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_ipsec_gre_tunnel_add_del_reply_t_handler
5088 (vl_api_ipsec_gre_tunnel_add_del_reply_t * mp)
5090 vat_main_t *vam = &vat_main;
5091 i32 retval = ntohl (mp->retval);
5092 if (vam->async_mode)
5094 vam->async_errors += (retval < 0);
5098 vam->retval = retval;
5099 vam->sw_if_index = ntohl (mp->sw_if_index);
5100 vam->result_ready = 1;
5102 vam->regenerate_interface_table = 1;
5105 static void vl_api_ipsec_gre_tunnel_add_del_reply_t_handler_json
5106 (vl_api_ipsec_gre_tunnel_add_del_reply_t * mp)
5108 vat_main_t *vam = &vat_main;
5109 vat_json_node_t node;
5111 vat_json_init_object (&node);
5112 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
5113 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
5115 vat_json_print (vam->ofp, &node);
5116 vat_json_free (&node);
5118 vam->retval = ntohl (mp->retval);
5119 vam->result_ready = 1;
5122 static void vl_api_flow_classify_details_t_handler
5123 (vl_api_flow_classify_details_t * mp)
5125 vat_main_t *vam = &vat_main;
5127 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
5128 ntohl (mp->table_index));
5131 static void vl_api_flow_classify_details_t_handler_json
5132 (vl_api_flow_classify_details_t * mp)
5134 vat_main_t *vam = &vat_main;
5135 vat_json_node_t *node;
5137 if (VAT_JSON_ARRAY != vam->json_tree.type)
5139 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5140 vat_json_init_array (&vam->json_tree);
5142 node = vat_json_array_add (&vam->json_tree);
5144 vat_json_init_object (node);
5145 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5146 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5149 #define vl_api_one_adjacencies_get_reply_t_endian vl_noop_handler
5150 #define vl_api_one_adjacencies_get_reply_t_print vl_noop_handler
5151 #define vl_api_one_l2_arp_bd_get_reply_t_print vl_noop_handler
5152 #define vl_api_one_l2_arp_entries_get_reply_t_endian vl_noop_handler
5153 #define vl_api_one_l2_arp_entries_get_reply_t_print vl_noop_handler
5154 #define vl_api_one_l2_arp_bd_get_reply_t_endian vl_noop_handler
5155 #define vl_api_one_ndp_bd_get_reply_t_endian vl_noop_handler
5156 #define vl_api_one_ndp_bd_get_reply_t_print vl_noop_handler
5157 #define vl_api_one_ndp_entries_get_reply_t_print vl_noop_handler
5158 #define vl_api_one_ndp_entries_get_reply_t_endian vl_noop_handler
5161 * Generate boilerplate reply handlers, which
5162 * dig the return value out of the xxx_reply_t API message,
5163 * stick it into vam->retval, and set vam->result_ready
5165 * Could also do this by pointing N message decode slots at
5166 * a single function, but that could break in subtle ways.
5169 #define foreach_standard_reply_retval_handler \
5170 _(sw_interface_set_flags_reply) \
5171 _(sw_interface_add_del_address_reply) \
5172 _(sw_interface_set_rx_mode_reply) \
5173 _(sw_interface_set_rx_placement_reply) \
5174 _(sw_interface_set_table_reply) \
5175 _(sw_interface_set_mpls_enable_reply) \
5176 _(sw_interface_set_vpath_reply) \
5177 _(sw_interface_set_vxlan_bypass_reply) \
5178 _(sw_interface_set_geneve_bypass_reply) \
5179 _(sw_interface_set_vxlan_gpe_bypass_reply) \
5180 _(sw_interface_set_l2_bridge_reply) \
5181 _(bridge_domain_add_del_reply) \
5182 _(sw_interface_set_l2_xconnect_reply) \
5183 _(l2fib_add_del_reply) \
5184 _(l2fib_flush_int_reply) \
5185 _(l2fib_flush_bd_reply) \
5186 _(ip_route_add_del_reply) \
5187 _(ip_table_add_del_reply) \
5188 _(ip_mroute_add_del_reply) \
5189 _(mpls_route_add_del_reply) \
5190 _(mpls_table_add_del_reply) \
5191 _(mpls_ip_bind_unbind_reply) \
5192 _(bier_route_add_del_reply) \
5193 _(bier_table_add_del_reply) \
5194 _(proxy_arp_add_del_reply) \
5195 _(proxy_arp_intfc_enable_disable_reply) \
5196 _(sw_interface_set_unnumbered_reply) \
5197 _(ip_neighbor_add_del_reply) \
5198 _(reset_fib_reply) \
5199 _(dhcp_proxy_config_reply) \
5200 _(dhcp_proxy_set_vss_reply) \
5201 _(dhcp_client_config_reply) \
5202 _(set_ip_flow_hash_reply) \
5203 _(sw_interface_ip6_enable_disable_reply) \
5204 _(ip6nd_proxy_add_del_reply) \
5205 _(sw_interface_ip6nd_ra_prefix_reply) \
5206 _(sw_interface_ip6nd_ra_config_reply) \
5207 _(set_arp_neighbor_limit_reply) \
5208 _(l2_patch_add_del_reply) \
5209 _(sr_mpls_policy_add_reply) \
5210 _(sr_mpls_policy_mod_reply) \
5211 _(sr_mpls_policy_del_reply) \
5212 _(sr_policy_add_reply) \
5213 _(sr_policy_mod_reply) \
5214 _(sr_policy_del_reply) \
5215 _(sr_localsid_add_del_reply) \
5216 _(sr_steering_add_del_reply) \
5217 _(classify_add_del_session_reply) \
5218 _(classify_set_interface_ip_table_reply) \
5219 _(classify_set_interface_l2_tables_reply) \
5220 _(l2tpv3_set_tunnel_cookies_reply) \
5221 _(l2tpv3_interface_enable_disable_reply) \
5222 _(l2tpv3_set_lookup_key_reply) \
5223 _(l2_fib_clear_table_reply) \
5224 _(l2_interface_efp_filter_reply) \
5225 _(l2_interface_vlan_tag_rewrite_reply) \
5226 _(modify_vhost_user_if_reply) \
5227 _(delete_vhost_user_if_reply) \
5228 _(ip_probe_neighbor_reply) \
5229 _(ip_scan_neighbor_enable_disable_reply) \
5230 _(want_ip4_arp_events_reply) \
5231 _(want_ip6_nd_events_reply) \
5232 _(want_l2_macs_events_reply) \
5233 _(input_acl_set_interface_reply) \
5234 _(ipsec_spd_add_del_reply) \
5235 _(ipsec_interface_add_del_spd_reply) \
5236 _(ipsec_spd_entry_add_del_reply) \
5237 _(ipsec_sad_entry_add_del_reply) \
5238 _(ipsec_tunnel_if_add_del_reply) \
5239 _(ipsec_tunnel_if_set_sa_reply) \
5240 _(delete_loopback_reply) \
5241 _(bd_ip_mac_add_del_reply) \
5242 _(bd_ip_mac_flush_reply) \
5243 _(want_interface_events_reply) \
5244 _(cop_interface_enable_disable_reply) \
5245 _(cop_whitelist_enable_disable_reply) \
5246 _(sw_interface_clear_stats_reply) \
5247 _(ioam_enable_reply) \
5248 _(ioam_disable_reply) \
5249 _(one_add_del_locator_reply) \
5250 _(one_add_del_local_eid_reply) \
5251 _(one_add_del_remote_mapping_reply) \
5252 _(one_add_del_adjacency_reply) \
5253 _(one_add_del_map_resolver_reply) \
5254 _(one_add_del_map_server_reply) \
5255 _(one_enable_disable_reply) \
5256 _(one_rloc_probe_enable_disable_reply) \
5257 _(one_map_register_enable_disable_reply) \
5258 _(one_map_register_set_ttl_reply) \
5259 _(one_set_transport_protocol_reply) \
5260 _(one_map_register_fallback_threshold_reply) \
5261 _(one_pitr_set_locator_set_reply) \
5262 _(one_map_request_mode_reply) \
5263 _(one_add_del_map_request_itr_rlocs_reply) \
5264 _(one_eid_table_add_del_map_reply) \
5265 _(one_use_petr_reply) \
5266 _(one_stats_enable_disable_reply) \
5267 _(one_add_del_l2_arp_entry_reply) \
5268 _(one_add_del_ndp_entry_reply) \
5269 _(one_stats_flush_reply) \
5270 _(one_enable_disable_xtr_mode_reply) \
5271 _(one_enable_disable_pitr_mode_reply) \
5272 _(one_enable_disable_petr_mode_reply) \
5273 _(gpe_enable_disable_reply) \
5274 _(gpe_set_encap_mode_reply) \
5275 _(gpe_add_del_iface_reply) \
5276 _(gpe_add_del_native_fwd_rpath_reply) \
5277 _(af_packet_delete_reply) \
5278 _(policer_classify_set_interface_reply) \
5279 _(netmap_create_reply) \
5280 _(netmap_delete_reply) \
5281 _(set_ipfix_exporter_reply) \
5282 _(set_ipfix_classify_stream_reply) \
5283 _(ipfix_classify_table_add_del_reply) \
5284 _(flow_classify_set_interface_reply) \
5285 _(sw_interface_span_enable_disable_reply) \
5286 _(pg_capture_reply) \
5287 _(pg_enable_disable_reply) \
5288 _(ip_source_and_port_range_check_add_del_reply) \
5289 _(ip_source_and_port_range_check_interface_add_del_reply)\
5290 _(delete_subif_reply) \
5291 _(l2_interface_pbb_tag_rewrite_reply) \
5293 _(feature_enable_disable_reply) \
5294 _(sw_interface_tag_add_del_reply) \
5295 _(hw_interface_set_mtu_reply) \
5296 _(p2p_ethernet_add_reply) \
5297 _(p2p_ethernet_del_reply) \
5298 _(lldp_config_reply) \
5299 _(sw_interface_set_lldp_reply) \
5300 _(tcp_configure_src_addresses_reply) \
5301 _(dns_enable_disable_reply) \
5302 _(dns_name_server_add_del_reply) \
5303 _(session_rule_add_del_reply) \
5304 _(ip_container_proxy_add_del_reply) \
5305 _(output_acl_set_interface_reply) \
5306 _(qos_record_enable_disable_reply)
5309 static void vl_api_##n##_t_handler \
5310 (vl_api_##n##_t * mp) \
5312 vat_main_t * vam = &vat_main; \
5313 i32 retval = ntohl(mp->retval); \
5314 if (vam->async_mode) { \
5315 vam->async_errors += (retval < 0); \
5317 vam->retval = retval; \
5318 vam->result_ready = 1; \
5321 foreach_standard_reply_retval_handler;
5325 static void vl_api_##n##_t_handler_json \
5326 (vl_api_##n##_t * mp) \
5328 vat_main_t * vam = &vat_main; \
5329 vat_json_node_t node; \
5330 vat_json_init_object(&node); \
5331 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
5332 vat_json_print(vam->ofp, &node); \
5333 vam->retval = ntohl(mp->retval); \
5334 vam->result_ready = 1; \
5336 foreach_standard_reply_retval_handler;
5340 * Table of message reply handlers, must include boilerplate handlers
5344 #define foreach_vpe_api_reply_msg \
5345 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
5346 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
5347 _(SW_INTERFACE_DETAILS, sw_interface_details) \
5348 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
5349 _(CONTROL_PING_REPLY, control_ping_reply) \
5350 _(CLI_REPLY, cli_reply) \
5351 _(CLI_INBAND_REPLY, cli_inband_reply) \
5352 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
5353 sw_interface_add_del_address_reply) \
5354 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
5355 _(SW_INTERFACE_SET_RX_PLACEMENT_REPLY, sw_interface_set_rx_placement_reply) \
5356 _(SW_INTERFACE_RX_PLACEMENT_DETAILS, sw_interface_rx_placement_details) \
5357 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
5358 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
5359 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
5360 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
5361 _(SW_INTERFACE_SET_GENEVE_BYPASS_REPLY, sw_interface_set_geneve_bypass_reply) \
5362 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
5363 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
5364 sw_interface_set_l2_xconnect_reply) \
5365 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
5366 sw_interface_set_l2_bridge_reply) \
5367 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
5368 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
5369 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
5370 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
5371 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
5372 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
5373 _(L2_FLAGS_REPLY, l2_flags_reply) \
5374 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
5375 _(TAP_CREATE_V2_REPLY, tap_create_v2_reply) \
5376 _(TAP_DELETE_V2_REPLY, tap_delete_v2_reply) \
5377 _(SW_INTERFACE_TAP_V2_DETAILS, sw_interface_tap_v2_details) \
5378 _(VIRTIO_PCI_CREATE_REPLY, virtio_pci_create_reply) \
5379 _(VIRTIO_PCI_DELETE_REPLY, virtio_pci_delete_reply) \
5380 _(SW_INTERFACE_VIRTIO_PCI_DETAILS, sw_interface_virtio_pci_details) \
5381 _(BOND_CREATE_REPLY, bond_create_reply) \
5382 _(BOND_DELETE_REPLY, bond_delete_reply) \
5383 _(BOND_ENSLAVE_REPLY, bond_enslave_reply) \
5384 _(BOND_DETACH_SLAVE_REPLY, bond_detach_slave_reply) \
5385 _(SW_INTERFACE_BOND_DETAILS, sw_interface_bond_details) \
5386 _(SW_INTERFACE_SLAVE_DETAILS, sw_interface_slave_details) \
5387 _(IP_ROUTE_ADD_DEL_REPLY, ip_route_add_del_reply) \
5388 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
5389 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
5390 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
5391 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
5392 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
5393 _(BIER_ROUTE_ADD_DEL_REPLY, bier_route_add_del_reply) \
5394 _(BIER_TABLE_ADD_DEL_REPLY, bier_table_add_del_reply) \
5395 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
5396 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
5397 proxy_arp_intfc_enable_disable_reply) \
5398 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
5399 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
5400 sw_interface_set_unnumbered_reply) \
5401 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
5402 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
5403 _(CREATE_SUBIF_REPLY, create_subif_reply) \
5404 _(RESET_FIB_REPLY, reset_fib_reply) \
5405 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
5406 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
5407 _(DHCP_PROXY_DETAILS, dhcp_proxy_details) \
5408 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
5409 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
5410 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
5411 sw_interface_ip6_enable_disable_reply) \
5412 _(IP6ND_PROXY_ADD_DEL_REPLY, ip6nd_proxy_add_del_reply) \
5413 _(IP6ND_PROXY_DETAILS, ip6nd_proxy_details) \
5414 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
5415 sw_interface_ip6nd_ra_prefix_reply) \
5416 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
5417 sw_interface_ip6nd_ra_config_reply) \
5418 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
5419 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
5420 _(SR_MPLS_POLICY_ADD_REPLY, sr_mpls_policy_add_reply) \
5421 _(SR_MPLS_POLICY_MOD_REPLY, sr_mpls_policy_mod_reply) \
5422 _(SR_MPLS_POLICY_DEL_REPLY, sr_mpls_policy_del_reply) \
5423 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
5424 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
5425 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
5426 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
5427 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
5428 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
5429 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
5430 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
5431 classify_set_interface_ip_table_reply) \
5432 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
5433 classify_set_interface_l2_tables_reply) \
5434 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
5435 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
5436 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
5437 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
5438 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
5439 l2tpv3_interface_enable_disable_reply) \
5440 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
5441 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
5442 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
5443 _(VXLAN_OFFLOAD_RX_REPLY, vxlan_offload_rx_reply) \
5444 _(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
5445 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
5446 _(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
5447 _(GRE_TUNNEL_ADD_DEL_REPLY, gre_tunnel_add_del_reply) \
5448 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
5449 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
5450 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
5451 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
5452 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
5453 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
5454 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
5455 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
5456 _(SHOW_VERSION_REPLY, show_version_reply) \
5457 _(SHOW_THREADS_REPLY, show_threads_reply) \
5458 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
5459 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
5460 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
5461 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
5462 _(IP_PROBE_NEIGHBOR_REPLY, ip_probe_neighbor_reply) \
5463 _(IP_SCAN_NEIGHBOR_ENABLE_DISABLE_REPLY, ip_scan_neighbor_enable_disable_reply) \
5464 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
5465 _(IP4_ARP_EVENT, ip4_arp_event) \
5466 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
5467 _(IP6_ND_EVENT, ip6_nd_event) \
5468 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
5469 _(L2_MACS_EVENT, l2_macs_event) \
5470 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
5471 _(IP_ADDRESS_DETAILS, ip_address_details) \
5472 _(IP_DETAILS, ip_details) \
5473 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
5474 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
5475 _(IPSEC_SPD_ENTRY_ADD_DEL_REPLY, ipsec_spd_entry_add_del_reply) \
5476 _(IPSEC_SAD_ENTRY_ADD_DEL_REPLY, ipsec_sad_entry_add_del_reply) \
5477 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
5478 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
5479 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
5480 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
5481 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
5482 _(BD_IP_MAC_FLUSH_REPLY, bd_ip_mac_flush_reply) \
5483 _(BD_IP_MAC_DETAILS, bd_ip_mac_details) \
5484 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
5485 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
5486 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
5487 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
5488 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
5489 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
5490 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
5491 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
5492 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
5493 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
5494 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
5495 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
5496 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
5497 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
5498 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
5499 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
5500 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
5501 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
5502 one_map_register_enable_disable_reply) \
5503 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
5504 _(ONE_SET_TRANSPORT_PROTOCOL_REPLY, one_set_transport_protocol_reply) \
5505 _(ONE_GET_TRANSPORT_PROTOCOL_REPLY, one_get_transport_protocol_reply) \
5506 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5507 one_map_register_fallback_threshold_reply) \
5508 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
5509 one_rloc_probe_enable_disable_reply) \
5510 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
5511 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
5512 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
5513 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
5514 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
5515 _(ONE_LOCATOR_DETAILS, one_locator_details) \
5516 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
5517 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
5518 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
5519 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
5520 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
5521 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
5522 _(ONE_STATS_DETAILS, one_stats_details) \
5523 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
5524 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
5525 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
5526 show_one_stats_enable_disable_reply) \
5527 _(ONE_ADD_DEL_NDP_ENTRY_REPLY, one_add_del_ndp_entry_reply) \
5528 _(ONE_NDP_BD_GET_REPLY, one_ndp_bd_get_reply) \
5529 _(ONE_NDP_ENTRIES_GET_REPLY, one_ndp_entries_get_reply) \
5530 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
5531 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
5532 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
5533 _(ONE_ENABLE_DISABLE_XTR_MODE_REPLY, one_enable_disable_xtr_mode_reply) \
5534 _(ONE_ENABLE_DISABLE_PITR_MODE_REPLY, \
5535 one_enable_disable_pitr_mode_reply) \
5536 _(ONE_ENABLE_DISABLE_PETR_MODE_REPLY, \
5537 one_enable_disable_petr_mode_reply) \
5538 _(ONE_SHOW_XTR_MODE_REPLY, one_show_xtr_mode_reply) \
5539 _(ONE_SHOW_PITR_MODE_REPLY, one_show_pitr_mode_reply) \
5540 _(ONE_SHOW_PETR_MODE_REPLY, one_show_petr_mode_reply) \
5541 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
5542 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
5543 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
5544 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
5545 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
5546 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
5547 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
5548 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
5549 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
5550 gpe_add_del_native_fwd_rpath_reply) \
5551 _(GPE_FWD_ENTRY_PATH_DETAILS, \
5552 gpe_fwd_entry_path_details) \
5553 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
5554 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
5555 one_add_del_map_request_itr_rlocs_reply) \
5556 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
5557 one_get_map_request_itr_rlocs_reply) \
5558 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
5559 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
5560 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
5561 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
5562 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
5563 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
5564 show_one_map_register_state_reply) \
5565 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
5566 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5567 show_one_map_register_fallback_threshold_reply) \
5568 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
5569 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
5570 _(AF_PACKET_DETAILS, af_packet_details) \
5571 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
5572 _(POLICER_DETAILS, policer_details) \
5573 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
5574 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
5575 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
5576 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
5577 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
5578 _(MPLS_TABLE_DETAILS, mpls_table_details) \
5579 _(MPLS_ROUTE_DETAILS, mpls_route_details) \
5580 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
5581 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
5582 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
5583 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
5584 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
5585 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
5586 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
5587 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5588 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5589 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5590 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5591 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5592 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5593 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5594 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5595 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5596 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5597 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5598 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5599 ip_source_and_port_range_check_add_del_reply) \
5600 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5601 ip_source_and_port_range_check_interface_add_del_reply) \
5602 _(IPSEC_GRE_TUNNEL_ADD_DEL_REPLY, ipsec_gre_tunnel_add_del_reply) \
5603 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
5604 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5605 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5606 _(SET_PUNT_REPLY, set_punt_reply) \
5607 _(IP_TABLE_DETAILS, ip_table_details) \
5608 _(IP_ROUTE_DETAILS, ip_route_details) \
5609 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5610 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5611 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5612 _(HW_INTERFACE_SET_MTU_REPLY, hw_interface_set_mtu_reply) \
5613 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
5614 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5615 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5616 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5617 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5618 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply) \
5619 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
5620 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
5621 _(DNS_ENABLE_DISABLE_REPLY, dns_enable_disable_reply) \
5622 _(DNS_NAME_SERVER_ADD_DEL_REPLY, dns_name_server_add_del_reply) \
5623 _(DNS_RESOLVE_NAME_REPLY, dns_resolve_name_reply) \
5624 _(DNS_RESOLVE_IP_REPLY, dns_resolve_ip_reply) \
5625 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
5626 _(SESSION_RULES_DETAILS, session_rules_details) \
5627 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
5628 _(OUTPUT_ACL_SET_INTERFACE_REPLY, output_acl_set_interface_reply) \
5629 _(QOS_RECORD_ENABLE_DISABLE_REPLY, qos_record_enable_disable_reply)
5631 #define foreach_standalone_reply_msg \
5632 _(SW_INTERFACE_EVENT, sw_interface_event)
5640 #define STR_VTR_OP_CASE(op) \
5641 case L2_VTR_ ## op: \
5645 str_vtr_op (u32 vtr_op)
5649 STR_VTR_OP_CASE (DISABLED);
5650 STR_VTR_OP_CASE (PUSH_1);
5651 STR_VTR_OP_CASE (PUSH_2);
5652 STR_VTR_OP_CASE (POP_1);
5653 STR_VTR_OP_CASE (POP_2);
5654 STR_VTR_OP_CASE (TRANSLATE_1_1);
5655 STR_VTR_OP_CASE (TRANSLATE_1_2);
5656 STR_VTR_OP_CASE (TRANSLATE_2_1);
5657 STR_VTR_OP_CASE (TRANSLATE_2_2);
5664 dump_sub_interface_table (vat_main_t * vam)
5666 const sw_interface_subif_t *sub = NULL;
5668 if (vam->json_output)
5671 ("JSON output supported only for VPE API calls and dump_stats_table");
5676 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5677 "Interface", "sw_if_index",
5678 "sub id", "dot1ad", "tags", "outer id",
5679 "inner id", "exact", "default", "outer any", "inner any");
5681 vec_foreach (sub, vam->sw_if_subif_table)
5684 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5685 sub->interface_name,
5687 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5688 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5689 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5690 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5691 if (sub->vtr_op != L2_VTR_DISABLED)
5694 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
5695 "tag1: %d tag2: %d ]",
5696 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
5697 sub->vtr_tag1, sub->vtr_tag2);
5705 name_sort_cmp (void *a1, void *a2)
5707 name_sort_t *n1 = a1;
5708 name_sort_t *n2 = a2;
5710 return strcmp ((char *) n1->name, (char *) n2->name);
5714 dump_interface_table (vat_main_t * vam)
5717 name_sort_t *nses = 0, *ns;
5719 if (vam->json_output)
5722 ("JSON output supported only for VPE API calls and dump_stats_table");
5727 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5729 vec_add2 (nses, ns, 1);
5730 ns->name = (u8 *)(p->key);
5731 ns->value = (u32) p->value[0];
5735 vec_sort_with_function (nses, name_sort_cmp);
5737 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
5738 vec_foreach (ns, nses)
5740 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
5747 dump_ip_table (vat_main_t * vam, int is_ipv6)
5749 const ip_details_t *det = NULL;
5750 const ip_address_details_t *address = NULL;
5753 print (vam->ofp, "%-12s", "sw_if_index");
5755 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
5762 print (vam->ofp, "%-12d", i);
5763 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
5768 vec_foreach (address, det->addr)
5772 is_ipv6 ? format_ip6_address : format_ip4_address,
5773 address->ip, address->prefix_length);
5781 dump_ipv4_table (vat_main_t * vam)
5783 if (vam->json_output)
5786 ("JSON output supported only for VPE API calls and dump_stats_table");
5790 return dump_ip_table (vam, 0);
5794 dump_ipv6_table (vat_main_t * vam)
5796 if (vam->json_output)
5799 ("JSON output supported only for VPE API calls and dump_stats_table");
5803 return dump_ip_table (vam, 1);
5807 * Pass CLI buffers directly in the CLI_INBAND API message,
5808 * instead of an additional shared memory area.
5811 exec_inband (vat_main_t * vam)
5813 vl_api_cli_inband_t *mp;
5814 unformat_input_t *i = vam->input;
5817 if (vec_len (i->buffer) == 0)
5820 if (vam->exec_mode == 0 && unformat (i, "mode"))
5825 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
5832 * In order for the CLI command to work, it
5833 * must be a vector ending in \n, not a C-string ending
5836 u32 len = vec_len (vam->input->buffer);
5837 M2 (CLI_INBAND, mp, len);
5838 vl_api_to_api_string (len - 1, (const char *) vam->input->buffer, &mp->cmd);
5842 /* json responses may or may not include a useful reply... */
5843 if (vec_len (vam->cmd_reply))
5844 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
5849 exec (vat_main_t * vam)
5851 return exec_inband (vam);
5855 api_create_loopback (vat_main_t * vam)
5857 unformat_input_t *i = vam->input;
5858 vl_api_create_loopback_t *mp;
5859 vl_api_create_loopback_instance_t *mp_lbi;
5862 u8 is_specified = 0;
5863 u32 user_instance = 0;
5866 clib_memset (mac_address, 0, sizeof (mac_address));
5868 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5870 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5872 if (unformat (i, "instance %d", &user_instance))
5880 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
5881 mp_lbi->is_specified = is_specified;
5883 mp_lbi->user_instance = htonl (user_instance);
5885 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
5890 /* Construct the API message */
5891 M (CREATE_LOOPBACK, mp);
5893 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
5902 api_delete_loopback (vat_main_t * vam)
5904 unformat_input_t *i = vam->input;
5905 vl_api_delete_loopback_t *mp;
5906 u32 sw_if_index = ~0;
5909 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5911 if (unformat (i, "sw_if_index %d", &sw_if_index))
5917 if (sw_if_index == ~0)
5919 errmsg ("missing sw_if_index");
5923 /* Construct the API message */
5924 M (DELETE_LOOPBACK, mp);
5925 mp->sw_if_index = ntohl (sw_if_index);
5933 api_want_interface_events (vat_main_t * vam)
5935 unformat_input_t *i = vam->input;
5936 vl_api_want_interface_events_t *mp;
5940 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5942 if (unformat (i, "enable"))
5944 else if (unformat (i, "disable"))
5952 errmsg ("missing enable|disable");
5956 M (WANT_INTERFACE_EVENTS, mp);
5957 mp->enable_disable = enable;
5959 vam->interface_event_display = enable;
5967 /* Note: non-static, called once to set up the initial intfc table */
5969 api_sw_interface_dump (vat_main_t * vam)
5971 vl_api_sw_interface_dump_t *mp;
5972 vl_api_control_ping_t *mp_ping;
5974 name_sort_t *nses = 0, *ns;
5975 sw_interface_subif_t *sub = NULL;
5978 /* Toss the old name table */
5980 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5982 vec_add2 (nses, ns, 1);
5983 ns->name = (u8 *)(p->key);
5984 ns->value = (u32) p->value[0];
5988 hash_free (vam->sw_if_index_by_interface_name);
5990 vec_foreach (ns, nses) vec_free (ns->name);
5994 vec_foreach (sub, vam->sw_if_subif_table)
5996 vec_free (sub->interface_name);
5998 vec_free (vam->sw_if_subif_table);
6000 /* recreate the interface name hash table */
6001 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
6004 * Ask for all interface names. Otherwise, the epic catalog of
6005 * name filters becomes ridiculously long, and vat ends up needing
6006 * to be taught about new interface types.
6008 M (SW_INTERFACE_DUMP, mp);
6011 /* Use a control ping for synchronization */
6012 MPING (CONTROL_PING, mp_ping);
6020 api_sw_interface_set_flags (vat_main_t * vam)
6022 unformat_input_t *i = vam->input;
6023 vl_api_sw_interface_set_flags_t *mp;
6025 u8 sw_if_index_set = 0;
6029 /* Parse args required to build the message */
6030 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6032 if (unformat (i, "admin-up"))
6034 else if (unformat (i, "admin-down"))
6037 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6038 sw_if_index_set = 1;
6039 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6040 sw_if_index_set = 1;
6045 if (sw_if_index_set == 0)
6047 errmsg ("missing interface name or sw_if_index");
6051 /* Construct the API message */
6052 M (SW_INTERFACE_SET_FLAGS, mp);
6053 mp->sw_if_index = ntohl (sw_if_index);
6054 mp->admin_up_down = admin_up;
6059 /* Wait for a reply, return the good/bad news... */
6065 api_sw_interface_set_rx_mode (vat_main_t * vam)
6067 unformat_input_t *i = vam->input;
6068 vl_api_sw_interface_set_rx_mode_t *mp;
6070 u8 sw_if_index_set = 0;
6072 u8 queue_id_valid = 0;
6074 vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN;
6076 /* Parse args required to build the message */
6077 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6079 if (unformat (i, "queue %d", &queue_id))
6081 else if (unformat (i, "polling"))
6082 mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
6083 else if (unformat (i, "interrupt"))
6084 mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT;
6085 else if (unformat (i, "adaptive"))
6086 mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE;
6088 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6089 sw_if_index_set = 1;
6090 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6091 sw_if_index_set = 1;
6096 if (sw_if_index_set == 0)
6098 errmsg ("missing interface name or sw_if_index");
6101 if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
6103 errmsg ("missing rx-mode");
6107 /* Construct the API message */
6108 M (SW_INTERFACE_SET_RX_MODE, mp);
6109 mp->sw_if_index = ntohl (sw_if_index);
6111 mp->queue_id_valid = queue_id_valid;
6112 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
6117 /* Wait for a reply, return the good/bad news... */
6123 api_sw_interface_set_rx_placement (vat_main_t * vam)
6125 unformat_input_t *i = vam->input;
6126 vl_api_sw_interface_set_rx_placement_t *mp;
6128 u8 sw_if_index_set = 0;
6131 u32 queue_id, thread_index;
6133 /* Parse args required to build the message */
6134 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6136 if (unformat (i, "queue %d", &queue_id))
6138 else if (unformat (i, "main"))
6140 else if (unformat (i, "worker %d", &thread_index))
6143 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6144 sw_if_index_set = 1;
6145 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6146 sw_if_index_set = 1;
6151 if (sw_if_index_set == 0)
6153 errmsg ("missing interface name or sw_if_index");
6159 /* Construct the API message */
6160 M (SW_INTERFACE_SET_RX_PLACEMENT, mp);
6161 mp->sw_if_index = ntohl (sw_if_index);
6162 mp->worker_id = ntohl (thread_index);
6163 mp->queue_id = ntohl (queue_id);
6164 mp->is_main = is_main;
6168 /* Wait for a reply, return the good/bad news... */
6173 static void vl_api_sw_interface_rx_placement_details_t_handler
6174 (vl_api_sw_interface_rx_placement_details_t * mp)
6176 vat_main_t *vam = &vat_main;
6177 u32 worker_id = ntohl (mp->worker_id);
6180 "\n%-11d %-11s %-6d %-5d %-9s",
6181 ntohl (mp->sw_if_index), (worker_id == 0) ? "main" : "worker",
6182 worker_id, ntohl (mp->queue_id),
6184 1) ? "polling" : ((mp->mode == 2) ? "interrupt" : "adaptive"));
6187 static void vl_api_sw_interface_rx_placement_details_t_handler_json
6188 (vl_api_sw_interface_rx_placement_details_t * mp)
6190 vat_main_t *vam = &vat_main;
6191 vat_json_node_t *node = NULL;
6193 if (VAT_JSON_ARRAY != vam->json_tree.type)
6195 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
6196 vat_json_init_array (&vam->json_tree);
6198 node = vat_json_array_add (&vam->json_tree);
6200 vat_json_init_object (node);
6201 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
6202 vat_json_object_add_uint (node, "worker_id", ntohl (mp->worker_id));
6203 vat_json_object_add_uint (node, "queue_id", ntohl (mp->queue_id));
6204 vat_json_object_add_uint (node, "mode", mp->mode);
6208 api_sw_interface_rx_placement_dump (vat_main_t * vam)
6210 unformat_input_t *i = vam->input;
6211 vl_api_sw_interface_rx_placement_dump_t *mp;
6212 vl_api_control_ping_t *mp_ping;
6215 u8 sw_if_index_set = 0;
6217 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6219 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6221 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6228 "\n%-11s %-11s %-6s %-5s %-4s",
6229 "sw_if_index", "main/worker", "thread", "queue", "mode");
6231 /* Dump Interface rx placement */
6232 M (SW_INTERFACE_RX_PLACEMENT_DUMP, mp);
6234 if (sw_if_index_set)
6235 mp->sw_if_index = htonl (sw_if_index);
6237 mp->sw_if_index = ~0;
6241 /* Use a control ping for synchronization */
6242 MPING (CONTROL_PING, mp_ping);
6250 api_sw_interface_clear_stats (vat_main_t * vam)
6252 unformat_input_t *i = vam->input;
6253 vl_api_sw_interface_clear_stats_t *mp;
6255 u8 sw_if_index_set = 0;
6258 /* Parse args required to build the message */
6259 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6261 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6262 sw_if_index_set = 1;
6263 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6264 sw_if_index_set = 1;
6269 /* Construct the API message */
6270 M (SW_INTERFACE_CLEAR_STATS, mp);
6272 if (sw_if_index_set == 1)
6273 mp->sw_if_index = ntohl (sw_if_index);
6275 mp->sw_if_index = ~0;
6280 /* Wait for a reply, return the good/bad news... */
6286 api_sw_interface_add_del_address (vat_main_t * vam)
6288 unformat_input_t *i = vam->input;
6289 vl_api_sw_interface_add_del_address_t *mp;
6291 u8 sw_if_index_set = 0;
6292 u8 is_add = 1, del_all = 0;
6293 u32 address_length = 0;
6294 u8 v4_address_set = 0;
6295 u8 v6_address_set = 0;
6296 ip4_address_t v4address;
6297 ip6_address_t v6address;
6300 /* Parse args required to build the message */
6301 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6303 if (unformat (i, "del-all"))
6305 else if (unformat (i, "del"))
6308 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6309 sw_if_index_set = 1;
6310 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6311 sw_if_index_set = 1;
6312 else if (unformat (i, "%U/%d",
6313 unformat_ip4_address, &v4address, &address_length))
6315 else if (unformat (i, "%U/%d",
6316 unformat_ip6_address, &v6address, &address_length))
6322 if (sw_if_index_set == 0)
6324 errmsg ("missing interface name or sw_if_index");
6327 if (v4_address_set && v6_address_set)
6329 errmsg ("both v4 and v6 addresses set");
6332 if (!v4_address_set && !v6_address_set && !del_all)
6334 errmsg ("no addresses set");
6338 /* Construct the API message */
6339 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
6341 mp->sw_if_index = ntohl (sw_if_index);
6342 mp->is_add = is_add;
6343 mp->del_all = del_all;
6347 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6351 clib_memcpy (mp->address, &v4address, sizeof (v4address));
6353 mp->address_length = address_length;
6358 /* Wait for a reply, return good/bad news */
6364 api_sw_interface_set_mpls_enable (vat_main_t * vam)
6366 unformat_input_t *i = vam->input;
6367 vl_api_sw_interface_set_mpls_enable_t *mp;
6369 u8 sw_if_index_set = 0;
6373 /* Parse args required to build the message */
6374 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6376 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6377 sw_if_index_set = 1;
6378 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6379 sw_if_index_set = 1;
6380 else if (unformat (i, "disable"))
6382 else if (unformat (i, "dis"))
6388 if (sw_if_index_set == 0)
6390 errmsg ("missing interface name or sw_if_index");
6394 /* Construct the API message */
6395 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
6397 mp->sw_if_index = ntohl (sw_if_index);
6398 mp->enable = enable;
6403 /* Wait for a reply... */
6409 api_sw_interface_set_table (vat_main_t * vam)
6411 unformat_input_t *i = vam->input;
6412 vl_api_sw_interface_set_table_t *mp;
6413 u32 sw_if_index, vrf_id = 0;
6414 u8 sw_if_index_set = 0;
6418 /* Parse args required to build the message */
6419 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6421 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6422 sw_if_index_set = 1;
6423 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6424 sw_if_index_set = 1;
6425 else if (unformat (i, "vrf %d", &vrf_id))
6427 else if (unformat (i, "ipv6"))
6433 if (sw_if_index_set == 0)
6435 errmsg ("missing interface name or sw_if_index");
6439 /* Construct the API message */
6440 M (SW_INTERFACE_SET_TABLE, mp);
6442 mp->sw_if_index = ntohl (sw_if_index);
6443 mp->is_ipv6 = is_ipv6;
6444 mp->vrf_id = ntohl (vrf_id);
6449 /* Wait for a reply... */
6454 static void vl_api_sw_interface_get_table_reply_t_handler
6455 (vl_api_sw_interface_get_table_reply_t * mp)
6457 vat_main_t *vam = &vat_main;
6459 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6461 vam->retval = ntohl (mp->retval);
6462 vam->result_ready = 1;
6466 static void vl_api_sw_interface_get_table_reply_t_handler_json
6467 (vl_api_sw_interface_get_table_reply_t * mp)
6469 vat_main_t *vam = &vat_main;
6470 vat_json_node_t node;
6472 vat_json_init_object (&node);
6473 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6474 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6476 vat_json_print (vam->ofp, &node);
6477 vat_json_free (&node);
6479 vam->retval = ntohl (mp->retval);
6480 vam->result_ready = 1;
6484 api_sw_interface_get_table (vat_main_t * vam)
6486 unformat_input_t *i = vam->input;
6487 vl_api_sw_interface_get_table_t *mp;
6489 u8 sw_if_index_set = 0;
6493 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6495 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6496 sw_if_index_set = 1;
6497 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6498 sw_if_index_set = 1;
6499 else if (unformat (i, "ipv6"))
6505 if (sw_if_index_set == 0)
6507 errmsg ("missing interface name or sw_if_index");
6511 M (SW_INTERFACE_GET_TABLE, mp);
6512 mp->sw_if_index = htonl (sw_if_index);
6513 mp->is_ipv6 = is_ipv6;
6521 api_sw_interface_set_vpath (vat_main_t * vam)
6523 unformat_input_t *i = vam->input;
6524 vl_api_sw_interface_set_vpath_t *mp;
6525 u32 sw_if_index = 0;
6526 u8 sw_if_index_set = 0;
6530 /* Parse args required to build the message */
6531 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6533 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6534 sw_if_index_set = 1;
6535 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6536 sw_if_index_set = 1;
6537 else if (unformat (i, "enable"))
6539 else if (unformat (i, "disable"))
6545 if (sw_if_index_set == 0)
6547 errmsg ("missing interface name or sw_if_index");
6551 /* Construct the API message */
6552 M (SW_INTERFACE_SET_VPATH, mp);
6554 mp->sw_if_index = ntohl (sw_if_index);
6555 mp->enable = is_enable;
6560 /* Wait for a reply... */
6566 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
6568 unformat_input_t *i = vam->input;
6569 vl_api_sw_interface_set_vxlan_bypass_t *mp;
6570 u32 sw_if_index = 0;
6571 u8 sw_if_index_set = 0;
6576 /* Parse args required to build the message */
6577 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6579 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6580 sw_if_index_set = 1;
6581 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6582 sw_if_index_set = 1;
6583 else if (unformat (i, "enable"))
6585 else if (unformat (i, "disable"))
6587 else if (unformat (i, "ip4"))
6589 else if (unformat (i, "ip6"))
6595 if (sw_if_index_set == 0)
6597 errmsg ("missing interface name or sw_if_index");
6601 /* Construct the API message */
6602 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
6604 mp->sw_if_index = ntohl (sw_if_index);
6605 mp->enable = is_enable;
6606 mp->is_ipv6 = is_ipv6;
6611 /* Wait for a reply... */
6617 api_sw_interface_set_geneve_bypass (vat_main_t * vam)
6619 unformat_input_t *i = vam->input;
6620 vl_api_sw_interface_set_geneve_bypass_t *mp;
6621 u32 sw_if_index = 0;
6622 u8 sw_if_index_set = 0;
6627 /* Parse args required to build the message */
6628 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6630 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6631 sw_if_index_set = 1;
6632 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6633 sw_if_index_set = 1;
6634 else if (unformat (i, "enable"))
6636 else if (unformat (i, "disable"))
6638 else if (unformat (i, "ip4"))
6640 else if (unformat (i, "ip6"))
6646 if (sw_if_index_set == 0)
6648 errmsg ("missing interface name or sw_if_index");
6652 /* Construct the API message */
6653 M (SW_INTERFACE_SET_GENEVE_BYPASS, mp);
6655 mp->sw_if_index = ntohl (sw_if_index);
6656 mp->enable = is_enable;
6657 mp->is_ipv6 = is_ipv6;
6662 /* Wait for a reply... */
6668 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
6670 unformat_input_t *i = vam->input;
6671 vl_api_sw_interface_set_l2_xconnect_t *mp;
6673 u8 rx_sw_if_index_set = 0;
6675 u8 tx_sw_if_index_set = 0;
6679 /* Parse args required to build the message */
6680 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6682 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6683 rx_sw_if_index_set = 1;
6684 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6685 tx_sw_if_index_set = 1;
6686 else if (unformat (i, "rx"))
6688 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6690 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6692 rx_sw_if_index_set = 1;
6697 else if (unformat (i, "tx"))
6699 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6701 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6703 tx_sw_if_index_set = 1;
6708 else if (unformat (i, "enable"))
6710 else if (unformat (i, "disable"))
6716 if (rx_sw_if_index_set == 0)
6718 errmsg ("missing rx interface name or rx_sw_if_index");
6722 if (enable && (tx_sw_if_index_set == 0))
6724 errmsg ("missing tx interface name or tx_sw_if_index");
6728 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
6730 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6731 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6732 mp->enable = enable;
6740 api_sw_interface_set_l2_bridge (vat_main_t * vam)
6742 unformat_input_t *i = vam->input;
6743 vl_api_sw_interface_set_l2_bridge_t *mp;
6744 vl_api_l2_port_type_t port_type;
6746 u8 rx_sw_if_index_set = 0;
6753 port_type = L2_API_PORT_TYPE_NORMAL;
6755 /* Parse args required to build the message */
6756 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6758 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
6759 rx_sw_if_index_set = 1;
6760 else if (unformat (i, "bd_id %d", &bd_id))
6764 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
6765 rx_sw_if_index_set = 1;
6766 else if (unformat (i, "shg %d", &shg))
6768 else if (unformat (i, "bvi"))
6769 port_type = L2_API_PORT_TYPE_BVI;
6770 else if (unformat (i, "uu-fwd"))
6771 port_type = L2_API_PORT_TYPE_UU_FWD;
6772 else if (unformat (i, "enable"))
6774 else if (unformat (i, "disable"))
6780 if (rx_sw_if_index_set == 0)
6782 errmsg ("missing rx interface name or sw_if_index");
6786 if (enable && (bd_id_set == 0))
6788 errmsg ("missing bridge domain");
6792 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
6794 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6795 mp->bd_id = ntohl (bd_id);
6797 mp->port_type = ntohl (port_type);
6798 mp->enable = enable;
6806 api_bridge_domain_dump (vat_main_t * vam)
6808 unformat_input_t *i = vam->input;
6809 vl_api_bridge_domain_dump_t *mp;
6810 vl_api_control_ping_t *mp_ping;
6814 /* Parse args required to build the message */
6815 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6817 if (unformat (i, "bd_id %d", &bd_id))
6823 M (BRIDGE_DOMAIN_DUMP, mp);
6824 mp->bd_id = ntohl (bd_id);
6827 /* Use a control ping for synchronization */
6828 MPING (CONTROL_PING, mp_ping);
6836 api_bridge_domain_add_del (vat_main_t * vam)
6838 unformat_input_t *i = vam->input;
6839 vl_api_bridge_domain_add_del_t *mp;
6842 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
6847 /* Parse args required to build the message */
6848 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6850 if (unformat (i, "bd_id %d", &bd_id))
6852 else if (unformat (i, "flood %d", &flood))
6854 else if (unformat (i, "uu-flood %d", &uu_flood))
6856 else if (unformat (i, "forward %d", &forward))
6858 else if (unformat (i, "learn %d", &learn))
6860 else if (unformat (i, "arp-term %d", &arp_term))
6862 else if (unformat (i, "mac-age %d", &mac_age))
6864 else if (unformat (i, "bd-tag %s", &bd_tag))
6866 else if (unformat (i, "del"))
6869 flood = uu_flood = forward = learn = 0;
6877 errmsg ("missing bridge domain");
6884 errmsg ("mac age must be less than 256 ");
6889 if ((bd_tag) && (vec_len (bd_tag) > 63))
6891 errmsg ("bd-tag cannot be longer than 63");
6896 M (BRIDGE_DOMAIN_ADD_DEL, mp);
6898 mp->bd_id = ntohl (bd_id);
6900 mp->uu_flood = uu_flood;
6901 mp->forward = forward;
6903 mp->arp_term = arp_term;
6904 mp->is_add = is_add;
6905 mp->mac_age = (u8) mac_age;
6908 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
6909 mp->bd_tag[vec_len (bd_tag)] = 0;
6920 api_l2fib_flush_bd (vat_main_t * vam)
6922 unformat_input_t *i = vam->input;
6923 vl_api_l2fib_flush_bd_t *mp;
6927 /* Parse args required to build the message */
6928 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6930 if (unformat (i, "bd_id %d", &bd_id));
6937 errmsg ("missing bridge domain");
6941 M (L2FIB_FLUSH_BD, mp);
6943 mp->bd_id = htonl (bd_id);
6951 api_l2fib_flush_int (vat_main_t * vam)
6953 unformat_input_t *i = vam->input;
6954 vl_api_l2fib_flush_int_t *mp;
6955 u32 sw_if_index = ~0;
6958 /* Parse args required to build the message */
6959 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6961 if (unformat (i, "sw_if_index %d", &sw_if_index));
6963 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
6968 if (sw_if_index == ~0)
6970 errmsg ("missing interface name or sw_if_index");
6974 M (L2FIB_FLUSH_INT, mp);
6976 mp->sw_if_index = ntohl (sw_if_index);
6984 api_l2fib_add_del (vat_main_t * vam)
6986 unformat_input_t *i = vam->input;
6987 vl_api_l2fib_add_del_t *mp;
6993 u32 sw_if_index = 0;
6994 u8 sw_if_index_set = 0;
7003 /* Parse args required to build the message */
7004 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7006 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
7008 else if (unformat (i, "bd_id %d", &bd_id))
7010 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7011 sw_if_index_set = 1;
7012 else if (unformat (i, "sw_if"))
7014 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7017 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7018 sw_if_index_set = 1;
7023 else if (unformat (i, "static"))
7025 else if (unformat (i, "filter"))
7030 else if (unformat (i, "bvi"))
7035 else if (unformat (i, "del"))
7037 else if (unformat (i, "count %d", &count))
7045 errmsg ("missing mac address");
7051 errmsg ("missing bridge domain");
7055 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
7057 errmsg ("missing interface name or sw_if_index");
7063 /* Turn on async mode */
7064 vam->async_mode = 1;
7065 vam->async_errors = 0;
7066 before = vat_time_now (vam);
7069 for (j = 0; j < count; j++)
7071 M (L2FIB_ADD_DEL, mp);
7073 clib_memcpy (mp->mac, mac, 6);
7074 mp->bd_id = ntohl (bd_id);
7075 mp->is_add = is_add;
7076 mp->sw_if_index = ntohl (sw_if_index);
7080 mp->static_mac = static_mac;
7081 mp->filter_mac = filter_mac;
7082 mp->bvi_mac = bvi_mac;
7084 increment_mac_address (mac);
7091 vl_api_control_ping_t *mp_ping;
7094 /* Shut off async mode */
7095 vam->async_mode = 0;
7097 MPING (CONTROL_PING, mp_ping);
7100 timeout = vat_time_now (vam) + 1.0;
7101 while (vat_time_now (vam) < timeout)
7102 if (vam->result_ready == 1)
7107 if (vam->retval == -99)
7110 if (vam->async_errors > 0)
7112 errmsg ("%d asynchronous errors", vam->async_errors);
7115 vam->async_errors = 0;
7116 after = vat_time_now (vam);
7118 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
7119 count, after - before, count / (after - before));
7125 /* Wait for a reply... */
7129 /* Return the good/bad news */
7130 return (vam->retval);
7134 api_bridge_domain_set_mac_age (vat_main_t * vam)
7136 unformat_input_t *i = vam->input;
7137 vl_api_bridge_domain_set_mac_age_t *mp;
7142 /* Parse args required to build the message */
7143 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7145 if (unformat (i, "bd_id %d", &bd_id));
7146 else if (unformat (i, "mac-age %d", &mac_age));
7153 errmsg ("missing bridge domain");
7159 errmsg ("mac age must be less than 256 ");
7163 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
7165 mp->bd_id = htonl (bd_id);
7166 mp->mac_age = (u8) mac_age;
7174 api_l2_flags (vat_main_t * vam)
7176 unformat_input_t *i = vam->input;
7177 vl_api_l2_flags_t *mp;
7180 u8 sw_if_index_set = 0;
7184 /* Parse args required to build the message */
7185 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7187 if (unformat (i, "sw_if_index %d", &sw_if_index))
7188 sw_if_index_set = 1;
7189 else if (unformat (i, "sw_if"))
7191 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7194 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7195 sw_if_index_set = 1;
7200 else if (unformat (i, "learn"))
7202 else if (unformat (i, "forward"))
7204 else if (unformat (i, "flood"))
7206 else if (unformat (i, "uu-flood"))
7207 flags |= L2_UU_FLOOD;
7208 else if (unformat (i, "arp-term"))
7209 flags |= L2_ARP_TERM;
7210 else if (unformat (i, "off"))
7212 else if (unformat (i, "disable"))
7218 if (sw_if_index_set == 0)
7220 errmsg ("missing interface name or sw_if_index");
7226 mp->sw_if_index = ntohl (sw_if_index);
7227 mp->feature_bitmap = ntohl (flags);
7228 mp->is_set = is_set;
7236 api_bridge_flags (vat_main_t * vam)
7238 unformat_input_t *i = vam->input;
7239 vl_api_bridge_flags_t *mp;
7243 bd_flags_t flags = 0;
7246 /* Parse args required to build the message */
7247 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7249 if (unformat (i, "bd_id %d", &bd_id))
7251 else if (unformat (i, "learn"))
7252 flags |= BRIDGE_API_FLAG_LEARN;
7253 else if (unformat (i, "forward"))
7254 flags |= BRIDGE_API_FLAG_FWD;
7255 else if (unformat (i, "flood"))
7256 flags |= BRIDGE_API_FLAG_FLOOD;
7257 else if (unformat (i, "uu-flood"))
7258 flags |= BRIDGE_API_FLAG_UU_FLOOD;
7259 else if (unformat (i, "arp-term"))
7260 flags |= BRIDGE_API_FLAG_ARP_TERM;
7261 else if (unformat (i, "off"))
7263 else if (unformat (i, "disable"))
7271 errmsg ("missing bridge domain");
7275 M (BRIDGE_FLAGS, mp);
7277 mp->bd_id = ntohl (bd_id);
7278 mp->flags = ntohl (flags);
7279 mp->is_set = is_set;
7287 api_bd_ip_mac_add_del (vat_main_t * vam)
7289 vl_api_address_t ip = VL_API_ZERO_ADDRESS;
7290 vl_api_mac_address_t mac = { 0 };
7291 unformat_input_t *i = vam->input;
7292 vl_api_bd_ip_mac_add_del_t *mp;
7301 /* Parse args required to build the message */
7302 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7304 if (unformat (i, "bd_id %d", &bd_id))
7308 else if (unformat (i, "%U", unformat_vl_api_address, &ip))
7312 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
7316 else if (unformat (i, "del"))
7324 errmsg ("missing bridge domain");
7327 else if (ip_set == 0)
7329 errmsg ("missing IP address");
7332 else if (mac_set == 0)
7334 errmsg ("missing MAC address");
7338 M (BD_IP_MAC_ADD_DEL, mp);
7340 mp->bd_id = ntohl (bd_id);
7341 mp->is_add = is_add;
7343 clib_memcpy (&mp->ip, &ip, sizeof (ip));
7344 clib_memcpy (&mp->mac, &mac, sizeof (mac));
7352 api_bd_ip_mac_flush (vat_main_t * vam)
7354 unformat_input_t *i = vam->input;
7355 vl_api_bd_ip_mac_flush_t *mp;
7360 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7362 if (unformat (i, "bd_id %d", &bd_id))
7372 errmsg ("missing bridge domain");
7376 M (BD_IP_MAC_FLUSH, mp);
7378 mp->bd_id = ntohl (bd_id);
7385 static void vl_api_bd_ip_mac_details_t_handler
7386 (vl_api_bd_ip_mac_details_t * mp)
7388 vat_main_t *vam = &vat_main;
7393 format (0, "%U", format_ip4_address, (ip4_address_t *) mp->ip_address);
7396 format (0, "%U", format_ip6_address, (ip6_address_t *) mp->ip_address);
7399 "\n%-5d %-7s %-20U %-30s",
7400 ntohl (mp->bd_id), mp->is_ipv6 ? "ip6" : "ip4",
7401 format_ethernet_address, mp->mac_address, ip);
7406 static void vl_api_bd_ip_mac_details_t_handler_json
7407 (vl_api_bd_ip_mac_details_t * mp)
7409 vat_main_t *vam = &vat_main;
7410 vat_json_node_t *node = NULL;
7412 if (VAT_JSON_ARRAY != vam->json_tree.type)
7414 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7415 vat_json_init_array (&vam->json_tree);
7417 node = vat_json_array_add (&vam->json_tree);
7419 vat_json_init_object (node);
7420 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
7421 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6);
7422 vat_json_object_add_string_copy (node, "mac_address",
7423 format (0, "%U", format_ethernet_address,
7429 format (0, "%U", format_ip4_address, (ip4_address_t *) mp->ip_address);
7432 format (0, "%U", format_ip6_address, (ip6_address_t *) mp->ip_address);
7433 vat_json_object_add_string_copy (node, "ip_address", ip);
7438 api_bd_ip_mac_dump (vat_main_t * vam)
7440 unformat_input_t *i = vam->input;
7441 vl_api_bd_ip_mac_dump_t *mp;
7442 vl_api_control_ping_t *mp_ping;
7447 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7449 if (unformat (i, "bd_id %d", &bd_id))
7458 "\n%-5s %-7s %-20s %-30s",
7459 "bd_id", "is_ipv6", "mac_address", "ip_address");
7461 /* Dump Bridge Domain Ip to Mac entries */
7462 M (BD_IP_MAC_DUMP, mp);
7465 mp->bd_id = htonl (bd_id);
7471 /* Use a control ping for synchronization */
7472 MPING (CONTROL_PING, mp_ping);
7480 api_tap_create_v2 (vat_main_t * vam)
7482 unformat_input_t *i = vam->input;
7483 vl_api_tap_create_v2_t *mp;
7487 u8 *host_if_name = 0;
7489 u8 host_mac_addr[6];
7490 u8 host_mac_addr_set = 0;
7491 u8 *host_bridge = 0;
7492 ip4_address_t host_ip4_addr;
7493 ip4_address_t host_ip4_gw;
7494 u8 host_ip4_gw_set = 0;
7495 u32 host_ip4_prefix_len = 0;
7496 ip6_address_t host_ip6_addr;
7497 ip6_address_t host_ip6_gw;
7498 u8 host_ip6_gw_set = 0;
7499 u32 host_ip6_prefix_len = 0;
7501 u32 rx_ring_sz = 0, tx_ring_sz = 0;
7503 clib_memset (mac_address, 0, sizeof (mac_address));
7505 /* Parse args required to build the message */
7506 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7508 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7512 else if (unformat (i, "id %u", &id))
7514 else if (unformat (i, "host-if-name %s", &host_if_name))
7516 else if (unformat (i, "host-ns %s", &host_ns))
7518 else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
7520 host_mac_addr_set = 1;
7521 else if (unformat (i, "host-bridge %s", &host_bridge))
7523 else if (unformat (i, "host-ip4-addr %U/%d", unformat_ip4_address,
7524 &host_ip4_addr, &host_ip4_prefix_len))
7526 else if (unformat (i, "host-ip6-addr %U/%d", unformat_ip6_address,
7527 &host_ip6_addr, &host_ip6_prefix_len))
7529 else if (unformat (i, "host-ip4-gw %U", unformat_ip4_address,
7531 host_ip4_gw_set = 1;
7532 else if (unformat (i, "host-ip6-gw %U", unformat_ip6_address,
7534 host_ip6_gw_set = 1;
7535 else if (unformat (i, "rx-ring-size %d", &rx_ring_sz))
7537 else if (unformat (i, "tx-ring-size %d", &tx_ring_sz))
7543 if (vec_len (host_if_name) > 63)
7545 errmsg ("tap name too long. ");
7548 if (vec_len (host_ns) > 63)
7550 errmsg ("host name space too long. ");
7553 if (vec_len (host_bridge) > 63)
7555 errmsg ("host bridge name too long. ");
7558 if (host_ip4_prefix_len > 32)
7560 errmsg ("host ip4 prefix length not valid. ");
7563 if (host_ip6_prefix_len > 128)
7565 errmsg ("host ip6 prefix length not valid. ");
7568 if (!is_pow2 (rx_ring_sz))
7570 errmsg ("rx ring size must be power of 2. ");
7573 if (rx_ring_sz > 32768)
7575 errmsg ("rx ring size must be 32768 or lower. ");
7578 if (!is_pow2 (tx_ring_sz))
7580 errmsg ("tx ring size must be power of 2. ");
7583 if (tx_ring_sz > 32768)
7585 errmsg ("tx ring size must be 32768 or lower. ");
7589 /* Construct the API message */
7590 M (TAP_CREATE_V2, mp);
7592 mp->use_random_mac = random_mac;
7594 mp->id = ntohl (id);
7595 mp->host_namespace_set = host_ns != 0;
7596 mp->host_bridge_set = host_bridge != 0;
7597 mp->host_ip4_addr_set = host_ip4_prefix_len != 0;
7598 mp->host_ip6_addr_set = host_ip6_prefix_len != 0;
7599 mp->rx_ring_sz = ntohs (rx_ring_sz);
7600 mp->tx_ring_sz = ntohs (tx_ring_sz);
7602 if (random_mac == 0)
7603 clib_memcpy (mp->mac_address, mac_address, 6);
7604 if (host_mac_addr_set)
7605 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
7607 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
7609 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
7611 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
7612 if (host_ip4_prefix_len)
7613 clib_memcpy (mp->host_ip4_addr, &host_ip4_addr, 4);
7614 if (host_ip6_prefix_len)
7615 clib_memcpy (mp->host_ip6_addr, &host_ip6_addr, 16);
7616 if (host_ip4_gw_set)
7617 clib_memcpy (mp->host_ip4_gw, &host_ip4_gw, 4);
7618 if (host_ip6_gw_set)
7619 clib_memcpy (mp->host_ip6_gw, &host_ip6_gw, 16);
7622 vec_free (host_if_name);
7623 vec_free (host_bridge);
7628 /* Wait for a reply... */
7634 api_tap_delete_v2 (vat_main_t * vam)
7636 unformat_input_t *i = vam->input;
7637 vl_api_tap_delete_v2_t *mp;
7638 u32 sw_if_index = ~0;
7639 u8 sw_if_index_set = 0;
7642 /* Parse args required to build the message */
7643 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7645 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7646 sw_if_index_set = 1;
7647 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7648 sw_if_index_set = 1;
7653 if (sw_if_index_set == 0)
7655 errmsg ("missing vpp interface name. ");
7659 /* Construct the API message */
7660 M (TAP_DELETE_V2, mp);
7662 mp->sw_if_index = ntohl (sw_if_index);
7667 /* Wait for a reply... */
7673 unformat_pci_addr (unformat_input_t * input, va_list * args)
7682 addr = va_arg (*args, struct pci_addr_t *);
7685 if (!unformat (input, "%x:%x:%x.%x", &x[0], &x[1], &x[2], &x[3]))
7688 addr->domain = x[0];
7691 addr->function = x[3];
7697 api_virtio_pci_create (vat_main_t * vam)
7699 unformat_input_t *i = vam->input;
7700 vl_api_virtio_pci_create_t *mp;
7705 u64 features = (u64) ~ (0ULL);
7708 clib_memset (mac_address, 0, sizeof (mac_address));
7710 /* Parse args required to build the message */
7711 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7713 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7717 else if (unformat (i, "pci-addr %U", unformat_pci_addr, &pci_addr))
7719 else if (unformat (i, "features 0x%llx", &features))
7721 else if (unformat (i, "gso-enabled"))
7729 errmsg ("pci address must be non zero. ");
7733 /* Construct the API message */
7734 M (VIRTIO_PCI_CREATE, mp);
7736 mp->use_random_mac = random_mac;
7738 mp->pci_addr = htonl (pci_addr);
7739 mp->features = clib_host_to_net_u64 (features);
7740 mp->gso_enabled = gso_enabled;
7742 if (random_mac == 0)
7743 clib_memcpy (mp->mac_address, mac_address, 6);
7748 /* Wait for a reply... */
7754 api_virtio_pci_delete (vat_main_t * vam)
7756 unformat_input_t *i = vam->input;
7757 vl_api_virtio_pci_delete_t *mp;
7758 u32 sw_if_index = ~0;
7759 u8 sw_if_index_set = 0;
7762 /* Parse args required to build the message */
7763 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7765 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7766 sw_if_index_set = 1;
7767 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7768 sw_if_index_set = 1;
7773 if (sw_if_index_set == 0)
7775 errmsg ("missing vpp interface name. ");
7779 /* Construct the API message */
7780 M (VIRTIO_PCI_DELETE, mp);
7782 mp->sw_if_index = htonl (sw_if_index);
7787 /* Wait for a reply... */
7793 api_bond_create (vat_main_t * vam)
7795 unformat_input_t *i = vam->input;
7796 vl_api_bond_create_t *mp;
7805 clib_memset (mac_address, 0, sizeof (mac_address));
7808 /* Parse args required to build the message */
7809 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7811 if (unformat (i, "mode %U", unformat_bond_mode, &mode))
7813 else if (((mode == BOND_MODE_LACP) || (mode == BOND_MODE_XOR))
7814 && unformat (i, "lb %U", unformat_bond_load_balance, &lb))
7816 else if (unformat (i, "hw-addr %U", unformat_ethernet_address,
7819 else if (unformat (i, "id %u", &id))
7825 if (mode_is_set == 0)
7827 errmsg ("Missing bond mode. ");
7831 /* Construct the API message */
7832 M (BOND_CREATE, mp);
7834 mp->use_custom_mac = custom_mac;
7838 mp->id = htonl (id);
7841 clib_memcpy (mp->mac_address, mac_address, 6);
7846 /* Wait for a reply... */
7852 api_bond_delete (vat_main_t * vam)
7854 unformat_input_t *i = vam->input;
7855 vl_api_bond_delete_t *mp;
7856 u32 sw_if_index = ~0;
7857 u8 sw_if_index_set = 0;
7860 /* Parse args required to build the message */
7861 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7863 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7864 sw_if_index_set = 1;
7865 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7866 sw_if_index_set = 1;
7871 if (sw_if_index_set == 0)
7873 errmsg ("missing vpp interface name. ");
7877 /* Construct the API message */
7878 M (BOND_DELETE, mp);
7880 mp->sw_if_index = ntohl (sw_if_index);
7885 /* Wait for a reply... */
7891 api_bond_enslave (vat_main_t * vam)
7893 unformat_input_t *i = vam->input;
7894 vl_api_bond_enslave_t *mp;
7895 u32 bond_sw_if_index;
7899 u32 bond_sw_if_index_is_set = 0;
7901 u8 sw_if_index_is_set = 0;
7903 /* Parse args required to build the message */
7904 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7906 if (unformat (i, "sw_if_index %d", &sw_if_index))
7907 sw_if_index_is_set = 1;
7908 else if (unformat (i, "bond %u", &bond_sw_if_index))
7909 bond_sw_if_index_is_set = 1;
7910 else if (unformat (i, "passive %d", &is_passive))
7912 else if (unformat (i, "long-timeout %d", &is_long_timeout))
7918 if (bond_sw_if_index_is_set == 0)
7920 errmsg ("Missing bond sw_if_index. ");
7923 if (sw_if_index_is_set == 0)
7925 errmsg ("Missing slave sw_if_index. ");
7929 /* Construct the API message */
7930 M (BOND_ENSLAVE, mp);
7932 mp->bond_sw_if_index = ntohl (bond_sw_if_index);
7933 mp->sw_if_index = ntohl (sw_if_index);
7934 mp->is_long_timeout = is_long_timeout;
7935 mp->is_passive = is_passive;
7940 /* Wait for a reply... */
7946 api_bond_detach_slave (vat_main_t * vam)
7948 unformat_input_t *i = vam->input;
7949 vl_api_bond_detach_slave_t *mp;
7950 u32 sw_if_index = ~0;
7951 u8 sw_if_index_set = 0;
7954 /* Parse args required to build the message */
7955 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7957 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7958 sw_if_index_set = 1;
7959 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7960 sw_if_index_set = 1;
7965 if (sw_if_index_set == 0)
7967 errmsg ("missing vpp interface name. ");
7971 /* Construct the API message */
7972 M (BOND_DETACH_SLAVE, mp);
7974 mp->sw_if_index = ntohl (sw_if_index);
7979 /* Wait for a reply... */
7985 api_ip_table_add_del (vat_main_t * vam)
7987 unformat_input_t *i = vam->input;
7988 vl_api_ip_table_add_del_t *mp;
7994 /* Parse args required to build the message */
7995 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7997 if (unformat (i, "ipv6"))
7999 else if (unformat (i, "del"))
8001 else if (unformat (i, "add"))
8003 else if (unformat (i, "table %d", &table_id))
8007 clib_warning ("parse error '%U'", format_unformat_error, i);
8014 errmsg ("missing table-ID");
8018 /* Construct the API message */
8019 M (IP_TABLE_ADD_DEL, mp);
8021 mp->table.table_id = ntohl (table_id);
8022 mp->table.is_ip6 = is_ipv6;
8023 mp->is_add = is_add;
8028 /* Wait for a reply... */
8035 unformat_fib_path (unformat_input_t * input, va_list * args)
8037 vat_main_t *vam = va_arg (*args, vat_main_t *);
8038 vl_api_fib_path_t *path = va_arg (*args, vl_api_fib_path_t *);
8039 u32 weight, preference;
8040 mpls_label_t out_label;
8042 clib_memset (path, 0, sizeof (*path));
8044 path->sw_if_index = ~0;
8048 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8050 if (unformat (input, "%U %U",
8051 unformat_vl_api_ip4_address,
8052 &path->nh.address.ip4,
8053 api_unformat_sw_if_index, vam, &path->sw_if_index))
8055 path->proto = FIB_API_PATH_NH_PROTO_IP4;
8057 else if (unformat (input, "%U %U",
8058 unformat_vl_api_ip6_address,
8059 &path->nh.address.ip6,
8060 api_unformat_sw_if_index, vam, &path->sw_if_index))
8062 path->proto = FIB_API_PATH_NH_PROTO_IP6;
8064 else if (unformat (input, "weight %u", &weight))
8066 path->weight = weight;
8068 else if (unformat (input, "preference %u", &preference))
8070 path->preference = preference;
8072 else if (unformat (input, "%U next-hop-table %d",
8073 unformat_vl_api_ip4_address,
8074 &path->nh.address.ip4, &path->table_id))
8076 path->proto = FIB_API_PATH_NH_PROTO_IP4;
8078 else if (unformat (input, "%U next-hop-table %d",
8079 unformat_vl_api_ip6_address,
8080 &path->nh.address.ip6, &path->table_id))
8082 path->proto = FIB_API_PATH_NH_PROTO_IP6;
8084 else if (unformat (input, "%U",
8085 unformat_vl_api_ip4_address, &path->nh.address.ip4))
8088 * the recursive next-hops are by default in the default table
8091 path->sw_if_index = ~0;
8092 path->proto = FIB_API_PATH_NH_PROTO_IP4;
8094 else if (unformat (input, "%U",
8095 unformat_vl_api_ip6_address, &path->nh.address.ip6))
8098 * the recursive next-hops are by default in the default table
8101 path->sw_if_index = ~0;
8102 path->proto = FIB_API_PATH_NH_PROTO_IP6;
8104 else if (unformat (input, "resolve-via-host"))
8106 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_HOST;
8108 else if (unformat (input, "resolve-via-attached"))
8110 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_ATTACHED;
8112 else if (unformat (input, "ip4-lookup-in-table %d", &path->table_id))
8114 path->type = FIB_API_PATH_TYPE_LOCAL;
8115 path->sw_if_index = ~0;
8116 path->proto = FIB_API_PATH_NH_PROTO_IP4;
8118 else if (unformat (input, "ip6-lookup-in-table %d", &path->table_id))
8120 path->type = FIB_API_PATH_TYPE_LOCAL;
8121 path->sw_if_index = ~0;
8122 path->proto = FIB_API_PATH_NH_PROTO_IP6;
8124 else if (unformat (input, "sw_if_index %d", &path->sw_if_index))
8126 else if (unformat (input, "via-label %d", &path->nh.via_label))
8128 path->proto = FIB_API_PATH_NH_PROTO_MPLS;
8129 path->sw_if_index = ~0;
8131 else if (unformat (input, "l2-input-on %d", &path->sw_if_index))
8133 path->proto = FIB_API_PATH_NH_PROTO_ETHERNET;
8134 path->type = FIB_API_PATH_TYPE_INTERFACE_RX;
8136 else if (unformat (input, "local"))
8138 path->type = FIB_API_PATH_TYPE_LOCAL;
8140 else if (unformat (input, "out-labels"))
8142 while (unformat (input, "%d", &out_label))
8144 path->label_stack[path->n_labels].label = out_label;
8145 path->label_stack[path->n_labels].is_uniform = 0;
8146 path->label_stack[path->n_labels].ttl = 64;
8150 else if (unformat (input, "via"))
8152 /* new path, back up and return */
8153 unformat_put_input (input);
8154 unformat_put_input (input);
8155 unformat_put_input (input);
8156 unformat_put_input (input);
8165 path->proto = ntohl (path->proto);
8166 path->type = ntohl (path->type);
8167 path->flags = ntohl (path->flags);
8168 path->table_id = ntohl (path->table_id);
8169 path->sw_if_index = ntohl (path->sw_if_index);
8175 api_ip_route_add_del (vat_main_t * vam)
8177 unformat_input_t *i = vam->input;
8178 vl_api_ip_route_add_del_t *mp;
8181 u8 is_multipath = 0;
8184 vl_api_prefix_t pfx = { };
8185 vl_api_fib_path_t paths[8];
8189 u32 random_add_del = 0;
8190 u32 *random_vector = 0;
8191 u32 random_seed = 0xdeaddabe;
8193 /* Parse args required to build the message */
8194 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8196 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8198 else if (unformat (i, "del"))
8200 else if (unformat (i, "add"))
8202 else if (unformat (i, "vrf %d", &vrf_id))
8204 else if (unformat (i, "count %d", &count))
8206 else if (unformat (i, "random"))
8208 else if (unformat (i, "multipath"))
8210 else if (unformat (i, "seed %d", &random_seed))
8214 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8217 if (8 == path_count)
8219 errmsg ("max 8 paths");
8225 clib_warning ("parse error '%U'", format_unformat_error, i);
8232 errmsg ("specify a path; via ...");
8235 if (prefix_set == 0)
8237 errmsg ("missing prefix");
8241 /* Generate a pile of unique, random routes */
8244 ip4_address_t *i = (ip4_address_t *) & paths[0].nh.address.ip4;
8245 u32 this_random_address;
8248 random_hash = hash_create (count, sizeof (uword));
8250 hash_set (random_hash, i->as_u32, 1);
8251 for (j = 0; j <= count; j++)
8255 this_random_address = random_u32 (&random_seed);
8256 this_random_address =
8257 clib_host_to_net_u32 (this_random_address);
8259 while (hash_get (random_hash, this_random_address));
8260 vec_add1 (random_vector, this_random_address);
8261 hash_set (random_hash, this_random_address, 1);
8263 hash_free (random_hash);
8264 set_ip4_address (&pfx.address, random_vector[0]);
8269 /* Turn on async mode */
8270 vam->async_mode = 1;
8271 vam->async_errors = 0;
8272 before = vat_time_now (vam);
8275 for (j = 0; j < count; j++)
8277 /* Construct the API message */
8278 M2 (IP_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8280 mp->is_add = is_add;
8281 mp->is_multipath = is_multipath;
8283 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8284 mp->route.table_id = ntohl (vrf_id);
8285 mp->route.n_paths = path_count;
8287 clib_memcpy (&mp->route.paths, &paths, sizeof (paths[0]) * path_count);
8290 set_ip4_address (&pfx.address, random_vector[j + 1]);
8292 increment_address (&pfx.address);
8295 /* If we receive SIGTERM, stop now... */
8300 /* When testing multiple add/del ops, use a control-ping to sync */
8303 vl_api_control_ping_t *mp_ping;
8307 /* Shut off async mode */
8308 vam->async_mode = 0;
8310 MPING (CONTROL_PING, mp_ping);
8313 timeout = vat_time_now (vam) + 1.0;
8314 while (vat_time_now (vam) < timeout)
8315 if (vam->result_ready == 1)
8320 if (vam->retval == -99)
8323 if (vam->async_errors > 0)
8325 errmsg ("%d asynchronous errors", vam->async_errors);
8328 vam->async_errors = 0;
8329 after = vat_time_now (vam);
8331 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8335 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8336 count, after - before, count / (after - before));
8342 /* Wait for a reply... */
8347 /* Return the good/bad news */
8348 return (vam->retval);
8352 api_ip_mroute_add_del (vat_main_t * vam)
8354 unformat_input_t *i = vam->input;
8355 u8 path_set = 0, prefix_set = 0, is_add = 1;
8356 vl_api_ip_mroute_add_del_t *mp;
8357 mfib_entry_flags_t eflags = 0;
8358 vl_api_mfib_path_t path;
8359 vl_api_mprefix_t pfx = { };
8363 /* Parse args required to build the message */
8364 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8366 if (unformat (i, "%U", unformat_vl_api_mprefix, &pfx))
8369 pfx.grp_address_length = htons (pfx.grp_address_length);
8371 else if (unformat (i, "del"))
8373 else if (unformat (i, "add"))
8375 else if (unformat (i, "vrf %d", &vrf_id))
8377 else if (unformat (i, "%U", unformat_mfib_itf_flags, &path.itf_flags))
8378 path.itf_flags = htonl (path.itf_flags);
8379 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8381 else if (unformat (i, "via %U", unformat_fib_path, vam, &path.path))
8385 clib_warning ("parse error '%U'", format_unformat_error, i);
8390 if (prefix_set == 0)
8392 errmsg ("missing addresses\n");
8397 errmsg ("missing path\n");
8401 /* Construct the API message */
8402 M (IP_MROUTE_ADD_DEL, mp);
8404 mp->is_add = is_add;
8405 mp->is_multipath = 1;
8407 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8408 mp->route.table_id = htonl (vrf_id);
8409 mp->route.n_paths = 1;
8410 mp->route.entry_flags = htonl (eflags);
8412 clib_memcpy (&mp->route.paths, &path, sizeof (path));
8416 /* Wait for a reply... */
8422 api_mpls_table_add_del (vat_main_t * vam)
8424 unformat_input_t *i = vam->input;
8425 vl_api_mpls_table_add_del_t *mp;
8430 /* Parse args required to build the message */
8431 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8433 if (unformat (i, "table %d", &table_id))
8435 else if (unformat (i, "del"))
8437 else if (unformat (i, "add"))
8441 clib_warning ("parse error '%U'", format_unformat_error, i);
8448 errmsg ("missing table-ID");
8452 /* Construct the API message */
8453 M (MPLS_TABLE_ADD_DEL, mp);
8455 mp->mt_table.mt_table_id = ntohl (table_id);
8456 mp->mt_is_add = is_add;
8461 /* Wait for a reply... */
8468 api_mpls_route_add_del (vat_main_t * vam)
8470 u8 is_add = 1, path_count = 0, is_multipath = 0, is_eos = 0;
8471 mpls_label_t local_label = MPLS_LABEL_INVALID;
8472 unformat_input_t *i = vam->input;
8473 vl_api_mpls_route_add_del_t *mp;
8474 vl_api_fib_path_t paths[8];
8478 /* Parse args required to build the message */
8479 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8481 if (unformat (i, "%d", &local_label))
8483 else if (unformat (i, "eos"))
8485 else if (unformat (i, "non-eos"))
8487 else if (unformat (i, "del"))
8489 else if (unformat (i, "add"))
8491 else if (unformat (i, "multipath"))
8493 else if (unformat (i, "count %d", &count))
8497 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8500 if (8 == path_count)
8502 errmsg ("max 8 paths");
8508 clib_warning ("parse error '%U'", format_unformat_error, i);
8515 errmsg ("specify a path; via ...");
8519 if (MPLS_LABEL_INVALID == local_label)
8521 errmsg ("missing label");
8527 /* Turn on async mode */
8528 vam->async_mode = 1;
8529 vam->async_errors = 0;
8530 before = vat_time_now (vam);
8533 for (j = 0; j < count; j++)
8535 /* Construct the API message */
8536 M2 (MPLS_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8538 mp->mr_is_add = is_add;
8539 mp->mr_is_multipath = is_multipath;
8541 mp->mr_route.mr_label = local_label;
8542 mp->mr_route.mr_eos = is_eos;
8543 mp->mr_route.mr_table_id = 0;
8544 mp->mr_route.mr_n_paths = path_count;
8546 clib_memcpy (&mp->mr_route.mr_paths, paths,
8547 sizeof (paths[0]) * path_count);
8553 /* If we receive SIGTERM, stop now... */
8558 /* When testing multiple add/del ops, use a control-ping to sync */
8561 vl_api_control_ping_t *mp_ping;
8565 /* Shut off async mode */
8566 vam->async_mode = 0;
8568 MPING (CONTROL_PING, mp_ping);
8571 timeout = vat_time_now (vam) + 1.0;
8572 while (vat_time_now (vam) < timeout)
8573 if (vam->result_ready == 1)
8578 if (vam->retval == -99)
8581 if (vam->async_errors > 0)
8583 errmsg ("%d asynchronous errors", vam->async_errors);
8586 vam->async_errors = 0;
8587 after = vat_time_now (vam);
8589 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8593 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8594 count, after - before, count / (after - before));
8600 /* Wait for a reply... */
8605 /* Return the good/bad news */
8606 return (vam->retval);
8611 api_mpls_ip_bind_unbind (vat_main_t * vam)
8613 unformat_input_t *i = vam->input;
8614 vl_api_mpls_ip_bind_unbind_t *mp;
8615 u32 ip_table_id = 0;
8617 vl_api_prefix_t pfx;
8619 mpls_label_t local_label = MPLS_LABEL_INVALID;
8622 /* Parse args required to build the message */
8623 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8625 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8627 else if (unformat (i, "%d", &local_label))
8629 else if (unformat (i, "table-id %d", &ip_table_id))
8631 else if (unformat (i, "unbind"))
8633 else if (unformat (i, "bind"))
8637 clib_warning ("parse error '%U'", format_unformat_error, i);
8644 errmsg ("IP prefix not set");
8648 if (MPLS_LABEL_INVALID == local_label)
8650 errmsg ("missing label");
8654 /* Construct the API message */
8655 M (MPLS_IP_BIND_UNBIND, mp);
8657 mp->mb_is_bind = is_bind;
8658 mp->mb_ip_table_id = ntohl (ip_table_id);
8659 mp->mb_mpls_table_id = 0;
8660 mp->mb_label = ntohl (local_label);
8661 clib_memcpy (&mp->mb_prefix, &pfx, sizeof (pfx));
8666 /* Wait for a reply... */
8673 api_sr_mpls_policy_add (vat_main_t * vam)
8675 unformat_input_t *i = vam->input;
8676 vl_api_sr_mpls_policy_add_t *mp;
8682 u32 *segments = NULL;
8685 /* Parse args required to build the message */
8686 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8688 if (unformat (i, "bsid %d", &bsid))
8690 else if (unformat (i, "weight %d", &weight))
8692 else if (unformat (i, "spray"))
8694 else if (unformat (i, "next %d", &sid))
8697 vec_add1 (segments, htonl (sid));
8701 clib_warning ("parse error '%U'", format_unformat_error, i);
8708 errmsg ("bsid not set");
8712 if (n_segments == 0)
8714 errmsg ("no sid in segment stack");
8718 /* Construct the API message */
8719 M2 (SR_MPLS_POLICY_ADD, mp, sizeof (u32) * n_segments);
8721 mp->bsid = htonl (bsid);
8722 mp->weight = htonl (weight);
8724 mp->n_segments = n_segments;
8725 memcpy (mp->segments, segments, sizeof (u32) * n_segments);
8726 vec_free (segments);
8731 /* Wait for a reply... */
8737 api_sr_mpls_policy_del (vat_main_t * vam)
8739 unformat_input_t *i = vam->input;
8740 vl_api_sr_mpls_policy_del_t *mp;
8744 /* Parse args required to build the message */
8745 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8747 if (unformat (i, "bsid %d", &bsid))
8751 clib_warning ("parse error '%U'", format_unformat_error, i);
8758 errmsg ("bsid not set");
8762 /* Construct the API message */
8763 M (SR_MPLS_POLICY_DEL, mp);
8765 mp->bsid = htonl (bsid);
8770 /* Wait for a reply... */
8776 api_bier_table_add_del (vat_main_t * vam)
8778 unformat_input_t *i = vam->input;
8779 vl_api_bier_table_add_del_t *mp;
8781 u32 set = 0, sub_domain = 0, hdr_len = 3;
8782 mpls_label_t local_label = MPLS_LABEL_INVALID;
8785 /* Parse args required to build the message */
8786 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8788 if (unformat (i, "sub-domain %d", &sub_domain))
8790 else if (unformat (i, "set %d", &set))
8792 else if (unformat (i, "label %d", &local_label))
8794 else if (unformat (i, "hdr-len %d", &hdr_len))
8796 else if (unformat (i, "add"))
8798 else if (unformat (i, "del"))
8802 clib_warning ("parse error '%U'", format_unformat_error, i);
8807 if (MPLS_LABEL_INVALID == local_label)
8809 errmsg ("missing label\n");
8813 /* Construct the API message */
8814 M (BIER_TABLE_ADD_DEL, mp);
8816 mp->bt_is_add = is_add;
8817 mp->bt_label = ntohl (local_label);
8818 mp->bt_tbl_id.bt_set = set;
8819 mp->bt_tbl_id.bt_sub_domain = sub_domain;
8820 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
8825 /* Wait for a reply... */
8832 api_bier_route_add_del (vat_main_t * vam)
8834 unformat_input_t *i = vam->input;
8835 vl_api_bier_route_add_del_t *mp;
8837 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
8838 ip4_address_t v4_next_hop_address;
8839 ip6_address_t v6_next_hop_address;
8840 u8 next_hop_set = 0;
8841 u8 next_hop_proto_is_ip4 = 1;
8842 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8845 /* Parse args required to build the message */
8846 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8848 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
8850 next_hop_proto_is_ip4 = 1;
8853 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
8855 next_hop_proto_is_ip4 = 0;
8858 if (unformat (i, "sub-domain %d", &sub_domain))
8860 else if (unformat (i, "set %d", &set))
8862 else if (unformat (i, "hdr-len %d", &hdr_len))
8864 else if (unformat (i, "bp %d", &bp))
8866 else if (unformat (i, "add"))
8868 else if (unformat (i, "del"))
8870 else if (unformat (i, "out-label %d", &next_hop_out_label))
8874 clib_warning ("parse error '%U'", format_unformat_error, i);
8879 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
8881 errmsg ("next hop / label set\n");
8886 errmsg ("bit=position not set\n");
8890 /* Construct the API message */
8891 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t));
8893 mp->br_is_add = is_add;
8894 mp->br_route.br_tbl_id.bt_set = set;
8895 mp->br_route.br_tbl_id.bt_sub_domain = sub_domain;
8896 mp->br_route.br_tbl_id.bt_hdr_len_id = hdr_len;
8897 mp->br_route.br_bp = ntohs (bp);
8898 mp->br_route.br_n_paths = 1;
8899 mp->br_route.br_paths[0].n_labels = 1;
8900 mp->br_route.br_paths[0].label_stack[0].label = ntohl (next_hop_out_label);
8901 mp->br_route.br_paths[0].proto = (next_hop_proto_is_ip4 ?
8902 FIB_API_PATH_NH_PROTO_IP4 :
8903 FIB_API_PATH_NH_PROTO_IP6);
8905 if (next_hop_proto_is_ip4)
8907 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip4,
8908 &v4_next_hop_address, sizeof (v4_next_hop_address));
8912 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip6,
8913 &v6_next_hop_address, sizeof (v6_next_hop_address));
8919 /* Wait for a reply... */
8926 api_proxy_arp_add_del (vat_main_t * vam)
8928 unformat_input_t *i = vam->input;
8929 vl_api_proxy_arp_add_del_t *mp;
8932 vl_api_ip4_address_t lo, hi;
8936 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8938 if (unformat (i, "vrf %d", &vrf_id))
8940 else if (unformat (i, "%U - %U", unformat_vl_api_ip4_address, &lo,
8941 unformat_vl_api_ip4_address, &hi))
8943 else if (unformat (i, "del"))
8947 clib_warning ("parse error '%U'", format_unformat_error, i);
8954 errmsg ("address range not set");
8958 M (PROXY_ARP_ADD_DEL, mp);
8960 mp->proxy.table_id = ntohl (vrf_id);
8961 mp->is_add = is_add;
8962 clib_memcpy (mp->proxy.low, &lo, sizeof (lo));
8963 clib_memcpy (mp->proxy.hi, &hi, sizeof (hi));
8971 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
8973 unformat_input_t *i = vam->input;
8974 vl_api_proxy_arp_intfc_enable_disable_t *mp;
8977 u8 sw_if_index_set = 0;
8980 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8982 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8983 sw_if_index_set = 1;
8984 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8985 sw_if_index_set = 1;
8986 else if (unformat (i, "enable"))
8988 else if (unformat (i, "disable"))
8992 clib_warning ("parse error '%U'", format_unformat_error, i);
8997 if (sw_if_index_set == 0)
8999 errmsg ("missing interface name or sw_if_index");
9003 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
9005 mp->sw_if_index = ntohl (sw_if_index);
9006 mp->enable_disable = enable;
9014 api_mpls_tunnel_add_del (vat_main_t * vam)
9016 unformat_input_t *i = vam->input;
9017 vl_api_mpls_tunnel_add_del_t *mp;
9019 vl_api_fib_path_t paths[8];
9020 u32 sw_if_index = ~0;
9026 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9028 if (unformat (i, "add"))
9032 (i, "del %U", api_unformat_sw_if_index, vam, &sw_if_index))
9034 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
9036 else if (unformat (i, "l2-only"))
9040 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
9043 if (8 == path_count)
9045 errmsg ("max 8 paths");
9051 clib_warning ("parse error '%U'", format_unformat_error, i);
9056 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
9058 mp->mt_is_add = is_add;
9059 mp->mt_tunnel.mt_sw_if_index = ntohl (sw_if_index);
9060 mp->mt_tunnel.mt_l2_only = l2_only;
9061 mp->mt_tunnel.mt_is_multicast = 0;
9062 mp->mt_tunnel.mt_n_paths = path_count;
9064 clib_memcpy (&mp->mt_tunnel.mt_paths, &paths,
9065 sizeof (paths[0]) * path_count);
9073 api_sw_interface_set_unnumbered (vat_main_t * vam)
9075 unformat_input_t *i = vam->input;
9076 vl_api_sw_interface_set_unnumbered_t *mp;
9078 u32 unnum_sw_index = ~0;
9080 u8 sw_if_index_set = 0;
9083 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9085 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9086 sw_if_index_set = 1;
9087 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9088 sw_if_index_set = 1;
9089 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
9091 else if (unformat (i, "del"))
9095 clib_warning ("parse error '%U'", format_unformat_error, i);
9100 if (sw_if_index_set == 0)
9102 errmsg ("missing interface name or sw_if_index");
9106 M (SW_INTERFACE_SET_UNNUMBERED, mp);
9108 mp->sw_if_index = ntohl (sw_if_index);
9109 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
9110 mp->is_add = is_add;
9118 api_ip_neighbor_add_del (vat_main_t * vam)
9120 vl_api_mac_address_t mac_address;
9121 unformat_input_t *i = vam->input;
9122 vl_api_ip_neighbor_add_del_t *mp;
9123 vl_api_address_t ip_address;
9125 u8 sw_if_index_set = 0;
9130 ip_neighbor_flags_t flags;
9132 flags = IP_NEIGHBOR_FLAG_NONE;
9133 clib_memset (&ip_address, 0, sizeof (ip_address));
9134 clib_memset (&mac_address, 0, sizeof (mac_address));
9136 /* Parse args required to build the message */
9137 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9139 if (unformat (i, "mac %U", unformat_vl_api_mac_address, &mac_address))
9143 else if (unformat (i, "del"))
9146 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9147 sw_if_index_set = 1;
9148 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9149 sw_if_index_set = 1;
9150 else if (unformat (i, "static"))
9151 flags |= IP_NEIGHBOR_FLAG_STATIC;
9152 else if (unformat (i, "no-fib-entry"))
9153 flags |= IP_NEIGHBOR_FLAG_NO_FIB_ENTRY;
9154 else if (unformat (i, "dst %U", unformat_vl_api_address, &ip_address))
9158 clib_warning ("parse error '%U'", format_unformat_error, i);
9163 if (sw_if_index_set == 0)
9165 errmsg ("missing interface name or sw_if_index");
9170 errmsg ("no address set");
9174 /* Construct the API message */
9175 M (IP_NEIGHBOR_ADD_DEL, mp);
9177 mp->neighbor.sw_if_index = ntohl (sw_if_index);
9178 mp->is_add = is_add;
9179 mp->neighbor.flags = htonl (flags);
9181 clib_memcpy (&mp->neighbor.mac_address, &mac_address,
9182 sizeof (mac_address));
9184 clib_memcpy (&mp->neighbor.ip_address, &ip_address, sizeof (ip_address));
9189 /* Wait for a reply, return good/bad news */
9195 api_create_vlan_subif (vat_main_t * vam)
9197 unformat_input_t *i = vam->input;
9198 vl_api_create_vlan_subif_t *mp;
9200 u8 sw_if_index_set = 0;
9205 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9207 if (unformat (i, "sw_if_index %d", &sw_if_index))
9208 sw_if_index_set = 1;
9210 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9211 sw_if_index_set = 1;
9212 else if (unformat (i, "vlan %d", &vlan_id))
9216 clib_warning ("parse error '%U'", format_unformat_error, i);
9221 if (sw_if_index_set == 0)
9223 errmsg ("missing interface name or sw_if_index");
9227 if (vlan_id_set == 0)
9229 errmsg ("missing vlan_id");
9232 M (CREATE_VLAN_SUBIF, mp);
9234 mp->sw_if_index = ntohl (sw_if_index);
9235 mp->vlan_id = ntohl (vlan_id);
9242 #define foreach_create_subif_bit \
9249 _(outer_vlan_id_any) \
9250 _(inner_vlan_id_any)
9253 api_create_subif (vat_main_t * vam)
9255 unformat_input_t *i = vam->input;
9256 vl_api_create_subif_t *mp;
9258 u8 sw_if_index_set = 0;
9265 u32 exact_match = 0;
9266 u32 default_sub = 0;
9267 u32 outer_vlan_id_any = 0;
9268 u32 inner_vlan_id_any = 0;
9270 u16 outer_vlan_id = 0;
9271 u16 inner_vlan_id = 0;
9274 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9276 if (unformat (i, "sw_if_index %d", &sw_if_index))
9277 sw_if_index_set = 1;
9279 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9280 sw_if_index_set = 1;
9281 else if (unformat (i, "sub_id %d", &sub_id))
9283 else if (unformat (i, "outer_vlan_id %d", &tmp))
9284 outer_vlan_id = tmp;
9285 else if (unformat (i, "inner_vlan_id %d", &tmp))
9286 inner_vlan_id = tmp;
9288 #define _(a) else if (unformat (i, #a)) a = 1 ;
9289 foreach_create_subif_bit
9293 clib_warning ("parse error '%U'", format_unformat_error, i);
9298 if (sw_if_index_set == 0)
9300 errmsg ("missing interface name or sw_if_index");
9304 if (sub_id_set == 0)
9306 errmsg ("missing sub_id");
9309 M (CREATE_SUBIF, mp);
9311 mp->sw_if_index = ntohl (sw_if_index);
9312 mp->sub_id = ntohl (sub_id);
9314 #define _(a) mp->a = a;
9315 foreach_create_subif_bit;
9318 mp->outer_vlan_id = ntohs (outer_vlan_id);
9319 mp->inner_vlan_id = ntohs (inner_vlan_id);
9327 api_reset_fib (vat_main_t * vam)
9329 unformat_input_t *i = vam->input;
9330 vl_api_reset_fib_t *mp;
9336 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9338 if (unformat (i, "vrf %d", &vrf_id))
9340 else if (unformat (i, "ipv6"))
9344 clib_warning ("parse error '%U'", format_unformat_error, i);
9349 if (vrf_id_set == 0)
9351 errmsg ("missing vrf id");
9357 mp->vrf_id = ntohl (vrf_id);
9358 mp->is_ipv6 = is_ipv6;
9366 api_dhcp_proxy_config (vat_main_t * vam)
9368 unformat_input_t *i = vam->input;
9369 vl_api_dhcp_proxy_config_t *mp;
9371 u32 server_vrf_id = 0;
9373 u8 v4_address_set = 0;
9374 u8 v6_address_set = 0;
9375 ip4_address_t v4address;
9376 ip6_address_t v6address;
9377 u8 v4_src_address_set = 0;
9378 u8 v6_src_address_set = 0;
9379 ip4_address_t v4srcaddress;
9380 ip6_address_t v6srcaddress;
9383 /* Parse args required to build the message */
9384 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9386 if (unformat (i, "del"))
9388 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
9390 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
9392 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
9394 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
9396 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
9397 v4_src_address_set = 1;
9398 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
9399 v6_src_address_set = 1;
9404 if (v4_address_set && v6_address_set)
9406 errmsg ("both v4 and v6 server addresses set");
9409 if (!v4_address_set && !v6_address_set)
9411 errmsg ("no server addresses set");
9415 if (v4_src_address_set && v6_src_address_set)
9417 errmsg ("both v4 and v6 src addresses set");
9420 if (!v4_src_address_set && !v6_src_address_set)
9422 errmsg ("no src addresses set");
9426 if (!(v4_src_address_set && v4_address_set) &&
9427 !(v6_src_address_set && v6_address_set))
9429 errmsg ("no matching server and src addresses set");
9433 /* Construct the API message */
9434 M (DHCP_PROXY_CONFIG, mp);
9436 mp->is_add = is_add;
9437 mp->rx_vrf_id = ntohl (rx_vrf_id);
9438 mp->server_vrf_id = ntohl (server_vrf_id);
9442 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
9443 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
9447 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
9448 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
9454 /* Wait for a reply, return good/bad news */
9459 #define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
9460 #define vl_api_dhcp_proxy_details_t_print vl_noop_handler
9463 vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
9465 vat_main_t *vam = &vat_main;
9466 u32 i, count = mp->count;
9467 vl_api_dhcp_server_t *s;
9471 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9472 "VSS ASCII VPN-ID '%s', VSS RFC2685 VPN-ID (oui:id) %d:%d",
9473 ntohl (mp->rx_vrf_id),
9474 format_ip6_address, mp->dhcp_src_address,
9475 mp->vss_type, mp->vss_vpn_ascii_id,
9476 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9479 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9480 "VSS ASCII VPN-ID '%s', VSS RFC2685 VPN-ID (oui:id) %d:%d",
9481 ntohl (mp->rx_vrf_id),
9482 format_ip4_address, mp->dhcp_src_address,
9483 mp->vss_type, mp->vss_vpn_ascii_id,
9484 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9486 for (i = 0; i < count; i++)
9488 s = &mp->servers[i];
9492 " Server Table-ID %d, Server Address %U",
9493 ntohl (s->server_vrf_id), format_ip6_address, s->dhcp_server);
9496 " Server Table-ID %d, Server Address %U",
9497 ntohl (s->server_vrf_id), format_ip4_address, s->dhcp_server);
9501 static void vl_api_dhcp_proxy_details_t_handler_json
9502 (vl_api_dhcp_proxy_details_t * mp)
9504 vat_main_t *vam = &vat_main;
9505 vat_json_node_t *node = NULL;
9506 u32 i, count = mp->count;
9508 struct in6_addr ip6;
9509 vl_api_dhcp_server_t *s;
9511 if (VAT_JSON_ARRAY != vam->json_tree.type)
9513 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9514 vat_json_init_array (&vam->json_tree);
9516 node = vat_json_array_add (&vam->json_tree);
9518 vat_json_init_object (node);
9519 vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
9520 vat_json_object_add_bytes (node, "vss-type", &mp->vss_type,
9521 sizeof (mp->vss_type));
9522 vat_json_object_add_string_copy (node, "vss-vpn-ascii-id",
9523 mp->vss_vpn_ascii_id);
9524 vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
9525 vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
9529 clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
9530 vat_json_object_add_ip6 (node, "src_address", ip6);
9534 clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
9535 vat_json_object_add_ip4 (node, "src_address", ip4);
9538 for (i = 0; i < count; i++)
9540 s = &mp->servers[i];
9542 vat_json_object_add_uint (node, "server-table-id",
9543 ntohl (s->server_vrf_id));
9547 clib_memcpy (&ip4, &s->dhcp_server, sizeof (ip4));
9548 vat_json_object_add_ip4 (node, "src_address", ip4);
9552 clib_memcpy (&ip6, &s->dhcp_server, sizeof (ip6));
9553 vat_json_object_add_ip6 (node, "server_address", ip6);
9559 api_dhcp_proxy_dump (vat_main_t * vam)
9561 unformat_input_t *i = vam->input;
9562 vl_api_control_ping_t *mp_ping;
9563 vl_api_dhcp_proxy_dump_t *mp;
9567 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9569 if (unformat (i, "ipv6"))
9573 clib_warning ("parse error '%U'", format_unformat_error, i);
9578 M (DHCP_PROXY_DUMP, mp);
9580 mp->is_ip6 = is_ipv6;
9583 /* Use a control ping for synchronization */
9584 MPING (CONTROL_PING, mp_ping);
9592 api_dhcp_proxy_set_vss (vat_main_t * vam)
9594 unformat_input_t *i = vam->input;
9595 vl_api_dhcp_proxy_set_vss_t *mp;
9599 u8 vss_type = VSS_TYPE_DEFAULT;
9600 u8 *vpn_ascii_id = 0;
9605 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9607 if (unformat (i, "tbl_id %d", &tbl_id))
9609 else if (unformat (i, "vpn_ascii_id %s", &vpn_ascii_id))
9610 vss_type = VSS_TYPE_ASCII;
9611 else if (unformat (i, "fib_id %d", &fib_id))
9612 vss_type = VSS_TYPE_VPN_ID;
9613 else if (unformat (i, "oui %d", &oui))
9614 vss_type = VSS_TYPE_VPN_ID;
9615 else if (unformat (i, "ipv6"))
9617 else if (unformat (i, "del"))
9625 errmsg ("missing tbl_id ");
9626 vec_free (vpn_ascii_id);
9630 if ((vpn_ascii_id) && (vec_len (vpn_ascii_id) > 128))
9632 errmsg ("vpn_ascii_id cannot be longer than 128 ");
9633 vec_free (vpn_ascii_id);
9637 M (DHCP_PROXY_SET_VSS, mp);
9638 mp->tbl_id = ntohl (tbl_id);
9639 mp->vss_type = vss_type;
9642 clib_memcpy (mp->vpn_ascii_id, vpn_ascii_id, vec_len (vpn_ascii_id));
9643 mp->vpn_ascii_id[vec_len (vpn_ascii_id)] = 0;
9645 mp->vpn_index = ntohl (fib_id);
9646 mp->oui = ntohl (oui);
9647 mp->is_ipv6 = is_ipv6;
9648 mp->is_add = is_add;
9653 vec_free (vpn_ascii_id);
9658 api_dhcp_client_config (vat_main_t * vam)
9660 unformat_input_t *i = vam->input;
9661 vl_api_dhcp_client_config_t *mp;
9663 u8 sw_if_index_set = 0;
9666 u8 disable_event = 0;
9669 /* Parse args required to build the message */
9670 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9672 if (unformat (i, "del"))
9675 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9676 sw_if_index_set = 1;
9677 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9678 sw_if_index_set = 1;
9679 else if (unformat (i, "hostname %s", &hostname))
9681 else if (unformat (i, "disable_event"))
9687 if (sw_if_index_set == 0)
9689 errmsg ("missing interface name or sw_if_index");
9693 if (vec_len (hostname) > 63)
9695 errmsg ("hostname too long");
9697 vec_add1 (hostname, 0);
9699 /* Construct the API message */
9700 M (DHCP_CLIENT_CONFIG, mp);
9702 mp->is_add = is_add;
9703 mp->client.sw_if_index = htonl (sw_if_index);
9704 clib_memcpy (mp->client.hostname, hostname, vec_len (hostname));
9705 vec_free (hostname);
9706 mp->client.want_dhcp_event = disable_event ? 0 : 1;
9707 mp->client.pid = htonl (getpid ());
9712 /* Wait for a reply, return good/bad news */
9718 api_set_ip_flow_hash (vat_main_t * vam)
9720 unformat_input_t *i = vam->input;
9721 vl_api_set_ip_flow_hash_t *mp;
9733 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9735 if (unformat (i, "vrf %d", &vrf_id))
9737 else if (unformat (i, "ipv6"))
9739 else if (unformat (i, "src"))
9741 else if (unformat (i, "dst"))
9743 else if (unformat (i, "sport"))
9745 else if (unformat (i, "dport"))
9747 else if (unformat (i, "proto"))
9749 else if (unformat (i, "reverse"))
9754 clib_warning ("parse error '%U'", format_unformat_error, i);
9759 if (vrf_id_set == 0)
9761 errmsg ("missing vrf id");
9765 M (SET_IP_FLOW_HASH, mp);
9771 mp->reverse = reverse;
9772 mp->vrf_id = ntohl (vrf_id);
9773 mp->is_ipv6 = is_ipv6;
9781 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
9783 unformat_input_t *i = vam->input;
9784 vl_api_sw_interface_ip6_enable_disable_t *mp;
9786 u8 sw_if_index_set = 0;
9790 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9792 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9793 sw_if_index_set = 1;
9794 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9795 sw_if_index_set = 1;
9796 else if (unformat (i, "enable"))
9798 else if (unformat (i, "disable"))
9802 clib_warning ("parse error '%U'", format_unformat_error, i);
9807 if (sw_if_index_set == 0)
9809 errmsg ("missing interface name or sw_if_index");
9813 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
9815 mp->sw_if_index = ntohl (sw_if_index);
9816 mp->enable = enable;
9824 api_ip6nd_proxy_add_del (vat_main_t * vam)
9826 unformat_input_t *i = vam->input;
9827 vl_api_ip6nd_proxy_add_del_t *mp;
9828 u32 sw_if_index = ~0;
9829 u8 v6_address_set = 0;
9830 vl_api_ip6_address_t v6address;
9834 /* Parse args required to build the message */
9835 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9837 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9839 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9841 else if (unformat (i, "%U", unformat_vl_api_ip6_address, &v6address))
9843 if (unformat (i, "del"))
9847 clib_warning ("parse error '%U'", format_unformat_error, i);
9852 if (sw_if_index == ~0)
9854 errmsg ("missing interface name or sw_if_index");
9857 if (!v6_address_set)
9859 errmsg ("no address set");
9863 /* Construct the API message */
9864 M (IP6ND_PROXY_ADD_DEL, mp);
9866 mp->is_del = is_del;
9867 mp->sw_if_index = ntohl (sw_if_index);
9868 clib_memcpy (mp->ip, v6address, sizeof (v6address));
9873 /* Wait for a reply, return good/bad news */
9879 api_ip6nd_proxy_dump (vat_main_t * vam)
9881 vl_api_ip6nd_proxy_dump_t *mp;
9882 vl_api_control_ping_t *mp_ping;
9885 M (IP6ND_PROXY_DUMP, mp);
9889 /* Use a control ping for synchronization */
9890 MPING (CONTROL_PING, mp_ping);
9897 static void vl_api_ip6nd_proxy_details_t_handler
9898 (vl_api_ip6nd_proxy_details_t * mp)
9900 vat_main_t *vam = &vat_main;
9902 print (vam->ofp, "host %U sw_if_index %d",
9903 format_vl_api_ip6_address, mp->ip, ntohl (mp->sw_if_index));
9906 static void vl_api_ip6nd_proxy_details_t_handler_json
9907 (vl_api_ip6nd_proxy_details_t * mp)
9909 vat_main_t *vam = &vat_main;
9910 struct in6_addr ip6;
9911 vat_json_node_t *node = NULL;
9913 if (VAT_JSON_ARRAY != vam->json_tree.type)
9915 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9916 vat_json_init_array (&vam->json_tree);
9918 node = vat_json_array_add (&vam->json_tree);
9920 vat_json_init_object (node);
9921 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9923 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
9924 vat_json_object_add_ip6 (node, "host", ip6);
9928 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
9930 unformat_input_t *i = vam->input;
9931 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
9933 u8 sw_if_index_set = 0;
9934 u8 v6_address_set = 0;
9935 vl_api_prefix_t pfx;
9937 u8 no_advertise = 0;
9939 u8 no_autoconfig = 0;
9942 u32 val_lifetime = 0;
9943 u32 pref_lifetime = 0;
9946 /* Parse args required to build the message */
9947 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9949 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9950 sw_if_index_set = 1;
9951 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9952 sw_if_index_set = 1;
9953 else if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
9955 else if (unformat (i, "val_life %d", &val_lifetime))
9957 else if (unformat (i, "pref_life %d", &pref_lifetime))
9959 else if (unformat (i, "def"))
9961 else if (unformat (i, "noadv"))
9963 else if (unformat (i, "offl"))
9965 else if (unformat (i, "noauto"))
9967 else if (unformat (i, "nolink"))
9969 else if (unformat (i, "isno"))
9973 clib_warning ("parse error '%U'", format_unformat_error, i);
9978 if (sw_if_index_set == 0)
9980 errmsg ("missing interface name or sw_if_index");
9983 if (!v6_address_set)
9985 errmsg ("no address set");
9989 /* Construct the API message */
9990 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
9992 mp->sw_if_index = ntohl (sw_if_index);
9993 clib_memcpy (&mp->prefix, &pfx, sizeof (pfx));
9994 mp->use_default = use_default;
9995 mp->no_advertise = no_advertise;
9996 mp->off_link = off_link;
9997 mp->no_autoconfig = no_autoconfig;
9998 mp->no_onlink = no_onlink;
10000 mp->val_lifetime = ntohl (val_lifetime);
10001 mp->pref_lifetime = ntohl (pref_lifetime);
10006 /* Wait for a reply, return good/bad news */
10012 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
10014 unformat_input_t *i = vam->input;
10015 vl_api_sw_interface_ip6nd_ra_config_t *mp;
10017 u8 sw_if_index_set = 0;
10022 u8 send_unicast = 0;
10025 u8 default_router = 0;
10026 u32 max_interval = 0;
10027 u32 min_interval = 0;
10029 u32 initial_count = 0;
10030 u32 initial_interval = 0;
10034 /* Parse args required to build the message */
10035 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10037 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10038 sw_if_index_set = 1;
10039 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10040 sw_if_index_set = 1;
10041 else if (unformat (i, "maxint %d", &max_interval))
10043 else if (unformat (i, "minint %d", &min_interval))
10045 else if (unformat (i, "life %d", &lifetime))
10047 else if (unformat (i, "count %d", &initial_count))
10049 else if (unformat (i, "interval %d", &initial_interval))
10051 else if (unformat (i, "suppress") || unformat (i, "surpress"))
10053 else if (unformat (i, "managed"))
10055 else if (unformat (i, "other"))
10057 else if (unformat (i, "ll"))
10059 else if (unformat (i, "send"))
10061 else if (unformat (i, "cease"))
10063 else if (unformat (i, "isno"))
10065 else if (unformat (i, "def"))
10066 default_router = 1;
10069 clib_warning ("parse error '%U'", format_unformat_error, i);
10074 if (sw_if_index_set == 0)
10076 errmsg ("missing interface name or sw_if_index");
10080 /* Construct the API message */
10081 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
10083 mp->sw_if_index = ntohl (sw_if_index);
10084 mp->max_interval = ntohl (max_interval);
10085 mp->min_interval = ntohl (min_interval);
10086 mp->lifetime = ntohl (lifetime);
10087 mp->initial_count = ntohl (initial_count);
10088 mp->initial_interval = ntohl (initial_interval);
10089 mp->suppress = suppress;
10090 mp->managed = managed;
10092 mp->ll_option = ll_option;
10093 mp->send_unicast = send_unicast;
10096 mp->default_router = default_router;
10101 /* Wait for a reply, return good/bad news */
10107 api_set_arp_neighbor_limit (vat_main_t * vam)
10109 unformat_input_t *i = vam->input;
10110 vl_api_set_arp_neighbor_limit_t *mp;
10116 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10118 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
10120 else if (unformat (i, "ipv6"))
10124 clib_warning ("parse error '%U'", format_unformat_error, i);
10129 if (limit_set == 0)
10131 errmsg ("missing limit value");
10135 M (SET_ARP_NEIGHBOR_LIMIT, mp);
10137 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
10138 mp->is_ipv6 = is_ipv6;
10146 api_l2_patch_add_del (vat_main_t * vam)
10148 unformat_input_t *i = vam->input;
10149 vl_api_l2_patch_add_del_t *mp;
10150 u32 rx_sw_if_index;
10151 u8 rx_sw_if_index_set = 0;
10152 u32 tx_sw_if_index;
10153 u8 tx_sw_if_index_set = 0;
10157 /* Parse args required to build the message */
10158 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10160 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
10161 rx_sw_if_index_set = 1;
10162 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
10163 tx_sw_if_index_set = 1;
10164 else if (unformat (i, "rx"))
10166 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10168 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10170 rx_sw_if_index_set = 1;
10175 else if (unformat (i, "tx"))
10177 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10179 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10181 tx_sw_if_index_set = 1;
10186 else if (unformat (i, "del"))
10192 if (rx_sw_if_index_set == 0)
10194 errmsg ("missing rx interface name or rx_sw_if_index");
10198 if (tx_sw_if_index_set == 0)
10200 errmsg ("missing tx interface name or tx_sw_if_index");
10204 M (L2_PATCH_ADD_DEL, mp);
10206 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
10207 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
10208 mp->is_add = is_add;
10216 u8 localsid_addr[16];
10225 api_sr_localsid_add_del (vat_main_t * vam)
10227 unformat_input_t *i = vam->input;
10228 vl_api_sr_localsid_add_del_t *mp;
10231 ip6_address_t localsid;
10235 u32 fib_table = ~(u32) 0;
10236 ip6_address_t nh_addr6;
10237 ip4_address_t nh_addr4;
10238 clib_memset (&nh_addr6, 0, sizeof (ip6_address_t));
10239 clib_memset (&nh_addr4, 0, sizeof (ip4_address_t));
10241 bool nexthop_set = 0;
10245 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10247 if (unformat (i, "del"))
10249 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
10250 else if (unformat (i, "next-hop %U", unformat_ip4_address, &nh_addr4))
10252 else if (unformat (i, "next-hop %U", unformat_ip6_address, &nh_addr6))
10254 else if (unformat (i, "behavior %u", &behavior));
10255 else if (unformat (i, "sw_if_index %u", &sw_if_index));
10256 else if (unformat (i, "fib-table %u", &fib_table));
10257 else if (unformat (i, "end.psp %u", &behavior));
10262 M (SR_LOCALSID_ADD_DEL, mp);
10264 clib_memcpy (mp->localsid.addr, &localsid, sizeof (mp->localsid));
10267 clib_memcpy (mp->nh_addr6, &nh_addr6, sizeof (mp->nh_addr6));
10268 clib_memcpy (mp->nh_addr4, &nh_addr4, sizeof (mp->nh_addr4));
10270 mp->behavior = behavior;
10271 mp->sw_if_index = ntohl (sw_if_index);
10272 mp->fib_table = ntohl (fib_table);
10273 mp->end_psp = end_psp;
10274 mp->is_del = is_del;
10282 api_ioam_enable (vat_main_t * vam)
10284 unformat_input_t *input = vam->input;
10285 vl_api_ioam_enable_t *mp;
10287 int has_trace_option = 0;
10288 int has_pot_option = 0;
10289 int has_seqno_option = 0;
10290 int has_analyse_option = 0;
10293 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10295 if (unformat (input, "trace"))
10296 has_trace_option = 1;
10297 else if (unformat (input, "pot"))
10298 has_pot_option = 1;
10299 else if (unformat (input, "seqno"))
10300 has_seqno_option = 1;
10301 else if (unformat (input, "analyse"))
10302 has_analyse_option = 1;
10306 M (IOAM_ENABLE, mp);
10307 mp->id = htons (id);
10308 mp->seqno = has_seqno_option;
10309 mp->analyse = has_analyse_option;
10310 mp->pot_enable = has_pot_option;
10311 mp->trace_enable = has_trace_option;
10320 api_ioam_disable (vat_main_t * vam)
10322 vl_api_ioam_disable_t *mp;
10325 M (IOAM_DISABLE, mp);
10331 #define foreach_tcp_proto_field \
10335 #define foreach_udp_proto_field \
10339 #define foreach_ip4_proto_field \
10351 u16 src_port, dst_port;
10354 #if VPP_API_TEST_BUILTIN == 0
10356 unformat_tcp_mask (unformat_input_t * input, va_list * args)
10358 u8 **maskp = va_arg (*args, u8 **);
10360 u8 found_something = 0;
10363 #define _(a) u8 a=0;
10364 foreach_tcp_proto_field;
10367 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10370 #define _(a) else if (unformat (input, #a)) a=1;
10371 foreach_tcp_proto_field
10377 #define _(a) found_something += a;
10378 foreach_tcp_proto_field;
10381 if (found_something == 0)
10384 vec_validate (mask, sizeof (*tcp) - 1);
10386 tcp = (tcp_header_t *) mask;
10388 #define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
10389 foreach_tcp_proto_field;
10397 unformat_udp_mask (unformat_input_t * input, va_list * args)
10399 u8 **maskp = va_arg (*args, u8 **);
10401 u8 found_something = 0;
10404 #define _(a) u8 a=0;
10405 foreach_udp_proto_field;
10408 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10411 #define _(a) else if (unformat (input, #a)) a=1;
10412 foreach_udp_proto_field
10418 #define _(a) found_something += a;
10419 foreach_udp_proto_field;
10422 if (found_something == 0)
10425 vec_validate (mask, sizeof (*udp) - 1);
10427 udp = (udp_header_t *) mask;
10429 #define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
10430 foreach_udp_proto_field;
10438 unformat_l4_mask (unformat_input_t * input, va_list * args)
10440 u8 **maskp = va_arg (*args, u8 **);
10441 u16 src_port = 0, dst_port = 0;
10442 tcpudp_header_t *tcpudp;
10444 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10446 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
10448 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
10450 else if (unformat (input, "src_port"))
10452 else if (unformat (input, "dst_port"))
10458 if (!src_port && !dst_port)
10462 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
10464 tcpudp = (tcpudp_header_t *) mask;
10465 tcpudp->src_port = src_port;
10466 tcpudp->dst_port = dst_port;
10474 unformat_ip4_mask (unformat_input_t * input, va_list * args)
10476 u8 **maskp = va_arg (*args, u8 **);
10478 u8 found_something = 0;
10481 #define _(a) u8 a=0;
10482 foreach_ip4_proto_field;
10488 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10490 if (unformat (input, "version"))
10492 else if (unformat (input, "hdr_length"))
10494 else if (unformat (input, "src"))
10496 else if (unformat (input, "dst"))
10498 else if (unformat (input, "proto"))
10501 #define _(a) else if (unformat (input, #a)) a=1;
10502 foreach_ip4_proto_field
10508 #define _(a) found_something += a;
10509 foreach_ip4_proto_field;
10512 if (found_something == 0)
10515 vec_validate (mask, sizeof (*ip) - 1);
10517 ip = (ip4_header_t *) mask;
10519 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
10520 foreach_ip4_proto_field;
10523 ip->ip_version_and_header_length = 0;
10526 ip->ip_version_and_header_length |= 0xF0;
10529 ip->ip_version_and_header_length |= 0x0F;
10535 #define foreach_ip6_proto_field \
10538 _(payload_length) \
10543 unformat_ip6_mask (unformat_input_t * input, va_list * args)
10545 u8 **maskp = va_arg (*args, u8 **);
10547 u8 found_something = 0;
10549 u32 ip_version_traffic_class_and_flow_label;
10551 #define _(a) u8 a=0;
10552 foreach_ip6_proto_field;
10555 u8 traffic_class = 0;
10558 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10560 if (unformat (input, "version"))
10562 else if (unformat (input, "traffic-class"))
10564 else if (unformat (input, "flow-label"))
10566 else if (unformat (input, "src"))
10568 else if (unformat (input, "dst"))
10570 else if (unformat (input, "proto"))
10573 #define _(a) else if (unformat (input, #a)) a=1;
10574 foreach_ip6_proto_field
10580 #define _(a) found_something += a;
10581 foreach_ip6_proto_field;
10584 if (found_something == 0)
10587 vec_validate (mask, sizeof (*ip) - 1);
10589 ip = (ip6_header_t *) mask;
10591 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
10592 foreach_ip6_proto_field;
10595 ip_version_traffic_class_and_flow_label = 0;
10598 ip_version_traffic_class_and_flow_label |= 0xF0000000;
10601 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
10604 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
10606 ip->ip_version_traffic_class_and_flow_label =
10607 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10614 unformat_l3_mask (unformat_input_t * input, va_list * args)
10616 u8 **maskp = va_arg (*args, u8 **);
10618 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10620 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
10622 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
10631 unformat_l2_mask (unformat_input_t * input, va_list * args)
10633 u8 **maskp = va_arg (*args, u8 **);
10640 u8 ignore_tag1 = 0;
10641 u8 ignore_tag2 = 0;
10648 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10650 if (unformat (input, "src"))
10652 else if (unformat (input, "dst"))
10654 else if (unformat (input, "proto"))
10656 else if (unformat (input, "tag1"))
10658 else if (unformat (input, "tag2"))
10660 else if (unformat (input, "ignore-tag1"))
10662 else if (unformat (input, "ignore-tag2"))
10664 else if (unformat (input, "cos1"))
10666 else if (unformat (input, "cos2"))
10668 else if (unformat (input, "dot1q"))
10670 else if (unformat (input, "dot1ad"))
10675 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
10676 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10679 if (tag1 || ignore_tag1 || cos1 || dot1q)
10681 if (tag2 || ignore_tag2 || cos2 || dot1ad)
10684 vec_validate (mask, len - 1);
10687 clib_memset (mask, 0xff, 6);
10690 clib_memset (mask + 6, 0xff, 6);
10692 if (tag2 || dot1ad)
10694 /* inner vlan tag */
10703 mask[21] = mask[20] = 0xff;
10724 mask[16] = mask[17] = 0xff;
10734 mask[12] = mask[13] = 0xff;
10741 unformat_classify_mask (unformat_input_t * input, va_list * args)
10743 u8 **maskp = va_arg (*args, u8 **);
10744 u32 *skipp = va_arg (*args, u32 *);
10745 u32 *matchp = va_arg (*args, u32 *);
10753 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10755 if (unformat (input, "hex %U", unformat_hex_string, &mask))
10757 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
10759 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
10761 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
10775 if (mask || l2 || l3 || l4)
10777 if (l2 || l3 || l4)
10779 /* "With a free Ethernet header in every package" */
10781 vec_validate (l2, 13);
10785 vec_append (mask, l3);
10790 vec_append (mask, l4);
10795 /* Scan forward looking for the first significant mask octet */
10796 for (i = 0; i < vec_len (mask); i++)
10800 /* compute (skip, match) params */
10801 *skipp = i / sizeof (u32x4);
10802 vec_delete (mask, *skipp * sizeof (u32x4), 0);
10804 /* Pad mask to an even multiple of the vector size */
10805 while (vec_len (mask) % sizeof (u32x4))
10806 vec_add1 (mask, 0);
10808 match = vec_len (mask) / sizeof (u32x4);
10810 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
10812 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
10813 if (*tmp || *(tmp + 1))
10818 clib_warning ("BUG: match 0");
10820 _vec_len (mask) = match * sizeof (u32x4);
10830 #endif /* VPP_API_TEST_BUILTIN */
10832 #define foreach_l2_next \
10834 _(ethernet, ETHERNET_INPUT) \
10835 _(ip4, IP4_INPUT) \
10839 unformat_l2_next_index (unformat_input_t * input, va_list * args)
10841 u32 *miss_next_indexp = va_arg (*args, u32 *);
10842 u32 next_index = 0;
10846 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
10850 if (unformat (input, "%d", &tmp))
10859 *miss_next_indexp = next_index;
10863 #define foreach_ip_next \
10866 _(rewrite, REWRITE)
10869 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
10871 u32 *miss_next_indexp = va_arg (*args, u32 *);
10872 u32 next_index = 0;
10876 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
10880 if (unformat (input, "%d", &tmp))
10889 *miss_next_indexp = next_index;
10893 #define foreach_acl_next \
10897 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
10899 u32 *miss_next_indexp = va_arg (*args, u32 *);
10900 u32 next_index = 0;
10904 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
10908 if (unformat (input, "permit"))
10913 else if (unformat (input, "%d", &tmp))
10922 *miss_next_indexp = next_index;
10927 unformat_policer_precolor (unformat_input_t * input, va_list * args)
10929 u32 *r = va_arg (*args, u32 *);
10931 if (unformat (input, "conform-color"))
10932 *r = POLICE_CONFORM;
10933 else if (unformat (input, "exceed-color"))
10934 *r = POLICE_EXCEED;
10942 api_classify_add_del_table (vat_main_t * vam)
10944 unformat_input_t *i = vam->input;
10945 vl_api_classify_add_del_table_t *mp;
10952 u32 table_index = ~0;
10953 u32 next_table_index = ~0;
10954 u32 miss_next_index = ~0;
10955 u32 memory_size = 32 << 20;
10957 u32 current_data_flag = 0;
10958 int current_data_offset = 0;
10961 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10963 if (unformat (i, "del"))
10965 else if (unformat (i, "del-chain"))
10970 else if (unformat (i, "buckets %d", &nbuckets))
10972 else if (unformat (i, "memory_size %d", &memory_size))
10974 else if (unformat (i, "skip %d", &skip))
10976 else if (unformat (i, "match %d", &match))
10978 else if (unformat (i, "table %d", &table_index))
10980 else if (unformat (i, "mask %U", unformat_classify_mask,
10981 &mask, &skip, &match))
10983 else if (unformat (i, "next-table %d", &next_table_index))
10985 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
10988 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
10991 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
10994 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
10996 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
11002 if (is_add && mask == 0)
11004 errmsg ("Mask required");
11008 if (is_add && skip == ~0)
11010 errmsg ("skip count required");
11014 if (is_add && match == ~0)
11016 errmsg ("match count required");
11020 if (!is_add && table_index == ~0)
11022 errmsg ("table index required for delete");
11026 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
11028 mp->is_add = is_add;
11029 mp->del_chain = del_chain;
11030 mp->table_index = ntohl (table_index);
11031 mp->nbuckets = ntohl (nbuckets);
11032 mp->memory_size = ntohl (memory_size);
11033 mp->skip_n_vectors = ntohl (skip);
11034 mp->match_n_vectors = ntohl (match);
11035 mp->next_table_index = ntohl (next_table_index);
11036 mp->miss_next_index = ntohl (miss_next_index);
11037 mp->current_data_flag = ntohl (current_data_flag);
11038 mp->current_data_offset = ntohl (current_data_offset);
11039 mp->mask_len = ntohl (vec_len (mask));
11040 clib_memcpy (mp->mask, mask, vec_len (mask));
11049 #if VPP_API_TEST_BUILTIN == 0
11051 unformat_l4_match (unformat_input_t * input, va_list * args)
11053 u8 **matchp = va_arg (*args, u8 **);
11055 u8 *proto_header = 0;
11061 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11063 if (unformat (input, "src_port %d", &src_port))
11065 else if (unformat (input, "dst_port %d", &dst_port))
11071 h.src_port = clib_host_to_net_u16 (src_port);
11072 h.dst_port = clib_host_to_net_u16 (dst_port);
11073 vec_validate (proto_header, sizeof (h) - 1);
11074 memcpy (proto_header, &h, sizeof (h));
11076 *matchp = proto_header;
11082 unformat_ip4_match (unformat_input_t * input, va_list * args)
11084 u8 **matchp = va_arg (*args, u8 **);
11089 int hdr_length = 0;
11090 u32 hdr_length_val;
11091 int src = 0, dst = 0;
11092 ip4_address_t src_val, dst_val;
11099 int fragment_id = 0;
11100 u32 fragment_id_val;
11106 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11108 if (unformat (input, "version %d", &version_val))
11110 else if (unformat (input, "hdr_length %d", &hdr_length_val))
11112 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
11114 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
11116 else if (unformat (input, "proto %d", &proto_val))
11118 else if (unformat (input, "tos %d", &tos_val))
11120 else if (unformat (input, "length %d", &length_val))
11122 else if (unformat (input, "fragment_id %d", &fragment_id_val))
11124 else if (unformat (input, "ttl %d", &ttl_val))
11126 else if (unformat (input, "checksum %d", &checksum_val))
11132 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
11133 + ttl + checksum == 0)
11137 * Aligned because we use the real comparison functions
11139 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11141 ip = (ip4_header_t *) match;
11143 /* These are realistically matched in practice */
11145 ip->src_address.as_u32 = src_val.as_u32;
11148 ip->dst_address.as_u32 = dst_val.as_u32;
11151 ip->protocol = proto_val;
11154 /* These are not, but they're included for completeness */
11156 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
11159 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
11165 ip->length = clib_host_to_net_u16 (length_val);
11171 ip->checksum = clib_host_to_net_u16 (checksum_val);
11178 unformat_ip6_match (unformat_input_t * input, va_list * args)
11180 u8 **matchp = va_arg (*args, u8 **);
11185 u8 traffic_class = 0;
11186 u32 traffic_class_val = 0;
11189 int src = 0, dst = 0;
11190 ip6_address_t src_val, dst_val;
11193 int payload_length = 0;
11194 u32 payload_length_val;
11197 u32 ip_version_traffic_class_and_flow_label;
11199 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11201 if (unformat (input, "version %d", &version_val))
11203 else if (unformat (input, "traffic_class %d", &traffic_class_val))
11205 else if (unformat (input, "flow_label %d", &flow_label_val))
11207 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
11209 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
11211 else if (unformat (input, "proto %d", &proto_val))
11213 else if (unformat (input, "payload_length %d", &payload_length_val))
11214 payload_length = 1;
11215 else if (unformat (input, "hop_limit %d", &hop_limit_val))
11221 if (version + traffic_class + flow_label + src + dst + proto +
11222 payload_length + hop_limit == 0)
11226 * Aligned because we use the real comparison functions
11228 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11230 ip = (ip6_header_t *) match;
11233 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
11236 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
11239 ip->protocol = proto_val;
11241 ip_version_traffic_class_and_flow_label = 0;
11244 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
11247 ip_version_traffic_class_and_flow_label |=
11248 (traffic_class_val & 0xFF) << 20;
11251 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
11253 ip->ip_version_traffic_class_and_flow_label =
11254 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
11256 if (payload_length)
11257 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
11260 ip->hop_limit = hop_limit_val;
11267 unformat_l3_match (unformat_input_t * input, va_list * args)
11269 u8 **matchp = va_arg (*args, u8 **);
11271 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11273 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
11275 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
11284 unformat_vlan_tag (unformat_input_t * input, va_list * args)
11286 u8 *tagp = va_arg (*args, u8 *);
11289 if (unformat (input, "%d", &tag))
11291 tagp[0] = (tag >> 8) & 0x0F;
11292 tagp[1] = tag & 0xFF;
11300 unformat_l2_match (unformat_input_t * input, va_list * args)
11302 u8 **matchp = va_arg (*args, u8 **);
11315 u8 ignore_tag1 = 0;
11316 u8 ignore_tag2 = 0;
11322 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11324 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
11327 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
11329 else if (unformat (input, "proto %U",
11330 unformat_ethernet_type_host_byte_order, &proto_val))
11332 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
11334 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
11336 else if (unformat (input, "ignore-tag1"))
11338 else if (unformat (input, "ignore-tag2"))
11340 else if (unformat (input, "cos1 %d", &cos1_val))
11342 else if (unformat (input, "cos2 %d", &cos2_val))
11347 if ((src + dst + proto + tag1 + tag2 +
11348 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
11351 if (tag1 || ignore_tag1 || cos1)
11353 if (tag2 || ignore_tag2 || cos2)
11356 vec_validate_aligned (match, len - 1, sizeof (u32x4));
11359 clib_memcpy (match, dst_val, 6);
11362 clib_memcpy (match + 6, src_val, 6);
11366 /* inner vlan tag */
11367 match[19] = tag2_val[1];
11368 match[18] = tag2_val[0];
11370 match[18] |= (cos2_val & 0x7) << 5;
11373 match[21] = proto_val & 0xff;
11374 match[20] = proto_val >> 8;
11378 match[15] = tag1_val[1];
11379 match[14] = tag1_val[0];
11382 match[14] |= (cos1_val & 0x7) << 5;
11388 match[15] = tag1_val[1];
11389 match[14] = tag1_val[0];
11392 match[17] = proto_val & 0xff;
11393 match[16] = proto_val >> 8;
11396 match[14] |= (cos1_val & 0x7) << 5;
11402 match[18] |= (cos2_val & 0x7) << 5;
11404 match[14] |= (cos1_val & 0x7) << 5;
11407 match[13] = proto_val & 0xff;
11408 match[12] = proto_val >> 8;
11416 unformat_qos_source (unformat_input_t * input, va_list * args)
11418 int *qs = va_arg (*args, int *);
11420 if (unformat (input, "ip"))
11421 *qs = QOS_SOURCE_IP;
11422 else if (unformat (input, "mpls"))
11423 *qs = QOS_SOURCE_MPLS;
11424 else if (unformat (input, "ext"))
11425 *qs = QOS_SOURCE_EXT;
11426 else if (unformat (input, "vlan"))
11427 *qs = QOS_SOURCE_VLAN;
11436 api_unformat_classify_match (unformat_input_t * input, va_list * args)
11438 u8 **matchp = va_arg (*args, u8 **);
11439 u32 skip_n_vectors = va_arg (*args, u32);
11440 u32 match_n_vectors = va_arg (*args, u32);
11447 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11449 if (unformat (input, "hex %U", unformat_hex_string, &match))
11451 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
11453 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
11455 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
11469 if (match || l2 || l3 || l4)
11471 if (l2 || l3 || l4)
11473 /* "Win a free Ethernet header in every packet" */
11475 vec_validate_aligned (l2, 13, sizeof (u32x4));
11479 vec_append_aligned (match, l3, sizeof (u32x4));
11484 vec_append_aligned (match, l4, sizeof (u32x4));
11489 /* Make sure the vector is big enough even if key is all 0's */
11490 vec_validate_aligned
11491 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
11494 /* Set size, include skipped vectors */
11495 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
11506 api_classify_add_del_session (vat_main_t * vam)
11508 unformat_input_t *i = vam->input;
11509 vl_api_classify_add_del_session_t *mp;
11511 u32 table_index = ~0;
11512 u32 hit_next_index = ~0;
11513 u32 opaque_index = ~0;
11516 u32 skip_n_vectors = 0;
11517 u32 match_n_vectors = 0;
11523 * Warning: you have to supply skip_n and match_n
11524 * because the API client cant simply look at the classify
11528 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11530 if (unformat (i, "del"))
11532 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
11535 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
11538 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
11541 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
11543 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
11545 else if (unformat (i, "opaque-index %d", &opaque_index))
11547 else if (unformat (i, "skip_n %d", &skip_n_vectors))
11549 else if (unformat (i, "match_n %d", &match_n_vectors))
11551 else if (unformat (i, "match %U", api_unformat_classify_match,
11552 &match, skip_n_vectors, match_n_vectors))
11554 else if (unformat (i, "advance %d", &advance))
11556 else if (unformat (i, "table-index %d", &table_index))
11558 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
11560 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
11562 else if (unformat (i, "action %d", &action))
11564 else if (unformat (i, "metadata %d", &metadata))
11570 if (table_index == ~0)
11572 errmsg ("Table index required");
11576 if (is_add && match == 0)
11578 errmsg ("Match value required");
11582 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
11584 mp->is_add = is_add;
11585 mp->table_index = ntohl (table_index);
11586 mp->hit_next_index = ntohl (hit_next_index);
11587 mp->opaque_index = ntohl (opaque_index);
11588 mp->advance = ntohl (advance);
11589 mp->action = action;
11590 mp->metadata = ntohl (metadata);
11591 mp->match_len = ntohl (vec_len (match));
11592 clib_memcpy (mp->match, match, vec_len (match));
11601 api_classify_set_interface_ip_table (vat_main_t * vam)
11603 unformat_input_t *i = vam->input;
11604 vl_api_classify_set_interface_ip_table_t *mp;
11606 int sw_if_index_set;
11607 u32 table_index = ~0;
11611 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11613 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11614 sw_if_index_set = 1;
11615 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11616 sw_if_index_set = 1;
11617 else if (unformat (i, "table %d", &table_index))
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_IP_TABLE, mp);
11635 mp->sw_if_index = ntohl (sw_if_index);
11636 mp->table_index = ntohl (table_index);
11637 mp->is_ipv6 = is_ipv6;
11645 api_classify_set_interface_l2_tables (vat_main_t * vam)
11647 unformat_input_t *i = vam->input;
11648 vl_api_classify_set_interface_l2_tables_t *mp;
11650 int sw_if_index_set;
11651 u32 ip4_table_index = ~0;
11652 u32 ip6_table_index = ~0;
11653 u32 other_table_index = ~0;
11657 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11659 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11660 sw_if_index_set = 1;
11661 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11662 sw_if_index_set = 1;
11663 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11665 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11667 else if (unformat (i, "other-table %d", &other_table_index))
11669 else if (unformat (i, "is-input %d", &is_input))
11673 clib_warning ("parse error '%U'", format_unformat_error, i);
11678 if (sw_if_index_set == 0)
11680 errmsg ("missing interface name or sw_if_index");
11685 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
11687 mp->sw_if_index = ntohl (sw_if_index);
11688 mp->ip4_table_index = ntohl (ip4_table_index);
11689 mp->ip6_table_index = ntohl (ip6_table_index);
11690 mp->other_table_index = ntohl (other_table_index);
11691 mp->is_input = (u8) is_input;
11699 api_set_ipfix_exporter (vat_main_t * vam)
11701 unformat_input_t *i = vam->input;
11702 vl_api_set_ipfix_exporter_t *mp;
11703 ip4_address_t collector_address;
11704 u8 collector_address_set = 0;
11705 u32 collector_port = ~0;
11706 ip4_address_t src_address;
11707 u8 src_address_set = 0;
11710 u32 template_interval = ~0;
11711 u8 udp_checksum = 0;
11714 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11716 if (unformat (i, "collector_address %U", unformat_ip4_address,
11717 &collector_address))
11718 collector_address_set = 1;
11719 else if (unformat (i, "collector_port %d", &collector_port))
11721 else if (unformat (i, "src_address %U", unformat_ip4_address,
11723 src_address_set = 1;
11724 else if (unformat (i, "vrf_id %d", &vrf_id))
11726 else if (unformat (i, "path_mtu %d", &path_mtu))
11728 else if (unformat (i, "template_interval %d", &template_interval))
11730 else if (unformat (i, "udp_checksum"))
11736 if (collector_address_set == 0)
11738 errmsg ("collector_address required");
11742 if (src_address_set == 0)
11744 errmsg ("src_address required");
11748 M (SET_IPFIX_EXPORTER, mp);
11750 memcpy (mp->collector_address, collector_address.data,
11751 sizeof (collector_address.data));
11752 mp->collector_port = htons ((u16) collector_port);
11753 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
11754 mp->vrf_id = htonl (vrf_id);
11755 mp->path_mtu = htonl (path_mtu);
11756 mp->template_interval = htonl (template_interval);
11757 mp->udp_checksum = udp_checksum;
11765 api_set_ipfix_classify_stream (vat_main_t * vam)
11767 unformat_input_t *i = vam->input;
11768 vl_api_set_ipfix_classify_stream_t *mp;
11770 u32 src_port = UDP_DST_PORT_ipfix;
11773 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11775 if (unformat (i, "domain %d", &domain_id))
11777 else if (unformat (i, "src_port %d", &src_port))
11781 errmsg ("unknown input `%U'", format_unformat_error, i);
11786 M (SET_IPFIX_CLASSIFY_STREAM, mp);
11788 mp->domain_id = htonl (domain_id);
11789 mp->src_port = htons ((u16) src_port);
11797 api_ipfix_classify_table_add_del (vat_main_t * vam)
11799 unformat_input_t *i = vam->input;
11800 vl_api_ipfix_classify_table_add_del_t *mp;
11802 u32 classify_table_index = ~0;
11804 u8 transport_protocol = 255;
11807 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11809 if (unformat (i, "add"))
11811 else if (unformat (i, "del"))
11813 else if (unformat (i, "table %d", &classify_table_index))
11815 else if (unformat (i, "ip4"))
11817 else if (unformat (i, "ip6"))
11819 else if (unformat (i, "tcp"))
11820 transport_protocol = 6;
11821 else if (unformat (i, "udp"))
11822 transport_protocol = 17;
11825 errmsg ("unknown input `%U'", format_unformat_error, i);
11832 errmsg ("expecting: add|del");
11835 if (classify_table_index == ~0)
11837 errmsg ("classifier table not specified");
11840 if (ip_version == 0)
11842 errmsg ("IP version not specified");
11846 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
11848 mp->is_add = is_add;
11849 mp->table_id = htonl (classify_table_index);
11850 mp->ip_version = ip_version;
11851 mp->transport_protocol = transport_protocol;
11859 api_get_node_index (vat_main_t * vam)
11861 unformat_input_t *i = vam->input;
11862 vl_api_get_node_index_t *mp;
11866 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11868 if (unformat (i, "node %s", &name))
11875 errmsg ("node name required");
11878 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11880 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11884 M (GET_NODE_INDEX, mp);
11885 clib_memcpy (mp->node_name, name, vec_len (name));
11894 api_get_next_index (vat_main_t * vam)
11896 unformat_input_t *i = vam->input;
11897 vl_api_get_next_index_t *mp;
11898 u8 *node_name = 0, *next_node_name = 0;
11901 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11903 if (unformat (i, "node-name %s", &node_name))
11905 else if (unformat (i, "next-node-name %s", &next_node_name))
11909 if (node_name == 0)
11911 errmsg ("node name required");
11914 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
11916 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11920 if (next_node_name == 0)
11922 errmsg ("next node name required");
11925 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
11927 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
11931 M (GET_NEXT_INDEX, mp);
11932 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
11933 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
11934 vec_free (node_name);
11935 vec_free (next_node_name);
11943 api_add_node_next (vat_main_t * vam)
11945 unformat_input_t *i = vam->input;
11946 vl_api_add_node_next_t *mp;
11951 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11953 if (unformat (i, "node %s", &name))
11955 else if (unformat (i, "next %s", &next))
11962 errmsg ("node name required");
11965 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11967 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11972 errmsg ("next node required");
11975 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
11977 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
11981 M (ADD_NODE_NEXT, mp);
11982 clib_memcpy (mp->node_name, name, vec_len (name));
11983 clib_memcpy (mp->next_name, next, vec_len (next));
11993 api_l2tpv3_create_tunnel (vat_main_t * vam)
11995 unformat_input_t *i = vam->input;
11996 ip6_address_t client_address, our_address;
11997 int client_address_set = 0;
11998 int our_address_set = 0;
11999 u32 local_session_id = 0;
12000 u32 remote_session_id = 0;
12001 u64 local_cookie = 0;
12002 u64 remote_cookie = 0;
12003 u8 l2_sublayer_present = 0;
12004 vl_api_l2tpv3_create_tunnel_t *mp;
12007 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12009 if (unformat (i, "client_address %U", unformat_ip6_address,
12011 client_address_set = 1;
12012 else if (unformat (i, "our_address %U", unformat_ip6_address,
12014 our_address_set = 1;
12015 else if (unformat (i, "local_session_id %d", &local_session_id))
12017 else if (unformat (i, "remote_session_id %d", &remote_session_id))
12019 else if (unformat (i, "local_cookie %lld", &local_cookie))
12021 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
12023 else if (unformat (i, "l2-sublayer-present"))
12024 l2_sublayer_present = 1;
12029 if (client_address_set == 0)
12031 errmsg ("client_address required");
12035 if (our_address_set == 0)
12037 errmsg ("our_address required");
12041 M (L2TPV3_CREATE_TUNNEL, mp);
12043 clib_memcpy (mp->client_address, client_address.as_u8,
12044 sizeof (mp->client_address));
12046 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
12048 mp->local_session_id = ntohl (local_session_id);
12049 mp->remote_session_id = ntohl (remote_session_id);
12050 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
12051 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
12052 mp->l2_sublayer_present = l2_sublayer_present;
12061 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
12063 unformat_input_t *i = vam->input;
12065 u8 sw_if_index_set = 0;
12066 u64 new_local_cookie = 0;
12067 u64 new_remote_cookie = 0;
12068 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
12071 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12073 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12074 sw_if_index_set = 1;
12075 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12076 sw_if_index_set = 1;
12077 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
12079 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
12085 if (sw_if_index_set == 0)
12087 errmsg ("missing interface name or sw_if_index");
12091 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
12093 mp->sw_if_index = ntohl (sw_if_index);
12094 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
12095 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
12103 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
12105 unformat_input_t *i = vam->input;
12106 vl_api_l2tpv3_interface_enable_disable_t *mp;
12108 u8 sw_if_index_set = 0;
12109 u8 enable_disable = 1;
12112 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12114 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12115 sw_if_index_set = 1;
12116 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12117 sw_if_index_set = 1;
12118 else if (unformat (i, "enable"))
12119 enable_disable = 1;
12120 else if (unformat (i, "disable"))
12121 enable_disable = 0;
12126 if (sw_if_index_set == 0)
12128 errmsg ("missing interface name or sw_if_index");
12132 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
12134 mp->sw_if_index = ntohl (sw_if_index);
12135 mp->enable_disable = enable_disable;
12143 api_l2tpv3_set_lookup_key (vat_main_t * vam)
12145 unformat_input_t *i = vam->input;
12146 vl_api_l2tpv3_set_lookup_key_t *mp;
12150 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12152 if (unformat (i, "lookup_v6_src"))
12153 key = L2T_LOOKUP_SRC_ADDRESS;
12154 else if (unformat (i, "lookup_v6_dst"))
12155 key = L2T_LOOKUP_DST_ADDRESS;
12156 else if (unformat (i, "lookup_session_id"))
12157 key = L2T_LOOKUP_SESSION_ID;
12162 if (key == (u8) ~ 0)
12164 errmsg ("l2tp session lookup key unset");
12168 M (L2TPV3_SET_LOOKUP_KEY, mp);
12177 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
12178 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12180 vat_main_t *vam = &vat_main;
12182 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
12183 format_ip6_address, mp->our_address,
12184 format_ip6_address, mp->client_address,
12185 clib_net_to_host_u32 (mp->sw_if_index));
12188 " local cookies %016llx %016llx remote cookie %016llx",
12189 clib_net_to_host_u64 (mp->local_cookie[0]),
12190 clib_net_to_host_u64 (mp->local_cookie[1]),
12191 clib_net_to_host_u64 (mp->remote_cookie));
12193 print (vam->ofp, " local session-id %d remote session-id %d",
12194 clib_net_to_host_u32 (mp->local_session_id),
12195 clib_net_to_host_u32 (mp->remote_session_id));
12197 print (vam->ofp, " l2 specific sublayer %s\n",
12198 mp->l2_sublayer_present ? "preset" : "absent");
12202 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
12203 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12205 vat_main_t *vam = &vat_main;
12206 vat_json_node_t *node = NULL;
12207 struct in6_addr addr;
12209 if (VAT_JSON_ARRAY != vam->json_tree.type)
12211 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12212 vat_json_init_array (&vam->json_tree);
12214 node = vat_json_array_add (&vam->json_tree);
12216 vat_json_init_object (node);
12218 clib_memcpy (&addr, mp->our_address, sizeof (addr));
12219 vat_json_object_add_ip6 (node, "our_address", addr);
12220 clib_memcpy (&addr, mp->client_address, sizeof (addr));
12221 vat_json_object_add_ip6 (node, "client_address", addr);
12223 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
12224 vat_json_init_array (lc);
12225 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
12226 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
12227 vat_json_object_add_uint (node, "remote_cookie",
12228 clib_net_to_host_u64 (mp->remote_cookie));
12230 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
12231 vat_json_object_add_uint (node, "local_session_id",
12232 clib_net_to_host_u32 (mp->local_session_id));
12233 vat_json_object_add_uint (node, "remote_session_id",
12234 clib_net_to_host_u32 (mp->remote_session_id));
12235 vat_json_object_add_string_copy (node, "l2_sublayer",
12236 mp->l2_sublayer_present ? (u8 *) "present"
12237 : (u8 *) "absent");
12241 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
12243 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
12244 vl_api_control_ping_t *mp_ping;
12247 /* Get list of l2tpv3-tunnel interfaces */
12248 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
12251 /* Use a control ping for synchronization */
12252 MPING (CONTROL_PING, mp_ping);
12260 static void vl_api_sw_interface_tap_v2_details_t_handler
12261 (vl_api_sw_interface_tap_v2_details_t * mp)
12263 vat_main_t *vam = &vat_main;
12265 u8 *ip4 = format (0, "%U/%d", format_ip4_address, mp->host_ip4_addr,
12266 mp->host_ip4_prefix_len);
12267 u8 *ip6 = format (0, "%U/%d", format_ip6_address, mp->host_ip6_addr,
12268 mp->host_ip6_prefix_len);
12271 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s 0x%-08x",
12272 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
12273 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
12274 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
12275 mp->host_bridge, ip4, ip6, ntohl (mp->tap_flags));
12281 static void vl_api_sw_interface_tap_v2_details_t_handler_json
12282 (vl_api_sw_interface_tap_v2_details_t * mp)
12284 vat_main_t *vam = &vat_main;
12285 vat_json_node_t *node = NULL;
12287 if (VAT_JSON_ARRAY != vam->json_tree.type)
12289 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12290 vat_json_init_array (&vam->json_tree);
12292 node = vat_json_array_add (&vam->json_tree);
12294 vat_json_init_object (node);
12295 vat_json_object_add_uint (node, "id", ntohl (mp->id));
12296 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12297 vat_json_object_add_uint (node, "tap_flags", ntohl (mp->tap_flags));
12298 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
12299 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
12300 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
12301 vat_json_object_add_string_copy (node, "host_mac_addr",
12302 format (0, "%U", format_ethernet_address,
12303 &mp->host_mac_addr));
12304 vat_json_object_add_string_copy (node, "host_namespace",
12305 mp->host_namespace);
12306 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
12307 vat_json_object_add_string_copy (node, "host_ip4_addr",
12308 format (0, "%U/%d", format_ip4_address,
12310 mp->host_ip4_prefix_len));
12311 vat_json_object_add_string_copy (node, "host_ip6_addr",
12312 format (0, "%U/%d", format_ip6_address,
12314 mp->host_ip6_prefix_len));
12319 api_sw_interface_tap_v2_dump (vat_main_t * vam)
12321 vl_api_sw_interface_tap_v2_dump_t *mp;
12322 vl_api_control_ping_t *mp_ping;
12326 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
12327 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
12328 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
12331 /* Get list of tap interfaces */
12332 M (SW_INTERFACE_TAP_V2_DUMP, mp);
12335 /* Use a control ping for synchronization */
12336 MPING (CONTROL_PING, mp_ping);
12343 static void vl_api_sw_interface_virtio_pci_details_t_handler
12344 (vl_api_sw_interface_virtio_pci_details_t * mp)
12346 vat_main_t *vam = &vat_main;
12360 addr.as_u32 = ntohl (mp->pci_addr);
12361 u8 *pci_addr = format (0, "%04x:%02x:%02x.%x", addr.domain, addr.bus,
12362 addr.slot, addr.function);
12365 "\n%-12s %-12d %-12d %-12d %-17U 0x%-08llx",
12366 pci_addr, ntohl (mp->sw_if_index),
12367 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
12368 format_ethernet_address, mp->mac_addr,
12369 clib_net_to_host_u64 (mp->features));
12370 vec_free (pci_addr);
12373 static void vl_api_sw_interface_virtio_pci_details_t_handler_json
12374 (vl_api_sw_interface_virtio_pci_details_t * mp)
12376 vat_main_t *vam = &vat_main;
12377 vat_json_node_t *node = NULL;
12379 if (VAT_JSON_ARRAY != vam->json_tree.type)
12381 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12382 vat_json_init_array (&vam->json_tree);
12384 node = vat_json_array_add (&vam->json_tree);
12386 vat_json_init_object (node);
12387 vat_json_object_add_uint (node, "pci-addr", ntohl (mp->pci_addr));
12388 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12389 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
12390 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
12391 vat_json_object_add_uint (node, "features",
12392 clib_net_to_host_u64 (mp->features));
12393 vat_json_object_add_string_copy (node, "mac_addr",
12394 format (0, "%U", format_ethernet_address,
12399 api_sw_interface_virtio_pci_dump (vat_main_t * vam)
12401 vl_api_sw_interface_virtio_pci_dump_t *mp;
12402 vl_api_control_ping_t *mp_ping;
12406 "\n%-12s %-12s %-12s %-12s %-17s %-08s",
12407 "pci_addr", "sw_if_index", "rx_ring_sz", "tx_ring_sz",
12408 "mac_addr", "features");
12410 /* Get list of tap interfaces */
12411 M (SW_INTERFACE_VIRTIO_PCI_DUMP, mp);
12414 /* Use a control ping for synchronization */
12415 MPING (CONTROL_PING, mp_ping);
12423 api_vxlan_offload_rx (vat_main_t * vam)
12425 unformat_input_t *line_input = vam->input;
12426 vl_api_vxlan_offload_rx_t *mp;
12427 u32 hw_if_index = ~0, rx_if_index = ~0;
12431 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12433 if (unformat (line_input, "del"))
12435 else if (unformat (line_input, "hw %U", api_unformat_hw_if_index, vam,
12438 else if (unformat (line_input, "hw hw_if_index %u", &hw_if_index))
12440 else if (unformat (line_input, "rx %U", api_unformat_sw_if_index, vam,
12443 else if (unformat (line_input, "rx sw_if_index %u", &rx_if_index))
12447 errmsg ("parse error '%U'", format_unformat_error, line_input);
12452 if (hw_if_index == ~0)
12454 errmsg ("no hw interface");
12458 if (rx_if_index == ~0)
12460 errmsg ("no rx tunnel");
12464 M (VXLAN_OFFLOAD_RX, mp);
12466 mp->hw_if_index = ntohl (hw_if_index);
12467 mp->sw_if_index = ntohl (rx_if_index);
12468 mp->enable = is_add;
12475 static uword unformat_vxlan_decap_next
12476 (unformat_input_t * input, va_list * args)
12478 u32 *result = va_arg (*args, u32 *);
12481 if (unformat (input, "l2"))
12482 *result = VXLAN_INPUT_NEXT_L2_INPUT;
12483 else if (unformat (input, "%d", &tmp))
12491 api_vxlan_add_del_tunnel (vat_main_t * vam)
12493 unformat_input_t *line_input = vam->input;
12494 vl_api_vxlan_add_del_tunnel_t *mp;
12495 ip46_address_t src, dst;
12497 u8 ipv4_set = 0, ipv6_set = 0;
12502 u32 mcast_sw_if_index = ~0;
12503 u32 encap_vrf_id = 0;
12504 u32 decap_next_index = ~0;
12508 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12509 clib_memset (&src, 0, sizeof src);
12510 clib_memset (&dst, 0, sizeof dst);
12512 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12514 if (unformat (line_input, "del"))
12516 else if (unformat (line_input, "instance %d", &instance))
12519 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12525 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12531 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12537 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12542 else if (unformat (line_input, "group %U %U",
12543 unformat_ip4_address, &dst.ip4,
12544 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12546 grp_set = dst_set = 1;
12549 else if (unformat (line_input, "group %U",
12550 unformat_ip4_address, &dst.ip4))
12552 grp_set = dst_set = 1;
12555 else if (unformat (line_input, "group %U %U",
12556 unformat_ip6_address, &dst.ip6,
12557 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12559 grp_set = dst_set = 1;
12562 else if (unformat (line_input, "group %U",
12563 unformat_ip6_address, &dst.ip6))
12565 grp_set = dst_set = 1;
12569 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12571 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12573 else if (unformat (line_input, "decap-next %U",
12574 unformat_vxlan_decap_next, &decap_next_index))
12576 else if (unformat (line_input, "vni %d", &vni))
12580 errmsg ("parse error '%U'", format_unformat_error, line_input);
12587 errmsg ("tunnel src address not specified");
12592 errmsg ("tunnel dst address not specified");
12596 if (grp_set && !ip46_address_is_multicast (&dst))
12598 errmsg ("tunnel group address not multicast");
12601 if (grp_set && mcast_sw_if_index == ~0)
12603 errmsg ("tunnel nonexistent multicast device");
12606 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12608 errmsg ("tunnel dst address must be unicast");
12613 if (ipv4_set && ipv6_set)
12615 errmsg ("both IPv4 and IPv6 addresses specified");
12619 if ((vni == 0) || (vni >> 24))
12621 errmsg ("vni not specified or out of range");
12625 M (VXLAN_ADD_DEL_TUNNEL, mp);
12629 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
12630 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
12634 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
12635 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
12638 mp->instance = htonl (instance);
12639 mp->encap_vrf_id = ntohl (encap_vrf_id);
12640 mp->decap_next_index = ntohl (decap_next_index);
12641 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12642 mp->vni = ntohl (vni);
12643 mp->is_add = is_add;
12644 mp->is_ipv6 = ipv6_set;
12651 static void vl_api_vxlan_tunnel_details_t_handler
12652 (vl_api_vxlan_tunnel_details_t * mp)
12654 vat_main_t *vam = &vat_main;
12655 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12656 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12658 print (vam->ofp, "%11d%11d%24U%24U%14d%18d%13d%19d",
12659 ntohl (mp->sw_if_index),
12660 ntohl (mp->instance),
12661 format_ip46_address, &src, IP46_TYPE_ANY,
12662 format_ip46_address, &dst, IP46_TYPE_ANY,
12663 ntohl (mp->encap_vrf_id),
12664 ntohl (mp->decap_next_index), ntohl (mp->vni),
12665 ntohl (mp->mcast_sw_if_index));
12668 static void vl_api_vxlan_tunnel_details_t_handler_json
12669 (vl_api_vxlan_tunnel_details_t * mp)
12671 vat_main_t *vam = &vat_main;
12672 vat_json_node_t *node = NULL;
12674 if (VAT_JSON_ARRAY != vam->json_tree.type)
12676 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12677 vat_json_init_array (&vam->json_tree);
12679 node = vat_json_array_add (&vam->json_tree);
12681 vat_json_init_object (node);
12682 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12684 vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
12688 struct in6_addr ip6;
12690 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12691 vat_json_object_add_ip6 (node, "src_address", ip6);
12692 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12693 vat_json_object_add_ip6 (node, "dst_address", ip6);
12697 struct in_addr ip4;
12699 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12700 vat_json_object_add_ip4 (node, "src_address", ip4);
12701 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12702 vat_json_object_add_ip4 (node, "dst_address", ip4);
12704 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12705 vat_json_object_add_uint (node, "decap_next_index",
12706 ntohl (mp->decap_next_index));
12707 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12708 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12709 vat_json_object_add_uint (node, "mcast_sw_if_index",
12710 ntohl (mp->mcast_sw_if_index));
12714 api_vxlan_tunnel_dump (vat_main_t * vam)
12716 unformat_input_t *i = vam->input;
12717 vl_api_vxlan_tunnel_dump_t *mp;
12718 vl_api_control_ping_t *mp_ping;
12720 u8 sw_if_index_set = 0;
12723 /* Parse args required to build the message */
12724 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12726 if (unformat (i, "sw_if_index %d", &sw_if_index))
12727 sw_if_index_set = 1;
12732 if (sw_if_index_set == 0)
12737 if (!vam->json_output)
12739 print (vam->ofp, "%11s%11s%24s%24s%14s%18s%13s%19s",
12740 "sw_if_index", "instance", "src_address", "dst_address",
12741 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12744 /* Get list of vxlan-tunnel interfaces */
12745 M (VXLAN_TUNNEL_DUMP, mp);
12747 mp->sw_if_index = htonl (sw_if_index);
12751 /* Use a control ping for synchronization */
12752 MPING (CONTROL_PING, mp_ping);
12759 static uword unformat_geneve_decap_next
12760 (unformat_input_t * input, va_list * args)
12762 u32 *result = va_arg (*args, u32 *);
12765 if (unformat (input, "l2"))
12766 *result = GENEVE_INPUT_NEXT_L2_INPUT;
12767 else if (unformat (input, "%d", &tmp))
12775 api_geneve_add_del_tunnel (vat_main_t * vam)
12777 unformat_input_t *line_input = vam->input;
12778 vl_api_geneve_add_del_tunnel_t *mp;
12779 ip46_address_t src, dst;
12781 u8 ipv4_set = 0, ipv6_set = 0;
12785 u32 mcast_sw_if_index = ~0;
12786 u32 encap_vrf_id = 0;
12787 u32 decap_next_index = ~0;
12791 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12792 clib_memset (&src, 0, sizeof src);
12793 clib_memset (&dst, 0, sizeof dst);
12795 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12797 if (unformat (line_input, "del"))
12800 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12806 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12812 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12818 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12823 else if (unformat (line_input, "group %U %U",
12824 unformat_ip4_address, &dst.ip4,
12825 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12827 grp_set = dst_set = 1;
12830 else if (unformat (line_input, "group %U",
12831 unformat_ip4_address, &dst.ip4))
12833 grp_set = dst_set = 1;
12836 else if (unformat (line_input, "group %U %U",
12837 unformat_ip6_address, &dst.ip6,
12838 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12840 grp_set = dst_set = 1;
12843 else if (unformat (line_input, "group %U",
12844 unformat_ip6_address, &dst.ip6))
12846 grp_set = dst_set = 1;
12850 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12852 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12854 else if (unformat (line_input, "decap-next %U",
12855 unformat_geneve_decap_next, &decap_next_index))
12857 else if (unformat (line_input, "vni %d", &vni))
12861 errmsg ("parse error '%U'", format_unformat_error, line_input);
12868 errmsg ("tunnel src address not specified");
12873 errmsg ("tunnel dst address not specified");
12877 if (grp_set && !ip46_address_is_multicast (&dst))
12879 errmsg ("tunnel group address not multicast");
12882 if (grp_set && mcast_sw_if_index == ~0)
12884 errmsg ("tunnel nonexistent multicast device");
12887 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12889 errmsg ("tunnel dst address must be unicast");
12894 if (ipv4_set && ipv6_set)
12896 errmsg ("both IPv4 and IPv6 addresses specified");
12900 if ((vni == 0) || (vni >> 24))
12902 errmsg ("vni not specified or out of range");
12906 M (GENEVE_ADD_DEL_TUNNEL, mp);
12910 clib_memcpy (mp->local_address, &src.ip6, sizeof (src.ip6));
12911 clib_memcpy (mp->remote_address, &dst.ip6, sizeof (dst.ip6));
12915 clib_memcpy (mp->local_address, &src.ip4, sizeof (src.ip4));
12916 clib_memcpy (mp->remote_address, &dst.ip4, sizeof (dst.ip4));
12918 mp->encap_vrf_id = ntohl (encap_vrf_id);
12919 mp->decap_next_index = ntohl (decap_next_index);
12920 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12921 mp->vni = ntohl (vni);
12922 mp->is_add = is_add;
12923 mp->is_ipv6 = ipv6_set;
12930 static void vl_api_geneve_tunnel_details_t_handler
12931 (vl_api_geneve_tunnel_details_t * mp)
12933 vat_main_t *vam = &vat_main;
12934 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12935 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12937 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12938 ntohl (mp->sw_if_index),
12939 format_ip46_address, &src, IP46_TYPE_ANY,
12940 format_ip46_address, &dst, IP46_TYPE_ANY,
12941 ntohl (mp->encap_vrf_id),
12942 ntohl (mp->decap_next_index), ntohl (mp->vni),
12943 ntohl (mp->mcast_sw_if_index));
12946 static void vl_api_geneve_tunnel_details_t_handler_json
12947 (vl_api_geneve_tunnel_details_t * mp)
12949 vat_main_t *vam = &vat_main;
12950 vat_json_node_t *node = NULL;
12952 if (VAT_JSON_ARRAY != vam->json_tree.type)
12954 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12955 vat_json_init_array (&vam->json_tree);
12957 node = vat_json_array_add (&vam->json_tree);
12959 vat_json_init_object (node);
12960 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12963 struct in6_addr ip6;
12965 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12966 vat_json_object_add_ip6 (node, "src_address", ip6);
12967 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12968 vat_json_object_add_ip6 (node, "dst_address", ip6);
12972 struct in_addr ip4;
12974 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12975 vat_json_object_add_ip4 (node, "src_address", ip4);
12976 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12977 vat_json_object_add_ip4 (node, "dst_address", ip4);
12979 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12980 vat_json_object_add_uint (node, "decap_next_index",
12981 ntohl (mp->decap_next_index));
12982 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12983 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12984 vat_json_object_add_uint (node, "mcast_sw_if_index",
12985 ntohl (mp->mcast_sw_if_index));
12989 api_geneve_tunnel_dump (vat_main_t * vam)
12991 unformat_input_t *i = vam->input;
12992 vl_api_geneve_tunnel_dump_t *mp;
12993 vl_api_control_ping_t *mp_ping;
12995 u8 sw_if_index_set = 0;
12998 /* Parse args required to build the message */
12999 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13001 if (unformat (i, "sw_if_index %d", &sw_if_index))
13002 sw_if_index_set = 1;
13007 if (sw_if_index_set == 0)
13012 if (!vam->json_output)
13014 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
13015 "sw_if_index", "local_address", "remote_address",
13016 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
13019 /* Get list of geneve-tunnel interfaces */
13020 M (GENEVE_TUNNEL_DUMP, mp);
13022 mp->sw_if_index = htonl (sw_if_index);
13026 /* Use a control ping for synchronization */
13027 M (CONTROL_PING, mp_ping);
13035 api_gre_tunnel_add_del (vat_main_t * vam)
13037 unformat_input_t *line_input = vam->input;
13038 vl_api_address_t src = { }, dst =
13041 vl_api_gre_tunnel_add_del_t *mp;
13042 vl_api_gre_tunnel_type_t t_type;
13046 u32 outer_fib_id = 0;
13047 u32 session_id = 0;
13051 t_type = GRE_API_TUNNEL_TYPE_L3;
13053 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13055 if (unformat (line_input, "del"))
13057 else if (unformat (line_input, "instance %d", &instance))
13059 else if (unformat (line_input, "src %U", unformat_vl_api_address, &src))
13063 else if (unformat (line_input, "dst %U", unformat_vl_api_address, &dst))
13067 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
13069 else if (unformat (line_input, "teb"))
13070 t_type = GRE_API_TUNNEL_TYPE_TEB;
13071 else if (unformat (line_input, "erspan %d", &session_id))
13072 t_type = GRE_API_TUNNEL_TYPE_ERSPAN;
13075 errmsg ("parse error '%U'", format_unformat_error, line_input);
13082 errmsg ("tunnel src address not specified");
13087 errmsg ("tunnel dst address not specified");
13091 M (GRE_TUNNEL_ADD_DEL, mp);
13093 clib_memcpy (&mp->tunnel.src, &src, sizeof (mp->tunnel.src));
13094 clib_memcpy (&mp->tunnel.dst, &dst, sizeof (mp->tunnel.dst));
13096 mp->tunnel.instance = htonl (instance);
13097 mp->tunnel.outer_fib_id = htonl (outer_fib_id);
13098 mp->is_add = is_add;
13099 mp->tunnel.session_id = htons ((u16) session_id);
13100 mp->tunnel.type = htonl (t_type);
13107 static void vl_api_gre_tunnel_details_t_handler
13108 (vl_api_gre_tunnel_details_t * mp)
13110 vat_main_t *vam = &vat_main;
13112 print (vam->ofp, "%11d%11d%24U%24U%13d%14d%12d",
13113 ntohl (mp->tunnel.sw_if_index),
13114 ntohl (mp->tunnel.instance),
13115 format_vl_api_address, &mp->tunnel.src,
13116 format_vl_api_address, &mp->tunnel.dst,
13117 mp->tunnel.type, ntohl (mp->tunnel.outer_fib_id),
13118 ntohl (mp->tunnel.session_id));
13121 static void vl_api_gre_tunnel_details_t_handler_json
13122 (vl_api_gre_tunnel_details_t * mp)
13124 vat_main_t *vam = &vat_main;
13125 vat_json_node_t *node = NULL;
13127 if (VAT_JSON_ARRAY != vam->json_tree.type)
13129 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13130 vat_json_init_array (&vam->json_tree);
13132 node = vat_json_array_add (&vam->json_tree);
13134 vat_json_init_object (node);
13135 vat_json_object_add_uint (node, "sw_if_index",
13136 ntohl (mp->tunnel.sw_if_index));
13137 vat_json_object_add_uint (node, "instance", ntohl (mp->tunnel.instance));
13139 vat_json_object_add_address (node, "src", &mp->tunnel.src);
13140 vat_json_object_add_address (node, "dst", &mp->tunnel.dst);
13141 vat_json_object_add_uint (node, "tunnel_type", mp->tunnel.type);
13142 vat_json_object_add_uint (node, "outer_fib_id",
13143 ntohl (mp->tunnel.outer_fib_id));
13144 vat_json_object_add_uint (node, "session_id", mp->tunnel.session_id);
13148 api_gre_tunnel_dump (vat_main_t * vam)
13150 unformat_input_t *i = vam->input;
13151 vl_api_gre_tunnel_dump_t *mp;
13152 vl_api_control_ping_t *mp_ping;
13154 u8 sw_if_index_set = 0;
13157 /* Parse args required to build the message */
13158 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13160 if (unformat (i, "sw_if_index %d", &sw_if_index))
13161 sw_if_index_set = 1;
13166 if (sw_if_index_set == 0)
13171 if (!vam->json_output)
13173 print (vam->ofp, "%11s%11s%24s%24s%13s%14s%12s",
13174 "sw_if_index", "instance", "src_address", "dst_address",
13175 "tunnel_type", "outer_fib_id", "session_id");
13178 /* Get list of gre-tunnel interfaces */
13179 M (GRE_TUNNEL_DUMP, mp);
13181 mp->sw_if_index = htonl (sw_if_index);
13185 /* Use a control ping for synchronization */
13186 MPING (CONTROL_PING, mp_ping);
13194 api_l2_fib_clear_table (vat_main_t * vam)
13196 // unformat_input_t * i = vam->input;
13197 vl_api_l2_fib_clear_table_t *mp;
13200 M (L2_FIB_CLEAR_TABLE, mp);
13208 api_l2_interface_efp_filter (vat_main_t * vam)
13210 unformat_input_t *i = vam->input;
13211 vl_api_l2_interface_efp_filter_t *mp;
13214 u8 sw_if_index_set = 0;
13217 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13219 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13220 sw_if_index_set = 1;
13221 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13222 sw_if_index_set = 1;
13223 else if (unformat (i, "enable"))
13225 else if (unformat (i, "disable"))
13229 clib_warning ("parse error '%U'", format_unformat_error, i);
13234 if (sw_if_index_set == 0)
13236 errmsg ("missing sw_if_index");
13240 M (L2_INTERFACE_EFP_FILTER, mp);
13242 mp->sw_if_index = ntohl (sw_if_index);
13243 mp->enable_disable = enable;
13250 #define foreach_vtr_op \
13251 _("disable", L2_VTR_DISABLED) \
13252 _("push-1", L2_VTR_PUSH_1) \
13253 _("push-2", L2_VTR_PUSH_2) \
13254 _("pop-1", L2_VTR_POP_1) \
13255 _("pop-2", L2_VTR_POP_2) \
13256 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
13257 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
13258 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
13259 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
13262 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
13264 unformat_input_t *i = vam->input;
13265 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
13267 u8 sw_if_index_set = 0;
13270 u32 push_dot1q = 1;
13275 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13277 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13278 sw_if_index_set = 1;
13279 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13280 sw_if_index_set = 1;
13281 else if (unformat (i, "vtr_op %d", &vtr_op))
13283 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
13286 else if (unformat (i, "push_dot1q %d", &push_dot1q))
13288 else if (unformat (i, "tag1 %d", &tag1))
13290 else if (unformat (i, "tag2 %d", &tag2))
13294 clib_warning ("parse error '%U'", format_unformat_error, i);
13299 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
13301 errmsg ("missing vtr operation or sw_if_index");
13305 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
13306 mp->sw_if_index = ntohl (sw_if_index);
13307 mp->vtr_op = ntohl (vtr_op);
13308 mp->push_dot1q = ntohl (push_dot1q);
13309 mp->tag1 = ntohl (tag1);
13310 mp->tag2 = ntohl (tag2);
13318 api_create_vhost_user_if (vat_main_t * vam)
13320 unformat_input_t *i = vam->input;
13321 vl_api_create_vhost_user_if_t *mp;
13324 u8 file_name_set = 0;
13325 u32 custom_dev_instance = ~0;
13327 u8 use_custom_mac = 0;
13328 u8 disable_mrg_rxbuf = 0;
13329 u8 disable_indirect_desc = 0;
13333 /* Shut up coverity */
13334 clib_memset (hwaddr, 0, sizeof (hwaddr));
13336 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13338 if (unformat (i, "socket %s", &file_name))
13342 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13344 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
13345 use_custom_mac = 1;
13346 else if (unformat (i, "server"))
13348 else if (unformat (i, "disable_mrg_rxbuf"))
13349 disable_mrg_rxbuf = 1;
13350 else if (unformat (i, "disable_indirect_desc"))
13351 disable_indirect_desc = 1;
13352 else if (unformat (i, "tag %s", &tag))
13358 if (file_name_set == 0)
13360 errmsg ("missing socket file name");
13364 if (vec_len (file_name) > 255)
13366 errmsg ("socket file name too long");
13369 vec_add1 (file_name, 0);
13371 M (CREATE_VHOST_USER_IF, mp);
13373 mp->is_server = is_server;
13374 mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
13375 mp->disable_indirect_desc = disable_indirect_desc;
13376 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13377 vec_free (file_name);
13378 if (custom_dev_instance != ~0)
13381 mp->custom_dev_instance = ntohl (custom_dev_instance);
13384 mp->use_custom_mac = use_custom_mac;
13385 clib_memcpy (mp->mac_address, hwaddr, 6);
13387 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
13396 api_modify_vhost_user_if (vat_main_t * vam)
13398 unformat_input_t *i = vam->input;
13399 vl_api_modify_vhost_user_if_t *mp;
13402 u8 file_name_set = 0;
13403 u32 custom_dev_instance = ~0;
13404 u8 sw_if_index_set = 0;
13405 u32 sw_if_index = (u32) ~ 0;
13408 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13410 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13411 sw_if_index_set = 1;
13412 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13413 sw_if_index_set = 1;
13414 else if (unformat (i, "socket %s", &file_name))
13418 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13420 else if (unformat (i, "server"))
13426 if (sw_if_index_set == 0)
13428 errmsg ("missing sw_if_index or interface name");
13432 if (file_name_set == 0)
13434 errmsg ("missing socket file name");
13438 if (vec_len (file_name) > 255)
13440 errmsg ("socket file name too long");
13443 vec_add1 (file_name, 0);
13445 M (MODIFY_VHOST_USER_IF, mp);
13447 mp->sw_if_index = ntohl (sw_if_index);
13448 mp->is_server = is_server;
13449 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13450 vec_free (file_name);
13451 if (custom_dev_instance != ~0)
13454 mp->custom_dev_instance = ntohl (custom_dev_instance);
13463 api_delete_vhost_user_if (vat_main_t * vam)
13465 unformat_input_t *i = vam->input;
13466 vl_api_delete_vhost_user_if_t *mp;
13467 u32 sw_if_index = ~0;
13468 u8 sw_if_index_set = 0;
13471 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13473 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13474 sw_if_index_set = 1;
13475 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13476 sw_if_index_set = 1;
13481 if (sw_if_index_set == 0)
13483 errmsg ("missing sw_if_index or interface name");
13488 M (DELETE_VHOST_USER_IF, mp);
13490 mp->sw_if_index = ntohl (sw_if_index);
13497 static void vl_api_sw_interface_vhost_user_details_t_handler
13498 (vl_api_sw_interface_vhost_user_details_t * mp)
13500 vat_main_t *vam = &vat_main;
13502 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
13503 (char *) mp->interface_name,
13504 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
13505 clib_net_to_host_u64 (mp->features), mp->is_server,
13506 ntohl (mp->num_regions), (char *) mp->sock_filename);
13507 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
13510 static void vl_api_sw_interface_vhost_user_details_t_handler_json
13511 (vl_api_sw_interface_vhost_user_details_t * mp)
13513 vat_main_t *vam = &vat_main;
13514 vat_json_node_t *node = NULL;
13516 if (VAT_JSON_ARRAY != vam->json_tree.type)
13518 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13519 vat_json_init_array (&vam->json_tree);
13521 node = vat_json_array_add (&vam->json_tree);
13523 vat_json_init_object (node);
13524 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13525 vat_json_object_add_string_copy (node, "interface_name",
13526 mp->interface_name);
13527 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
13528 ntohl (mp->virtio_net_hdr_sz));
13529 vat_json_object_add_uint (node, "features",
13530 clib_net_to_host_u64 (mp->features));
13531 vat_json_object_add_uint (node, "is_server", mp->is_server);
13532 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
13533 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
13534 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
13538 api_sw_interface_vhost_user_dump (vat_main_t * vam)
13540 vl_api_sw_interface_vhost_user_dump_t *mp;
13541 vl_api_control_ping_t *mp_ping;
13544 "Interface name idx hdr_sz features server regions filename");
13546 /* Get list of vhost-user interfaces */
13547 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
13550 /* Use a control ping for synchronization */
13551 MPING (CONTROL_PING, mp_ping);
13559 api_show_version (vat_main_t * vam)
13561 vl_api_show_version_t *mp;
13564 M (SHOW_VERSION, mp);
13573 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
13575 unformat_input_t *line_input = vam->input;
13576 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
13577 ip4_address_t local4, remote4;
13578 ip6_address_t local6, remote6;
13580 u8 ipv4_set = 0, ipv6_set = 0;
13584 u32 mcast_sw_if_index = ~0;
13585 u32 encap_vrf_id = 0;
13586 u32 decap_vrf_id = 0;
13592 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
13593 clib_memset (&local4, 0, sizeof local4);
13594 clib_memset (&remote4, 0, sizeof remote4);
13595 clib_memset (&local6, 0, sizeof local6);
13596 clib_memset (&remote6, 0, sizeof remote6);
13598 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13600 if (unformat (line_input, "del"))
13602 else if (unformat (line_input, "local %U",
13603 unformat_ip4_address, &local4))
13608 else if (unformat (line_input, "remote %U",
13609 unformat_ip4_address, &remote4))
13614 else if (unformat (line_input, "local %U",
13615 unformat_ip6_address, &local6))
13620 else if (unformat (line_input, "remote %U",
13621 unformat_ip6_address, &remote6))
13626 else if (unformat (line_input, "group %U %U",
13627 unformat_ip4_address, &remote4,
13628 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13630 grp_set = remote_set = 1;
13633 else if (unformat (line_input, "group %U",
13634 unformat_ip4_address, &remote4))
13636 grp_set = remote_set = 1;
13639 else if (unformat (line_input, "group %U %U",
13640 unformat_ip6_address, &remote6,
13641 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13643 grp_set = remote_set = 1;
13646 else if (unformat (line_input, "group %U",
13647 unformat_ip6_address, &remote6))
13649 grp_set = remote_set = 1;
13653 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13655 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13657 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
13659 else if (unformat (line_input, "vni %d", &vni))
13661 else if (unformat (line_input, "next-ip4"))
13663 else if (unformat (line_input, "next-ip6"))
13665 else if (unformat (line_input, "next-ethernet"))
13667 else if (unformat (line_input, "next-nsh"))
13671 errmsg ("parse error '%U'", format_unformat_error, line_input);
13676 if (local_set == 0)
13678 errmsg ("tunnel local address not specified");
13681 if (remote_set == 0)
13683 errmsg ("tunnel remote address not specified");
13686 if (grp_set && mcast_sw_if_index == ~0)
13688 errmsg ("tunnel nonexistent multicast device");
13691 if (ipv4_set && ipv6_set)
13693 errmsg ("both IPv4 and IPv6 addresses specified");
13699 errmsg ("vni not specified");
13703 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
13708 clib_memcpy (&mp->local, &local6, sizeof (local6));
13709 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
13713 clib_memcpy (&mp->local, &local4, sizeof (local4));
13714 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
13717 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
13718 mp->encap_vrf_id = ntohl (encap_vrf_id);
13719 mp->decap_vrf_id = ntohl (decap_vrf_id);
13720 mp->protocol = protocol;
13721 mp->vni = ntohl (vni);
13722 mp->is_add = is_add;
13723 mp->is_ipv6 = ipv6_set;
13730 static void vl_api_vxlan_gpe_tunnel_details_t_handler
13731 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13733 vat_main_t *vam = &vat_main;
13734 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
13735 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
13737 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
13738 ntohl (mp->sw_if_index),
13739 format_ip46_address, &local, IP46_TYPE_ANY,
13740 format_ip46_address, &remote, IP46_TYPE_ANY,
13741 ntohl (mp->vni), mp->protocol,
13742 ntohl (mp->mcast_sw_if_index),
13743 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
13747 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
13748 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13750 vat_main_t *vam = &vat_main;
13751 vat_json_node_t *node = NULL;
13752 struct in_addr ip4;
13753 struct in6_addr ip6;
13755 if (VAT_JSON_ARRAY != vam->json_tree.type)
13757 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13758 vat_json_init_array (&vam->json_tree);
13760 node = vat_json_array_add (&vam->json_tree);
13762 vat_json_init_object (node);
13763 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13766 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
13767 vat_json_object_add_ip6 (node, "local", ip6);
13768 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
13769 vat_json_object_add_ip6 (node, "remote", ip6);
13773 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
13774 vat_json_object_add_ip4 (node, "local", ip4);
13775 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
13776 vat_json_object_add_ip4 (node, "remote", ip4);
13778 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
13779 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
13780 vat_json_object_add_uint (node, "mcast_sw_if_index",
13781 ntohl (mp->mcast_sw_if_index));
13782 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
13783 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
13784 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
13788 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
13790 unformat_input_t *i = vam->input;
13791 vl_api_vxlan_gpe_tunnel_dump_t *mp;
13792 vl_api_control_ping_t *mp_ping;
13794 u8 sw_if_index_set = 0;
13797 /* Parse args required to build the message */
13798 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13800 if (unformat (i, "sw_if_index %d", &sw_if_index))
13801 sw_if_index_set = 1;
13806 if (sw_if_index_set == 0)
13811 if (!vam->json_output)
13813 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
13814 "sw_if_index", "local", "remote", "vni",
13815 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
13818 /* Get list of vxlan-tunnel interfaces */
13819 M (VXLAN_GPE_TUNNEL_DUMP, mp);
13821 mp->sw_if_index = htonl (sw_if_index);
13825 /* Use a control ping for synchronization */
13826 MPING (CONTROL_PING, mp_ping);
13833 static void vl_api_l2_fib_table_details_t_handler
13834 (vl_api_l2_fib_table_details_t * mp)
13836 vat_main_t *vam = &vat_main;
13838 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
13840 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
13841 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
13845 static void vl_api_l2_fib_table_details_t_handler_json
13846 (vl_api_l2_fib_table_details_t * mp)
13848 vat_main_t *vam = &vat_main;
13849 vat_json_node_t *node = NULL;
13851 if (VAT_JSON_ARRAY != vam->json_tree.type)
13853 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13854 vat_json_init_array (&vam->json_tree);
13856 node = vat_json_array_add (&vam->json_tree);
13858 vat_json_init_object (node);
13859 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
13860 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
13861 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13862 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
13863 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
13864 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
13868 api_l2_fib_table_dump (vat_main_t * vam)
13870 unformat_input_t *i = vam->input;
13871 vl_api_l2_fib_table_dump_t *mp;
13872 vl_api_control_ping_t *mp_ping;
13877 /* Parse args required to build the message */
13878 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13880 if (unformat (i, "bd_id %d", &bd_id))
13886 if (bd_id_set == 0)
13888 errmsg ("missing bridge domain");
13892 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
13894 /* Get list of l2 fib entries */
13895 M (L2_FIB_TABLE_DUMP, mp);
13897 mp->bd_id = ntohl (bd_id);
13900 /* Use a control ping for synchronization */
13901 MPING (CONTROL_PING, mp_ping);
13910 api_interface_name_renumber (vat_main_t * vam)
13912 unformat_input_t *line_input = vam->input;
13913 vl_api_interface_name_renumber_t *mp;
13914 u32 sw_if_index = ~0;
13915 u32 new_show_dev_instance = ~0;
13918 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13920 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
13923 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13925 else if (unformat (line_input, "new_show_dev_instance %d",
13926 &new_show_dev_instance))
13932 if (sw_if_index == ~0)
13934 errmsg ("missing interface name or sw_if_index");
13938 if (new_show_dev_instance == ~0)
13940 errmsg ("missing new_show_dev_instance");
13944 M (INTERFACE_NAME_RENUMBER, mp);
13946 mp->sw_if_index = ntohl (sw_if_index);
13947 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
13955 api_ip_probe_neighbor (vat_main_t * vam)
13957 unformat_input_t *i = vam->input;
13958 vl_api_ip_probe_neighbor_t *mp;
13959 vl_api_address_t dst_adr = { };
13965 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13967 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13969 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13971 else if (unformat (i, "address %U", unformat_vl_api_address, &dst_adr))
13979 errmsg ("missing interface");
13985 errmsg ("missing addresses");
13989 M (IP_PROBE_NEIGHBOR, mp);
13991 mp->sw_if_index = ntohl (sw_if_index);
13992 clib_memcpy (&mp->dst, &dst_adr, sizeof (dst_adr));
14000 api_ip_scan_neighbor_enable_disable (vat_main_t * vam)
14002 unformat_input_t *i = vam->input;
14003 vl_api_ip_scan_neighbor_enable_disable_t *mp;
14004 u8 mode = IP_SCAN_V46_NEIGHBORS;
14005 u32 interval = 0, time = 0, update = 0, delay = 0, stale = 0;
14008 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14010 if (unformat (i, "ip4"))
14011 mode = IP_SCAN_V4_NEIGHBORS;
14012 else if (unformat (i, "ip6"))
14013 mode = IP_SCAN_V6_NEIGHBORS;
14014 if (unformat (i, "both"))
14015 mode = IP_SCAN_V46_NEIGHBORS;
14016 else if (unformat (i, "disable"))
14017 mode = IP_SCAN_DISABLED;
14018 else if (unformat (i, "interval %d", &interval))
14020 else if (unformat (i, "max-time %d", &time))
14022 else if (unformat (i, "max-update %d", &update))
14024 else if (unformat (i, "delay %d", &delay))
14026 else if (unformat (i, "stale %d", &stale))
14032 if (interval > 255)
14034 errmsg ("interval cannot exceed 255 minutes.");
14039 errmsg ("max-time cannot exceed 255 usec.");
14044 errmsg ("max-update cannot exceed 255.");
14049 errmsg ("delay cannot exceed 255 msec.");
14054 errmsg ("stale cannot exceed 255 minutes.");
14058 M (IP_SCAN_NEIGHBOR_ENABLE_DISABLE, mp);
14060 mp->scan_interval = interval;
14061 mp->max_proc_time = time;
14062 mp->max_update = update;
14063 mp->scan_int_delay = delay;
14064 mp->stale_threshold = stale;
14072 api_want_ip4_arp_events (vat_main_t * vam)
14074 unformat_input_t *line_input = vam->input;
14075 vl_api_want_ip4_arp_events_t *mp;
14076 ip4_address_t address;
14077 int address_set = 0;
14078 u32 enable_disable = 1;
14081 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14083 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
14085 else if (unformat (line_input, "del"))
14086 enable_disable = 0;
14091 if (address_set == 0)
14093 errmsg ("missing addresses");
14097 M (WANT_IP4_ARP_EVENTS, mp);
14098 mp->enable_disable = enable_disable;
14099 mp->pid = htonl (getpid ());
14100 clib_memcpy (mp->ip, &address, sizeof (address));
14108 api_want_ip6_nd_events (vat_main_t * vam)
14110 unformat_input_t *line_input = vam->input;
14111 vl_api_want_ip6_nd_events_t *mp;
14112 vl_api_ip6_address_t address;
14113 int address_set = 0;
14114 u32 enable_disable = 1;
14117 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14120 (line_input, "address %U", unformat_vl_api_ip6_address, &address))
14122 else if (unformat (line_input, "del"))
14123 enable_disable = 0;
14128 if (address_set == 0)
14130 errmsg ("missing addresses");
14134 M (WANT_IP6_ND_EVENTS, mp);
14135 mp->enable_disable = enable_disable;
14136 mp->pid = htonl (getpid ());
14137 clib_memcpy (&mp->ip, &address, sizeof (address));
14145 api_want_l2_macs_events (vat_main_t * vam)
14147 unformat_input_t *line_input = vam->input;
14148 vl_api_want_l2_macs_events_t *mp;
14149 u8 enable_disable = 1;
14150 u32 scan_delay = 0;
14151 u32 max_macs_in_event = 0;
14152 u32 learn_limit = 0;
14155 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14157 if (unformat (line_input, "learn-limit %d", &learn_limit))
14159 else if (unformat (line_input, "scan-delay %d", &scan_delay))
14161 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
14163 else if (unformat (line_input, "disable"))
14164 enable_disable = 0;
14169 M (WANT_L2_MACS_EVENTS, mp);
14170 mp->enable_disable = enable_disable;
14171 mp->pid = htonl (getpid ());
14172 mp->learn_limit = htonl (learn_limit);
14173 mp->scan_delay = (u8) scan_delay;
14174 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
14181 api_input_acl_set_interface (vat_main_t * vam)
14183 unformat_input_t *i = vam->input;
14184 vl_api_input_acl_set_interface_t *mp;
14186 int sw_if_index_set;
14187 u32 ip4_table_index = ~0;
14188 u32 ip6_table_index = ~0;
14189 u32 l2_table_index = ~0;
14193 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14195 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14196 sw_if_index_set = 1;
14197 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14198 sw_if_index_set = 1;
14199 else if (unformat (i, "del"))
14201 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14203 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14205 else if (unformat (i, "l2-table %d", &l2_table_index))
14209 clib_warning ("parse error '%U'", format_unformat_error, i);
14214 if (sw_if_index_set == 0)
14216 errmsg ("missing interface name or sw_if_index");
14220 M (INPUT_ACL_SET_INTERFACE, mp);
14222 mp->sw_if_index = ntohl (sw_if_index);
14223 mp->ip4_table_index = ntohl (ip4_table_index);
14224 mp->ip6_table_index = ntohl (ip6_table_index);
14225 mp->l2_table_index = ntohl (l2_table_index);
14226 mp->is_add = is_add;
14234 api_output_acl_set_interface (vat_main_t * vam)
14236 unformat_input_t *i = vam->input;
14237 vl_api_output_acl_set_interface_t *mp;
14239 int sw_if_index_set;
14240 u32 ip4_table_index = ~0;
14241 u32 ip6_table_index = ~0;
14242 u32 l2_table_index = ~0;
14246 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14248 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14249 sw_if_index_set = 1;
14250 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14251 sw_if_index_set = 1;
14252 else if (unformat (i, "del"))
14254 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14256 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14258 else if (unformat (i, "l2-table %d", &l2_table_index))
14262 clib_warning ("parse error '%U'", format_unformat_error, i);
14267 if (sw_if_index_set == 0)
14269 errmsg ("missing interface name or sw_if_index");
14273 M (OUTPUT_ACL_SET_INTERFACE, mp);
14275 mp->sw_if_index = ntohl (sw_if_index);
14276 mp->ip4_table_index = ntohl (ip4_table_index);
14277 mp->ip6_table_index = ntohl (ip6_table_index);
14278 mp->l2_table_index = ntohl (l2_table_index);
14279 mp->is_add = is_add;
14287 api_ip_address_dump (vat_main_t * vam)
14289 unformat_input_t *i = vam->input;
14290 vl_api_ip_address_dump_t *mp;
14291 vl_api_control_ping_t *mp_ping;
14292 u32 sw_if_index = ~0;
14293 u8 sw_if_index_set = 0;
14298 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14300 if (unformat (i, "sw_if_index %d", &sw_if_index))
14301 sw_if_index_set = 1;
14303 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14304 sw_if_index_set = 1;
14305 else if (unformat (i, "ipv4"))
14307 else if (unformat (i, "ipv6"))
14313 if (ipv4_set && ipv6_set)
14315 errmsg ("ipv4 and ipv6 flags cannot be both set");
14319 if ((!ipv4_set) && (!ipv6_set))
14321 errmsg ("no ipv4 nor ipv6 flag set");
14325 if (sw_if_index_set == 0)
14327 errmsg ("missing interface name or sw_if_index");
14331 vam->current_sw_if_index = sw_if_index;
14332 vam->is_ipv6 = ipv6_set;
14334 M (IP_ADDRESS_DUMP, mp);
14335 mp->sw_if_index = ntohl (sw_if_index);
14336 mp->is_ipv6 = ipv6_set;
14339 /* Use a control ping for synchronization */
14340 MPING (CONTROL_PING, mp_ping);
14348 api_ip_dump (vat_main_t * vam)
14350 vl_api_ip_dump_t *mp;
14351 vl_api_control_ping_t *mp_ping;
14352 unformat_input_t *in = vam->input;
14359 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
14361 if (unformat (in, "ipv4"))
14363 else if (unformat (in, "ipv6"))
14369 if (ipv4_set && ipv6_set)
14371 errmsg ("ipv4 and ipv6 flags cannot be both set");
14375 if ((!ipv4_set) && (!ipv6_set))
14377 errmsg ("no ipv4 nor ipv6 flag set");
14381 is_ipv6 = ipv6_set;
14382 vam->is_ipv6 = is_ipv6;
14384 /* free old data */
14385 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
14387 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
14389 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
14392 mp->is_ipv6 = ipv6_set;
14395 /* Use a control ping for synchronization */
14396 MPING (CONTROL_PING, mp_ping);
14404 api_ipsec_spd_add_del (vat_main_t * vam)
14406 unformat_input_t *i = vam->input;
14407 vl_api_ipsec_spd_add_del_t *mp;
14412 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14414 if (unformat (i, "spd_id %d", &spd_id))
14416 else if (unformat (i, "del"))
14420 clib_warning ("parse error '%U'", format_unformat_error, i);
14426 errmsg ("spd_id must be set");
14430 M (IPSEC_SPD_ADD_DEL, mp);
14432 mp->spd_id = ntohl (spd_id);
14433 mp->is_add = is_add;
14441 api_ipsec_interface_add_del_spd (vat_main_t * vam)
14443 unformat_input_t *i = vam->input;
14444 vl_api_ipsec_interface_add_del_spd_t *mp;
14446 u8 sw_if_index_set = 0;
14447 u32 spd_id = (u32) ~ 0;
14451 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14453 if (unformat (i, "del"))
14455 else if (unformat (i, "spd_id %d", &spd_id))
14458 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14459 sw_if_index_set = 1;
14460 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14461 sw_if_index_set = 1;
14464 clib_warning ("parse error '%U'", format_unformat_error, i);
14470 if (spd_id == (u32) ~ 0)
14472 errmsg ("spd_id must be set");
14476 if (sw_if_index_set == 0)
14478 errmsg ("missing interface name or sw_if_index");
14482 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
14484 mp->spd_id = ntohl (spd_id);
14485 mp->sw_if_index = ntohl (sw_if_index);
14486 mp->is_add = is_add;
14494 api_ipsec_spd_entry_add_del (vat_main_t * vam)
14496 unformat_input_t *i = vam->input;
14497 vl_api_ipsec_spd_entry_add_del_t *mp;
14498 u8 is_add = 1, is_outbound = 0;
14499 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
14501 u32 rport_start = 0, rport_stop = (u32) ~ 0;
14502 u32 lport_start = 0, lport_stop = (u32) ~ 0;
14503 vl_api_address_t laddr_start = { }, laddr_stop =
14512 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14514 if (unformat (i, "del"))
14516 if (unformat (i, "outbound"))
14518 if (unformat (i, "inbound"))
14520 else if (unformat (i, "spd_id %d", &spd_id))
14522 else if (unformat (i, "sa_id %d", &sa_id))
14524 else if (unformat (i, "priority %d", &priority))
14526 else if (unformat (i, "protocol %d", &protocol))
14528 else if (unformat (i, "lport_start %d", &lport_start))
14530 else if (unformat (i, "lport_stop %d", &lport_stop))
14532 else if (unformat (i, "rport_start %d", &rport_start))
14534 else if (unformat (i, "rport_stop %d", &rport_stop))
14536 else if (unformat (i, "laddr_start %U",
14537 unformat_vl_api_address, &laddr_start))
14539 else if (unformat (i, "laddr_stop %U", unformat_vl_api_address,
14542 else if (unformat (i, "raddr_start %U", unformat_vl_api_address,
14545 else if (unformat (i, "raddr_stop %U", unformat_vl_api_address,
14549 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
14551 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
14553 clib_warning ("unsupported action: 'resolve'");
14559 clib_warning ("parse error '%U'", format_unformat_error, i);
14565 M (IPSEC_SPD_ENTRY_ADD_DEL, mp);
14567 mp->is_add = is_add;
14569 mp->entry.spd_id = ntohl (spd_id);
14570 mp->entry.priority = ntohl (priority);
14571 mp->entry.is_outbound = is_outbound;
14573 clib_memcpy (&mp->entry.remote_address_start, &raddr_start,
14574 sizeof (vl_api_address_t));
14575 clib_memcpy (&mp->entry.remote_address_stop, &raddr_stop,
14576 sizeof (vl_api_address_t));
14577 clib_memcpy (&mp->entry.local_address_start, &laddr_start,
14578 sizeof (vl_api_address_t));
14579 clib_memcpy (&mp->entry.local_address_stop, &laddr_stop,
14580 sizeof (vl_api_address_t));
14582 mp->entry.protocol = (u8) protocol;
14583 mp->entry.local_port_start = ntohs ((u16) lport_start);
14584 mp->entry.local_port_stop = ntohs ((u16) lport_stop);
14585 mp->entry.remote_port_start = ntohs ((u16) rport_start);
14586 mp->entry.remote_port_stop = ntohs ((u16) rport_stop);
14587 mp->entry.policy = (u8) policy;
14588 mp->entry.sa_id = ntohl (sa_id);
14596 api_ipsec_sad_entry_add_del (vat_main_t * vam)
14598 unformat_input_t *i = vam->input;
14599 vl_api_ipsec_sad_entry_add_del_t *mp;
14600 u32 sad_id = 0, spi = 0;
14601 u8 *ck = 0, *ik = 0;
14604 vl_api_ipsec_crypto_alg_t crypto_alg = IPSEC_API_CRYPTO_ALG_NONE;
14605 vl_api_ipsec_integ_alg_t integ_alg = IPSEC_API_INTEG_ALG_NONE;
14606 vl_api_ipsec_sad_flags_t flags = IPSEC_API_SAD_FLAG_NONE;
14607 vl_api_ipsec_proto_t protocol = IPSEC_API_PROTO_AH;
14608 vl_api_address_t tun_src, tun_dst;
14611 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14613 if (unformat (i, "del"))
14615 else if (unformat (i, "sad_id %d", &sad_id))
14617 else if (unformat (i, "spi %d", &spi))
14619 else if (unformat (i, "esp"))
14620 protocol = IPSEC_API_PROTO_ESP;
14622 if (unformat (i, "tunnel_src %U", unformat_vl_api_address, &tun_src))
14624 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
14625 if (ADDRESS_IP6 == tun_src.af)
14626 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
14629 if (unformat (i, "tunnel_dst %U", unformat_vl_api_address, &tun_dst))
14631 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
14632 if (ADDRESS_IP6 == tun_src.af)
14633 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
14636 if (unformat (i, "crypto_alg %U",
14637 unformat_ipsec_api_crypto_alg, &crypto_alg))
14639 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14641 else if (unformat (i, "integ_alg %U",
14642 unformat_ipsec_api_integ_alg, &integ_alg))
14644 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14648 clib_warning ("parse error '%U'", format_unformat_error, i);
14654 M (IPSEC_SAD_ENTRY_ADD_DEL, mp);
14656 mp->is_add = is_add;
14657 mp->entry.sad_id = ntohl (sad_id);
14658 mp->entry.protocol = protocol;
14659 mp->entry.spi = ntohl (spi);
14660 mp->entry.flags = flags;
14662 mp->entry.crypto_algorithm = crypto_alg;
14663 mp->entry.integrity_algorithm = integ_alg;
14664 mp->entry.crypto_key.length = vec_len (ck);
14665 mp->entry.integrity_key.length = vec_len (ik);
14667 if (mp->entry.crypto_key.length > sizeof (mp->entry.crypto_key.data))
14668 mp->entry.crypto_key.length = sizeof (mp->entry.crypto_key.data);
14670 if (mp->entry.integrity_key.length > sizeof (mp->entry.integrity_key.data))
14671 mp->entry.integrity_key.length = sizeof (mp->entry.integrity_key.data);
14674 clib_memcpy (mp->entry.crypto_key.data, ck, mp->entry.crypto_key.length);
14676 clib_memcpy (mp->entry.integrity_key.data, ik,
14677 mp->entry.integrity_key.length);
14679 if (flags & IPSEC_API_SAD_FLAG_IS_TUNNEL)
14681 clib_memcpy (&mp->entry.tunnel_src, &tun_src,
14682 sizeof (mp->entry.tunnel_src));
14683 clib_memcpy (&mp->entry.tunnel_dst, &tun_dst,
14684 sizeof (mp->entry.tunnel_dst));
14693 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
14695 unformat_input_t *i = vam->input;
14696 vl_api_ipsec_tunnel_if_add_del_t *mp;
14697 u32 local_spi = 0, remote_spi = 0;
14698 u32 crypto_alg = 0, integ_alg = 0;
14699 u8 *lck = NULL, *rck = NULL;
14700 u8 *lik = NULL, *rik = NULL;
14701 vl_api_address_t local_ip = { 0 };
14702 vl_api_address_t remote_ip = { 0 };
14706 u8 anti_replay = 0;
14712 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14714 if (unformat (i, "del"))
14716 else if (unformat (i, "esn"))
14718 else if (unformat (i, "anti-replay"))
14720 else if (unformat (i, "count %d", &count))
14722 else if (unformat (i, "local_spi %d", &local_spi))
14724 else if (unformat (i, "remote_spi %d", &remote_spi))
14727 if (unformat (i, "local_ip %U", unformat_vl_api_address, &local_ip))
14730 if (unformat (i, "remote_ip %U", unformat_vl_api_address, &remote_ip))
14732 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
14735 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
14737 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
14739 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
14743 (i, "crypto_alg %U", unformat_ipsec_api_crypto_alg, &crypto_alg))
14745 if (crypto_alg >= IPSEC_CRYPTO_N_ALG)
14747 errmsg ("unsupported crypto-alg: '%U'\n",
14748 format_ipsec_crypto_alg, crypto_alg);
14754 (i, "integ_alg %U", unformat_ipsec_api_integ_alg, &integ_alg))
14756 if (integ_alg >= IPSEC_INTEG_N_ALG)
14758 errmsg ("unsupported integ-alg: '%U'\n",
14759 format_ipsec_integ_alg, integ_alg);
14763 else if (unformat (i, "instance %u", &instance))
14767 errmsg ("parse error '%U'\n", format_unformat_error, i);
14774 /* Turn on async mode */
14775 vam->async_mode = 1;
14776 vam->async_errors = 0;
14777 before = vat_time_now (vam);
14780 for (jj = 0; jj < count; jj++)
14782 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
14784 mp->is_add = is_add;
14786 mp->anti_replay = anti_replay;
14789 increment_address (&remote_ip);
14791 clib_memcpy (&mp->local_ip, &local_ip, sizeof (local_ip));
14792 clib_memcpy (&mp->remote_ip, &remote_ip, sizeof (remote_ip));
14794 mp->local_spi = htonl (local_spi + jj);
14795 mp->remote_spi = htonl (remote_spi + jj);
14796 mp->crypto_alg = (u8) crypto_alg;
14798 mp->local_crypto_key_len = 0;
14801 mp->local_crypto_key_len = vec_len (lck);
14802 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
14803 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
14804 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
14807 mp->remote_crypto_key_len = 0;
14810 mp->remote_crypto_key_len = vec_len (rck);
14811 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
14812 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
14813 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
14816 mp->integ_alg = (u8) integ_alg;
14818 mp->local_integ_key_len = 0;
14821 mp->local_integ_key_len = vec_len (lik);
14822 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
14823 mp->local_integ_key_len = sizeof (mp->local_integ_key);
14824 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
14827 mp->remote_integ_key_len = 0;
14830 mp->remote_integ_key_len = vec_len (rik);
14831 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
14832 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
14833 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
14838 mp->renumber = renumber;
14839 mp->show_instance = ntohl (instance);
14844 /* When testing multiple add/del ops, use a control-ping to sync */
14847 vl_api_control_ping_t *mp_ping;
14851 /* Shut off async mode */
14852 vam->async_mode = 0;
14854 MPING (CONTROL_PING, mp_ping);
14857 timeout = vat_time_now (vam) + 1.0;
14858 while (vat_time_now (vam) < timeout)
14859 if (vam->result_ready == 1)
14864 if (vam->retval == -99)
14865 errmsg ("timeout");
14867 if (vam->async_errors > 0)
14869 errmsg ("%d asynchronous errors", vam->async_errors);
14872 vam->async_errors = 0;
14873 after = vat_time_now (vam);
14875 /* slim chance, but we might have eaten SIGTERM on the first iteration */
14879 print (vam->ofp, "%d tunnels in %.6f secs, %.2f tunnels/sec",
14880 count, after - before, count / (after - before));
14884 /* Wait for a reply... */
14893 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
14895 vat_main_t *vam = &vat_main;
14897 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
14898 "crypto_key %U integ_alg %u integ_key %U flags %x "
14899 "tunnel_src_addr %U tunnel_dst_addr %U "
14900 "salt %u seq_outbound %lu last_seq_inbound %lu "
14901 "replay_window %lu\n",
14902 ntohl (mp->entry.sad_id),
14903 ntohl (mp->sw_if_index),
14904 ntohl (mp->entry.spi),
14905 ntohl (mp->entry.protocol),
14906 ntohl (mp->entry.crypto_algorithm),
14907 format_hex_bytes, mp->entry.crypto_key.data,
14908 mp->entry.crypto_key.length, ntohl (mp->entry.integrity_algorithm),
14909 format_hex_bytes, mp->entry.integrity_key.data,
14910 mp->entry.integrity_key.length, ntohl (mp->entry.flags),
14911 format_vl_api_address, &mp->entry.tunnel_src, format_vl_api_address,
14912 &mp->entry.tunnel_dst, ntohl (mp->salt),
14913 clib_net_to_host_u64 (mp->seq_outbound),
14914 clib_net_to_host_u64 (mp->last_seq_inbound),
14915 clib_net_to_host_u64 (mp->replay_window));
14918 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
14919 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
14921 static void vl_api_ipsec_sa_details_t_handler_json
14922 (vl_api_ipsec_sa_details_t * mp)
14924 vat_main_t *vam = &vat_main;
14925 vat_json_node_t *node = NULL;
14926 vl_api_ipsec_sad_flags_t flags;
14928 if (VAT_JSON_ARRAY != vam->json_tree.type)
14930 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14931 vat_json_init_array (&vam->json_tree);
14933 node = vat_json_array_add (&vam->json_tree);
14935 vat_json_init_object (node);
14936 vat_json_object_add_uint (node, "sa_id", ntohl (mp->entry.sad_id));
14937 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14938 vat_json_object_add_uint (node, "spi", ntohl (mp->entry.spi));
14939 vat_json_object_add_uint (node, "proto", ntohl (mp->entry.protocol));
14940 vat_json_object_add_uint (node, "crypto_alg",
14941 ntohl (mp->entry.crypto_algorithm));
14942 vat_json_object_add_uint (node, "integ_alg",
14943 ntohl (mp->entry.integrity_algorithm));
14944 flags = ntohl (mp->entry.flags);
14945 vat_json_object_add_uint (node, "use_esn",
14946 ! !(flags & IPSEC_API_SAD_FLAG_USE_ESN));
14947 vat_json_object_add_uint (node, "use_anti_replay",
14948 ! !(flags & IPSEC_API_SAD_FLAG_USE_ANTI_REPLAY));
14949 vat_json_object_add_uint (node, "is_tunnel",
14950 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL));
14951 vat_json_object_add_uint (node, "is_tunnel_ip6",
14952 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL_V6));
14953 vat_json_object_add_uint (node, "udp_encap",
14954 ! !(flags & IPSEC_API_SAD_FLAG_UDP_ENCAP));
14955 vat_json_object_add_bytes (node, "crypto_key", mp->entry.crypto_key.data,
14956 mp->entry.crypto_key.length);
14957 vat_json_object_add_bytes (node, "integ_key", mp->entry.integrity_key.data,
14958 mp->entry.integrity_key.length);
14959 vat_json_object_add_address (node, "src", &mp->entry.tunnel_src);
14960 vat_json_object_add_address (node, "dst", &mp->entry.tunnel_dst);
14961 vat_json_object_add_uint (node, "replay_window",
14962 clib_net_to_host_u64 (mp->replay_window));
14966 api_ipsec_sa_dump (vat_main_t * vam)
14968 unformat_input_t *i = vam->input;
14969 vl_api_ipsec_sa_dump_t *mp;
14970 vl_api_control_ping_t *mp_ping;
14974 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14976 if (unformat (i, "sa_id %d", &sa_id))
14980 clib_warning ("parse error '%U'", format_unformat_error, i);
14985 M (IPSEC_SA_DUMP, mp);
14987 mp->sa_id = ntohl (sa_id);
14991 /* Use a control ping for synchronization */
14992 M (CONTROL_PING, mp_ping);
15000 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
15002 unformat_input_t *i = vam->input;
15003 vl_api_ipsec_tunnel_if_set_sa_t *mp;
15004 u32 sw_if_index = ~0;
15006 u8 is_outbound = (u8) ~ 0;
15009 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15011 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15013 else if (unformat (i, "sa_id %d", &sa_id))
15015 else if (unformat (i, "outbound"))
15017 else if (unformat (i, "inbound"))
15021 clib_warning ("parse error '%U'", format_unformat_error, i);
15026 if (sw_if_index == ~0)
15028 errmsg ("interface must be specified");
15034 errmsg ("SA ID must be specified");
15038 M (IPSEC_TUNNEL_IF_SET_SA, mp);
15040 mp->sw_if_index = htonl (sw_if_index);
15041 mp->sa_id = htonl (sa_id);
15042 mp->is_outbound = is_outbound;
15051 api_get_first_msg_id (vat_main_t * vam)
15053 vl_api_get_first_msg_id_t *mp;
15054 unformat_input_t *i = vam->input;
15059 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15061 if (unformat (i, "client %s", &name))
15069 errmsg ("missing client name");
15072 vec_add1 (name, 0);
15074 if (vec_len (name) > 63)
15076 errmsg ("client name too long");
15080 M (GET_FIRST_MSG_ID, mp);
15081 clib_memcpy (mp->name, name, vec_len (name));
15088 api_cop_interface_enable_disable (vat_main_t * vam)
15090 unformat_input_t *line_input = vam->input;
15091 vl_api_cop_interface_enable_disable_t *mp;
15092 u32 sw_if_index = ~0;
15093 u8 enable_disable = 1;
15096 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15098 if (unformat (line_input, "disable"))
15099 enable_disable = 0;
15100 if (unformat (line_input, "enable"))
15101 enable_disable = 1;
15102 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
15103 vam, &sw_if_index))
15105 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
15111 if (sw_if_index == ~0)
15113 errmsg ("missing interface name or sw_if_index");
15117 /* Construct the API message */
15118 M (COP_INTERFACE_ENABLE_DISABLE, mp);
15119 mp->sw_if_index = ntohl (sw_if_index);
15120 mp->enable_disable = enable_disable;
15124 /* Wait for the reply */
15130 api_cop_whitelist_enable_disable (vat_main_t * vam)
15132 unformat_input_t *line_input = vam->input;
15133 vl_api_cop_whitelist_enable_disable_t *mp;
15134 u32 sw_if_index = ~0;
15135 u8 ip4 = 0, ip6 = 0, default_cop = 0;
15139 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15141 if (unformat (line_input, "ip4"))
15143 else if (unformat (line_input, "ip6"))
15145 else if (unformat (line_input, "default"))
15147 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
15148 vam, &sw_if_index))
15150 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
15152 else if (unformat (line_input, "fib-id %d", &fib_id))
15158 if (sw_if_index == ~0)
15160 errmsg ("missing interface name or sw_if_index");
15164 /* Construct the API message */
15165 M (COP_WHITELIST_ENABLE_DISABLE, mp);
15166 mp->sw_if_index = ntohl (sw_if_index);
15167 mp->fib_id = ntohl (fib_id);
15170 mp->default_cop = default_cop;
15174 /* Wait for the reply */
15180 api_get_node_graph (vat_main_t * vam)
15182 vl_api_get_node_graph_t *mp;
15185 M (GET_NODE_GRAPH, mp);
15189 /* Wait for the reply */
15195 /** Used for parsing LISP eids */
15196 typedef CLIB_PACKED(struct{
15197 u8 addr[16]; /**< eid address */
15198 u32 len; /**< prefix length if IP */
15199 u8 type; /**< type of eid */
15204 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
15206 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
15208 clib_memset (a, 0, sizeof (a[0]));
15210 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
15212 a->type = 0; /* ipv4 type */
15214 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
15216 a->type = 1; /* ipv6 type */
15218 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
15220 a->type = 2; /* mac type */
15222 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
15224 a->type = 3; /* NSH type */
15225 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
15226 nsh->spi = clib_host_to_net_u32 (nsh->spi);
15233 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
15242 lisp_eid_size_vat (u8 type)
15259 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
15261 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
15265 api_one_add_del_locator_set (vat_main_t * vam)
15267 unformat_input_t *input = vam->input;
15268 vl_api_one_add_del_locator_set_t *mp;
15270 u8 *locator_set_name = NULL;
15271 u8 locator_set_name_set = 0;
15272 vl_api_local_locator_t locator, *locators = 0;
15273 u32 sw_if_index, priority, weight;
15277 /* Parse args required to build the message */
15278 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15280 if (unformat (input, "del"))
15284 else if (unformat (input, "locator-set %s", &locator_set_name))
15286 locator_set_name_set = 1;
15288 else if (unformat (input, "sw_if_index %u p %u w %u",
15289 &sw_if_index, &priority, &weight))
15291 locator.sw_if_index = htonl (sw_if_index);
15292 locator.priority = priority;
15293 locator.weight = weight;
15294 vec_add1 (locators, locator);
15298 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
15299 &sw_if_index, &priority, &weight))
15301 locator.sw_if_index = htonl (sw_if_index);
15302 locator.priority = priority;
15303 locator.weight = weight;
15304 vec_add1 (locators, locator);
15310 if (locator_set_name_set == 0)
15312 errmsg ("missing locator-set name");
15313 vec_free (locators);
15317 if (vec_len (locator_set_name) > 64)
15319 errmsg ("locator-set name too long");
15320 vec_free (locator_set_name);
15321 vec_free (locators);
15324 vec_add1 (locator_set_name, 0);
15326 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
15328 /* Construct the API message */
15329 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
15331 mp->is_add = is_add;
15332 clib_memcpy (mp->locator_set_name, locator_set_name,
15333 vec_len (locator_set_name));
15334 vec_free (locator_set_name);
15336 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
15338 clib_memcpy (mp->locators, locators, data_len);
15339 vec_free (locators);
15344 /* Wait for a reply... */
15349 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
15352 api_one_add_del_locator (vat_main_t * vam)
15354 unformat_input_t *input = vam->input;
15355 vl_api_one_add_del_locator_t *mp;
15356 u32 tmp_if_index = ~0;
15357 u32 sw_if_index = ~0;
15358 u8 sw_if_index_set = 0;
15359 u8 sw_if_index_if_name_set = 0;
15361 u8 priority_set = 0;
15365 u8 *locator_set_name = NULL;
15366 u8 locator_set_name_set = 0;
15369 /* Parse args required to build the message */
15370 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15372 if (unformat (input, "del"))
15376 else if (unformat (input, "locator-set %s", &locator_set_name))
15378 locator_set_name_set = 1;
15380 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
15383 sw_if_index_if_name_set = 1;
15384 sw_if_index = tmp_if_index;
15386 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
15388 sw_if_index_set = 1;
15389 sw_if_index = tmp_if_index;
15391 else if (unformat (input, "p %d", &priority))
15395 else if (unformat (input, "w %d", &weight))
15403 if (locator_set_name_set == 0)
15405 errmsg ("missing locator-set name");
15409 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
15411 errmsg ("missing sw_if_index");
15412 vec_free (locator_set_name);
15416 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
15418 errmsg ("cannot use both params interface name and sw_if_index");
15419 vec_free (locator_set_name);
15423 if (priority_set == 0)
15425 errmsg ("missing locator-set priority");
15426 vec_free (locator_set_name);
15430 if (weight_set == 0)
15432 errmsg ("missing locator-set weight");
15433 vec_free (locator_set_name);
15437 if (vec_len (locator_set_name) > 64)
15439 errmsg ("locator-set name too long");
15440 vec_free (locator_set_name);
15443 vec_add1 (locator_set_name, 0);
15445 /* Construct the API message */
15446 M (ONE_ADD_DEL_LOCATOR, mp);
15448 mp->is_add = is_add;
15449 mp->sw_if_index = ntohl (sw_if_index);
15450 mp->priority = priority;
15451 mp->weight = weight;
15452 clib_memcpy (mp->locator_set_name, locator_set_name,
15453 vec_len (locator_set_name));
15454 vec_free (locator_set_name);
15459 /* Wait for a reply... */
15464 #define api_lisp_add_del_locator api_one_add_del_locator
15467 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
15469 u32 *key_id = va_arg (*args, u32 *);
15472 if (unformat (input, "%s", &s))
15474 if (!strcmp ((char *) s, "sha1"))
15475 key_id[0] = HMAC_SHA_1_96;
15476 else if (!strcmp ((char *) s, "sha256"))
15477 key_id[0] = HMAC_SHA_256_128;
15480 clib_warning ("invalid key_id: '%s'", s);
15481 key_id[0] = HMAC_NO_KEY;
15492 api_one_add_del_local_eid (vat_main_t * vam)
15494 unformat_input_t *input = vam->input;
15495 vl_api_one_add_del_local_eid_t *mp;
15498 lisp_eid_vat_t _eid, *eid = &_eid;
15499 u8 *locator_set_name = 0;
15500 u8 locator_set_name_set = 0;
15506 /* Parse args required to build the message */
15507 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15509 if (unformat (input, "del"))
15513 else if (unformat (input, "vni %d", &vni))
15517 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
15521 else if (unformat (input, "locator-set %s", &locator_set_name))
15523 locator_set_name_set = 1;
15525 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
15527 else if (unformat (input, "secret-key %_%v%_", &key))
15533 if (locator_set_name_set == 0)
15535 errmsg ("missing locator-set name");
15541 errmsg ("EID address not set!");
15542 vec_free (locator_set_name);
15546 if (key && (0 == key_id))
15548 errmsg ("invalid key_id!");
15552 if (vec_len (key) > 64)
15554 errmsg ("key too long");
15559 if (vec_len (locator_set_name) > 64)
15561 errmsg ("locator-set name too long");
15562 vec_free (locator_set_name);
15565 vec_add1 (locator_set_name, 0);
15567 /* Construct the API message */
15568 M (ONE_ADD_DEL_LOCAL_EID, mp);
15570 mp->is_add = is_add;
15571 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
15572 mp->eid_type = eid->type;
15573 mp->prefix_len = eid->len;
15574 mp->vni = clib_host_to_net_u32 (vni);
15575 mp->key_id = clib_host_to_net_u16 (key_id);
15576 clib_memcpy (mp->locator_set_name, locator_set_name,
15577 vec_len (locator_set_name));
15578 clib_memcpy (mp->key, key, vec_len (key));
15580 vec_free (locator_set_name);
15586 /* Wait for a reply... */
15591 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
15594 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
15596 u32 dp_table = 0, vni = 0;;
15597 unformat_input_t *input = vam->input;
15598 vl_api_gpe_add_del_fwd_entry_t *mp;
15600 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
15601 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
15602 u8 rmt_eid_set = 0, lcl_eid_set = 0;
15603 u32 action = ~0, w;
15604 ip4_address_t rmt_rloc4, lcl_rloc4;
15605 ip6_address_t rmt_rloc6, lcl_rloc6;
15606 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
15609 clib_memset (&rloc, 0, sizeof (rloc));
15611 /* Parse args required to build the message */
15612 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15614 if (unformat (input, "del"))
15616 else if (unformat (input, "add"))
15618 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
15622 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
15626 else if (unformat (input, "vrf %d", &dp_table))
15628 else if (unformat (input, "bd %d", &dp_table))
15630 else if (unformat (input, "vni %d", &vni))
15632 else if (unformat (input, "w %d", &w))
15636 errmsg ("No RLOC configured for setting priority/weight!");
15639 curr_rloc->weight = w;
15641 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
15642 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
15646 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
15648 vec_add1 (lcl_locs, rloc);
15650 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
15651 vec_add1 (rmt_locs, rloc);
15652 /* weight saved in rmt loc */
15653 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
15655 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
15656 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
15659 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
15661 vec_add1 (lcl_locs, rloc);
15663 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
15664 vec_add1 (rmt_locs, rloc);
15665 /* weight saved in rmt loc */
15666 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
15668 else if (unformat (input, "action %d", &action))
15674 clib_warning ("parse error '%U'", format_unformat_error, input);
15681 errmsg ("remote eid addresses not set");
15685 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
15687 errmsg ("eid types don't match");
15691 if (0 == rmt_locs && (u32) ~ 0 == action)
15693 errmsg ("action not set for negative mapping");
15697 /* Construct the API message */
15698 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
15699 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
15701 mp->is_add = is_add;
15702 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
15703 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
15704 mp->eid_type = rmt_eid->type;
15705 mp->dp_table = clib_host_to_net_u32 (dp_table);
15706 mp->vni = clib_host_to_net_u32 (vni);
15707 mp->rmt_len = rmt_eid->len;
15708 mp->lcl_len = lcl_eid->len;
15709 mp->action = action;
15711 if (0 != rmt_locs && 0 != lcl_locs)
15713 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
15714 clib_memcpy (mp->locs, lcl_locs,
15715 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
15717 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
15718 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
15719 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
15721 vec_free (lcl_locs);
15722 vec_free (rmt_locs);
15727 /* Wait for a reply... */
15733 api_one_add_del_map_server (vat_main_t * vam)
15735 unformat_input_t *input = vam->input;
15736 vl_api_one_add_del_map_server_t *mp;
15740 ip4_address_t ipv4;
15741 ip6_address_t ipv6;
15744 /* Parse args required to build the message */
15745 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15747 if (unformat (input, "del"))
15751 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
15755 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
15763 if (ipv4_set && ipv6_set)
15765 errmsg ("both eid v4 and v6 addresses set");
15769 if (!ipv4_set && !ipv6_set)
15771 errmsg ("eid addresses not set");
15775 /* Construct the API message */
15776 M (ONE_ADD_DEL_MAP_SERVER, mp);
15778 mp->is_add = is_add;
15782 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
15787 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
15793 /* Wait for a reply... */
15798 #define api_lisp_add_del_map_server api_one_add_del_map_server
15801 api_one_add_del_map_resolver (vat_main_t * vam)
15803 unformat_input_t *input = vam->input;
15804 vl_api_one_add_del_map_resolver_t *mp;
15808 ip4_address_t ipv4;
15809 ip6_address_t ipv6;
15812 /* Parse args required to build the message */
15813 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15815 if (unformat (input, "del"))
15819 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
15823 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
15831 if (ipv4_set && ipv6_set)
15833 errmsg ("both eid v4 and v6 addresses set");
15837 if (!ipv4_set && !ipv6_set)
15839 errmsg ("eid addresses not set");
15843 /* Construct the API message */
15844 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
15846 mp->is_add = is_add;
15850 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
15855 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
15861 /* Wait for a reply... */
15866 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
15869 api_lisp_gpe_enable_disable (vat_main_t * vam)
15871 unformat_input_t *input = vam->input;
15872 vl_api_gpe_enable_disable_t *mp;
15877 /* Parse args required to build the message */
15878 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15880 if (unformat (input, "enable"))
15885 else if (unformat (input, "disable"))
15896 errmsg ("Value not set");
15900 /* Construct the API message */
15901 M (GPE_ENABLE_DISABLE, mp);
15908 /* Wait for a reply... */
15914 api_one_rloc_probe_enable_disable (vat_main_t * vam)
15916 unformat_input_t *input = vam->input;
15917 vl_api_one_rloc_probe_enable_disable_t *mp;
15922 /* Parse args required to build the message */
15923 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15925 if (unformat (input, "enable"))
15930 else if (unformat (input, "disable"))
15938 errmsg ("Value not set");
15942 /* Construct the API message */
15943 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
15945 mp->is_enabled = is_en;
15950 /* Wait for a reply... */
15955 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
15958 api_one_map_register_enable_disable (vat_main_t * vam)
15960 unformat_input_t *input = vam->input;
15961 vl_api_one_map_register_enable_disable_t *mp;
15966 /* Parse args required to build the message */
15967 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15969 if (unformat (input, "enable"))
15974 else if (unformat (input, "disable"))
15982 errmsg ("Value not set");
15986 /* Construct the API message */
15987 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
15989 mp->is_enabled = is_en;
15994 /* Wait for a reply... */
15999 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
16002 api_one_enable_disable (vat_main_t * vam)
16004 unformat_input_t *input = vam->input;
16005 vl_api_one_enable_disable_t *mp;
16010 /* Parse args required to build the message */
16011 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16013 if (unformat (input, "enable"))
16018 else if (unformat (input, "disable"))
16028 errmsg ("Value not set");
16032 /* Construct the API message */
16033 M (ONE_ENABLE_DISABLE, mp);
16040 /* Wait for a reply... */
16045 #define api_lisp_enable_disable api_one_enable_disable
16048 api_one_enable_disable_xtr_mode (vat_main_t * vam)
16050 unformat_input_t *input = vam->input;
16051 vl_api_one_enable_disable_xtr_mode_t *mp;
16056 /* Parse args required to build the message */
16057 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16059 if (unformat (input, "enable"))
16064 else if (unformat (input, "disable"))
16074 errmsg ("Value not set");
16078 /* Construct the API message */
16079 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
16086 /* Wait for a reply... */
16092 api_one_show_xtr_mode (vat_main_t * vam)
16094 vl_api_one_show_xtr_mode_t *mp;
16097 /* Construct the API message */
16098 M (ONE_SHOW_XTR_MODE, mp);
16103 /* Wait for a reply... */
16109 api_one_enable_disable_pitr_mode (vat_main_t * vam)
16111 unformat_input_t *input = vam->input;
16112 vl_api_one_enable_disable_pitr_mode_t *mp;
16117 /* Parse args required to build the message */
16118 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16120 if (unformat (input, "enable"))
16125 else if (unformat (input, "disable"))
16135 errmsg ("Value not set");
16139 /* Construct the API message */
16140 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
16147 /* Wait for a reply... */
16153 api_one_show_pitr_mode (vat_main_t * vam)
16155 vl_api_one_show_pitr_mode_t *mp;
16158 /* Construct the API message */
16159 M (ONE_SHOW_PITR_MODE, mp);
16164 /* Wait for a reply... */
16170 api_one_enable_disable_petr_mode (vat_main_t * vam)
16172 unformat_input_t *input = vam->input;
16173 vl_api_one_enable_disable_petr_mode_t *mp;
16178 /* Parse args required to build the message */
16179 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16181 if (unformat (input, "enable"))
16186 else if (unformat (input, "disable"))
16196 errmsg ("Value not set");
16200 /* Construct the API message */
16201 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
16208 /* Wait for a reply... */
16214 api_one_show_petr_mode (vat_main_t * vam)
16216 vl_api_one_show_petr_mode_t *mp;
16219 /* Construct the API message */
16220 M (ONE_SHOW_PETR_MODE, mp);
16225 /* Wait for a reply... */
16231 api_show_one_map_register_state (vat_main_t * vam)
16233 vl_api_show_one_map_register_state_t *mp;
16236 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
16241 /* wait for reply */
16246 #define api_show_lisp_map_register_state api_show_one_map_register_state
16249 api_show_one_rloc_probe_state (vat_main_t * vam)
16251 vl_api_show_one_rloc_probe_state_t *mp;
16254 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
16259 /* wait for reply */
16264 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
16267 api_one_add_del_ndp_entry (vat_main_t * vam)
16269 vl_api_one_add_del_ndp_entry_t *mp;
16270 unformat_input_t *input = vam->input;
16275 u8 mac[6] = { 0, };
16276 u8 ip6[16] = { 0, };
16280 /* Parse args required to build the message */
16281 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16283 if (unformat (input, "del"))
16285 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
16287 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
16289 else if (unformat (input, "bd %d", &bd))
16293 errmsg ("parse error '%U'", format_unformat_error, input);
16298 if (!bd_set || !ip_set || (!mac_set && is_add))
16300 errmsg ("Missing BD, IP or MAC!");
16304 M (ONE_ADD_DEL_NDP_ENTRY, mp);
16305 mp->is_add = is_add;
16306 clib_memcpy (mp->mac, mac, 6);
16307 mp->bd = clib_host_to_net_u32 (bd);
16308 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
16313 /* wait for reply */
16319 api_one_add_del_l2_arp_entry (vat_main_t * vam)
16321 vl_api_one_add_del_l2_arp_entry_t *mp;
16322 unformat_input_t *input = vam->input;
16327 u8 mac[6] = { 0, };
16328 u32 ip4 = 0, bd = ~0;
16331 /* Parse args required to build the message */
16332 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16334 if (unformat (input, "del"))
16336 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
16338 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
16340 else if (unformat (input, "bd %d", &bd))
16344 errmsg ("parse error '%U'", format_unformat_error, input);
16349 if (!bd_set || !ip_set || (!mac_set && is_add))
16351 errmsg ("Missing BD, IP or MAC!");
16355 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
16356 mp->is_add = is_add;
16357 clib_memcpy (mp->mac, mac, 6);
16358 mp->bd = clib_host_to_net_u32 (bd);
16364 /* wait for reply */
16370 api_one_ndp_bd_get (vat_main_t * vam)
16372 vl_api_one_ndp_bd_get_t *mp;
16375 M (ONE_NDP_BD_GET, mp);
16380 /* wait for reply */
16386 api_one_ndp_entries_get (vat_main_t * vam)
16388 vl_api_one_ndp_entries_get_t *mp;
16389 unformat_input_t *input = vam->input;
16394 /* Parse args required to build the message */
16395 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16397 if (unformat (input, "bd %d", &bd))
16401 errmsg ("parse error '%U'", format_unformat_error, input);
16408 errmsg ("Expected bridge domain!");
16412 M (ONE_NDP_ENTRIES_GET, mp);
16413 mp->bd = clib_host_to_net_u32 (bd);
16418 /* wait for reply */
16424 api_one_l2_arp_bd_get (vat_main_t * vam)
16426 vl_api_one_l2_arp_bd_get_t *mp;
16429 M (ONE_L2_ARP_BD_GET, mp);
16434 /* wait for reply */
16440 api_one_l2_arp_entries_get (vat_main_t * vam)
16442 vl_api_one_l2_arp_entries_get_t *mp;
16443 unformat_input_t *input = vam->input;
16448 /* Parse args required to build the message */
16449 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16451 if (unformat (input, "bd %d", &bd))
16455 errmsg ("parse error '%U'", format_unformat_error, input);
16462 errmsg ("Expected bridge domain!");
16466 M (ONE_L2_ARP_ENTRIES_GET, mp);
16467 mp->bd = clib_host_to_net_u32 (bd);
16472 /* wait for reply */
16478 api_one_stats_enable_disable (vat_main_t * vam)
16480 vl_api_one_stats_enable_disable_t *mp;
16481 unformat_input_t *input = vam->input;
16486 /* Parse args required to build the message */
16487 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16489 if (unformat (input, "enable"))
16494 else if (unformat (input, "disable"))
16504 errmsg ("Value not set");
16508 M (ONE_STATS_ENABLE_DISABLE, mp);
16514 /* wait for reply */
16520 api_show_one_stats_enable_disable (vat_main_t * vam)
16522 vl_api_show_one_stats_enable_disable_t *mp;
16525 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
16530 /* wait for reply */
16536 api_show_one_map_request_mode (vat_main_t * vam)
16538 vl_api_show_one_map_request_mode_t *mp;
16541 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
16546 /* wait for reply */
16551 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
16554 api_one_map_request_mode (vat_main_t * vam)
16556 unformat_input_t *input = vam->input;
16557 vl_api_one_map_request_mode_t *mp;
16561 /* Parse args required to build the message */
16562 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16564 if (unformat (input, "dst-only"))
16566 else if (unformat (input, "src-dst"))
16570 errmsg ("parse error '%U'", format_unformat_error, input);
16575 M (ONE_MAP_REQUEST_MODE, mp);
16582 /* wait for reply */
16587 #define api_lisp_map_request_mode api_one_map_request_mode
16590 * Enable/disable ONE proxy ITR.
16592 * @param vam vpp API test context
16593 * @return return code
16596 api_one_pitr_set_locator_set (vat_main_t * vam)
16598 u8 ls_name_set = 0;
16599 unformat_input_t *input = vam->input;
16600 vl_api_one_pitr_set_locator_set_t *mp;
16605 /* Parse args required to build the message */
16606 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16608 if (unformat (input, "del"))
16610 else if (unformat (input, "locator-set %s", &ls_name))
16614 errmsg ("parse error '%U'", format_unformat_error, input);
16621 errmsg ("locator-set name not set!");
16625 M (ONE_PITR_SET_LOCATOR_SET, mp);
16627 mp->is_add = is_add;
16628 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
16629 vec_free (ls_name);
16634 /* wait for reply */
16639 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
16642 api_one_nsh_set_locator_set (vat_main_t * vam)
16644 u8 ls_name_set = 0;
16645 unformat_input_t *input = vam->input;
16646 vl_api_one_nsh_set_locator_set_t *mp;
16651 /* Parse args required to build the message */
16652 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16654 if (unformat (input, "del"))
16656 else if (unformat (input, "ls %s", &ls_name))
16660 errmsg ("parse error '%U'", format_unformat_error, input);
16665 if (!ls_name_set && is_add)
16667 errmsg ("locator-set name not set!");
16671 M (ONE_NSH_SET_LOCATOR_SET, mp);
16673 mp->is_add = is_add;
16674 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
16675 vec_free (ls_name);
16680 /* wait for reply */
16686 api_show_one_pitr (vat_main_t * vam)
16688 vl_api_show_one_pitr_t *mp;
16691 if (!vam->json_output)
16693 print (vam->ofp, "%=20s", "lisp status:");
16696 M (SHOW_ONE_PITR, mp);
16700 /* Wait for a reply... */
16705 #define api_show_lisp_pitr api_show_one_pitr
16708 api_one_use_petr (vat_main_t * vam)
16710 unformat_input_t *input = vam->input;
16711 vl_api_one_use_petr_t *mp;
16716 clib_memset (&ip, 0, sizeof (ip));
16718 /* Parse args required to build the message */
16719 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16721 if (unformat (input, "disable"))
16724 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
16727 ip_addr_version (&ip) = IP4;
16730 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
16733 ip_addr_version (&ip) = IP6;
16737 errmsg ("parse error '%U'", format_unformat_error, input);
16742 M (ONE_USE_PETR, mp);
16744 mp->is_add = is_add;
16747 mp->is_ip4 = ip_addr_version (&ip) == IP4 ? 1 : 0;
16749 clib_memcpy (mp->address, &ip, 4);
16751 clib_memcpy (mp->address, &ip, 16);
16757 /* wait for reply */
16762 #define api_lisp_use_petr api_one_use_petr
16765 api_show_one_nsh_mapping (vat_main_t * vam)
16767 vl_api_show_one_use_petr_t *mp;
16770 if (!vam->json_output)
16772 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
16775 M (SHOW_ONE_NSH_MAPPING, mp);
16779 /* Wait for a reply... */
16785 api_show_one_use_petr (vat_main_t * vam)
16787 vl_api_show_one_use_petr_t *mp;
16790 if (!vam->json_output)
16792 print (vam->ofp, "%=20s", "Proxy-ETR status:");
16795 M (SHOW_ONE_USE_PETR, mp);
16799 /* Wait for a reply... */
16804 #define api_show_lisp_use_petr api_show_one_use_petr
16807 * Add/delete mapping between vni and vrf
16810 api_one_eid_table_add_del_map (vat_main_t * vam)
16812 unformat_input_t *input = vam->input;
16813 vl_api_one_eid_table_add_del_map_t *mp;
16814 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
16815 u32 vni, vrf, bd_index;
16818 /* Parse args required to build the message */
16819 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16821 if (unformat (input, "del"))
16823 else if (unformat (input, "vrf %d", &vrf))
16825 else if (unformat (input, "bd_index %d", &bd_index))
16827 else if (unformat (input, "vni %d", &vni))
16833 if (!vni_set || (!vrf_set && !bd_index_set))
16835 errmsg ("missing arguments!");
16839 if (vrf_set && bd_index_set)
16841 errmsg ("error: both vrf and bd entered!");
16845 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
16847 mp->is_add = is_add;
16848 mp->vni = htonl (vni);
16849 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
16850 mp->is_l2 = bd_index_set;
16855 /* wait for reply */
16860 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
16863 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
16865 u32 *action = va_arg (*args, u32 *);
16868 if (unformat (input, "%s", &s))
16870 if (!strcmp ((char *) s, "no-action"))
16872 else if (!strcmp ((char *) s, "natively-forward"))
16874 else if (!strcmp ((char *) s, "send-map-request"))
16876 else if (!strcmp ((char *) s, "drop"))
16880 clib_warning ("invalid action: '%s'", s);
16892 * Add/del remote mapping to/from ONE control plane
16894 * @param vam vpp API test context
16895 * @return return code
16898 api_one_add_del_remote_mapping (vat_main_t * vam)
16900 unformat_input_t *input = vam->input;
16901 vl_api_one_add_del_remote_mapping_t *mp;
16903 lisp_eid_vat_t _eid, *eid = &_eid;
16904 lisp_eid_vat_t _seid, *seid = &_seid;
16905 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
16906 u32 action = ~0, p, w, data_len;
16907 ip4_address_t rloc4;
16908 ip6_address_t rloc6;
16909 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
16912 clib_memset (&rloc, 0, sizeof (rloc));
16914 /* Parse args required to build the message */
16915 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16917 if (unformat (input, "del-all"))
16921 else if (unformat (input, "del"))
16925 else if (unformat (input, "add"))
16929 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
16933 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
16937 else if (unformat (input, "vni %d", &vni))
16941 else if (unformat (input, "p %d w %d", &p, &w))
16945 errmsg ("No RLOC configured for setting priority/weight!");
16948 curr_rloc->priority = p;
16949 curr_rloc->weight = w;
16951 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
16954 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
16955 vec_add1 (rlocs, rloc);
16956 curr_rloc = &rlocs[vec_len (rlocs) - 1];
16958 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
16961 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
16962 vec_add1 (rlocs, rloc);
16963 curr_rloc = &rlocs[vec_len (rlocs) - 1];
16965 else if (unformat (input, "action %U",
16966 unformat_negative_mapping_action, &action))
16972 clib_warning ("parse error '%U'", format_unformat_error, input);
16979 errmsg ("missing params!");
16983 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
16985 errmsg ("no action set for negative map-reply!");
16989 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
16991 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
16992 mp->is_add = is_add;
16993 mp->vni = htonl (vni);
16994 mp->action = (u8) action;
16995 mp->is_src_dst = seid_set;
16996 mp->eid_len = eid->len;
16997 mp->seid_len = seid->len;
16998 mp->del_all = del_all;
16999 mp->eid_type = eid->type;
17000 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
17001 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
17003 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
17004 clib_memcpy (mp->rlocs, rlocs, data_len);
17010 /* Wait for a reply... */
17015 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
17018 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
17019 * forwarding entries in data-plane accordingly.
17021 * @param vam vpp API test context
17022 * @return return code
17025 api_one_add_del_adjacency (vat_main_t * vam)
17027 unformat_input_t *input = vam->input;
17028 vl_api_one_add_del_adjacency_t *mp;
17030 ip4_address_t leid4, reid4;
17031 ip6_address_t leid6, reid6;
17032 u8 reid_mac[6] = { 0 };
17033 u8 leid_mac[6] = { 0 };
17034 u8 reid_type, leid_type;
17035 u32 leid_len = 0, reid_len = 0, len;
17039 leid_type = reid_type = (u8) ~ 0;
17041 /* Parse args required to build the message */
17042 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17044 if (unformat (input, "del"))
17048 else if (unformat (input, "add"))
17052 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
17055 reid_type = 0; /* ipv4 */
17058 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
17061 reid_type = 1; /* ipv6 */
17064 else if (unformat (input, "reid %U", unformat_ethernet_address,
17067 reid_type = 2; /* mac */
17069 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
17072 leid_type = 0; /* ipv4 */
17075 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
17078 leid_type = 1; /* ipv6 */
17081 else if (unformat (input, "leid %U", unformat_ethernet_address,
17084 leid_type = 2; /* mac */
17086 else if (unformat (input, "vni %d", &vni))
17092 errmsg ("parse error '%U'", format_unformat_error, input);
17097 if ((u8) ~ 0 == reid_type)
17099 errmsg ("missing params!");
17103 if (leid_type != reid_type)
17105 errmsg ("remote and local EIDs are of different types!");
17109 M (ONE_ADD_DEL_ADJACENCY, mp);
17110 mp->is_add = is_add;
17111 mp->vni = htonl (vni);
17112 mp->leid_len = leid_len;
17113 mp->reid_len = reid_len;
17114 mp->eid_type = reid_type;
17116 switch (mp->eid_type)
17119 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
17120 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
17123 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
17124 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
17127 clib_memcpy (mp->leid, leid_mac, 6);
17128 clib_memcpy (mp->reid, reid_mac, 6);
17131 errmsg ("unknown EID type %d!", mp->eid_type);
17138 /* Wait for a reply... */
17143 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
17146 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
17148 u32 *mode = va_arg (*args, u32 *);
17150 if (unformat (input, "lisp"))
17152 else if (unformat (input, "vxlan"))
17161 api_gpe_get_encap_mode (vat_main_t * vam)
17163 vl_api_gpe_get_encap_mode_t *mp;
17166 /* Construct the API message */
17167 M (GPE_GET_ENCAP_MODE, mp);
17172 /* Wait for a reply... */
17178 api_gpe_set_encap_mode (vat_main_t * vam)
17180 unformat_input_t *input = vam->input;
17181 vl_api_gpe_set_encap_mode_t *mp;
17185 /* Parse args required to build the message */
17186 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17188 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
17194 /* Construct the API message */
17195 M (GPE_SET_ENCAP_MODE, mp);
17202 /* Wait for a reply... */
17208 api_lisp_gpe_add_del_iface (vat_main_t * vam)
17210 unformat_input_t *input = vam->input;
17211 vl_api_gpe_add_del_iface_t *mp;
17212 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
17213 u32 dp_table = 0, vni = 0;
17216 /* Parse args required to build the message */
17217 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17219 if (unformat (input, "up"))
17224 else if (unformat (input, "down"))
17229 else if (unformat (input, "table_id %d", &dp_table))
17233 else if (unformat (input, "bd_id %d", &dp_table))
17238 else if (unformat (input, "vni %d", &vni))
17246 if (action_set == 0)
17248 errmsg ("Action not set");
17251 if (dp_table_set == 0 || vni_set == 0)
17253 errmsg ("vni and dp_table must be set");
17257 /* Construct the API message */
17258 M (GPE_ADD_DEL_IFACE, mp);
17260 mp->is_add = is_add;
17261 mp->dp_table = clib_host_to_net_u32 (dp_table);
17263 mp->vni = clib_host_to_net_u32 (vni);
17268 /* Wait for a reply... */
17274 api_one_map_register_fallback_threshold (vat_main_t * vam)
17276 unformat_input_t *input = vam->input;
17277 vl_api_one_map_register_fallback_threshold_t *mp;
17282 /* Parse args required to build the message */
17283 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17285 if (unformat (input, "%u", &value))
17289 clib_warning ("parse error '%U'", format_unformat_error, input);
17296 errmsg ("fallback threshold value is missing!");
17300 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
17301 mp->value = clib_host_to_net_u32 (value);
17306 /* Wait for a reply... */
17312 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
17314 vl_api_show_one_map_register_fallback_threshold_t *mp;
17317 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
17322 /* Wait for a reply... */
17328 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
17330 u32 *proto = va_arg (*args, u32 *);
17332 if (unformat (input, "udp"))
17334 else if (unformat (input, "api"))
17343 api_one_set_transport_protocol (vat_main_t * vam)
17345 unformat_input_t *input = vam->input;
17346 vl_api_one_set_transport_protocol_t *mp;
17351 /* Parse args required to build the message */
17352 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17354 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
17358 clib_warning ("parse error '%U'", format_unformat_error, input);
17365 errmsg ("Transport protocol missing!");
17369 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
17370 mp->protocol = (u8) protocol;
17375 /* Wait for a reply... */
17381 api_one_get_transport_protocol (vat_main_t * vam)
17383 vl_api_one_get_transport_protocol_t *mp;
17386 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
17391 /* Wait for a reply... */
17397 api_one_map_register_set_ttl (vat_main_t * vam)
17399 unformat_input_t *input = vam->input;
17400 vl_api_one_map_register_set_ttl_t *mp;
17405 /* Parse args required to build the message */
17406 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17408 if (unformat (input, "%u", &ttl))
17412 clib_warning ("parse error '%U'", format_unformat_error, input);
17419 errmsg ("TTL value missing!");
17423 M (ONE_MAP_REGISTER_SET_TTL, mp);
17424 mp->ttl = clib_host_to_net_u32 (ttl);
17429 /* Wait for a reply... */
17435 api_show_one_map_register_ttl (vat_main_t * vam)
17437 vl_api_show_one_map_register_ttl_t *mp;
17440 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
17445 /* Wait for a reply... */
17451 * Add/del map request itr rlocs from ONE control plane and updates
17453 * @param vam vpp API test context
17454 * @return return code
17457 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
17459 unformat_input_t *input = vam->input;
17460 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
17461 u8 *locator_set_name = 0;
17462 u8 locator_set_name_set = 0;
17466 /* Parse args required to build the message */
17467 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17469 if (unformat (input, "del"))
17473 else if (unformat (input, "%_%v%_", &locator_set_name))
17475 locator_set_name_set = 1;
17479 clib_warning ("parse error '%U'", format_unformat_error, input);
17484 if (is_add && !locator_set_name_set)
17486 errmsg ("itr-rloc is not set!");
17490 if (is_add && vec_len (locator_set_name) > 64)
17492 errmsg ("itr-rloc locator-set name too long");
17493 vec_free (locator_set_name);
17497 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
17498 mp->is_add = is_add;
17501 clib_memcpy (mp->locator_set_name, locator_set_name,
17502 vec_len (locator_set_name));
17506 clib_memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
17508 vec_free (locator_set_name);
17513 /* Wait for a reply... */
17518 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
17521 api_one_locator_dump (vat_main_t * vam)
17523 unformat_input_t *input = vam->input;
17524 vl_api_one_locator_dump_t *mp;
17525 vl_api_control_ping_t *mp_ping;
17526 u8 is_index_set = 0, is_name_set = 0;
17531 /* Parse args required to build the message */
17532 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17534 if (unformat (input, "ls_name %_%v%_", &ls_name))
17538 else if (unformat (input, "ls_index %d", &ls_index))
17544 errmsg ("parse error '%U'", format_unformat_error, input);
17549 if (!is_index_set && !is_name_set)
17551 errmsg ("error: expected one of index or name!");
17555 if (is_index_set && is_name_set)
17557 errmsg ("error: only one param expected!");
17561 if (vec_len (ls_name) > 62)
17563 errmsg ("error: locator set name too long!");
17567 if (!vam->json_output)
17569 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
17572 M (ONE_LOCATOR_DUMP, mp);
17573 mp->is_index_set = is_index_set;
17576 mp->ls_index = clib_host_to_net_u32 (ls_index);
17579 vec_add1 (ls_name, 0);
17580 strncpy ((char *) mp->ls_name, (char *) ls_name,
17581 sizeof (mp->ls_name) - 1);
17587 /* Use a control ping for synchronization */
17588 MPING (CONTROL_PING, mp_ping);
17591 /* Wait for a reply... */
17596 #define api_lisp_locator_dump api_one_locator_dump
17599 api_one_locator_set_dump (vat_main_t * vam)
17601 vl_api_one_locator_set_dump_t *mp;
17602 vl_api_control_ping_t *mp_ping;
17603 unformat_input_t *input = vam->input;
17607 /* Parse args required to build the message */
17608 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17610 if (unformat (input, "local"))
17614 else if (unformat (input, "remote"))
17620 errmsg ("parse error '%U'", format_unformat_error, input);
17625 if (!vam->json_output)
17627 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
17630 M (ONE_LOCATOR_SET_DUMP, mp);
17632 mp->filter = filter;
17637 /* Use a control ping for synchronization */
17638 MPING (CONTROL_PING, mp_ping);
17641 /* Wait for a reply... */
17646 #define api_lisp_locator_set_dump api_one_locator_set_dump
17649 api_one_eid_table_map_dump (vat_main_t * vam)
17653 unformat_input_t *input = vam->input;
17654 vl_api_one_eid_table_map_dump_t *mp;
17655 vl_api_control_ping_t *mp_ping;
17658 /* Parse args required to build the message */
17659 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17661 if (unformat (input, "l2"))
17666 else if (unformat (input, "l3"))
17673 errmsg ("parse error '%U'", format_unformat_error, input);
17680 errmsg ("expected one of 'l2' or 'l3' parameter!");
17684 if (!vam->json_output)
17686 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
17689 M (ONE_EID_TABLE_MAP_DUMP, mp);
17695 /* Use a control ping for synchronization */
17696 MPING (CONTROL_PING, mp_ping);
17699 /* Wait for a reply... */
17704 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
17707 api_one_eid_table_vni_dump (vat_main_t * vam)
17709 vl_api_one_eid_table_vni_dump_t *mp;
17710 vl_api_control_ping_t *mp_ping;
17713 if (!vam->json_output)
17715 print (vam->ofp, "VNI");
17718 M (ONE_EID_TABLE_VNI_DUMP, mp);
17723 /* Use a control ping for synchronization */
17724 MPING (CONTROL_PING, mp_ping);
17727 /* Wait for a reply... */
17732 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
17735 api_one_eid_table_dump (vat_main_t * vam)
17737 unformat_input_t *i = vam->input;
17738 vl_api_one_eid_table_dump_t *mp;
17739 vl_api_control_ping_t *mp_ping;
17740 struct in_addr ip4;
17741 struct in6_addr ip6;
17743 u8 eid_type = ~0, eid_set = 0;
17744 u32 prefix_length = ~0, t, vni = 0;
17747 lisp_nsh_api_t nsh;
17749 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17751 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
17757 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
17763 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
17768 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
17773 else if (unformat (i, "vni %d", &t))
17777 else if (unformat (i, "local"))
17781 else if (unformat (i, "remote"))
17787 errmsg ("parse error '%U'", format_unformat_error, i);
17792 if (!vam->json_output)
17794 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
17795 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
17798 M (ONE_EID_TABLE_DUMP, mp);
17800 mp->filter = filter;
17804 mp->vni = htonl (vni);
17805 mp->eid_type = eid_type;
17809 mp->prefix_length = prefix_length;
17810 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
17813 mp->prefix_length = prefix_length;
17814 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
17817 clib_memcpy (mp->eid, mac, sizeof (mac));
17820 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
17823 errmsg ("unknown EID type %d!", eid_type);
17831 /* Use a control ping for synchronization */
17832 MPING (CONTROL_PING, mp_ping);
17835 /* Wait for a reply... */
17840 #define api_lisp_eid_table_dump api_one_eid_table_dump
17843 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
17845 unformat_input_t *i = vam->input;
17846 vl_api_gpe_fwd_entries_get_t *mp;
17851 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17853 if (unformat (i, "vni %d", &vni))
17859 errmsg ("parse error '%U'", format_unformat_error, i);
17866 errmsg ("vni not set!");
17870 if (!vam->json_output)
17872 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
17876 M (GPE_FWD_ENTRIES_GET, mp);
17877 mp->vni = clib_host_to_net_u32 (vni);
17882 /* Wait for a reply... */
17887 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
17888 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
17889 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
17890 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
17891 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
17892 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
17893 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
17894 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
17897 api_one_adjacencies_get (vat_main_t * vam)
17899 unformat_input_t *i = vam->input;
17900 vl_api_one_adjacencies_get_t *mp;
17905 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17907 if (unformat (i, "vni %d", &vni))
17913 errmsg ("parse error '%U'", format_unformat_error, i);
17920 errmsg ("vni not set!");
17924 if (!vam->json_output)
17926 print (vam->ofp, "%s %40s", "leid", "reid");
17929 M (ONE_ADJACENCIES_GET, mp);
17930 mp->vni = clib_host_to_net_u32 (vni);
17935 /* Wait for a reply... */
17940 #define api_lisp_adjacencies_get api_one_adjacencies_get
17943 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
17945 unformat_input_t *i = vam->input;
17946 vl_api_gpe_native_fwd_rpaths_get_t *mp;
17948 u8 ip_family_set = 0, is_ip4 = 1;
17950 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17952 if (unformat (i, "ip4"))
17957 else if (unformat (i, "ip6"))
17964 errmsg ("parse error '%U'", format_unformat_error, i);
17969 if (!ip_family_set)
17971 errmsg ("ip family not set!");
17975 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
17976 mp->is_ip4 = is_ip4;
17981 /* Wait for a reply... */
17987 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
17989 vl_api_gpe_fwd_entry_vnis_get_t *mp;
17992 if (!vam->json_output)
17994 print (vam->ofp, "VNIs");
17997 M (GPE_FWD_ENTRY_VNIS_GET, mp);
18002 /* Wait for a reply... */
18008 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
18010 unformat_input_t *i = vam->input;
18011 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
18013 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
18014 struct in_addr ip4;
18015 struct in6_addr ip6;
18016 u32 table_id = 0, nh_sw_if_index = ~0;
18018 clib_memset (&ip4, 0, sizeof (ip4));
18019 clib_memset (&ip6, 0, sizeof (ip6));
18021 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18023 if (unformat (i, "del"))
18025 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
18026 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18031 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
18032 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18037 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
18041 nh_sw_if_index = ~0;
18043 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
18047 nh_sw_if_index = ~0;
18049 else if (unformat (i, "table %d", &table_id))
18053 errmsg ("parse error '%U'", format_unformat_error, i);
18060 errmsg ("nh addr not set!");
18064 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
18065 mp->is_add = is_add;
18066 mp->table_id = clib_host_to_net_u32 (table_id);
18067 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
18068 mp->is_ip4 = is_ip4;
18070 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
18072 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
18077 /* Wait for a reply... */
18083 api_one_map_server_dump (vat_main_t * vam)
18085 vl_api_one_map_server_dump_t *mp;
18086 vl_api_control_ping_t *mp_ping;
18089 if (!vam->json_output)
18091 print (vam->ofp, "%=20s", "Map server");
18094 M (ONE_MAP_SERVER_DUMP, mp);
18098 /* Use a control ping for synchronization */
18099 MPING (CONTROL_PING, mp_ping);
18102 /* Wait for a reply... */
18107 #define api_lisp_map_server_dump api_one_map_server_dump
18110 api_one_map_resolver_dump (vat_main_t * vam)
18112 vl_api_one_map_resolver_dump_t *mp;
18113 vl_api_control_ping_t *mp_ping;
18116 if (!vam->json_output)
18118 print (vam->ofp, "%=20s", "Map resolver");
18121 M (ONE_MAP_RESOLVER_DUMP, mp);
18125 /* Use a control ping for synchronization */
18126 MPING (CONTROL_PING, mp_ping);
18129 /* Wait for a reply... */
18134 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
18137 api_one_stats_flush (vat_main_t * vam)
18139 vl_api_one_stats_flush_t *mp;
18142 M (ONE_STATS_FLUSH, mp);
18149 api_one_stats_dump (vat_main_t * vam)
18151 vl_api_one_stats_dump_t *mp;
18152 vl_api_control_ping_t *mp_ping;
18155 M (ONE_STATS_DUMP, mp);
18159 /* Use a control ping for synchronization */
18160 MPING (CONTROL_PING, mp_ping);
18163 /* Wait for a reply... */
18169 api_show_one_status (vat_main_t * vam)
18171 vl_api_show_one_status_t *mp;
18174 if (!vam->json_output)
18176 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
18179 M (SHOW_ONE_STATUS, mp);
18182 /* Wait for a reply... */
18187 #define api_show_lisp_status api_show_one_status
18190 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
18192 vl_api_gpe_fwd_entry_path_dump_t *mp;
18193 vl_api_control_ping_t *mp_ping;
18194 unformat_input_t *i = vam->input;
18195 u32 fwd_entry_index = ~0;
18198 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18200 if (unformat (i, "index %d", &fwd_entry_index))
18206 if (~0 == fwd_entry_index)
18208 errmsg ("no index specified!");
18212 if (!vam->json_output)
18214 print (vam->ofp, "first line");
18217 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
18221 /* Use a control ping for synchronization */
18222 MPING (CONTROL_PING, mp_ping);
18225 /* Wait for a reply... */
18231 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
18233 vl_api_one_get_map_request_itr_rlocs_t *mp;
18236 if (!vam->json_output)
18238 print (vam->ofp, "%=20s", "itr-rlocs:");
18241 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
18244 /* Wait for a reply... */
18249 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
18252 api_af_packet_create (vat_main_t * vam)
18254 unformat_input_t *i = vam->input;
18255 vl_api_af_packet_create_t *mp;
18256 u8 *host_if_name = 0;
18258 u8 random_hw_addr = 1;
18261 clib_memset (hw_addr, 0, sizeof (hw_addr));
18263 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18265 if (unformat (i, "name %s", &host_if_name))
18266 vec_add1 (host_if_name, 0);
18267 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
18268 random_hw_addr = 0;
18273 if (!vec_len (host_if_name))
18275 errmsg ("host-interface name must be specified");
18279 if (vec_len (host_if_name) > 64)
18281 errmsg ("host-interface name too long");
18285 M (AF_PACKET_CREATE, mp);
18287 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
18288 clib_memcpy (mp->hw_addr, hw_addr, 6);
18289 mp->use_random_hw_addr = random_hw_addr;
18290 vec_free (host_if_name);
18298 fprintf (vam->ofp ? vam->ofp : stderr,
18299 " new sw_if_index = %d\n", vam->sw_if_index);
18306 api_af_packet_delete (vat_main_t * vam)
18308 unformat_input_t *i = vam->input;
18309 vl_api_af_packet_delete_t *mp;
18310 u8 *host_if_name = 0;
18313 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18315 if (unformat (i, "name %s", &host_if_name))
18316 vec_add1 (host_if_name, 0);
18321 if (!vec_len (host_if_name))
18323 errmsg ("host-interface name must be specified");
18327 if (vec_len (host_if_name) > 64)
18329 errmsg ("host-interface name too long");
18333 M (AF_PACKET_DELETE, mp);
18335 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
18336 vec_free (host_if_name);
18343 static void vl_api_af_packet_details_t_handler
18344 (vl_api_af_packet_details_t * mp)
18346 vat_main_t *vam = &vat_main;
18348 print (vam->ofp, "%-16s %d",
18349 mp->host_if_name, clib_net_to_host_u32 (mp->sw_if_index));
18352 static void vl_api_af_packet_details_t_handler_json
18353 (vl_api_af_packet_details_t * mp)
18355 vat_main_t *vam = &vat_main;
18356 vat_json_node_t *node = NULL;
18358 if (VAT_JSON_ARRAY != vam->json_tree.type)
18360 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18361 vat_json_init_array (&vam->json_tree);
18363 node = vat_json_array_add (&vam->json_tree);
18365 vat_json_init_object (node);
18366 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
18367 vat_json_object_add_string_copy (node, "dev_name", mp->host_if_name);
18371 api_af_packet_dump (vat_main_t * vam)
18373 vl_api_af_packet_dump_t *mp;
18374 vl_api_control_ping_t *mp_ping;
18377 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
18378 /* Get list of tap interfaces */
18379 M (AF_PACKET_DUMP, mp);
18382 /* Use a control ping for synchronization */
18383 MPING (CONTROL_PING, mp_ping);
18391 api_policer_add_del (vat_main_t * vam)
18393 unformat_input_t *i = vam->input;
18394 vl_api_policer_add_del_t *mp;
18404 u8 color_aware = 0;
18405 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
18408 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
18409 conform_action.dscp = 0;
18410 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
18411 exceed_action.dscp = 0;
18412 violate_action.action_type = SSE2_QOS_ACTION_DROP;
18413 violate_action.dscp = 0;
18415 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18417 if (unformat (i, "del"))
18419 else if (unformat (i, "name %s", &name))
18420 vec_add1 (name, 0);
18421 else if (unformat (i, "cir %u", &cir))
18423 else if (unformat (i, "eir %u", &eir))
18425 else if (unformat (i, "cb %u", &cb))
18427 else if (unformat (i, "eb %u", &eb))
18429 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
18432 else if (unformat (i, "round_type %U", unformat_policer_round_type,
18435 else if (unformat (i, "type %U", unformat_policer_type, &type))
18437 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
18440 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
18443 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
18446 else if (unformat (i, "color-aware"))
18452 if (!vec_len (name))
18454 errmsg ("policer name must be specified");
18458 if (vec_len (name) > 64)
18460 errmsg ("policer name too long");
18464 M (POLICER_ADD_DEL, mp);
18466 clib_memcpy (mp->name, name, vec_len (name));
18468 mp->is_add = is_add;
18469 mp->cir = ntohl (cir);
18470 mp->eir = ntohl (eir);
18471 mp->cb = clib_net_to_host_u64 (cb);
18472 mp->eb = clib_net_to_host_u64 (eb);
18473 mp->rate_type = rate_type;
18474 mp->round_type = round_type;
18476 mp->conform_action_type = conform_action.action_type;
18477 mp->conform_dscp = conform_action.dscp;
18478 mp->exceed_action_type = exceed_action.action_type;
18479 mp->exceed_dscp = exceed_action.dscp;
18480 mp->violate_action_type = violate_action.action_type;
18481 mp->violate_dscp = violate_action.dscp;
18482 mp->color_aware = color_aware;
18490 api_policer_dump (vat_main_t * vam)
18492 unformat_input_t *i = vam->input;
18493 vl_api_policer_dump_t *mp;
18494 vl_api_control_ping_t *mp_ping;
18495 u8 *match_name = 0;
18496 u8 match_name_valid = 0;
18499 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18501 if (unformat (i, "name %s", &match_name))
18503 vec_add1 (match_name, 0);
18504 match_name_valid = 1;
18510 M (POLICER_DUMP, mp);
18511 mp->match_name_valid = match_name_valid;
18512 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
18513 vec_free (match_name);
18517 /* Use a control ping for synchronization */
18518 MPING (CONTROL_PING, mp_ping);
18521 /* Wait for a reply... */
18527 api_policer_classify_set_interface (vat_main_t * vam)
18529 unformat_input_t *i = vam->input;
18530 vl_api_policer_classify_set_interface_t *mp;
18532 int sw_if_index_set;
18533 u32 ip4_table_index = ~0;
18534 u32 ip6_table_index = ~0;
18535 u32 l2_table_index = ~0;
18539 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18541 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18542 sw_if_index_set = 1;
18543 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18544 sw_if_index_set = 1;
18545 else if (unformat (i, "del"))
18547 else if (unformat (i, "ip4-table %d", &ip4_table_index))
18549 else if (unformat (i, "ip6-table %d", &ip6_table_index))
18551 else if (unformat (i, "l2-table %d", &l2_table_index))
18555 clib_warning ("parse error '%U'", format_unformat_error, i);
18560 if (sw_if_index_set == 0)
18562 errmsg ("missing interface name or sw_if_index");
18566 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
18568 mp->sw_if_index = ntohl (sw_if_index);
18569 mp->ip4_table_index = ntohl (ip4_table_index);
18570 mp->ip6_table_index = ntohl (ip6_table_index);
18571 mp->l2_table_index = ntohl (l2_table_index);
18572 mp->is_add = is_add;
18580 api_policer_classify_dump (vat_main_t * vam)
18582 unformat_input_t *i = vam->input;
18583 vl_api_policer_classify_dump_t *mp;
18584 vl_api_control_ping_t *mp_ping;
18585 u8 type = POLICER_CLASSIFY_N_TABLES;
18588 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
18592 errmsg ("classify table type must be specified");
18596 if (!vam->json_output)
18598 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
18601 M (POLICER_CLASSIFY_DUMP, mp);
18606 /* Use a control ping for synchronization */
18607 MPING (CONTROL_PING, mp_ping);
18610 /* Wait for a reply... */
18616 api_netmap_create (vat_main_t * vam)
18618 unformat_input_t *i = vam->input;
18619 vl_api_netmap_create_t *mp;
18622 u8 random_hw_addr = 1;
18627 clib_memset (hw_addr, 0, sizeof (hw_addr));
18629 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18631 if (unformat (i, "name %s", &if_name))
18632 vec_add1 (if_name, 0);
18633 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
18634 random_hw_addr = 0;
18635 else if (unformat (i, "pipe"))
18637 else if (unformat (i, "master"))
18639 else if (unformat (i, "slave"))
18645 if (!vec_len (if_name))
18647 errmsg ("interface name must be specified");
18651 if (vec_len (if_name) > 64)
18653 errmsg ("interface name too long");
18657 M (NETMAP_CREATE, mp);
18659 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
18660 clib_memcpy (mp->hw_addr, hw_addr, 6);
18661 mp->use_random_hw_addr = random_hw_addr;
18662 mp->is_pipe = is_pipe;
18663 mp->is_master = is_master;
18664 vec_free (if_name);
18672 api_netmap_delete (vat_main_t * vam)
18674 unformat_input_t *i = vam->input;
18675 vl_api_netmap_delete_t *mp;
18679 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18681 if (unformat (i, "name %s", &if_name))
18682 vec_add1 (if_name, 0);
18687 if (!vec_len (if_name))
18689 errmsg ("interface name must be specified");
18693 if (vec_len (if_name) > 64)
18695 errmsg ("interface name too long");
18699 M (NETMAP_DELETE, mp);
18701 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
18702 vec_free (if_name);
18710 format_fib_api_path_nh_proto (u8 * s, va_list * args)
18712 vl_api_fib_path_nh_proto_t proto =
18713 va_arg (*args, vl_api_fib_path_nh_proto_t);
18717 case FIB_API_PATH_NH_PROTO_IP4:
18718 s = format (s, "ip4");
18720 case FIB_API_PATH_NH_PROTO_IP6:
18721 s = format (s, "ip6");
18723 case FIB_API_PATH_NH_PROTO_MPLS:
18724 s = format (s, "mpls");
18726 case FIB_API_PATH_NH_PROTO_BIER:
18727 s = format (s, "bier");
18729 case FIB_API_PATH_NH_PROTO_ETHERNET:
18730 s = format (s, "ethernet");
18738 format_vl_api_ip_address_union (u8 * s, va_list * args)
18740 vl_api_address_family_t af = va_arg (*args, vl_api_address_family_t);
18741 const vl_api_address_union_t *u = va_arg (*args, vl_api_address_union_t *);
18746 s = format (s, "%U", format_ip4_address, u->ip4);
18749 s = format (s, "%U", format_ip6_address, u->ip6);
18756 format_vl_api_fib_path_type (u8 * s, va_list * args)
18758 vl_api_fib_path_type_t t = va_arg (*args, vl_api_fib_path_type_t);
18762 case FIB_API_PATH_TYPE_NORMAL:
18763 s = format (s, "normal");
18765 case FIB_API_PATH_TYPE_LOCAL:
18766 s = format (s, "local");
18768 case FIB_API_PATH_TYPE_DROP:
18769 s = format (s, "drop");
18771 case FIB_API_PATH_TYPE_UDP_ENCAP:
18772 s = format (s, "udp-encap");
18774 case FIB_API_PATH_TYPE_BIER_IMP:
18775 s = format (s, "bier-imp");
18777 case FIB_API_PATH_TYPE_ICMP_UNREACH:
18778 s = format (s, "unreach");
18780 case FIB_API_PATH_TYPE_ICMP_PROHIBIT:
18781 s = format (s, "prohibit");
18783 case FIB_API_PATH_TYPE_SOURCE_LOOKUP:
18784 s = format (s, "src-lookup");
18786 case FIB_API_PATH_TYPE_DVR:
18787 s = format (s, "dvr");
18789 case FIB_API_PATH_TYPE_INTERFACE_RX:
18790 s = format (s, "interface-rx");
18792 case FIB_API_PATH_TYPE_CLASSIFY:
18793 s = format (s, "classify");
18801 vl_api_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
18804 " weight %d, sw_if_index %d, type %U, afi %U, next_hop %U",
18805 ntohl (fp->weight), ntohl (fp->sw_if_index),
18806 format_vl_api_fib_path_type, fp->type,
18807 format_fib_api_path_nh_proto, fp->proto,
18808 format_vl_api_ip_address_union, &fp->nh.address);
18812 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
18813 vl_api_fib_path_t * fp)
18815 struct in_addr ip4;
18816 struct in6_addr ip6;
18818 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
18819 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
18820 vat_json_object_add_uint (node, "type", fp->type);
18821 vat_json_object_add_uint (node, "next_hop_proto", fp->proto);
18822 if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
18824 clib_memcpy (&ip4, &fp->nh.address.ip4, sizeof (ip4));
18825 vat_json_object_add_ip4 (node, "next_hop", ip4);
18827 else if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
18829 clib_memcpy (&ip6, &fp->nh.address.ip6, sizeof (ip6));
18830 vat_json_object_add_ip6 (node, "next_hop", ip6);
18835 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
18837 vat_main_t *vam = &vat_main;
18838 int count = ntohl (mp->mt_tunnel.mt_n_paths);
18839 vl_api_fib_path_t *fp;
18842 print (vam->ofp, "sw_if_index %d via:",
18843 ntohl (mp->mt_tunnel.mt_sw_if_index));
18844 fp = mp->mt_tunnel.mt_paths;
18845 for (i = 0; i < count; i++)
18847 vl_api_fib_path_print (vam, fp);
18851 print (vam->ofp, "");
18854 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
18855 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
18858 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
18860 vat_main_t *vam = &vat_main;
18861 vat_json_node_t *node = NULL;
18862 int count = ntohl (mp->mt_tunnel.mt_n_paths);
18863 vl_api_fib_path_t *fp;
18866 if (VAT_JSON_ARRAY != vam->json_tree.type)
18868 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18869 vat_json_init_array (&vam->json_tree);
18871 node = vat_json_array_add (&vam->json_tree);
18873 vat_json_init_object (node);
18874 vat_json_object_add_uint (node, "sw_if_index",
18875 ntohl (mp->mt_tunnel.mt_sw_if_index));
18877 vat_json_object_add_uint (node, "l2_only", mp->mt_tunnel.mt_l2_only);
18879 fp = mp->mt_tunnel.mt_paths;
18880 for (i = 0; i < count; i++)
18882 vl_api_mpls_fib_path_json_print (node, fp);
18888 api_mpls_tunnel_dump (vat_main_t * vam)
18890 vl_api_mpls_tunnel_dump_t *mp;
18891 vl_api_control_ping_t *mp_ping;
18894 M (MPLS_TUNNEL_DUMP, mp);
18898 /* Use a control ping for synchronization */
18899 MPING (CONTROL_PING, mp_ping);
18906 #define vl_api_mpls_table_details_t_endian vl_noop_handler
18907 #define vl_api_mpls_table_details_t_print vl_noop_handler
18911 vl_api_mpls_table_details_t_handler (vl_api_mpls_table_details_t * mp)
18913 vat_main_t *vam = &vat_main;
18915 print (vam->ofp, "table-id %d,", ntohl (mp->mt_table.mt_table_id));
18918 static void vl_api_mpls_table_details_t_handler_json
18919 (vl_api_mpls_table_details_t * mp)
18921 vat_main_t *vam = &vat_main;
18922 vat_json_node_t *node = NULL;
18924 if (VAT_JSON_ARRAY != vam->json_tree.type)
18926 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18927 vat_json_init_array (&vam->json_tree);
18929 node = vat_json_array_add (&vam->json_tree);
18931 vat_json_init_object (node);
18932 vat_json_object_add_uint (node, "table", ntohl (mp->mt_table.mt_table_id));
18936 api_mpls_table_dump (vat_main_t * vam)
18938 vl_api_mpls_table_dump_t *mp;
18939 vl_api_control_ping_t *mp_ping;
18942 M (MPLS_TABLE_DUMP, mp);
18945 /* Use a control ping for synchronization */
18946 MPING (CONTROL_PING, mp_ping);
18953 #define vl_api_mpls_route_details_t_endian vl_noop_handler
18954 #define vl_api_mpls_route_details_t_print vl_noop_handler
18957 vl_api_mpls_route_details_t_handler (vl_api_mpls_route_details_t * mp)
18959 vat_main_t *vam = &vat_main;
18960 int count = ntohl (mp->mr_route.mr_n_paths);
18961 vl_api_fib_path_t *fp;
18965 "table-id %d, label %u, ess_bit %u",
18966 ntohl (mp->mr_route.mr_table_id),
18967 ntohl (mp->mr_route.mr_label), mp->mr_route.mr_eos);
18968 fp = mp->mr_route.mr_paths;
18969 for (i = 0; i < count; i++)
18971 vl_api_fib_path_print (vam, fp);
18976 static void vl_api_mpls_route_details_t_handler_json
18977 (vl_api_mpls_route_details_t * mp)
18979 vat_main_t *vam = &vat_main;
18980 int count = ntohl (mp->mr_route.mr_n_paths);
18981 vat_json_node_t *node = NULL;
18982 vl_api_fib_path_t *fp;
18985 if (VAT_JSON_ARRAY != vam->json_tree.type)
18987 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18988 vat_json_init_array (&vam->json_tree);
18990 node = vat_json_array_add (&vam->json_tree);
18992 vat_json_init_object (node);
18993 vat_json_object_add_uint (node, "table", ntohl (mp->mr_route.mr_table_id));
18994 vat_json_object_add_uint (node, "s_bit", mp->mr_route.mr_eos);
18995 vat_json_object_add_uint (node, "label", ntohl (mp->mr_route.mr_label));
18996 vat_json_object_add_uint (node, "path_count", count);
18997 fp = mp->mr_route.mr_paths;
18998 for (i = 0; i < count; i++)
19000 vl_api_mpls_fib_path_json_print (node, fp);
19006 api_mpls_route_dump (vat_main_t * vam)
19008 unformat_input_t *input = vam->input;
19009 vl_api_mpls_route_dump_t *mp;
19010 vl_api_control_ping_t *mp_ping;
19014 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19016 if (unformat (input, "table_id %d", &table_id))
19021 if (table_id == ~0)
19023 errmsg ("missing table id");
19027 M (MPLS_ROUTE_DUMP, mp);
19029 mp->table.mt_table_id = ntohl (table_id);
19032 /* Use a control ping for synchronization */
19033 MPING (CONTROL_PING, mp_ping);
19040 #define vl_api_ip_table_details_t_endian vl_noop_handler
19041 #define vl_api_ip_table_details_t_print vl_noop_handler
19044 vl_api_ip_table_details_t_handler (vl_api_ip_table_details_t * mp)
19046 vat_main_t *vam = &vat_main;
19049 "%s; table-id %d, prefix %U/%d",
19050 mp->table.name, ntohl (mp->table.table_id));
19054 static void vl_api_ip_table_details_t_handler_json
19055 (vl_api_ip_table_details_t * mp)
19057 vat_main_t *vam = &vat_main;
19058 vat_json_node_t *node = NULL;
19060 if (VAT_JSON_ARRAY != vam->json_tree.type)
19062 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19063 vat_json_init_array (&vam->json_tree);
19065 node = vat_json_array_add (&vam->json_tree);
19067 vat_json_init_object (node);
19068 vat_json_object_add_uint (node, "table", ntohl (mp->table.table_id));
19072 api_ip_table_dump (vat_main_t * vam)
19074 vl_api_ip_table_dump_t *mp;
19075 vl_api_control_ping_t *mp_ping;
19078 M (IP_TABLE_DUMP, mp);
19081 /* Use a control ping for synchronization */
19082 MPING (CONTROL_PING, mp_ping);
19090 api_ip_mtable_dump (vat_main_t * vam)
19092 vl_api_ip_mtable_dump_t *mp;
19093 vl_api_control_ping_t *mp_ping;
19096 M (IP_MTABLE_DUMP, mp);
19099 /* Use a control ping for synchronization */
19100 MPING (CONTROL_PING, mp_ping);
19108 api_ip_mroute_dump (vat_main_t * vam)
19110 unformat_input_t *input = vam->input;
19111 vl_api_control_ping_t *mp_ping;
19112 vl_api_ip_mroute_dump_t *mp;
19117 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19119 if (unformat (input, "table_id %d", &table_id))
19121 else if (unformat (input, "ip6"))
19123 else if (unformat (input, "ip4"))
19128 if (table_id == ~0)
19130 errmsg ("missing table id");
19134 M (IP_MROUTE_DUMP, mp);
19135 mp->table.table_id = table_id;
19136 mp->table.is_ip6 = is_ip6;
19139 /* Use a control ping for synchronization */
19140 MPING (CONTROL_PING, mp_ping);
19147 static void vl_api_ip_neighbor_details_t_handler
19148 (vl_api_ip_neighbor_details_t * mp)
19150 vat_main_t *vam = &vat_main;
19152 print (vam->ofp, "%c %U %U",
19153 (ntohl (mp->neighbor.flags) & IP_NEIGHBOR_FLAG_STATIC) ? 'S' : 'D',
19154 format_vl_api_mac_address, &mp->neighbor.mac_address,
19155 format_vl_api_address, &mp->neighbor.ip_address);
19158 static void vl_api_ip_neighbor_details_t_handler_json
19159 (vl_api_ip_neighbor_details_t * mp)
19162 vat_main_t *vam = &vat_main;
19163 vat_json_node_t *node;
19165 if (VAT_JSON_ARRAY != vam->json_tree.type)
19167 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19168 vat_json_init_array (&vam->json_tree);
19170 node = vat_json_array_add (&vam->json_tree);
19172 vat_json_init_object (node);
19173 vat_json_object_add_string_copy
19175 ((ntohl (mp->neighbor.flags) & IP_NEIGHBOR_FLAG_STATIC) ?
19176 (u8 *) "static" : (u8 *) "dynamic"));
19178 vat_json_object_add_string_copy (node, "link_layer",
19179 format (0, "%U", format_vl_api_mac_address,
19180 &mp->neighbor.mac_address));
19181 vat_json_object_add_address (node, "ip", &mp->neighbor.ip_address);
19185 api_ip_neighbor_dump (vat_main_t * vam)
19187 unformat_input_t *i = vam->input;
19188 vl_api_ip_neighbor_dump_t *mp;
19189 vl_api_control_ping_t *mp_ping;
19191 u32 sw_if_index = ~0;
19194 /* Parse args required to build the message */
19195 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19197 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19199 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19201 else if (unformat (i, "ip6"))
19207 if (sw_if_index == ~0)
19209 errmsg ("missing interface name or sw_if_index");
19213 M (IP_NEIGHBOR_DUMP, mp);
19214 mp->is_ipv6 = (u8) is_ipv6;
19215 mp->sw_if_index = ntohl (sw_if_index);
19218 /* Use a control ping for synchronization */
19219 MPING (CONTROL_PING, mp_ping);
19226 #define vl_api_ip_route_details_t_endian vl_noop_handler
19227 #define vl_api_ip_route_details_t_print vl_noop_handler
19230 vl_api_ip_route_details_t_handler (vl_api_ip_route_details_t * mp)
19232 vat_main_t *vam = &vat_main;
19233 u8 count = mp->route.n_paths;
19234 vl_api_fib_path_t *fp;
19238 "table-id %d, prefix %U/%d",
19239 ntohl (mp->route.table_id),
19240 format_ip46_address,
19241 mp->route.prefix.address, mp->route.prefix.address_length);
19242 for (i = 0; i < count; i++)
19244 fp = &mp->route.paths[i];
19246 vl_api_fib_path_print (vam, fp);
19251 static void vl_api_ip_route_details_t_handler_json
19252 (vl_api_ip_route_details_t * mp)
19254 vat_main_t *vam = &vat_main;
19255 u8 count = mp->route.n_paths;
19256 vat_json_node_t *node = NULL;
19257 struct in_addr ip4;
19258 struct in6_addr ip6;
19259 vl_api_fib_path_t *fp;
19262 if (VAT_JSON_ARRAY != vam->json_tree.type)
19264 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19265 vat_json_init_array (&vam->json_tree);
19267 node = vat_json_array_add (&vam->json_tree);
19269 vat_json_init_object (node);
19270 vat_json_object_add_uint (node, "table", ntohl (mp->route.table_id));
19271 if (ADDRESS_IP6 == mp->route.prefix.address.af)
19273 clib_memcpy (&ip6, &mp->route.prefix.address.un.ip6, sizeof (ip6));
19274 vat_json_object_add_ip6 (node, "prefix", ip6);
19278 clib_memcpy (&ip4, &mp->route.prefix.address.un.ip4, sizeof (ip4));
19279 vat_json_object_add_ip4 (node, "prefix", ip4);
19281 vat_json_object_add_uint (node, "mask_length",
19282 mp->route.prefix.address_length);
19283 vat_json_object_add_uint (node, "path_count", count);
19284 for (i = 0; i < count; i++)
19286 fp = &mp->route.paths[i];
19287 vl_api_mpls_fib_path_json_print (node, fp);
19292 api_ip_route_dump (vat_main_t * vam)
19294 unformat_input_t *input = vam->input;
19295 vl_api_ip_route_dump_t *mp;
19296 vl_api_control_ping_t *mp_ping;
19302 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19304 if (unformat (input, "table_id %d", &table_id))
19306 else if (unformat (input, "ip6"))
19308 else if (unformat (input, "ip4"))
19313 if (table_id == ~0)
19315 errmsg ("missing table id");
19319 M (IP_ROUTE_DUMP, mp);
19321 mp->table.table_id = table_id;
19322 mp->table.is_ip6 = is_ip6;
19326 /* Use a control ping for synchronization */
19327 MPING (CONTROL_PING, mp_ping);
19335 api_classify_table_ids (vat_main_t * vam)
19337 vl_api_classify_table_ids_t *mp;
19340 /* Construct the API message */
19341 M (CLASSIFY_TABLE_IDS, mp);
19350 api_classify_table_by_interface (vat_main_t * vam)
19352 unformat_input_t *input = vam->input;
19353 vl_api_classify_table_by_interface_t *mp;
19355 u32 sw_if_index = ~0;
19357 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19359 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19361 else if (unformat (input, "sw_if_index %d", &sw_if_index))
19366 if (sw_if_index == ~0)
19368 errmsg ("missing interface name or sw_if_index");
19372 /* Construct the API message */
19373 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
19375 mp->sw_if_index = ntohl (sw_if_index);
19383 api_classify_table_info (vat_main_t * vam)
19385 unformat_input_t *input = vam->input;
19386 vl_api_classify_table_info_t *mp;
19390 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19392 if (unformat (input, "table_id %d", &table_id))
19397 if (table_id == ~0)
19399 errmsg ("missing table id");
19403 /* Construct the API message */
19404 M (CLASSIFY_TABLE_INFO, mp);
19406 mp->table_id = ntohl (table_id);
19414 api_classify_session_dump (vat_main_t * vam)
19416 unformat_input_t *input = vam->input;
19417 vl_api_classify_session_dump_t *mp;
19418 vl_api_control_ping_t *mp_ping;
19422 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19424 if (unformat (input, "table_id %d", &table_id))
19429 if (table_id == ~0)
19431 errmsg ("missing table id");
19435 /* Construct the API message */
19436 M (CLASSIFY_SESSION_DUMP, mp);
19438 mp->table_id = ntohl (table_id);
19441 /* Use a control ping for synchronization */
19442 MPING (CONTROL_PING, mp_ping);
19450 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
19452 vat_main_t *vam = &vat_main;
19454 print (vam->ofp, "collector_address %U, collector_port %d, "
19455 "src_address %U, vrf_id %d, path_mtu %u, "
19456 "template_interval %u, udp_checksum %d",
19457 format_ip4_address, mp->collector_address,
19458 ntohs (mp->collector_port),
19459 format_ip4_address, mp->src_address,
19460 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
19461 ntohl (mp->template_interval), mp->udp_checksum);
19464 vam->result_ready = 1;
19468 vl_api_ipfix_exporter_details_t_handler_json
19469 (vl_api_ipfix_exporter_details_t * mp)
19471 vat_main_t *vam = &vat_main;
19472 vat_json_node_t node;
19473 struct in_addr collector_address;
19474 struct in_addr src_address;
19476 vat_json_init_object (&node);
19477 clib_memcpy (&collector_address, &mp->collector_address,
19478 sizeof (collector_address));
19479 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
19480 vat_json_object_add_uint (&node, "collector_port",
19481 ntohs (mp->collector_port));
19482 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
19483 vat_json_object_add_ip4 (&node, "src_address", src_address);
19484 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
19485 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
19486 vat_json_object_add_uint (&node, "template_interval",
19487 ntohl (mp->template_interval));
19488 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
19490 vat_json_print (vam->ofp, &node);
19491 vat_json_free (&node);
19493 vam->result_ready = 1;
19497 api_ipfix_exporter_dump (vat_main_t * vam)
19499 vl_api_ipfix_exporter_dump_t *mp;
19502 /* Construct the API message */
19503 M (IPFIX_EXPORTER_DUMP, mp);
19512 api_ipfix_classify_stream_dump (vat_main_t * vam)
19514 vl_api_ipfix_classify_stream_dump_t *mp;
19517 /* Construct the API message */
19518 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
19529 vl_api_ipfix_classify_stream_details_t_handler
19530 (vl_api_ipfix_classify_stream_details_t * mp)
19532 vat_main_t *vam = &vat_main;
19533 print (vam->ofp, "domain_id %d, src_port %d",
19534 ntohl (mp->domain_id), ntohs (mp->src_port));
19536 vam->result_ready = 1;
19540 vl_api_ipfix_classify_stream_details_t_handler_json
19541 (vl_api_ipfix_classify_stream_details_t * mp)
19543 vat_main_t *vam = &vat_main;
19544 vat_json_node_t node;
19546 vat_json_init_object (&node);
19547 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
19548 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
19550 vat_json_print (vam->ofp, &node);
19551 vat_json_free (&node);
19553 vam->result_ready = 1;
19557 api_ipfix_classify_table_dump (vat_main_t * vam)
19559 vl_api_ipfix_classify_table_dump_t *mp;
19560 vl_api_control_ping_t *mp_ping;
19563 if (!vam->json_output)
19565 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
19566 "transport_protocol");
19569 /* Construct the API message */
19570 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
19575 /* Use a control ping for synchronization */
19576 MPING (CONTROL_PING, mp_ping);
19584 vl_api_ipfix_classify_table_details_t_handler
19585 (vl_api_ipfix_classify_table_details_t * mp)
19587 vat_main_t *vam = &vat_main;
19588 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
19589 mp->transport_protocol);
19593 vl_api_ipfix_classify_table_details_t_handler_json
19594 (vl_api_ipfix_classify_table_details_t * mp)
19596 vat_json_node_t *node = NULL;
19597 vat_main_t *vam = &vat_main;
19599 if (VAT_JSON_ARRAY != vam->json_tree.type)
19601 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19602 vat_json_init_array (&vam->json_tree);
19605 node = vat_json_array_add (&vam->json_tree);
19606 vat_json_init_object (node);
19608 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
19609 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
19610 vat_json_object_add_uint (node, "transport_protocol",
19611 mp->transport_protocol);
19615 api_sw_interface_span_enable_disable (vat_main_t * vam)
19617 unformat_input_t *i = vam->input;
19618 vl_api_sw_interface_span_enable_disable_t *mp;
19619 u32 src_sw_if_index = ~0;
19620 u32 dst_sw_if_index = ~0;
19625 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19628 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
19630 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
19634 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
19636 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
19638 else if (unformat (i, "disable"))
19640 else if (unformat (i, "rx"))
19642 else if (unformat (i, "tx"))
19644 else if (unformat (i, "both"))
19646 else if (unformat (i, "l2"))
19652 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
19654 mp->sw_if_index_from = htonl (src_sw_if_index);
19655 mp->sw_if_index_to = htonl (dst_sw_if_index);
19665 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
19668 vat_main_t *vam = &vat_main;
19669 u8 *sw_if_from_name = 0;
19670 u8 *sw_if_to_name = 0;
19671 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
19672 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
19673 char *states[] = { "none", "rx", "tx", "both" };
19677 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
19679 if ((u32) p->value[0] == sw_if_index_from)
19681 sw_if_from_name = (u8 *)(p->key);
19685 if ((u32) p->value[0] == sw_if_index_to)
19687 sw_if_to_name = (u8 *)(p->key);
19688 if (sw_if_from_name)
19693 print (vam->ofp, "%20s => %20s (%s) %s",
19694 sw_if_from_name, sw_if_to_name, states[mp->state],
19695 mp->is_l2 ? "l2" : "device");
19699 vl_api_sw_interface_span_details_t_handler_json
19700 (vl_api_sw_interface_span_details_t * mp)
19702 vat_main_t *vam = &vat_main;
19703 vat_json_node_t *node = NULL;
19704 u8 *sw_if_from_name = 0;
19705 u8 *sw_if_to_name = 0;
19706 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
19707 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
19711 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
19713 if ((u32) p->value[0] == sw_if_index_from)
19715 sw_if_from_name = (u8 *)(p->key);
19719 if ((u32) p->value[0] == sw_if_index_to)
19721 sw_if_to_name = (u8 *)(p->key);
19722 if (sw_if_from_name)
19728 if (VAT_JSON_ARRAY != vam->json_tree.type)
19730 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19731 vat_json_init_array (&vam->json_tree);
19733 node = vat_json_array_add (&vam->json_tree);
19735 vat_json_init_object (node);
19736 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
19737 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
19738 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
19739 if (0 != sw_if_to_name)
19741 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
19743 vat_json_object_add_uint (node, "state", mp->state);
19744 vat_json_object_add_uint (node, "is-l2", mp->is_l2);
19748 api_sw_interface_span_dump (vat_main_t * vam)
19750 unformat_input_t *input = vam->input;
19751 vl_api_sw_interface_span_dump_t *mp;
19752 vl_api_control_ping_t *mp_ping;
19756 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19758 if (unformat (input, "l2"))
19764 M (SW_INTERFACE_SPAN_DUMP, mp);
19768 /* Use a control ping for synchronization */
19769 MPING (CONTROL_PING, mp_ping);
19777 api_pg_create_interface (vat_main_t * vam)
19779 unformat_input_t *input = vam->input;
19780 vl_api_pg_create_interface_t *mp;
19784 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19786 if (unformat (input, "if_id %d", &if_id))
19793 errmsg ("missing pg interface index");
19797 /* Construct the API message */
19798 M (PG_CREATE_INTERFACE, mp);
19800 mp->interface_id = ntohl (if_id);
19808 api_pg_capture (vat_main_t * vam)
19810 unformat_input_t *input = vam->input;
19811 vl_api_pg_capture_t *mp;
19816 u8 pcap_file_set = 0;
19819 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19821 if (unformat (input, "if_id %d", &if_id))
19823 else if (unformat (input, "pcap %s", &pcap_file))
19825 else if (unformat (input, "count %d", &count))
19827 else if (unformat (input, "disable"))
19834 errmsg ("missing pg interface index");
19837 if (pcap_file_set > 0)
19839 if (vec_len (pcap_file) > 255)
19841 errmsg ("pcap file name is too long");
19846 u32 name_len = vec_len (pcap_file);
19847 /* Construct the API message */
19848 M (PG_CAPTURE, mp);
19850 mp->interface_id = ntohl (if_id);
19851 mp->is_enabled = enable;
19852 mp->count = ntohl (count);
19853 mp->pcap_name_length = ntohl (name_len);
19854 if (pcap_file_set != 0)
19856 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
19858 vec_free (pcap_file);
19866 api_pg_enable_disable (vat_main_t * vam)
19868 unformat_input_t *input = vam->input;
19869 vl_api_pg_enable_disable_t *mp;
19872 u8 stream_name_set = 0;
19873 u8 *stream_name = 0;
19875 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19877 if (unformat (input, "stream %s", &stream_name))
19878 stream_name_set = 1;
19879 else if (unformat (input, "disable"))
19885 if (stream_name_set > 0)
19887 if (vec_len (stream_name) > 255)
19889 errmsg ("stream name too long");
19894 u32 name_len = vec_len (stream_name);
19895 /* Construct the API message */
19896 M (PG_ENABLE_DISABLE, mp);
19898 mp->is_enabled = enable;
19899 if (stream_name_set != 0)
19901 mp->stream_name_length = ntohl (name_len);
19902 clib_memcpy (mp->stream_name, stream_name, name_len);
19904 vec_free (stream_name);
19912 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
19914 unformat_input_t *input = vam->input;
19915 vl_api_ip_source_and_port_range_check_add_del_t *mp;
19917 u16 *low_ports = 0;
19918 u16 *high_ports = 0;
19921 vl_api_prefix_t prefix;
19928 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19930 if (unformat (input, "%U", unformat_vl_api_prefix, &prefix))
19932 else if (unformat (input, "vrf %d", &vrf_id))
19934 else if (unformat (input, "del"))
19936 else if (unformat (input, "port %d", &tmp))
19938 if (tmp == 0 || tmp > 65535)
19940 errmsg ("port %d out of range", tmp);
19944 this_hi = this_low + 1;
19945 vec_add1 (low_ports, this_low);
19946 vec_add1 (high_ports, this_hi);
19948 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
19950 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
19952 errmsg ("incorrect range parameters");
19956 /* Note: in debug CLI +1 is added to high before
19957 passing to real fn that does "the work"
19958 (ip_source_and_port_range_check_add_del).
19959 This fn is a wrapper around the binary API fn a
19960 control plane will call, which expects this increment
19961 to have occurred. Hence letting the binary API control
19962 plane fn do the increment for consistency between VAT
19963 and other control planes.
19966 vec_add1 (low_ports, this_low);
19967 vec_add1 (high_ports, this_hi);
19973 if (prefix_set == 0)
19975 errmsg ("<address>/<mask> not specified");
19981 errmsg ("VRF ID required, not specified");
19988 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
19992 if (vec_len (low_ports) == 0)
19994 errmsg ("At least one port or port range required");
19998 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
20000 mp->is_add = is_add;
20002 clib_memcpy (&mp->prefix, &prefix, sizeof (prefix));
20004 mp->number_of_ranges = vec_len (low_ports);
20006 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
20007 vec_free (low_ports);
20009 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
20010 vec_free (high_ports);
20012 mp->vrf_id = ntohl (vrf_id);
20020 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
20022 unformat_input_t *input = vam->input;
20023 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
20024 u32 sw_if_index = ~0;
20026 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
20027 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
20031 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20033 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20035 else if (unformat (input, "sw_if_index %d", &sw_if_index))
20037 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
20039 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
20041 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
20043 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
20045 else if (unformat (input, "del"))
20051 if (sw_if_index == ~0)
20053 errmsg ("Interface required but not specified");
20059 errmsg ("VRF ID required but not specified");
20063 if (tcp_out_vrf_id == 0
20064 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
20067 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
20071 /* Construct the API message */
20072 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
20074 mp->sw_if_index = ntohl (sw_if_index);
20075 mp->is_add = is_add;
20076 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
20077 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
20078 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
20079 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
20084 /* Wait for a reply... */
20090 api_ipsec_gre_tunnel_add_del (vat_main_t * vam)
20092 unformat_input_t *i = vam->input;
20093 vl_api_ipsec_gre_tunnel_add_del_t *mp;
20094 u32 local_sa_id = 0;
20095 u32 remote_sa_id = 0;
20096 vl_api_ip4_address_t src_address;
20097 vl_api_ip4_address_t dst_address;
20101 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20103 if (unformat (i, "local_sa %d", &local_sa_id))
20105 else if (unformat (i, "remote_sa %d", &remote_sa_id))
20108 if (unformat (i, "src %U", unformat_vl_api_ip4_address, &src_address))
20111 if (unformat (i, "dst %U", unformat_vl_api_ip4_address, &dst_address))
20113 else if (unformat (i, "del"))
20117 clib_warning ("parse error '%U'", format_unformat_error, i);
20122 M (IPSEC_GRE_TUNNEL_ADD_DEL, mp);
20124 mp->tunnel.local_sa_id = ntohl (local_sa_id);
20125 mp->tunnel.remote_sa_id = ntohl (remote_sa_id);
20126 clib_memcpy (mp->tunnel.src, &src_address, sizeof (src_address));
20127 clib_memcpy (mp->tunnel.dst, &dst_address, sizeof (dst_address));
20128 mp->is_add = is_add;
20136 api_set_punt (vat_main_t * vam)
20138 unformat_input_t *i = vam->input;
20139 vl_api_address_family_t af;
20140 vl_api_set_punt_t *mp;
20146 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20148 if (unformat (i, "%U", unformat_vl_api_address_family, &af))
20150 else if (unformat (i, "protocol %d", &protocol))
20152 else if (unformat (i, "port %d", &port))
20154 else if (unformat (i, "del"))
20158 clib_warning ("parse error '%U'", format_unformat_error, i);
20165 mp->is_add = (u8) is_add;
20166 mp->punt.type = PUNT_API_TYPE_L4;
20167 mp->punt.punt.l4.af = af;
20168 mp->punt.punt.l4.protocol = (u8) protocol;
20169 mp->punt.punt.l4.port = htons ((u16) port);
20176 static void vl_api_ipsec_gre_tunnel_details_t_handler
20177 (vl_api_ipsec_gre_tunnel_details_t * mp)
20179 vat_main_t *vam = &vat_main;
20181 print (vam->ofp, "%11d%15U%15U%14d%14d",
20182 ntohl (mp->tunnel.sw_if_index),
20183 format_vl_api_ip4_address, mp->tunnel.src,
20184 format_vl_api_ip4_address, mp->tunnel.dst,
20185 ntohl (mp->tunnel.local_sa_id), ntohl (mp->tunnel.remote_sa_id));
20189 vat_json_object_add_vl_api_ip4 (vat_json_node_t * node,
20191 const vl_api_ip4_address_t addr)
20193 struct in_addr ip4;
20195 clib_memcpy (&ip4, addr, sizeof (ip4));
20196 vat_json_object_add_ip4 (node, name, ip4);
20199 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
20200 (vl_api_ipsec_gre_tunnel_details_t * mp)
20202 vat_main_t *vam = &vat_main;
20203 vat_json_node_t *node = NULL;
20205 if (VAT_JSON_ARRAY != vam->json_tree.type)
20207 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20208 vat_json_init_array (&vam->json_tree);
20210 node = vat_json_array_add (&vam->json_tree);
20212 vat_json_init_object (node);
20213 vat_json_object_add_uint (node, "sw_if_index",
20214 ntohl (mp->tunnel.sw_if_index));
20215 vat_json_object_add_vl_api_ip4 (node, "src", mp->tunnel.src);
20216 vat_json_object_add_vl_api_ip4 (node, "src", mp->tunnel.dst);
20217 vat_json_object_add_uint (node, "local_sa_id",
20218 ntohl (mp->tunnel.local_sa_id));
20219 vat_json_object_add_uint (node, "remote_sa_id",
20220 ntohl (mp->tunnel.remote_sa_id));
20224 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
20226 unformat_input_t *i = vam->input;
20227 vl_api_ipsec_gre_tunnel_dump_t *mp;
20228 vl_api_control_ping_t *mp_ping;
20230 u8 sw_if_index_set = 0;
20233 /* Parse args required to build the message */
20234 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20236 if (unformat (i, "sw_if_index %d", &sw_if_index))
20237 sw_if_index_set = 1;
20242 if (sw_if_index_set == 0)
20247 if (!vam->json_output)
20249 print (vam->ofp, "%11s%15s%15s%14s%14s",
20250 "sw_if_index", "src_address", "dst_address",
20251 "local_sa_id", "remote_sa_id");
20254 /* Get list of gre-tunnel interfaces */
20255 M (IPSEC_GRE_TUNNEL_DUMP, mp);
20257 mp->sw_if_index = htonl (sw_if_index);
20261 /* Use a control ping for synchronization */
20262 MPING (CONTROL_PING, mp_ping);
20270 api_delete_subif (vat_main_t * vam)
20272 unformat_input_t *i = vam->input;
20273 vl_api_delete_subif_t *mp;
20274 u32 sw_if_index = ~0;
20277 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20279 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20281 if (unformat (i, "sw_if_index %d", &sw_if_index))
20287 if (sw_if_index == ~0)
20289 errmsg ("missing sw_if_index");
20293 /* Construct the API message */
20294 M (DELETE_SUBIF, mp);
20295 mp->sw_if_index = ntohl (sw_if_index);
20302 #define foreach_pbb_vtr_op \
20303 _("disable", L2_VTR_DISABLED) \
20304 _("pop", L2_VTR_POP_2) \
20305 _("push", L2_VTR_PUSH_2)
20308 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
20310 unformat_input_t *i = vam->input;
20311 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
20312 u32 sw_if_index = ~0, vtr_op = ~0;
20313 u16 outer_tag = ~0;
20314 u8 dmac[6], smac[6];
20315 u8 dmac_set = 0, smac_set = 0;
20321 /* Shut up coverity */
20322 clib_memset (dmac, 0, sizeof (dmac));
20323 clib_memset (smac, 0, sizeof (smac));
20325 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20327 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20329 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20331 else if (unformat (i, "vtr_op %d", &vtr_op))
20333 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
20336 else if (unformat (i, "translate_pbb_stag"))
20338 if (unformat (i, "%d", &tmp))
20340 vtr_op = L2_VTR_TRANSLATE_2_1;
20346 ("translate_pbb_stag operation requires outer tag definition");
20350 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
20352 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
20354 else if (unformat (i, "sid %d", &sid))
20356 else if (unformat (i, "vlanid %d", &tmp))
20360 clib_warning ("parse error '%U'", format_unformat_error, i);
20365 if ((sw_if_index == ~0) || (vtr_op == ~0))
20367 errmsg ("missing sw_if_index or vtr operation");
20370 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
20371 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
20374 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
20378 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
20379 mp->sw_if_index = ntohl (sw_if_index);
20380 mp->vtr_op = ntohl (vtr_op);
20381 mp->outer_tag = ntohs (outer_tag);
20382 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
20383 clib_memcpy (mp->b_smac, smac, sizeof (smac));
20384 mp->b_vlanid = ntohs (vlanid);
20385 mp->i_sid = ntohl (sid);
20393 api_flow_classify_set_interface (vat_main_t * vam)
20395 unformat_input_t *i = vam->input;
20396 vl_api_flow_classify_set_interface_t *mp;
20398 int sw_if_index_set;
20399 u32 ip4_table_index = ~0;
20400 u32 ip6_table_index = ~0;
20404 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20406 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20407 sw_if_index_set = 1;
20408 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20409 sw_if_index_set = 1;
20410 else if (unformat (i, "del"))
20412 else if (unformat (i, "ip4-table %d", &ip4_table_index))
20414 else if (unformat (i, "ip6-table %d", &ip6_table_index))
20418 clib_warning ("parse error '%U'", format_unformat_error, i);
20423 if (sw_if_index_set == 0)
20425 errmsg ("missing interface name or sw_if_index");
20429 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
20431 mp->sw_if_index = ntohl (sw_if_index);
20432 mp->ip4_table_index = ntohl (ip4_table_index);
20433 mp->ip6_table_index = ntohl (ip6_table_index);
20434 mp->is_add = is_add;
20442 api_flow_classify_dump (vat_main_t * vam)
20444 unformat_input_t *i = vam->input;
20445 vl_api_flow_classify_dump_t *mp;
20446 vl_api_control_ping_t *mp_ping;
20447 u8 type = FLOW_CLASSIFY_N_TABLES;
20450 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
20454 errmsg ("classify table type must be specified");
20458 if (!vam->json_output)
20460 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
20463 M (FLOW_CLASSIFY_DUMP, mp);
20468 /* Use a control ping for synchronization */
20469 MPING (CONTROL_PING, mp_ping);
20472 /* Wait for a reply... */
20478 api_feature_enable_disable (vat_main_t * vam)
20480 unformat_input_t *i = vam->input;
20481 vl_api_feature_enable_disable_t *mp;
20483 u8 *feature_name = 0;
20484 u32 sw_if_index = ~0;
20488 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20490 if (unformat (i, "arc_name %s", &arc_name))
20492 else if (unformat (i, "feature_name %s", &feature_name))
20495 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20497 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20499 else if (unformat (i, "disable"))
20507 errmsg ("missing arc name");
20510 if (vec_len (arc_name) > 63)
20512 errmsg ("arc name too long");
20515 if (feature_name == 0)
20517 errmsg ("missing feature name");
20520 if (vec_len (feature_name) > 63)
20522 errmsg ("feature name too long");
20525 if (sw_if_index == ~0)
20527 errmsg ("missing interface name or sw_if_index");
20531 /* Construct the API message */
20532 M (FEATURE_ENABLE_DISABLE, mp);
20533 mp->sw_if_index = ntohl (sw_if_index);
20534 mp->enable = enable;
20535 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
20536 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
20537 vec_free (arc_name);
20538 vec_free (feature_name);
20546 api_sw_interface_tag_add_del (vat_main_t * vam)
20548 unformat_input_t *i = vam->input;
20549 vl_api_sw_interface_tag_add_del_t *mp;
20550 u32 sw_if_index = ~0;
20555 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20557 if (unformat (i, "tag %s", &tag))
20559 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20561 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20563 else if (unformat (i, "del"))
20569 if (sw_if_index == ~0)
20571 errmsg ("missing interface name or sw_if_index");
20575 if (enable && (tag == 0))
20577 errmsg ("no tag specified");
20581 /* Construct the API message */
20582 M (SW_INTERFACE_TAG_ADD_DEL, mp);
20583 mp->sw_if_index = ntohl (sw_if_index);
20584 mp->is_add = enable;
20586 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
20594 static void vl_api_l2_xconnect_details_t_handler
20595 (vl_api_l2_xconnect_details_t * mp)
20597 vat_main_t *vam = &vat_main;
20599 print (vam->ofp, "%15d%15d",
20600 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
20603 static void vl_api_l2_xconnect_details_t_handler_json
20604 (vl_api_l2_xconnect_details_t * mp)
20606 vat_main_t *vam = &vat_main;
20607 vat_json_node_t *node = NULL;
20609 if (VAT_JSON_ARRAY != vam->json_tree.type)
20611 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20612 vat_json_init_array (&vam->json_tree);
20614 node = vat_json_array_add (&vam->json_tree);
20616 vat_json_init_object (node);
20617 vat_json_object_add_uint (node, "rx_sw_if_index",
20618 ntohl (mp->rx_sw_if_index));
20619 vat_json_object_add_uint (node, "tx_sw_if_index",
20620 ntohl (mp->tx_sw_if_index));
20624 api_l2_xconnect_dump (vat_main_t * vam)
20626 vl_api_l2_xconnect_dump_t *mp;
20627 vl_api_control_ping_t *mp_ping;
20630 if (!vam->json_output)
20632 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
20635 M (L2_XCONNECT_DUMP, mp);
20639 /* Use a control ping for synchronization */
20640 MPING (CONTROL_PING, mp_ping);
20648 api_hw_interface_set_mtu (vat_main_t * vam)
20650 unformat_input_t *i = vam->input;
20651 vl_api_hw_interface_set_mtu_t *mp;
20652 u32 sw_if_index = ~0;
20656 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20658 if (unformat (i, "mtu %d", &mtu))
20660 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20662 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20668 if (sw_if_index == ~0)
20670 errmsg ("missing interface name or sw_if_index");
20676 errmsg ("no mtu specified");
20680 /* Construct the API message */
20681 M (HW_INTERFACE_SET_MTU, mp);
20682 mp->sw_if_index = ntohl (sw_if_index);
20683 mp->mtu = ntohs ((u16) mtu);
20691 api_p2p_ethernet_add (vat_main_t * vam)
20693 unformat_input_t *i = vam->input;
20694 vl_api_p2p_ethernet_add_t *mp;
20695 u32 parent_if_index = ~0;
20701 clib_memset (remote_mac, 0, sizeof (remote_mac));
20702 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20704 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
20706 else if (unformat (i, "sw_if_index %d", &parent_if_index))
20710 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
20712 else if (unformat (i, "sub_id %d", &sub_id))
20716 clib_warning ("parse error '%U'", format_unformat_error, i);
20721 if (parent_if_index == ~0)
20723 errmsg ("missing interface name or sw_if_index");
20728 errmsg ("missing remote mac address");
20733 errmsg ("missing sub-interface id");
20737 M (P2P_ETHERNET_ADD, mp);
20738 mp->parent_if_index = ntohl (parent_if_index);
20739 mp->subif_id = ntohl (sub_id);
20740 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
20748 api_p2p_ethernet_del (vat_main_t * vam)
20750 unformat_input_t *i = vam->input;
20751 vl_api_p2p_ethernet_del_t *mp;
20752 u32 parent_if_index = ~0;
20757 clib_memset (remote_mac, 0, sizeof (remote_mac));
20758 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20760 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
20762 else if (unformat (i, "sw_if_index %d", &parent_if_index))
20766 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
20770 clib_warning ("parse error '%U'", format_unformat_error, i);
20775 if (parent_if_index == ~0)
20777 errmsg ("missing interface name or sw_if_index");
20782 errmsg ("missing remote mac address");
20786 M (P2P_ETHERNET_DEL, mp);
20787 mp->parent_if_index = ntohl (parent_if_index);
20788 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
20796 api_lldp_config (vat_main_t * vam)
20798 unformat_input_t *i = vam->input;
20799 vl_api_lldp_config_t *mp;
20801 int tx_interval = 0;
20802 u8 *sys_name = NULL;
20805 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20807 if (unformat (i, "system-name %s", &sys_name))
20809 else if (unformat (i, "tx-hold %d", &tx_hold))
20811 else if (unformat (i, "tx-interval %d", &tx_interval))
20815 clib_warning ("parse error '%U'", format_unformat_error, i);
20820 vec_add1 (sys_name, 0);
20822 M (LLDP_CONFIG, mp);
20823 mp->tx_hold = htonl (tx_hold);
20824 mp->tx_interval = htonl (tx_interval);
20825 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
20826 vec_free (sys_name);
20834 api_sw_interface_set_lldp (vat_main_t * vam)
20836 unformat_input_t *i = vam->input;
20837 vl_api_sw_interface_set_lldp_t *mp;
20838 u32 sw_if_index = ~0;
20840 u8 *port_desc = NULL, *mgmt_oid = NULL;
20841 ip4_address_t ip4_addr;
20842 ip6_address_t ip6_addr;
20845 clib_memset (&ip4_addr, 0, sizeof (ip4_addr));
20846 clib_memset (&ip6_addr, 0, sizeof (ip6_addr));
20848 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20850 if (unformat (i, "disable"))
20853 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20855 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20857 else if (unformat (i, "port-desc %s", &port_desc))
20859 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
20861 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
20863 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
20869 if (sw_if_index == ~0)
20871 errmsg ("missing interface name or sw_if_index");
20875 /* Construct the API message */
20876 vec_add1 (port_desc, 0);
20877 vec_add1 (mgmt_oid, 0);
20878 M (SW_INTERFACE_SET_LLDP, mp);
20879 mp->sw_if_index = ntohl (sw_if_index);
20880 mp->enable = enable;
20881 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
20882 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
20883 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
20884 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
20885 vec_free (port_desc);
20886 vec_free (mgmt_oid);
20894 api_tcp_configure_src_addresses (vat_main_t * vam)
20896 vl_api_tcp_configure_src_addresses_t *mp;
20897 unformat_input_t *i = vam->input;
20898 ip4_address_t v4first, v4last;
20899 ip6_address_t v6first, v6last;
20904 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20906 if (unformat (i, "%U - %U",
20907 unformat_ip4_address, &v4first,
20908 unformat_ip4_address, &v4last))
20912 errmsg ("one range per message (range already set)");
20917 else if (unformat (i, "%U - %U",
20918 unformat_ip6_address, &v6first,
20919 unformat_ip6_address, &v6last))
20923 errmsg ("one range per message (range already set)");
20928 else if (unformat (i, "vrf %d", &vrf_id))
20934 if (range_set == 0)
20936 errmsg ("address range not set");
20940 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
20941 mp->vrf_id = ntohl (vrf_id);
20943 if (range_set == 2)
20946 clib_memcpy (mp->first_address, &v6first, sizeof (v6first));
20947 clib_memcpy (mp->last_address, &v6last, sizeof (v6last));
20952 clib_memcpy (mp->first_address, &v4first, sizeof (v4first));
20953 clib_memcpy (mp->last_address, &v4last, sizeof (v4last));
20960 static void vl_api_app_namespace_add_del_reply_t_handler
20961 (vl_api_app_namespace_add_del_reply_t * mp)
20963 vat_main_t *vam = &vat_main;
20964 i32 retval = ntohl (mp->retval);
20965 if (vam->async_mode)
20967 vam->async_errors += (retval < 0);
20971 vam->retval = retval;
20973 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
20974 vam->result_ready = 1;
20978 static void vl_api_app_namespace_add_del_reply_t_handler_json
20979 (vl_api_app_namespace_add_del_reply_t * mp)
20981 vat_main_t *vam = &vat_main;
20982 vat_json_node_t node;
20984 vat_json_init_object (&node);
20985 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
20986 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
20988 vat_json_print (vam->ofp, &node);
20989 vat_json_free (&node);
20991 vam->retval = ntohl (mp->retval);
20992 vam->result_ready = 1;
20996 api_app_namespace_add_del (vat_main_t * vam)
20998 vl_api_app_namespace_add_del_t *mp;
20999 unformat_input_t *i = vam->input;
21000 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
21001 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
21005 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21007 if (unformat (i, "id %_%v%_", &ns_id))
21009 else if (unformat (i, "secret %lu", &secret))
21011 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21012 sw_if_index_set = 1;
21013 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
21015 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
21020 if (!ns_id || !secret_set || !sw_if_index_set)
21022 errmsg ("namespace id, secret and sw_if_index must be set");
21025 if (vec_len (ns_id) > 64)
21027 errmsg ("namespace id too long");
21030 M (APP_NAMESPACE_ADD_DEL, mp);
21032 clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
21033 mp->namespace_id_len = vec_len (ns_id);
21034 mp->secret = clib_host_to_net_u64 (secret);
21035 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
21036 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
21037 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
21045 api_sock_init_shm (vat_main_t * vam)
21047 #if VPP_API_TEST_BUILTIN == 0
21048 unformat_input_t *i = vam->input;
21049 vl_api_shm_elem_config_t *config = 0;
21050 u64 size = 64 << 20;
21053 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21055 if (unformat (i, "size %U", unformat_memory_size, &size))
21062 * Canned custom ring allocator config.
21063 * Should probably parse all of this
21065 vec_validate (config, 6);
21066 config[0].type = VL_API_VLIB_RING;
21067 config[0].size = 256;
21068 config[0].count = 32;
21070 config[1].type = VL_API_VLIB_RING;
21071 config[1].size = 1024;
21072 config[1].count = 16;
21074 config[2].type = VL_API_VLIB_RING;
21075 config[2].size = 4096;
21076 config[2].count = 2;
21078 config[3].type = VL_API_CLIENT_RING;
21079 config[3].size = 256;
21080 config[3].count = 32;
21082 config[4].type = VL_API_CLIENT_RING;
21083 config[4].size = 1024;
21084 config[4].count = 16;
21086 config[5].type = VL_API_CLIENT_RING;
21087 config[5].size = 4096;
21088 config[5].count = 2;
21090 config[6].type = VL_API_QUEUE;
21091 config[6].count = 128;
21092 config[6].size = sizeof (uword);
21094 rv = vl_socket_client_init_shm (config, 1 /* want_pthread */ );
21096 vam->client_index_invalid = 1;
21104 api_dns_enable_disable (vat_main_t * vam)
21106 unformat_input_t *line_input = vam->input;
21107 vl_api_dns_enable_disable_t *mp;
21108 u8 enable_disable = 1;
21111 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21113 if (unformat (line_input, "disable"))
21114 enable_disable = 0;
21115 if (unformat (line_input, "enable"))
21116 enable_disable = 1;
21121 /* Construct the API message */
21122 M (DNS_ENABLE_DISABLE, mp);
21123 mp->enable = enable_disable;
21127 /* Wait for the reply */
21133 api_dns_resolve_name (vat_main_t * vam)
21135 unformat_input_t *line_input = vam->input;
21136 vl_api_dns_resolve_name_t *mp;
21140 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21142 if (unformat (line_input, "%s", &name))
21148 if (vec_len (name) > 127)
21150 errmsg ("name too long");
21154 /* Construct the API message */
21155 M (DNS_RESOLVE_NAME, mp);
21156 memcpy (mp->name, name, vec_len (name));
21161 /* Wait for the reply */
21167 api_dns_resolve_ip (vat_main_t * vam)
21169 unformat_input_t *line_input = vam->input;
21170 vl_api_dns_resolve_ip_t *mp;
21172 ip4_address_t addr4;
21173 ip6_address_t addr6;
21176 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21178 if (unformat (line_input, "%U", unformat_ip6_address, &addr6))
21180 else if (unformat (line_input, "%U", unformat_ip4_address, &addr4))
21188 errmsg ("missing address");
21192 /* Construct the API message */
21193 M (DNS_RESOLVE_IP, mp);
21194 mp->is_ip6 = is_ip6;
21196 memcpy (mp->address, &addr6, sizeof (addr6));
21198 memcpy (mp->address, &addr4, sizeof (addr4));
21202 /* Wait for the reply */
21208 api_dns_name_server_add_del (vat_main_t * vam)
21210 unformat_input_t *i = vam->input;
21211 vl_api_dns_name_server_add_del_t *mp;
21213 ip6_address_t ip6_server;
21214 ip4_address_t ip4_server;
21219 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21221 if (unformat (i, "%U", unformat_ip6_address, &ip6_server))
21223 else if (unformat (i, "%U", unformat_ip4_address, &ip4_server))
21225 else if (unformat (i, "del"))
21229 clib_warning ("parse error '%U'", format_unformat_error, i);
21234 if (ip4_set && ip6_set)
21236 errmsg ("Only one server address allowed per message");
21239 if ((ip4_set + ip6_set) == 0)
21241 errmsg ("Server address required");
21245 /* Construct the API message */
21246 M (DNS_NAME_SERVER_ADD_DEL, mp);
21250 memcpy (mp->server_address, &ip6_server, sizeof (ip6_address_t));
21255 memcpy (mp->server_address, &ip4_server, sizeof (ip4_address_t));
21259 mp->is_add = is_add;
21264 /* Wait for a reply, return good/bad news */
21270 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
21272 vat_main_t *vam = &vat_main;
21277 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
21278 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
21279 mp->scope, format_ip4_address, &mp->lcl_ip, mp->lcl_plen,
21280 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
21281 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
21282 clib_net_to_host_u32 (mp->action_index), mp->tag);
21287 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
21288 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
21289 mp->scope, format_ip6_address, &mp->lcl_ip, mp->lcl_plen,
21290 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
21291 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
21292 clib_net_to_host_u32 (mp->action_index), mp->tag);
21297 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
21300 vat_main_t *vam = &vat_main;
21301 vat_json_node_t *node = NULL;
21302 struct in6_addr ip6;
21303 struct in_addr ip4;
21305 if (VAT_JSON_ARRAY != vam->json_tree.type)
21307 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
21308 vat_json_init_array (&vam->json_tree);
21310 node = vat_json_array_add (&vam->json_tree);
21311 vat_json_init_object (node);
21313 vat_json_object_add_uint (node, "is_ip4", mp->is_ip4 ? 1 : 0);
21314 vat_json_object_add_uint (node, "appns_index",
21315 clib_net_to_host_u32 (mp->appns_index));
21316 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
21317 vat_json_object_add_uint (node, "scope", mp->scope);
21318 vat_json_object_add_uint (node, "action_index",
21319 clib_net_to_host_u32 (mp->action_index));
21320 vat_json_object_add_uint (node, "lcl_port",
21321 clib_net_to_host_u16 (mp->lcl_port));
21322 vat_json_object_add_uint (node, "rmt_port",
21323 clib_net_to_host_u16 (mp->rmt_port));
21324 vat_json_object_add_uint (node, "lcl_plen", mp->lcl_plen);
21325 vat_json_object_add_uint (node, "rmt_plen", mp->rmt_plen);
21326 vat_json_object_add_string_copy (node, "tag", mp->tag);
21329 clib_memcpy (&ip4, mp->lcl_ip, sizeof (ip4));
21330 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
21331 clib_memcpy (&ip4, mp->rmt_ip, sizeof (ip4));
21332 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
21336 clib_memcpy (&ip6, mp->lcl_ip, sizeof (ip6));
21337 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
21338 clib_memcpy (&ip6, mp->rmt_ip, sizeof (ip6));
21339 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
21344 api_session_rule_add_del (vat_main_t * vam)
21346 vl_api_session_rule_add_del_t *mp;
21347 unformat_input_t *i = vam->input;
21348 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
21349 u32 appns_index = 0, scope = 0;
21350 ip4_address_t lcl_ip4, rmt_ip4;
21351 ip6_address_t lcl_ip6, rmt_ip6;
21352 u8 is_ip4 = 1, conn_set = 0;
21353 u8 is_add = 1, *tag = 0;
21356 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21358 if (unformat (i, "del"))
21360 else if (unformat (i, "add"))
21362 else if (unformat (i, "proto tcp"))
21364 else if (unformat (i, "proto udp"))
21366 else if (unformat (i, "appns %d", &appns_index))
21368 else if (unformat (i, "scope %d", &scope))
21370 else if (unformat (i, "tag %_%v%_", &tag))
21374 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
21375 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
21383 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
21384 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
21390 else if (unformat (i, "action %d", &action))
21395 if (proto == ~0 || !conn_set || action == ~0)
21397 errmsg ("transport proto, connection and action must be set");
21403 errmsg ("scope should be 0-3");
21407 M (SESSION_RULE_ADD_DEL, mp);
21409 mp->is_ip4 = is_ip4;
21410 mp->transport_proto = proto;
21411 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
21412 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
21413 mp->lcl_plen = lcl_plen;
21414 mp->rmt_plen = rmt_plen;
21415 mp->action_index = clib_host_to_net_u32 (action);
21416 mp->appns_index = clib_host_to_net_u32 (appns_index);
21418 mp->is_add = is_add;
21421 clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
21422 clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
21426 clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
21427 clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
21431 clib_memcpy (mp->tag, tag, vec_len (tag));
21441 api_session_rules_dump (vat_main_t * vam)
21443 vl_api_session_rules_dump_t *mp;
21444 vl_api_control_ping_t *mp_ping;
21447 if (!vam->json_output)
21449 print (vam->ofp, "%=20s", "Session Rules");
21452 M (SESSION_RULES_DUMP, mp);
21456 /* Use a control ping for synchronization */
21457 MPING (CONTROL_PING, mp_ping);
21460 /* Wait for a reply... */
21466 api_ip_container_proxy_add_del (vat_main_t * vam)
21468 vl_api_ip_container_proxy_add_del_t *mp;
21469 unformat_input_t *i = vam->input;
21470 u32 sw_if_index = ~0;
21471 vl_api_prefix_t pfx = { };
21475 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21477 if (unformat (i, "del"))
21479 else if (unformat (i, "add"))
21481 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
21483 else if (unformat (i, "sw_if_index %u", &sw_if_index))
21488 if (sw_if_index == ~0 || pfx.address_length == 0)
21490 errmsg ("address and sw_if_index must be set");
21494 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
21496 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
21497 mp->is_add = is_add;
21498 clib_memcpy (&mp->pfx, &pfx, sizeof (pfx));
21506 api_qos_record_enable_disable (vat_main_t * vam)
21508 unformat_input_t *i = vam->input;
21509 vl_api_qos_record_enable_disable_t *mp;
21510 u32 sw_if_index, qs = 0xff;
21511 u8 sw_if_index_set = 0;
21515 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21517 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21518 sw_if_index_set = 1;
21519 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21520 sw_if_index_set = 1;
21521 else if (unformat (i, "%U", unformat_qos_source, &qs))
21523 else if (unformat (i, "disable"))
21527 clib_warning ("parse error '%U'", format_unformat_error, i);
21532 if (sw_if_index_set == 0)
21534 errmsg ("missing interface name or sw_if_index");
21539 errmsg ("input location must be specified");
21543 M (QOS_RECORD_ENABLE_DISABLE, mp);
21545 mp->sw_if_index = ntohl (sw_if_index);
21546 mp->input_source = qs;
21547 mp->enable = enable;
21556 q_or_quit (vat_main_t * vam)
21558 #if VPP_API_TEST_BUILTIN == 0
21559 longjmp (vam->jump_buf, 1);
21561 return 0; /* not so much */
21565 q (vat_main_t * vam)
21567 return q_or_quit (vam);
21571 quit (vat_main_t * vam)
21573 return q_or_quit (vam);
21577 comment (vat_main_t * vam)
21583 statseg (vat_main_t * vam)
21585 ssvm_private_t *ssvmp = &vam->stat_segment;
21586 ssvm_shared_header_t *shared_header = ssvmp->sh;
21587 vlib_counter_t **counters;
21588 u64 thread0_index1_packets;
21589 u64 thread0_index1_bytes;
21590 f64 vector_rate, input_rate;
21593 uword *counter_vector_by_name;
21594 if (vam->stat_segment_lockp == 0)
21596 errmsg ("Stat segment not mapped...");
21600 /* look up "/if/rx for sw_if_index 1 as a test */
21602 clib_spinlock_lock (vam->stat_segment_lockp);
21604 counter_vector_by_name = (uword *) shared_header->opaque[1];
21606 p = hash_get_mem (counter_vector_by_name, "/if/rx");
21609 clib_spinlock_unlock (vam->stat_segment_lockp);
21610 errmsg ("/if/tx not found?");
21614 /* Fish per-thread vector of combined counters from shared memory */
21615 counters = (vlib_counter_t **) p[0];
21617 if (vec_len (counters[0]) < 2)
21619 clib_spinlock_unlock (vam->stat_segment_lockp);
21620 errmsg ("/if/tx vector length %d", vec_len (counters[0]));
21624 /* Read thread 0 sw_if_index 1 counter */
21625 thread0_index1_packets = counters[0][1].packets;
21626 thread0_index1_bytes = counters[0][1].bytes;
21628 p = hash_get_mem (counter_vector_by_name, "vector_rate");
21631 clib_spinlock_unlock (vam->stat_segment_lockp);
21632 errmsg ("vector_rate not found?");
21636 vector_rate = *(f64 *) (p[0]);
21637 p = hash_get_mem (counter_vector_by_name, "input_rate");
21640 clib_spinlock_unlock (vam->stat_segment_lockp);
21641 errmsg ("input_rate not found?");
21644 input_rate = *(f64 *) (p[0]);
21646 clib_spinlock_unlock (vam->stat_segment_lockp);
21648 print (vam->ofp, "vector_rate %.2f input_rate %.2f",
21649 vector_rate, input_rate);
21650 print (vam->ofp, "thread 0 sw_if_index 1 rx pkts %lld, bytes %lld",
21651 thread0_index1_packets, thread0_index1_bytes);
21657 cmd_cmp (void *a1, void *a2)
21662 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
21666 help (vat_main_t * vam)
21671 unformat_input_t *i = vam->input;
21674 if (unformat (i, "%s", &name))
21678 vec_add1 (name, 0);
21680 hs = hash_get_mem (vam->help_by_name, name);
21682 print (vam->ofp, "usage: %s %s", name, hs[0]);
21684 print (vam->ofp, "No such msg / command '%s'", name);
21689 print (vam->ofp, "Help is available for the following:");
21692 hash_foreach_pair (p, vam->function_by_name,
21694 vec_add1 (cmds, (u8 *)(p->key));
21698 vec_sort_with_function (cmds, cmd_cmp);
21700 for (j = 0; j < vec_len (cmds); j++)
21701 print (vam->ofp, "%s", cmds[j]);
21708 set (vat_main_t * vam)
21710 u8 *name = 0, *value = 0;
21711 unformat_input_t *i = vam->input;
21713 if (unformat (i, "%s", &name))
21715 /* The input buffer is a vector, not a string. */
21716 value = vec_dup (i->buffer);
21717 vec_delete (value, i->index, 0);
21718 /* Almost certainly has a trailing newline */
21719 if (value[vec_len (value) - 1] == '\n')
21720 value[vec_len (value) - 1] = 0;
21721 /* Make sure it's a proper string, one way or the other */
21722 vec_add1 (value, 0);
21723 (void) clib_macro_set_value (&vam->macro_main,
21724 (char *) name, (char *) value);
21727 errmsg ("usage: set <name> <value>");
21735 unset (vat_main_t * vam)
21739 if (unformat (vam->input, "%s", &name))
21740 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
21741 errmsg ("unset: %s wasn't set", name);
21754 macro_sort_cmp (void *a1, void *a2)
21756 macro_sort_t *s1 = a1;
21757 macro_sort_t *s2 = a2;
21759 return strcmp ((char *) (s1->name), (char *) (s2->name));
21763 dump_macro_table (vat_main_t * vam)
21765 macro_sort_t *sort_me = 0, *sm;
21770 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
21772 vec_add2 (sort_me, sm, 1);
21773 sm->name = (u8 *)(p->key);
21774 sm->value = (u8 *) (p->value[0]);
21778 vec_sort_with_function (sort_me, macro_sort_cmp);
21780 if (vec_len (sort_me))
21781 print (vam->ofp, "%-15s%s", "Name", "Value");
21783 print (vam->ofp, "The macro table is empty...");
21785 for (i = 0; i < vec_len (sort_me); i++)
21786 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
21791 dump_node_table (vat_main_t * vam)
21794 vlib_node_t *node, *next_node;
21796 if (vec_len (vam->graph_nodes) == 0)
21798 print (vam->ofp, "Node table empty, issue get_node_graph...");
21802 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
21804 node = vam->graph_nodes[0][i];
21805 print (vam->ofp, "[%d] %s", i, node->name);
21806 for (j = 0; j < vec_len (node->next_nodes); j++)
21808 if (node->next_nodes[j] != ~0)
21810 next_node = vam->graph_nodes[0][node->next_nodes[j]];
21811 print (vam->ofp, " [%d] %s", j, next_node->name);
21819 value_sort_cmp (void *a1, void *a2)
21821 name_sort_t *n1 = a1;
21822 name_sort_t *n2 = a2;
21824 if (n1->value < n2->value)
21826 if (n1->value > n2->value)
21833 dump_msg_api_table (vat_main_t * vam)
21835 api_main_t *am = &api_main;
21836 name_sort_t *nses = 0, *ns;
21841 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
21843 vec_add2 (nses, ns, 1);
21844 ns->name = (u8 *)(hp->key);
21845 ns->value = (u32) hp->value[0];
21849 vec_sort_with_function (nses, value_sort_cmp);
21851 for (i = 0; i < vec_len (nses); i++)
21852 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
21858 get_msg_id (vat_main_t * vam)
21863 if (unformat (vam->input, "%s", &name_and_crc))
21865 message_index = vl_msg_api_get_msg_index (name_and_crc);
21866 if (message_index == ~0)
21868 print (vam->ofp, " '%s' not found", name_and_crc);
21871 print (vam->ofp, " '%s' has message index %d",
21872 name_and_crc, message_index);
21875 errmsg ("name_and_crc required...");
21880 search_node_table (vat_main_t * vam)
21882 unformat_input_t *line_input = vam->input;
21885 vlib_node_t *node, *next_node;
21888 if (vam->graph_node_index_by_name == 0)
21890 print (vam->ofp, "Node table empty, issue get_node_graph...");
21894 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21896 if (unformat (line_input, "%s", &node_to_find))
21898 vec_add1 (node_to_find, 0);
21899 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
21902 print (vam->ofp, "%s not found...", node_to_find);
21905 node = vam->graph_nodes[0][p[0]];
21906 print (vam->ofp, "[%d] %s", p[0], node->name);
21907 for (j = 0; j < vec_len (node->next_nodes); j++)
21909 if (node->next_nodes[j] != ~0)
21911 next_node = vam->graph_nodes[0][node->next_nodes[j]];
21912 print (vam->ofp, " [%d] %s", j, next_node->name);
21919 clib_warning ("parse error '%U'", format_unformat_error,
21925 vec_free (node_to_find);
21934 script (vat_main_t * vam)
21936 #if (VPP_API_TEST_BUILTIN==0)
21938 char *save_current_file;
21939 unformat_input_t save_input;
21940 jmp_buf save_jump_buf;
21941 u32 save_line_number;
21943 FILE *new_fp, *save_ifp;
21945 if (unformat (vam->input, "%s", &s))
21947 new_fp = fopen ((char *) s, "r");
21950 errmsg ("Couldn't open script file %s", s);
21957 errmsg ("Missing script name");
21961 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
21962 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
21963 save_ifp = vam->ifp;
21964 save_line_number = vam->input_line_number;
21965 save_current_file = (char *) vam->current_file;
21967 vam->input_line_number = 0;
21969 vam->current_file = s;
21972 clib_memcpy (&vam->input, &save_input, sizeof (save_input));
21973 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
21974 vam->ifp = save_ifp;
21975 vam->input_line_number = save_line_number;
21976 vam->current_file = (u8 *) save_current_file;
21981 clib_warning ("use the exec command...");
21987 echo (vat_main_t * vam)
21989 print (vam->ofp, "%v", vam->input->buffer);
21993 /* List of API message constructors, CLI names map to api_xxx */
21994 #define foreach_vpe_api_msg \
21995 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
21996 _(sw_interface_dump,"") \
21997 _(sw_interface_set_flags, \
21998 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
21999 _(sw_interface_add_del_address, \
22000 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
22001 _(sw_interface_set_rx_mode, \
22002 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
22003 _(sw_interface_set_rx_placement, \
22004 "<intfc> | sw_if_index <id> [queue <id>] [worker <id> | main]") \
22005 _(sw_interface_rx_placement_dump, \
22006 "[<intfc> | sw_if_index <id>]") \
22007 _(sw_interface_set_table, \
22008 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
22009 _(sw_interface_set_mpls_enable, \
22010 "<intfc> | sw_if_index [disable | dis]") \
22011 _(sw_interface_set_vpath, \
22012 "<intfc> | sw_if_index <id> enable | disable") \
22013 _(sw_interface_set_vxlan_bypass, \
22014 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
22015 _(sw_interface_set_geneve_bypass, \
22016 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
22017 _(sw_interface_set_l2_xconnect, \
22018 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
22019 "enable | disable") \
22020 _(sw_interface_set_l2_bridge, \
22021 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
22022 "[shg <split-horizon-group>] [bvi]\n" \
22023 "enable | disable") \
22024 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
22025 _(bridge_domain_add_del, \
22026 "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") \
22027 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
22029 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
22030 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
22031 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
22033 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
22035 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
22037 "id <num> [hw-addr <mac-addr>] [host-ns <name>] [rx-ring-size <num> [tx-ring-size <num>]") \
22039 "<vpp-if-name> | sw_if_index <id>") \
22040 _(sw_interface_tap_v2_dump, "") \
22041 _(virtio_pci_create, \
22042 "pci-addr <pci-address> [use_random_mac | hw-addr <mac-addr>] [features <hex-value>] [gso-enabled]") \
22043 _(virtio_pci_delete, \
22044 "<vpp-if-name> | sw_if_index <id>") \
22045 _(sw_interface_virtio_pci_dump, "") \
22047 "[hw-addr <mac-addr>] {round-robin | active-backup | " \
22048 "broadcast | {lacp | xor} [load-balance { l2 | l23 | l34 }]} " \
22051 "<vpp-if-name> | sw_if_index <id>") \
22053 "sw_if_index <n> bond <sw_if_index> [is_passive] [is_long_timeout]") \
22054 _(bond_detach_slave, \
22055 "sw_if_index <n>") \
22056 _(sw_interface_bond_dump, "") \
22057 _(sw_interface_slave_dump, \
22058 "<vpp-if-name> | sw_if_index <id>") \
22059 _(ip_table_add_del, \
22060 "table <n> [ipv6] [add | del]\n") \
22061 _(ip_route_add_del, \
22062 "<addr>/<mask> via <<addr>|<intfc>|sw_if_index <id>|via-label <n>>\n" \
22063 "[table-id <n>] [<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n"\
22064 "[weight <n>] [drop] [local] [classify <n>] [out-label <n>]\n" \
22065 "[multipath] [count <n>] [del]") \
22066 _(ip_mroute_add_del, \
22067 "<src> <grp>/<mask> [table-id <n>]\n" \
22068 "[<intfc> | sw_if_index <id>] [local] [del]") \
22069 _(mpls_table_add_del, \
22070 "table <n> [add | del]\n") \
22071 _(mpls_route_add_del, \
22072 "<label> <eos> via <addr | next-hop-table <n> | via-label <n> |\n" \
22073 "lookup-ip4-table <n> | lookup-in-ip6-table <n> |\n" \
22074 "l2-input-on <intfc> | l2-input-on sw_if_index <id>>\n" \
22075 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>] [weight <n>]\n" \
22076 "[drop] [local] [classify <n>] [out-label <n>] [multipath]\n" \
22077 "[count <n>] [del]") \
22078 _(mpls_ip_bind_unbind, \
22079 "<label> <addr/len>") \
22080 _(mpls_tunnel_add_del, \
22081 "[add | del <intfc | sw_if_index <id>>] via <addr | via-label <n>>\n" \
22082 "[<intfc> | sw_if_index <id> | next-hop-table <id>]\n" \
22083 "[l2-only] [out-label <n>]") \
22084 _(sr_mpls_policy_add, \
22085 "bsid <id> [weight <n>] [spray] next <sid> [next <sid>]") \
22086 _(sr_mpls_policy_del, \
22088 _(bier_table_add_del, \
22089 "<label> <sub-domain> <set> <bsl> [del]") \
22090 _(bier_route_add_del, \
22091 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
22092 "[<intfc> | sw_if_index <id>]" \
22093 "[weight <n>] [del] [multipath]") \
22094 _(proxy_arp_add_del, \
22095 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
22096 _(proxy_arp_intfc_enable_disable, \
22097 "<intfc> | sw_if_index <id> enable | disable") \
22098 _(sw_interface_set_unnumbered, \
22099 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
22100 _(ip_neighbor_add_del, \
22101 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
22102 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
22103 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
22104 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
22105 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
22106 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
22107 "[outer_vlan_id_any][inner_vlan_id_any]") \
22108 _(reset_fib, "vrf <n> [ipv6]") \
22109 _(dhcp_proxy_config, \
22110 "svr <v46-address> src <v46-address>\n" \
22111 "rx_vrf_id <nn> server_vrf_id <nn> [del]") \
22112 _(dhcp_proxy_set_vss, \
22113 "tbl_id <n> [fib_id <n> oui <n> | vpn_ascii_id <text>] [ipv6] [del]") \
22114 _(dhcp_proxy_dump, "ip6") \
22115 _(dhcp_client_config, \
22116 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
22117 _(set_ip_flow_hash, \
22118 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
22119 _(sw_interface_ip6_enable_disable, \
22120 "<intfc> | sw_if_index <id> enable | disable") \
22121 _(ip6nd_proxy_add_del, \
22122 "<intfc> | sw_if_index <id> <ip6-address>") \
22123 _(ip6nd_proxy_dump, "") \
22124 _(sw_interface_ip6nd_ra_prefix, \
22125 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
22126 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
22127 "[nolink] [isno]") \
22128 _(sw_interface_ip6nd_ra_config, \
22129 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
22130 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
22131 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
22132 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
22133 _(l2_patch_add_del, \
22134 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
22135 "enable | disable") \
22136 _(sr_localsid_add_del, \
22137 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
22138 "fib-table <num> (end.psp) sw_if_index <num>") \
22139 _(classify_add_del_table, \
22140 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
22141 " [del] [del-chain] mask <mask-value>\n" \
22142 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
22143 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
22144 _(classify_add_del_session, \
22145 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
22146 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
22147 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
22148 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
22149 _(classify_set_interface_ip_table, \
22150 "<intfc> | sw_if_index <nn> table <nn>") \
22151 _(classify_set_interface_l2_tables, \
22152 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22153 " [other-table <nn>]") \
22154 _(get_node_index, "node <node-name") \
22155 _(add_node_next, "node <node-name> next <next-node-name>") \
22156 _(l2tpv3_create_tunnel, \
22157 "client_address <ip6-addr> our_address <ip6-addr>\n" \
22158 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
22159 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
22160 _(l2tpv3_set_tunnel_cookies, \
22161 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
22162 "[new_remote_cookie <nn>]\n") \
22163 _(l2tpv3_interface_enable_disable, \
22164 "<intfc> | sw_if_index <nn> enable | disable") \
22165 _(l2tpv3_set_lookup_key, \
22166 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
22167 _(sw_if_l2tpv3_tunnel_dump, "") \
22168 _(vxlan_offload_rx, \
22169 "hw { <interface name> | hw_if_index <nn>} " \
22170 "rx { <vxlan tunnel name> | sw_if_index <nn> } [del]") \
22171 _(vxlan_add_del_tunnel, \
22172 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
22173 "{ <intfc> | mcast_sw_if_index <nn> } [instance <id>]}\n" \
22174 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
22175 _(geneve_add_del_tunnel, \
22176 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
22177 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22178 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
22179 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22180 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22181 _(gre_tunnel_add_del, \
22182 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [instance <n>]\n" \
22183 "[teb | erspan <session-id>] [del]") \
22184 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22185 _(l2_fib_clear_table, "") \
22186 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
22187 _(l2_interface_vlan_tag_rewrite, \
22188 "<intfc> | sw_if_index <nn> \n" \
22189 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
22190 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
22191 _(create_vhost_user_if, \
22192 "socket <filename> [server] [renumber <dev_instance>] " \
22193 "[disable_mrg_rxbuf] [disable_indirect_desc] " \
22194 "[mac <mac_address>]") \
22195 _(modify_vhost_user_if, \
22196 "<intfc> | sw_if_index <nn> socket <filename>\n" \
22197 "[server] [renumber <dev_instance>]") \
22198 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
22199 _(sw_interface_vhost_user_dump, "") \
22200 _(show_version, "") \
22201 _(show_threads, "") \
22202 _(vxlan_gpe_add_del_tunnel, \
22203 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
22204 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22205 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
22206 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
22207 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22208 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
22209 _(interface_name_renumber, \
22210 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
22211 _(input_acl_set_interface, \
22212 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22213 " [l2-table <nn>] [del]") \
22214 _(ip_probe_neighbor, "(<intc> | sw_if_index <nn>) address <ip4|ip6-addr>") \
22215 _(ip_scan_neighbor_enable_disable, "[ip4|ip6|both|disable] [interval <n-min>]\n" \
22216 " [max-time <n-usec>] [max-update <n>] [delay <n-msec>] [stale <n-min>]") \
22217 _(want_ip4_arp_events, "address <ip4-address> [del]") \
22218 _(want_ip6_nd_events, "address <ip6-address> [del]") \
22219 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
22220 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
22221 _(ip_dump, "ipv4 | ipv6") \
22222 _(ipsec_spd_add_del, "spd_id <n> [del]") \
22223 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
22225 _(ipsec_sad_entry_add_del, "sad_id <n> spi <n> crypto_alg <alg>\n" \
22226 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
22227 " integ_alg <alg> integ_key <hex>") \
22228 _(ipsec_spd_entry_add_del, "spd_id <n> priority <n> action <action>\n" \
22229 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
22230 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
22231 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
22232 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
22233 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
22234 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
22235 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n" \
22236 " [instance <n>]") \
22237 _(ipsec_sa_dump, "[sa_id <n>]") \
22238 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
22239 _(delete_loopback,"sw_if_index <nn>") \
22240 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
22241 _(bd_ip_mac_flush, "bd_id <bridge-domain-id>") \
22242 _(bd_ip_mac_dump, "[bd_id] <bridge-domain-id>") \
22243 _(want_interface_events, "enable|disable") \
22244 _(get_first_msg_id, "client <name>") \
22245 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
22246 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
22247 "fib-id <nn> [ip4][ip6][default]") \
22248 _(get_node_graph, " ") \
22249 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
22250 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
22251 _(ioam_disable, "") \
22252 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
22253 " sw_if_index <sw_if_index> p <priority> " \
22254 "w <weight>] [del]") \
22255 _(one_add_del_locator, "locator-set <locator_name> " \
22256 "iface <intf> | sw_if_index <sw_if_index> " \
22257 "p <priority> w <weight> [del]") \
22258 _(one_add_del_local_eid,"vni <vni> eid " \
22259 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22260 "locator-set <locator_name> [del]" \
22261 "[key-id sha1|sha256 secret-key <secret-key>]")\
22262 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
22263 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
22264 _(one_enable_disable, "enable|disable") \
22265 _(one_map_register_enable_disable, "enable|disable") \
22266 _(one_map_register_fallback_threshold, "<value>") \
22267 _(one_rloc_probe_enable_disable, "enable|disable") \
22268 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22270 "rloc <locator> p <prio> " \
22271 "w <weight> [rloc <loc> ... ] " \
22272 "action <action> [del-all]") \
22273 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22275 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22276 _(one_use_petr, "ip-address> | disable") \
22277 _(one_map_request_mode, "src-dst|dst-only") \
22278 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22279 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22280 _(one_locator_set_dump, "[local | remote]") \
22281 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
22282 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22283 "[local] | [remote]") \
22284 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
22285 _(one_ndp_bd_get, "") \
22286 _(one_ndp_entries_get, "bd <bridge-domain>") \
22287 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
22288 _(one_l2_arp_bd_get, "") \
22289 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
22290 _(one_stats_enable_disable, "enable|disable") \
22291 _(show_one_stats_enable_disable, "") \
22292 _(one_eid_table_vni_dump, "") \
22293 _(one_eid_table_map_dump, "l2|l3") \
22294 _(one_map_resolver_dump, "") \
22295 _(one_map_server_dump, "") \
22296 _(one_adjacencies_get, "vni <vni>") \
22297 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
22298 _(show_one_rloc_probe_state, "") \
22299 _(show_one_map_register_state, "") \
22300 _(show_one_status, "") \
22301 _(one_stats_dump, "") \
22302 _(one_stats_flush, "") \
22303 _(one_get_map_request_itr_rlocs, "") \
22304 _(one_map_register_set_ttl, "<ttl>") \
22305 _(one_set_transport_protocol, "udp|api") \
22306 _(one_get_transport_protocol, "") \
22307 _(one_enable_disable_xtr_mode, "enable|disable") \
22308 _(one_show_xtr_mode, "") \
22309 _(one_enable_disable_pitr_mode, "enable|disable") \
22310 _(one_show_pitr_mode, "") \
22311 _(one_enable_disable_petr_mode, "enable|disable") \
22312 _(one_show_petr_mode, "") \
22313 _(show_one_nsh_mapping, "") \
22314 _(show_one_pitr, "") \
22315 _(show_one_use_petr, "") \
22316 _(show_one_map_request_mode, "") \
22317 _(show_one_map_register_ttl, "") \
22318 _(show_one_map_register_fallback_threshold, "") \
22319 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
22320 " sw_if_index <sw_if_index> p <priority> " \
22321 "w <weight>] [del]") \
22322 _(lisp_add_del_locator, "locator-set <locator_name> " \
22323 "iface <intf> | sw_if_index <sw_if_index> " \
22324 "p <priority> w <weight> [del]") \
22325 _(lisp_add_del_local_eid,"vni <vni> eid " \
22326 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22327 "locator-set <locator_name> [del]" \
22328 "[key-id sha1|sha256 secret-key <secret-key>]") \
22329 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
22330 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
22331 _(lisp_enable_disable, "enable|disable") \
22332 _(lisp_map_register_enable_disable, "enable|disable") \
22333 _(lisp_rloc_probe_enable_disable, "enable|disable") \
22334 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22336 "rloc <locator> p <prio> " \
22337 "w <weight> [rloc <loc> ... ] " \
22338 "action <action> [del-all]") \
22339 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22341 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22342 _(lisp_use_petr, "<ip-address> | disable") \
22343 _(lisp_map_request_mode, "src-dst|dst-only") \
22344 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22345 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22346 _(lisp_locator_set_dump, "[local | remote]") \
22347 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
22348 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22349 "[local] | [remote]") \
22350 _(lisp_eid_table_vni_dump, "") \
22351 _(lisp_eid_table_map_dump, "l2|l3") \
22352 _(lisp_map_resolver_dump, "") \
22353 _(lisp_map_server_dump, "") \
22354 _(lisp_adjacencies_get, "vni <vni>") \
22355 _(gpe_fwd_entry_vnis_get, "") \
22356 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
22357 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
22358 "[table <table-id>]") \
22359 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
22360 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
22361 _(gpe_set_encap_mode, "lisp|vxlan") \
22362 _(gpe_get_encap_mode, "") \
22363 _(lisp_gpe_add_del_iface, "up|down") \
22364 _(lisp_gpe_enable_disable, "enable|disable") \
22365 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
22366 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
22367 _(show_lisp_rloc_probe_state, "") \
22368 _(show_lisp_map_register_state, "") \
22369 _(show_lisp_status, "") \
22370 _(lisp_get_map_request_itr_rlocs, "") \
22371 _(show_lisp_pitr, "") \
22372 _(show_lisp_use_petr, "") \
22373 _(show_lisp_map_request_mode, "") \
22374 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
22375 _(af_packet_delete, "name <host interface name>") \
22376 _(af_packet_dump, "") \
22377 _(policer_add_del, "name <policer name> <params> [del]") \
22378 _(policer_dump, "[name <policer name>]") \
22379 _(policer_classify_set_interface, \
22380 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22381 " [l2-table <nn>] [del]") \
22382 _(policer_classify_dump, "type [ip4|ip6|l2]") \
22383 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
22384 "[master|slave]") \
22385 _(netmap_delete, "name <interface name>") \
22386 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
22387 _(mpls_table_dump, "") \
22388 _(mpls_route_dump, "table-id <ID>") \
22389 _(classify_table_ids, "") \
22390 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
22391 _(classify_table_info, "table_id <nn>") \
22392 _(classify_session_dump, "table_id <nn>") \
22393 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
22394 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
22395 "[template_interval <nn>] [udp_checksum]") \
22396 _(ipfix_exporter_dump, "") \
22397 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
22398 _(ipfix_classify_stream_dump, "") \
22399 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
22400 _(ipfix_classify_table_dump, "") \
22401 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
22402 _(sw_interface_span_dump, "[l2]") \
22403 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
22404 _(pg_create_interface, "if_id <nn>") \
22405 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
22406 _(pg_enable_disable, "[stream <id>] disable") \
22407 _(ip_source_and_port_range_check_add_del, \
22408 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
22409 _(ip_source_and_port_range_check_interface_add_del, \
22410 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
22411 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
22412 _(ipsec_gre_tunnel_add_del, \
22413 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
22414 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
22415 _(delete_subif,"<intfc> | sw_if_index <nn>") \
22416 _(l2_interface_pbb_tag_rewrite, \
22417 "<intfc> | sw_if_index <nn> \n" \
22418 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
22419 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
22420 _(set_punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
22421 _(flow_classify_set_interface, \
22422 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
22423 _(flow_classify_dump, "type [ip4|ip6]") \
22424 _(ip_table_dump, "") \
22425 _(ip_route_dump, "table-id [ip4|ip6]") \
22426 _(ip_mtable_dump, "") \
22427 _(ip_mroute_dump, "table-id [ip4|ip6]") \
22428 _(feature_enable_disable, "arc_name <arc_name> " \
22429 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
22430 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
22432 _(l2_xconnect_dump, "") \
22433 _(hw_interface_set_mtu, "<intfc> | hw_if_index <nn> mtu <nn>") \
22434 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
22435 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
22436 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
22437 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
22438 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
22439 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
22440 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
22441 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
22442 _(sock_init_shm, "size <nnn>") \
22443 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
22444 _(dns_enable_disable, "[enable][disable]") \
22445 _(dns_name_server_add_del, "<ip-address> [del]") \
22446 _(dns_resolve_name, "<hostname>") \
22447 _(dns_resolve_ip, "<ip4|ip6>") \
22448 _(dns_name_server_add_del, "<ip-address> [del]") \
22449 _(dns_resolve_name, "<hostname>") \
22450 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
22451 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
22452 _(session_rules_dump, "") \
22453 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
22454 _(output_acl_set_interface, \
22455 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22456 " [l2-table <nn>] [del]") \
22457 _(qos_record_enable_disable, "<record-source> <intfc> | sw_if_index <id> [disable]")
22459 /* List of command functions, CLI names map directly to functions */
22460 #define foreach_cli_function \
22461 _(comment, "usage: comment <ignore-rest-of-line>") \
22462 _(dump_interface_table, "usage: dump_interface_table") \
22463 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
22464 _(dump_ipv4_table, "usage: dump_ipv4_table") \
22465 _(dump_ipv6_table, "usage: dump_ipv6_table") \
22466 _(dump_macro_table, "usage: dump_macro_table ") \
22467 _(dump_node_table, "usage: dump_node_table") \
22468 _(dump_msg_api_table, "usage: dump_msg_api_table") \
22469 _(get_msg_id, "usage: get_msg_id name_and_crc") \
22470 _(echo, "usage: echo <message>") \
22471 _(exec, "usage: exec <vpe-debug-CLI-command>") \
22472 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
22473 _(help, "usage: help") \
22474 _(q, "usage: quit") \
22475 _(quit, "usage: quit") \
22476 _(search_node_table, "usage: search_node_table <name>...") \
22477 _(set, "usage: set <variable-name> <value>") \
22478 _(script, "usage: script <file-name>") \
22479 _(statseg, "usage: statseg") \
22480 _(unset, "usage: unset <variable-name>")
22483 static void vl_api_##n##_t_handler_uni \
22484 (vl_api_##n##_t * mp) \
22486 vat_main_t * vam = &vat_main; \
22487 if (vam->json_output) { \
22488 vl_api_##n##_t_handler_json(mp); \
22490 vl_api_##n##_t_handler(mp); \
22493 foreach_vpe_api_reply_msg;
22494 #if VPP_API_TEST_BUILTIN == 0
22495 foreach_standalone_reply_msg;
22500 vat_api_hookup (vat_main_t * vam)
22503 vl_msg_api_set_handlers(VL_API_##N, #n, \
22504 vl_api_##n##_t_handler_uni, \
22506 vl_api_##n##_t_endian, \
22507 vl_api_##n##_t_print, \
22508 sizeof(vl_api_##n##_t), 1);
22509 foreach_vpe_api_reply_msg;
22510 #if VPP_API_TEST_BUILTIN == 0
22511 foreach_standalone_reply_msg;
22515 #if (VPP_API_TEST_BUILTIN==0)
22516 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
22518 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
22520 vam->function_by_name = hash_create_string (0, sizeof (uword));
22522 vam->help_by_name = hash_create_string (0, sizeof (uword));
22525 /* API messages we can send */
22526 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
22527 foreach_vpe_api_msg;
22531 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
22532 foreach_vpe_api_msg;
22535 /* CLI functions */
22536 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
22537 foreach_cli_function;
22541 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
22542 foreach_cli_function;
22546 #if VPP_API_TEST_BUILTIN
22547 static clib_error_t *
22548 vat_api_hookup_shim (vlib_main_t * vm)
22550 vat_api_hookup (&vat_main);
22554 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
22558 * fd.io coding-style-patch-verification: ON
22561 * eval: (c-set-style "gnu")