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>
44 #include <vnet/ipsec/ikev2.h>
46 #include <vnet/cop/cop.h>
47 #include <vnet/ip/ip6_hop_by_hop.h>
48 #include <vnet/ip/ip_source_and_port_range_check.h>
49 #include <vnet/policer/xlate.h>
50 #include <vnet/span/span.h>
51 #include <vnet/policer/policer.h>
52 #include <vnet/policer/police.h>
53 #include <vnet/mfib/mfib_types.h>
54 #include <vnet/dhcp/dhcp_proxy.h>
55 #include <vnet/bonding/node.h>
56 #include <vnet/qos/qos_types.h>
57 #include <vnet/ethernet/ethernet_types_api.h>
58 #include <vnet/ip/ip_types_api.h>
59 #include "vat/json_format.h"
60 #include <vnet/ip/ip_types_api.h>
61 #include <vnet/ethernet/ethernet_types_api.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 #define vl_print(handle, ...)
79 #include <vpp/api/vpe_all_api_h.h>
82 #define __plugin_msg_base 0
83 #include <vlibapi/vat_helper_macros.h>
85 #if VPP_API_TEST_BUILTIN == 0
95 vat_socket_connect (vat_main_t * vam)
98 vam->socket_client_main = &socket_client_main;
99 if ((rv = vl_socket_client_connect ((char *) vam->socket_name,
101 0 /* default socket rx, tx buffer */ )))
103 /* vpp expects the client index in network order */
104 vam->my_client_index = htonl (socket_client_main.client_index);
107 #else /* vpp built-in case, we don't do sockets... */
109 vat_socket_connect (vat_main_t * vam)
115 vl_socket_client_read (int wait)
121 vl_socket_client_write ()
127 vl_socket_client_msg_alloc (int nbytes)
135 vat_time_now (vat_main_t * vam)
137 #if VPP_API_TEST_BUILTIN
138 return vlib_time_now (vam->vlib_main);
140 return clib_time_now (&vam->clib_time);
145 errmsg (char *fmt, ...)
147 vat_main_t *vam = &vat_main;
152 s = va_format (0, fmt, &va);
157 #if VPP_API_TEST_BUILTIN
158 vlib_cli_output (vam->vlib_main, (char *) s);
161 if (vam->ifp != stdin)
162 fformat (vam->ofp, "%s(%d): \n", vam->current_file,
163 vam->input_line_number);
164 fformat (vam->ofp, (char *) s);
172 #if VPP_API_TEST_BUILTIN == 0
174 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
176 vat_main_t *vam = va_arg (*args, vat_main_t *);
177 u32 *result = va_arg (*args, u32 *);
181 if (!unformat (input, "%s", &if_name))
184 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
192 api_unformat_hw_if_index (unformat_input_t * input, va_list * args)
197 /* Parse an IP4 address %d.%d.%d.%d. */
199 unformat_ip4_address (unformat_input_t * input, va_list * args)
201 u8 *result = va_arg (*args, u8 *);
204 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
207 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
219 unformat_ethernet_address (unformat_input_t * input, va_list * args)
221 u8 *result = va_arg (*args, u8 *);
224 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
225 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
229 for (i = 0; i < 6; i++)
230 if (a[i] >= (1 << 8))
233 for (i = 0; i < 6; i++)
239 /* Returns ethernet type as an int in host byte order. */
241 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
244 u16 *result = va_arg (*args, u16 *);
248 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
250 if (type >= (1 << 16))
258 /* Parse an IP6 address. */
260 unformat_ip6_address (unformat_input_t * input, va_list * args)
262 ip6_address_t *result = va_arg (*args, ip6_address_t *);
264 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
265 uword c, n_colon, double_colon_index;
267 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
268 double_colon_index = ARRAY_LEN (hex_quads);
269 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
272 if (c >= '0' && c <= '9')
274 else if (c >= 'a' && c <= 'f')
275 hex_digit = c + 10 - 'a';
276 else if (c >= 'A' && c <= 'F')
277 hex_digit = c + 10 - 'A';
278 else if (c == ':' && n_colon < 2)
282 unformat_put_input (input);
286 /* Too many hex quads. */
287 if (n_hex_quads >= ARRAY_LEN (hex_quads))
292 hex_quad = (hex_quad << 4) | hex_digit;
294 /* Hex quad must fit in 16 bits. */
295 if (n_hex_digits >= 4)
302 /* Save position of :: */
305 /* More than one :: ? */
306 if (double_colon_index < ARRAY_LEN (hex_quads))
308 double_colon_index = n_hex_quads;
311 if (n_colon > 0 && n_hex_digits > 0)
313 hex_quads[n_hex_quads++] = hex_quad;
319 if (n_hex_digits > 0)
320 hex_quads[n_hex_quads++] = hex_quad;
325 /* Expand :: to appropriate number of zero hex quads. */
326 if (double_colon_index < ARRAY_LEN (hex_quads))
328 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
330 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
331 hex_quads[n_zero + i] = hex_quads[i];
333 for (i = 0; i < n_zero; i++)
334 hex_quads[double_colon_index + i] = 0;
336 n_hex_quads = ARRAY_LEN (hex_quads);
339 /* Too few hex quads given. */
340 if (n_hex_quads < ARRAY_LEN (hex_quads))
343 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
344 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
351 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
353 u32 *r = va_arg (*args, u32 *);
356 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
357 foreach_ipsec_policy_action
365 unformat_ipsec_crypto_alg (unformat_input_t * input, va_list * args)
367 u32 *r = va_arg (*args, u32 *);
370 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_CRYPTO_ALG_##f;
371 foreach_ipsec_crypto_alg
379 format_ipsec_crypto_alg (u8 * s, va_list * args)
381 u32 i = va_arg (*args, u32);
386 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
387 foreach_ipsec_crypto_alg
390 return format (s, "unknown");
392 return format (s, "%s", t);
396 unformat_ipsec_integ_alg (unformat_input_t * input, va_list * args)
398 u32 *r = va_arg (*args, u32 *);
401 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_INTEG_ALG_##f;
402 foreach_ipsec_integ_alg
410 format_ipsec_integ_alg (u8 * s, va_list * args)
412 u32 i = va_arg (*args, u32);
417 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
418 foreach_ipsec_integ_alg
421 return format (s, "unknown");
423 return format (s, "%s", t);
427 unformat_ikev2_auth_method (unformat_input_t * input, va_list * args)
429 u32 *r = va_arg (*args, u32 *);
432 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_AUTH_METHOD_##f;
433 foreach_ikev2_auth_method
441 unformat_ikev2_id_type (unformat_input_t * input, va_list * args)
443 u32 *r = va_arg (*args, u32 *);
446 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_ID_TYPE_##f;
447 foreach_ikev2_id_type
453 #else /* VPP_API_TEST_BUILTIN == 1 */
455 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
457 vat_main_t *vam __attribute__ ((unused)) = va_arg (*args, vat_main_t *);
458 vnet_main_t *vnm = vnet_get_main ();
459 u32 *result = va_arg (*args, u32 *);
461 return unformat (input, "%U", unformat_vnet_sw_interface, vnm, result);
465 api_unformat_hw_if_index (unformat_input_t * input, va_list * args)
467 vat_main_t *vam __attribute__ ((unused)) = va_arg (*args, vat_main_t *);
468 vnet_main_t *vnm = vnet_get_main ();
469 u32 *result = va_arg (*args, u32 *);
471 return unformat (input, "%U", unformat_vnet_hw_interface, vnm, result);
474 #endif /* VPP_API_TEST_BUILTIN */
477 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
479 u8 *r = va_arg (*args, u8 *);
481 if (unformat (input, "kbps"))
482 *r = SSE2_QOS_RATE_KBPS;
483 else if (unformat (input, "pps"))
484 *r = SSE2_QOS_RATE_PPS;
491 unformat_policer_round_type (unformat_input_t * input, va_list * args)
493 u8 *r = va_arg (*args, u8 *);
495 if (unformat (input, "closest"))
496 *r = SSE2_QOS_ROUND_TO_CLOSEST;
497 else if (unformat (input, "up"))
498 *r = SSE2_QOS_ROUND_TO_UP;
499 else if (unformat (input, "down"))
500 *r = SSE2_QOS_ROUND_TO_DOWN;
507 unformat_policer_type (unformat_input_t * input, va_list * args)
509 u8 *r = va_arg (*args, u8 *);
511 if (unformat (input, "1r2c"))
512 *r = SSE2_QOS_POLICER_TYPE_1R2C;
513 else if (unformat (input, "1r3c"))
514 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
515 else if (unformat (input, "2r3c-2698"))
516 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
517 else if (unformat (input, "2r3c-4115"))
518 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
519 else if (unformat (input, "2r3c-mef5cf1"))
520 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
527 unformat_dscp (unformat_input_t * input, va_list * va)
529 u8 *r = va_arg (*va, u8 *);
532 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
541 unformat_policer_action_type (unformat_input_t * input, va_list * va)
543 sse2_qos_pol_action_params_st *a
544 = va_arg (*va, sse2_qos_pol_action_params_st *);
546 if (unformat (input, "drop"))
547 a->action_type = SSE2_QOS_ACTION_DROP;
548 else if (unformat (input, "transmit"))
549 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
550 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
551 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
558 unformat_policer_classify_table_type (unformat_input_t * input, va_list * va)
560 u32 *r = va_arg (*va, u32 *);
563 if (unformat (input, "ip4"))
564 tid = POLICER_CLASSIFY_TABLE_IP4;
565 else if (unformat (input, "ip6"))
566 tid = POLICER_CLASSIFY_TABLE_IP6;
567 else if (unformat (input, "l2"))
568 tid = POLICER_CLASSIFY_TABLE_L2;
577 unformat_flow_classify_table_type (unformat_input_t * input, va_list * va)
579 u32 *r = va_arg (*va, u32 *);
582 if (unformat (input, "ip4"))
583 tid = FLOW_CLASSIFY_TABLE_IP4;
584 else if (unformat (input, "ip6"))
585 tid = FLOW_CLASSIFY_TABLE_IP6;
593 static const char *mfib_flag_names[] = MFIB_ENTRY_NAMES_SHORT;
594 static const char *mfib_flag_long_names[] = MFIB_ENTRY_NAMES_LONG;
595 static const char *mfib_itf_flag_long_names[] = MFIB_ITF_NAMES_LONG;
596 static const char *mfib_itf_flag_names[] = MFIB_ITF_NAMES_SHORT;
598 #if (VPP_API_TEST_BUILTIN==0)
600 unformat_mfib_itf_flags (unformat_input_t * input, va_list * args)
602 mfib_itf_flags_t old, *iflags = va_arg (*args, mfib_itf_flags_t *);
603 mfib_itf_attribute_t attr;
606 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
608 if (unformat (input, mfib_itf_flag_long_names[attr]))
609 *iflags |= (1 << attr);
611 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
613 if (unformat (input, mfib_itf_flag_names[attr]))
614 *iflags |= (1 << attr);
617 return (old == *iflags ? 0 : 1);
621 unformat_mfib_entry_flags (unformat_input_t * input, va_list * args)
623 mfib_entry_flags_t old, *eflags = va_arg (*args, mfib_entry_flags_t *);
624 mfib_entry_attribute_t attr;
627 FOR_EACH_MFIB_ATTRIBUTE (attr)
629 if (unformat (input, mfib_flag_long_names[attr]))
630 *eflags |= (1 << attr);
632 FOR_EACH_MFIB_ATTRIBUTE (attr)
634 if (unformat (input, mfib_flag_names[attr]))
635 *eflags |= (1 << attr);
638 return (old == *eflags ? 0 : 1);
642 format_ip4_address (u8 * s, va_list * args)
644 u8 *a = va_arg (*args, u8 *);
645 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
649 format_ip6_address (u8 * s, va_list * args)
651 ip6_address_t *a = va_arg (*args, ip6_address_t *);
652 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
654 i_max_n_zero = ARRAY_LEN (a->as_u16);
656 i_first_zero = i_max_n_zero;
658 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
660 u32 is_zero = a->as_u16[i] == 0;
661 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
667 if ((!is_zero && n_zeros > max_n_zeros)
668 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
670 i_max_n_zero = i_first_zero;
671 max_n_zeros = n_zeros;
672 i_first_zero = ARRAY_LEN (a->as_u16);
677 last_double_colon = 0;
678 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
680 if (i == i_max_n_zero && max_n_zeros > 1)
682 s = format (s, "::");
683 i += max_n_zeros - 1;
684 last_double_colon = 1;
688 s = format (s, "%s%x",
689 (last_double_colon || i == 0) ? "" : ":",
690 clib_net_to_host_u16 (a->as_u16[i]));
691 last_double_colon = 0;
698 /* Format an IP46 address. */
700 format_ip46_address (u8 * s, va_list * args)
702 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
703 ip46_type_t type = va_arg (*args, ip46_type_t);
709 is_ip4 = ip46_address_is_ip4 (ip46);
720 format (s, "%U", format_ip4_address, &ip46->ip4) :
721 format (s, "%U", format_ip6_address, &ip46->ip6);
725 format_ethernet_address (u8 * s, va_list * args)
727 u8 *a = va_arg (*args, u8 *);
729 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
730 a[0], a[1], a[2], a[3], a[4], a[5]);
735 increment_v4_address (ip4_address_t * a)
739 v = ntohl (a->as_u32) + 1;
740 a->as_u32 = ntohl (v);
744 increment_v6_address (ip6_address_t * a)
748 v0 = clib_net_to_host_u64 (a->as_u64[0]);
749 v1 = clib_net_to_host_u64 (a->as_u64[1]);
754 a->as_u64[0] = clib_net_to_host_u64 (v0);
755 a->as_u64[1] = clib_net_to_host_u64 (v1);
759 increment_mac_address (u8 * mac)
761 u64 tmp = *((u64 *) mac);
762 tmp = clib_net_to_host_u64 (tmp);
763 tmp += 1 << 16; /* skip unused (least significant) octets */
764 tmp = clib_host_to_net_u64 (tmp);
766 clib_memcpy (mac, &tmp, 6);
769 static void vl_api_create_loopback_reply_t_handler
770 (vl_api_create_loopback_reply_t * mp)
772 vat_main_t *vam = &vat_main;
773 i32 retval = ntohl (mp->retval);
775 vam->retval = retval;
776 vam->regenerate_interface_table = 1;
777 vam->sw_if_index = ntohl (mp->sw_if_index);
778 vam->result_ready = 1;
781 static void vl_api_create_loopback_reply_t_handler_json
782 (vl_api_create_loopback_reply_t * mp)
784 vat_main_t *vam = &vat_main;
785 vat_json_node_t node;
787 vat_json_init_object (&node);
788 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
789 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
791 vat_json_print (vam->ofp, &node);
792 vat_json_free (&node);
793 vam->retval = ntohl (mp->retval);
794 vam->result_ready = 1;
797 static void vl_api_create_loopback_instance_reply_t_handler
798 (vl_api_create_loopback_instance_reply_t * mp)
800 vat_main_t *vam = &vat_main;
801 i32 retval = ntohl (mp->retval);
803 vam->retval = retval;
804 vam->regenerate_interface_table = 1;
805 vam->sw_if_index = ntohl (mp->sw_if_index);
806 vam->result_ready = 1;
809 static void vl_api_create_loopback_instance_reply_t_handler_json
810 (vl_api_create_loopback_instance_reply_t * mp)
812 vat_main_t *vam = &vat_main;
813 vat_json_node_t node;
815 vat_json_init_object (&node);
816 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
817 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
819 vat_json_print (vam->ofp, &node);
820 vat_json_free (&node);
821 vam->retval = ntohl (mp->retval);
822 vam->result_ready = 1;
825 static void vl_api_af_packet_create_reply_t_handler
826 (vl_api_af_packet_create_reply_t * mp)
828 vat_main_t *vam = &vat_main;
829 i32 retval = ntohl (mp->retval);
831 vam->retval = retval;
832 vam->regenerate_interface_table = 1;
833 vam->sw_if_index = ntohl (mp->sw_if_index);
834 vam->result_ready = 1;
837 static void vl_api_af_packet_create_reply_t_handler_json
838 (vl_api_af_packet_create_reply_t * mp)
840 vat_main_t *vam = &vat_main;
841 vat_json_node_t node;
843 vat_json_init_object (&node);
844 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
845 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
847 vat_json_print (vam->ofp, &node);
848 vat_json_free (&node);
850 vam->retval = ntohl (mp->retval);
851 vam->result_ready = 1;
854 static void vl_api_create_vlan_subif_reply_t_handler
855 (vl_api_create_vlan_subif_reply_t * mp)
857 vat_main_t *vam = &vat_main;
858 i32 retval = ntohl (mp->retval);
860 vam->retval = retval;
861 vam->regenerate_interface_table = 1;
862 vam->sw_if_index = ntohl (mp->sw_if_index);
863 vam->result_ready = 1;
866 static void vl_api_create_vlan_subif_reply_t_handler_json
867 (vl_api_create_vlan_subif_reply_t * mp)
869 vat_main_t *vam = &vat_main;
870 vat_json_node_t node;
872 vat_json_init_object (&node);
873 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
874 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
876 vat_json_print (vam->ofp, &node);
877 vat_json_free (&node);
879 vam->retval = ntohl (mp->retval);
880 vam->result_ready = 1;
883 static void vl_api_create_subif_reply_t_handler
884 (vl_api_create_subif_reply_t * mp)
886 vat_main_t *vam = &vat_main;
887 i32 retval = ntohl (mp->retval);
889 vam->retval = retval;
890 vam->regenerate_interface_table = 1;
891 vam->sw_if_index = ntohl (mp->sw_if_index);
892 vam->result_ready = 1;
895 static void vl_api_create_subif_reply_t_handler_json
896 (vl_api_create_subif_reply_t * mp)
898 vat_main_t *vam = &vat_main;
899 vat_json_node_t node;
901 vat_json_init_object (&node);
902 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
903 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
905 vat_json_print (vam->ofp, &node);
906 vat_json_free (&node);
908 vam->retval = ntohl (mp->retval);
909 vam->result_ready = 1;
912 static void vl_api_interface_name_renumber_reply_t_handler
913 (vl_api_interface_name_renumber_reply_t * mp)
915 vat_main_t *vam = &vat_main;
916 i32 retval = ntohl (mp->retval);
918 vam->retval = retval;
919 vam->regenerate_interface_table = 1;
920 vam->result_ready = 1;
923 static void vl_api_interface_name_renumber_reply_t_handler_json
924 (vl_api_interface_name_renumber_reply_t * mp)
926 vat_main_t *vam = &vat_main;
927 vat_json_node_t node;
929 vat_json_init_object (&node);
930 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
932 vat_json_print (vam->ofp, &node);
933 vat_json_free (&node);
935 vam->retval = ntohl (mp->retval);
936 vam->result_ready = 1;
940 * Special-case: build the interface table, maintain
941 * the next loopback sw_if_index vbl.
943 static void vl_api_sw_interface_details_t_handler
944 (vl_api_sw_interface_details_t * mp)
946 vat_main_t *vam = &vat_main;
947 u8 *s = format (0, "%s%c", mp->interface_name, 0);
949 hash_set_mem (vam->sw_if_index_by_interface_name, s,
950 ntohl (mp->sw_if_index));
952 /* In sub interface case, fill the sub interface table entry */
953 if (mp->sw_if_index != mp->sup_sw_if_index)
955 sw_interface_subif_t *sub = NULL;
957 vec_add2 (vam->sw_if_subif_table, sub, 1);
959 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
960 strncpy ((char *) sub->interface_name, (char *) s,
961 vec_len (sub->interface_name));
962 sub->sw_if_index = ntohl (mp->sw_if_index);
963 sub->sub_id = ntohl (mp->sub_id);
965 sub->sub_dot1ad = mp->sub_dot1ad;
966 sub->sub_number_of_tags = mp->sub_number_of_tags;
967 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
968 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
969 sub->sub_exact_match = mp->sub_exact_match;
970 sub->sub_default = mp->sub_default;
971 sub->sub_outer_vlan_id_any = mp->sub_outer_vlan_id_any;
972 sub->sub_inner_vlan_id_any = mp->sub_inner_vlan_id_any;
974 /* vlan tag rewrite */
975 sub->vtr_op = ntohl (mp->vtr_op);
976 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
977 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
978 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
982 static void vl_api_sw_interface_details_t_handler_json
983 (vl_api_sw_interface_details_t * mp)
985 vat_main_t *vam = &vat_main;
986 vat_json_node_t *node = NULL;
988 if (VAT_JSON_ARRAY != vam->json_tree.type)
990 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
991 vat_json_init_array (&vam->json_tree);
993 node = vat_json_array_add (&vam->json_tree);
995 vat_json_init_object (node);
996 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
997 vat_json_object_add_uint (node, "sup_sw_if_index",
998 ntohl (mp->sup_sw_if_index));
999 vat_json_object_add_uint (node, "l2_address_length",
1000 ntohl (mp->l2_address_length));
1001 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
1002 sizeof (mp->l2_address));
1003 vat_json_object_add_string_copy (node, "interface_name",
1004 mp->interface_name);
1005 vat_json_object_add_uint (node, "admin_up_down", mp->admin_up_down);
1006 vat_json_object_add_uint (node, "link_up_down", mp->link_up_down);
1007 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
1008 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
1009 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
1010 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
1011 vat_json_object_add_uint (node, "sub_dot1ad", mp->sub_dot1ad);
1012 vat_json_object_add_uint (node, "sub_number_of_tags",
1013 mp->sub_number_of_tags);
1014 vat_json_object_add_uint (node, "sub_outer_vlan_id",
1015 ntohs (mp->sub_outer_vlan_id));
1016 vat_json_object_add_uint (node, "sub_inner_vlan_id",
1017 ntohs (mp->sub_inner_vlan_id));
1018 vat_json_object_add_uint (node, "sub_exact_match", mp->sub_exact_match);
1019 vat_json_object_add_uint (node, "sub_default", mp->sub_default);
1020 vat_json_object_add_uint (node, "sub_outer_vlan_id_any",
1021 mp->sub_outer_vlan_id_any);
1022 vat_json_object_add_uint (node, "sub_inner_vlan_id_any",
1023 mp->sub_inner_vlan_id_any);
1024 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
1025 vat_json_object_add_uint (node, "vtr_push_dot1q",
1026 ntohl (mp->vtr_push_dot1q));
1027 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
1028 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
1031 vat_json_object_add_string_copy (node, "pbb_vtr_dmac",
1033 format_ethernet_address,
1035 vat_json_object_add_string_copy (node, "pbb_vtr_smac",
1037 format_ethernet_address,
1039 vat_json_object_add_uint (node, "pbb_vtr_b_vlanid", mp->b_vlanid);
1040 vat_json_object_add_uint (node, "pbb_vtr_i_sid", mp->i_sid);
1044 #if VPP_API_TEST_BUILTIN == 0
1045 static void vl_api_sw_interface_event_t_handler
1046 (vl_api_sw_interface_event_t * mp)
1048 vat_main_t *vam = &vat_main;
1049 if (vam->interface_event_display)
1050 errmsg ("interface flags: sw_if_index %d %s %s",
1051 ntohl (mp->sw_if_index),
1052 mp->admin_up_down ? "admin-up" : "admin-down",
1053 mp->link_up_down ? "link-up" : "link-down");
1057 static void vl_api_sw_interface_event_t_handler_json
1058 (vl_api_sw_interface_event_t * mp)
1060 /* JSON output not supported */
1064 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
1066 vat_main_t *vam = &vat_main;
1067 i32 retval = ntohl (mp->retval);
1069 vam->retval = retval;
1070 vam->shmem_result = uword_to_pointer (mp->reply_in_shmem, u8 *);
1071 vam->result_ready = 1;
1075 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
1077 vat_main_t *vam = &vat_main;
1078 vat_json_node_t node;
1079 api_main_t *am = &api_main;
1083 vat_json_init_object (&node);
1084 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1085 vat_json_object_add_uint (&node, "reply_in_shmem",
1086 ntohl (mp->reply_in_shmem));
1087 /* Toss the shared-memory original... */
1088 pthread_mutex_lock (&am->vlib_rp->mutex);
1089 oldheap = svm_push_data_heap (am->vlib_rp);
1091 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
1094 svm_pop_heap (oldheap);
1095 pthread_mutex_unlock (&am->vlib_rp->mutex);
1097 vat_json_print (vam->ofp, &node);
1098 vat_json_free (&node);
1100 vam->retval = ntohl (mp->retval);
1101 vam->result_ready = 1;
1105 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
1107 vat_main_t *vam = &vat_main;
1108 i32 retval = ntohl (mp->retval);
1109 u32 length = vl_api_string_len (&mp->reply);
1111 vec_reset_length (vam->cmd_reply);
1113 vam->retval = retval;
1116 vec_validate (vam->cmd_reply, length);
1117 clib_memcpy ((char *) (vam->cmd_reply),
1118 vl_api_from_api_string (&mp->reply), length);
1119 vam->cmd_reply[length] = 0;
1121 vam->result_ready = 1;
1125 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
1127 vat_main_t *vam = &vat_main;
1128 vat_json_node_t node;
1130 vec_reset_length (vam->cmd_reply);
1132 vat_json_init_object (&node);
1133 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1134 vat_json_object_add_string_copy (&node, "reply",
1135 vl_api_from_api_string (&mp->reply));
1137 vat_json_print (vam->ofp, &node);
1138 vat_json_free (&node);
1140 vam->retval = ntohl (mp->retval);
1141 vam->result_ready = 1;
1144 static void vl_api_classify_add_del_table_reply_t_handler
1145 (vl_api_classify_add_del_table_reply_t * mp)
1147 vat_main_t *vam = &vat_main;
1148 i32 retval = ntohl (mp->retval);
1149 if (vam->async_mode)
1151 vam->async_errors += (retval < 0);
1155 vam->retval = retval;
1157 ((mp->new_table_index != 0xFFFFFFFF) ||
1158 (mp->skip_n_vectors != 0xFFFFFFFF) ||
1159 (mp->match_n_vectors != 0xFFFFFFFF)))
1161 * Note: this is just barely thread-safe, depends on
1162 * the main thread spinning waiting for an answer...
1164 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d",
1165 ntohl (mp->new_table_index),
1166 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
1167 vam->result_ready = 1;
1171 static void vl_api_classify_add_del_table_reply_t_handler_json
1172 (vl_api_classify_add_del_table_reply_t * mp)
1174 vat_main_t *vam = &vat_main;
1175 vat_json_node_t node;
1177 vat_json_init_object (&node);
1178 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1179 vat_json_object_add_uint (&node, "new_table_index",
1180 ntohl (mp->new_table_index));
1181 vat_json_object_add_uint (&node, "skip_n_vectors",
1182 ntohl (mp->skip_n_vectors));
1183 vat_json_object_add_uint (&node, "match_n_vectors",
1184 ntohl (mp->match_n_vectors));
1186 vat_json_print (vam->ofp, &node);
1187 vat_json_free (&node);
1189 vam->retval = ntohl (mp->retval);
1190 vam->result_ready = 1;
1193 static void vl_api_get_node_index_reply_t_handler
1194 (vl_api_get_node_index_reply_t * mp)
1196 vat_main_t *vam = &vat_main;
1197 i32 retval = ntohl (mp->retval);
1198 if (vam->async_mode)
1200 vam->async_errors += (retval < 0);
1204 vam->retval = retval;
1206 errmsg ("node index %d", ntohl (mp->node_index));
1207 vam->result_ready = 1;
1211 static void vl_api_get_node_index_reply_t_handler_json
1212 (vl_api_get_node_index_reply_t * mp)
1214 vat_main_t *vam = &vat_main;
1215 vat_json_node_t node;
1217 vat_json_init_object (&node);
1218 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1219 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1221 vat_json_print (vam->ofp, &node);
1222 vat_json_free (&node);
1224 vam->retval = ntohl (mp->retval);
1225 vam->result_ready = 1;
1228 static void vl_api_get_next_index_reply_t_handler
1229 (vl_api_get_next_index_reply_t * mp)
1231 vat_main_t *vam = &vat_main;
1232 i32 retval = ntohl (mp->retval);
1233 if (vam->async_mode)
1235 vam->async_errors += (retval < 0);
1239 vam->retval = retval;
1241 errmsg ("next node index %d", ntohl (mp->next_index));
1242 vam->result_ready = 1;
1246 static void vl_api_get_next_index_reply_t_handler_json
1247 (vl_api_get_next_index_reply_t * mp)
1249 vat_main_t *vam = &vat_main;
1250 vat_json_node_t node;
1252 vat_json_init_object (&node);
1253 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1254 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1256 vat_json_print (vam->ofp, &node);
1257 vat_json_free (&node);
1259 vam->retval = ntohl (mp->retval);
1260 vam->result_ready = 1;
1263 static void vl_api_add_node_next_reply_t_handler
1264 (vl_api_add_node_next_reply_t * mp)
1266 vat_main_t *vam = &vat_main;
1267 i32 retval = ntohl (mp->retval);
1268 if (vam->async_mode)
1270 vam->async_errors += (retval < 0);
1274 vam->retval = retval;
1276 errmsg ("next index %d", ntohl (mp->next_index));
1277 vam->result_ready = 1;
1281 static void vl_api_add_node_next_reply_t_handler_json
1282 (vl_api_add_node_next_reply_t * mp)
1284 vat_main_t *vam = &vat_main;
1285 vat_json_node_t node;
1287 vat_json_init_object (&node);
1288 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1289 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1291 vat_json_print (vam->ofp, &node);
1292 vat_json_free (&node);
1294 vam->retval = ntohl (mp->retval);
1295 vam->result_ready = 1;
1298 static void vl_api_show_version_reply_t_handler
1299 (vl_api_show_version_reply_t * mp)
1301 vat_main_t *vam = &vat_main;
1302 i32 retval = ntohl (mp->retval);
1307 char *p = (char *) &mp->program;
1309 s = vl_api_from_api_string_c ((vl_api_string_t *) p);
1310 errmsg (" program: %s\n", s);
1314 vl_api_string_len ((vl_api_string_t *) p) + sizeof (vl_api_string_t);
1315 s = vl_api_from_api_string_c ((vl_api_string_t *) p);
1316 errmsg (" version: %s\n", s);
1320 vl_api_string_len ((vl_api_string_t *) p) + sizeof (vl_api_string_t);
1321 s = vl_api_from_api_string_c ((vl_api_string_t *) p);
1322 errmsg (" build date: %s\n", s);
1326 vl_api_string_len ((vl_api_string_t *) p) + sizeof (vl_api_string_t);
1327 s = vl_api_from_api_string_c ((vl_api_string_t *) p);
1328 errmsg ("build directory: %s\n", s);
1331 vam->retval = retval;
1332 vam->result_ready = 1;
1335 static void vl_api_show_version_reply_t_handler_json
1336 (vl_api_show_version_reply_t * mp)
1338 vat_main_t *vam = &vat_main;
1339 vat_json_node_t node;
1341 vat_json_init_object (&node);
1342 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1343 char *p = (char *) &mp->program;
1344 vat_json_object_add_string_copy (&node, "program",
1345 vl_api_from_api_string ((vl_api_string_t *)
1347 p += vl_api_string_len ((vl_api_string_t *) p) + sizeof (u32);
1348 vat_json_object_add_string_copy (&node, "version",
1349 vl_api_from_api_string ((vl_api_string_t *)
1351 p += vl_api_string_len ((vl_api_string_t *) p) + sizeof (u32);
1352 vat_json_object_add_string_copy (&node, "build_date",
1353 vl_api_from_api_string ((vl_api_string_t *)
1355 p += vl_api_string_len ((vl_api_string_t *) p) + sizeof (u32);
1356 vat_json_object_add_string_copy (&node, "build_directory",
1357 vl_api_from_api_string ((vl_api_string_t *)
1360 vat_json_print (vam->ofp, &node);
1361 vat_json_free (&node);
1363 vam->retval = ntohl (mp->retval);
1364 vam->result_ready = 1;
1367 static void vl_api_show_threads_reply_t_handler
1368 (vl_api_show_threads_reply_t * mp)
1370 vat_main_t *vam = &vat_main;
1371 i32 retval = ntohl (mp->retval);
1375 count = ntohl (mp->count);
1377 for (i = 0; i < count; i++)
1379 "\n%-2d %-11s %-11s %-5d %-6d %-4d %-6d",
1380 ntohl (mp->thread_data[i].id), mp->thread_data[i].name,
1381 mp->thread_data[i].type, ntohl (mp->thread_data[i].pid),
1382 ntohl (mp->thread_data[i].cpu_id), ntohl (mp->thread_data[i].core),
1383 ntohl (mp->thread_data[i].cpu_socket));
1385 vam->retval = retval;
1386 vam->result_ready = 1;
1389 static void vl_api_show_threads_reply_t_handler_json
1390 (vl_api_show_threads_reply_t * mp)
1392 vat_main_t *vam = &vat_main;
1393 vat_json_node_t node;
1394 vl_api_thread_data_t *td;
1395 i32 retval = ntohl (mp->retval);
1399 count = ntohl (mp->count);
1401 vat_json_init_object (&node);
1402 vat_json_object_add_int (&node, "retval", retval);
1403 vat_json_object_add_uint (&node, "count", count);
1405 for (i = 0; i < count; i++)
1407 td = &mp->thread_data[i];
1408 vat_json_object_add_uint (&node, "id", ntohl (td->id));
1409 vat_json_object_add_string_copy (&node, "name", td->name);
1410 vat_json_object_add_string_copy (&node, "type", td->type);
1411 vat_json_object_add_uint (&node, "pid", ntohl (td->pid));
1412 vat_json_object_add_int (&node, "cpu_id", ntohl (td->cpu_id));
1413 vat_json_object_add_int (&node, "core", ntohl (td->id));
1414 vat_json_object_add_int (&node, "cpu_socket", ntohl (td->cpu_socket));
1417 vat_json_print (vam->ofp, &node);
1418 vat_json_free (&node);
1420 vam->retval = retval;
1421 vam->result_ready = 1;
1425 api_show_threads (vat_main_t * vam)
1427 vl_api_show_threads_t *mp;
1431 "\n%-2s %-11s %-11s %-5s %-6s %-4s %-6s",
1432 "ID", "Name", "Type", "LWP", "cpu_id", "Core", "Socket");
1434 M (SHOW_THREADS, mp);
1442 vl_api_ip4_arp_event_t_handler (vl_api_ip4_arp_event_t * mp)
1444 u32 sw_if_index = ntohl (mp->sw_if_index);
1445 errmsg ("arp %s event: pid %d address %U new mac %U sw_if_index %d\n",
1446 mp->mac_ip ? "mac/ip binding" : "address resolution",
1447 ntohl (mp->pid), format_ip4_address, mp->ip,
1448 format_vl_api_mac_address, &mp->mac, sw_if_index);
1452 vl_api_ip4_arp_event_t_handler_json (vl_api_ip4_arp_event_t * mp)
1454 /* JSON output not supported */
1458 vl_api_ip6_nd_event_t_handler (vl_api_ip6_nd_event_t * mp)
1460 u32 sw_if_index = ntohl (mp->sw_if_index);
1461 errmsg ("ip6 nd %s event: pid %d address %U new mac %U sw_if_index %d\n",
1462 mp->mac_ip ? "mac/ip binding" : "address resolution",
1463 ntohl (mp->pid), format_vl_api_ip6_address, mp->ip,
1464 format_vl_api_mac_address, mp->mac, sw_if_index);
1468 vl_api_ip6_nd_event_t_handler_json (vl_api_ip6_nd_event_t * mp)
1470 /* JSON output not supported */
1474 vl_api_l2_macs_event_t_handler (vl_api_l2_macs_event_t * mp)
1476 u32 n_macs = ntohl (mp->n_macs);
1477 errmsg ("L2MAC event received with pid %d cl-idx %d for %d macs: \n",
1478 ntohl (mp->pid), mp->client_index, n_macs);
1480 for (i = 0; i < n_macs; i++)
1482 vl_api_mac_entry_t *mac = &mp->mac[i];
1483 errmsg (" [%d] sw_if_index %d mac_addr %U action %d \n",
1484 i + 1, ntohl (mac->sw_if_index),
1485 format_ethernet_address, mac->mac_addr, mac->action);
1492 vl_api_l2_macs_event_t_handler_json (vl_api_l2_macs_event_t * mp)
1494 /* JSON output not supported */
1497 #define vl_api_bridge_domain_details_t_endian vl_noop_handler
1498 #define vl_api_bridge_domain_details_t_print vl_noop_handler
1501 * Special-case: build the bridge domain table, maintain
1502 * the next bd id vbl.
1504 static void vl_api_bridge_domain_details_t_handler
1505 (vl_api_bridge_domain_details_t * mp)
1507 vat_main_t *vam = &vat_main;
1508 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1511 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-6s %-3s",
1512 " ID", "LRN", "FWD", "FLD", "BVI", "UU-FWD", "#IF");
1514 print (vam->ofp, "%3d %3d %3d %3d %3d %6d %3d",
1515 ntohl (mp->bd_id), mp->learn, mp->forward,
1516 mp->flood, ntohl (mp->bvi_sw_if_index),
1517 ntohl (mp->uu_fwd_sw_if_index), n_sw_ifs);
1521 vl_api_bridge_domain_sw_if_t *sw_ifs;
1522 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG",
1525 sw_ifs = mp->sw_if_details;
1526 for (i = 0; i < n_sw_ifs; i++)
1532 sw_if_index = ntohl (sw_ifs->sw_if_index);
1535 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1537 if ((u32) p->value[0] == sw_if_index)
1539 sw_if_name = (u8 *)(p->key);
1544 print (vam->ofp, "%7d %3d %s", sw_if_index,
1545 sw_ifs->shg, sw_if_name ? (char *) sw_if_name :
1546 "sw_if_index not found!");
1553 static void vl_api_bridge_domain_details_t_handler_json
1554 (vl_api_bridge_domain_details_t * mp)
1556 vat_main_t *vam = &vat_main;
1557 vat_json_node_t *node, *array = NULL;
1558 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1560 if (VAT_JSON_ARRAY != vam->json_tree.type)
1562 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1563 vat_json_init_array (&vam->json_tree);
1565 node = vat_json_array_add (&vam->json_tree);
1567 vat_json_init_object (node);
1568 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1569 vat_json_object_add_uint (node, "flood", mp->flood);
1570 vat_json_object_add_uint (node, "forward", mp->forward);
1571 vat_json_object_add_uint (node, "learn", mp->learn);
1572 vat_json_object_add_uint (node, "bvi_sw_if_index",
1573 ntohl (mp->bvi_sw_if_index));
1574 vat_json_object_add_uint (node, "n_sw_ifs", n_sw_ifs);
1575 array = vat_json_object_add (node, "sw_if");
1576 vat_json_init_array (array);
1582 vl_api_bridge_domain_sw_if_t *sw_ifs;
1585 sw_ifs = mp->sw_if_details;
1586 for (i = 0; i < n_sw_ifs; i++)
1588 node = vat_json_array_add (array);
1589 vat_json_init_object (node);
1590 vat_json_object_add_uint (node, "sw_if_index",
1591 ntohl (sw_ifs->sw_if_index));
1592 vat_json_object_add_uint (node, "shg", sw_ifs->shg);
1598 static void vl_api_control_ping_reply_t_handler
1599 (vl_api_control_ping_reply_t * mp)
1601 vat_main_t *vam = &vat_main;
1602 i32 retval = ntohl (mp->retval);
1603 if (vam->async_mode)
1605 vam->async_errors += (retval < 0);
1609 vam->retval = retval;
1610 vam->result_ready = 1;
1612 if (vam->socket_client_main)
1613 vam->socket_client_main->control_pings_outstanding--;
1616 static void vl_api_control_ping_reply_t_handler_json
1617 (vl_api_control_ping_reply_t * mp)
1619 vat_main_t *vam = &vat_main;
1620 i32 retval = ntohl (mp->retval);
1622 if (VAT_JSON_NONE != vam->json_tree.type)
1624 vat_json_print (vam->ofp, &vam->json_tree);
1625 vat_json_free (&vam->json_tree);
1626 vam->json_tree.type = VAT_JSON_NONE;
1631 vat_json_init_array (&vam->json_tree);
1632 vat_json_print (vam->ofp, &vam->json_tree);
1633 vam->json_tree.type = VAT_JSON_NONE;
1636 vam->retval = retval;
1637 vam->result_ready = 1;
1641 vl_api_bridge_domain_set_mac_age_reply_t_handler
1642 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1644 vat_main_t *vam = &vat_main;
1645 i32 retval = ntohl (mp->retval);
1646 if (vam->async_mode)
1648 vam->async_errors += (retval < 0);
1652 vam->retval = retval;
1653 vam->result_ready = 1;
1657 static void vl_api_bridge_domain_set_mac_age_reply_t_handler_json
1658 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1660 vat_main_t *vam = &vat_main;
1661 vat_json_node_t node;
1663 vat_json_init_object (&node);
1664 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1666 vat_json_print (vam->ofp, &node);
1667 vat_json_free (&node);
1669 vam->retval = ntohl (mp->retval);
1670 vam->result_ready = 1;
1674 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1676 vat_main_t *vam = &vat_main;
1677 i32 retval = ntohl (mp->retval);
1678 if (vam->async_mode)
1680 vam->async_errors += (retval < 0);
1684 vam->retval = retval;
1685 vam->result_ready = 1;
1689 static void vl_api_l2_flags_reply_t_handler_json
1690 (vl_api_l2_flags_reply_t * mp)
1692 vat_main_t *vam = &vat_main;
1693 vat_json_node_t node;
1695 vat_json_init_object (&node);
1696 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1697 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1698 ntohl (mp->resulting_feature_bitmap));
1700 vat_json_print (vam->ofp, &node);
1701 vat_json_free (&node);
1703 vam->retval = ntohl (mp->retval);
1704 vam->result_ready = 1;
1707 static void vl_api_bridge_flags_reply_t_handler
1708 (vl_api_bridge_flags_reply_t * mp)
1710 vat_main_t *vam = &vat_main;
1711 i32 retval = ntohl (mp->retval);
1712 if (vam->async_mode)
1714 vam->async_errors += (retval < 0);
1718 vam->retval = retval;
1719 vam->result_ready = 1;
1723 static void vl_api_bridge_flags_reply_t_handler_json
1724 (vl_api_bridge_flags_reply_t * mp)
1726 vat_main_t *vam = &vat_main;
1727 vat_json_node_t node;
1729 vat_json_init_object (&node);
1730 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1731 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1732 ntohl (mp->resulting_feature_bitmap));
1734 vat_json_print (vam->ofp, &node);
1735 vat_json_free (&node);
1737 vam->retval = ntohl (mp->retval);
1738 vam->result_ready = 1;
1742 vl_api_tap_create_v2_reply_t_handler (vl_api_tap_create_v2_reply_t * mp)
1744 vat_main_t *vam = &vat_main;
1745 i32 retval = ntohl (mp->retval);
1746 if (vam->async_mode)
1748 vam->async_errors += (retval < 0);
1752 vam->retval = retval;
1753 vam->sw_if_index = ntohl (mp->sw_if_index);
1754 vam->result_ready = 1;
1759 static void vl_api_tap_create_v2_reply_t_handler_json
1760 (vl_api_tap_create_v2_reply_t * mp)
1762 vat_main_t *vam = &vat_main;
1763 vat_json_node_t node;
1765 vat_json_init_object (&node);
1766 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1767 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1769 vat_json_print (vam->ofp, &node);
1770 vat_json_free (&node);
1772 vam->retval = ntohl (mp->retval);
1773 vam->result_ready = 1;
1778 vl_api_tap_delete_v2_reply_t_handler (vl_api_tap_delete_v2_reply_t * mp)
1780 vat_main_t *vam = &vat_main;
1781 i32 retval = ntohl (mp->retval);
1782 if (vam->async_mode)
1784 vam->async_errors += (retval < 0);
1788 vam->retval = retval;
1789 vam->result_ready = 1;
1793 static void vl_api_tap_delete_v2_reply_t_handler_json
1794 (vl_api_tap_delete_v2_reply_t * mp)
1796 vat_main_t *vam = &vat_main;
1797 vat_json_node_t node;
1799 vat_json_init_object (&node);
1800 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1802 vat_json_print (vam->ofp, &node);
1803 vat_json_free (&node);
1805 vam->retval = ntohl (mp->retval);
1806 vam->result_ready = 1;
1810 vl_api_virtio_pci_create_reply_t_handler (vl_api_virtio_pci_create_reply_t *
1813 vat_main_t *vam = &vat_main;
1814 i32 retval = ntohl (mp->retval);
1815 if (vam->async_mode)
1817 vam->async_errors += (retval < 0);
1821 vam->retval = retval;
1822 vam->sw_if_index = ntohl (mp->sw_if_index);
1823 vam->result_ready = 1;
1827 static void vl_api_virtio_pci_create_reply_t_handler_json
1828 (vl_api_virtio_pci_create_reply_t * mp)
1830 vat_main_t *vam = &vat_main;
1831 vat_json_node_t node;
1833 vat_json_init_object (&node);
1834 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1835 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1837 vat_json_print (vam->ofp, &node);
1838 vat_json_free (&node);
1840 vam->retval = ntohl (mp->retval);
1841 vam->result_ready = 1;
1846 vl_api_virtio_pci_delete_reply_t_handler (vl_api_virtio_pci_delete_reply_t *
1849 vat_main_t *vam = &vat_main;
1850 i32 retval = ntohl (mp->retval);
1851 if (vam->async_mode)
1853 vam->async_errors += (retval < 0);
1857 vam->retval = retval;
1858 vam->result_ready = 1;
1862 static void vl_api_virtio_pci_delete_reply_t_handler_json
1863 (vl_api_virtio_pci_delete_reply_t * mp)
1865 vat_main_t *vam = &vat_main;
1866 vat_json_node_t node;
1868 vat_json_init_object (&node);
1869 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1871 vat_json_print (vam->ofp, &node);
1872 vat_json_free (&node);
1874 vam->retval = ntohl (mp->retval);
1875 vam->result_ready = 1;
1879 vl_api_bond_create_reply_t_handler (vl_api_bond_create_reply_t * mp)
1881 vat_main_t *vam = &vat_main;
1882 i32 retval = ntohl (mp->retval);
1884 if (vam->async_mode)
1886 vam->async_errors += (retval < 0);
1890 vam->retval = retval;
1891 vam->sw_if_index = ntohl (mp->sw_if_index);
1892 vam->result_ready = 1;
1896 static void vl_api_bond_create_reply_t_handler_json
1897 (vl_api_bond_create_reply_t * mp)
1899 vat_main_t *vam = &vat_main;
1900 vat_json_node_t node;
1902 vat_json_init_object (&node);
1903 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1904 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1906 vat_json_print (vam->ofp, &node);
1907 vat_json_free (&node);
1909 vam->retval = ntohl (mp->retval);
1910 vam->result_ready = 1;
1914 vl_api_bond_delete_reply_t_handler (vl_api_bond_delete_reply_t * mp)
1916 vat_main_t *vam = &vat_main;
1917 i32 retval = ntohl (mp->retval);
1919 if (vam->async_mode)
1921 vam->async_errors += (retval < 0);
1925 vam->retval = retval;
1926 vam->result_ready = 1;
1930 static void vl_api_bond_delete_reply_t_handler_json
1931 (vl_api_bond_delete_reply_t * mp)
1933 vat_main_t *vam = &vat_main;
1934 vat_json_node_t node;
1936 vat_json_init_object (&node);
1937 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1939 vat_json_print (vam->ofp, &node);
1940 vat_json_free (&node);
1942 vam->retval = ntohl (mp->retval);
1943 vam->result_ready = 1;
1947 vl_api_bond_enslave_reply_t_handler (vl_api_bond_enslave_reply_t * mp)
1949 vat_main_t *vam = &vat_main;
1950 i32 retval = ntohl (mp->retval);
1952 if (vam->async_mode)
1954 vam->async_errors += (retval < 0);
1958 vam->retval = retval;
1959 vam->result_ready = 1;
1963 static void vl_api_bond_enslave_reply_t_handler_json
1964 (vl_api_bond_enslave_reply_t * mp)
1966 vat_main_t *vam = &vat_main;
1967 vat_json_node_t node;
1969 vat_json_init_object (&node);
1970 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1972 vat_json_print (vam->ofp, &node);
1973 vat_json_free (&node);
1975 vam->retval = ntohl (mp->retval);
1976 vam->result_ready = 1;
1980 vl_api_bond_detach_slave_reply_t_handler (vl_api_bond_detach_slave_reply_t *
1983 vat_main_t *vam = &vat_main;
1984 i32 retval = ntohl (mp->retval);
1986 if (vam->async_mode)
1988 vam->async_errors += (retval < 0);
1992 vam->retval = retval;
1993 vam->result_ready = 1;
1997 static void vl_api_bond_detach_slave_reply_t_handler_json
1998 (vl_api_bond_detach_slave_reply_t * mp)
2000 vat_main_t *vam = &vat_main;
2001 vat_json_node_t node;
2003 vat_json_init_object (&node);
2004 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2006 vat_json_print (vam->ofp, &node);
2007 vat_json_free (&node);
2009 vam->retval = ntohl (mp->retval);
2010 vam->result_ready = 1;
2013 static void vl_api_sw_interface_bond_details_t_handler
2014 (vl_api_sw_interface_bond_details_t * mp)
2016 vat_main_t *vam = &vat_main;
2019 "%-16s %-12d %-12U %-13U %-14u %-14u",
2020 mp->interface_name, ntohl (mp->sw_if_index),
2021 format_bond_mode, mp->mode, format_bond_load_balance, mp->lb,
2022 ntohl (mp->active_slaves), ntohl (mp->slaves));
2025 static void vl_api_sw_interface_bond_details_t_handler_json
2026 (vl_api_sw_interface_bond_details_t * mp)
2028 vat_main_t *vam = &vat_main;
2029 vat_json_node_t *node = NULL;
2031 if (VAT_JSON_ARRAY != vam->json_tree.type)
2033 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2034 vat_json_init_array (&vam->json_tree);
2036 node = vat_json_array_add (&vam->json_tree);
2038 vat_json_init_object (node);
2039 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2040 vat_json_object_add_string_copy (node, "interface_name",
2041 mp->interface_name);
2042 vat_json_object_add_uint (node, "mode", mp->mode);
2043 vat_json_object_add_uint (node, "load_balance", mp->lb);
2044 vat_json_object_add_uint (node, "active_slaves", ntohl (mp->active_slaves));
2045 vat_json_object_add_uint (node, "slaves", ntohl (mp->slaves));
2049 api_sw_interface_bond_dump (vat_main_t * vam)
2051 vl_api_sw_interface_bond_dump_t *mp;
2052 vl_api_control_ping_t *mp_ping;
2056 "\n%-16s %-12s %-12s %-13s %-14s %-14s",
2057 "interface name", "sw_if_index", "mode", "load balance",
2058 "active slaves", "slaves");
2060 /* Get list of bond interfaces */
2061 M (SW_INTERFACE_BOND_DUMP, mp);
2064 /* Use a control ping for synchronization */
2065 MPING (CONTROL_PING, mp_ping);
2072 static void vl_api_sw_interface_slave_details_t_handler
2073 (vl_api_sw_interface_slave_details_t * mp)
2075 vat_main_t *vam = &vat_main;
2078 "%-25s %-12d %-12d %d", mp->interface_name,
2079 ntohl (mp->sw_if_index), mp->is_passive, mp->is_long_timeout);
2082 static void vl_api_sw_interface_slave_details_t_handler_json
2083 (vl_api_sw_interface_slave_details_t * mp)
2085 vat_main_t *vam = &vat_main;
2086 vat_json_node_t *node = NULL;
2088 if (VAT_JSON_ARRAY != vam->json_tree.type)
2090 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2091 vat_json_init_array (&vam->json_tree);
2093 node = vat_json_array_add (&vam->json_tree);
2095 vat_json_init_object (node);
2096 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2097 vat_json_object_add_string_copy (node, "interface_name",
2098 mp->interface_name);
2099 vat_json_object_add_uint (node, "passive", mp->is_passive);
2100 vat_json_object_add_uint (node, "long_timeout", mp->is_long_timeout);
2104 api_sw_interface_slave_dump (vat_main_t * vam)
2106 unformat_input_t *i = vam->input;
2107 vl_api_sw_interface_slave_dump_t *mp;
2108 vl_api_control_ping_t *mp_ping;
2109 u32 sw_if_index = ~0;
2110 u8 sw_if_index_set = 0;
2113 /* Parse args required to build the message */
2114 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2116 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2117 sw_if_index_set = 1;
2118 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2119 sw_if_index_set = 1;
2124 if (sw_if_index_set == 0)
2126 errmsg ("missing vpp interface name. ");
2131 "\n%-25s %-12s %-12s %s",
2132 "slave interface name", "sw_if_index", "passive", "long_timeout");
2134 /* Get list of bond interfaces */
2135 M (SW_INTERFACE_SLAVE_DUMP, mp);
2136 mp->sw_if_index = ntohl (sw_if_index);
2139 /* Use a control ping for synchronization */
2140 MPING (CONTROL_PING, mp_ping);
2147 static void vl_api_mpls_tunnel_add_del_reply_t_handler
2148 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2150 vat_main_t *vam = &vat_main;
2151 i32 retval = ntohl (mp->retval);
2152 if (vam->async_mode)
2154 vam->async_errors += (retval < 0);
2158 vam->retval = retval;
2159 vam->sw_if_index = ntohl (mp->sw_if_index);
2160 vam->result_ready = 1;
2162 vam->regenerate_interface_table = 1;
2165 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
2166 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2168 vat_main_t *vam = &vat_main;
2169 vat_json_node_t node;
2171 vat_json_init_object (&node);
2172 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2173 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
2174 ntohl (mp->sw_if_index));
2176 vat_json_print (vam->ofp, &node);
2177 vat_json_free (&node);
2179 vam->retval = ntohl (mp->retval);
2180 vam->result_ready = 1;
2183 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
2184 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2186 vat_main_t *vam = &vat_main;
2187 i32 retval = ntohl (mp->retval);
2188 if (vam->async_mode)
2190 vam->async_errors += (retval < 0);
2194 vam->retval = retval;
2195 vam->sw_if_index = ntohl (mp->sw_if_index);
2196 vam->result_ready = 1;
2200 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
2201 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2203 vat_main_t *vam = &vat_main;
2204 vat_json_node_t node;
2206 vat_json_init_object (&node);
2207 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2208 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2210 vat_json_print (vam->ofp, &node);
2211 vat_json_free (&node);
2213 vam->retval = ntohl (mp->retval);
2214 vam->result_ready = 1;
2217 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler
2218 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2220 vat_main_t *vam = &vat_main;
2221 i32 retval = ntohl (mp->retval);
2222 if (vam->async_mode)
2224 vam->async_errors += (retval < 0);
2228 vam->retval = retval;
2229 vam->result_ready = 1;
2233 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler_json
2234 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2236 vat_main_t *vam = &vat_main;
2237 vat_json_node_t node;
2239 vat_json_init_object (&node);
2240 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2241 vat_json_object_add_uint (&node, "fwd_entry_index",
2242 clib_net_to_host_u32 (mp->fwd_entry_index));
2244 vat_json_print (vam->ofp, &node);
2245 vat_json_free (&node);
2247 vam->retval = ntohl (mp->retval);
2248 vam->result_ready = 1;
2252 format_lisp_transport_protocol (u8 * s, va_list * args)
2254 u32 proto = va_arg (*args, u32);
2259 return format (s, "udp");
2261 return format (s, "api");
2268 static void vl_api_one_get_transport_protocol_reply_t_handler
2269 (vl_api_one_get_transport_protocol_reply_t * mp)
2271 vat_main_t *vam = &vat_main;
2272 i32 retval = ntohl (mp->retval);
2273 if (vam->async_mode)
2275 vam->async_errors += (retval < 0);
2279 u32 proto = mp->protocol;
2280 print (vam->ofp, "Transport protocol: %U",
2281 format_lisp_transport_protocol, proto);
2282 vam->retval = retval;
2283 vam->result_ready = 1;
2287 static void vl_api_one_get_transport_protocol_reply_t_handler_json
2288 (vl_api_one_get_transport_protocol_reply_t * mp)
2290 vat_main_t *vam = &vat_main;
2291 vat_json_node_t node;
2294 s = format (0, "%U", format_lisp_transport_protocol, mp->protocol);
2297 vat_json_init_object (&node);
2298 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2299 vat_json_object_add_string_copy (&node, "transport-protocol", s);
2302 vat_json_print (vam->ofp, &node);
2303 vat_json_free (&node);
2305 vam->retval = ntohl (mp->retval);
2306 vam->result_ready = 1;
2309 static void vl_api_one_add_del_locator_set_reply_t_handler
2310 (vl_api_one_add_del_locator_set_reply_t * mp)
2312 vat_main_t *vam = &vat_main;
2313 i32 retval = ntohl (mp->retval);
2314 if (vam->async_mode)
2316 vam->async_errors += (retval < 0);
2320 vam->retval = retval;
2321 vam->result_ready = 1;
2325 static void vl_api_one_add_del_locator_set_reply_t_handler_json
2326 (vl_api_one_add_del_locator_set_reply_t * mp)
2328 vat_main_t *vam = &vat_main;
2329 vat_json_node_t node;
2331 vat_json_init_object (&node);
2332 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2333 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
2335 vat_json_print (vam->ofp, &node);
2336 vat_json_free (&node);
2338 vam->retval = ntohl (mp->retval);
2339 vam->result_ready = 1;
2342 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
2343 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2345 vat_main_t *vam = &vat_main;
2346 i32 retval = ntohl (mp->retval);
2347 if (vam->async_mode)
2349 vam->async_errors += (retval < 0);
2353 vam->retval = retval;
2354 vam->sw_if_index = ntohl (mp->sw_if_index);
2355 vam->result_ready = 1;
2357 vam->regenerate_interface_table = 1;
2360 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
2361 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2363 vat_main_t *vam = &vat_main;
2364 vat_json_node_t node;
2366 vat_json_init_object (&node);
2367 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2368 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2370 vat_json_print (vam->ofp, &node);
2371 vat_json_free (&node);
2373 vam->retval = ntohl (mp->retval);
2374 vam->result_ready = 1;
2377 static void vl_api_vxlan_offload_rx_reply_t_handler
2378 (vl_api_vxlan_offload_rx_reply_t * mp)
2380 vat_main_t *vam = &vat_main;
2381 i32 retval = ntohl (mp->retval);
2382 if (vam->async_mode)
2384 vam->async_errors += (retval < 0);
2388 vam->retval = retval;
2389 vam->result_ready = 1;
2393 static void vl_api_vxlan_offload_rx_reply_t_handler_json
2394 (vl_api_vxlan_offload_rx_reply_t * mp)
2396 vat_main_t *vam = &vat_main;
2397 vat_json_node_t node;
2399 vat_json_init_object (&node);
2400 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2402 vat_json_print (vam->ofp, &node);
2403 vat_json_free (&node);
2405 vam->retval = ntohl (mp->retval);
2406 vam->result_ready = 1;
2409 static void vl_api_geneve_add_del_tunnel_reply_t_handler
2410 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2412 vat_main_t *vam = &vat_main;
2413 i32 retval = ntohl (mp->retval);
2414 if (vam->async_mode)
2416 vam->async_errors += (retval < 0);
2420 vam->retval = retval;
2421 vam->sw_if_index = ntohl (mp->sw_if_index);
2422 vam->result_ready = 1;
2426 static void vl_api_geneve_add_del_tunnel_reply_t_handler_json
2427 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2429 vat_main_t *vam = &vat_main;
2430 vat_json_node_t node;
2432 vat_json_init_object (&node);
2433 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2434 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2436 vat_json_print (vam->ofp, &node);
2437 vat_json_free (&node);
2439 vam->retval = ntohl (mp->retval);
2440 vam->result_ready = 1;
2443 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler
2444 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2446 vat_main_t *vam = &vat_main;
2447 i32 retval = ntohl (mp->retval);
2448 if (vam->async_mode)
2450 vam->async_errors += (retval < 0);
2454 vam->retval = retval;
2455 vam->sw_if_index = ntohl (mp->sw_if_index);
2456 vam->result_ready = 1;
2458 vam->regenerate_interface_table = 1;
2461 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler_json
2462 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2464 vat_main_t *vam = &vat_main;
2465 vat_json_node_t node;
2467 vat_json_init_object (&node);
2468 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2469 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2471 vat_json_print (vam->ofp, &node);
2472 vat_json_free (&node);
2474 vam->retval = ntohl (mp->retval);
2475 vam->result_ready = 1;
2478 static void vl_api_gre_add_del_tunnel_reply_t_handler
2479 (vl_api_gre_add_del_tunnel_reply_t * mp)
2481 vat_main_t *vam = &vat_main;
2482 i32 retval = ntohl (mp->retval);
2483 if (vam->async_mode)
2485 vam->async_errors += (retval < 0);
2489 vam->retval = retval;
2490 vam->sw_if_index = ntohl (mp->sw_if_index);
2491 vam->result_ready = 1;
2495 static void vl_api_gre_add_del_tunnel_reply_t_handler_json
2496 (vl_api_gre_add_del_tunnel_reply_t * mp)
2498 vat_main_t *vam = &vat_main;
2499 vat_json_node_t node;
2501 vat_json_init_object (&node);
2502 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2503 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2505 vat_json_print (vam->ofp, &node);
2506 vat_json_free (&node);
2508 vam->retval = ntohl (mp->retval);
2509 vam->result_ready = 1;
2512 static void vl_api_create_vhost_user_if_reply_t_handler
2513 (vl_api_create_vhost_user_if_reply_t * mp)
2515 vat_main_t *vam = &vat_main;
2516 i32 retval = ntohl (mp->retval);
2517 if (vam->async_mode)
2519 vam->async_errors += (retval < 0);
2523 vam->retval = retval;
2524 vam->sw_if_index = ntohl (mp->sw_if_index);
2525 vam->result_ready = 1;
2527 vam->regenerate_interface_table = 1;
2530 static void vl_api_create_vhost_user_if_reply_t_handler_json
2531 (vl_api_create_vhost_user_if_reply_t * mp)
2533 vat_main_t *vam = &vat_main;
2534 vat_json_node_t node;
2536 vat_json_init_object (&node);
2537 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2538 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2540 vat_json_print (vam->ofp, &node);
2541 vat_json_free (&node);
2543 vam->retval = ntohl (mp->retval);
2544 vam->result_ready = 1;
2547 static void vl_api_dns_resolve_name_reply_t_handler
2548 (vl_api_dns_resolve_name_reply_t * mp)
2550 vat_main_t *vam = &vat_main;
2551 i32 retval = ntohl (mp->retval);
2552 if (vam->async_mode)
2554 vam->async_errors += (retval < 0);
2558 vam->retval = retval;
2559 vam->result_ready = 1;
2564 clib_warning ("ip4 address %U", format_ip4_address,
2565 (ip4_address_t *) mp->ip4_address);
2567 clib_warning ("ip6 address %U", format_ip6_address,
2568 (ip6_address_t *) mp->ip6_address);
2571 clib_warning ("retval %d", retval);
2575 static void vl_api_dns_resolve_name_reply_t_handler_json
2576 (vl_api_dns_resolve_name_reply_t * mp)
2578 clib_warning ("not implemented");
2581 static void vl_api_dns_resolve_ip_reply_t_handler
2582 (vl_api_dns_resolve_ip_reply_t * mp)
2584 vat_main_t *vam = &vat_main;
2585 i32 retval = ntohl (mp->retval);
2586 if (vam->async_mode)
2588 vam->async_errors += (retval < 0);
2592 vam->retval = retval;
2593 vam->result_ready = 1;
2597 clib_warning ("canonical name %s", mp->name);
2600 clib_warning ("retval %d", retval);
2604 static void vl_api_dns_resolve_ip_reply_t_handler_json
2605 (vl_api_dns_resolve_ip_reply_t * mp)
2607 clib_warning ("not implemented");
2611 static void vl_api_ip_address_details_t_handler
2612 (vl_api_ip_address_details_t * mp)
2614 vat_main_t *vam = &vat_main;
2615 static ip_address_details_t empty_ip_address_details = { {0} };
2616 ip_address_details_t *address = NULL;
2617 ip_details_t *current_ip_details = NULL;
2618 ip_details_t *details = NULL;
2620 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
2622 if (!details || vam->current_sw_if_index >= vec_len (details)
2623 || !details[vam->current_sw_if_index].present)
2625 errmsg ("ip address details arrived but not stored");
2626 errmsg ("ip_dump should be called first");
2630 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
2632 #define addresses (current_ip_details->addr)
2634 vec_validate_init_empty (addresses, vec_len (addresses),
2635 empty_ip_address_details);
2637 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
2639 clib_memcpy (&address->ip, &mp->ip, sizeof (address->ip));
2640 address->prefix_length = mp->prefix_length;
2644 static void vl_api_ip_address_details_t_handler_json
2645 (vl_api_ip_address_details_t * mp)
2647 vat_main_t *vam = &vat_main;
2648 vat_json_node_t *node = NULL;
2649 struct in6_addr ip6;
2652 if (VAT_JSON_ARRAY != vam->json_tree.type)
2654 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2655 vat_json_init_array (&vam->json_tree);
2657 node = vat_json_array_add (&vam->json_tree);
2659 vat_json_init_object (node);
2662 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
2663 vat_json_object_add_ip6 (node, "ip", ip6);
2667 clib_memcpy (&ip4, mp->ip, sizeof (ip4));
2668 vat_json_object_add_ip4 (node, "ip", ip4);
2670 vat_json_object_add_uint (node, "prefix_length", mp->prefix_length);
2674 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
2676 vat_main_t *vam = &vat_main;
2677 static ip_details_t empty_ip_details = { 0 };
2678 ip_details_t *ip = NULL;
2679 u32 sw_if_index = ~0;
2681 sw_if_index = ntohl (mp->sw_if_index);
2683 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2684 sw_if_index, empty_ip_details);
2686 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2693 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
2695 vat_main_t *vam = &vat_main;
2697 if (VAT_JSON_ARRAY != vam->json_tree.type)
2699 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2700 vat_json_init_array (&vam->json_tree);
2702 vat_json_array_add_uint (&vam->json_tree,
2703 clib_net_to_host_u32 (mp->sw_if_index));
2707 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
2709 errmsg ("DHCP compl event: pid %d %s hostname %s host_addr %U "
2710 "router_addr %U host_mac %U",
2711 ntohl (mp->pid), mp->lease.is_ipv6 ? "ipv6" : "ipv4",
2713 format_ip4_address, &mp->lease.host_address,
2714 format_ip4_address, &mp->lease.router_address,
2715 format_ethernet_address, mp->lease.host_mac);
2718 static void vl_api_dhcp_compl_event_t_handler_json
2719 (vl_api_dhcp_compl_event_t * mp)
2721 /* JSON output not supported */
2724 static void vl_api_get_first_msg_id_reply_t_handler
2725 (vl_api_get_first_msg_id_reply_t * mp)
2727 vat_main_t *vam = &vat_main;
2728 i32 retval = ntohl (mp->retval);
2730 if (vam->async_mode)
2732 vam->async_errors += (retval < 0);
2736 vam->retval = retval;
2737 vam->result_ready = 1;
2741 errmsg ("first message id %d", ntohs (mp->first_msg_id));
2745 static void vl_api_get_first_msg_id_reply_t_handler_json
2746 (vl_api_get_first_msg_id_reply_t * mp)
2748 vat_main_t *vam = &vat_main;
2749 vat_json_node_t node;
2751 vat_json_init_object (&node);
2752 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2753 vat_json_object_add_uint (&node, "first_msg_id",
2754 (uint) ntohs (mp->first_msg_id));
2756 vat_json_print (vam->ofp, &node);
2757 vat_json_free (&node);
2759 vam->retval = ntohl (mp->retval);
2760 vam->result_ready = 1;
2763 static void vl_api_get_node_graph_reply_t_handler
2764 (vl_api_get_node_graph_reply_t * mp)
2766 vat_main_t *vam = &vat_main;
2767 api_main_t *am = &api_main;
2768 i32 retval = ntohl (mp->retval);
2769 u8 *pvt_copy, *reply;
2774 if (vam->async_mode)
2776 vam->async_errors += (retval < 0);
2780 vam->retval = retval;
2781 vam->result_ready = 1;
2784 /* "Should never happen..." */
2788 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2789 pvt_copy = vec_dup (reply);
2791 /* Toss the shared-memory original... */
2792 pthread_mutex_lock (&am->vlib_rp->mutex);
2793 oldheap = svm_push_data_heap (am->vlib_rp);
2797 svm_pop_heap (oldheap);
2798 pthread_mutex_unlock (&am->vlib_rp->mutex);
2800 if (vam->graph_nodes)
2802 hash_free (vam->graph_node_index_by_name);
2804 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2806 node = vam->graph_nodes[0][i];
2807 vec_free (node->name);
2808 vec_free (node->next_nodes);
2811 vec_free (vam->graph_nodes[0]);
2812 vec_free (vam->graph_nodes);
2815 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2816 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2817 vec_free (pvt_copy);
2819 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2821 node = vam->graph_nodes[0][i];
2822 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2826 static void vl_api_get_node_graph_reply_t_handler_json
2827 (vl_api_get_node_graph_reply_t * mp)
2829 vat_main_t *vam = &vat_main;
2830 api_main_t *am = &api_main;
2832 vat_json_node_t node;
2835 /* $$$$ make this real? */
2836 vat_json_init_object (&node);
2837 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2838 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2840 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2842 /* Toss the shared-memory original... */
2843 pthread_mutex_lock (&am->vlib_rp->mutex);
2844 oldheap = svm_push_data_heap (am->vlib_rp);
2848 svm_pop_heap (oldheap);
2849 pthread_mutex_unlock (&am->vlib_rp->mutex);
2851 vat_json_print (vam->ofp, &node);
2852 vat_json_free (&node);
2854 vam->retval = ntohl (mp->retval);
2855 vam->result_ready = 1;
2859 vl_api_one_locator_details_t_handler (vl_api_one_locator_details_t * mp)
2861 vat_main_t *vam = &vat_main;
2866 s = format (s, "%=16d%=16d%=16d",
2867 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2871 s = format (s, "%=16U%=16d%=16d",
2872 mp->is_ipv6 ? format_ip6_address :
2874 mp->ip_address, mp->priority, mp->weight);
2877 print (vam->ofp, "%v", s);
2882 vl_api_one_locator_details_t_handler_json (vl_api_one_locator_details_t * mp)
2884 vat_main_t *vam = &vat_main;
2885 vat_json_node_t *node = NULL;
2886 struct in6_addr ip6;
2889 if (VAT_JSON_ARRAY != vam->json_tree.type)
2891 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2892 vat_json_init_array (&vam->json_tree);
2894 node = vat_json_array_add (&vam->json_tree);
2895 vat_json_init_object (node);
2897 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2898 vat_json_object_add_uint (node, "priority", mp->priority);
2899 vat_json_object_add_uint (node, "weight", mp->weight);
2902 vat_json_object_add_uint (node, "sw_if_index",
2903 clib_net_to_host_u32 (mp->sw_if_index));
2908 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2909 vat_json_object_add_ip6 (node, "address", ip6);
2913 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2914 vat_json_object_add_ip4 (node, "address", ip4);
2920 vl_api_one_locator_set_details_t_handler (vl_api_one_locator_set_details_t *
2923 vat_main_t *vam = &vat_main;
2926 ls_name = format (0, "%s", mp->ls_name);
2928 print (vam->ofp, "%=10d%=15v", clib_net_to_host_u32 (mp->ls_index),
2934 vl_api_one_locator_set_details_t_handler_json
2935 (vl_api_one_locator_set_details_t * mp)
2937 vat_main_t *vam = &vat_main;
2938 vat_json_node_t *node = 0;
2941 ls_name = format (0, "%s", mp->ls_name);
2942 vec_add1 (ls_name, 0);
2944 if (VAT_JSON_ARRAY != vam->json_tree.type)
2946 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2947 vat_json_init_array (&vam->json_tree);
2949 node = vat_json_array_add (&vam->json_tree);
2951 vat_json_init_object (node);
2952 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2953 vat_json_object_add_uint (node, "ls_index",
2954 clib_net_to_host_u32 (mp->ls_index));
2962 } __attribute__ ((__packed__)) lisp_nsh_api_t;
2965 unformat_nsh_address (unformat_input_t * input, va_list * args)
2967 lisp_nsh_api_t *nsh = va_arg (*args, lisp_nsh_api_t *);
2968 return unformat (input, "SPI:%d SI:%d", &nsh->spi, &nsh->si);
2972 format_nsh_address_vat (u8 * s, va_list * args)
2974 nsh_t *a = va_arg (*args, nsh_t *);
2975 return format (s, "SPI:%d SI:%d", clib_net_to_host_u32 (a->spi), a->si);
2979 format_lisp_flat_eid (u8 * s, va_list * args)
2981 u32 type = va_arg (*args, u32);
2982 u8 *eid = va_arg (*args, u8 *);
2983 u32 eid_len = va_arg (*args, u32);
2988 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
2990 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
2992 return format (s, "%U", format_ethernet_address, eid);
2994 return format (s, "%U", format_nsh_address_vat, eid);
3000 format_lisp_eid_vat (u8 * s, va_list * args)
3002 u32 type = va_arg (*args, u32);
3003 u8 *eid = va_arg (*args, u8 *);
3004 u32 eid_len = va_arg (*args, u32);
3005 u8 *seid = va_arg (*args, u8 *);
3006 u32 seid_len = va_arg (*args, u32);
3007 u32 is_src_dst = va_arg (*args, u32);
3010 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
3012 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
3018 vl_api_one_eid_table_details_t_handler (vl_api_one_eid_table_details_t * mp)
3020 vat_main_t *vam = &vat_main;
3021 u8 *s = 0, *eid = 0;
3023 if (~0 == mp->locator_set_index)
3024 s = format (0, "action: %d", mp->action);
3026 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
3028 eid = format (0, "%U", format_lisp_eid_vat,
3032 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
3035 print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
3036 clib_net_to_host_u32 (mp->vni),
3038 mp->is_local ? "local" : "remote",
3039 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
3040 clib_net_to_host_u16 (mp->key_id), mp->key);
3047 vl_api_one_eid_table_details_t_handler_json (vl_api_one_eid_table_details_t
3050 vat_main_t *vam = &vat_main;
3051 vat_json_node_t *node = 0;
3054 if (VAT_JSON_ARRAY != vam->json_tree.type)
3056 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3057 vat_json_init_array (&vam->json_tree);
3059 node = vat_json_array_add (&vam->json_tree);
3061 vat_json_init_object (node);
3062 if (~0 == mp->locator_set_index)
3063 vat_json_object_add_uint (node, "action", mp->action);
3065 vat_json_object_add_uint (node, "locator_set_index",
3066 clib_net_to_host_u32 (mp->locator_set_index));
3068 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
3069 if (mp->eid_type == 3)
3071 vat_json_node_t *nsh_json = vat_json_object_add (node, "eid");
3072 vat_json_init_object (nsh_json);
3073 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) mp->eid;
3074 vat_json_object_add_uint (nsh_json, "spi",
3075 clib_net_to_host_u32 (nsh->spi));
3076 vat_json_object_add_uint (nsh_json, "si", nsh->si);
3080 eid = format (0, "%U", format_lisp_eid_vat,
3084 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
3086 vat_json_object_add_string_copy (node, "eid", eid);
3089 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3090 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
3091 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
3095 vat_json_object_add_uint (node, "key_id",
3096 clib_net_to_host_u16 (mp->key_id));
3097 vat_json_object_add_string_copy (node, "key", mp->key);
3102 vl_api_one_stats_details_t_handler (vl_api_one_stats_details_t * mp)
3104 vat_main_t *vam = &vat_main;
3105 u8 *seid = 0, *deid = 0;
3106 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3108 deid = format (0, "%U", format_lisp_eid_vat,
3109 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3111 seid = format (0, "%U", format_lisp_eid_vat,
3112 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3118 format_ip_address_fcn = format_ip4_address;
3120 format_ip_address_fcn = format_ip6_address;
3123 print (vam->ofp, "([%d] %s %s) (%U %U) %u %u",
3124 clib_net_to_host_u32 (mp->vni),
3126 format_ip_address_fcn, mp->lloc,
3127 format_ip_address_fcn, mp->rloc,
3128 clib_net_to_host_u32 (mp->pkt_count),
3129 clib_net_to_host_u32 (mp->bytes));
3136 vl_api_one_stats_details_t_handler_json (vl_api_one_stats_details_t * mp)
3138 struct in6_addr ip6;
3140 vat_main_t *vam = &vat_main;
3141 vat_json_node_t *node = 0;
3142 u8 *deid = 0, *seid = 0;
3144 if (VAT_JSON_ARRAY != vam->json_tree.type)
3146 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3147 vat_json_init_array (&vam->json_tree);
3149 node = vat_json_array_add (&vam->json_tree);
3151 vat_json_init_object (node);
3152 deid = format (0, "%U", format_lisp_eid_vat,
3153 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3155 seid = format (0, "%U", format_lisp_eid_vat,
3156 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3161 vat_json_object_add_string_copy (node, "seid", seid);
3162 vat_json_object_add_string_copy (node, "deid", deid);
3163 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3167 clib_memcpy (&ip4, mp->lloc, sizeof (ip4));
3168 vat_json_object_add_ip4 (node, "lloc", ip4);
3169 clib_memcpy (&ip4, mp->rloc, sizeof (ip4));
3170 vat_json_object_add_ip4 (node, "rloc", ip4);
3174 clib_memcpy (&ip6, mp->lloc, sizeof (ip6));
3175 vat_json_object_add_ip6 (node, "lloc", ip6);
3176 clib_memcpy (&ip6, mp->rloc, sizeof (ip6));
3177 vat_json_object_add_ip6 (node, "rloc", ip6);
3179 vat_json_object_add_uint (node, "pkt_count",
3180 clib_net_to_host_u32 (mp->pkt_count));
3181 vat_json_object_add_uint (node, "bytes", clib_net_to_host_u32 (mp->bytes));
3188 vl_api_one_eid_table_map_details_t_handler
3189 (vl_api_one_eid_table_map_details_t * mp)
3191 vat_main_t *vam = &vat_main;
3193 u8 *line = format (0, "%=10d%=10d",
3194 clib_net_to_host_u32 (mp->vni),
3195 clib_net_to_host_u32 (mp->dp_table));
3196 print (vam->ofp, "%v", line);
3201 vl_api_one_eid_table_map_details_t_handler_json
3202 (vl_api_one_eid_table_map_details_t * mp)
3204 vat_main_t *vam = &vat_main;
3205 vat_json_node_t *node = NULL;
3207 if (VAT_JSON_ARRAY != vam->json_tree.type)
3209 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3210 vat_json_init_array (&vam->json_tree);
3212 node = vat_json_array_add (&vam->json_tree);
3213 vat_json_init_object (node);
3214 vat_json_object_add_uint (node, "dp_table",
3215 clib_net_to_host_u32 (mp->dp_table));
3216 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3220 vl_api_one_eid_table_vni_details_t_handler
3221 (vl_api_one_eid_table_vni_details_t * mp)
3223 vat_main_t *vam = &vat_main;
3225 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
3226 print (vam->ofp, "%v", line);
3231 vl_api_one_eid_table_vni_details_t_handler_json
3232 (vl_api_one_eid_table_vni_details_t * mp)
3234 vat_main_t *vam = &vat_main;
3235 vat_json_node_t *node = NULL;
3237 if (VAT_JSON_ARRAY != vam->json_tree.type)
3239 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3240 vat_json_init_array (&vam->json_tree);
3242 node = vat_json_array_add (&vam->json_tree);
3243 vat_json_init_object (node);
3244 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3248 vl_api_show_one_map_register_fallback_threshold_reply_t_handler
3249 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3251 vat_main_t *vam = &vat_main;
3252 int retval = clib_net_to_host_u32 (mp->retval);
3254 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3255 print (vam->ofp, "fallback threshold value: %d", mp->value);
3257 vam->retval = retval;
3258 vam->result_ready = 1;
3262 vl_api_show_one_map_register_fallback_threshold_reply_t_handler_json
3263 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3265 vat_main_t *vam = &vat_main;
3266 vat_json_node_t _node, *node = &_node;
3267 int retval = clib_net_to_host_u32 (mp->retval);
3269 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3270 vat_json_init_object (node);
3271 vat_json_object_add_uint (node, "value", mp->value);
3273 vat_json_print (vam->ofp, node);
3274 vat_json_free (node);
3276 vam->retval = retval;
3277 vam->result_ready = 1;
3281 vl_api_show_one_map_register_state_reply_t_handler
3282 (vl_api_show_one_map_register_state_reply_t * mp)
3284 vat_main_t *vam = &vat_main;
3285 int retval = clib_net_to_host_u32 (mp->retval);
3287 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3289 vam->retval = retval;
3290 vam->result_ready = 1;
3294 vl_api_show_one_map_register_state_reply_t_handler_json
3295 (vl_api_show_one_map_register_state_reply_t * mp)
3297 vat_main_t *vam = &vat_main;
3298 vat_json_node_t _node, *node = &_node;
3299 int retval = clib_net_to_host_u32 (mp->retval);
3301 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3303 vat_json_init_object (node);
3304 vat_json_object_add_string_copy (node, "state", s);
3306 vat_json_print (vam->ofp, node);
3307 vat_json_free (node);
3309 vam->retval = retval;
3310 vam->result_ready = 1;
3315 vl_api_show_one_rloc_probe_state_reply_t_handler
3316 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3318 vat_main_t *vam = &vat_main;
3319 int retval = clib_net_to_host_u32 (mp->retval);
3324 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3326 vam->retval = retval;
3327 vam->result_ready = 1;
3331 vl_api_show_one_rloc_probe_state_reply_t_handler_json
3332 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3334 vat_main_t *vam = &vat_main;
3335 vat_json_node_t _node, *node = &_node;
3336 int retval = clib_net_to_host_u32 (mp->retval);
3338 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3339 vat_json_init_object (node);
3340 vat_json_object_add_string_copy (node, "state", s);
3342 vat_json_print (vam->ofp, node);
3343 vat_json_free (node);
3345 vam->retval = retval;
3346 vam->result_ready = 1;
3351 vl_api_show_one_stats_enable_disable_reply_t_handler
3352 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3354 vat_main_t *vam = &vat_main;
3355 int retval = clib_net_to_host_u32 (mp->retval);
3360 print (vam->ofp, "%s", mp->is_en ? "enabled" : "disabled");
3362 vam->retval = retval;
3363 vam->result_ready = 1;
3367 vl_api_show_one_stats_enable_disable_reply_t_handler_json
3368 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3370 vat_main_t *vam = &vat_main;
3371 vat_json_node_t _node, *node = &_node;
3372 int retval = clib_net_to_host_u32 (mp->retval);
3374 u8 *s = format (0, "%s", mp->is_en ? "enabled" : "disabled");
3375 vat_json_init_object (node);
3376 vat_json_object_add_string_copy (node, "state", s);
3378 vat_json_print (vam->ofp, node);
3379 vat_json_free (node);
3381 vam->retval = retval;
3382 vam->result_ready = 1;
3387 api_gpe_fwd_entry_net_to_host (vl_api_gpe_fwd_entry_t * e)
3389 e->dp_table = clib_net_to_host_u32 (e->dp_table);
3390 e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
3391 e->vni = clib_net_to_host_u32 (e->vni);
3395 gpe_fwd_entries_get_reply_t_net_to_host
3396 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3400 mp->count = clib_net_to_host_u32 (mp->count);
3401 for (i = 0; i < mp->count; i++)
3403 api_gpe_fwd_entry_net_to_host (&mp->entries[i]);
3408 format_gpe_encap_mode (u8 * s, va_list * args)
3410 u32 mode = va_arg (*args, u32);
3415 return format (s, "lisp");
3417 return format (s, "vxlan");
3423 vl_api_gpe_get_encap_mode_reply_t_handler
3424 (vl_api_gpe_get_encap_mode_reply_t * mp)
3426 vat_main_t *vam = &vat_main;
3428 print (vam->ofp, "gpe mode: %U", format_gpe_encap_mode, mp->encap_mode);
3429 vam->retval = ntohl (mp->retval);
3430 vam->result_ready = 1;
3434 vl_api_gpe_get_encap_mode_reply_t_handler_json
3435 (vl_api_gpe_get_encap_mode_reply_t * mp)
3437 vat_main_t *vam = &vat_main;
3438 vat_json_node_t node;
3440 u8 *encap_mode = format (0, "%U", format_gpe_encap_mode, mp->encap_mode);
3441 vec_add1 (encap_mode, 0);
3443 vat_json_init_object (&node);
3444 vat_json_object_add_string_copy (&node, "gpe_mode", encap_mode);
3446 vec_free (encap_mode);
3447 vat_json_print (vam->ofp, &node);
3448 vat_json_free (&node);
3450 vam->retval = ntohl (mp->retval);
3451 vam->result_ready = 1;
3455 vl_api_gpe_fwd_entry_path_details_t_handler
3456 (vl_api_gpe_fwd_entry_path_details_t * mp)
3458 vat_main_t *vam = &vat_main;
3459 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3461 if (mp->lcl_loc.is_ip4)
3462 format_ip_address_fcn = format_ip4_address;
3464 format_ip_address_fcn = format_ip6_address;
3466 print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
3467 format_ip_address_fcn, &mp->lcl_loc,
3468 format_ip_address_fcn, &mp->rmt_loc);
3472 lisp_fill_locator_node (vat_json_node_t * n, vl_api_gpe_locator_t * loc)
3474 struct in6_addr ip6;
3479 clib_memcpy (&ip4, loc->addr, sizeof (ip4));
3480 vat_json_object_add_ip4 (n, "address", ip4);
3484 clib_memcpy (&ip6, loc->addr, sizeof (ip6));
3485 vat_json_object_add_ip6 (n, "address", ip6);
3487 vat_json_object_add_uint (n, "weight", loc->weight);
3491 vl_api_gpe_fwd_entry_path_details_t_handler_json
3492 (vl_api_gpe_fwd_entry_path_details_t * mp)
3494 vat_main_t *vam = &vat_main;
3495 vat_json_node_t *node = NULL;
3496 vat_json_node_t *loc_node;
3498 if (VAT_JSON_ARRAY != vam->json_tree.type)
3500 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3501 vat_json_init_array (&vam->json_tree);
3503 node = vat_json_array_add (&vam->json_tree);
3504 vat_json_init_object (node);
3506 loc_node = vat_json_object_add (node, "local_locator");
3507 vat_json_init_object (loc_node);
3508 lisp_fill_locator_node (loc_node, &mp->lcl_loc);
3510 loc_node = vat_json_object_add (node, "remote_locator");
3511 vat_json_init_object (loc_node);
3512 lisp_fill_locator_node (loc_node, &mp->rmt_loc);
3516 vl_api_gpe_fwd_entries_get_reply_t_handler
3517 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3519 vat_main_t *vam = &vat_main;
3521 int retval = clib_net_to_host_u32 (mp->retval);
3522 vl_api_gpe_fwd_entry_t *e;
3527 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3529 for (i = 0; i < mp->count; i++)
3531 e = &mp->entries[i];
3532 print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
3533 format_lisp_flat_eid, e->eid_type, e->leid, e->leid_prefix_len,
3534 format_lisp_flat_eid, e->eid_type, e->reid, e->reid_prefix_len);
3538 vam->retval = retval;
3539 vam->result_ready = 1;
3543 vl_api_gpe_fwd_entries_get_reply_t_handler_json
3544 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3547 vat_main_t *vam = &vat_main;
3548 vat_json_node_t *e = 0, root;
3550 int retval = clib_net_to_host_u32 (mp->retval);
3551 vl_api_gpe_fwd_entry_t *fwd;
3556 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3557 vat_json_init_array (&root);
3559 for (i = 0; i < mp->count; i++)
3561 e = vat_json_array_add (&root);
3562 fwd = &mp->entries[i];
3564 vat_json_init_object (e);
3565 vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
3566 vat_json_object_add_int (e, "dp_table", fwd->dp_table);
3567 vat_json_object_add_int (e, "vni", fwd->vni);
3568 vat_json_object_add_int (e, "action", fwd->action);
3570 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->leid,
3571 fwd->leid_prefix_len);
3573 vat_json_object_add_string_copy (e, "leid", s);
3576 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->reid,
3577 fwd->reid_prefix_len);
3579 vat_json_object_add_string_copy (e, "reid", s);
3583 vat_json_print (vam->ofp, &root);
3584 vat_json_free (&root);
3587 vam->retval = retval;
3588 vam->result_ready = 1;
3592 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler
3593 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3595 vat_main_t *vam = &vat_main;
3597 int retval = clib_net_to_host_u32 (mp->retval);
3598 vl_api_gpe_native_fwd_rpath_t *r;
3603 n = clib_net_to_host_u32 (mp->count);
3605 for (i = 0; i < n; i++)
3607 r = &mp->entries[i];
3608 print (vam->ofp, "fib_index: %d sw_if_index %d nh %U",
3609 clib_net_to_host_u32 (r->fib_index),
3610 clib_net_to_host_u32 (r->nh_sw_if_index),
3611 r->is_ip4 ? format_ip4_address : format_ip6_address, r->nh_addr);
3615 vam->retval = retval;
3616 vam->result_ready = 1;
3620 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler_json
3621 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3623 vat_main_t *vam = &vat_main;
3624 vat_json_node_t root, *e;
3626 int retval = clib_net_to_host_u32 (mp->retval);
3627 vl_api_gpe_native_fwd_rpath_t *r;
3633 n = clib_net_to_host_u32 (mp->count);
3634 vat_json_init_array (&root);
3636 for (i = 0; i < n; i++)
3638 e = vat_json_array_add (&root);
3639 vat_json_init_object (e);
3640 r = &mp->entries[i];
3642 format (0, "%U", r->is_ip4 ? format_ip4_address : format_ip6_address,
3645 vat_json_object_add_string_copy (e, "ip4", s);
3648 vat_json_object_add_uint (e, "fib_index",
3649 clib_net_to_host_u32 (r->fib_index));
3650 vat_json_object_add_uint (e, "nh_sw_if_index",
3651 clib_net_to_host_u32 (r->nh_sw_if_index));
3654 vat_json_print (vam->ofp, &root);
3655 vat_json_free (&root);
3658 vam->retval = retval;
3659 vam->result_ready = 1;
3663 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler
3664 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3666 vat_main_t *vam = &vat_main;
3668 int retval = clib_net_to_host_u32 (mp->retval);
3673 n = clib_net_to_host_u32 (mp->count);
3675 for (i = 0; i < n; i++)
3676 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->vnis[i]));
3679 vam->retval = retval;
3680 vam->result_ready = 1;
3684 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler_json
3685 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3687 vat_main_t *vam = &vat_main;
3688 vat_json_node_t root;
3690 int retval = clib_net_to_host_u32 (mp->retval);
3695 n = clib_net_to_host_u32 (mp->count);
3696 vat_json_init_array (&root);
3698 for (i = 0; i < n; i++)
3699 vat_json_array_add_uint (&root, clib_net_to_host_u32 (mp->vnis[i]));
3701 vat_json_print (vam->ofp, &root);
3702 vat_json_free (&root);
3705 vam->retval = retval;
3706 vam->result_ready = 1;
3710 vl_api_one_ndp_entries_get_reply_t_handler
3711 (vl_api_one_ndp_entries_get_reply_t * mp)
3713 vat_main_t *vam = &vat_main;
3715 int retval = clib_net_to_host_u32 (mp->retval);
3720 n = clib_net_to_host_u32 (mp->count);
3722 for (i = 0; i < n; i++)
3723 print (vam->ofp, "%U -> %U", format_ip6_address, &mp->entries[i].ip6,
3724 format_ethernet_address, mp->entries[i].mac);
3727 vam->retval = retval;
3728 vam->result_ready = 1;
3732 vl_api_one_ndp_entries_get_reply_t_handler_json
3733 (vl_api_one_ndp_entries_get_reply_t * mp)
3736 vat_main_t *vam = &vat_main;
3737 vat_json_node_t *e = 0, root;
3739 int retval = clib_net_to_host_u32 (mp->retval);
3740 vl_api_one_ndp_entry_t *arp_entry;
3745 n = clib_net_to_host_u32 (mp->count);
3746 vat_json_init_array (&root);
3748 for (i = 0; i < n; i++)
3750 e = vat_json_array_add (&root);
3751 arp_entry = &mp->entries[i];
3753 vat_json_init_object (e);
3754 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3757 vat_json_object_add_string_copy (e, "mac", s);
3760 s = format (0, "%U", format_ip6_address, &arp_entry->ip6);
3762 vat_json_object_add_string_copy (e, "ip6", s);
3766 vat_json_print (vam->ofp, &root);
3767 vat_json_free (&root);
3770 vam->retval = retval;
3771 vam->result_ready = 1;
3775 vl_api_one_l2_arp_entries_get_reply_t_handler
3776 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3778 vat_main_t *vam = &vat_main;
3780 int retval = clib_net_to_host_u32 (mp->retval);
3785 n = clib_net_to_host_u32 (mp->count);
3787 for (i = 0; i < n; i++)
3788 print (vam->ofp, "%U -> %U", format_ip4_address, &mp->entries[i].ip4,
3789 format_ethernet_address, mp->entries[i].mac);
3792 vam->retval = retval;
3793 vam->result_ready = 1;
3797 vl_api_one_l2_arp_entries_get_reply_t_handler_json
3798 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3801 vat_main_t *vam = &vat_main;
3802 vat_json_node_t *e = 0, root;
3804 int retval = clib_net_to_host_u32 (mp->retval);
3805 vl_api_one_l2_arp_entry_t *arp_entry;
3810 n = clib_net_to_host_u32 (mp->count);
3811 vat_json_init_array (&root);
3813 for (i = 0; i < n; i++)
3815 e = vat_json_array_add (&root);
3816 arp_entry = &mp->entries[i];
3818 vat_json_init_object (e);
3819 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3822 vat_json_object_add_string_copy (e, "mac", s);
3825 s = format (0, "%U", format_ip4_address, &arp_entry->ip4);
3827 vat_json_object_add_string_copy (e, "ip4", s);
3831 vat_json_print (vam->ofp, &root);
3832 vat_json_free (&root);
3835 vam->retval = retval;
3836 vam->result_ready = 1;
3840 vl_api_one_ndp_bd_get_reply_t_handler (vl_api_one_ndp_bd_get_reply_t * mp)
3842 vat_main_t *vam = &vat_main;
3844 int retval = clib_net_to_host_u32 (mp->retval);
3849 n = clib_net_to_host_u32 (mp->count);
3851 for (i = 0; i < n; i++)
3853 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3857 vam->retval = retval;
3858 vam->result_ready = 1;
3862 vl_api_one_ndp_bd_get_reply_t_handler_json
3863 (vl_api_one_ndp_bd_get_reply_t * mp)
3865 vat_main_t *vam = &vat_main;
3866 vat_json_node_t root;
3868 int retval = clib_net_to_host_u32 (mp->retval);
3873 n = clib_net_to_host_u32 (mp->count);
3874 vat_json_init_array (&root);
3876 for (i = 0; i < n; i++)
3878 vat_json_array_add_uint (&root,
3879 clib_net_to_host_u32 (mp->bridge_domains[i]));
3882 vat_json_print (vam->ofp, &root);
3883 vat_json_free (&root);
3886 vam->retval = retval;
3887 vam->result_ready = 1;
3891 vl_api_one_l2_arp_bd_get_reply_t_handler
3892 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3894 vat_main_t *vam = &vat_main;
3896 int retval = clib_net_to_host_u32 (mp->retval);
3901 n = clib_net_to_host_u32 (mp->count);
3903 for (i = 0; i < n; i++)
3905 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3909 vam->retval = retval;
3910 vam->result_ready = 1;
3914 vl_api_one_l2_arp_bd_get_reply_t_handler_json
3915 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3917 vat_main_t *vam = &vat_main;
3918 vat_json_node_t root;
3920 int retval = clib_net_to_host_u32 (mp->retval);
3925 n = clib_net_to_host_u32 (mp->count);
3926 vat_json_init_array (&root);
3928 for (i = 0; i < n; i++)
3930 vat_json_array_add_uint (&root,
3931 clib_net_to_host_u32 (mp->bridge_domains[i]));
3934 vat_json_print (vam->ofp, &root);
3935 vat_json_free (&root);
3938 vam->retval = retval;
3939 vam->result_ready = 1;
3943 vl_api_one_adjacencies_get_reply_t_handler
3944 (vl_api_one_adjacencies_get_reply_t * mp)
3946 vat_main_t *vam = &vat_main;
3948 int retval = clib_net_to_host_u32 (mp->retval);
3949 vl_api_one_adjacency_t *a;
3954 n = clib_net_to_host_u32 (mp->count);
3956 for (i = 0; i < n; i++)
3958 a = &mp->adjacencies[i];
3959 print (vam->ofp, "%U %40U",
3960 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
3961 format_lisp_flat_eid, a->eid_type, a->reid, a->reid_prefix_len);
3965 vam->retval = retval;
3966 vam->result_ready = 1;
3970 vl_api_one_adjacencies_get_reply_t_handler_json
3971 (vl_api_one_adjacencies_get_reply_t * mp)
3974 vat_main_t *vam = &vat_main;
3975 vat_json_node_t *e = 0, root;
3977 int retval = clib_net_to_host_u32 (mp->retval);
3978 vl_api_one_adjacency_t *a;
3983 n = clib_net_to_host_u32 (mp->count);
3984 vat_json_init_array (&root);
3986 for (i = 0; i < n; i++)
3988 e = vat_json_array_add (&root);
3989 a = &mp->adjacencies[i];
3991 vat_json_init_object (e);
3992 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
3993 a->leid_prefix_len);
3995 vat_json_object_add_string_copy (e, "leid", s);
3998 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
3999 a->reid_prefix_len);
4001 vat_json_object_add_string_copy (e, "reid", s);
4005 vat_json_print (vam->ofp, &root);
4006 vat_json_free (&root);
4009 vam->retval = retval;
4010 vam->result_ready = 1;
4014 vl_api_one_map_server_details_t_handler (vl_api_one_map_server_details_t * mp)
4016 vat_main_t *vam = &vat_main;
4018 print (vam->ofp, "%=20U",
4019 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
4024 vl_api_one_map_server_details_t_handler_json
4025 (vl_api_one_map_server_details_t * mp)
4027 vat_main_t *vam = &vat_main;
4028 vat_json_node_t *node = NULL;
4029 struct in6_addr ip6;
4032 if (VAT_JSON_ARRAY != vam->json_tree.type)
4034 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4035 vat_json_init_array (&vam->json_tree);
4037 node = vat_json_array_add (&vam->json_tree);
4039 vat_json_init_object (node);
4042 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
4043 vat_json_object_add_ip6 (node, "map-server", ip6);
4047 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
4048 vat_json_object_add_ip4 (node, "map-server", ip4);
4053 vl_api_one_map_resolver_details_t_handler (vl_api_one_map_resolver_details_t
4056 vat_main_t *vam = &vat_main;
4058 print (vam->ofp, "%=20U",
4059 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
4064 vl_api_one_map_resolver_details_t_handler_json
4065 (vl_api_one_map_resolver_details_t * mp)
4067 vat_main_t *vam = &vat_main;
4068 vat_json_node_t *node = NULL;
4069 struct in6_addr ip6;
4072 if (VAT_JSON_ARRAY != vam->json_tree.type)
4074 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4075 vat_json_init_array (&vam->json_tree);
4077 node = vat_json_array_add (&vam->json_tree);
4079 vat_json_init_object (node);
4082 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
4083 vat_json_object_add_ip6 (node, "map resolver", ip6);
4087 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
4088 vat_json_object_add_ip4 (node, "map resolver", ip4);
4093 vl_api_show_one_status_reply_t_handler (vl_api_show_one_status_reply_t * mp)
4095 vat_main_t *vam = &vat_main;
4096 i32 retval = ntohl (mp->retval);
4100 print (vam->ofp, "feature: %s\ngpe: %s",
4101 mp->feature_status ? "enabled" : "disabled",
4102 mp->gpe_status ? "enabled" : "disabled");
4105 vam->retval = retval;
4106 vam->result_ready = 1;
4110 vl_api_show_one_status_reply_t_handler_json
4111 (vl_api_show_one_status_reply_t * mp)
4113 vat_main_t *vam = &vat_main;
4114 vat_json_node_t node;
4115 u8 *gpe_status = NULL;
4116 u8 *feature_status = NULL;
4118 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
4119 feature_status = format (0, "%s",
4120 mp->feature_status ? "enabled" : "disabled");
4121 vec_add1 (gpe_status, 0);
4122 vec_add1 (feature_status, 0);
4124 vat_json_init_object (&node);
4125 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
4126 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
4128 vec_free (gpe_status);
4129 vec_free (feature_status);
4131 vat_json_print (vam->ofp, &node);
4132 vat_json_free (&node);
4134 vam->retval = ntohl (mp->retval);
4135 vam->result_ready = 1;
4139 vl_api_one_get_map_request_itr_rlocs_reply_t_handler
4140 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4142 vat_main_t *vam = &vat_main;
4143 i32 retval = ntohl (mp->retval);
4147 print (vam->ofp, "%=20s", mp->locator_set_name);
4150 vam->retval = retval;
4151 vam->result_ready = 1;
4155 vl_api_one_get_map_request_itr_rlocs_reply_t_handler_json
4156 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4158 vat_main_t *vam = &vat_main;
4159 vat_json_node_t *node = NULL;
4161 if (VAT_JSON_ARRAY != vam->json_tree.type)
4163 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4164 vat_json_init_array (&vam->json_tree);
4166 node = vat_json_array_add (&vam->json_tree);
4168 vat_json_init_object (node);
4169 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
4171 vat_json_print (vam->ofp, node);
4172 vat_json_free (node);
4174 vam->retval = ntohl (mp->retval);
4175 vam->result_ready = 1;
4179 format_lisp_map_request_mode (u8 * s, va_list * args)
4181 u32 mode = va_arg (*args, u32);
4186 return format (0, "dst-only");
4188 return format (0, "src-dst");
4194 vl_api_show_one_map_request_mode_reply_t_handler
4195 (vl_api_show_one_map_request_mode_reply_t * mp)
4197 vat_main_t *vam = &vat_main;
4198 i32 retval = ntohl (mp->retval);
4202 u32 mode = mp->mode;
4203 print (vam->ofp, "map_request_mode: %U",
4204 format_lisp_map_request_mode, mode);
4207 vam->retval = retval;
4208 vam->result_ready = 1;
4212 vl_api_show_one_map_request_mode_reply_t_handler_json
4213 (vl_api_show_one_map_request_mode_reply_t * mp)
4215 vat_main_t *vam = &vat_main;
4216 vat_json_node_t node;
4221 s = format (0, "%U", format_lisp_map_request_mode, mode);
4224 vat_json_init_object (&node);
4225 vat_json_object_add_string_copy (&node, "map_request_mode", s);
4226 vat_json_print (vam->ofp, &node);
4227 vat_json_free (&node);
4230 vam->retval = ntohl (mp->retval);
4231 vam->result_ready = 1;
4235 vl_api_one_show_xtr_mode_reply_t_handler
4236 (vl_api_one_show_xtr_mode_reply_t * mp)
4238 vat_main_t *vam = &vat_main;
4239 i32 retval = ntohl (mp->retval);
4243 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4246 vam->retval = retval;
4247 vam->result_ready = 1;
4251 vl_api_one_show_xtr_mode_reply_t_handler_json
4252 (vl_api_one_show_xtr_mode_reply_t * mp)
4254 vat_main_t *vam = &vat_main;
4255 vat_json_node_t node;
4258 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4259 vec_add1 (status, 0);
4261 vat_json_init_object (&node);
4262 vat_json_object_add_string_copy (&node, "status", status);
4266 vat_json_print (vam->ofp, &node);
4267 vat_json_free (&node);
4269 vam->retval = ntohl (mp->retval);
4270 vam->result_ready = 1;
4274 vl_api_one_show_pitr_mode_reply_t_handler
4275 (vl_api_one_show_pitr_mode_reply_t * mp)
4277 vat_main_t *vam = &vat_main;
4278 i32 retval = ntohl (mp->retval);
4282 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4285 vam->retval = retval;
4286 vam->result_ready = 1;
4290 vl_api_one_show_pitr_mode_reply_t_handler_json
4291 (vl_api_one_show_pitr_mode_reply_t * mp)
4293 vat_main_t *vam = &vat_main;
4294 vat_json_node_t node;
4297 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4298 vec_add1 (status, 0);
4300 vat_json_init_object (&node);
4301 vat_json_object_add_string_copy (&node, "status", status);
4305 vat_json_print (vam->ofp, &node);
4306 vat_json_free (&node);
4308 vam->retval = ntohl (mp->retval);
4309 vam->result_ready = 1;
4313 vl_api_one_show_petr_mode_reply_t_handler
4314 (vl_api_one_show_petr_mode_reply_t * mp)
4316 vat_main_t *vam = &vat_main;
4317 i32 retval = ntohl (mp->retval);
4321 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4324 vam->retval = retval;
4325 vam->result_ready = 1;
4329 vl_api_one_show_petr_mode_reply_t_handler_json
4330 (vl_api_one_show_petr_mode_reply_t * mp)
4332 vat_main_t *vam = &vat_main;
4333 vat_json_node_t node;
4336 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4337 vec_add1 (status, 0);
4339 vat_json_init_object (&node);
4340 vat_json_object_add_string_copy (&node, "status", status);
4344 vat_json_print (vam->ofp, &node);
4345 vat_json_free (&node);
4347 vam->retval = ntohl (mp->retval);
4348 vam->result_ready = 1;
4352 vl_api_show_one_use_petr_reply_t_handler
4353 (vl_api_show_one_use_petr_reply_t * mp)
4355 vat_main_t *vam = &vat_main;
4356 i32 retval = ntohl (mp->retval);
4360 print (vam->ofp, "%s\n", mp->status ? "enabled" : "disabled");
4363 print (vam->ofp, "Proxy-ETR address; %U",
4364 mp->is_ip4 ? format_ip4_address : format_ip6_address,
4369 vam->retval = retval;
4370 vam->result_ready = 1;
4374 vl_api_show_one_use_petr_reply_t_handler_json
4375 (vl_api_show_one_use_petr_reply_t * mp)
4377 vat_main_t *vam = &vat_main;
4378 vat_json_node_t node;
4381 struct in6_addr ip6;
4383 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4384 vec_add1 (status, 0);
4386 vat_json_init_object (&node);
4387 vat_json_object_add_string_copy (&node, "status", status);
4392 clib_memcpy (&ip6, mp->address, sizeof (ip6));
4393 vat_json_object_add_ip6 (&node, "address", ip6);
4397 clib_memcpy (&ip4, mp->address, sizeof (ip4));
4398 vat_json_object_add_ip4 (&node, "address", ip4);
4404 vat_json_print (vam->ofp, &node);
4405 vat_json_free (&node);
4407 vam->retval = ntohl (mp->retval);
4408 vam->result_ready = 1;
4412 vl_api_show_one_nsh_mapping_reply_t_handler
4413 (vl_api_show_one_nsh_mapping_reply_t * mp)
4415 vat_main_t *vam = &vat_main;
4416 i32 retval = ntohl (mp->retval);
4420 print (vam->ofp, "%-20s%-16s",
4421 mp->is_set ? "set" : "not-set",
4422 mp->is_set ? (char *) mp->locator_set_name : "");
4425 vam->retval = retval;
4426 vam->result_ready = 1;
4430 vl_api_show_one_nsh_mapping_reply_t_handler_json
4431 (vl_api_show_one_nsh_mapping_reply_t * mp)
4433 vat_main_t *vam = &vat_main;
4434 vat_json_node_t node;
4437 status = format (0, "%s", mp->is_set ? "yes" : "no");
4438 vec_add1 (status, 0);
4440 vat_json_init_object (&node);
4441 vat_json_object_add_string_copy (&node, "is_set", status);
4444 vat_json_object_add_string_copy (&node, "locator_set",
4445 mp->locator_set_name);
4450 vat_json_print (vam->ofp, &node);
4451 vat_json_free (&node);
4453 vam->retval = ntohl (mp->retval);
4454 vam->result_ready = 1;
4458 vl_api_show_one_map_register_ttl_reply_t_handler
4459 (vl_api_show_one_map_register_ttl_reply_t * mp)
4461 vat_main_t *vam = &vat_main;
4462 i32 retval = ntohl (mp->retval);
4464 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4468 print (vam->ofp, "ttl: %u", mp->ttl);
4471 vam->retval = retval;
4472 vam->result_ready = 1;
4476 vl_api_show_one_map_register_ttl_reply_t_handler_json
4477 (vl_api_show_one_map_register_ttl_reply_t * mp)
4479 vat_main_t *vam = &vat_main;
4480 vat_json_node_t node;
4482 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4483 vat_json_init_object (&node);
4484 vat_json_object_add_uint (&node, "ttl", mp->ttl);
4486 vat_json_print (vam->ofp, &node);
4487 vat_json_free (&node);
4489 vam->retval = ntohl (mp->retval);
4490 vam->result_ready = 1;
4494 vl_api_show_one_pitr_reply_t_handler (vl_api_show_one_pitr_reply_t * mp)
4496 vat_main_t *vam = &vat_main;
4497 i32 retval = ntohl (mp->retval);
4501 print (vam->ofp, "%-20s%-16s",
4502 mp->status ? "enabled" : "disabled",
4503 mp->status ? (char *) mp->locator_set_name : "");
4506 vam->retval = retval;
4507 vam->result_ready = 1;
4511 vl_api_show_one_pitr_reply_t_handler_json (vl_api_show_one_pitr_reply_t * mp)
4513 vat_main_t *vam = &vat_main;
4514 vat_json_node_t node;
4517 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4518 vec_add1 (status, 0);
4520 vat_json_init_object (&node);
4521 vat_json_object_add_string_copy (&node, "status", status);
4524 vat_json_object_add_string_copy (&node, "locator_set",
4525 mp->locator_set_name);
4530 vat_json_print (vam->ofp, &node);
4531 vat_json_free (&node);
4533 vam->retval = ntohl (mp->retval);
4534 vam->result_ready = 1;
4538 format_policer_type (u8 * s, va_list * va)
4540 u32 i = va_arg (*va, u32);
4542 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
4543 s = format (s, "1r2c");
4544 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
4545 s = format (s, "1r3c");
4546 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
4547 s = format (s, "2r3c-2698");
4548 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
4549 s = format (s, "2r3c-4115");
4550 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
4551 s = format (s, "2r3c-mef5cf1");
4553 s = format (s, "ILLEGAL");
4558 format_policer_rate_type (u8 * s, va_list * va)
4560 u32 i = va_arg (*va, u32);
4562 if (i == SSE2_QOS_RATE_KBPS)
4563 s = format (s, "kbps");
4564 else if (i == SSE2_QOS_RATE_PPS)
4565 s = format (s, "pps");
4567 s = format (s, "ILLEGAL");
4572 format_policer_round_type (u8 * s, va_list * va)
4574 u32 i = va_arg (*va, u32);
4576 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
4577 s = format (s, "closest");
4578 else if (i == SSE2_QOS_ROUND_TO_UP)
4579 s = format (s, "up");
4580 else if (i == SSE2_QOS_ROUND_TO_DOWN)
4581 s = format (s, "down");
4583 s = format (s, "ILLEGAL");
4588 format_policer_action_type (u8 * s, va_list * va)
4590 u32 i = va_arg (*va, u32);
4592 if (i == SSE2_QOS_ACTION_DROP)
4593 s = format (s, "drop");
4594 else if (i == SSE2_QOS_ACTION_TRANSMIT)
4595 s = format (s, "transmit");
4596 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4597 s = format (s, "mark-and-transmit");
4599 s = format (s, "ILLEGAL");
4604 format_dscp (u8 * s, va_list * va)
4606 u32 i = va_arg (*va, u32);
4611 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
4615 return format (s, "ILLEGAL");
4617 s = format (s, "%s", t);
4622 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
4624 vat_main_t *vam = &vat_main;
4625 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
4627 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4628 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4630 conform_dscp_str = format (0, "");
4632 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4633 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4635 exceed_dscp_str = format (0, "");
4637 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4638 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4640 violate_dscp_str = format (0, "");
4642 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
4643 "rate type %U, round type %U, %s rate, %s color-aware, "
4644 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
4645 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
4646 "conform action %U%s, exceed action %U%s, violate action %U%s",
4648 format_policer_type, mp->type,
4651 clib_net_to_host_u64 (mp->cb),
4652 clib_net_to_host_u64 (mp->eb),
4653 format_policer_rate_type, mp->rate_type,
4654 format_policer_round_type, mp->round_type,
4655 mp->single_rate ? "single" : "dual",
4656 mp->color_aware ? "is" : "not",
4657 ntohl (mp->cir_tokens_per_period),
4658 ntohl (mp->pir_tokens_per_period),
4660 ntohl (mp->current_limit),
4661 ntohl (mp->current_bucket),
4662 ntohl (mp->extended_limit),
4663 ntohl (mp->extended_bucket),
4664 clib_net_to_host_u64 (mp->last_update_time),
4665 format_policer_action_type, mp->conform_action_type,
4667 format_policer_action_type, mp->exceed_action_type,
4669 format_policer_action_type, mp->violate_action_type,
4672 vec_free (conform_dscp_str);
4673 vec_free (exceed_dscp_str);
4674 vec_free (violate_dscp_str);
4677 static void vl_api_policer_details_t_handler_json
4678 (vl_api_policer_details_t * mp)
4680 vat_main_t *vam = &vat_main;
4681 vat_json_node_t *node;
4682 u8 *rate_type_str, *round_type_str, *type_str;
4683 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
4685 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
4687 format (0, "%U", format_policer_round_type, mp->round_type);
4688 type_str = format (0, "%U", format_policer_type, mp->type);
4689 conform_action_str = format (0, "%U", format_policer_action_type,
4690 mp->conform_action_type);
4691 exceed_action_str = format (0, "%U", format_policer_action_type,
4692 mp->exceed_action_type);
4693 violate_action_str = format (0, "%U", format_policer_action_type,
4694 mp->violate_action_type);
4696 if (VAT_JSON_ARRAY != vam->json_tree.type)
4698 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4699 vat_json_init_array (&vam->json_tree);
4701 node = vat_json_array_add (&vam->json_tree);
4703 vat_json_init_object (node);
4704 vat_json_object_add_string_copy (node, "name", mp->name);
4705 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
4706 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
4707 vat_json_object_add_uint (node, "cb", clib_net_to_host_u64 (mp->cb));
4708 vat_json_object_add_uint (node, "eb", clib_net_to_host_u64 (mp->eb));
4709 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
4710 vat_json_object_add_string_copy (node, "round_type", round_type_str);
4711 vat_json_object_add_string_copy (node, "type", type_str);
4712 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
4713 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
4714 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
4715 vat_json_object_add_uint (node, "cir_tokens_per_period",
4716 ntohl (mp->cir_tokens_per_period));
4717 vat_json_object_add_uint (node, "eir_tokens_per_period",
4718 ntohl (mp->pir_tokens_per_period));
4719 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
4720 vat_json_object_add_uint (node, "current_bucket",
4721 ntohl (mp->current_bucket));
4722 vat_json_object_add_uint (node, "extended_limit",
4723 ntohl (mp->extended_limit));
4724 vat_json_object_add_uint (node, "extended_bucket",
4725 ntohl (mp->extended_bucket));
4726 vat_json_object_add_uint (node, "last_update_time",
4727 ntohl (mp->last_update_time));
4728 vat_json_object_add_string_copy (node, "conform_action",
4729 conform_action_str);
4730 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4732 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4733 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
4734 vec_free (dscp_str);
4736 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
4737 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4739 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4740 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
4741 vec_free (dscp_str);
4743 vat_json_object_add_string_copy (node, "violate_action",
4744 violate_action_str);
4745 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4747 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4748 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
4749 vec_free (dscp_str);
4752 vec_free (rate_type_str);
4753 vec_free (round_type_str);
4754 vec_free (type_str);
4755 vec_free (conform_action_str);
4756 vec_free (exceed_action_str);
4757 vec_free (violate_action_str);
4761 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
4764 vat_main_t *vam = &vat_main;
4765 int i, count = ntohl (mp->count);
4768 print (vam->ofp, "classify table ids (%d) : ", count);
4769 for (i = 0; i < count; i++)
4771 print (vam->ofp, "%d", ntohl (mp->ids[i]));
4772 print (vam->ofp, (i < count - 1) ? "," : "");
4774 vam->retval = ntohl (mp->retval);
4775 vam->result_ready = 1;
4779 vl_api_classify_table_ids_reply_t_handler_json
4780 (vl_api_classify_table_ids_reply_t * mp)
4782 vat_main_t *vam = &vat_main;
4783 int i, count = ntohl (mp->count);
4787 vat_json_node_t node;
4789 vat_json_init_object (&node);
4790 for (i = 0; i < count; i++)
4792 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
4794 vat_json_print (vam->ofp, &node);
4795 vat_json_free (&node);
4797 vam->retval = ntohl (mp->retval);
4798 vam->result_ready = 1;
4802 vl_api_classify_table_by_interface_reply_t_handler
4803 (vl_api_classify_table_by_interface_reply_t * mp)
4805 vat_main_t *vam = &vat_main;
4808 table_id = ntohl (mp->l2_table_id);
4810 print (vam->ofp, "l2 table id : %d", table_id);
4812 print (vam->ofp, "l2 table id : No input ACL tables configured");
4813 table_id = ntohl (mp->ip4_table_id);
4815 print (vam->ofp, "ip4 table id : %d", table_id);
4817 print (vam->ofp, "ip4 table id : No input ACL tables configured");
4818 table_id = ntohl (mp->ip6_table_id);
4820 print (vam->ofp, "ip6 table id : %d", table_id);
4822 print (vam->ofp, "ip6 table id : No input ACL tables configured");
4823 vam->retval = ntohl (mp->retval);
4824 vam->result_ready = 1;
4828 vl_api_classify_table_by_interface_reply_t_handler_json
4829 (vl_api_classify_table_by_interface_reply_t * mp)
4831 vat_main_t *vam = &vat_main;
4832 vat_json_node_t node;
4834 vat_json_init_object (&node);
4836 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
4837 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
4838 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
4840 vat_json_print (vam->ofp, &node);
4841 vat_json_free (&node);
4843 vam->retval = ntohl (mp->retval);
4844 vam->result_ready = 1;
4847 static void vl_api_policer_add_del_reply_t_handler
4848 (vl_api_policer_add_del_reply_t * mp)
4850 vat_main_t *vam = &vat_main;
4851 i32 retval = ntohl (mp->retval);
4852 if (vam->async_mode)
4854 vam->async_errors += (retval < 0);
4858 vam->retval = retval;
4859 vam->result_ready = 1;
4860 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
4862 * Note: this is just barely thread-safe, depends on
4863 * the main thread spinning waiting for an answer...
4865 errmsg ("policer index %d", ntohl (mp->policer_index));
4869 static void vl_api_policer_add_del_reply_t_handler_json
4870 (vl_api_policer_add_del_reply_t * mp)
4872 vat_main_t *vam = &vat_main;
4873 vat_json_node_t node;
4875 vat_json_init_object (&node);
4876 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
4877 vat_json_object_add_uint (&node, "policer_index",
4878 ntohl (mp->policer_index));
4880 vat_json_print (vam->ofp, &node);
4881 vat_json_free (&node);
4883 vam->retval = ntohl (mp->retval);
4884 vam->result_ready = 1;
4887 /* Format hex dump. */
4889 format_hex_bytes (u8 * s, va_list * va)
4891 u8 *bytes = va_arg (*va, u8 *);
4892 int n_bytes = va_arg (*va, int);
4895 /* Print short or long form depending on byte count. */
4896 uword short_form = n_bytes <= 32;
4897 u32 indent = format_get_indent (s);
4902 for (i = 0; i < n_bytes; i++)
4904 if (!short_form && (i % 32) == 0)
4905 s = format (s, "%08x: ", i);
4906 s = format (s, "%02x", bytes[i]);
4907 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
4908 s = format (s, "\n%U", format_white_space, indent);
4915 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
4918 vat_main_t *vam = &vat_main;
4919 i32 retval = ntohl (mp->retval);
4922 print (vam->ofp, "classify table info :");
4923 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
4924 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
4925 ntohl (mp->miss_next_index));
4926 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
4927 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
4928 ntohl (mp->match_n_vectors));
4929 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
4930 ntohl (mp->mask_length));
4932 vam->retval = retval;
4933 vam->result_ready = 1;
4937 vl_api_classify_table_info_reply_t_handler_json
4938 (vl_api_classify_table_info_reply_t * mp)
4940 vat_main_t *vam = &vat_main;
4941 vat_json_node_t node;
4943 i32 retval = ntohl (mp->retval);
4946 vat_json_init_object (&node);
4948 vat_json_object_add_int (&node, "sessions",
4949 ntohl (mp->active_sessions));
4950 vat_json_object_add_int (&node, "nexttbl",
4951 ntohl (mp->next_table_index));
4952 vat_json_object_add_int (&node, "nextnode",
4953 ntohl (mp->miss_next_index));
4954 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
4955 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
4956 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
4957 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
4958 ntohl (mp->mask_length), 0);
4959 vat_json_object_add_string_copy (&node, "mask", s);
4961 vat_json_print (vam->ofp, &node);
4962 vat_json_free (&node);
4964 vam->retval = ntohl (mp->retval);
4965 vam->result_ready = 1;
4969 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
4972 vat_main_t *vam = &vat_main;
4974 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
4975 ntohl (mp->hit_next_index), ntohl (mp->advance),
4976 ntohl (mp->opaque_index));
4977 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
4978 ntohl (mp->match_length));
4982 vl_api_classify_session_details_t_handler_json
4983 (vl_api_classify_session_details_t * mp)
4985 vat_main_t *vam = &vat_main;
4986 vat_json_node_t *node = NULL;
4988 if (VAT_JSON_ARRAY != vam->json_tree.type)
4990 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4991 vat_json_init_array (&vam->json_tree);
4993 node = vat_json_array_add (&vam->json_tree);
4995 vat_json_init_object (node);
4996 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
4997 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
4998 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
5000 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
5002 vat_json_object_add_string_copy (node, "match", s);
5005 static void vl_api_pg_create_interface_reply_t_handler
5006 (vl_api_pg_create_interface_reply_t * mp)
5008 vat_main_t *vam = &vat_main;
5010 vam->retval = ntohl (mp->retval);
5011 vam->result_ready = 1;
5014 static void vl_api_pg_create_interface_reply_t_handler_json
5015 (vl_api_pg_create_interface_reply_t * mp)
5017 vat_main_t *vam = &vat_main;
5018 vat_json_node_t node;
5020 i32 retval = ntohl (mp->retval);
5023 vat_json_init_object (&node);
5025 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
5027 vat_json_print (vam->ofp, &node);
5028 vat_json_free (&node);
5030 vam->retval = ntohl (mp->retval);
5031 vam->result_ready = 1;
5034 static void vl_api_policer_classify_details_t_handler
5035 (vl_api_policer_classify_details_t * mp)
5037 vat_main_t *vam = &vat_main;
5039 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
5040 ntohl (mp->table_index));
5043 static void vl_api_policer_classify_details_t_handler_json
5044 (vl_api_policer_classify_details_t * mp)
5046 vat_main_t *vam = &vat_main;
5047 vat_json_node_t *node;
5049 if (VAT_JSON_ARRAY != vam->json_tree.type)
5051 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5052 vat_json_init_array (&vam->json_tree);
5054 node = vat_json_array_add (&vam->json_tree);
5056 vat_json_init_object (node);
5057 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5058 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5061 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler
5062 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
5064 vat_main_t *vam = &vat_main;
5065 i32 retval = ntohl (mp->retval);
5066 if (vam->async_mode)
5068 vam->async_errors += (retval < 0);
5072 vam->retval = retval;
5073 vam->sw_if_index = ntohl (mp->sw_if_index);
5074 vam->result_ready = 1;
5076 vam->regenerate_interface_table = 1;
5079 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler_json
5080 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
5082 vat_main_t *vam = &vat_main;
5083 vat_json_node_t node;
5085 vat_json_init_object (&node);
5086 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
5087 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
5089 vat_json_print (vam->ofp, &node);
5090 vat_json_free (&node);
5092 vam->retval = ntohl (mp->retval);
5093 vam->result_ready = 1;
5096 static void vl_api_flow_classify_details_t_handler
5097 (vl_api_flow_classify_details_t * mp)
5099 vat_main_t *vam = &vat_main;
5101 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
5102 ntohl (mp->table_index));
5105 static void vl_api_flow_classify_details_t_handler_json
5106 (vl_api_flow_classify_details_t * mp)
5108 vat_main_t *vam = &vat_main;
5109 vat_json_node_t *node;
5111 if (VAT_JSON_ARRAY != vam->json_tree.type)
5113 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5114 vat_json_init_array (&vam->json_tree);
5116 node = vat_json_array_add (&vam->json_tree);
5118 vat_json_init_object (node);
5119 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5120 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5123 #define vl_api_one_adjacencies_get_reply_t_endian vl_noop_handler
5124 #define vl_api_one_adjacencies_get_reply_t_print vl_noop_handler
5125 #define vl_api_one_l2_arp_bd_get_reply_t_print vl_noop_handler
5126 #define vl_api_one_l2_arp_entries_get_reply_t_endian vl_noop_handler
5127 #define vl_api_one_l2_arp_entries_get_reply_t_print vl_noop_handler
5128 #define vl_api_one_l2_arp_bd_get_reply_t_endian vl_noop_handler
5129 #define vl_api_one_ndp_bd_get_reply_t_endian vl_noop_handler
5130 #define vl_api_one_ndp_bd_get_reply_t_print vl_noop_handler
5131 #define vl_api_one_ndp_entries_get_reply_t_print vl_noop_handler
5132 #define vl_api_one_ndp_entries_get_reply_t_endian vl_noop_handler
5135 * Generate boilerplate reply handlers, which
5136 * dig the return value out of the xxx_reply_t API message,
5137 * stick it into vam->retval, and set vam->result_ready
5139 * Could also do this by pointing N message decode slots at
5140 * a single function, but that could break in subtle ways.
5143 #define foreach_standard_reply_retval_handler \
5144 _(sw_interface_set_flags_reply) \
5145 _(sw_interface_add_del_address_reply) \
5146 _(sw_interface_set_rx_mode_reply) \
5147 _(sw_interface_set_rx_placement_reply) \
5148 _(sw_interface_set_table_reply) \
5149 _(sw_interface_set_mpls_enable_reply) \
5150 _(sw_interface_set_vpath_reply) \
5151 _(sw_interface_set_vxlan_bypass_reply) \
5152 _(sw_interface_set_geneve_bypass_reply) \
5153 _(sw_interface_set_vxlan_gpe_bypass_reply) \
5154 _(sw_interface_set_l2_bridge_reply) \
5155 _(bridge_domain_add_del_reply) \
5156 _(sw_interface_set_l2_xconnect_reply) \
5157 _(l2fib_add_del_reply) \
5158 _(l2fib_flush_int_reply) \
5159 _(l2fib_flush_bd_reply) \
5160 _(ip_add_del_route_reply) \
5161 _(ip_table_add_del_reply) \
5162 _(ip_mroute_add_del_reply) \
5163 _(mpls_route_add_del_reply) \
5164 _(mpls_table_add_del_reply) \
5165 _(mpls_ip_bind_unbind_reply) \
5166 _(bier_route_add_del_reply) \
5167 _(bier_table_add_del_reply) \
5168 _(proxy_arp_add_del_reply) \
5169 _(proxy_arp_intfc_enable_disable_reply) \
5170 _(sw_interface_set_unnumbered_reply) \
5171 _(ip_neighbor_add_del_reply) \
5172 _(oam_add_del_reply) \
5173 _(reset_fib_reply) \
5174 _(dhcp_proxy_config_reply) \
5175 _(dhcp_proxy_set_vss_reply) \
5176 _(dhcp_client_config_reply) \
5177 _(set_ip_flow_hash_reply) \
5178 _(sw_interface_ip6_enable_disable_reply) \
5179 _(ip6nd_proxy_add_del_reply) \
5180 _(sw_interface_ip6nd_ra_prefix_reply) \
5181 _(sw_interface_ip6nd_ra_config_reply) \
5182 _(set_arp_neighbor_limit_reply) \
5183 _(l2_patch_add_del_reply) \
5184 _(sr_mpls_policy_add_reply) \
5185 _(sr_mpls_policy_mod_reply) \
5186 _(sr_mpls_policy_del_reply) \
5187 _(sr_policy_add_reply) \
5188 _(sr_policy_mod_reply) \
5189 _(sr_policy_del_reply) \
5190 _(sr_localsid_add_del_reply) \
5191 _(sr_steering_add_del_reply) \
5192 _(classify_add_del_session_reply) \
5193 _(classify_set_interface_ip_table_reply) \
5194 _(classify_set_interface_l2_tables_reply) \
5195 _(l2tpv3_set_tunnel_cookies_reply) \
5196 _(l2tpv3_interface_enable_disable_reply) \
5197 _(l2tpv3_set_lookup_key_reply) \
5198 _(l2_fib_clear_table_reply) \
5199 _(l2_interface_efp_filter_reply) \
5200 _(l2_interface_vlan_tag_rewrite_reply) \
5201 _(modify_vhost_user_if_reply) \
5202 _(delete_vhost_user_if_reply) \
5203 _(ip_probe_neighbor_reply) \
5204 _(ip_scan_neighbor_enable_disable_reply) \
5205 _(want_ip4_arp_events_reply) \
5206 _(want_ip6_nd_events_reply) \
5207 _(want_l2_macs_events_reply) \
5208 _(input_acl_set_interface_reply) \
5209 _(ipsec_spd_add_del_reply) \
5210 _(ipsec_interface_add_del_spd_reply) \
5211 _(ipsec_spd_add_del_entry_reply) \
5212 _(ipsec_sad_add_del_entry_reply) \
5213 _(ipsec_sa_set_key_reply) \
5214 _(ipsec_tunnel_if_add_del_reply) \
5215 _(ipsec_tunnel_if_set_key_reply) \
5216 _(ipsec_tunnel_if_set_sa_reply) \
5217 _(ikev2_profile_add_del_reply) \
5218 _(ikev2_profile_set_auth_reply) \
5219 _(ikev2_profile_set_id_reply) \
5220 _(ikev2_profile_set_ts_reply) \
5221 _(ikev2_set_local_key_reply) \
5222 _(ikev2_set_responder_reply) \
5223 _(ikev2_set_ike_transforms_reply) \
5224 _(ikev2_set_esp_transforms_reply) \
5225 _(ikev2_set_sa_lifetime_reply) \
5226 _(ikev2_initiate_sa_init_reply) \
5227 _(ikev2_initiate_del_ike_sa_reply) \
5228 _(ikev2_initiate_del_child_sa_reply) \
5229 _(ikev2_initiate_rekey_child_sa_reply) \
5230 _(delete_loopback_reply) \
5231 _(bd_ip_mac_add_del_reply) \
5232 _(bd_ip_mac_flush_reply) \
5233 _(want_interface_events_reply) \
5234 _(cop_interface_enable_disable_reply) \
5235 _(cop_whitelist_enable_disable_reply) \
5236 _(sw_interface_clear_stats_reply) \
5237 _(ioam_enable_reply) \
5238 _(ioam_disable_reply) \
5239 _(one_add_del_locator_reply) \
5240 _(one_add_del_local_eid_reply) \
5241 _(one_add_del_remote_mapping_reply) \
5242 _(one_add_del_adjacency_reply) \
5243 _(one_add_del_map_resolver_reply) \
5244 _(one_add_del_map_server_reply) \
5245 _(one_enable_disable_reply) \
5246 _(one_rloc_probe_enable_disable_reply) \
5247 _(one_map_register_enable_disable_reply) \
5248 _(one_map_register_set_ttl_reply) \
5249 _(one_set_transport_protocol_reply) \
5250 _(one_map_register_fallback_threshold_reply) \
5251 _(one_pitr_set_locator_set_reply) \
5252 _(one_map_request_mode_reply) \
5253 _(one_add_del_map_request_itr_rlocs_reply) \
5254 _(one_eid_table_add_del_map_reply) \
5255 _(one_use_petr_reply) \
5256 _(one_stats_enable_disable_reply) \
5257 _(one_add_del_l2_arp_entry_reply) \
5258 _(one_add_del_ndp_entry_reply) \
5259 _(one_stats_flush_reply) \
5260 _(one_enable_disable_xtr_mode_reply) \
5261 _(one_enable_disable_pitr_mode_reply) \
5262 _(one_enable_disable_petr_mode_reply) \
5263 _(gpe_enable_disable_reply) \
5264 _(gpe_set_encap_mode_reply) \
5265 _(gpe_add_del_iface_reply) \
5266 _(gpe_add_del_native_fwd_rpath_reply) \
5267 _(af_packet_delete_reply) \
5268 _(policer_classify_set_interface_reply) \
5269 _(netmap_create_reply) \
5270 _(netmap_delete_reply) \
5271 _(set_ipfix_exporter_reply) \
5272 _(set_ipfix_classify_stream_reply) \
5273 _(ipfix_classify_table_add_del_reply) \
5274 _(flow_classify_set_interface_reply) \
5275 _(sw_interface_span_enable_disable_reply) \
5276 _(pg_capture_reply) \
5277 _(pg_enable_disable_reply) \
5278 _(ip_source_and_port_range_check_add_del_reply) \
5279 _(ip_source_and_port_range_check_interface_add_del_reply)\
5280 _(delete_subif_reply) \
5281 _(l2_interface_pbb_tag_rewrite_reply) \
5283 _(feature_enable_disable_reply) \
5284 _(sw_interface_tag_add_del_reply) \
5285 _(hw_interface_set_mtu_reply) \
5286 _(p2p_ethernet_add_reply) \
5287 _(p2p_ethernet_del_reply) \
5288 _(lldp_config_reply) \
5289 _(sw_interface_set_lldp_reply) \
5290 _(tcp_configure_src_addresses_reply) \
5291 _(dns_enable_disable_reply) \
5292 _(dns_name_server_add_del_reply) \
5293 _(session_rule_add_del_reply) \
5294 _(ip_container_proxy_add_del_reply) \
5295 _(output_acl_set_interface_reply) \
5296 _(qos_record_enable_disable_reply)
5299 static void vl_api_##n##_t_handler \
5300 (vl_api_##n##_t * mp) \
5302 vat_main_t * vam = &vat_main; \
5303 i32 retval = ntohl(mp->retval); \
5304 if (vam->async_mode) { \
5305 vam->async_errors += (retval < 0); \
5307 vam->retval = retval; \
5308 vam->result_ready = 1; \
5311 foreach_standard_reply_retval_handler;
5315 static void vl_api_##n##_t_handler_json \
5316 (vl_api_##n##_t * mp) \
5318 vat_main_t * vam = &vat_main; \
5319 vat_json_node_t node; \
5320 vat_json_init_object(&node); \
5321 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
5322 vat_json_print(vam->ofp, &node); \
5323 vam->retval = ntohl(mp->retval); \
5324 vam->result_ready = 1; \
5326 foreach_standard_reply_retval_handler;
5330 * Table of message reply handlers, must include boilerplate handlers
5334 #define foreach_vpe_api_reply_msg \
5335 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
5336 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
5337 _(SW_INTERFACE_DETAILS, sw_interface_details) \
5338 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
5339 _(CONTROL_PING_REPLY, control_ping_reply) \
5340 _(CLI_REPLY, cli_reply) \
5341 _(CLI_INBAND_REPLY, cli_inband_reply) \
5342 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
5343 sw_interface_add_del_address_reply) \
5344 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
5345 _(SW_INTERFACE_SET_RX_PLACEMENT_REPLY, sw_interface_set_rx_placement_reply) \
5346 _(SW_INTERFACE_RX_PLACEMENT_DETAILS, sw_interface_rx_placement_details) \
5347 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
5348 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
5349 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
5350 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
5351 _(SW_INTERFACE_SET_GENEVE_BYPASS_REPLY, sw_interface_set_geneve_bypass_reply) \
5352 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
5353 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
5354 sw_interface_set_l2_xconnect_reply) \
5355 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
5356 sw_interface_set_l2_bridge_reply) \
5357 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
5358 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
5359 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
5360 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
5361 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
5362 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
5363 _(L2_FLAGS_REPLY, l2_flags_reply) \
5364 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
5365 _(TAP_CREATE_V2_REPLY, tap_create_v2_reply) \
5366 _(TAP_DELETE_V2_REPLY, tap_delete_v2_reply) \
5367 _(SW_INTERFACE_TAP_V2_DETAILS, sw_interface_tap_v2_details) \
5368 _(VIRTIO_PCI_CREATE_REPLY, virtio_pci_create_reply) \
5369 _(VIRTIO_PCI_DELETE_REPLY, virtio_pci_delete_reply) \
5370 _(SW_INTERFACE_VIRTIO_PCI_DETAILS, sw_interface_virtio_pci_details) \
5371 _(BOND_CREATE_REPLY, bond_create_reply) \
5372 _(BOND_DELETE_REPLY, bond_delete_reply) \
5373 _(BOND_ENSLAVE_REPLY, bond_enslave_reply) \
5374 _(BOND_DETACH_SLAVE_REPLY, bond_detach_slave_reply) \
5375 _(SW_INTERFACE_BOND_DETAILS, sw_interface_bond_details) \
5376 _(SW_INTERFACE_SLAVE_DETAILS, sw_interface_slave_details) \
5377 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
5378 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
5379 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
5380 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
5381 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
5382 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
5383 _(BIER_ROUTE_ADD_DEL_REPLY, bier_route_add_del_reply) \
5384 _(BIER_TABLE_ADD_DEL_REPLY, bier_table_add_del_reply) \
5385 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
5386 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
5387 proxy_arp_intfc_enable_disable_reply) \
5388 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
5389 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
5390 sw_interface_set_unnumbered_reply) \
5391 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
5392 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
5393 _(CREATE_SUBIF_REPLY, create_subif_reply) \
5394 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
5395 _(RESET_FIB_REPLY, reset_fib_reply) \
5396 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
5397 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
5398 _(DHCP_PROXY_DETAILS, dhcp_proxy_details) \
5399 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
5400 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
5401 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
5402 sw_interface_ip6_enable_disable_reply) \
5403 _(IP6ND_PROXY_ADD_DEL_REPLY, ip6nd_proxy_add_del_reply) \
5404 _(IP6ND_PROXY_DETAILS, ip6nd_proxy_details) \
5405 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
5406 sw_interface_ip6nd_ra_prefix_reply) \
5407 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
5408 sw_interface_ip6nd_ra_config_reply) \
5409 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
5410 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
5411 _(SR_MPLS_POLICY_ADD_REPLY, sr_mpls_policy_add_reply) \
5412 _(SR_MPLS_POLICY_MOD_REPLY, sr_mpls_policy_mod_reply) \
5413 _(SR_MPLS_POLICY_DEL_REPLY, sr_mpls_policy_del_reply) \
5414 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
5415 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
5416 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
5417 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
5418 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
5419 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
5420 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
5421 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
5422 classify_set_interface_ip_table_reply) \
5423 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
5424 classify_set_interface_l2_tables_reply) \
5425 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
5426 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
5427 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
5428 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
5429 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
5430 l2tpv3_interface_enable_disable_reply) \
5431 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
5432 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
5433 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
5434 _(VXLAN_OFFLOAD_RX_REPLY, vxlan_offload_rx_reply) \
5435 _(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
5436 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
5437 _(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
5438 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
5439 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
5440 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
5441 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
5442 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
5443 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
5444 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
5445 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
5446 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
5447 _(SHOW_VERSION_REPLY, show_version_reply) \
5448 _(SHOW_THREADS_REPLY, show_threads_reply) \
5449 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
5450 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
5451 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
5452 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
5453 _(IP_PROBE_NEIGHBOR_REPLY, ip_probe_neighbor_reply) \
5454 _(IP_SCAN_NEIGHBOR_ENABLE_DISABLE_REPLY, ip_scan_neighbor_enable_disable_reply) \
5455 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
5456 _(IP4_ARP_EVENT, ip4_arp_event) \
5457 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
5458 _(IP6_ND_EVENT, ip6_nd_event) \
5459 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
5460 _(L2_MACS_EVENT, l2_macs_event) \
5461 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
5462 _(IP_ADDRESS_DETAILS, ip_address_details) \
5463 _(IP_DETAILS, ip_details) \
5464 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
5465 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
5466 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
5467 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
5468 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
5469 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
5470 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
5471 _(IPSEC_TUNNEL_IF_SET_KEY_REPLY, ipsec_tunnel_if_set_key_reply) \
5472 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
5473 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
5474 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
5475 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
5476 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
5477 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
5478 _(IKEV2_SET_RESPONDER_REPLY, ikev2_set_responder_reply) \
5479 _(IKEV2_SET_IKE_TRANSFORMS_REPLY, ikev2_set_ike_transforms_reply) \
5480 _(IKEV2_SET_ESP_TRANSFORMS_REPLY, ikev2_set_esp_transforms_reply) \
5481 _(IKEV2_SET_SA_LIFETIME_REPLY, ikev2_set_sa_lifetime_reply) \
5482 _(IKEV2_INITIATE_SA_INIT_REPLY, ikev2_initiate_sa_init_reply) \
5483 _(IKEV2_INITIATE_DEL_IKE_SA_REPLY, ikev2_initiate_del_ike_sa_reply) \
5484 _(IKEV2_INITIATE_DEL_CHILD_SA_REPLY, ikev2_initiate_del_child_sa_reply) \
5485 _(IKEV2_INITIATE_REKEY_CHILD_SA_REPLY, ikev2_initiate_rekey_child_sa_reply) \
5486 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
5487 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
5488 _(BD_IP_MAC_FLUSH_REPLY, bd_ip_mac_flush_reply) \
5489 _(BD_IP_MAC_DETAILS, bd_ip_mac_details) \
5490 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
5491 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
5492 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
5493 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
5494 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
5495 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
5496 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
5497 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
5498 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
5499 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
5500 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
5501 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
5502 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
5503 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
5504 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
5505 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
5506 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
5507 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
5508 one_map_register_enable_disable_reply) \
5509 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
5510 _(ONE_SET_TRANSPORT_PROTOCOL_REPLY, one_set_transport_protocol_reply) \
5511 _(ONE_GET_TRANSPORT_PROTOCOL_REPLY, one_get_transport_protocol_reply) \
5512 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5513 one_map_register_fallback_threshold_reply) \
5514 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
5515 one_rloc_probe_enable_disable_reply) \
5516 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
5517 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
5518 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
5519 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
5520 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
5521 _(ONE_LOCATOR_DETAILS, one_locator_details) \
5522 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
5523 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
5524 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
5525 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
5526 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
5527 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
5528 _(ONE_STATS_DETAILS, one_stats_details) \
5529 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
5530 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
5531 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
5532 show_one_stats_enable_disable_reply) \
5533 _(ONE_ADD_DEL_NDP_ENTRY_REPLY, one_add_del_ndp_entry_reply) \
5534 _(ONE_NDP_BD_GET_REPLY, one_ndp_bd_get_reply) \
5535 _(ONE_NDP_ENTRIES_GET_REPLY, one_ndp_entries_get_reply) \
5536 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
5537 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
5538 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
5539 _(ONE_ENABLE_DISABLE_XTR_MODE_REPLY, one_enable_disable_xtr_mode_reply) \
5540 _(ONE_ENABLE_DISABLE_PITR_MODE_REPLY, \
5541 one_enable_disable_pitr_mode_reply) \
5542 _(ONE_ENABLE_DISABLE_PETR_MODE_REPLY, \
5543 one_enable_disable_petr_mode_reply) \
5544 _(ONE_SHOW_XTR_MODE_REPLY, one_show_xtr_mode_reply) \
5545 _(ONE_SHOW_PITR_MODE_REPLY, one_show_pitr_mode_reply) \
5546 _(ONE_SHOW_PETR_MODE_REPLY, one_show_petr_mode_reply) \
5547 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
5548 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
5549 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
5550 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
5551 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
5552 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
5553 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
5554 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
5555 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
5556 gpe_add_del_native_fwd_rpath_reply) \
5557 _(GPE_FWD_ENTRY_PATH_DETAILS, \
5558 gpe_fwd_entry_path_details) \
5559 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
5560 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
5561 one_add_del_map_request_itr_rlocs_reply) \
5562 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
5563 one_get_map_request_itr_rlocs_reply) \
5564 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
5565 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
5566 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
5567 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
5568 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
5569 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
5570 show_one_map_register_state_reply) \
5571 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
5572 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5573 show_one_map_register_fallback_threshold_reply) \
5574 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
5575 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
5576 _(AF_PACKET_DETAILS, af_packet_details) \
5577 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
5578 _(POLICER_DETAILS, policer_details) \
5579 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
5580 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
5581 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
5582 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
5583 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
5584 _(MPLS_FIB_DETAILS, mpls_fib_details) \
5585 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
5586 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
5587 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
5588 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
5589 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
5590 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
5591 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
5592 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5593 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5594 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5595 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5596 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5597 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5598 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5599 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5600 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5601 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5602 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5603 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5604 ip_source_and_port_range_check_add_del_reply) \
5605 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5606 ip_source_and_port_range_check_interface_add_del_reply) \
5607 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
5608 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
5609 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5610 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5611 _(SET_PUNT_REPLY, set_punt_reply) \
5612 _(IP_FIB_DETAILS, ip_fib_details) \
5613 _(IP6_FIB_DETAILS, ip6_fib_details) \
5614 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5615 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5616 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5617 _(HW_INTERFACE_SET_MTU_REPLY, hw_interface_set_mtu_reply) \
5618 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
5619 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5620 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5621 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5622 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5623 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply) \
5624 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
5625 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
5626 _(DNS_ENABLE_DISABLE_REPLY, dns_enable_disable_reply) \
5627 _(DNS_NAME_SERVER_ADD_DEL_REPLY, dns_name_server_add_del_reply) \
5628 _(DNS_RESOLVE_NAME_REPLY, dns_resolve_name_reply) \
5629 _(DNS_RESOLVE_IP_REPLY, dns_resolve_ip_reply) \
5630 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
5631 _(SESSION_RULES_DETAILS, session_rules_details) \
5632 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
5633 _(OUTPUT_ACL_SET_INTERFACE_REPLY, output_acl_set_interface_reply) \
5634 _(QOS_RECORD_ENABLE_DISABLE_REPLY, qos_record_enable_disable_reply)
5636 #define foreach_standalone_reply_msg \
5637 _(SW_INTERFACE_EVENT, sw_interface_event)
5645 #define STR_VTR_OP_CASE(op) \
5646 case L2_VTR_ ## op: \
5650 str_vtr_op (u32 vtr_op)
5654 STR_VTR_OP_CASE (DISABLED);
5655 STR_VTR_OP_CASE (PUSH_1);
5656 STR_VTR_OP_CASE (PUSH_2);
5657 STR_VTR_OP_CASE (POP_1);
5658 STR_VTR_OP_CASE (POP_2);
5659 STR_VTR_OP_CASE (TRANSLATE_1_1);
5660 STR_VTR_OP_CASE (TRANSLATE_1_2);
5661 STR_VTR_OP_CASE (TRANSLATE_2_1);
5662 STR_VTR_OP_CASE (TRANSLATE_2_2);
5669 dump_sub_interface_table (vat_main_t * vam)
5671 const sw_interface_subif_t *sub = NULL;
5673 if (vam->json_output)
5676 ("JSON output supported only for VPE API calls and dump_stats_table");
5681 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5682 "Interface", "sw_if_index",
5683 "sub id", "dot1ad", "tags", "outer id",
5684 "inner id", "exact", "default", "outer any", "inner any");
5686 vec_foreach (sub, vam->sw_if_subif_table)
5689 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5690 sub->interface_name,
5692 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5693 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5694 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5695 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5696 if (sub->vtr_op != L2_VTR_DISABLED)
5699 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
5700 "tag1: %d tag2: %d ]",
5701 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
5702 sub->vtr_tag1, sub->vtr_tag2);
5710 name_sort_cmp (void *a1, void *a2)
5712 name_sort_t *n1 = a1;
5713 name_sort_t *n2 = a2;
5715 return strcmp ((char *) n1->name, (char *) n2->name);
5719 dump_interface_table (vat_main_t * vam)
5722 name_sort_t *nses = 0, *ns;
5724 if (vam->json_output)
5727 ("JSON output supported only for VPE API calls and dump_stats_table");
5732 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5734 vec_add2 (nses, ns, 1);
5735 ns->name = (u8 *)(p->key);
5736 ns->value = (u32) p->value[0];
5740 vec_sort_with_function (nses, name_sort_cmp);
5742 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
5743 vec_foreach (ns, nses)
5745 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
5752 dump_ip_table (vat_main_t * vam, int is_ipv6)
5754 const ip_details_t *det = NULL;
5755 const ip_address_details_t *address = NULL;
5758 print (vam->ofp, "%-12s", "sw_if_index");
5760 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
5767 print (vam->ofp, "%-12d", i);
5768 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
5773 vec_foreach (address, det->addr)
5777 is_ipv6 ? format_ip6_address : format_ip4_address,
5778 address->ip, address->prefix_length);
5786 dump_ipv4_table (vat_main_t * vam)
5788 if (vam->json_output)
5791 ("JSON output supported only for VPE API calls and dump_stats_table");
5795 return dump_ip_table (vam, 0);
5799 dump_ipv6_table (vat_main_t * vam)
5801 if (vam->json_output)
5804 ("JSON output supported only for VPE API calls and dump_stats_table");
5808 return dump_ip_table (vam, 1);
5812 * Pass CLI buffers directly in the CLI_INBAND API message,
5813 * instead of an additional shared memory area.
5816 exec_inband (vat_main_t * vam)
5818 vl_api_cli_inband_t *mp;
5819 unformat_input_t *i = vam->input;
5822 if (vec_len (i->buffer) == 0)
5825 if (vam->exec_mode == 0 && unformat (i, "mode"))
5830 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
5837 * In order for the CLI command to work, it
5838 * must be a vector ending in \n, not a C-string ending
5841 u32 len = vec_len (vam->input->buffer);
5842 M2 (CLI_INBAND, mp, len);
5843 vl_api_to_api_string (len - 1, (const char *) vam->input->buffer, &mp->cmd);
5847 /* json responses may or may not include a useful reply... */
5848 if (vec_len (vam->cmd_reply))
5849 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
5854 exec (vat_main_t * vam)
5856 return exec_inband (vam);
5860 api_create_loopback (vat_main_t * vam)
5862 unformat_input_t *i = vam->input;
5863 vl_api_create_loopback_t *mp;
5864 vl_api_create_loopback_instance_t *mp_lbi;
5867 u8 is_specified = 0;
5868 u32 user_instance = 0;
5871 clib_memset (mac_address, 0, sizeof (mac_address));
5873 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5875 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5877 if (unformat (i, "instance %d", &user_instance))
5885 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
5886 mp_lbi->is_specified = is_specified;
5888 mp_lbi->user_instance = htonl (user_instance);
5890 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
5895 /* Construct the API message */
5896 M (CREATE_LOOPBACK, mp);
5898 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
5907 api_delete_loopback (vat_main_t * vam)
5909 unformat_input_t *i = vam->input;
5910 vl_api_delete_loopback_t *mp;
5911 u32 sw_if_index = ~0;
5914 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5916 if (unformat (i, "sw_if_index %d", &sw_if_index))
5922 if (sw_if_index == ~0)
5924 errmsg ("missing sw_if_index");
5928 /* Construct the API message */
5929 M (DELETE_LOOPBACK, mp);
5930 mp->sw_if_index = ntohl (sw_if_index);
5938 api_want_interface_events (vat_main_t * vam)
5940 unformat_input_t *i = vam->input;
5941 vl_api_want_interface_events_t *mp;
5945 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5947 if (unformat (i, "enable"))
5949 else if (unformat (i, "disable"))
5957 errmsg ("missing enable|disable");
5961 M (WANT_INTERFACE_EVENTS, mp);
5962 mp->enable_disable = enable;
5964 vam->interface_event_display = enable;
5972 /* Note: non-static, called once to set up the initial intfc table */
5974 api_sw_interface_dump (vat_main_t * vam)
5976 vl_api_sw_interface_dump_t *mp;
5977 vl_api_control_ping_t *mp_ping;
5979 name_sort_t *nses = 0, *ns;
5980 sw_interface_subif_t *sub = NULL;
5983 /* Toss the old name table */
5985 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5987 vec_add2 (nses, ns, 1);
5988 ns->name = (u8 *)(p->key);
5989 ns->value = (u32) p->value[0];
5993 hash_free (vam->sw_if_index_by_interface_name);
5995 vec_foreach (ns, nses) vec_free (ns->name);
5999 vec_foreach (sub, vam->sw_if_subif_table)
6001 vec_free (sub->interface_name);
6003 vec_free (vam->sw_if_subif_table);
6005 /* recreate the interface name hash table */
6006 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
6009 * Ask for all interface names. Otherwise, the epic catalog of
6010 * name filters becomes ridiculously long, and vat ends up needing
6011 * to be taught about new interface types.
6013 M (SW_INTERFACE_DUMP, mp);
6016 /* Use a control ping for synchronization */
6017 MPING (CONTROL_PING, mp_ping);
6025 api_sw_interface_set_flags (vat_main_t * vam)
6027 unformat_input_t *i = vam->input;
6028 vl_api_sw_interface_set_flags_t *mp;
6030 u8 sw_if_index_set = 0;
6034 /* Parse args required to build the message */
6035 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6037 if (unformat (i, "admin-up"))
6039 else if (unformat (i, "admin-down"))
6042 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6043 sw_if_index_set = 1;
6044 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6045 sw_if_index_set = 1;
6050 if (sw_if_index_set == 0)
6052 errmsg ("missing interface name or sw_if_index");
6056 /* Construct the API message */
6057 M (SW_INTERFACE_SET_FLAGS, mp);
6058 mp->sw_if_index = ntohl (sw_if_index);
6059 mp->admin_up_down = admin_up;
6064 /* Wait for a reply, return the good/bad news... */
6070 api_sw_interface_set_rx_mode (vat_main_t * vam)
6072 unformat_input_t *i = vam->input;
6073 vl_api_sw_interface_set_rx_mode_t *mp;
6075 u8 sw_if_index_set = 0;
6077 u8 queue_id_valid = 0;
6079 vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN;
6081 /* Parse args required to build the message */
6082 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6084 if (unformat (i, "queue %d", &queue_id))
6086 else if (unformat (i, "polling"))
6087 mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
6088 else if (unformat (i, "interrupt"))
6089 mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT;
6090 else if (unformat (i, "adaptive"))
6091 mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE;
6093 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6094 sw_if_index_set = 1;
6095 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6096 sw_if_index_set = 1;
6101 if (sw_if_index_set == 0)
6103 errmsg ("missing interface name or sw_if_index");
6106 if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
6108 errmsg ("missing rx-mode");
6112 /* Construct the API message */
6113 M (SW_INTERFACE_SET_RX_MODE, mp);
6114 mp->sw_if_index = ntohl (sw_if_index);
6116 mp->queue_id_valid = queue_id_valid;
6117 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
6122 /* Wait for a reply, return the good/bad news... */
6128 api_sw_interface_set_rx_placement (vat_main_t * vam)
6130 unformat_input_t *i = vam->input;
6131 vl_api_sw_interface_set_rx_placement_t *mp;
6133 u8 sw_if_index_set = 0;
6136 u32 queue_id, thread_index;
6138 /* Parse args required to build the message */
6139 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6141 if (unformat (i, "queue %d", &queue_id))
6143 else if (unformat (i, "main"))
6145 else if (unformat (i, "worker %d", &thread_index))
6148 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6149 sw_if_index_set = 1;
6150 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6151 sw_if_index_set = 1;
6156 if (sw_if_index_set == 0)
6158 errmsg ("missing interface name or sw_if_index");
6164 /* Construct the API message */
6165 M (SW_INTERFACE_SET_RX_PLACEMENT, mp);
6166 mp->sw_if_index = ntohl (sw_if_index);
6167 mp->worker_id = ntohl (thread_index);
6168 mp->queue_id = ntohl (queue_id);
6169 mp->is_main = is_main;
6173 /* Wait for a reply, return the good/bad news... */
6178 static void vl_api_sw_interface_rx_placement_details_t_handler
6179 (vl_api_sw_interface_rx_placement_details_t * mp)
6181 vat_main_t *vam = &vat_main;
6182 u32 worker_id = ntohl (mp->worker_id);
6185 "\n%-11d %-11s %-6d %-5d %-9s",
6186 ntohl (mp->sw_if_index), (worker_id == 0) ? "main" : "worker",
6187 worker_id, ntohl (mp->queue_id),
6189 1) ? "polling" : ((mp->mode == 2) ? "interrupt" : "adaptive"));
6192 static void vl_api_sw_interface_rx_placement_details_t_handler_json
6193 (vl_api_sw_interface_rx_placement_details_t * mp)
6195 vat_main_t *vam = &vat_main;
6196 vat_json_node_t *node = NULL;
6198 if (VAT_JSON_ARRAY != vam->json_tree.type)
6200 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
6201 vat_json_init_array (&vam->json_tree);
6203 node = vat_json_array_add (&vam->json_tree);
6205 vat_json_init_object (node);
6206 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
6207 vat_json_object_add_uint (node, "worker_id", ntohl (mp->worker_id));
6208 vat_json_object_add_uint (node, "queue_id", ntohl (mp->queue_id));
6209 vat_json_object_add_uint (node, "mode", mp->mode);
6213 api_sw_interface_rx_placement_dump (vat_main_t * vam)
6215 unformat_input_t *i = vam->input;
6216 vl_api_sw_interface_rx_placement_dump_t *mp;
6217 vl_api_control_ping_t *mp_ping;
6220 u8 sw_if_index_set = 0;
6222 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6224 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6226 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6233 "\n%-11s %-11s %-6s %-5s %-4s",
6234 "sw_if_index", "main/worker", "thread", "queue", "mode");
6236 /* Dump Interface rx placement */
6237 M (SW_INTERFACE_RX_PLACEMENT_DUMP, mp);
6239 if (sw_if_index_set)
6240 mp->sw_if_index = htonl (sw_if_index);
6242 mp->sw_if_index = ~0;
6246 /* Use a control ping for synchronization */
6247 MPING (CONTROL_PING, mp_ping);
6255 api_sw_interface_clear_stats (vat_main_t * vam)
6257 unformat_input_t *i = vam->input;
6258 vl_api_sw_interface_clear_stats_t *mp;
6260 u8 sw_if_index_set = 0;
6263 /* Parse args required to build the message */
6264 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6266 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6267 sw_if_index_set = 1;
6268 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6269 sw_if_index_set = 1;
6274 /* Construct the API message */
6275 M (SW_INTERFACE_CLEAR_STATS, mp);
6277 if (sw_if_index_set == 1)
6278 mp->sw_if_index = ntohl (sw_if_index);
6280 mp->sw_if_index = ~0;
6285 /* Wait for a reply, return the good/bad news... */
6291 api_sw_interface_add_del_address (vat_main_t * vam)
6293 unformat_input_t *i = vam->input;
6294 vl_api_sw_interface_add_del_address_t *mp;
6296 u8 sw_if_index_set = 0;
6297 u8 is_add = 1, del_all = 0;
6298 u32 address_length = 0;
6299 u8 v4_address_set = 0;
6300 u8 v6_address_set = 0;
6301 ip4_address_t v4address;
6302 ip6_address_t v6address;
6305 /* Parse args required to build the message */
6306 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6308 if (unformat (i, "del-all"))
6310 else if (unformat (i, "del"))
6313 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6314 sw_if_index_set = 1;
6315 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6316 sw_if_index_set = 1;
6317 else if (unformat (i, "%U/%d",
6318 unformat_ip4_address, &v4address, &address_length))
6320 else if (unformat (i, "%U/%d",
6321 unformat_ip6_address, &v6address, &address_length))
6327 if (sw_if_index_set == 0)
6329 errmsg ("missing interface name or sw_if_index");
6332 if (v4_address_set && v6_address_set)
6334 errmsg ("both v4 and v6 addresses set");
6337 if (!v4_address_set && !v6_address_set && !del_all)
6339 errmsg ("no addresses set");
6343 /* Construct the API message */
6344 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
6346 mp->sw_if_index = ntohl (sw_if_index);
6347 mp->is_add = is_add;
6348 mp->del_all = del_all;
6352 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6356 clib_memcpy (mp->address, &v4address, sizeof (v4address));
6358 mp->address_length = address_length;
6363 /* Wait for a reply, return good/bad news */
6369 api_sw_interface_set_mpls_enable (vat_main_t * vam)
6371 unformat_input_t *i = vam->input;
6372 vl_api_sw_interface_set_mpls_enable_t *mp;
6374 u8 sw_if_index_set = 0;
6378 /* Parse args required to build the message */
6379 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6381 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6382 sw_if_index_set = 1;
6383 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6384 sw_if_index_set = 1;
6385 else if (unformat (i, "disable"))
6387 else if (unformat (i, "dis"))
6393 if (sw_if_index_set == 0)
6395 errmsg ("missing interface name or sw_if_index");
6399 /* Construct the API message */
6400 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
6402 mp->sw_if_index = ntohl (sw_if_index);
6403 mp->enable = enable;
6408 /* Wait for a reply... */
6414 api_sw_interface_set_table (vat_main_t * vam)
6416 unformat_input_t *i = vam->input;
6417 vl_api_sw_interface_set_table_t *mp;
6418 u32 sw_if_index, vrf_id = 0;
6419 u8 sw_if_index_set = 0;
6423 /* Parse args required to build the message */
6424 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6426 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6427 sw_if_index_set = 1;
6428 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6429 sw_if_index_set = 1;
6430 else if (unformat (i, "vrf %d", &vrf_id))
6432 else if (unformat (i, "ipv6"))
6438 if (sw_if_index_set == 0)
6440 errmsg ("missing interface name or sw_if_index");
6444 /* Construct the API message */
6445 M (SW_INTERFACE_SET_TABLE, mp);
6447 mp->sw_if_index = ntohl (sw_if_index);
6448 mp->is_ipv6 = is_ipv6;
6449 mp->vrf_id = ntohl (vrf_id);
6454 /* Wait for a reply... */
6459 static void vl_api_sw_interface_get_table_reply_t_handler
6460 (vl_api_sw_interface_get_table_reply_t * mp)
6462 vat_main_t *vam = &vat_main;
6464 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6466 vam->retval = ntohl (mp->retval);
6467 vam->result_ready = 1;
6471 static void vl_api_sw_interface_get_table_reply_t_handler_json
6472 (vl_api_sw_interface_get_table_reply_t * mp)
6474 vat_main_t *vam = &vat_main;
6475 vat_json_node_t node;
6477 vat_json_init_object (&node);
6478 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6479 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6481 vat_json_print (vam->ofp, &node);
6482 vat_json_free (&node);
6484 vam->retval = ntohl (mp->retval);
6485 vam->result_ready = 1;
6489 api_sw_interface_get_table (vat_main_t * vam)
6491 unformat_input_t *i = vam->input;
6492 vl_api_sw_interface_get_table_t *mp;
6494 u8 sw_if_index_set = 0;
6498 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6500 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6501 sw_if_index_set = 1;
6502 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6503 sw_if_index_set = 1;
6504 else if (unformat (i, "ipv6"))
6510 if (sw_if_index_set == 0)
6512 errmsg ("missing interface name or sw_if_index");
6516 M (SW_INTERFACE_GET_TABLE, mp);
6517 mp->sw_if_index = htonl (sw_if_index);
6518 mp->is_ipv6 = is_ipv6;
6526 api_sw_interface_set_vpath (vat_main_t * vam)
6528 unformat_input_t *i = vam->input;
6529 vl_api_sw_interface_set_vpath_t *mp;
6530 u32 sw_if_index = 0;
6531 u8 sw_if_index_set = 0;
6535 /* Parse args required to build the message */
6536 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6538 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6539 sw_if_index_set = 1;
6540 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6541 sw_if_index_set = 1;
6542 else if (unformat (i, "enable"))
6544 else if (unformat (i, "disable"))
6550 if (sw_if_index_set == 0)
6552 errmsg ("missing interface name or sw_if_index");
6556 /* Construct the API message */
6557 M (SW_INTERFACE_SET_VPATH, mp);
6559 mp->sw_if_index = ntohl (sw_if_index);
6560 mp->enable = is_enable;
6565 /* Wait for a reply... */
6571 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
6573 unformat_input_t *i = vam->input;
6574 vl_api_sw_interface_set_vxlan_bypass_t *mp;
6575 u32 sw_if_index = 0;
6576 u8 sw_if_index_set = 0;
6581 /* Parse args required to build the message */
6582 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6584 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6585 sw_if_index_set = 1;
6586 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6587 sw_if_index_set = 1;
6588 else if (unformat (i, "enable"))
6590 else if (unformat (i, "disable"))
6592 else if (unformat (i, "ip4"))
6594 else if (unformat (i, "ip6"))
6600 if (sw_if_index_set == 0)
6602 errmsg ("missing interface name or sw_if_index");
6606 /* Construct the API message */
6607 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
6609 mp->sw_if_index = ntohl (sw_if_index);
6610 mp->enable = is_enable;
6611 mp->is_ipv6 = is_ipv6;
6616 /* Wait for a reply... */
6622 api_sw_interface_set_geneve_bypass (vat_main_t * vam)
6624 unformat_input_t *i = vam->input;
6625 vl_api_sw_interface_set_geneve_bypass_t *mp;
6626 u32 sw_if_index = 0;
6627 u8 sw_if_index_set = 0;
6632 /* Parse args required to build the message */
6633 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6635 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6636 sw_if_index_set = 1;
6637 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6638 sw_if_index_set = 1;
6639 else if (unformat (i, "enable"))
6641 else if (unformat (i, "disable"))
6643 else if (unformat (i, "ip4"))
6645 else if (unformat (i, "ip6"))
6651 if (sw_if_index_set == 0)
6653 errmsg ("missing interface name or sw_if_index");
6657 /* Construct the API message */
6658 M (SW_INTERFACE_SET_GENEVE_BYPASS, mp);
6660 mp->sw_if_index = ntohl (sw_if_index);
6661 mp->enable = is_enable;
6662 mp->is_ipv6 = is_ipv6;
6667 /* Wait for a reply... */
6673 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
6675 unformat_input_t *i = vam->input;
6676 vl_api_sw_interface_set_l2_xconnect_t *mp;
6678 u8 rx_sw_if_index_set = 0;
6680 u8 tx_sw_if_index_set = 0;
6684 /* Parse args required to build the message */
6685 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6687 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6688 rx_sw_if_index_set = 1;
6689 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6690 tx_sw_if_index_set = 1;
6691 else if (unformat (i, "rx"))
6693 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6695 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6697 rx_sw_if_index_set = 1;
6702 else if (unformat (i, "tx"))
6704 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6706 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6708 tx_sw_if_index_set = 1;
6713 else if (unformat (i, "enable"))
6715 else if (unformat (i, "disable"))
6721 if (rx_sw_if_index_set == 0)
6723 errmsg ("missing rx interface name or rx_sw_if_index");
6727 if (enable && (tx_sw_if_index_set == 0))
6729 errmsg ("missing tx interface name or tx_sw_if_index");
6733 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
6735 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6736 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6737 mp->enable = enable;
6745 api_sw_interface_set_l2_bridge (vat_main_t * vam)
6747 unformat_input_t *i = vam->input;
6748 vl_api_sw_interface_set_l2_bridge_t *mp;
6749 vl_api_l2_port_type_t port_type;
6751 u8 rx_sw_if_index_set = 0;
6758 port_type = L2_API_PORT_TYPE_NORMAL;
6760 /* Parse args required to build the message */
6761 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6763 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
6764 rx_sw_if_index_set = 1;
6765 else if (unformat (i, "bd_id %d", &bd_id))
6769 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
6770 rx_sw_if_index_set = 1;
6771 else if (unformat (i, "shg %d", &shg))
6773 else if (unformat (i, "bvi"))
6774 port_type = L2_API_PORT_TYPE_BVI;
6775 else if (unformat (i, "uu-fwd"))
6776 port_type = L2_API_PORT_TYPE_UU_FWD;
6777 else if (unformat (i, "enable"))
6779 else if (unformat (i, "disable"))
6785 if (rx_sw_if_index_set == 0)
6787 errmsg ("missing rx interface name or sw_if_index");
6791 if (enable && (bd_id_set == 0))
6793 errmsg ("missing bridge domain");
6797 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
6799 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6800 mp->bd_id = ntohl (bd_id);
6802 mp->port_type = ntohl (port_type);
6803 mp->enable = enable;
6811 api_bridge_domain_dump (vat_main_t * vam)
6813 unformat_input_t *i = vam->input;
6814 vl_api_bridge_domain_dump_t *mp;
6815 vl_api_control_ping_t *mp_ping;
6819 /* Parse args required to build the message */
6820 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6822 if (unformat (i, "bd_id %d", &bd_id))
6828 M (BRIDGE_DOMAIN_DUMP, mp);
6829 mp->bd_id = ntohl (bd_id);
6832 /* Use a control ping for synchronization */
6833 MPING (CONTROL_PING, mp_ping);
6841 api_bridge_domain_add_del (vat_main_t * vam)
6843 unformat_input_t *i = vam->input;
6844 vl_api_bridge_domain_add_del_t *mp;
6847 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
6852 /* Parse args required to build the message */
6853 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6855 if (unformat (i, "bd_id %d", &bd_id))
6857 else if (unformat (i, "flood %d", &flood))
6859 else if (unformat (i, "uu-flood %d", &uu_flood))
6861 else if (unformat (i, "forward %d", &forward))
6863 else if (unformat (i, "learn %d", &learn))
6865 else if (unformat (i, "arp-term %d", &arp_term))
6867 else if (unformat (i, "mac-age %d", &mac_age))
6869 else if (unformat (i, "bd-tag %s", &bd_tag))
6871 else if (unformat (i, "del"))
6874 flood = uu_flood = forward = learn = 0;
6882 errmsg ("missing bridge domain");
6889 errmsg ("mac age must be less than 256 ");
6894 if ((bd_tag) && (vec_len (bd_tag) > 63))
6896 errmsg ("bd-tag cannot be longer than 63");
6901 M (BRIDGE_DOMAIN_ADD_DEL, mp);
6903 mp->bd_id = ntohl (bd_id);
6905 mp->uu_flood = uu_flood;
6906 mp->forward = forward;
6908 mp->arp_term = arp_term;
6909 mp->is_add = is_add;
6910 mp->mac_age = (u8) mac_age;
6913 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
6914 mp->bd_tag[vec_len (bd_tag)] = 0;
6925 api_l2fib_flush_bd (vat_main_t * vam)
6927 unformat_input_t *i = vam->input;
6928 vl_api_l2fib_flush_bd_t *mp;
6932 /* Parse args required to build the message */
6933 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6935 if (unformat (i, "bd_id %d", &bd_id));
6942 errmsg ("missing bridge domain");
6946 M (L2FIB_FLUSH_BD, mp);
6948 mp->bd_id = htonl (bd_id);
6956 api_l2fib_flush_int (vat_main_t * vam)
6958 unformat_input_t *i = vam->input;
6959 vl_api_l2fib_flush_int_t *mp;
6960 u32 sw_if_index = ~0;
6963 /* Parse args required to build the message */
6964 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6966 if (unformat (i, "sw_if_index %d", &sw_if_index));
6968 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
6973 if (sw_if_index == ~0)
6975 errmsg ("missing interface name or sw_if_index");
6979 M (L2FIB_FLUSH_INT, mp);
6981 mp->sw_if_index = ntohl (sw_if_index);
6989 api_l2fib_add_del (vat_main_t * vam)
6991 unformat_input_t *i = vam->input;
6992 vl_api_l2fib_add_del_t *mp;
6998 u32 sw_if_index = 0;
6999 u8 sw_if_index_set = 0;
7008 /* Parse args required to build the message */
7009 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7011 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
7013 else if (unformat (i, "bd_id %d", &bd_id))
7015 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7016 sw_if_index_set = 1;
7017 else if (unformat (i, "sw_if"))
7019 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7022 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7023 sw_if_index_set = 1;
7028 else if (unformat (i, "static"))
7030 else if (unformat (i, "filter"))
7035 else if (unformat (i, "bvi"))
7040 else if (unformat (i, "del"))
7042 else if (unformat (i, "count %d", &count))
7050 errmsg ("missing mac address");
7056 errmsg ("missing bridge domain");
7060 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
7062 errmsg ("missing interface name or sw_if_index");
7068 /* Turn on async mode */
7069 vam->async_mode = 1;
7070 vam->async_errors = 0;
7071 before = vat_time_now (vam);
7074 for (j = 0; j < count; j++)
7076 M (L2FIB_ADD_DEL, mp);
7078 clib_memcpy (mp->mac, mac, 6);
7079 mp->bd_id = ntohl (bd_id);
7080 mp->is_add = is_add;
7081 mp->sw_if_index = ntohl (sw_if_index);
7085 mp->static_mac = static_mac;
7086 mp->filter_mac = filter_mac;
7087 mp->bvi_mac = bvi_mac;
7089 increment_mac_address (mac);
7096 vl_api_control_ping_t *mp_ping;
7099 /* Shut off async mode */
7100 vam->async_mode = 0;
7102 MPING (CONTROL_PING, mp_ping);
7105 timeout = vat_time_now (vam) + 1.0;
7106 while (vat_time_now (vam) < timeout)
7107 if (vam->result_ready == 1)
7112 if (vam->retval == -99)
7115 if (vam->async_errors > 0)
7117 errmsg ("%d asynchronous errors", vam->async_errors);
7120 vam->async_errors = 0;
7121 after = vat_time_now (vam);
7123 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
7124 count, after - before, count / (after - before));
7130 /* Wait for a reply... */
7134 /* Return the good/bad news */
7135 return (vam->retval);
7139 api_bridge_domain_set_mac_age (vat_main_t * vam)
7141 unformat_input_t *i = vam->input;
7142 vl_api_bridge_domain_set_mac_age_t *mp;
7147 /* Parse args required to build the message */
7148 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7150 if (unformat (i, "bd_id %d", &bd_id));
7151 else if (unformat (i, "mac-age %d", &mac_age));
7158 errmsg ("missing bridge domain");
7164 errmsg ("mac age must be less than 256 ");
7168 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
7170 mp->bd_id = htonl (bd_id);
7171 mp->mac_age = (u8) mac_age;
7179 api_l2_flags (vat_main_t * vam)
7181 unformat_input_t *i = vam->input;
7182 vl_api_l2_flags_t *mp;
7185 u8 sw_if_index_set = 0;
7189 /* Parse args required to build the message */
7190 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7192 if (unformat (i, "sw_if_index %d", &sw_if_index))
7193 sw_if_index_set = 1;
7194 else if (unformat (i, "sw_if"))
7196 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7199 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7200 sw_if_index_set = 1;
7205 else if (unformat (i, "learn"))
7207 else if (unformat (i, "forward"))
7209 else if (unformat (i, "flood"))
7211 else if (unformat (i, "uu-flood"))
7212 flags |= L2_UU_FLOOD;
7213 else if (unformat (i, "arp-term"))
7214 flags |= L2_ARP_TERM;
7215 else if (unformat (i, "off"))
7217 else if (unformat (i, "disable"))
7223 if (sw_if_index_set == 0)
7225 errmsg ("missing interface name or sw_if_index");
7231 mp->sw_if_index = ntohl (sw_if_index);
7232 mp->feature_bitmap = ntohl (flags);
7233 mp->is_set = is_set;
7241 api_bridge_flags (vat_main_t * vam)
7243 unformat_input_t *i = vam->input;
7244 vl_api_bridge_flags_t *mp;
7248 bd_flags_t flags = 0;
7251 /* Parse args required to build the message */
7252 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7254 if (unformat (i, "bd_id %d", &bd_id))
7256 else if (unformat (i, "learn"))
7257 flags |= BRIDGE_API_FLAG_LEARN;
7258 else if (unformat (i, "forward"))
7259 flags |= BRIDGE_API_FLAG_FWD;
7260 else if (unformat (i, "flood"))
7261 flags |= BRIDGE_API_FLAG_FLOOD;
7262 else if (unformat (i, "uu-flood"))
7263 flags |= BRIDGE_API_FLAG_UU_FLOOD;
7264 else if (unformat (i, "arp-term"))
7265 flags |= BRIDGE_API_FLAG_ARP_TERM;
7266 else if (unformat (i, "off"))
7268 else if (unformat (i, "disable"))
7276 errmsg ("missing bridge domain");
7280 M (BRIDGE_FLAGS, mp);
7282 mp->bd_id = ntohl (bd_id);
7283 mp->flags = ntohl (flags);
7284 mp->is_set = is_set;
7292 api_bd_ip_mac_add_del (vat_main_t * vam)
7294 vl_api_address_t ip = VL_API_ZERO_ADDRESS;
7295 vl_api_mac_address_t mac = { 0 };
7296 unformat_input_t *i = vam->input;
7297 vl_api_bd_ip_mac_add_del_t *mp;
7309 /* Parse args required to build the message */
7310 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7312 if (unformat (i, "bd_id %d", &bd_id))
7316 else if (unformat (i, "%U", unformat_vl_api_address, &ip))
7320 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
7324 else if (unformat (i, "del"))
7332 errmsg ("missing bridge domain");
7335 else if (ip_set == 0)
7337 errmsg ("missing IP address");
7340 else if (mac_set == 0)
7342 errmsg ("missing MAC address");
7346 M (BD_IP_MAC_ADD_DEL, mp);
7348 mp->bd_id = ntohl (bd_id);
7349 mp->is_add = is_add;
7351 clib_memcpy (&mp->ip, &ip, sizeof (ip));
7352 clib_memcpy (&mp->mac, &mac, sizeof (mac));
7360 api_bd_ip_mac_flush (vat_main_t * vam)
7362 unformat_input_t *i = vam->input;
7363 vl_api_bd_ip_mac_flush_t *mp;
7368 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7370 if (unformat (i, "bd_id %d", &bd_id))
7380 errmsg ("missing bridge domain");
7384 M (BD_IP_MAC_FLUSH, mp);
7386 mp->bd_id = ntohl (bd_id);
7393 static void vl_api_bd_ip_mac_details_t_handler
7394 (vl_api_bd_ip_mac_details_t * mp)
7396 vat_main_t *vam = &vat_main;
7401 format (0, "%U", format_ip4_address, (ip4_address_t *) mp->ip_address);
7404 format (0, "%U", format_ip6_address, (ip6_address_t *) mp->ip_address);
7407 "\n%-5d %-7s %-20U %-30s",
7408 ntohl (mp->bd_id), mp->is_ipv6 ? "ip6" : "ip4",
7409 format_ethernet_address, mp->mac_address, ip);
7414 static void vl_api_bd_ip_mac_details_t_handler_json
7415 (vl_api_bd_ip_mac_details_t * mp)
7417 vat_main_t *vam = &vat_main;
7418 vat_json_node_t *node = NULL;
7420 if (VAT_JSON_ARRAY != vam->json_tree.type)
7422 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7423 vat_json_init_array (&vam->json_tree);
7425 node = vat_json_array_add (&vam->json_tree);
7427 vat_json_init_object (node);
7428 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
7429 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6);
7430 vat_json_object_add_string_copy (node, "mac_address",
7431 format (0, "%U", format_ethernet_address,
7437 format (0, "%U", format_ip4_address, (ip4_address_t *) mp->ip_address);
7440 format (0, "%U", format_ip6_address, (ip6_address_t *) mp->ip_address);
7441 vat_json_object_add_string_copy (node, "ip_address", ip);
7446 api_bd_ip_mac_dump (vat_main_t * vam)
7448 unformat_input_t *i = vam->input;
7449 vl_api_bd_ip_mac_dump_t *mp;
7450 vl_api_control_ping_t *mp_ping;
7455 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7457 if (unformat (i, "bd_id %d", &bd_id))
7466 "\n%-5s %-7s %-20s %-30s",
7467 "bd_id", "is_ipv6", "mac_address", "ip_address");
7469 /* Dump Bridge Domain Ip to Mac entries */
7470 M (BD_IP_MAC_DUMP, mp);
7473 mp->bd_id = htonl (bd_id);
7479 /* Use a control ping for synchronization */
7480 MPING (CONTROL_PING, mp_ping);
7488 api_tap_create_v2 (vat_main_t * vam)
7490 unformat_input_t *i = vam->input;
7491 vl_api_tap_create_v2_t *mp;
7495 u8 *host_if_name = 0;
7497 u8 host_mac_addr[6];
7498 u8 host_mac_addr_set = 0;
7499 u8 *host_bridge = 0;
7500 ip4_address_t host_ip4_addr;
7501 ip4_address_t host_ip4_gw;
7502 u8 host_ip4_gw_set = 0;
7503 u32 host_ip4_prefix_len = 0;
7504 ip6_address_t host_ip6_addr;
7505 ip6_address_t host_ip6_gw;
7506 u8 host_ip6_gw_set = 0;
7507 u32 host_ip6_prefix_len = 0;
7509 u32 rx_ring_sz = 0, tx_ring_sz = 0;
7511 clib_memset (mac_address, 0, sizeof (mac_address));
7513 /* Parse args required to build the message */
7514 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7516 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7520 else if (unformat (i, "id %u", &id))
7522 else if (unformat (i, "host-if-name %s", &host_if_name))
7524 else if (unformat (i, "host-ns %s", &host_ns))
7526 else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
7528 host_mac_addr_set = 1;
7529 else if (unformat (i, "host-bridge %s", &host_bridge))
7531 else if (unformat (i, "host-ip4-addr %U/%d", unformat_ip4_address,
7532 &host_ip4_addr, &host_ip4_prefix_len))
7534 else if (unformat (i, "host-ip6-addr %U/%d", unformat_ip6_address,
7535 &host_ip6_addr, &host_ip6_prefix_len))
7537 else if (unformat (i, "host-ip4-gw %U", unformat_ip4_address,
7539 host_ip4_gw_set = 1;
7540 else if (unformat (i, "host-ip6-gw %U", unformat_ip6_address,
7542 host_ip6_gw_set = 1;
7543 else if (unformat (i, "rx-ring-size %d", &rx_ring_sz))
7545 else if (unformat (i, "tx-ring-size %d", &tx_ring_sz))
7551 if (vec_len (host_if_name) > 63)
7553 errmsg ("tap name too long. ");
7556 if (vec_len (host_ns) > 63)
7558 errmsg ("host name space too long. ");
7561 if (vec_len (host_bridge) > 63)
7563 errmsg ("host bridge name too long. ");
7566 if (host_ip4_prefix_len > 32)
7568 errmsg ("host ip4 prefix length not valid. ");
7571 if (host_ip6_prefix_len > 128)
7573 errmsg ("host ip6 prefix length not valid. ");
7576 if (!is_pow2 (rx_ring_sz))
7578 errmsg ("rx ring size must be power of 2. ");
7581 if (rx_ring_sz > 32768)
7583 errmsg ("rx ring size must be 32768 or lower. ");
7586 if (!is_pow2 (tx_ring_sz))
7588 errmsg ("tx ring size must be power of 2. ");
7591 if (tx_ring_sz > 32768)
7593 errmsg ("tx ring size must be 32768 or lower. ");
7597 /* Construct the API message */
7598 M (TAP_CREATE_V2, mp);
7600 mp->use_random_mac = random_mac;
7602 mp->id = ntohl (id);
7603 mp->host_namespace_set = host_ns != 0;
7604 mp->host_bridge_set = host_bridge != 0;
7605 mp->host_ip4_addr_set = host_ip4_prefix_len != 0;
7606 mp->host_ip6_addr_set = host_ip6_prefix_len != 0;
7607 mp->rx_ring_sz = ntohs (rx_ring_sz);
7608 mp->tx_ring_sz = ntohs (tx_ring_sz);
7610 if (random_mac == 0)
7611 clib_memcpy (mp->mac_address, mac_address, 6);
7612 if (host_mac_addr_set)
7613 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
7615 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
7617 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
7619 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
7620 if (host_ip4_prefix_len)
7621 clib_memcpy (mp->host_ip4_addr, &host_ip4_addr, 4);
7622 if (host_ip6_prefix_len)
7623 clib_memcpy (mp->host_ip6_addr, &host_ip6_addr, 16);
7624 if (host_ip4_gw_set)
7625 clib_memcpy (mp->host_ip4_gw, &host_ip4_gw, 4);
7626 if (host_ip6_gw_set)
7627 clib_memcpy (mp->host_ip6_gw, &host_ip6_gw, 16);
7630 vec_free (host_if_name);
7631 vec_free (host_bridge);
7636 /* Wait for a reply... */
7642 api_tap_delete_v2 (vat_main_t * vam)
7644 unformat_input_t *i = vam->input;
7645 vl_api_tap_delete_v2_t *mp;
7646 u32 sw_if_index = ~0;
7647 u8 sw_if_index_set = 0;
7650 /* Parse args required to build the message */
7651 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7653 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7654 sw_if_index_set = 1;
7655 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7656 sw_if_index_set = 1;
7661 if (sw_if_index_set == 0)
7663 errmsg ("missing vpp interface name. ");
7667 /* Construct the API message */
7668 M (TAP_DELETE_V2, mp);
7670 mp->sw_if_index = ntohl (sw_if_index);
7675 /* Wait for a reply... */
7681 unformat_pci_addr (unformat_input_t * input, va_list * args)
7690 addr = va_arg (*args, struct pci_addr_t *);
7693 if (!unformat (input, "%x:%x:%x.%x", &x[0], &x[1], &x[2], &x[3]))
7696 addr->domain = x[0];
7699 addr->function = x[3];
7705 api_virtio_pci_create (vat_main_t * vam)
7707 unformat_input_t *i = vam->input;
7708 vl_api_virtio_pci_create_t *mp;
7712 u64 features = (u64) ~ (0ULL);
7713 u32 rx_ring_sz = 0, tx_ring_sz = 0;
7716 clib_memset (mac_address, 0, sizeof (mac_address));
7718 /* Parse args required to build the message */
7719 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7721 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7725 else if (unformat (i, "pci-addr %U", unformat_pci_addr, &pci_addr))
7727 else if (unformat (i, "features 0x%llx", &features))
7729 else if (unformat (i, "rx-ring-size %u", &rx_ring_sz))
7731 else if (unformat (i, "tx-ring-size %u", &tx_ring_sz))
7739 errmsg ("pci address must be non zero. ");
7742 if (!is_pow2 (rx_ring_sz))
7744 errmsg ("rx ring size must be power of 2. ");
7747 if (rx_ring_sz > 32768)
7749 errmsg ("rx ring size must be 32768 or lower. ");
7752 if (!is_pow2 (tx_ring_sz))
7754 errmsg ("tx ring size must be power of 2. ");
7757 if (tx_ring_sz > 32768)
7759 errmsg ("tx ring size must be 32768 or lower. ");
7763 /* Construct the API message */
7764 M (VIRTIO_PCI_CREATE, mp);
7766 mp->use_random_mac = random_mac;
7768 mp->pci_addr = htonl (pci_addr);
7769 mp->features = clib_host_to_net_u64 (features);
7770 mp->rx_ring_sz = htons (rx_ring_sz);
7771 mp->tx_ring_sz = htons (tx_ring_sz);
7773 if (random_mac == 0)
7774 clib_memcpy (mp->mac_address, mac_address, 6);
7779 /* Wait for a reply... */
7785 api_virtio_pci_delete (vat_main_t * vam)
7787 unformat_input_t *i = vam->input;
7788 vl_api_virtio_pci_delete_t *mp;
7789 u32 sw_if_index = ~0;
7790 u8 sw_if_index_set = 0;
7793 /* Parse args required to build the message */
7794 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7796 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7797 sw_if_index_set = 1;
7798 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7799 sw_if_index_set = 1;
7804 if (sw_if_index_set == 0)
7806 errmsg ("missing vpp interface name. ");
7810 /* Construct the API message */
7811 M (VIRTIO_PCI_DELETE, mp);
7813 mp->sw_if_index = htonl (sw_if_index);
7818 /* Wait for a reply... */
7824 api_bond_create (vat_main_t * vam)
7826 unformat_input_t *i = vam->input;
7827 vl_api_bond_create_t *mp;
7836 clib_memset (mac_address, 0, sizeof (mac_address));
7839 /* Parse args required to build the message */
7840 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7842 if (unformat (i, "mode %U", unformat_bond_mode, &mode))
7844 else if (((mode == BOND_MODE_LACP) || (mode == BOND_MODE_XOR))
7845 && unformat (i, "lb %U", unformat_bond_load_balance, &lb))
7847 else if (unformat (i, "hw-addr %U", unformat_ethernet_address,
7850 else if (unformat (i, "id %u", &id))
7856 if (mode_is_set == 0)
7858 errmsg ("Missing bond mode. ");
7862 /* Construct the API message */
7863 M (BOND_CREATE, mp);
7865 mp->use_custom_mac = custom_mac;
7869 mp->id = htonl (id);
7872 clib_memcpy (mp->mac_address, mac_address, 6);
7877 /* Wait for a reply... */
7883 api_bond_delete (vat_main_t * vam)
7885 unformat_input_t *i = vam->input;
7886 vl_api_bond_delete_t *mp;
7887 u32 sw_if_index = ~0;
7888 u8 sw_if_index_set = 0;
7891 /* Parse args required to build the message */
7892 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7894 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7895 sw_if_index_set = 1;
7896 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7897 sw_if_index_set = 1;
7902 if (sw_if_index_set == 0)
7904 errmsg ("missing vpp interface name. ");
7908 /* Construct the API message */
7909 M (BOND_DELETE, mp);
7911 mp->sw_if_index = ntohl (sw_if_index);
7916 /* Wait for a reply... */
7922 api_bond_enslave (vat_main_t * vam)
7924 unformat_input_t *i = vam->input;
7925 vl_api_bond_enslave_t *mp;
7926 u32 bond_sw_if_index;
7930 u32 bond_sw_if_index_is_set = 0;
7932 u8 sw_if_index_is_set = 0;
7934 /* Parse args required to build the message */
7935 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7937 if (unformat (i, "sw_if_index %d", &sw_if_index))
7938 sw_if_index_is_set = 1;
7939 else if (unformat (i, "bond %u", &bond_sw_if_index))
7940 bond_sw_if_index_is_set = 1;
7941 else if (unformat (i, "passive %d", &is_passive))
7943 else if (unformat (i, "long-timeout %d", &is_long_timeout))
7949 if (bond_sw_if_index_is_set == 0)
7951 errmsg ("Missing bond sw_if_index. ");
7954 if (sw_if_index_is_set == 0)
7956 errmsg ("Missing slave sw_if_index. ");
7960 /* Construct the API message */
7961 M (BOND_ENSLAVE, mp);
7963 mp->bond_sw_if_index = ntohl (bond_sw_if_index);
7964 mp->sw_if_index = ntohl (sw_if_index);
7965 mp->is_long_timeout = is_long_timeout;
7966 mp->is_passive = is_passive;
7971 /* Wait for a reply... */
7977 api_bond_detach_slave (vat_main_t * vam)
7979 unformat_input_t *i = vam->input;
7980 vl_api_bond_detach_slave_t *mp;
7981 u32 sw_if_index = ~0;
7982 u8 sw_if_index_set = 0;
7985 /* Parse args required to build the message */
7986 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7988 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7989 sw_if_index_set = 1;
7990 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7991 sw_if_index_set = 1;
7996 if (sw_if_index_set == 0)
7998 errmsg ("missing vpp interface name. ");
8002 /* Construct the API message */
8003 M (BOND_DETACH_SLAVE, mp);
8005 mp->sw_if_index = ntohl (sw_if_index);
8010 /* Wait for a reply... */
8016 api_ip_table_add_del (vat_main_t * vam)
8018 unformat_input_t *i = vam->input;
8019 vl_api_ip_table_add_del_t *mp;
8025 /* Parse args required to build the message */
8026 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8028 if (unformat (i, "ipv6"))
8030 else if (unformat (i, "del"))
8032 else if (unformat (i, "add"))
8034 else if (unformat (i, "table %d", &table_id))
8038 clib_warning ("parse error '%U'", format_unformat_error, i);
8045 errmsg ("missing table-ID");
8049 /* Construct the API message */
8050 M (IP_TABLE_ADD_DEL, mp);
8052 mp->table_id = ntohl (table_id);
8053 mp->is_ipv6 = is_ipv6;
8054 mp->is_add = is_add;
8059 /* Wait for a reply... */
8066 api_ip_add_del_route (vat_main_t * vam)
8068 unformat_input_t *i = vam->input;
8069 vl_api_ip_add_del_route_t *mp;
8070 u32 sw_if_index = ~0, vrf_id = 0;
8072 u8 is_local = 0, is_drop = 0;
8073 u8 is_unreach = 0, is_prohibit = 0;
8075 u32 next_hop_weight = 1;
8076 u8 is_multipath = 0;
8078 u8 address_length_set = 0;
8079 u32 next_hop_table_id = 0;
8080 u32 resolve_attempts = 0;
8081 u32 dst_address_length = 0;
8082 u8 next_hop_set = 0;
8083 ip4_address_t v4_dst_address, v4_next_hop_address;
8084 ip6_address_t v6_dst_address, v6_next_hop_address;
8088 u32 random_add_del = 0;
8089 u32 *random_vector = 0;
8091 u32 random_seed = 0xdeaddabe;
8092 u32 classify_table_index = ~0;
8094 u8 resolve_host = 0, resolve_attached = 0;
8095 vl_api_fib_mpls_label_t *next_hop_out_label_stack = NULL;
8096 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8097 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
8099 clib_memset (&v4_next_hop_address, 0, sizeof (ip4_address_t));
8100 clib_memset (&v6_next_hop_address, 0, sizeof (ip6_address_t));
8101 /* Parse args required to build the message */
8102 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8104 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8106 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8108 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
8113 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
8118 else if (unformat (i, "/%d", &dst_address_length))
8120 address_length_set = 1;
8123 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
8124 &v4_next_hop_address))
8128 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
8129 &v6_next_hop_address))
8135 (i, "via %U", api_unformat_sw_if_index, vam, &sw_if_index))
8139 else if (unformat (i, "via sw_if_index %d", &sw_if_index))
8143 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
8145 else if (unformat (i, "weight %d", &next_hop_weight))
8147 else if (unformat (i, "drop"))
8151 else if (unformat (i, "null-send-unreach"))
8155 else if (unformat (i, "null-send-prohibit"))
8159 else if (unformat (i, "local"))
8163 else if (unformat (i, "classify %d", &classify_table_index))
8167 else if (unformat (i, "del"))
8169 else if (unformat (i, "add"))
8171 else if (unformat (i, "resolve-via-host"))
8173 else if (unformat (i, "resolve-via-attached"))
8174 resolve_attached = 1;
8175 else if (unformat (i, "multipath"))
8177 else if (unformat (i, "vrf %d", &vrf_id))
8179 else if (unformat (i, "count %d", &count))
8181 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
8183 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
8185 else if (unformat (i, "out-label %d", &next_hop_out_label))
8187 vl_api_fib_mpls_label_t fib_label = {
8188 .label = ntohl (next_hop_out_label),
8192 vec_add1 (next_hop_out_label_stack, fib_label);
8194 else if (unformat (i, "via via-label %d", &next_hop_via_label))
8196 else if (unformat (i, "random"))
8198 else if (unformat (i, "seed %d", &random_seed))
8202 clib_warning ("parse error '%U'", format_unformat_error, i);
8207 if (!next_hop_set && !is_drop && !is_local &&
8208 !is_classify && !is_unreach && !is_prohibit &&
8209 MPLS_LABEL_INVALID == next_hop_via_label)
8212 ("next hop / local / drop / unreach / prohibit / classify not set");
8216 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
8218 errmsg ("next hop and next-hop via label set");
8221 if (address_set == 0)
8223 errmsg ("missing addresses");
8227 if (address_length_set == 0)
8229 errmsg ("missing address length");
8233 /* Generate a pile of unique, random routes */
8236 u32 this_random_address;
8237 random_hash = hash_create (count, sizeof (uword));
8239 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
8240 for (j = 0; j <= count; j++)
8244 this_random_address = random_u32 (&random_seed);
8245 this_random_address =
8246 clib_host_to_net_u32 (this_random_address);
8248 while (hash_get (random_hash, this_random_address));
8249 vec_add1 (random_vector, this_random_address);
8250 hash_set (random_hash, this_random_address, 1);
8252 hash_free (random_hash);
8253 v4_dst_address.as_u32 = random_vector[0];
8258 /* Turn on async mode */
8259 vam->async_mode = 1;
8260 vam->async_errors = 0;
8261 before = vat_time_now (vam);
8264 for (j = 0; j < count; j++)
8266 /* Construct the API message */
8267 M2 (IP_ADD_DEL_ROUTE, mp, sizeof (vl_api_fib_mpls_label_t) *
8268 vec_len (next_hop_out_label_stack));
8270 mp->next_hop_sw_if_index = ntohl (sw_if_index);
8271 mp->table_id = ntohl (vrf_id);
8273 mp->is_add = is_add;
8274 mp->is_drop = is_drop;
8275 mp->is_unreach = is_unreach;
8276 mp->is_prohibit = is_prohibit;
8277 mp->is_ipv6 = is_ipv6;
8278 mp->is_local = is_local;
8279 mp->is_classify = is_classify;
8280 mp->is_multipath = is_multipath;
8281 mp->is_resolve_host = resolve_host;
8282 mp->is_resolve_attached = resolve_attached;
8283 mp->next_hop_weight = next_hop_weight;
8284 mp->next_hop_preference = 0;
8285 mp->dst_address_length = dst_address_length;
8286 mp->next_hop_table_id = ntohl (next_hop_table_id);
8287 mp->classify_table_index = ntohl (classify_table_index);
8288 mp->next_hop_via_label = ntohl (next_hop_via_label);
8289 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
8290 if (0 != mp->next_hop_n_out_labels)
8292 memcpy (mp->next_hop_out_label_stack,
8293 next_hop_out_label_stack,
8294 (vec_len (next_hop_out_label_stack) *
8295 sizeof (vl_api_fib_mpls_label_t)));
8296 vec_free (next_hop_out_label_stack);
8301 clib_memcpy (mp->dst_address, &v6_dst_address,
8302 sizeof (v6_dst_address));
8304 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
8305 sizeof (v6_next_hop_address));
8306 increment_v6_address (&v6_dst_address);
8310 clib_memcpy (mp->dst_address, &v4_dst_address,
8311 sizeof (v4_dst_address));
8313 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
8314 sizeof (v4_next_hop_address));
8316 v4_dst_address.as_u32 = random_vector[j + 1];
8318 increment_v4_address (&v4_dst_address);
8322 /* If we receive SIGTERM, stop now... */
8327 /* When testing multiple add/del ops, use a control-ping to sync */
8330 vl_api_control_ping_t *mp_ping;
8334 /* Shut off async mode */
8335 vam->async_mode = 0;
8337 MPING (CONTROL_PING, mp_ping);
8340 timeout = vat_time_now (vam) + 1.0;
8341 while (vat_time_now (vam) < timeout)
8342 if (vam->result_ready == 1)
8347 if (vam->retval == -99)
8350 if (vam->async_errors > 0)
8352 errmsg ("%d asynchronous errors", vam->async_errors);
8355 vam->async_errors = 0;
8356 after = vat_time_now (vam);
8358 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8362 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8363 count, after - before, count / (after - before));
8369 /* Wait for a reply... */
8374 /* Return the good/bad news */
8375 return (vam->retval);
8379 api_ip_mroute_add_del (vat_main_t * vam)
8381 unformat_input_t *i = vam->input;
8382 vl_api_ip_mroute_add_del_t *mp;
8383 u32 sw_if_index = ~0, vrf_id = 0;
8388 u32 grp_address_length = 0;
8389 ip4_address_t v4_grp_address, v4_src_address;
8390 ip6_address_t v6_grp_address, v6_src_address;
8391 mfib_itf_flags_t iflags = 0;
8392 mfib_entry_flags_t eflags = 0;
8395 /* Parse args required to build the message */
8396 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8398 if (unformat (i, "sw_if_index %d", &sw_if_index))
8400 else if (unformat (i, "%U %U",
8401 unformat_ip4_address, &v4_src_address,
8402 unformat_ip4_address, &v4_grp_address))
8404 grp_address_length = 64;
8408 else if (unformat (i, "%U %U",
8409 unformat_ip6_address, &v6_src_address,
8410 unformat_ip6_address, &v6_grp_address))
8412 grp_address_length = 256;
8416 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
8418 clib_memset (&v4_src_address, 0, sizeof (v4_src_address));
8419 grp_address_length = 32;
8423 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
8425 clib_memset (&v6_src_address, 0, sizeof (v6_src_address));
8426 grp_address_length = 128;
8430 else if (unformat (i, "/%d", &grp_address_length))
8432 else if (unformat (i, "local"))
8436 else if (unformat (i, "del"))
8438 else if (unformat (i, "add"))
8440 else if (unformat (i, "vrf %d", &vrf_id))
8442 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
8444 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8448 clib_warning ("parse error '%U'", format_unformat_error, i);
8453 if (address_set == 0)
8455 errmsg ("missing addresses\n");
8459 /* Construct the API message */
8460 M (IP_MROUTE_ADD_DEL, mp);
8462 mp->next_hop_sw_if_index = ntohl (sw_if_index);
8463 mp->table_id = ntohl (vrf_id);
8465 mp->is_add = is_add;
8466 mp->is_ipv6 = is_ipv6;
8467 mp->is_local = is_local;
8468 mp->itf_flags = ntohl (iflags);
8469 mp->entry_flags = ntohl (eflags);
8470 mp->grp_address_length = grp_address_length;
8471 mp->grp_address_length = ntohs (mp->grp_address_length);
8475 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
8476 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
8480 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
8481 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
8487 /* Wait for a reply... */
8493 api_mpls_table_add_del (vat_main_t * vam)
8495 unformat_input_t *i = vam->input;
8496 vl_api_mpls_table_add_del_t *mp;
8501 /* Parse args required to build the message */
8502 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8504 if (unformat (i, "table %d", &table_id))
8506 else if (unformat (i, "del"))
8508 else if (unformat (i, "add"))
8512 clib_warning ("parse error '%U'", format_unformat_error, i);
8519 errmsg ("missing table-ID");
8523 /* Construct the API message */
8524 M (MPLS_TABLE_ADD_DEL, mp);
8526 mp->mt_table_id = ntohl (table_id);
8527 mp->mt_is_add = is_add;
8532 /* Wait for a reply... */
8539 api_mpls_route_add_del (vat_main_t * vam)
8541 unformat_input_t *i = vam->input;
8542 vl_api_mpls_route_add_del_t *mp;
8543 u32 sw_if_index = ~0, table_id = 0;
8545 u32 next_hop_weight = 1;
8546 u8 is_multipath = 0;
8547 u32 next_hop_table_id = 0;
8548 u8 next_hop_set = 0;
8549 ip4_address_t v4_next_hop_address = {
8552 ip6_address_t v6_next_hop_address = { {0} };
8556 u32 classify_table_index = ~0;
8558 u8 resolve_host = 0, resolve_attached = 0;
8559 u8 is_interface_rx = 0;
8560 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
8561 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8562 vl_api_fib_mpls_label_t *next_hop_out_label_stack = NULL;
8563 mpls_label_t local_label = MPLS_LABEL_INVALID;
8565 dpo_proto_t next_hop_proto = DPO_PROTO_MPLS;
8567 /* Parse args required to build the message */
8568 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8570 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8572 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8574 else if (unformat (i, "%d", &local_label))
8576 else if (unformat (i, "eos"))
8578 else if (unformat (i, "non-eos"))
8580 else if (unformat (i, "via %U", unformat_ip4_address,
8581 &v4_next_hop_address))
8584 next_hop_proto = DPO_PROTO_IP4;
8586 else if (unformat (i, "via %U", unformat_ip6_address,
8587 &v6_next_hop_address))
8590 next_hop_proto = DPO_PROTO_IP6;
8592 else if (unformat (i, "weight %d", &next_hop_weight))
8594 else if (unformat (i, "classify %d", &classify_table_index))
8598 else if (unformat (i, "del"))
8600 else if (unformat (i, "add"))
8602 else if (unformat (i, "resolve-via-host"))
8604 else if (unformat (i, "resolve-via-attached"))
8605 resolve_attached = 1;
8606 else if (unformat (i, "multipath"))
8608 else if (unformat (i, "count %d", &count))
8610 else if (unformat (i, "via lookup-in-ip4-table %d", &next_hop_table_id))
8613 next_hop_proto = DPO_PROTO_IP4;
8615 else if (unformat (i, "via lookup-in-ip6-table %d", &next_hop_table_id))
8618 next_hop_proto = DPO_PROTO_IP6;
8622 (i, "via l2-input-on %U", api_unformat_sw_if_index, vam,
8626 next_hop_proto = DPO_PROTO_ETHERNET;
8627 is_interface_rx = 1;
8629 else if (unformat (i, "via l2-input-on sw_if_index %d", &sw_if_index))
8632 next_hop_proto = DPO_PROTO_ETHERNET;
8633 is_interface_rx = 1;
8635 else if (unformat (i, "via next-hop-table %d", &next_hop_table_id))
8637 else if (unformat (i, "via via-label %d", &next_hop_via_label))
8639 else if (unformat (i, "out-label %d", &next_hop_out_label))
8641 vl_api_fib_mpls_label_t fib_label = {
8642 .label = ntohl (next_hop_out_label),
8646 vec_add1 (next_hop_out_label_stack, fib_label);
8650 clib_warning ("parse error '%U'", format_unformat_error, i);
8655 if (!next_hop_set && !is_classify)
8657 errmsg ("next hop / classify not set");
8661 if (MPLS_LABEL_INVALID == local_label)
8663 errmsg ("missing label");
8669 /* Turn on async mode */
8670 vam->async_mode = 1;
8671 vam->async_errors = 0;
8672 before = vat_time_now (vam);
8675 for (j = 0; j < count; j++)
8677 /* Construct the API message */
8678 M2 (MPLS_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_mpls_label_t) *
8679 vec_len (next_hop_out_label_stack));
8681 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
8682 mp->mr_table_id = ntohl (table_id);
8684 mp->mr_is_add = is_add;
8685 mp->mr_next_hop_proto = next_hop_proto;
8686 mp->mr_is_classify = is_classify;
8687 mp->mr_is_multipath = is_multipath;
8688 mp->mr_is_resolve_host = resolve_host;
8689 mp->mr_is_resolve_attached = resolve_attached;
8690 mp->mr_is_interface_rx = is_interface_rx;
8691 mp->mr_next_hop_weight = next_hop_weight;
8692 mp->mr_next_hop_preference = 0;
8693 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
8694 mp->mr_classify_table_index = ntohl (classify_table_index);
8695 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
8696 mp->mr_label = ntohl (local_label);
8697 mp->mr_eos = is_eos;
8699 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
8700 if (0 != mp->mr_next_hop_n_out_labels)
8702 memcpy (mp->mr_next_hop_out_label_stack,
8703 next_hop_out_label_stack,
8704 vec_len (next_hop_out_label_stack) *
8705 sizeof (vl_api_fib_mpls_label_t));
8706 vec_free (next_hop_out_label_stack);
8711 if (DPO_PROTO_IP4 == next_hop_proto)
8713 clib_memcpy (mp->mr_next_hop,
8714 &v4_next_hop_address,
8715 sizeof (v4_next_hop_address));
8717 else if (DPO_PROTO_IP6 == next_hop_proto)
8720 clib_memcpy (mp->mr_next_hop,
8721 &v6_next_hop_address,
8722 sizeof (v6_next_hop_address));
8729 /* If we receive SIGTERM, stop now... */
8734 /* When testing multiple add/del ops, use a control-ping to sync */
8737 vl_api_control_ping_t *mp_ping;
8741 /* Shut off async mode */
8742 vam->async_mode = 0;
8744 MPING (CONTROL_PING, mp_ping);
8747 timeout = vat_time_now (vam) + 1.0;
8748 while (vat_time_now (vam) < timeout)
8749 if (vam->result_ready == 1)
8754 if (vam->retval == -99)
8757 if (vam->async_errors > 0)
8759 errmsg ("%d asynchronous errors", vam->async_errors);
8762 vam->async_errors = 0;
8763 after = vat_time_now (vam);
8765 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8769 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8770 count, after - before, count / (after - before));
8776 /* Wait for a reply... */
8781 /* Return the good/bad news */
8782 return (vam->retval);
8786 api_mpls_ip_bind_unbind (vat_main_t * vam)
8788 unformat_input_t *i = vam->input;
8789 vl_api_mpls_ip_bind_unbind_t *mp;
8790 u32 ip_table_id = 0;
8793 ip4_address_t v4_address;
8794 ip6_address_t v6_address;
8797 mpls_label_t local_label = MPLS_LABEL_INVALID;
8800 /* Parse args required to build the message */
8801 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8803 if (unformat (i, "%U/%d", unformat_ip4_address,
8804 &v4_address, &address_length))
8809 else if (unformat (i, "%U/%d", unformat_ip6_address,
8810 &v6_address, &address_length))
8815 else if (unformat (i, "%d", &local_label))
8817 else if (unformat (i, "table-id %d", &ip_table_id))
8819 else if (unformat (i, "unbind"))
8821 else if (unformat (i, "bind"))
8825 clib_warning ("parse error '%U'", format_unformat_error, i);
8832 errmsg ("IP address not set");
8836 if (MPLS_LABEL_INVALID == local_label)
8838 errmsg ("missing label");
8842 /* Construct the API message */
8843 M (MPLS_IP_BIND_UNBIND, mp);
8845 mp->mb_is_bind = is_bind;
8846 mp->mb_is_ip4 = is_ip4;
8847 mp->mb_ip_table_id = ntohl (ip_table_id);
8848 mp->mb_mpls_table_id = 0;
8849 mp->mb_label = ntohl (local_label);
8850 mp->mb_address_length = address_length;
8853 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
8855 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
8860 /* Wait for a reply... */
8866 api_sr_mpls_policy_add (vat_main_t * vam)
8868 unformat_input_t *i = vam->input;
8869 vl_api_sr_mpls_policy_add_t *mp;
8875 u32 *segments = NULL;
8878 /* Parse args required to build the message */
8879 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8881 if (unformat (i, "bsid %d", &bsid))
8883 else if (unformat (i, "weight %d", &weight))
8885 else if (unformat (i, "spray"))
8887 else if (unformat (i, "next %d", &sid))
8890 vec_add1 (segments, htonl (sid));
8894 clib_warning ("parse error '%U'", format_unformat_error, i);
8901 errmsg ("bsid not set");
8905 if (n_segments == 0)
8907 errmsg ("no sid in segment stack");
8911 /* Construct the API message */
8912 M2 (SR_MPLS_POLICY_ADD, mp, sizeof (u32) * n_segments);
8914 mp->bsid = htonl (bsid);
8915 mp->weight = htonl (weight);
8917 mp->n_segments = n_segments;
8918 memcpy (mp->segments, segments, sizeof (u32) * n_segments);
8919 vec_free (segments);
8924 /* Wait for a reply... */
8930 api_sr_mpls_policy_del (vat_main_t * vam)
8932 unformat_input_t *i = vam->input;
8933 vl_api_sr_mpls_policy_del_t *mp;
8937 /* Parse args required to build the message */
8938 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8940 if (unformat (i, "bsid %d", &bsid))
8944 clib_warning ("parse error '%U'", format_unformat_error, i);
8951 errmsg ("bsid not set");
8955 /* Construct the API message */
8956 M (SR_MPLS_POLICY_DEL, mp);
8958 mp->bsid = htonl (bsid);
8963 /* Wait for a reply... */
8969 api_bier_table_add_del (vat_main_t * vam)
8971 unformat_input_t *i = vam->input;
8972 vl_api_bier_table_add_del_t *mp;
8974 u32 set = 0, sub_domain = 0, hdr_len = 3;
8975 mpls_label_t local_label = MPLS_LABEL_INVALID;
8978 /* Parse args required to build the message */
8979 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8981 if (unformat (i, "sub-domain %d", &sub_domain))
8983 else if (unformat (i, "set %d", &set))
8985 else if (unformat (i, "label %d", &local_label))
8987 else if (unformat (i, "hdr-len %d", &hdr_len))
8989 else if (unformat (i, "add"))
8991 else if (unformat (i, "del"))
8995 clib_warning ("parse error '%U'", format_unformat_error, i);
9000 if (MPLS_LABEL_INVALID == local_label)
9002 errmsg ("missing label\n");
9006 /* Construct the API message */
9007 M (BIER_TABLE_ADD_DEL, mp);
9009 mp->bt_is_add = is_add;
9010 mp->bt_label = ntohl (local_label);
9011 mp->bt_tbl_id.bt_set = set;
9012 mp->bt_tbl_id.bt_sub_domain = sub_domain;
9013 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
9018 /* Wait for a reply... */
9025 api_bier_route_add_del (vat_main_t * vam)
9027 unformat_input_t *i = vam->input;
9028 vl_api_bier_route_add_del_t *mp;
9030 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
9031 ip4_address_t v4_next_hop_address;
9032 ip6_address_t v6_next_hop_address;
9033 u8 next_hop_set = 0;
9034 u8 next_hop_proto_is_ip4 = 1;
9035 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
9038 /* Parse args required to build the message */
9039 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9041 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
9043 next_hop_proto_is_ip4 = 1;
9046 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
9048 next_hop_proto_is_ip4 = 0;
9051 if (unformat (i, "sub-domain %d", &sub_domain))
9053 else if (unformat (i, "set %d", &set))
9055 else if (unformat (i, "hdr-len %d", &hdr_len))
9057 else if (unformat (i, "bp %d", &bp))
9059 else if (unformat (i, "add"))
9061 else if (unformat (i, "del"))
9063 else if (unformat (i, "out-label %d", &next_hop_out_label))
9067 clib_warning ("parse error '%U'", format_unformat_error, i);
9072 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
9074 errmsg ("next hop / label set\n");
9079 errmsg ("bit=position not set\n");
9083 /* Construct the API message */
9084 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t));
9086 mp->br_is_add = is_add;
9087 mp->br_tbl_id.bt_set = set;
9088 mp->br_tbl_id.bt_sub_domain = sub_domain;
9089 mp->br_tbl_id.bt_hdr_len_id = hdr_len;
9090 mp->br_bp = ntohs (bp);
9092 mp->br_paths[0].n_labels = 1;
9093 mp->br_paths[0].label_stack[0].label = ntohl (next_hop_out_label);
9094 mp->br_paths[0].afi = (next_hop_proto_is_ip4 ? 0 : 1);
9096 if (next_hop_proto_is_ip4)
9098 clib_memcpy (mp->br_paths[0].next_hop,
9099 &v4_next_hop_address, sizeof (v4_next_hop_address));
9103 clib_memcpy (mp->br_paths[0].next_hop,
9104 &v6_next_hop_address, sizeof (v6_next_hop_address));
9110 /* Wait for a reply... */
9117 api_proxy_arp_add_del (vat_main_t * vam)
9119 unformat_input_t *i = vam->input;
9120 vl_api_proxy_arp_add_del_t *mp;
9123 vl_api_ip4_address_t lo, hi;
9127 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9129 if (unformat (i, "vrf %d", &vrf_id))
9131 else if (unformat (i, "%U - %U", unformat_vl_api_ip4_address, &lo,
9132 unformat_vl_api_ip4_address, &hi))
9134 else if (unformat (i, "del"))
9138 clib_warning ("parse error '%U'", format_unformat_error, i);
9145 errmsg ("address range not set");
9149 M (PROXY_ARP_ADD_DEL, mp);
9151 mp->proxy.table_id = ntohl (vrf_id);
9152 mp->is_add = is_add;
9153 clib_memcpy (mp->proxy.low, &lo, sizeof (lo));
9154 clib_memcpy (mp->proxy.hi, &hi, sizeof (hi));
9162 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
9164 unformat_input_t *i = vam->input;
9165 vl_api_proxy_arp_intfc_enable_disable_t *mp;
9168 u8 sw_if_index_set = 0;
9171 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9173 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9174 sw_if_index_set = 1;
9175 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9176 sw_if_index_set = 1;
9177 else if (unformat (i, "enable"))
9179 else if (unformat (i, "disable"))
9183 clib_warning ("parse error '%U'", format_unformat_error, i);
9188 if (sw_if_index_set == 0)
9190 errmsg ("missing interface name or sw_if_index");
9194 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
9196 mp->sw_if_index = ntohl (sw_if_index);
9197 mp->enable_disable = enable;
9205 api_mpls_tunnel_add_del (vat_main_t * vam)
9207 unformat_input_t *i = vam->input;
9208 vl_api_mpls_tunnel_add_del_t *mp;
9212 u32 sw_if_index = ~0;
9213 u32 next_hop_sw_if_index = ~0;
9214 u32 next_hop_proto_is_ip4 = 1;
9216 u32 next_hop_table_id = 0;
9217 ip4_address_t v4_next_hop_address = {
9220 ip6_address_t v6_next_hop_address = { {0} };
9221 vl_api_fib_mpls_label_t *next_hop_out_label_stack = NULL;
9222 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
9223 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
9226 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9228 if (unformat (i, "add"))
9232 (i, "del %U", api_unformat_sw_if_index, vam, &sw_if_index))
9234 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
9236 else if (unformat (i, "via %U",
9237 unformat_ip4_address, &v4_next_hop_address))
9239 next_hop_proto_is_ip4 = 1;
9241 else if (unformat (i, "via %U",
9242 unformat_ip6_address, &v6_next_hop_address))
9244 next_hop_proto_is_ip4 = 0;
9246 else if (unformat (i, "via-label %d", &next_hop_via_label))
9250 (i, "%U", api_unformat_sw_if_index, vam, &next_hop_sw_if_index))
9252 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
9254 else if (unformat (i, "l2-only"))
9256 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
9258 else if (unformat (i, "out-label %d", &next_hop_out_label))
9260 vl_api_fib_mpls_label_t fib_label = {
9261 .label = ntohl (next_hop_out_label),
9265 vec_add1 (next_hop_out_label_stack, fib_label);
9269 clib_warning ("parse error '%U'", format_unformat_error, i);
9274 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (vl_api_fib_mpls_label_t) *
9275 vec_len (next_hop_out_label_stack));
9277 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
9278 mp->mt_sw_if_index = ntohl (sw_if_index);
9279 mp->mt_is_add = is_add;
9280 mp->mt_l2_only = l2_only;
9281 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
9282 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
9283 mp->mt_next_hop_via_label = ntohl (next_hop_via_label);
9284 mp->mt_next_hop_weight = 1;
9285 mp->mt_next_hop_preference = 0;
9287 mp->mt_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
9289 if (0 != mp->mt_next_hop_n_out_labels)
9291 clib_memcpy (mp->mt_next_hop_out_label_stack,
9292 next_hop_out_label_stack,
9293 (vec_len (next_hop_out_label_stack) *
9294 sizeof (vl_api_fib_mpls_label_t)));
9295 vec_free (next_hop_out_label_stack);
9298 if (next_hop_proto_is_ip4)
9300 clib_memcpy (mp->mt_next_hop,
9301 &v4_next_hop_address, sizeof (v4_next_hop_address));
9305 clib_memcpy (mp->mt_next_hop,
9306 &v6_next_hop_address, sizeof (v6_next_hop_address));
9315 api_sw_interface_set_unnumbered (vat_main_t * vam)
9317 unformat_input_t *i = vam->input;
9318 vl_api_sw_interface_set_unnumbered_t *mp;
9320 u32 unnum_sw_index = ~0;
9322 u8 sw_if_index_set = 0;
9325 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9327 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9328 sw_if_index_set = 1;
9329 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9330 sw_if_index_set = 1;
9331 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
9333 else if (unformat (i, "del"))
9337 clib_warning ("parse error '%U'", format_unformat_error, i);
9342 if (sw_if_index_set == 0)
9344 errmsg ("missing interface name or sw_if_index");
9348 M (SW_INTERFACE_SET_UNNUMBERED, mp);
9350 mp->sw_if_index = ntohl (sw_if_index);
9351 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
9352 mp->is_add = is_add;
9360 api_ip_neighbor_add_del (vat_main_t * vam)
9362 vl_api_mac_address_t mac_address;
9363 unformat_input_t *i = vam->input;
9364 vl_api_ip_neighbor_add_del_t *mp;
9365 vl_api_address_t ip_address;
9367 u8 sw_if_index_set = 0;
9372 ip_neighbor_flags_t flags;
9374 flags = IP_NEIGHBOR_FLAG_NONE;
9375 clib_memset (&ip_address, 0, sizeof (ip_address));
9376 clib_memset (&mac_address, 0, sizeof (mac_address));
9377 /* Parse args required to build the message */
9378 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9380 if (unformat (i, "mac %U", unformat_vl_api_mac_address, &mac_address))
9384 else if (unformat (i, "del"))
9387 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9388 sw_if_index_set = 1;
9389 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9390 sw_if_index_set = 1;
9391 else if (unformat (i, "static"))
9392 flags |= IP_NEIGHBOR_FLAG_STATIC;
9393 else if (unformat (i, "no-fib-entry"))
9394 flags |= IP_NEIGHBOR_FLAG_NO_FIB_ENTRY;
9395 else if (unformat (i, "dst %U", unformat_vl_api_address, &ip_address))
9399 clib_warning ("parse error '%U'", format_unformat_error, i);
9404 if (sw_if_index_set == 0)
9406 errmsg ("missing interface name or sw_if_index");
9411 errmsg ("no address set");
9415 /* Construct the API message */
9416 M (IP_NEIGHBOR_ADD_DEL, mp);
9418 mp->neighbor.sw_if_index = ntohl (sw_if_index);
9419 mp->is_add = is_add;
9420 mp->neighbor.flags = htonl (flags);
9422 clib_memcpy (&mp->neighbor.mac_address, &mac_address,
9423 sizeof (mac_address));
9425 clib_memcpy (&mp->neighbor.ip_address, &ip_address, sizeof (ip_address));
9430 /* Wait for a reply, return good/bad news */
9436 api_create_vlan_subif (vat_main_t * vam)
9438 unformat_input_t *i = vam->input;
9439 vl_api_create_vlan_subif_t *mp;
9441 u8 sw_if_index_set = 0;
9446 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9448 if (unformat (i, "sw_if_index %d", &sw_if_index))
9449 sw_if_index_set = 1;
9451 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9452 sw_if_index_set = 1;
9453 else if (unformat (i, "vlan %d", &vlan_id))
9457 clib_warning ("parse error '%U'", format_unformat_error, i);
9462 if (sw_if_index_set == 0)
9464 errmsg ("missing interface name or sw_if_index");
9468 if (vlan_id_set == 0)
9470 errmsg ("missing vlan_id");
9473 M (CREATE_VLAN_SUBIF, mp);
9475 mp->sw_if_index = ntohl (sw_if_index);
9476 mp->vlan_id = ntohl (vlan_id);
9483 #define foreach_create_subif_bit \
9490 _(outer_vlan_id_any) \
9491 _(inner_vlan_id_any)
9494 api_create_subif (vat_main_t * vam)
9496 unformat_input_t *i = vam->input;
9497 vl_api_create_subif_t *mp;
9499 u8 sw_if_index_set = 0;
9506 u32 exact_match = 0;
9507 u32 default_sub = 0;
9508 u32 outer_vlan_id_any = 0;
9509 u32 inner_vlan_id_any = 0;
9511 u16 outer_vlan_id = 0;
9512 u16 inner_vlan_id = 0;
9515 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9517 if (unformat (i, "sw_if_index %d", &sw_if_index))
9518 sw_if_index_set = 1;
9520 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9521 sw_if_index_set = 1;
9522 else if (unformat (i, "sub_id %d", &sub_id))
9524 else if (unformat (i, "outer_vlan_id %d", &tmp))
9525 outer_vlan_id = tmp;
9526 else if (unformat (i, "inner_vlan_id %d", &tmp))
9527 inner_vlan_id = tmp;
9529 #define _(a) else if (unformat (i, #a)) a = 1 ;
9530 foreach_create_subif_bit
9534 clib_warning ("parse error '%U'", format_unformat_error, i);
9539 if (sw_if_index_set == 0)
9541 errmsg ("missing interface name or sw_if_index");
9545 if (sub_id_set == 0)
9547 errmsg ("missing sub_id");
9550 M (CREATE_SUBIF, mp);
9552 mp->sw_if_index = ntohl (sw_if_index);
9553 mp->sub_id = ntohl (sub_id);
9555 #define _(a) mp->a = a;
9556 foreach_create_subif_bit;
9559 mp->outer_vlan_id = ntohs (outer_vlan_id);
9560 mp->inner_vlan_id = ntohs (inner_vlan_id);
9568 api_oam_add_del (vat_main_t * vam)
9570 unformat_input_t *i = vam->input;
9571 vl_api_oam_add_del_t *mp;
9574 ip4_address_t src, dst;
9579 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9581 if (unformat (i, "vrf %d", &vrf_id))
9583 else if (unformat (i, "src %U", unformat_ip4_address, &src))
9585 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
9587 else if (unformat (i, "del"))
9591 clib_warning ("parse error '%U'", format_unformat_error, i);
9598 errmsg ("missing src addr");
9604 errmsg ("missing dst addr");
9608 M (OAM_ADD_DEL, mp);
9610 mp->vrf_id = ntohl (vrf_id);
9611 mp->is_add = is_add;
9612 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
9613 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
9621 api_reset_fib (vat_main_t * vam)
9623 unformat_input_t *i = vam->input;
9624 vl_api_reset_fib_t *mp;
9630 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9632 if (unformat (i, "vrf %d", &vrf_id))
9634 else if (unformat (i, "ipv6"))
9638 clib_warning ("parse error '%U'", format_unformat_error, i);
9643 if (vrf_id_set == 0)
9645 errmsg ("missing vrf id");
9651 mp->vrf_id = ntohl (vrf_id);
9652 mp->is_ipv6 = is_ipv6;
9660 api_dhcp_proxy_config (vat_main_t * vam)
9662 unformat_input_t *i = vam->input;
9663 vl_api_dhcp_proxy_config_t *mp;
9665 u32 server_vrf_id = 0;
9667 u8 v4_address_set = 0;
9668 u8 v6_address_set = 0;
9669 ip4_address_t v4address;
9670 ip6_address_t v6address;
9671 u8 v4_src_address_set = 0;
9672 u8 v6_src_address_set = 0;
9673 ip4_address_t v4srcaddress;
9674 ip6_address_t v6srcaddress;
9677 /* Parse args required to build the message */
9678 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9680 if (unformat (i, "del"))
9682 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
9684 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
9686 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
9688 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
9690 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
9691 v4_src_address_set = 1;
9692 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
9693 v6_src_address_set = 1;
9698 if (v4_address_set && v6_address_set)
9700 errmsg ("both v4 and v6 server addresses set");
9703 if (!v4_address_set && !v6_address_set)
9705 errmsg ("no server addresses set");
9709 if (v4_src_address_set && v6_src_address_set)
9711 errmsg ("both v4 and v6 src addresses set");
9714 if (!v4_src_address_set && !v6_src_address_set)
9716 errmsg ("no src addresses set");
9720 if (!(v4_src_address_set && v4_address_set) &&
9721 !(v6_src_address_set && v6_address_set))
9723 errmsg ("no matching server and src addresses set");
9727 /* Construct the API message */
9728 M (DHCP_PROXY_CONFIG, mp);
9730 mp->is_add = is_add;
9731 mp->rx_vrf_id = ntohl (rx_vrf_id);
9732 mp->server_vrf_id = ntohl (server_vrf_id);
9736 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
9737 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
9741 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
9742 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
9748 /* Wait for a reply, return good/bad news */
9753 #define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
9754 #define vl_api_dhcp_proxy_details_t_print vl_noop_handler
9757 vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
9759 vat_main_t *vam = &vat_main;
9760 u32 i, count = mp->count;
9761 vl_api_dhcp_server_t *s;
9765 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9766 "VSS ASCII VPN-ID '%s', VSS RFC2685 VPN-ID (oui:id) %d:%d",
9767 ntohl (mp->rx_vrf_id),
9768 format_ip6_address, mp->dhcp_src_address,
9769 mp->vss_type, mp->vss_vpn_ascii_id,
9770 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9773 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9774 "VSS ASCII VPN-ID '%s', VSS RFC2685 VPN-ID (oui:id) %d:%d",
9775 ntohl (mp->rx_vrf_id),
9776 format_ip4_address, mp->dhcp_src_address,
9777 mp->vss_type, mp->vss_vpn_ascii_id,
9778 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9780 for (i = 0; i < count; i++)
9782 s = &mp->servers[i];
9786 " Server Table-ID %d, Server Address %U",
9787 ntohl (s->server_vrf_id), format_ip6_address, s->dhcp_server);
9790 " Server Table-ID %d, Server Address %U",
9791 ntohl (s->server_vrf_id), format_ip4_address, s->dhcp_server);
9795 static void vl_api_dhcp_proxy_details_t_handler_json
9796 (vl_api_dhcp_proxy_details_t * mp)
9798 vat_main_t *vam = &vat_main;
9799 vat_json_node_t *node = NULL;
9800 u32 i, count = mp->count;
9802 struct in6_addr ip6;
9803 vl_api_dhcp_server_t *s;
9805 if (VAT_JSON_ARRAY != vam->json_tree.type)
9807 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9808 vat_json_init_array (&vam->json_tree);
9810 node = vat_json_array_add (&vam->json_tree);
9812 vat_json_init_object (node);
9813 vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
9814 vat_json_object_add_bytes (node, "vss-type", &mp->vss_type,
9815 sizeof (mp->vss_type));
9816 vat_json_object_add_string_copy (node, "vss-vpn-ascii-id",
9817 mp->vss_vpn_ascii_id);
9818 vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
9819 vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
9823 clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
9824 vat_json_object_add_ip6 (node, "src_address", ip6);
9828 clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
9829 vat_json_object_add_ip4 (node, "src_address", ip4);
9832 for (i = 0; i < count; i++)
9834 s = &mp->servers[i];
9836 vat_json_object_add_uint (node, "server-table-id",
9837 ntohl (s->server_vrf_id));
9841 clib_memcpy (&ip4, &s->dhcp_server, sizeof (ip4));
9842 vat_json_object_add_ip4 (node, "src_address", ip4);
9846 clib_memcpy (&ip6, &s->dhcp_server, sizeof (ip6));
9847 vat_json_object_add_ip6 (node, "server_address", ip6);
9853 api_dhcp_proxy_dump (vat_main_t * vam)
9855 unformat_input_t *i = vam->input;
9856 vl_api_control_ping_t *mp_ping;
9857 vl_api_dhcp_proxy_dump_t *mp;
9861 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9863 if (unformat (i, "ipv6"))
9867 clib_warning ("parse error '%U'", format_unformat_error, i);
9872 M (DHCP_PROXY_DUMP, mp);
9874 mp->is_ip6 = is_ipv6;
9877 /* Use a control ping for synchronization */
9878 MPING (CONTROL_PING, mp_ping);
9886 api_dhcp_proxy_set_vss (vat_main_t * vam)
9888 unformat_input_t *i = vam->input;
9889 vl_api_dhcp_proxy_set_vss_t *mp;
9893 u8 vss_type = VSS_TYPE_DEFAULT;
9894 u8 *vpn_ascii_id = 0;
9899 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9901 if (unformat (i, "tbl_id %d", &tbl_id))
9903 else if (unformat (i, "vpn_ascii_id %s", &vpn_ascii_id))
9904 vss_type = VSS_TYPE_ASCII;
9905 else if (unformat (i, "fib_id %d", &fib_id))
9906 vss_type = VSS_TYPE_VPN_ID;
9907 else if (unformat (i, "oui %d", &oui))
9908 vss_type = VSS_TYPE_VPN_ID;
9909 else if (unformat (i, "ipv6"))
9911 else if (unformat (i, "del"))
9919 errmsg ("missing tbl_id ");
9920 vec_free (vpn_ascii_id);
9924 if ((vpn_ascii_id) && (vec_len (vpn_ascii_id) > 128))
9926 errmsg ("vpn_ascii_id cannot be longer than 128 ");
9927 vec_free (vpn_ascii_id);
9931 M (DHCP_PROXY_SET_VSS, mp);
9932 mp->tbl_id = ntohl (tbl_id);
9933 mp->vss_type = vss_type;
9936 clib_memcpy (mp->vpn_ascii_id, vpn_ascii_id, vec_len (vpn_ascii_id));
9937 mp->vpn_ascii_id[vec_len (vpn_ascii_id)] = 0;
9939 mp->vpn_index = ntohl (fib_id);
9940 mp->oui = ntohl (oui);
9941 mp->is_ipv6 = is_ipv6;
9942 mp->is_add = is_add;
9947 vec_free (vpn_ascii_id);
9952 api_dhcp_client_config (vat_main_t * vam)
9954 unformat_input_t *i = vam->input;
9955 vl_api_dhcp_client_config_t *mp;
9957 u8 sw_if_index_set = 0;
9960 u8 disable_event = 0;
9963 /* Parse args required to build the message */
9964 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9966 if (unformat (i, "del"))
9969 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9970 sw_if_index_set = 1;
9971 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9972 sw_if_index_set = 1;
9973 else if (unformat (i, "hostname %s", &hostname))
9975 else if (unformat (i, "disable_event"))
9981 if (sw_if_index_set == 0)
9983 errmsg ("missing interface name or sw_if_index");
9987 if (vec_len (hostname) > 63)
9989 errmsg ("hostname too long");
9991 vec_add1 (hostname, 0);
9993 /* Construct the API message */
9994 M (DHCP_CLIENT_CONFIG, mp);
9996 mp->is_add = is_add;
9997 mp->client.sw_if_index = htonl (sw_if_index);
9998 clib_memcpy (mp->client.hostname, hostname, vec_len (hostname));
9999 vec_free (hostname);
10000 mp->client.want_dhcp_event = disable_event ? 0 : 1;
10001 mp->client.pid = htonl (getpid ());
10006 /* Wait for a reply, return good/bad news */
10012 api_set_ip_flow_hash (vat_main_t * vam)
10014 unformat_input_t *i = vam->input;
10015 vl_api_set_ip_flow_hash_t *mp;
10027 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10029 if (unformat (i, "vrf %d", &vrf_id))
10031 else if (unformat (i, "ipv6"))
10033 else if (unformat (i, "src"))
10035 else if (unformat (i, "dst"))
10037 else if (unformat (i, "sport"))
10039 else if (unformat (i, "dport"))
10041 else if (unformat (i, "proto"))
10043 else if (unformat (i, "reverse"))
10048 clib_warning ("parse error '%U'", format_unformat_error, i);
10053 if (vrf_id_set == 0)
10055 errmsg ("missing vrf id");
10059 M (SET_IP_FLOW_HASH, mp);
10065 mp->reverse = reverse;
10066 mp->vrf_id = ntohl (vrf_id);
10067 mp->is_ipv6 = is_ipv6;
10075 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
10077 unformat_input_t *i = vam->input;
10078 vl_api_sw_interface_ip6_enable_disable_t *mp;
10080 u8 sw_if_index_set = 0;
10084 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10086 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10087 sw_if_index_set = 1;
10088 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10089 sw_if_index_set = 1;
10090 else if (unformat (i, "enable"))
10092 else if (unformat (i, "disable"))
10096 clib_warning ("parse error '%U'", format_unformat_error, i);
10101 if (sw_if_index_set == 0)
10103 errmsg ("missing interface name or sw_if_index");
10107 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
10109 mp->sw_if_index = ntohl (sw_if_index);
10110 mp->enable = enable;
10118 api_ip6nd_proxy_add_del (vat_main_t * vam)
10120 unformat_input_t *i = vam->input;
10121 vl_api_ip6nd_proxy_add_del_t *mp;
10122 u32 sw_if_index = ~0;
10123 u8 v6_address_set = 0;
10124 vl_api_ip6_address_t v6address;
10128 /* Parse args required to build the message */
10129 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10131 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10133 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10135 else if (unformat (i, "%U", unformat_vl_api_ip6_address, &v6address))
10136 v6_address_set = 1;
10137 if (unformat (i, "del"))
10141 clib_warning ("parse error '%U'", format_unformat_error, i);
10146 if (sw_if_index == ~0)
10148 errmsg ("missing interface name or sw_if_index");
10151 if (!v6_address_set)
10153 errmsg ("no address set");
10157 /* Construct the API message */
10158 M (IP6ND_PROXY_ADD_DEL, mp);
10160 mp->is_del = is_del;
10161 mp->sw_if_index = ntohl (sw_if_index);
10162 clib_memcpy (mp->ip, v6address, sizeof (v6address));
10167 /* Wait for a reply, return good/bad news */
10173 api_ip6nd_proxy_dump (vat_main_t * vam)
10175 vl_api_ip6nd_proxy_dump_t *mp;
10176 vl_api_control_ping_t *mp_ping;
10179 M (IP6ND_PROXY_DUMP, mp);
10183 /* Use a control ping for synchronization */
10184 MPING (CONTROL_PING, mp_ping);
10191 static void vl_api_ip6nd_proxy_details_t_handler
10192 (vl_api_ip6nd_proxy_details_t * mp)
10194 vat_main_t *vam = &vat_main;
10196 print (vam->ofp, "host %U sw_if_index %d",
10197 format_vl_api_ip6_address, mp->ip, ntohl (mp->sw_if_index));
10200 static void vl_api_ip6nd_proxy_details_t_handler_json
10201 (vl_api_ip6nd_proxy_details_t * mp)
10203 vat_main_t *vam = &vat_main;
10204 struct in6_addr ip6;
10205 vat_json_node_t *node = NULL;
10207 if (VAT_JSON_ARRAY != vam->json_tree.type)
10209 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10210 vat_json_init_array (&vam->json_tree);
10212 node = vat_json_array_add (&vam->json_tree);
10214 vat_json_init_object (node);
10215 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10217 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
10218 vat_json_object_add_ip6 (node, "host", ip6);
10222 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
10224 unformat_input_t *i = vam->input;
10225 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
10227 u8 sw_if_index_set = 0;
10228 u32 address_length = 0;
10229 u8 v6_address_set = 0;
10230 vl_api_prefix_t pfx;
10231 u8 use_default = 0;
10232 u8 no_advertise = 0;
10234 u8 no_autoconfig = 0;
10237 u32 val_lifetime = 0;
10238 u32 pref_lifetime = 0;
10241 /* Parse args required to build the message */
10242 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10244 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10245 sw_if_index_set = 1;
10246 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10247 sw_if_index_set = 1;
10248 else if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
10249 v6_address_set = 1;
10250 else if (unformat (i, "val_life %d", &val_lifetime))
10252 else if (unformat (i, "pref_life %d", &pref_lifetime))
10254 else if (unformat (i, "def"))
10256 else if (unformat (i, "noadv"))
10258 else if (unformat (i, "offl"))
10260 else if (unformat (i, "noauto"))
10262 else if (unformat (i, "nolink"))
10264 else if (unformat (i, "isno"))
10268 clib_warning ("parse error '%U'", format_unformat_error, i);
10273 if (sw_if_index_set == 0)
10275 errmsg ("missing interface name or sw_if_index");
10278 if (!v6_address_set)
10280 errmsg ("no address set");
10284 /* Construct the API message */
10285 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
10287 mp->sw_if_index = ntohl (sw_if_index);
10288 clib_memcpy (&mp->prefix, &pfx, sizeof (pfx));
10289 mp->use_default = use_default;
10290 mp->no_advertise = no_advertise;
10291 mp->off_link = off_link;
10292 mp->no_autoconfig = no_autoconfig;
10293 mp->no_onlink = no_onlink;
10295 mp->val_lifetime = ntohl (val_lifetime);
10296 mp->pref_lifetime = ntohl (pref_lifetime);
10301 /* Wait for a reply, return good/bad news */
10307 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
10309 unformat_input_t *i = vam->input;
10310 vl_api_sw_interface_ip6nd_ra_config_t *mp;
10312 u8 sw_if_index_set = 0;
10317 u8 send_unicast = 0;
10320 u8 default_router = 0;
10321 u32 max_interval = 0;
10322 u32 min_interval = 0;
10324 u32 initial_count = 0;
10325 u32 initial_interval = 0;
10329 /* Parse args required to build the message */
10330 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10332 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10333 sw_if_index_set = 1;
10334 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10335 sw_if_index_set = 1;
10336 else if (unformat (i, "maxint %d", &max_interval))
10338 else if (unformat (i, "minint %d", &min_interval))
10340 else if (unformat (i, "life %d", &lifetime))
10342 else if (unformat (i, "count %d", &initial_count))
10344 else if (unformat (i, "interval %d", &initial_interval))
10346 else if (unformat (i, "suppress") || unformat (i, "surpress"))
10348 else if (unformat (i, "managed"))
10350 else if (unformat (i, "other"))
10352 else if (unformat (i, "ll"))
10354 else if (unformat (i, "send"))
10356 else if (unformat (i, "cease"))
10358 else if (unformat (i, "isno"))
10360 else if (unformat (i, "def"))
10361 default_router = 1;
10364 clib_warning ("parse error '%U'", format_unformat_error, i);
10369 if (sw_if_index_set == 0)
10371 errmsg ("missing interface name or sw_if_index");
10375 /* Construct the API message */
10376 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
10378 mp->sw_if_index = ntohl (sw_if_index);
10379 mp->max_interval = ntohl (max_interval);
10380 mp->min_interval = ntohl (min_interval);
10381 mp->lifetime = ntohl (lifetime);
10382 mp->initial_count = ntohl (initial_count);
10383 mp->initial_interval = ntohl (initial_interval);
10384 mp->suppress = suppress;
10385 mp->managed = managed;
10387 mp->ll_option = ll_option;
10388 mp->send_unicast = send_unicast;
10391 mp->default_router = default_router;
10396 /* Wait for a reply, return good/bad news */
10402 api_set_arp_neighbor_limit (vat_main_t * vam)
10404 unformat_input_t *i = vam->input;
10405 vl_api_set_arp_neighbor_limit_t *mp;
10411 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10413 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
10415 else if (unformat (i, "ipv6"))
10419 clib_warning ("parse error '%U'", format_unformat_error, i);
10424 if (limit_set == 0)
10426 errmsg ("missing limit value");
10430 M (SET_ARP_NEIGHBOR_LIMIT, mp);
10432 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
10433 mp->is_ipv6 = is_ipv6;
10441 api_l2_patch_add_del (vat_main_t * vam)
10443 unformat_input_t *i = vam->input;
10444 vl_api_l2_patch_add_del_t *mp;
10445 u32 rx_sw_if_index;
10446 u8 rx_sw_if_index_set = 0;
10447 u32 tx_sw_if_index;
10448 u8 tx_sw_if_index_set = 0;
10452 /* Parse args required to build the message */
10453 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10455 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
10456 rx_sw_if_index_set = 1;
10457 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
10458 tx_sw_if_index_set = 1;
10459 else if (unformat (i, "rx"))
10461 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10463 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10465 rx_sw_if_index_set = 1;
10470 else if (unformat (i, "tx"))
10472 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10474 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10476 tx_sw_if_index_set = 1;
10481 else if (unformat (i, "del"))
10487 if (rx_sw_if_index_set == 0)
10489 errmsg ("missing rx interface name or rx_sw_if_index");
10493 if (tx_sw_if_index_set == 0)
10495 errmsg ("missing tx interface name or tx_sw_if_index");
10499 M (L2_PATCH_ADD_DEL, mp);
10501 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
10502 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
10503 mp->is_add = is_add;
10511 u8 localsid_addr[16];
10520 api_sr_localsid_add_del (vat_main_t * vam)
10522 unformat_input_t *i = vam->input;
10523 vl_api_sr_localsid_add_del_t *mp;
10526 ip6_address_t localsid;
10530 u32 fib_table = ~(u32) 0;
10531 ip6_address_t nh_addr6;
10532 ip4_address_t nh_addr4;
10533 clib_memset (&nh_addr6, 0, sizeof (ip6_address_t));
10534 clib_memset (&nh_addr4, 0, sizeof (ip4_address_t));
10536 bool nexthop_set = 0;
10540 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10542 if (unformat (i, "del"))
10544 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
10545 else if (unformat (i, "next-hop %U", unformat_ip4_address, &nh_addr4))
10547 else if (unformat (i, "next-hop %U", unformat_ip6_address, &nh_addr6))
10549 else if (unformat (i, "behavior %u", &behavior));
10550 else if (unformat (i, "sw_if_index %u", &sw_if_index));
10551 else if (unformat (i, "fib-table %u", &fib_table));
10552 else if (unformat (i, "end.psp %u", &behavior));
10557 M (SR_LOCALSID_ADD_DEL, mp);
10559 clib_memcpy (mp->localsid.addr, &localsid, sizeof (mp->localsid));
10562 clib_memcpy (mp->nh_addr6, &nh_addr6, sizeof (mp->nh_addr6));
10563 clib_memcpy (mp->nh_addr4, &nh_addr4, sizeof (mp->nh_addr4));
10565 mp->behavior = behavior;
10566 mp->sw_if_index = ntohl (sw_if_index);
10567 mp->fib_table = ntohl (fib_table);
10568 mp->end_psp = end_psp;
10569 mp->is_del = is_del;
10577 api_ioam_enable (vat_main_t * vam)
10579 unformat_input_t *input = vam->input;
10580 vl_api_ioam_enable_t *mp;
10582 int has_trace_option = 0;
10583 int has_pot_option = 0;
10584 int has_seqno_option = 0;
10585 int has_analyse_option = 0;
10588 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10590 if (unformat (input, "trace"))
10591 has_trace_option = 1;
10592 else if (unformat (input, "pot"))
10593 has_pot_option = 1;
10594 else if (unformat (input, "seqno"))
10595 has_seqno_option = 1;
10596 else if (unformat (input, "analyse"))
10597 has_analyse_option = 1;
10601 M (IOAM_ENABLE, mp);
10602 mp->id = htons (id);
10603 mp->seqno = has_seqno_option;
10604 mp->analyse = has_analyse_option;
10605 mp->pot_enable = has_pot_option;
10606 mp->trace_enable = has_trace_option;
10615 api_ioam_disable (vat_main_t * vam)
10617 vl_api_ioam_disable_t *mp;
10620 M (IOAM_DISABLE, mp);
10626 #define foreach_tcp_proto_field \
10630 #define foreach_udp_proto_field \
10634 #define foreach_ip4_proto_field \
10646 u16 src_port, dst_port;
10649 #if VPP_API_TEST_BUILTIN == 0
10651 unformat_tcp_mask (unformat_input_t * input, va_list * args)
10653 u8 **maskp = va_arg (*args, u8 **);
10655 u8 found_something = 0;
10658 #define _(a) u8 a=0;
10659 foreach_tcp_proto_field;
10662 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10665 #define _(a) else if (unformat (input, #a)) a=1;
10666 foreach_tcp_proto_field
10672 #define _(a) found_something += a;
10673 foreach_tcp_proto_field;
10676 if (found_something == 0)
10679 vec_validate (mask, sizeof (*tcp) - 1);
10681 tcp = (tcp_header_t *) mask;
10683 #define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
10684 foreach_tcp_proto_field;
10692 unformat_udp_mask (unformat_input_t * input, va_list * args)
10694 u8 **maskp = va_arg (*args, u8 **);
10696 u8 found_something = 0;
10699 #define _(a) u8 a=0;
10700 foreach_udp_proto_field;
10703 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10706 #define _(a) else if (unformat (input, #a)) a=1;
10707 foreach_udp_proto_field
10713 #define _(a) found_something += a;
10714 foreach_udp_proto_field;
10717 if (found_something == 0)
10720 vec_validate (mask, sizeof (*udp) - 1);
10722 udp = (udp_header_t *) mask;
10724 #define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
10725 foreach_udp_proto_field;
10733 unformat_l4_mask (unformat_input_t * input, va_list * args)
10735 u8 **maskp = va_arg (*args, u8 **);
10736 u16 src_port = 0, dst_port = 0;
10737 tcpudp_header_t *tcpudp;
10739 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10741 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
10743 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
10745 else if (unformat (input, "src_port"))
10747 else if (unformat (input, "dst_port"))
10753 if (!src_port && !dst_port)
10757 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
10759 tcpudp = (tcpudp_header_t *) mask;
10760 tcpudp->src_port = src_port;
10761 tcpudp->dst_port = dst_port;
10769 unformat_ip4_mask (unformat_input_t * input, va_list * args)
10771 u8 **maskp = va_arg (*args, u8 **);
10773 u8 found_something = 0;
10776 #define _(a) u8 a=0;
10777 foreach_ip4_proto_field;
10783 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10785 if (unformat (input, "version"))
10787 else if (unformat (input, "hdr_length"))
10789 else if (unformat (input, "src"))
10791 else if (unformat (input, "dst"))
10793 else if (unformat (input, "proto"))
10796 #define _(a) else if (unformat (input, #a)) a=1;
10797 foreach_ip4_proto_field
10803 #define _(a) found_something += a;
10804 foreach_ip4_proto_field;
10807 if (found_something == 0)
10810 vec_validate (mask, sizeof (*ip) - 1);
10812 ip = (ip4_header_t *) mask;
10814 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
10815 foreach_ip4_proto_field;
10818 ip->ip_version_and_header_length = 0;
10821 ip->ip_version_and_header_length |= 0xF0;
10824 ip->ip_version_and_header_length |= 0x0F;
10830 #define foreach_ip6_proto_field \
10833 _(payload_length) \
10838 unformat_ip6_mask (unformat_input_t * input, va_list * args)
10840 u8 **maskp = va_arg (*args, u8 **);
10842 u8 found_something = 0;
10844 u32 ip_version_traffic_class_and_flow_label;
10846 #define _(a) u8 a=0;
10847 foreach_ip6_proto_field;
10850 u8 traffic_class = 0;
10853 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10855 if (unformat (input, "version"))
10857 else if (unformat (input, "traffic-class"))
10859 else if (unformat (input, "flow-label"))
10861 else if (unformat (input, "src"))
10863 else if (unformat (input, "dst"))
10865 else if (unformat (input, "proto"))
10868 #define _(a) else if (unformat (input, #a)) a=1;
10869 foreach_ip6_proto_field
10875 #define _(a) found_something += a;
10876 foreach_ip6_proto_field;
10879 if (found_something == 0)
10882 vec_validate (mask, sizeof (*ip) - 1);
10884 ip = (ip6_header_t *) mask;
10886 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
10887 foreach_ip6_proto_field;
10890 ip_version_traffic_class_and_flow_label = 0;
10893 ip_version_traffic_class_and_flow_label |= 0xF0000000;
10896 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
10899 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
10901 ip->ip_version_traffic_class_and_flow_label =
10902 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10909 unformat_l3_mask (unformat_input_t * input, va_list * args)
10911 u8 **maskp = va_arg (*args, u8 **);
10913 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10915 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
10917 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
10926 unformat_l2_mask (unformat_input_t * input, va_list * args)
10928 u8 **maskp = va_arg (*args, u8 **);
10935 u8 ignore_tag1 = 0;
10936 u8 ignore_tag2 = 0;
10943 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10945 if (unformat (input, "src"))
10947 else if (unformat (input, "dst"))
10949 else if (unformat (input, "proto"))
10951 else if (unformat (input, "tag1"))
10953 else if (unformat (input, "tag2"))
10955 else if (unformat (input, "ignore-tag1"))
10957 else if (unformat (input, "ignore-tag2"))
10959 else if (unformat (input, "cos1"))
10961 else if (unformat (input, "cos2"))
10963 else if (unformat (input, "dot1q"))
10965 else if (unformat (input, "dot1ad"))
10970 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
10971 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10974 if (tag1 || ignore_tag1 || cos1 || dot1q)
10976 if (tag2 || ignore_tag2 || cos2 || dot1ad)
10979 vec_validate (mask, len - 1);
10982 clib_memset (mask, 0xff, 6);
10985 clib_memset (mask + 6, 0xff, 6);
10987 if (tag2 || dot1ad)
10989 /* inner vlan tag */
10998 mask[21] = mask[20] = 0xff;
11019 mask[16] = mask[17] = 0xff;
11029 mask[12] = mask[13] = 0xff;
11036 unformat_classify_mask (unformat_input_t * input, va_list * args)
11038 u8 **maskp = va_arg (*args, u8 **);
11039 u32 *skipp = va_arg (*args, u32 *);
11040 u32 *matchp = va_arg (*args, u32 *);
11048 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11050 if (unformat (input, "hex %U", unformat_hex_string, &mask))
11052 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
11054 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
11056 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
11070 if (mask || l2 || l3 || l4)
11072 if (l2 || l3 || l4)
11074 /* "With a free Ethernet header in every package" */
11076 vec_validate (l2, 13);
11080 vec_append (mask, l3);
11085 vec_append (mask, l4);
11090 /* Scan forward looking for the first significant mask octet */
11091 for (i = 0; i < vec_len (mask); i++)
11095 /* compute (skip, match) params */
11096 *skipp = i / sizeof (u32x4);
11097 vec_delete (mask, *skipp * sizeof (u32x4), 0);
11099 /* Pad mask to an even multiple of the vector size */
11100 while (vec_len (mask) % sizeof (u32x4))
11101 vec_add1 (mask, 0);
11103 match = vec_len (mask) / sizeof (u32x4);
11105 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
11107 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
11108 if (*tmp || *(tmp + 1))
11113 clib_warning ("BUG: match 0");
11115 _vec_len (mask) = match * sizeof (u32x4);
11125 #endif /* VPP_API_TEST_BUILTIN */
11127 #define foreach_l2_next \
11129 _(ethernet, ETHERNET_INPUT) \
11130 _(ip4, IP4_INPUT) \
11134 unformat_l2_next_index (unformat_input_t * input, va_list * args)
11136 u32 *miss_next_indexp = va_arg (*args, u32 *);
11137 u32 next_index = 0;
11141 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
11145 if (unformat (input, "%d", &tmp))
11154 *miss_next_indexp = next_index;
11158 #define foreach_ip_next \
11161 _(rewrite, REWRITE)
11164 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
11166 u32 *miss_next_indexp = va_arg (*args, u32 *);
11167 u32 next_index = 0;
11171 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
11175 if (unformat (input, "%d", &tmp))
11184 *miss_next_indexp = next_index;
11188 #define foreach_acl_next \
11192 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
11194 u32 *miss_next_indexp = va_arg (*args, u32 *);
11195 u32 next_index = 0;
11199 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
11203 if (unformat (input, "permit"))
11208 else if (unformat (input, "%d", &tmp))
11217 *miss_next_indexp = next_index;
11222 unformat_policer_precolor (unformat_input_t * input, va_list * args)
11224 u32 *r = va_arg (*args, u32 *);
11226 if (unformat (input, "conform-color"))
11227 *r = POLICE_CONFORM;
11228 else if (unformat (input, "exceed-color"))
11229 *r = POLICE_EXCEED;
11237 api_classify_add_del_table (vat_main_t * vam)
11239 unformat_input_t *i = vam->input;
11240 vl_api_classify_add_del_table_t *mp;
11247 u32 table_index = ~0;
11248 u32 next_table_index = ~0;
11249 u32 miss_next_index = ~0;
11250 u32 memory_size = 32 << 20;
11252 u32 current_data_flag = 0;
11253 int current_data_offset = 0;
11256 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11258 if (unformat (i, "del"))
11260 else if (unformat (i, "del-chain"))
11265 else if (unformat (i, "buckets %d", &nbuckets))
11267 else if (unformat (i, "memory_size %d", &memory_size))
11269 else if (unformat (i, "skip %d", &skip))
11271 else if (unformat (i, "match %d", &match))
11273 else if (unformat (i, "table %d", &table_index))
11275 else if (unformat (i, "mask %U", unformat_classify_mask,
11276 &mask, &skip, &match))
11278 else if (unformat (i, "next-table %d", &next_table_index))
11280 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
11283 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
11286 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
11289 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
11291 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
11297 if (is_add && mask == 0)
11299 errmsg ("Mask required");
11303 if (is_add && skip == ~0)
11305 errmsg ("skip count required");
11309 if (is_add && match == ~0)
11311 errmsg ("match count required");
11315 if (!is_add && table_index == ~0)
11317 errmsg ("table index required for delete");
11321 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
11323 mp->is_add = is_add;
11324 mp->del_chain = del_chain;
11325 mp->table_index = ntohl (table_index);
11326 mp->nbuckets = ntohl (nbuckets);
11327 mp->memory_size = ntohl (memory_size);
11328 mp->skip_n_vectors = ntohl (skip);
11329 mp->match_n_vectors = ntohl (match);
11330 mp->next_table_index = ntohl (next_table_index);
11331 mp->miss_next_index = ntohl (miss_next_index);
11332 mp->current_data_flag = ntohl (current_data_flag);
11333 mp->current_data_offset = ntohl (current_data_offset);
11334 mp->mask_len = ntohl (vec_len (mask));
11335 clib_memcpy (mp->mask, mask, vec_len (mask));
11344 #if VPP_API_TEST_BUILTIN == 0
11346 unformat_l4_match (unformat_input_t * input, va_list * args)
11348 u8 **matchp = va_arg (*args, u8 **);
11350 u8 *proto_header = 0;
11356 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11358 if (unformat (input, "src_port %d", &src_port))
11360 else if (unformat (input, "dst_port %d", &dst_port))
11366 h.src_port = clib_host_to_net_u16 (src_port);
11367 h.dst_port = clib_host_to_net_u16 (dst_port);
11368 vec_validate (proto_header, sizeof (h) - 1);
11369 memcpy (proto_header, &h, sizeof (h));
11371 *matchp = proto_header;
11377 unformat_ip4_match (unformat_input_t * input, va_list * args)
11379 u8 **matchp = va_arg (*args, u8 **);
11384 int hdr_length = 0;
11385 u32 hdr_length_val;
11386 int src = 0, dst = 0;
11387 ip4_address_t src_val, dst_val;
11394 int fragment_id = 0;
11395 u32 fragment_id_val;
11401 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11403 if (unformat (input, "version %d", &version_val))
11405 else if (unformat (input, "hdr_length %d", &hdr_length_val))
11407 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
11409 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
11411 else if (unformat (input, "proto %d", &proto_val))
11413 else if (unformat (input, "tos %d", &tos_val))
11415 else if (unformat (input, "length %d", &length_val))
11417 else if (unformat (input, "fragment_id %d", &fragment_id_val))
11419 else if (unformat (input, "ttl %d", &ttl_val))
11421 else if (unformat (input, "checksum %d", &checksum_val))
11427 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
11428 + ttl + checksum == 0)
11432 * Aligned because we use the real comparison functions
11434 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11436 ip = (ip4_header_t *) match;
11438 /* These are realistically matched in practice */
11440 ip->src_address.as_u32 = src_val.as_u32;
11443 ip->dst_address.as_u32 = dst_val.as_u32;
11446 ip->protocol = proto_val;
11449 /* These are not, but they're included for completeness */
11451 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
11454 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
11460 ip->length = clib_host_to_net_u16 (length_val);
11466 ip->checksum = clib_host_to_net_u16 (checksum_val);
11473 unformat_ip6_match (unformat_input_t * input, va_list * args)
11475 u8 **matchp = va_arg (*args, u8 **);
11480 u8 traffic_class = 0;
11481 u32 traffic_class_val = 0;
11484 int src = 0, dst = 0;
11485 ip6_address_t src_val, dst_val;
11488 int payload_length = 0;
11489 u32 payload_length_val;
11492 u32 ip_version_traffic_class_and_flow_label;
11494 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11496 if (unformat (input, "version %d", &version_val))
11498 else if (unformat (input, "traffic_class %d", &traffic_class_val))
11500 else if (unformat (input, "flow_label %d", &flow_label_val))
11502 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
11504 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
11506 else if (unformat (input, "proto %d", &proto_val))
11508 else if (unformat (input, "payload_length %d", &payload_length_val))
11509 payload_length = 1;
11510 else if (unformat (input, "hop_limit %d", &hop_limit_val))
11516 if (version + traffic_class + flow_label + src + dst + proto +
11517 payload_length + hop_limit == 0)
11521 * Aligned because we use the real comparison functions
11523 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11525 ip = (ip6_header_t *) match;
11528 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
11531 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
11534 ip->protocol = proto_val;
11536 ip_version_traffic_class_and_flow_label = 0;
11539 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
11542 ip_version_traffic_class_and_flow_label |=
11543 (traffic_class_val & 0xFF) << 20;
11546 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
11548 ip->ip_version_traffic_class_and_flow_label =
11549 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
11551 if (payload_length)
11552 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
11555 ip->hop_limit = hop_limit_val;
11562 unformat_l3_match (unformat_input_t * input, va_list * args)
11564 u8 **matchp = va_arg (*args, u8 **);
11566 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11568 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
11570 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
11579 unformat_vlan_tag (unformat_input_t * input, va_list * args)
11581 u8 *tagp = va_arg (*args, u8 *);
11584 if (unformat (input, "%d", &tag))
11586 tagp[0] = (tag >> 8) & 0x0F;
11587 tagp[1] = tag & 0xFF;
11595 unformat_l2_match (unformat_input_t * input, va_list * args)
11597 u8 **matchp = va_arg (*args, u8 **);
11610 u8 ignore_tag1 = 0;
11611 u8 ignore_tag2 = 0;
11617 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11619 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
11622 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
11624 else if (unformat (input, "proto %U",
11625 unformat_ethernet_type_host_byte_order, &proto_val))
11627 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
11629 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
11631 else if (unformat (input, "ignore-tag1"))
11633 else if (unformat (input, "ignore-tag2"))
11635 else if (unformat (input, "cos1 %d", &cos1_val))
11637 else if (unformat (input, "cos2 %d", &cos2_val))
11642 if ((src + dst + proto + tag1 + tag2 +
11643 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
11646 if (tag1 || ignore_tag1 || cos1)
11648 if (tag2 || ignore_tag2 || cos2)
11651 vec_validate_aligned (match, len - 1, sizeof (u32x4));
11654 clib_memcpy (match, dst_val, 6);
11657 clib_memcpy (match + 6, src_val, 6);
11661 /* inner vlan tag */
11662 match[19] = tag2_val[1];
11663 match[18] = tag2_val[0];
11665 match[18] |= (cos2_val & 0x7) << 5;
11668 match[21] = proto_val & 0xff;
11669 match[20] = proto_val >> 8;
11673 match[15] = tag1_val[1];
11674 match[14] = tag1_val[0];
11677 match[14] |= (cos1_val & 0x7) << 5;
11683 match[15] = tag1_val[1];
11684 match[14] = tag1_val[0];
11687 match[17] = proto_val & 0xff;
11688 match[16] = proto_val >> 8;
11691 match[14] |= (cos1_val & 0x7) << 5;
11697 match[18] |= (cos2_val & 0x7) << 5;
11699 match[14] |= (cos1_val & 0x7) << 5;
11702 match[13] = proto_val & 0xff;
11703 match[12] = proto_val >> 8;
11711 unformat_qos_source (unformat_input_t * input, va_list * args)
11713 int *qs = va_arg (*args, int *);
11715 if (unformat (input, "ip"))
11716 *qs = QOS_SOURCE_IP;
11717 else if (unformat (input, "mpls"))
11718 *qs = QOS_SOURCE_MPLS;
11719 else if (unformat (input, "ext"))
11720 *qs = QOS_SOURCE_EXT;
11721 else if (unformat (input, "vlan"))
11722 *qs = QOS_SOURCE_VLAN;
11731 api_unformat_classify_match (unformat_input_t * input, va_list * args)
11733 u8 **matchp = va_arg (*args, u8 **);
11734 u32 skip_n_vectors = va_arg (*args, u32);
11735 u32 match_n_vectors = va_arg (*args, u32);
11742 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11744 if (unformat (input, "hex %U", unformat_hex_string, &match))
11746 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
11748 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
11750 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
11764 if (match || l2 || l3 || l4)
11766 if (l2 || l3 || l4)
11768 /* "Win a free Ethernet header in every packet" */
11770 vec_validate_aligned (l2, 13, sizeof (u32x4));
11774 vec_append_aligned (match, l3, sizeof (u32x4));
11779 vec_append_aligned (match, l4, sizeof (u32x4));
11784 /* Make sure the vector is big enough even if key is all 0's */
11785 vec_validate_aligned
11786 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
11789 /* Set size, include skipped vectors */
11790 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
11801 api_classify_add_del_session (vat_main_t * vam)
11803 unformat_input_t *i = vam->input;
11804 vl_api_classify_add_del_session_t *mp;
11806 u32 table_index = ~0;
11807 u32 hit_next_index = ~0;
11808 u32 opaque_index = ~0;
11811 u32 skip_n_vectors = 0;
11812 u32 match_n_vectors = 0;
11818 * Warning: you have to supply skip_n and match_n
11819 * because the API client cant simply look at the classify
11823 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11825 if (unformat (i, "del"))
11827 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
11830 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
11833 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
11836 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
11838 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
11840 else if (unformat (i, "opaque-index %d", &opaque_index))
11842 else if (unformat (i, "skip_n %d", &skip_n_vectors))
11844 else if (unformat (i, "match_n %d", &match_n_vectors))
11846 else if (unformat (i, "match %U", api_unformat_classify_match,
11847 &match, skip_n_vectors, match_n_vectors))
11849 else if (unformat (i, "advance %d", &advance))
11851 else if (unformat (i, "table-index %d", &table_index))
11853 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
11855 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
11857 else if (unformat (i, "action %d", &action))
11859 else if (unformat (i, "metadata %d", &metadata))
11865 if (table_index == ~0)
11867 errmsg ("Table index required");
11871 if (is_add && match == 0)
11873 errmsg ("Match value required");
11877 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
11879 mp->is_add = is_add;
11880 mp->table_index = ntohl (table_index);
11881 mp->hit_next_index = ntohl (hit_next_index);
11882 mp->opaque_index = ntohl (opaque_index);
11883 mp->advance = ntohl (advance);
11884 mp->action = action;
11885 mp->metadata = ntohl (metadata);
11886 mp->match_len = ntohl (vec_len (match));
11887 clib_memcpy (mp->match, match, vec_len (match));
11896 api_classify_set_interface_ip_table (vat_main_t * vam)
11898 unformat_input_t *i = vam->input;
11899 vl_api_classify_set_interface_ip_table_t *mp;
11901 int sw_if_index_set;
11902 u32 table_index = ~0;
11906 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11908 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11909 sw_if_index_set = 1;
11910 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11911 sw_if_index_set = 1;
11912 else if (unformat (i, "table %d", &table_index))
11916 clib_warning ("parse error '%U'", format_unformat_error, i);
11921 if (sw_if_index_set == 0)
11923 errmsg ("missing interface name or sw_if_index");
11928 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
11930 mp->sw_if_index = ntohl (sw_if_index);
11931 mp->table_index = ntohl (table_index);
11932 mp->is_ipv6 = is_ipv6;
11940 api_classify_set_interface_l2_tables (vat_main_t * vam)
11942 unformat_input_t *i = vam->input;
11943 vl_api_classify_set_interface_l2_tables_t *mp;
11945 int sw_if_index_set;
11946 u32 ip4_table_index = ~0;
11947 u32 ip6_table_index = ~0;
11948 u32 other_table_index = ~0;
11952 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11954 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11955 sw_if_index_set = 1;
11956 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11957 sw_if_index_set = 1;
11958 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11960 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11962 else if (unformat (i, "other-table %d", &other_table_index))
11964 else if (unformat (i, "is-input %d", &is_input))
11968 clib_warning ("parse error '%U'", format_unformat_error, i);
11973 if (sw_if_index_set == 0)
11975 errmsg ("missing interface name or sw_if_index");
11980 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
11982 mp->sw_if_index = ntohl (sw_if_index);
11983 mp->ip4_table_index = ntohl (ip4_table_index);
11984 mp->ip6_table_index = ntohl (ip6_table_index);
11985 mp->other_table_index = ntohl (other_table_index);
11986 mp->is_input = (u8) is_input;
11994 api_set_ipfix_exporter (vat_main_t * vam)
11996 unformat_input_t *i = vam->input;
11997 vl_api_set_ipfix_exporter_t *mp;
11998 ip4_address_t collector_address;
11999 u8 collector_address_set = 0;
12000 u32 collector_port = ~0;
12001 ip4_address_t src_address;
12002 u8 src_address_set = 0;
12005 u32 template_interval = ~0;
12006 u8 udp_checksum = 0;
12009 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12011 if (unformat (i, "collector_address %U", unformat_ip4_address,
12012 &collector_address))
12013 collector_address_set = 1;
12014 else if (unformat (i, "collector_port %d", &collector_port))
12016 else if (unformat (i, "src_address %U", unformat_ip4_address,
12018 src_address_set = 1;
12019 else if (unformat (i, "vrf_id %d", &vrf_id))
12021 else if (unformat (i, "path_mtu %d", &path_mtu))
12023 else if (unformat (i, "template_interval %d", &template_interval))
12025 else if (unformat (i, "udp_checksum"))
12031 if (collector_address_set == 0)
12033 errmsg ("collector_address required");
12037 if (src_address_set == 0)
12039 errmsg ("src_address required");
12043 M (SET_IPFIX_EXPORTER, mp);
12045 memcpy (mp->collector_address, collector_address.data,
12046 sizeof (collector_address.data));
12047 mp->collector_port = htons ((u16) collector_port);
12048 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
12049 mp->vrf_id = htonl (vrf_id);
12050 mp->path_mtu = htonl (path_mtu);
12051 mp->template_interval = htonl (template_interval);
12052 mp->udp_checksum = udp_checksum;
12060 api_set_ipfix_classify_stream (vat_main_t * vam)
12062 unformat_input_t *i = vam->input;
12063 vl_api_set_ipfix_classify_stream_t *mp;
12065 u32 src_port = UDP_DST_PORT_ipfix;
12068 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12070 if (unformat (i, "domain %d", &domain_id))
12072 else if (unformat (i, "src_port %d", &src_port))
12076 errmsg ("unknown input `%U'", format_unformat_error, i);
12081 M (SET_IPFIX_CLASSIFY_STREAM, mp);
12083 mp->domain_id = htonl (domain_id);
12084 mp->src_port = htons ((u16) src_port);
12092 api_ipfix_classify_table_add_del (vat_main_t * vam)
12094 unformat_input_t *i = vam->input;
12095 vl_api_ipfix_classify_table_add_del_t *mp;
12097 u32 classify_table_index = ~0;
12099 u8 transport_protocol = 255;
12102 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12104 if (unformat (i, "add"))
12106 else if (unformat (i, "del"))
12108 else if (unformat (i, "table %d", &classify_table_index))
12110 else if (unformat (i, "ip4"))
12112 else if (unformat (i, "ip6"))
12114 else if (unformat (i, "tcp"))
12115 transport_protocol = 6;
12116 else if (unformat (i, "udp"))
12117 transport_protocol = 17;
12120 errmsg ("unknown input `%U'", format_unformat_error, i);
12127 errmsg ("expecting: add|del");
12130 if (classify_table_index == ~0)
12132 errmsg ("classifier table not specified");
12135 if (ip_version == 0)
12137 errmsg ("IP version not specified");
12141 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
12143 mp->is_add = is_add;
12144 mp->table_id = htonl (classify_table_index);
12145 mp->ip_version = ip_version;
12146 mp->transport_protocol = transport_protocol;
12154 api_get_node_index (vat_main_t * vam)
12156 unformat_input_t *i = vam->input;
12157 vl_api_get_node_index_t *mp;
12161 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12163 if (unformat (i, "node %s", &name))
12170 errmsg ("node name required");
12173 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
12175 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12179 M (GET_NODE_INDEX, mp);
12180 clib_memcpy (mp->node_name, name, vec_len (name));
12189 api_get_next_index (vat_main_t * vam)
12191 unformat_input_t *i = vam->input;
12192 vl_api_get_next_index_t *mp;
12193 u8 *node_name = 0, *next_node_name = 0;
12196 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12198 if (unformat (i, "node-name %s", &node_name))
12200 else if (unformat (i, "next-node-name %s", &next_node_name))
12204 if (node_name == 0)
12206 errmsg ("node name required");
12209 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
12211 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12215 if (next_node_name == 0)
12217 errmsg ("next node name required");
12220 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
12222 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
12226 M (GET_NEXT_INDEX, mp);
12227 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
12228 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
12229 vec_free (node_name);
12230 vec_free (next_node_name);
12238 api_add_node_next (vat_main_t * vam)
12240 unformat_input_t *i = vam->input;
12241 vl_api_add_node_next_t *mp;
12246 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12248 if (unformat (i, "node %s", &name))
12250 else if (unformat (i, "next %s", &next))
12257 errmsg ("node name required");
12260 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
12262 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12267 errmsg ("next node required");
12270 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
12272 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
12276 M (ADD_NODE_NEXT, mp);
12277 clib_memcpy (mp->node_name, name, vec_len (name));
12278 clib_memcpy (mp->next_name, next, vec_len (next));
12288 api_l2tpv3_create_tunnel (vat_main_t * vam)
12290 unformat_input_t *i = vam->input;
12291 ip6_address_t client_address, our_address;
12292 int client_address_set = 0;
12293 int our_address_set = 0;
12294 u32 local_session_id = 0;
12295 u32 remote_session_id = 0;
12296 u64 local_cookie = 0;
12297 u64 remote_cookie = 0;
12298 u8 l2_sublayer_present = 0;
12299 vl_api_l2tpv3_create_tunnel_t *mp;
12302 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12304 if (unformat (i, "client_address %U", unformat_ip6_address,
12306 client_address_set = 1;
12307 else if (unformat (i, "our_address %U", unformat_ip6_address,
12309 our_address_set = 1;
12310 else if (unformat (i, "local_session_id %d", &local_session_id))
12312 else if (unformat (i, "remote_session_id %d", &remote_session_id))
12314 else if (unformat (i, "local_cookie %lld", &local_cookie))
12316 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
12318 else if (unformat (i, "l2-sublayer-present"))
12319 l2_sublayer_present = 1;
12324 if (client_address_set == 0)
12326 errmsg ("client_address required");
12330 if (our_address_set == 0)
12332 errmsg ("our_address required");
12336 M (L2TPV3_CREATE_TUNNEL, mp);
12338 clib_memcpy (mp->client_address, client_address.as_u8,
12339 sizeof (mp->client_address));
12341 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
12343 mp->local_session_id = ntohl (local_session_id);
12344 mp->remote_session_id = ntohl (remote_session_id);
12345 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
12346 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
12347 mp->l2_sublayer_present = l2_sublayer_present;
12356 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
12358 unformat_input_t *i = vam->input;
12360 u8 sw_if_index_set = 0;
12361 u64 new_local_cookie = 0;
12362 u64 new_remote_cookie = 0;
12363 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
12366 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12368 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12369 sw_if_index_set = 1;
12370 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12371 sw_if_index_set = 1;
12372 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
12374 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
12380 if (sw_if_index_set == 0)
12382 errmsg ("missing interface name or sw_if_index");
12386 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
12388 mp->sw_if_index = ntohl (sw_if_index);
12389 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
12390 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
12398 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
12400 unformat_input_t *i = vam->input;
12401 vl_api_l2tpv3_interface_enable_disable_t *mp;
12403 u8 sw_if_index_set = 0;
12404 u8 enable_disable = 1;
12407 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12409 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12410 sw_if_index_set = 1;
12411 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12412 sw_if_index_set = 1;
12413 else if (unformat (i, "enable"))
12414 enable_disable = 1;
12415 else if (unformat (i, "disable"))
12416 enable_disable = 0;
12421 if (sw_if_index_set == 0)
12423 errmsg ("missing interface name or sw_if_index");
12427 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
12429 mp->sw_if_index = ntohl (sw_if_index);
12430 mp->enable_disable = enable_disable;
12438 api_l2tpv3_set_lookup_key (vat_main_t * vam)
12440 unformat_input_t *i = vam->input;
12441 vl_api_l2tpv3_set_lookup_key_t *mp;
12445 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12447 if (unformat (i, "lookup_v6_src"))
12448 key = L2T_LOOKUP_SRC_ADDRESS;
12449 else if (unformat (i, "lookup_v6_dst"))
12450 key = L2T_LOOKUP_DST_ADDRESS;
12451 else if (unformat (i, "lookup_session_id"))
12452 key = L2T_LOOKUP_SESSION_ID;
12457 if (key == (u8) ~ 0)
12459 errmsg ("l2tp session lookup key unset");
12463 M (L2TPV3_SET_LOOKUP_KEY, mp);
12472 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
12473 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12475 vat_main_t *vam = &vat_main;
12477 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
12478 format_ip6_address, mp->our_address,
12479 format_ip6_address, mp->client_address,
12480 clib_net_to_host_u32 (mp->sw_if_index));
12483 " local cookies %016llx %016llx remote cookie %016llx",
12484 clib_net_to_host_u64 (mp->local_cookie[0]),
12485 clib_net_to_host_u64 (mp->local_cookie[1]),
12486 clib_net_to_host_u64 (mp->remote_cookie));
12488 print (vam->ofp, " local session-id %d remote session-id %d",
12489 clib_net_to_host_u32 (mp->local_session_id),
12490 clib_net_to_host_u32 (mp->remote_session_id));
12492 print (vam->ofp, " l2 specific sublayer %s\n",
12493 mp->l2_sublayer_present ? "preset" : "absent");
12497 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
12498 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12500 vat_main_t *vam = &vat_main;
12501 vat_json_node_t *node = NULL;
12502 struct in6_addr addr;
12504 if (VAT_JSON_ARRAY != vam->json_tree.type)
12506 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12507 vat_json_init_array (&vam->json_tree);
12509 node = vat_json_array_add (&vam->json_tree);
12511 vat_json_init_object (node);
12513 clib_memcpy (&addr, mp->our_address, sizeof (addr));
12514 vat_json_object_add_ip6 (node, "our_address", addr);
12515 clib_memcpy (&addr, mp->client_address, sizeof (addr));
12516 vat_json_object_add_ip6 (node, "client_address", addr);
12518 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
12519 vat_json_init_array (lc);
12520 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
12521 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
12522 vat_json_object_add_uint (node, "remote_cookie",
12523 clib_net_to_host_u64 (mp->remote_cookie));
12525 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
12526 vat_json_object_add_uint (node, "local_session_id",
12527 clib_net_to_host_u32 (mp->local_session_id));
12528 vat_json_object_add_uint (node, "remote_session_id",
12529 clib_net_to_host_u32 (mp->remote_session_id));
12530 vat_json_object_add_string_copy (node, "l2_sublayer",
12531 mp->l2_sublayer_present ? (u8 *) "present"
12532 : (u8 *) "absent");
12536 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
12538 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
12539 vl_api_control_ping_t *mp_ping;
12542 /* Get list of l2tpv3-tunnel interfaces */
12543 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
12546 /* Use a control ping for synchronization */
12547 MPING (CONTROL_PING, mp_ping);
12555 static void vl_api_sw_interface_tap_v2_details_t_handler
12556 (vl_api_sw_interface_tap_v2_details_t * mp)
12558 vat_main_t *vam = &vat_main;
12560 u8 *ip4 = format (0, "%U/%d", format_ip4_address, mp->host_ip4_addr,
12561 mp->host_ip4_prefix_len);
12562 u8 *ip6 = format (0, "%U/%d", format_ip6_address, mp->host_ip6_addr,
12563 mp->host_ip6_prefix_len);
12566 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s 0x%-08x",
12567 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
12568 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
12569 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
12570 mp->host_bridge, ip4, ip6, ntohl (mp->tap_flags));
12576 static void vl_api_sw_interface_tap_v2_details_t_handler_json
12577 (vl_api_sw_interface_tap_v2_details_t * mp)
12579 vat_main_t *vam = &vat_main;
12580 vat_json_node_t *node = NULL;
12582 if (VAT_JSON_ARRAY != vam->json_tree.type)
12584 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12585 vat_json_init_array (&vam->json_tree);
12587 node = vat_json_array_add (&vam->json_tree);
12589 vat_json_init_object (node);
12590 vat_json_object_add_uint (node, "id", ntohl (mp->id));
12591 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12592 vat_json_object_add_uint (node, "tap_flags", ntohl (mp->tap_flags));
12593 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
12594 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
12595 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
12596 vat_json_object_add_string_copy (node, "host_mac_addr",
12597 format (0, "%U", format_ethernet_address,
12598 &mp->host_mac_addr));
12599 vat_json_object_add_string_copy (node, "host_namespace",
12600 mp->host_namespace);
12601 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
12602 vat_json_object_add_string_copy (node, "host_ip4_addr",
12603 format (0, "%U/%d", format_ip4_address,
12605 mp->host_ip4_prefix_len));
12606 vat_json_object_add_string_copy (node, "host_ip6_addr",
12607 format (0, "%U/%d", format_ip6_address,
12609 mp->host_ip6_prefix_len));
12614 api_sw_interface_tap_v2_dump (vat_main_t * vam)
12616 vl_api_sw_interface_tap_v2_dump_t *mp;
12617 vl_api_control_ping_t *mp_ping;
12621 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
12622 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
12623 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
12626 /* Get list of tap interfaces */
12627 M (SW_INTERFACE_TAP_V2_DUMP, mp);
12630 /* Use a control ping for synchronization */
12631 MPING (CONTROL_PING, mp_ping);
12638 static void vl_api_sw_interface_virtio_pci_details_t_handler
12639 (vl_api_sw_interface_virtio_pci_details_t * mp)
12641 vat_main_t *vam = &vat_main;
12655 addr.as_u32 = ntohl (mp->pci_addr);
12656 u8 *pci_addr = format (0, "%04x:%02x:%02x.%x", addr.domain, addr.bus,
12657 addr.slot, addr.function);
12660 "\n%-12s %-12d %-12d %-12d %-17U 0x%-08llx",
12661 pci_addr, ntohl (mp->sw_if_index),
12662 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
12663 format_ethernet_address, mp->mac_addr,
12664 clib_net_to_host_u64 (mp->features));
12665 vec_free (pci_addr);
12668 static void vl_api_sw_interface_virtio_pci_details_t_handler_json
12669 (vl_api_sw_interface_virtio_pci_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, "pci-addr", ntohl (mp->pci_addr));
12683 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12684 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
12685 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
12686 vat_json_object_add_uint (node, "features",
12687 clib_net_to_host_u64 (mp->features));
12688 vat_json_object_add_string_copy (node, "mac_addr",
12689 format (0, "%U", format_ethernet_address,
12694 api_sw_interface_virtio_pci_dump (vat_main_t * vam)
12696 vl_api_sw_interface_virtio_pci_dump_t *mp;
12697 vl_api_control_ping_t *mp_ping;
12701 "\n%-12s %-12s %-12s %-12s %-17s %-08s",
12702 "pci_addr", "sw_if_index", "rx_ring_sz", "tx_ring_sz",
12703 "mac_addr", "features");
12705 /* Get list of tap interfaces */
12706 M (SW_INTERFACE_VIRTIO_PCI_DUMP, mp);
12709 /* Use a control ping for synchronization */
12710 MPING (CONTROL_PING, mp_ping);
12718 api_vxlan_offload_rx (vat_main_t * vam)
12720 unformat_input_t *line_input = vam->input;
12721 vl_api_vxlan_offload_rx_t *mp;
12722 u32 hw_if_index = ~0, rx_if_index = ~0;
12726 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12728 if (unformat (line_input, "del"))
12730 else if (unformat (line_input, "hw %U", api_unformat_hw_if_index, vam,
12733 else if (unformat (line_input, "hw hw_if_index %u", &hw_if_index))
12735 else if (unformat (line_input, "rx %U", api_unformat_sw_if_index, vam,
12738 else if (unformat (line_input, "rx sw_if_index %u", &rx_if_index))
12742 errmsg ("parse error '%U'", format_unformat_error, line_input);
12747 if (hw_if_index == ~0)
12749 errmsg ("no hw interface");
12753 if (rx_if_index == ~0)
12755 errmsg ("no rx tunnel");
12759 M (VXLAN_OFFLOAD_RX, mp);
12761 mp->hw_if_index = ntohl (hw_if_index);
12762 mp->sw_if_index = ntohl (rx_if_index);
12763 mp->enable = is_add;
12770 static uword unformat_vxlan_decap_next
12771 (unformat_input_t * input, va_list * args)
12773 u32 *result = va_arg (*args, u32 *);
12776 if (unformat (input, "l2"))
12777 *result = VXLAN_INPUT_NEXT_L2_INPUT;
12778 else if (unformat (input, "%d", &tmp))
12786 api_vxlan_add_del_tunnel (vat_main_t * vam)
12788 unformat_input_t *line_input = vam->input;
12789 vl_api_vxlan_add_del_tunnel_t *mp;
12790 ip46_address_t src, dst;
12792 u8 ipv4_set = 0, ipv6_set = 0;
12797 u32 mcast_sw_if_index = ~0;
12798 u32 encap_vrf_id = 0;
12799 u32 decap_next_index = ~0;
12803 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12804 clib_memset (&src, 0, sizeof src);
12805 clib_memset (&dst, 0, sizeof dst);
12807 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12809 if (unformat (line_input, "del"))
12811 else if (unformat (line_input, "instance %d", &instance))
12814 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12820 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12826 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12832 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12837 else if (unformat (line_input, "group %U %U",
12838 unformat_ip4_address, &dst.ip4,
12839 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12841 grp_set = dst_set = 1;
12844 else if (unformat (line_input, "group %U",
12845 unformat_ip4_address, &dst.ip4))
12847 grp_set = dst_set = 1;
12850 else if (unformat (line_input, "group %U %U",
12851 unformat_ip6_address, &dst.ip6,
12852 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12854 grp_set = dst_set = 1;
12857 else if (unformat (line_input, "group %U",
12858 unformat_ip6_address, &dst.ip6))
12860 grp_set = dst_set = 1;
12864 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12866 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12868 else if (unformat (line_input, "decap-next %U",
12869 unformat_vxlan_decap_next, &decap_next_index))
12871 else if (unformat (line_input, "vni %d", &vni))
12875 errmsg ("parse error '%U'", format_unformat_error, line_input);
12882 errmsg ("tunnel src address not specified");
12887 errmsg ("tunnel dst address not specified");
12891 if (grp_set && !ip46_address_is_multicast (&dst))
12893 errmsg ("tunnel group address not multicast");
12896 if (grp_set && mcast_sw_if_index == ~0)
12898 errmsg ("tunnel nonexistent multicast device");
12901 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12903 errmsg ("tunnel dst address must be unicast");
12908 if (ipv4_set && ipv6_set)
12910 errmsg ("both IPv4 and IPv6 addresses specified");
12914 if ((vni == 0) || (vni >> 24))
12916 errmsg ("vni not specified or out of range");
12920 M (VXLAN_ADD_DEL_TUNNEL, mp);
12924 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
12925 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
12929 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
12930 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
12933 mp->instance = htonl (instance);
12934 mp->encap_vrf_id = ntohl (encap_vrf_id);
12935 mp->decap_next_index = ntohl (decap_next_index);
12936 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12937 mp->vni = ntohl (vni);
12938 mp->is_add = is_add;
12939 mp->is_ipv6 = ipv6_set;
12946 static void vl_api_vxlan_tunnel_details_t_handler
12947 (vl_api_vxlan_tunnel_details_t * mp)
12949 vat_main_t *vam = &vat_main;
12950 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12951 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12953 print (vam->ofp, "%11d%11d%24U%24U%14d%18d%13d%19d",
12954 ntohl (mp->sw_if_index),
12955 ntohl (mp->instance),
12956 format_ip46_address, &src, IP46_TYPE_ANY,
12957 format_ip46_address, &dst, IP46_TYPE_ANY,
12958 ntohl (mp->encap_vrf_id),
12959 ntohl (mp->decap_next_index), ntohl (mp->vni),
12960 ntohl (mp->mcast_sw_if_index));
12963 static void vl_api_vxlan_tunnel_details_t_handler_json
12964 (vl_api_vxlan_tunnel_details_t * mp)
12966 vat_main_t *vam = &vat_main;
12967 vat_json_node_t *node = NULL;
12969 if (VAT_JSON_ARRAY != vam->json_tree.type)
12971 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12972 vat_json_init_array (&vam->json_tree);
12974 node = vat_json_array_add (&vam->json_tree);
12976 vat_json_init_object (node);
12977 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12979 vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
12983 struct in6_addr ip6;
12985 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12986 vat_json_object_add_ip6 (node, "src_address", ip6);
12987 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12988 vat_json_object_add_ip6 (node, "dst_address", ip6);
12992 struct in_addr ip4;
12994 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12995 vat_json_object_add_ip4 (node, "src_address", ip4);
12996 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12997 vat_json_object_add_ip4 (node, "dst_address", ip4);
12999 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
13000 vat_json_object_add_uint (node, "decap_next_index",
13001 ntohl (mp->decap_next_index));
13002 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
13003 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
13004 vat_json_object_add_uint (node, "mcast_sw_if_index",
13005 ntohl (mp->mcast_sw_if_index));
13009 api_vxlan_tunnel_dump (vat_main_t * vam)
13011 unformat_input_t *i = vam->input;
13012 vl_api_vxlan_tunnel_dump_t *mp;
13013 vl_api_control_ping_t *mp_ping;
13015 u8 sw_if_index_set = 0;
13018 /* Parse args required to build the message */
13019 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13021 if (unformat (i, "sw_if_index %d", &sw_if_index))
13022 sw_if_index_set = 1;
13027 if (sw_if_index_set == 0)
13032 if (!vam->json_output)
13034 print (vam->ofp, "%11s%11s%24s%24s%14s%18s%13s%19s",
13035 "sw_if_index", "instance", "src_address", "dst_address",
13036 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
13039 /* Get list of vxlan-tunnel interfaces */
13040 M (VXLAN_TUNNEL_DUMP, mp);
13042 mp->sw_if_index = htonl (sw_if_index);
13046 /* Use a control ping for synchronization */
13047 MPING (CONTROL_PING, mp_ping);
13054 static uword unformat_geneve_decap_next
13055 (unformat_input_t * input, va_list * args)
13057 u32 *result = va_arg (*args, u32 *);
13060 if (unformat (input, "l2"))
13061 *result = GENEVE_INPUT_NEXT_L2_INPUT;
13062 else if (unformat (input, "%d", &tmp))
13070 api_geneve_add_del_tunnel (vat_main_t * vam)
13072 unformat_input_t *line_input = vam->input;
13073 vl_api_geneve_add_del_tunnel_t *mp;
13074 ip46_address_t src, dst;
13076 u8 ipv4_set = 0, ipv6_set = 0;
13080 u32 mcast_sw_if_index = ~0;
13081 u32 encap_vrf_id = 0;
13082 u32 decap_next_index = ~0;
13086 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
13087 clib_memset (&src, 0, sizeof src);
13088 clib_memset (&dst, 0, sizeof dst);
13090 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13092 if (unformat (line_input, "del"))
13095 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
13101 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
13107 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
13113 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
13118 else if (unformat (line_input, "group %U %U",
13119 unformat_ip4_address, &dst.ip4,
13120 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13122 grp_set = dst_set = 1;
13125 else if (unformat (line_input, "group %U",
13126 unformat_ip4_address, &dst.ip4))
13128 grp_set = dst_set = 1;
13131 else if (unformat (line_input, "group %U %U",
13132 unformat_ip6_address, &dst.ip6,
13133 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13135 grp_set = dst_set = 1;
13138 else if (unformat (line_input, "group %U",
13139 unformat_ip6_address, &dst.ip6))
13141 grp_set = dst_set = 1;
13145 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13147 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13149 else if (unformat (line_input, "decap-next %U",
13150 unformat_geneve_decap_next, &decap_next_index))
13152 else if (unformat (line_input, "vni %d", &vni))
13156 errmsg ("parse error '%U'", format_unformat_error, line_input);
13163 errmsg ("tunnel src address not specified");
13168 errmsg ("tunnel dst address not specified");
13172 if (grp_set && !ip46_address_is_multicast (&dst))
13174 errmsg ("tunnel group address not multicast");
13177 if (grp_set && mcast_sw_if_index == ~0)
13179 errmsg ("tunnel nonexistent multicast device");
13182 if (grp_set == 0 && ip46_address_is_multicast (&dst))
13184 errmsg ("tunnel dst address must be unicast");
13189 if (ipv4_set && ipv6_set)
13191 errmsg ("both IPv4 and IPv6 addresses specified");
13195 if ((vni == 0) || (vni >> 24))
13197 errmsg ("vni not specified or out of range");
13201 M (GENEVE_ADD_DEL_TUNNEL, mp);
13205 clib_memcpy (mp->local_address, &src.ip6, sizeof (src.ip6));
13206 clib_memcpy (mp->remote_address, &dst.ip6, sizeof (dst.ip6));
13210 clib_memcpy (mp->local_address, &src.ip4, sizeof (src.ip4));
13211 clib_memcpy (mp->remote_address, &dst.ip4, sizeof (dst.ip4));
13213 mp->encap_vrf_id = ntohl (encap_vrf_id);
13214 mp->decap_next_index = ntohl (decap_next_index);
13215 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
13216 mp->vni = ntohl (vni);
13217 mp->is_add = is_add;
13218 mp->is_ipv6 = ipv6_set;
13225 static void vl_api_geneve_tunnel_details_t_handler
13226 (vl_api_geneve_tunnel_details_t * mp)
13228 vat_main_t *vam = &vat_main;
13229 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
13230 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
13232 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
13233 ntohl (mp->sw_if_index),
13234 format_ip46_address, &src, IP46_TYPE_ANY,
13235 format_ip46_address, &dst, IP46_TYPE_ANY,
13236 ntohl (mp->encap_vrf_id),
13237 ntohl (mp->decap_next_index), ntohl (mp->vni),
13238 ntohl (mp->mcast_sw_if_index));
13241 static void vl_api_geneve_tunnel_details_t_handler_json
13242 (vl_api_geneve_tunnel_details_t * mp)
13244 vat_main_t *vam = &vat_main;
13245 vat_json_node_t *node = NULL;
13247 if (VAT_JSON_ARRAY != vam->json_tree.type)
13249 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13250 vat_json_init_array (&vam->json_tree);
13252 node = vat_json_array_add (&vam->json_tree);
13254 vat_json_init_object (node);
13255 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13258 struct in6_addr ip6;
13260 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
13261 vat_json_object_add_ip6 (node, "src_address", ip6);
13262 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
13263 vat_json_object_add_ip6 (node, "dst_address", ip6);
13267 struct in_addr ip4;
13269 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
13270 vat_json_object_add_ip4 (node, "src_address", ip4);
13271 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
13272 vat_json_object_add_ip4 (node, "dst_address", ip4);
13274 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
13275 vat_json_object_add_uint (node, "decap_next_index",
13276 ntohl (mp->decap_next_index));
13277 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
13278 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
13279 vat_json_object_add_uint (node, "mcast_sw_if_index",
13280 ntohl (mp->mcast_sw_if_index));
13284 api_geneve_tunnel_dump (vat_main_t * vam)
13286 unformat_input_t *i = vam->input;
13287 vl_api_geneve_tunnel_dump_t *mp;
13288 vl_api_control_ping_t *mp_ping;
13290 u8 sw_if_index_set = 0;
13293 /* Parse args required to build the message */
13294 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13296 if (unformat (i, "sw_if_index %d", &sw_if_index))
13297 sw_if_index_set = 1;
13302 if (sw_if_index_set == 0)
13307 if (!vam->json_output)
13309 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
13310 "sw_if_index", "local_address", "remote_address",
13311 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
13314 /* Get list of geneve-tunnel interfaces */
13315 M (GENEVE_TUNNEL_DUMP, mp);
13317 mp->sw_if_index = htonl (sw_if_index);
13321 /* Use a control ping for synchronization */
13322 M (CONTROL_PING, mp_ping);
13330 api_gre_add_del_tunnel (vat_main_t * vam)
13332 unformat_input_t *line_input = vam->input;
13333 vl_api_gre_add_del_tunnel_t *mp;
13334 ip4_address_t src4, dst4;
13335 ip6_address_t src6, dst6;
13339 u8 t_type = GRE_TUNNEL_TYPE_L3;
13342 u32 outer_fib_id = 0;
13343 u32 session_id = 0;
13347 clib_memset (&src4, 0, sizeof src4);
13348 clib_memset (&dst4, 0, sizeof dst4);
13349 clib_memset (&src6, 0, sizeof src6);
13350 clib_memset (&dst6, 0, sizeof dst6);
13352 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13354 if (unformat (line_input, "del"))
13356 else if (unformat (line_input, "instance %d", &instance))
13358 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
13363 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
13368 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
13373 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
13378 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
13380 else if (unformat (line_input, "teb"))
13381 t_type = GRE_TUNNEL_TYPE_TEB;
13382 else if (unformat (line_input, "erspan %d", &session_id))
13383 t_type = GRE_TUNNEL_TYPE_ERSPAN;
13386 errmsg ("parse error '%U'", format_unformat_error, line_input);
13393 errmsg ("tunnel src address not specified");
13398 errmsg ("tunnel dst address not specified");
13401 if (ipv4_set && ipv6_set)
13403 errmsg ("both IPv4 and IPv6 addresses specified");
13408 M (GRE_ADD_DEL_TUNNEL, mp);
13412 clib_memcpy (&mp->src_address, &src4, 4);
13413 clib_memcpy (&mp->dst_address, &dst4, 4);
13417 clib_memcpy (&mp->src_address, &src6, 16);
13418 clib_memcpy (&mp->dst_address, &dst6, 16);
13420 mp->instance = htonl (instance);
13421 mp->outer_fib_id = htonl (outer_fib_id);
13422 mp->is_add = is_add;
13423 mp->session_id = htons ((u16) session_id);
13424 mp->tunnel_type = t_type;
13425 mp->is_ipv6 = ipv6_set;
13432 static void vl_api_gre_tunnel_details_t_handler
13433 (vl_api_gre_tunnel_details_t * mp)
13435 vat_main_t *vam = &vat_main;
13436 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->src_address);
13437 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->dst_address);
13439 print (vam->ofp, "%11d%11d%24U%24U%13d%14d%12d",
13440 ntohl (mp->sw_if_index),
13441 ntohl (mp->instance),
13442 format_ip46_address, &src, IP46_TYPE_ANY,
13443 format_ip46_address, &dst, IP46_TYPE_ANY,
13444 mp->tunnel_type, ntohl (mp->outer_fib_id), ntohl (mp->session_id));
13447 static void vl_api_gre_tunnel_details_t_handler_json
13448 (vl_api_gre_tunnel_details_t * mp)
13450 vat_main_t *vam = &vat_main;
13451 vat_json_node_t *node = NULL;
13452 struct in_addr ip4;
13453 struct in6_addr ip6;
13455 if (VAT_JSON_ARRAY != vam->json_tree.type)
13457 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13458 vat_json_init_array (&vam->json_tree);
13460 node = vat_json_array_add (&vam->json_tree);
13462 vat_json_init_object (node);
13463 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13464 vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
13467 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
13468 vat_json_object_add_ip4 (node, "src_address", ip4);
13469 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
13470 vat_json_object_add_ip4 (node, "dst_address", ip4);
13474 clib_memcpy (&ip6, &mp->src_address, sizeof (ip6));
13475 vat_json_object_add_ip6 (node, "src_address", ip6);
13476 clib_memcpy (&ip6, &mp->dst_address, sizeof (ip6));
13477 vat_json_object_add_ip6 (node, "dst_address", ip6);
13479 vat_json_object_add_uint (node, "tunnel_type", mp->tunnel_type);
13480 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
13481 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6);
13482 vat_json_object_add_uint (node, "session_id", mp->session_id);
13486 api_gre_tunnel_dump (vat_main_t * vam)
13488 unformat_input_t *i = vam->input;
13489 vl_api_gre_tunnel_dump_t *mp;
13490 vl_api_control_ping_t *mp_ping;
13492 u8 sw_if_index_set = 0;
13495 /* Parse args required to build the message */
13496 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13498 if (unformat (i, "sw_if_index %d", &sw_if_index))
13499 sw_if_index_set = 1;
13504 if (sw_if_index_set == 0)
13509 if (!vam->json_output)
13511 print (vam->ofp, "%11s%11s%24s%24s%13s%14s%12s",
13512 "sw_if_index", "instance", "src_address", "dst_address",
13513 "tunnel_type", "outer_fib_id", "session_id");
13516 /* Get list of gre-tunnel interfaces */
13517 M (GRE_TUNNEL_DUMP, mp);
13519 mp->sw_if_index = htonl (sw_if_index);
13523 /* Use a control ping for synchronization */
13524 MPING (CONTROL_PING, mp_ping);
13532 api_l2_fib_clear_table (vat_main_t * vam)
13534 // unformat_input_t * i = vam->input;
13535 vl_api_l2_fib_clear_table_t *mp;
13538 M (L2_FIB_CLEAR_TABLE, mp);
13546 api_l2_interface_efp_filter (vat_main_t * vam)
13548 unformat_input_t *i = vam->input;
13549 vl_api_l2_interface_efp_filter_t *mp;
13552 u8 sw_if_index_set = 0;
13555 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13557 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13558 sw_if_index_set = 1;
13559 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13560 sw_if_index_set = 1;
13561 else if (unformat (i, "enable"))
13563 else if (unformat (i, "disable"))
13567 clib_warning ("parse error '%U'", format_unformat_error, i);
13572 if (sw_if_index_set == 0)
13574 errmsg ("missing sw_if_index");
13578 M (L2_INTERFACE_EFP_FILTER, mp);
13580 mp->sw_if_index = ntohl (sw_if_index);
13581 mp->enable_disable = enable;
13588 #define foreach_vtr_op \
13589 _("disable", L2_VTR_DISABLED) \
13590 _("push-1", L2_VTR_PUSH_1) \
13591 _("push-2", L2_VTR_PUSH_2) \
13592 _("pop-1", L2_VTR_POP_1) \
13593 _("pop-2", L2_VTR_POP_2) \
13594 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
13595 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
13596 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
13597 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
13600 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
13602 unformat_input_t *i = vam->input;
13603 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
13605 u8 sw_if_index_set = 0;
13608 u32 push_dot1q = 1;
13613 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13615 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13616 sw_if_index_set = 1;
13617 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13618 sw_if_index_set = 1;
13619 else if (unformat (i, "vtr_op %d", &vtr_op))
13621 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
13624 else if (unformat (i, "push_dot1q %d", &push_dot1q))
13626 else if (unformat (i, "tag1 %d", &tag1))
13628 else if (unformat (i, "tag2 %d", &tag2))
13632 clib_warning ("parse error '%U'", format_unformat_error, i);
13637 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
13639 errmsg ("missing vtr operation or sw_if_index");
13643 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
13644 mp->sw_if_index = ntohl (sw_if_index);
13645 mp->vtr_op = ntohl (vtr_op);
13646 mp->push_dot1q = ntohl (push_dot1q);
13647 mp->tag1 = ntohl (tag1);
13648 mp->tag2 = ntohl (tag2);
13656 api_create_vhost_user_if (vat_main_t * vam)
13658 unformat_input_t *i = vam->input;
13659 vl_api_create_vhost_user_if_t *mp;
13662 u8 file_name_set = 0;
13663 u32 custom_dev_instance = ~0;
13665 u8 use_custom_mac = 0;
13666 u8 disable_mrg_rxbuf = 0;
13667 u8 disable_indirect_desc = 0;
13671 /* Shut up coverity */
13672 clib_memset (hwaddr, 0, sizeof (hwaddr));
13674 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13676 if (unformat (i, "socket %s", &file_name))
13680 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13682 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
13683 use_custom_mac = 1;
13684 else if (unformat (i, "server"))
13686 else if (unformat (i, "disable_mrg_rxbuf"))
13687 disable_mrg_rxbuf = 1;
13688 else if (unformat (i, "disable_indirect_desc"))
13689 disable_indirect_desc = 1;
13690 else if (unformat (i, "tag %s", &tag))
13696 if (file_name_set == 0)
13698 errmsg ("missing socket file name");
13702 if (vec_len (file_name) > 255)
13704 errmsg ("socket file name too long");
13707 vec_add1 (file_name, 0);
13709 M (CREATE_VHOST_USER_IF, mp);
13711 mp->is_server = is_server;
13712 mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
13713 mp->disable_indirect_desc = disable_indirect_desc;
13714 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13715 vec_free (file_name);
13716 if (custom_dev_instance != ~0)
13719 mp->custom_dev_instance = ntohl (custom_dev_instance);
13722 mp->use_custom_mac = use_custom_mac;
13723 clib_memcpy (mp->mac_address, hwaddr, 6);
13725 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
13734 api_modify_vhost_user_if (vat_main_t * vam)
13736 unformat_input_t *i = vam->input;
13737 vl_api_modify_vhost_user_if_t *mp;
13740 u8 file_name_set = 0;
13741 u32 custom_dev_instance = ~0;
13742 u8 sw_if_index_set = 0;
13743 u32 sw_if_index = (u32) ~ 0;
13746 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13748 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13749 sw_if_index_set = 1;
13750 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13751 sw_if_index_set = 1;
13752 else if (unformat (i, "socket %s", &file_name))
13756 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13758 else if (unformat (i, "server"))
13764 if (sw_if_index_set == 0)
13766 errmsg ("missing sw_if_index or interface name");
13770 if (file_name_set == 0)
13772 errmsg ("missing socket file name");
13776 if (vec_len (file_name) > 255)
13778 errmsg ("socket file name too long");
13781 vec_add1 (file_name, 0);
13783 M (MODIFY_VHOST_USER_IF, mp);
13785 mp->sw_if_index = ntohl (sw_if_index);
13786 mp->is_server = is_server;
13787 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13788 vec_free (file_name);
13789 if (custom_dev_instance != ~0)
13792 mp->custom_dev_instance = ntohl (custom_dev_instance);
13801 api_delete_vhost_user_if (vat_main_t * vam)
13803 unformat_input_t *i = vam->input;
13804 vl_api_delete_vhost_user_if_t *mp;
13805 u32 sw_if_index = ~0;
13806 u8 sw_if_index_set = 0;
13809 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13811 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13812 sw_if_index_set = 1;
13813 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13814 sw_if_index_set = 1;
13819 if (sw_if_index_set == 0)
13821 errmsg ("missing sw_if_index or interface name");
13826 M (DELETE_VHOST_USER_IF, mp);
13828 mp->sw_if_index = ntohl (sw_if_index);
13835 static void vl_api_sw_interface_vhost_user_details_t_handler
13836 (vl_api_sw_interface_vhost_user_details_t * mp)
13838 vat_main_t *vam = &vat_main;
13840 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
13841 (char *) mp->interface_name,
13842 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
13843 clib_net_to_host_u64 (mp->features), mp->is_server,
13844 ntohl (mp->num_regions), (char *) mp->sock_filename);
13845 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
13848 static void vl_api_sw_interface_vhost_user_details_t_handler_json
13849 (vl_api_sw_interface_vhost_user_details_t * mp)
13851 vat_main_t *vam = &vat_main;
13852 vat_json_node_t *node = NULL;
13854 if (VAT_JSON_ARRAY != vam->json_tree.type)
13856 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13857 vat_json_init_array (&vam->json_tree);
13859 node = vat_json_array_add (&vam->json_tree);
13861 vat_json_init_object (node);
13862 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13863 vat_json_object_add_string_copy (node, "interface_name",
13864 mp->interface_name);
13865 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
13866 ntohl (mp->virtio_net_hdr_sz));
13867 vat_json_object_add_uint (node, "features",
13868 clib_net_to_host_u64 (mp->features));
13869 vat_json_object_add_uint (node, "is_server", mp->is_server);
13870 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
13871 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
13872 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
13876 api_sw_interface_vhost_user_dump (vat_main_t * vam)
13878 vl_api_sw_interface_vhost_user_dump_t *mp;
13879 vl_api_control_ping_t *mp_ping;
13882 "Interface name idx hdr_sz features server regions filename");
13884 /* Get list of vhost-user interfaces */
13885 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
13888 /* Use a control ping for synchronization */
13889 MPING (CONTROL_PING, mp_ping);
13897 api_show_version (vat_main_t * vam)
13899 vl_api_show_version_t *mp;
13902 M (SHOW_VERSION, mp);
13911 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
13913 unformat_input_t *line_input = vam->input;
13914 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
13915 ip4_address_t local4, remote4;
13916 ip6_address_t local6, remote6;
13918 u8 ipv4_set = 0, ipv6_set = 0;
13922 u32 mcast_sw_if_index = ~0;
13923 u32 encap_vrf_id = 0;
13924 u32 decap_vrf_id = 0;
13930 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
13931 clib_memset (&local4, 0, sizeof local4);
13932 clib_memset (&remote4, 0, sizeof remote4);
13933 clib_memset (&local6, 0, sizeof local6);
13934 clib_memset (&remote6, 0, sizeof remote6);
13936 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13938 if (unformat (line_input, "del"))
13940 else if (unformat (line_input, "local %U",
13941 unformat_ip4_address, &local4))
13946 else if (unformat (line_input, "remote %U",
13947 unformat_ip4_address, &remote4))
13952 else if (unformat (line_input, "local %U",
13953 unformat_ip6_address, &local6))
13958 else if (unformat (line_input, "remote %U",
13959 unformat_ip6_address, &remote6))
13964 else if (unformat (line_input, "group %U %U",
13965 unformat_ip4_address, &remote4,
13966 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13968 grp_set = remote_set = 1;
13971 else if (unformat (line_input, "group %U",
13972 unformat_ip4_address, &remote4))
13974 grp_set = remote_set = 1;
13977 else if (unformat (line_input, "group %U %U",
13978 unformat_ip6_address, &remote6,
13979 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13981 grp_set = remote_set = 1;
13984 else if (unformat (line_input, "group %U",
13985 unformat_ip6_address, &remote6))
13987 grp_set = remote_set = 1;
13991 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13993 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13995 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
13997 else if (unformat (line_input, "vni %d", &vni))
13999 else if (unformat (line_input, "next-ip4"))
14001 else if (unformat (line_input, "next-ip6"))
14003 else if (unformat (line_input, "next-ethernet"))
14005 else if (unformat (line_input, "next-nsh"))
14009 errmsg ("parse error '%U'", format_unformat_error, line_input);
14014 if (local_set == 0)
14016 errmsg ("tunnel local address not specified");
14019 if (remote_set == 0)
14021 errmsg ("tunnel remote address not specified");
14024 if (grp_set && mcast_sw_if_index == ~0)
14026 errmsg ("tunnel nonexistent multicast device");
14029 if (ipv4_set && ipv6_set)
14031 errmsg ("both IPv4 and IPv6 addresses specified");
14037 errmsg ("vni not specified");
14041 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
14046 clib_memcpy (&mp->local, &local6, sizeof (local6));
14047 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
14051 clib_memcpy (&mp->local, &local4, sizeof (local4));
14052 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
14055 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
14056 mp->encap_vrf_id = ntohl (encap_vrf_id);
14057 mp->decap_vrf_id = ntohl (decap_vrf_id);
14058 mp->protocol = protocol;
14059 mp->vni = ntohl (vni);
14060 mp->is_add = is_add;
14061 mp->is_ipv6 = ipv6_set;
14068 static void vl_api_vxlan_gpe_tunnel_details_t_handler
14069 (vl_api_vxlan_gpe_tunnel_details_t * mp)
14071 vat_main_t *vam = &vat_main;
14072 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
14073 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
14075 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
14076 ntohl (mp->sw_if_index),
14077 format_ip46_address, &local, IP46_TYPE_ANY,
14078 format_ip46_address, &remote, IP46_TYPE_ANY,
14079 ntohl (mp->vni), mp->protocol,
14080 ntohl (mp->mcast_sw_if_index),
14081 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
14085 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
14086 (vl_api_vxlan_gpe_tunnel_details_t * mp)
14088 vat_main_t *vam = &vat_main;
14089 vat_json_node_t *node = NULL;
14090 struct in_addr ip4;
14091 struct in6_addr ip6;
14093 if (VAT_JSON_ARRAY != vam->json_tree.type)
14095 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14096 vat_json_init_array (&vam->json_tree);
14098 node = vat_json_array_add (&vam->json_tree);
14100 vat_json_init_object (node);
14101 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14104 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
14105 vat_json_object_add_ip6 (node, "local", ip6);
14106 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
14107 vat_json_object_add_ip6 (node, "remote", ip6);
14111 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
14112 vat_json_object_add_ip4 (node, "local", ip4);
14113 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
14114 vat_json_object_add_ip4 (node, "remote", ip4);
14116 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
14117 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
14118 vat_json_object_add_uint (node, "mcast_sw_if_index",
14119 ntohl (mp->mcast_sw_if_index));
14120 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
14121 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
14122 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
14126 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
14128 unformat_input_t *i = vam->input;
14129 vl_api_vxlan_gpe_tunnel_dump_t *mp;
14130 vl_api_control_ping_t *mp_ping;
14132 u8 sw_if_index_set = 0;
14135 /* Parse args required to build the message */
14136 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14138 if (unformat (i, "sw_if_index %d", &sw_if_index))
14139 sw_if_index_set = 1;
14144 if (sw_if_index_set == 0)
14149 if (!vam->json_output)
14151 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
14152 "sw_if_index", "local", "remote", "vni",
14153 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
14156 /* Get list of vxlan-tunnel interfaces */
14157 M (VXLAN_GPE_TUNNEL_DUMP, mp);
14159 mp->sw_if_index = htonl (sw_if_index);
14163 /* Use a control ping for synchronization */
14164 MPING (CONTROL_PING, mp_ping);
14171 static void vl_api_l2_fib_table_details_t_handler
14172 (vl_api_l2_fib_table_details_t * mp)
14174 vat_main_t *vam = &vat_main;
14176 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
14178 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
14179 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
14183 static void vl_api_l2_fib_table_details_t_handler_json
14184 (vl_api_l2_fib_table_details_t * mp)
14186 vat_main_t *vam = &vat_main;
14187 vat_json_node_t *node = NULL;
14189 if (VAT_JSON_ARRAY != vam->json_tree.type)
14191 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14192 vat_json_init_array (&vam->json_tree);
14194 node = vat_json_array_add (&vam->json_tree);
14196 vat_json_init_object (node);
14197 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
14198 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
14199 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14200 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
14201 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
14202 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
14206 api_l2_fib_table_dump (vat_main_t * vam)
14208 unformat_input_t *i = vam->input;
14209 vl_api_l2_fib_table_dump_t *mp;
14210 vl_api_control_ping_t *mp_ping;
14215 /* Parse args required to build the message */
14216 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14218 if (unformat (i, "bd_id %d", &bd_id))
14224 if (bd_id_set == 0)
14226 errmsg ("missing bridge domain");
14230 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
14232 /* Get list of l2 fib entries */
14233 M (L2_FIB_TABLE_DUMP, mp);
14235 mp->bd_id = ntohl (bd_id);
14238 /* Use a control ping for synchronization */
14239 MPING (CONTROL_PING, mp_ping);
14248 api_interface_name_renumber (vat_main_t * vam)
14250 unformat_input_t *line_input = vam->input;
14251 vl_api_interface_name_renumber_t *mp;
14252 u32 sw_if_index = ~0;
14253 u32 new_show_dev_instance = ~0;
14256 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14258 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
14261 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14263 else if (unformat (line_input, "new_show_dev_instance %d",
14264 &new_show_dev_instance))
14270 if (sw_if_index == ~0)
14272 errmsg ("missing interface name or sw_if_index");
14276 if (new_show_dev_instance == ~0)
14278 errmsg ("missing new_show_dev_instance");
14282 M (INTERFACE_NAME_RENUMBER, mp);
14284 mp->sw_if_index = ntohl (sw_if_index);
14285 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
14293 api_ip_probe_neighbor (vat_main_t * vam)
14295 unformat_input_t *i = vam->input;
14296 vl_api_ip_probe_neighbor_t *mp;
14297 vl_api_address_t dst_adr;
14303 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14305 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14307 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14309 else if (unformat (i, "address %U", unformat_vl_api_address, dst_adr))
14317 errmsg ("missing interface");
14323 errmsg ("missing addresses");
14327 M (IP_PROBE_NEIGHBOR, mp);
14329 mp->sw_if_index = ntohl (sw_if_index);
14330 clib_memcpy (&mp->dst, &dst_adr, sizeof (dst_adr));
14338 api_ip_scan_neighbor_enable_disable (vat_main_t * vam)
14340 unformat_input_t *i = vam->input;
14341 vl_api_ip_scan_neighbor_enable_disable_t *mp;
14342 u8 mode = IP_SCAN_V46_NEIGHBORS;
14343 u32 interval = 0, time = 0, update = 0, delay = 0, stale = 0;
14346 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14348 if (unformat (i, "ip4"))
14349 mode = IP_SCAN_V4_NEIGHBORS;
14350 else if (unformat (i, "ip6"))
14351 mode = IP_SCAN_V6_NEIGHBORS;
14352 if (unformat (i, "both"))
14353 mode = IP_SCAN_V46_NEIGHBORS;
14354 else if (unformat (i, "disable"))
14355 mode = IP_SCAN_DISABLED;
14356 else if (unformat (i, "interval %d", &interval))
14358 else if (unformat (i, "max-time %d", &time))
14360 else if (unformat (i, "max-update %d", &update))
14362 else if (unformat (i, "delay %d", &delay))
14364 else if (unformat (i, "stale %d", &stale))
14370 if (interval > 255)
14372 errmsg ("interval cannot exceed 255 minutes.");
14377 errmsg ("max-time cannot exceed 255 usec.");
14382 errmsg ("max-update cannot exceed 255.");
14387 errmsg ("delay cannot exceed 255 msec.");
14392 errmsg ("stale cannot exceed 255 minutes.");
14396 M (IP_SCAN_NEIGHBOR_ENABLE_DISABLE, mp);
14398 mp->scan_interval = interval;
14399 mp->max_proc_time = time;
14400 mp->max_update = update;
14401 mp->scan_int_delay = delay;
14402 mp->stale_threshold = stale;
14410 api_want_ip4_arp_events (vat_main_t * vam)
14412 unformat_input_t *line_input = vam->input;
14413 vl_api_want_ip4_arp_events_t *mp;
14414 ip4_address_t address;
14415 int address_set = 0;
14416 u32 enable_disable = 1;
14419 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14421 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
14423 else if (unformat (line_input, "del"))
14424 enable_disable = 0;
14429 if (address_set == 0)
14431 errmsg ("missing addresses");
14435 M (WANT_IP4_ARP_EVENTS, mp);
14436 mp->enable_disable = enable_disable;
14437 mp->pid = htonl (getpid ());
14438 clib_memcpy (mp->ip, &address, sizeof (address));
14446 api_want_ip6_nd_events (vat_main_t * vam)
14448 unformat_input_t *line_input = vam->input;
14449 vl_api_want_ip6_nd_events_t *mp;
14450 vl_api_ip6_address_t address;
14451 int address_set = 0;
14452 u32 enable_disable = 1;
14455 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14458 (line_input, "address %U", unformat_vl_api_ip6_address, &address))
14460 else if (unformat (line_input, "del"))
14461 enable_disable = 0;
14466 if (address_set == 0)
14468 errmsg ("missing addresses");
14472 M (WANT_IP6_ND_EVENTS, mp);
14473 mp->enable_disable = enable_disable;
14474 mp->pid = htonl (getpid ());
14475 clib_memcpy (&mp->ip, &address, sizeof (address));
14483 api_want_l2_macs_events (vat_main_t * vam)
14485 unformat_input_t *line_input = vam->input;
14486 vl_api_want_l2_macs_events_t *mp;
14487 u8 enable_disable = 1;
14488 u32 scan_delay = 0;
14489 u32 max_macs_in_event = 0;
14490 u32 learn_limit = 0;
14493 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14495 if (unformat (line_input, "learn-limit %d", &learn_limit))
14497 else if (unformat (line_input, "scan-delay %d", &scan_delay))
14499 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
14501 else if (unformat (line_input, "disable"))
14502 enable_disable = 0;
14507 M (WANT_L2_MACS_EVENTS, mp);
14508 mp->enable_disable = enable_disable;
14509 mp->pid = htonl (getpid ());
14510 mp->learn_limit = htonl (learn_limit);
14511 mp->scan_delay = (u8) scan_delay;
14512 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
14519 api_input_acl_set_interface (vat_main_t * vam)
14521 unformat_input_t *i = vam->input;
14522 vl_api_input_acl_set_interface_t *mp;
14524 int sw_if_index_set;
14525 u32 ip4_table_index = ~0;
14526 u32 ip6_table_index = ~0;
14527 u32 l2_table_index = ~0;
14531 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14533 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14534 sw_if_index_set = 1;
14535 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14536 sw_if_index_set = 1;
14537 else if (unformat (i, "del"))
14539 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14541 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14543 else if (unformat (i, "l2-table %d", &l2_table_index))
14547 clib_warning ("parse error '%U'", format_unformat_error, i);
14552 if (sw_if_index_set == 0)
14554 errmsg ("missing interface name or sw_if_index");
14558 M (INPUT_ACL_SET_INTERFACE, mp);
14560 mp->sw_if_index = ntohl (sw_if_index);
14561 mp->ip4_table_index = ntohl (ip4_table_index);
14562 mp->ip6_table_index = ntohl (ip6_table_index);
14563 mp->l2_table_index = ntohl (l2_table_index);
14564 mp->is_add = is_add;
14572 api_output_acl_set_interface (vat_main_t * vam)
14574 unformat_input_t *i = vam->input;
14575 vl_api_output_acl_set_interface_t *mp;
14577 int sw_if_index_set;
14578 u32 ip4_table_index = ~0;
14579 u32 ip6_table_index = ~0;
14580 u32 l2_table_index = ~0;
14584 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14586 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14587 sw_if_index_set = 1;
14588 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14589 sw_if_index_set = 1;
14590 else if (unformat (i, "del"))
14592 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14594 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14596 else if (unformat (i, "l2-table %d", &l2_table_index))
14600 clib_warning ("parse error '%U'", format_unformat_error, i);
14605 if (sw_if_index_set == 0)
14607 errmsg ("missing interface name or sw_if_index");
14611 M (OUTPUT_ACL_SET_INTERFACE, mp);
14613 mp->sw_if_index = ntohl (sw_if_index);
14614 mp->ip4_table_index = ntohl (ip4_table_index);
14615 mp->ip6_table_index = ntohl (ip6_table_index);
14616 mp->l2_table_index = ntohl (l2_table_index);
14617 mp->is_add = is_add;
14625 api_ip_address_dump (vat_main_t * vam)
14627 unformat_input_t *i = vam->input;
14628 vl_api_ip_address_dump_t *mp;
14629 vl_api_control_ping_t *mp_ping;
14630 u32 sw_if_index = ~0;
14631 u8 sw_if_index_set = 0;
14636 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14638 if (unformat (i, "sw_if_index %d", &sw_if_index))
14639 sw_if_index_set = 1;
14641 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14642 sw_if_index_set = 1;
14643 else if (unformat (i, "ipv4"))
14645 else if (unformat (i, "ipv6"))
14651 if (ipv4_set && ipv6_set)
14653 errmsg ("ipv4 and ipv6 flags cannot be both set");
14657 if ((!ipv4_set) && (!ipv6_set))
14659 errmsg ("no ipv4 nor ipv6 flag set");
14663 if (sw_if_index_set == 0)
14665 errmsg ("missing interface name or sw_if_index");
14669 vam->current_sw_if_index = sw_if_index;
14670 vam->is_ipv6 = ipv6_set;
14672 M (IP_ADDRESS_DUMP, mp);
14673 mp->sw_if_index = ntohl (sw_if_index);
14674 mp->is_ipv6 = ipv6_set;
14677 /* Use a control ping for synchronization */
14678 MPING (CONTROL_PING, mp_ping);
14686 api_ip_dump (vat_main_t * vam)
14688 vl_api_ip_dump_t *mp;
14689 vl_api_control_ping_t *mp_ping;
14690 unformat_input_t *in = vam->input;
14697 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
14699 if (unformat (in, "ipv4"))
14701 else if (unformat (in, "ipv6"))
14707 if (ipv4_set && ipv6_set)
14709 errmsg ("ipv4 and ipv6 flags cannot be both set");
14713 if ((!ipv4_set) && (!ipv6_set))
14715 errmsg ("no ipv4 nor ipv6 flag set");
14719 is_ipv6 = ipv6_set;
14720 vam->is_ipv6 = is_ipv6;
14722 /* free old data */
14723 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
14725 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
14727 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
14730 mp->is_ipv6 = ipv6_set;
14733 /* Use a control ping for synchronization */
14734 MPING (CONTROL_PING, mp_ping);
14742 api_ipsec_spd_add_del (vat_main_t * vam)
14744 unformat_input_t *i = vam->input;
14745 vl_api_ipsec_spd_add_del_t *mp;
14750 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14752 if (unformat (i, "spd_id %d", &spd_id))
14754 else if (unformat (i, "del"))
14758 clib_warning ("parse error '%U'", format_unformat_error, i);
14764 errmsg ("spd_id must be set");
14768 M (IPSEC_SPD_ADD_DEL, mp);
14770 mp->spd_id = ntohl (spd_id);
14771 mp->is_add = is_add;
14779 api_ipsec_interface_add_del_spd (vat_main_t * vam)
14781 unformat_input_t *i = vam->input;
14782 vl_api_ipsec_interface_add_del_spd_t *mp;
14784 u8 sw_if_index_set = 0;
14785 u32 spd_id = (u32) ~ 0;
14789 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14791 if (unformat (i, "del"))
14793 else if (unformat (i, "spd_id %d", &spd_id))
14796 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14797 sw_if_index_set = 1;
14798 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14799 sw_if_index_set = 1;
14802 clib_warning ("parse error '%U'", format_unformat_error, i);
14808 if (spd_id == (u32) ~ 0)
14810 errmsg ("spd_id must be set");
14814 if (sw_if_index_set == 0)
14816 errmsg ("missing interface name or sw_if_index");
14820 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
14822 mp->spd_id = ntohl (spd_id);
14823 mp->sw_if_index = ntohl (sw_if_index);
14824 mp->is_add = is_add;
14832 api_ipsec_spd_add_del_entry (vat_main_t * vam)
14834 unformat_input_t *i = vam->input;
14835 vl_api_ipsec_spd_add_del_entry_t *mp;
14836 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
14837 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
14839 u32 rport_start = 0, rport_stop = (u32) ~ 0;
14840 u32 lport_start = 0, lport_stop = (u32) ~ 0;
14841 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
14842 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
14845 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
14846 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
14847 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
14848 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
14849 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
14850 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
14852 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14854 if (unformat (i, "del"))
14856 if (unformat (i, "outbound"))
14858 if (unformat (i, "inbound"))
14860 else if (unformat (i, "spd_id %d", &spd_id))
14862 else if (unformat (i, "sa_id %d", &sa_id))
14864 else if (unformat (i, "priority %d", &priority))
14866 else if (unformat (i, "protocol %d", &protocol))
14868 else if (unformat (i, "lport_start %d", &lport_start))
14870 else if (unformat (i, "lport_stop %d", &lport_stop))
14872 else if (unformat (i, "rport_start %d", &rport_start))
14874 else if (unformat (i, "rport_stop %d", &rport_stop))
14878 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
14884 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
14891 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
14897 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
14904 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
14910 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
14917 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
14923 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
14929 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
14931 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
14933 clib_warning ("unsupported action: 'resolve'");
14939 clib_warning ("parse error '%U'", format_unformat_error, i);
14945 M (IPSEC_SPD_ADD_DEL_ENTRY, mp);
14947 mp->spd_id = ntohl (spd_id);
14948 mp->priority = ntohl (priority);
14949 mp->is_outbound = is_outbound;
14951 mp->is_ipv6 = is_ipv6;
14952 if (is_ipv6 || is_ip_any)
14954 clib_memcpy (mp->remote_address_start, &raddr6_start,
14955 sizeof (ip6_address_t));
14956 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
14957 sizeof (ip6_address_t));
14958 clib_memcpy (mp->local_address_start, &laddr6_start,
14959 sizeof (ip6_address_t));
14960 clib_memcpy (mp->local_address_stop, &laddr6_stop,
14961 sizeof (ip6_address_t));
14965 clib_memcpy (mp->remote_address_start, &raddr4_start,
14966 sizeof (ip4_address_t));
14967 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
14968 sizeof (ip4_address_t));
14969 clib_memcpy (mp->local_address_start, &laddr4_start,
14970 sizeof (ip4_address_t));
14971 clib_memcpy (mp->local_address_stop, &laddr4_stop,
14972 sizeof (ip4_address_t));
14974 mp->protocol = (u8) protocol;
14975 mp->local_port_start = ntohs ((u16) lport_start);
14976 mp->local_port_stop = ntohs ((u16) lport_stop);
14977 mp->remote_port_start = ntohs ((u16) rport_start);
14978 mp->remote_port_stop = ntohs ((u16) rport_stop);
14979 mp->policy = (u8) policy;
14980 mp->sa_id = ntohl (sa_id);
14981 mp->is_add = is_add;
14982 mp->is_ip_any = is_ip_any;
14989 api_ipsec_sad_add_del_entry (vat_main_t * vam)
14991 unformat_input_t *i = vam->input;
14992 vl_api_ipsec_sad_add_del_entry_t *mp;
14993 u32 sad_id = 0, spi = 0;
14994 u8 *ck = 0, *ik = 0;
14997 u8 protocol = IPSEC_PROTOCOL_AH;
14998 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
14999 u32 crypto_alg = 0, integ_alg = 0;
15000 ip4_address_t tun_src4;
15001 ip4_address_t tun_dst4;
15002 ip6_address_t tun_src6;
15003 ip6_address_t tun_dst6;
15006 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15008 if (unformat (i, "del"))
15010 else if (unformat (i, "sad_id %d", &sad_id))
15012 else if (unformat (i, "spi %d", &spi))
15014 else if (unformat (i, "esp"))
15015 protocol = IPSEC_PROTOCOL_ESP;
15016 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
15019 is_tunnel_ipv6 = 0;
15021 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
15024 is_tunnel_ipv6 = 0;
15026 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
15029 is_tunnel_ipv6 = 1;
15031 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
15034 is_tunnel_ipv6 = 1;
15038 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
15040 if (crypto_alg >= IPSEC_CRYPTO_N_ALG)
15042 clib_warning ("unsupported crypto-alg: '%U'",
15043 format_ipsec_crypto_alg, crypto_alg);
15047 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
15051 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
15053 if (integ_alg >= IPSEC_INTEG_N_ALG)
15055 clib_warning ("unsupported integ-alg: '%U'",
15056 format_ipsec_integ_alg, integ_alg);
15060 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
15064 clib_warning ("parse error '%U'", format_unformat_error, i);
15070 M (IPSEC_SAD_ADD_DEL_ENTRY, mp);
15072 mp->sad_id = ntohl (sad_id);
15073 mp->is_add = is_add;
15074 mp->protocol = protocol;
15075 mp->spi = ntohl (spi);
15076 mp->is_tunnel = is_tunnel;
15077 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
15078 mp->crypto_algorithm = crypto_alg;
15079 mp->integrity_algorithm = integ_alg;
15080 mp->crypto_key_length = vec_len (ck);
15081 mp->integrity_key_length = vec_len (ik);
15083 if (mp->crypto_key_length > sizeof (mp->crypto_key))
15084 mp->crypto_key_length = sizeof (mp->crypto_key);
15086 if (mp->integrity_key_length > sizeof (mp->integrity_key))
15087 mp->integrity_key_length = sizeof (mp->integrity_key);
15090 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
15092 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
15096 if (is_tunnel_ipv6)
15098 clib_memcpy (mp->tunnel_src_address, &tun_src6,
15099 sizeof (ip6_address_t));
15100 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
15101 sizeof (ip6_address_t));
15105 clib_memcpy (mp->tunnel_src_address, &tun_src4,
15106 sizeof (ip4_address_t));
15107 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
15108 sizeof (ip4_address_t));
15118 api_ipsec_sa_set_key (vat_main_t * vam)
15120 unformat_input_t *i = vam->input;
15121 vl_api_ipsec_sa_set_key_t *mp;
15123 u8 *ck = 0, *ik = 0;
15126 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15128 if (unformat (i, "sa_id %d", &sa_id))
15130 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
15132 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
15136 clib_warning ("parse error '%U'", format_unformat_error, i);
15141 M (IPSEC_SA_SET_KEY, mp);
15143 mp->sa_id = ntohl (sa_id);
15144 mp->crypto_key_length = vec_len (ck);
15145 mp->integrity_key_length = vec_len (ik);
15147 if (mp->crypto_key_length > sizeof (mp->crypto_key))
15148 mp->crypto_key_length = sizeof (mp->crypto_key);
15150 if (mp->integrity_key_length > sizeof (mp->integrity_key))
15151 mp->integrity_key_length = sizeof (mp->integrity_key);
15154 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
15156 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
15164 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
15166 unformat_input_t *i = vam->input;
15167 vl_api_ipsec_tunnel_if_add_del_t *mp;
15168 u32 local_spi = 0, remote_spi = 0;
15169 u32 crypto_alg = 0, integ_alg = 0;
15170 u8 *lck = NULL, *rck = NULL;
15171 u8 *lik = NULL, *rik = NULL;
15172 ip4_address_t local_ip = { {0} };
15173 ip4_address_t remote_ip = { {0} };
15176 u8 anti_replay = 0;
15181 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15183 if (unformat (i, "del"))
15185 else if (unformat (i, "esn"))
15187 else if (unformat (i, "anti_replay"))
15189 else if (unformat (i, "local_spi %d", &local_spi))
15191 else if (unformat (i, "remote_spi %d", &remote_spi))
15193 else if (unformat (i, "local_ip %U", unformat_ip4_address, &local_ip))
15195 else if (unformat (i, "remote_ip %U", unformat_ip4_address, &remote_ip))
15197 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
15200 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
15202 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
15204 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
15208 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
15210 if (crypto_alg >= IPSEC_CRYPTO_N_ALG)
15212 errmsg ("unsupported crypto-alg: '%U'\n",
15213 format_ipsec_crypto_alg, crypto_alg);
15219 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
15221 if (integ_alg >= IPSEC_INTEG_N_ALG)
15223 errmsg ("unsupported integ-alg: '%U'\n",
15224 format_ipsec_integ_alg, integ_alg);
15228 else if (unformat (i, "instance %u", &instance))
15232 errmsg ("parse error '%U'\n", format_unformat_error, i);
15237 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
15239 mp->is_add = is_add;
15241 mp->anti_replay = anti_replay;
15243 clib_memcpy (mp->local_ip, &local_ip, sizeof (ip4_address_t));
15244 clib_memcpy (mp->remote_ip, &remote_ip, sizeof (ip4_address_t));
15246 mp->local_spi = htonl (local_spi);
15247 mp->remote_spi = htonl (remote_spi);
15248 mp->crypto_alg = (u8) crypto_alg;
15250 mp->local_crypto_key_len = 0;
15253 mp->local_crypto_key_len = vec_len (lck);
15254 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
15255 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
15256 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
15259 mp->remote_crypto_key_len = 0;
15262 mp->remote_crypto_key_len = vec_len (rck);
15263 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
15264 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
15265 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
15268 mp->integ_alg = (u8) integ_alg;
15270 mp->local_integ_key_len = 0;
15273 mp->local_integ_key_len = vec_len (lik);
15274 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
15275 mp->local_integ_key_len = sizeof (mp->local_integ_key);
15276 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
15279 mp->remote_integ_key_len = 0;
15282 mp->remote_integ_key_len = vec_len (rik);
15283 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
15284 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
15285 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
15290 mp->renumber = renumber;
15291 mp->show_instance = ntohl (instance);
15300 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
15302 vat_main_t *vam = &vat_main;
15304 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
15305 "crypto_key %U integ_alg %u integ_key %U use_esn %u "
15306 "use_anti_replay %u is_tunnel %u is_tunnel_ip6 %u "
15307 "tunnel_src_addr %U tunnel_dst_addr %U "
15308 "salt %u seq_outbound %lu last_seq_inbound %lu "
15309 "replay_window %lu total_data_size %lu\n",
15310 ntohl (mp->sa_id), ntohl (mp->sw_if_index), ntohl (mp->spi),
15312 mp->crypto_alg, format_hex_bytes, mp->crypto_key, mp->crypto_key_len,
15313 mp->integ_alg, format_hex_bytes, mp->integ_key, mp->integ_key_len,
15314 mp->use_esn, mp->use_anti_replay, mp->is_tunnel, mp->is_tunnel_ip6,
15315 (mp->is_tunnel_ip6) ? format_ip6_address : format_ip4_address,
15316 mp->tunnel_src_addr,
15317 (mp->is_tunnel_ip6) ? format_ip6_address : format_ip4_address,
15318 mp->tunnel_dst_addr,
15320 clib_net_to_host_u64 (mp->seq_outbound),
15321 clib_net_to_host_u64 (mp->last_seq_inbound),
15322 clib_net_to_host_u64 (mp->replay_window),
15323 clib_net_to_host_u64 (mp->total_data_size));
15326 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
15327 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
15329 static void vl_api_ipsec_sa_details_t_handler_json
15330 (vl_api_ipsec_sa_details_t * mp)
15332 vat_main_t *vam = &vat_main;
15333 vat_json_node_t *node = NULL;
15334 struct in_addr src_ip4, dst_ip4;
15335 struct in6_addr src_ip6, dst_ip6;
15337 if (VAT_JSON_ARRAY != vam->json_tree.type)
15339 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15340 vat_json_init_array (&vam->json_tree);
15342 node = vat_json_array_add (&vam->json_tree);
15344 vat_json_init_object (node);
15345 vat_json_object_add_uint (node, "sa_id", ntohl (mp->sa_id));
15346 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
15347 vat_json_object_add_uint (node, "spi", ntohl (mp->spi));
15348 vat_json_object_add_uint (node, "proto", mp->protocol);
15349 vat_json_object_add_uint (node, "crypto_alg", mp->crypto_alg);
15350 vat_json_object_add_uint (node, "integ_alg", mp->integ_alg);
15351 vat_json_object_add_uint (node, "use_esn", mp->use_esn);
15352 vat_json_object_add_uint (node, "use_anti_replay", mp->use_anti_replay);
15353 vat_json_object_add_uint (node, "is_tunnel", mp->is_tunnel);
15354 vat_json_object_add_uint (node, "is_tunnel_ip6", mp->is_tunnel_ip6);
15355 vat_json_object_add_bytes (node, "crypto_key", mp->crypto_key,
15356 mp->crypto_key_len);
15357 vat_json_object_add_bytes (node, "integ_key", mp->integ_key,
15358 mp->integ_key_len);
15359 if (mp->is_tunnel_ip6)
15361 clib_memcpy (&src_ip6, mp->tunnel_src_addr, sizeof (src_ip6));
15362 vat_json_object_add_ip6 (node, "tunnel_src_addr", src_ip6);
15363 clib_memcpy (&dst_ip6, mp->tunnel_dst_addr, sizeof (dst_ip6));
15364 vat_json_object_add_ip6 (node, "tunnel_dst_addr", dst_ip6);
15368 clib_memcpy (&src_ip4, mp->tunnel_src_addr, sizeof (src_ip4));
15369 vat_json_object_add_ip4 (node, "tunnel_src_addr", src_ip4);
15370 clib_memcpy (&dst_ip4, mp->tunnel_dst_addr, sizeof (dst_ip4));
15371 vat_json_object_add_ip4 (node, "tunnel_dst_addr", dst_ip4);
15373 vat_json_object_add_uint (node, "replay_window",
15374 clib_net_to_host_u64 (mp->replay_window));
15375 vat_json_object_add_uint (node, "total_data_size",
15376 clib_net_to_host_u64 (mp->total_data_size));
15381 api_ipsec_sa_dump (vat_main_t * vam)
15383 unformat_input_t *i = vam->input;
15384 vl_api_ipsec_sa_dump_t *mp;
15385 vl_api_control_ping_t *mp_ping;
15389 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15391 if (unformat (i, "sa_id %d", &sa_id))
15395 clib_warning ("parse error '%U'", format_unformat_error, i);
15400 M (IPSEC_SA_DUMP, mp);
15402 mp->sa_id = ntohl (sa_id);
15406 /* Use a control ping for synchronization */
15407 M (CONTROL_PING, mp_ping);
15415 api_ipsec_tunnel_if_set_key (vat_main_t * vam)
15417 unformat_input_t *i = vam->input;
15418 vl_api_ipsec_tunnel_if_set_key_t *mp;
15419 u32 sw_if_index = ~0;
15420 u8 key_type = IPSEC_IF_SET_KEY_TYPE_NONE;
15425 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15427 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15430 if (unformat (i, "local crypto %U", unformat_ipsec_crypto_alg, &alg))
15431 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_CRYPTO;
15433 if (unformat (i, "remote crypto %U", unformat_ipsec_crypto_alg, &alg))
15434 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_CRYPTO;
15435 else if (unformat (i, "local integ %U", unformat_ipsec_integ_alg, &alg))
15436 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_INTEG;
15438 if (unformat (i, "remote integ %U", unformat_ipsec_integ_alg, &alg))
15439 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_INTEG;
15440 else if (unformat (i, "%U", unformat_hex_string, &key))
15444 clib_warning ("parse error '%U'", format_unformat_error, i);
15449 if (sw_if_index == ~0)
15451 errmsg ("interface must be specified");
15455 if (key_type == IPSEC_IF_SET_KEY_TYPE_NONE)
15457 errmsg ("key type must be specified");
15463 errmsg ("algorithm must be specified");
15467 if (vec_len (key) == 0)
15469 errmsg ("key must be specified");
15473 M (IPSEC_TUNNEL_IF_SET_KEY, mp);
15475 mp->sw_if_index = htonl (sw_if_index);
15477 mp->key_type = key_type;
15478 mp->key_len = vec_len (key);
15479 clib_memcpy (mp->key, key, vec_len (key));
15488 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
15490 unformat_input_t *i = vam->input;
15491 vl_api_ipsec_tunnel_if_set_sa_t *mp;
15492 u32 sw_if_index = ~0;
15494 u8 is_outbound = (u8) ~ 0;
15497 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15499 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15501 else if (unformat (i, "sa_id %d", &sa_id))
15503 else if (unformat (i, "outbound"))
15505 else if (unformat (i, "inbound"))
15509 clib_warning ("parse error '%U'", format_unformat_error, i);
15514 if (sw_if_index == ~0)
15516 errmsg ("interface must be specified");
15522 errmsg ("SA ID must be specified");
15526 M (IPSEC_TUNNEL_IF_SET_SA, mp);
15528 mp->sw_if_index = htonl (sw_if_index);
15529 mp->sa_id = htonl (sa_id);
15530 mp->is_outbound = is_outbound;
15539 api_ikev2_profile_add_del (vat_main_t * vam)
15541 unformat_input_t *i = vam->input;
15542 vl_api_ikev2_profile_add_del_t *mp;
15547 const char *valid_chars = "a-zA-Z0-9_";
15549 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15551 if (unformat (i, "del"))
15553 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15554 vec_add1 (name, 0);
15557 errmsg ("parse error '%U'", format_unformat_error, i);
15562 if (!vec_len (name))
15564 errmsg ("profile name must be specified");
15568 if (vec_len (name) > 64)
15570 errmsg ("profile name too long");
15574 M (IKEV2_PROFILE_ADD_DEL, mp);
15576 clib_memcpy (mp->name, name, vec_len (name));
15577 mp->is_add = is_add;
15586 api_ikev2_profile_set_auth (vat_main_t * vam)
15588 unformat_input_t *i = vam->input;
15589 vl_api_ikev2_profile_set_auth_t *mp;
15592 u32 auth_method = 0;
15596 const char *valid_chars = "a-zA-Z0-9_";
15598 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15600 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15601 vec_add1 (name, 0);
15602 else if (unformat (i, "auth_method %U",
15603 unformat_ikev2_auth_method, &auth_method))
15605 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
15607 else if (unformat (i, "auth_data %v", &data))
15611 errmsg ("parse error '%U'", format_unformat_error, i);
15616 if (!vec_len (name))
15618 errmsg ("profile name must be specified");
15622 if (vec_len (name) > 64)
15624 errmsg ("profile name too long");
15628 if (!vec_len (data))
15630 errmsg ("auth_data must be specified");
15636 errmsg ("auth_method must be specified");
15640 M (IKEV2_PROFILE_SET_AUTH, mp);
15642 mp->is_hex = is_hex;
15643 mp->auth_method = (u8) auth_method;
15644 mp->data_len = vec_len (data);
15645 clib_memcpy (mp->name, name, vec_len (name));
15646 clib_memcpy (mp->data, data, vec_len (data));
15656 api_ikev2_profile_set_id (vat_main_t * vam)
15658 unformat_input_t *i = vam->input;
15659 vl_api_ikev2_profile_set_id_t *mp;
15667 const char *valid_chars = "a-zA-Z0-9_";
15669 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15671 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15672 vec_add1 (name, 0);
15673 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
15675 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
15677 data = vec_new (u8, 4);
15678 clib_memcpy (data, ip4.as_u8, 4);
15680 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
15682 else if (unformat (i, "id_data %v", &data))
15684 else if (unformat (i, "local"))
15686 else if (unformat (i, "remote"))
15690 errmsg ("parse error '%U'", format_unformat_error, i);
15695 if (!vec_len (name))
15697 errmsg ("profile name must be specified");
15701 if (vec_len (name) > 64)
15703 errmsg ("profile name too long");
15707 if (!vec_len (data))
15709 errmsg ("id_data must be specified");
15715 errmsg ("id_type must be specified");
15719 M (IKEV2_PROFILE_SET_ID, mp);
15721 mp->is_local = is_local;
15722 mp->id_type = (u8) id_type;
15723 mp->data_len = vec_len (data);
15724 clib_memcpy (mp->name, name, vec_len (name));
15725 clib_memcpy (mp->data, data, vec_len (data));
15735 api_ikev2_profile_set_ts (vat_main_t * vam)
15737 unformat_input_t *i = vam->input;
15738 vl_api_ikev2_profile_set_ts_t *mp;
15741 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
15742 ip4_address_t start_addr, end_addr;
15744 const char *valid_chars = "a-zA-Z0-9_";
15747 start_addr.as_u32 = 0;
15748 end_addr.as_u32 = (u32) ~ 0;
15750 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15752 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15753 vec_add1 (name, 0);
15754 else if (unformat (i, "protocol %d", &proto))
15756 else if (unformat (i, "start_port %d", &start_port))
15758 else if (unformat (i, "end_port %d", &end_port))
15761 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
15763 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
15765 else if (unformat (i, "local"))
15767 else if (unformat (i, "remote"))
15771 errmsg ("parse error '%U'", format_unformat_error, i);
15776 if (!vec_len (name))
15778 errmsg ("profile name must be specified");
15782 if (vec_len (name) > 64)
15784 errmsg ("profile name too long");
15788 M (IKEV2_PROFILE_SET_TS, mp);
15790 mp->is_local = is_local;
15791 mp->proto = (u8) proto;
15792 mp->start_port = (u16) start_port;
15793 mp->end_port = (u16) end_port;
15794 mp->start_addr = start_addr.as_u32;
15795 mp->end_addr = end_addr.as_u32;
15796 clib_memcpy (mp->name, name, vec_len (name));
15805 api_ikev2_set_local_key (vat_main_t * vam)
15807 unformat_input_t *i = vam->input;
15808 vl_api_ikev2_set_local_key_t *mp;
15812 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15814 if (unformat (i, "file %v", &file))
15815 vec_add1 (file, 0);
15818 errmsg ("parse error '%U'", format_unformat_error, i);
15823 if (!vec_len (file))
15825 errmsg ("RSA key file must be specified");
15829 if (vec_len (file) > 256)
15831 errmsg ("file name too long");
15835 M (IKEV2_SET_LOCAL_KEY, mp);
15837 clib_memcpy (mp->key_file, file, vec_len (file));
15846 api_ikev2_set_responder (vat_main_t * vam)
15848 unformat_input_t *i = vam->input;
15849 vl_api_ikev2_set_responder_t *mp;
15852 u32 sw_if_index = ~0;
15853 ip4_address_t address;
15855 const char *valid_chars = "a-zA-Z0-9_";
15857 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15860 (i, "%U interface %d address %U", unformat_token, valid_chars,
15861 &name, &sw_if_index, unformat_ip4_address, &address))
15862 vec_add1 (name, 0);
15865 errmsg ("parse error '%U'", format_unformat_error, i);
15870 if (!vec_len (name))
15872 errmsg ("profile name must be specified");
15876 if (vec_len (name) > 64)
15878 errmsg ("profile name too long");
15882 M (IKEV2_SET_RESPONDER, mp);
15884 clib_memcpy (mp->name, name, vec_len (name));
15887 mp->sw_if_index = sw_if_index;
15888 clib_memcpy (mp->address, &address, sizeof (address));
15896 api_ikev2_set_ike_transforms (vat_main_t * vam)
15898 unformat_input_t *i = vam->input;
15899 vl_api_ikev2_set_ike_transforms_t *mp;
15902 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
15904 const char *valid_chars = "a-zA-Z0-9_";
15906 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15908 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
15909 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
15910 vec_add1 (name, 0);
15913 errmsg ("parse error '%U'", format_unformat_error, i);
15918 if (!vec_len (name))
15920 errmsg ("profile name must be specified");
15924 if (vec_len (name) > 64)
15926 errmsg ("profile name too long");
15930 M (IKEV2_SET_IKE_TRANSFORMS, mp);
15932 clib_memcpy (mp->name, name, vec_len (name));
15934 mp->crypto_alg = crypto_alg;
15935 mp->crypto_key_size = crypto_key_size;
15936 mp->integ_alg = integ_alg;
15937 mp->dh_group = dh_group;
15946 api_ikev2_set_esp_transforms (vat_main_t * vam)
15948 unformat_input_t *i = vam->input;
15949 vl_api_ikev2_set_esp_transforms_t *mp;
15952 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
15954 const char *valid_chars = "a-zA-Z0-9_";
15956 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15958 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
15959 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
15960 vec_add1 (name, 0);
15963 errmsg ("parse error '%U'", format_unformat_error, i);
15968 if (!vec_len (name))
15970 errmsg ("profile name must be specified");
15974 if (vec_len (name) > 64)
15976 errmsg ("profile name too long");
15980 M (IKEV2_SET_ESP_TRANSFORMS, mp);
15982 clib_memcpy (mp->name, name, vec_len (name));
15984 mp->crypto_alg = crypto_alg;
15985 mp->crypto_key_size = crypto_key_size;
15986 mp->integ_alg = integ_alg;
15987 mp->dh_group = dh_group;
15995 api_ikev2_set_sa_lifetime (vat_main_t * vam)
15997 unformat_input_t *i = vam->input;
15998 vl_api_ikev2_set_sa_lifetime_t *mp;
16001 u64 lifetime, lifetime_maxdata;
16002 u32 lifetime_jitter, handover;
16004 const char *valid_chars = "a-zA-Z0-9_";
16006 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16008 if (unformat (i, "%U %lu %u %u %lu", unformat_token, valid_chars, &name,
16009 &lifetime, &lifetime_jitter, &handover,
16010 &lifetime_maxdata))
16011 vec_add1 (name, 0);
16014 errmsg ("parse error '%U'", format_unformat_error, i);
16019 if (!vec_len (name))
16021 errmsg ("profile name must be specified");
16025 if (vec_len (name) > 64)
16027 errmsg ("profile name too long");
16031 M (IKEV2_SET_SA_LIFETIME, mp);
16033 clib_memcpy (mp->name, name, vec_len (name));
16035 mp->lifetime = lifetime;
16036 mp->lifetime_jitter = lifetime_jitter;
16037 mp->handover = handover;
16038 mp->lifetime_maxdata = lifetime_maxdata;
16046 api_ikev2_initiate_sa_init (vat_main_t * vam)
16048 unformat_input_t *i = vam->input;
16049 vl_api_ikev2_initiate_sa_init_t *mp;
16053 const char *valid_chars = "a-zA-Z0-9_";
16055 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16057 if (unformat (i, "%U", unformat_token, valid_chars, &name))
16058 vec_add1 (name, 0);
16061 errmsg ("parse error '%U'", format_unformat_error, i);
16066 if (!vec_len (name))
16068 errmsg ("profile name must be specified");
16072 if (vec_len (name) > 64)
16074 errmsg ("profile name too long");
16078 M (IKEV2_INITIATE_SA_INIT, mp);
16080 clib_memcpy (mp->name, name, vec_len (name));
16089 api_ikev2_initiate_del_ike_sa (vat_main_t * vam)
16091 unformat_input_t *i = vam->input;
16092 vl_api_ikev2_initiate_del_ike_sa_t *mp;
16097 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16099 if (unformat (i, "%lx", &ispi))
16103 errmsg ("parse error '%U'", format_unformat_error, i);
16108 M (IKEV2_INITIATE_DEL_IKE_SA, mp);
16118 api_ikev2_initiate_del_child_sa (vat_main_t * vam)
16120 unformat_input_t *i = vam->input;
16121 vl_api_ikev2_initiate_del_child_sa_t *mp;
16126 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16128 if (unformat (i, "%x", &ispi))
16132 errmsg ("parse error '%U'", format_unformat_error, i);
16137 M (IKEV2_INITIATE_DEL_CHILD_SA, mp);
16147 api_ikev2_initiate_rekey_child_sa (vat_main_t * vam)
16149 unformat_input_t *i = vam->input;
16150 vl_api_ikev2_initiate_rekey_child_sa_t *mp;
16155 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16157 if (unformat (i, "%x", &ispi))
16161 errmsg ("parse error '%U'", format_unformat_error, i);
16166 M (IKEV2_INITIATE_REKEY_CHILD_SA, mp);
16176 api_get_first_msg_id (vat_main_t * vam)
16178 vl_api_get_first_msg_id_t *mp;
16179 unformat_input_t *i = vam->input;
16184 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16186 if (unformat (i, "client %s", &name))
16194 errmsg ("missing client name");
16197 vec_add1 (name, 0);
16199 if (vec_len (name) > 63)
16201 errmsg ("client name too long");
16205 M (GET_FIRST_MSG_ID, mp);
16206 clib_memcpy (mp->name, name, vec_len (name));
16213 api_cop_interface_enable_disable (vat_main_t * vam)
16215 unformat_input_t *line_input = vam->input;
16216 vl_api_cop_interface_enable_disable_t *mp;
16217 u32 sw_if_index = ~0;
16218 u8 enable_disable = 1;
16221 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
16223 if (unformat (line_input, "disable"))
16224 enable_disable = 0;
16225 if (unformat (line_input, "enable"))
16226 enable_disable = 1;
16227 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
16228 vam, &sw_if_index))
16230 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
16236 if (sw_if_index == ~0)
16238 errmsg ("missing interface name or sw_if_index");
16242 /* Construct the API message */
16243 M (COP_INTERFACE_ENABLE_DISABLE, mp);
16244 mp->sw_if_index = ntohl (sw_if_index);
16245 mp->enable_disable = enable_disable;
16249 /* Wait for the reply */
16255 api_cop_whitelist_enable_disable (vat_main_t * vam)
16257 unformat_input_t *line_input = vam->input;
16258 vl_api_cop_whitelist_enable_disable_t *mp;
16259 u32 sw_if_index = ~0;
16260 u8 ip4 = 0, ip6 = 0, default_cop = 0;
16264 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
16266 if (unformat (line_input, "ip4"))
16268 else if (unformat (line_input, "ip6"))
16270 else if (unformat (line_input, "default"))
16272 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
16273 vam, &sw_if_index))
16275 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
16277 else if (unformat (line_input, "fib-id %d", &fib_id))
16283 if (sw_if_index == ~0)
16285 errmsg ("missing interface name or sw_if_index");
16289 /* Construct the API message */
16290 M (COP_WHITELIST_ENABLE_DISABLE, mp);
16291 mp->sw_if_index = ntohl (sw_if_index);
16292 mp->fib_id = ntohl (fib_id);
16295 mp->default_cop = default_cop;
16299 /* Wait for the reply */
16305 api_get_node_graph (vat_main_t * vam)
16307 vl_api_get_node_graph_t *mp;
16310 M (GET_NODE_GRAPH, mp);
16314 /* Wait for the reply */
16320 /** Used for parsing LISP eids */
16321 typedef CLIB_PACKED(struct{
16322 u8 addr[16]; /**< eid address */
16323 u32 len; /**< prefix length if IP */
16324 u8 type; /**< type of eid */
16329 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
16331 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
16333 clib_memset (a, 0, sizeof (a[0]));
16335 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
16337 a->type = 0; /* ipv4 type */
16339 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
16341 a->type = 1; /* ipv6 type */
16343 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
16345 a->type = 2; /* mac type */
16347 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
16349 a->type = 3; /* NSH type */
16350 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
16351 nsh->spi = clib_host_to_net_u32 (nsh->spi);
16358 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
16367 lisp_eid_size_vat (u8 type)
16384 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
16386 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
16390 api_one_add_del_locator_set (vat_main_t * vam)
16392 unformat_input_t *input = vam->input;
16393 vl_api_one_add_del_locator_set_t *mp;
16395 u8 *locator_set_name = NULL;
16396 u8 locator_set_name_set = 0;
16397 vl_api_local_locator_t locator, *locators = 0;
16398 u32 sw_if_index, priority, weight;
16402 /* Parse args required to build the message */
16403 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16405 if (unformat (input, "del"))
16409 else if (unformat (input, "locator-set %s", &locator_set_name))
16411 locator_set_name_set = 1;
16413 else if (unformat (input, "sw_if_index %u p %u w %u",
16414 &sw_if_index, &priority, &weight))
16416 locator.sw_if_index = htonl (sw_if_index);
16417 locator.priority = priority;
16418 locator.weight = weight;
16419 vec_add1 (locators, locator);
16423 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
16424 &sw_if_index, &priority, &weight))
16426 locator.sw_if_index = htonl (sw_if_index);
16427 locator.priority = priority;
16428 locator.weight = weight;
16429 vec_add1 (locators, locator);
16435 if (locator_set_name_set == 0)
16437 errmsg ("missing locator-set name");
16438 vec_free (locators);
16442 if (vec_len (locator_set_name) > 64)
16444 errmsg ("locator-set name too long");
16445 vec_free (locator_set_name);
16446 vec_free (locators);
16449 vec_add1 (locator_set_name, 0);
16451 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
16453 /* Construct the API message */
16454 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
16456 mp->is_add = is_add;
16457 clib_memcpy (mp->locator_set_name, locator_set_name,
16458 vec_len (locator_set_name));
16459 vec_free (locator_set_name);
16461 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
16463 clib_memcpy (mp->locators, locators, data_len);
16464 vec_free (locators);
16469 /* Wait for a reply... */
16474 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
16477 api_one_add_del_locator (vat_main_t * vam)
16479 unformat_input_t *input = vam->input;
16480 vl_api_one_add_del_locator_t *mp;
16481 u32 tmp_if_index = ~0;
16482 u32 sw_if_index = ~0;
16483 u8 sw_if_index_set = 0;
16484 u8 sw_if_index_if_name_set = 0;
16486 u8 priority_set = 0;
16490 u8 *locator_set_name = NULL;
16491 u8 locator_set_name_set = 0;
16494 /* Parse args required to build the message */
16495 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16497 if (unformat (input, "del"))
16501 else if (unformat (input, "locator-set %s", &locator_set_name))
16503 locator_set_name_set = 1;
16505 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
16508 sw_if_index_if_name_set = 1;
16509 sw_if_index = tmp_if_index;
16511 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
16513 sw_if_index_set = 1;
16514 sw_if_index = tmp_if_index;
16516 else if (unformat (input, "p %d", &priority))
16520 else if (unformat (input, "w %d", &weight))
16528 if (locator_set_name_set == 0)
16530 errmsg ("missing locator-set name");
16534 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
16536 errmsg ("missing sw_if_index");
16537 vec_free (locator_set_name);
16541 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
16543 errmsg ("cannot use both params interface name and sw_if_index");
16544 vec_free (locator_set_name);
16548 if (priority_set == 0)
16550 errmsg ("missing locator-set priority");
16551 vec_free (locator_set_name);
16555 if (weight_set == 0)
16557 errmsg ("missing locator-set weight");
16558 vec_free (locator_set_name);
16562 if (vec_len (locator_set_name) > 64)
16564 errmsg ("locator-set name too long");
16565 vec_free (locator_set_name);
16568 vec_add1 (locator_set_name, 0);
16570 /* Construct the API message */
16571 M (ONE_ADD_DEL_LOCATOR, mp);
16573 mp->is_add = is_add;
16574 mp->sw_if_index = ntohl (sw_if_index);
16575 mp->priority = priority;
16576 mp->weight = weight;
16577 clib_memcpy (mp->locator_set_name, locator_set_name,
16578 vec_len (locator_set_name));
16579 vec_free (locator_set_name);
16584 /* Wait for a reply... */
16589 #define api_lisp_add_del_locator api_one_add_del_locator
16592 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
16594 u32 *key_id = va_arg (*args, u32 *);
16597 if (unformat (input, "%s", &s))
16599 if (!strcmp ((char *) s, "sha1"))
16600 key_id[0] = HMAC_SHA_1_96;
16601 else if (!strcmp ((char *) s, "sha256"))
16602 key_id[0] = HMAC_SHA_256_128;
16605 clib_warning ("invalid key_id: '%s'", s);
16606 key_id[0] = HMAC_NO_KEY;
16617 api_one_add_del_local_eid (vat_main_t * vam)
16619 unformat_input_t *input = vam->input;
16620 vl_api_one_add_del_local_eid_t *mp;
16623 lisp_eid_vat_t _eid, *eid = &_eid;
16624 u8 *locator_set_name = 0;
16625 u8 locator_set_name_set = 0;
16631 /* Parse args required to build the message */
16632 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16634 if (unformat (input, "del"))
16638 else if (unformat (input, "vni %d", &vni))
16642 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
16646 else if (unformat (input, "locator-set %s", &locator_set_name))
16648 locator_set_name_set = 1;
16650 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
16652 else if (unformat (input, "secret-key %_%v%_", &key))
16658 if (locator_set_name_set == 0)
16660 errmsg ("missing locator-set name");
16666 errmsg ("EID address not set!");
16667 vec_free (locator_set_name);
16671 if (key && (0 == key_id))
16673 errmsg ("invalid key_id!");
16677 if (vec_len (key) > 64)
16679 errmsg ("key too long");
16684 if (vec_len (locator_set_name) > 64)
16686 errmsg ("locator-set name too long");
16687 vec_free (locator_set_name);
16690 vec_add1 (locator_set_name, 0);
16692 /* Construct the API message */
16693 M (ONE_ADD_DEL_LOCAL_EID, mp);
16695 mp->is_add = is_add;
16696 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
16697 mp->eid_type = eid->type;
16698 mp->prefix_len = eid->len;
16699 mp->vni = clib_host_to_net_u32 (vni);
16700 mp->key_id = clib_host_to_net_u16 (key_id);
16701 clib_memcpy (mp->locator_set_name, locator_set_name,
16702 vec_len (locator_set_name));
16703 clib_memcpy (mp->key, key, vec_len (key));
16705 vec_free (locator_set_name);
16711 /* Wait for a reply... */
16716 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
16719 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
16721 u32 dp_table = 0, vni = 0;;
16722 unformat_input_t *input = vam->input;
16723 vl_api_gpe_add_del_fwd_entry_t *mp;
16725 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
16726 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
16727 u8 rmt_eid_set = 0, lcl_eid_set = 0;
16728 u32 action = ~0, w;
16729 ip4_address_t rmt_rloc4, lcl_rloc4;
16730 ip6_address_t rmt_rloc6, lcl_rloc6;
16731 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
16734 clib_memset (&rloc, 0, sizeof (rloc));
16736 /* Parse args required to build the message */
16737 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16739 if (unformat (input, "del"))
16741 else if (unformat (input, "add"))
16743 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
16747 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
16751 else if (unformat (input, "vrf %d", &dp_table))
16753 else if (unformat (input, "bd %d", &dp_table))
16755 else if (unformat (input, "vni %d", &vni))
16757 else if (unformat (input, "w %d", &w))
16761 errmsg ("No RLOC configured for setting priority/weight!");
16764 curr_rloc->weight = w;
16766 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
16767 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
16771 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
16773 vec_add1 (lcl_locs, rloc);
16775 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
16776 vec_add1 (rmt_locs, rloc);
16777 /* weight saved in rmt loc */
16778 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
16780 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
16781 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
16784 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
16786 vec_add1 (lcl_locs, rloc);
16788 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
16789 vec_add1 (rmt_locs, rloc);
16790 /* weight saved in rmt loc */
16791 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
16793 else if (unformat (input, "action %d", &action))
16799 clib_warning ("parse error '%U'", format_unformat_error, input);
16806 errmsg ("remote eid addresses not set");
16810 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
16812 errmsg ("eid types don't match");
16816 if (0 == rmt_locs && (u32) ~ 0 == action)
16818 errmsg ("action not set for negative mapping");
16822 /* Construct the API message */
16823 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
16824 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
16826 mp->is_add = is_add;
16827 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
16828 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
16829 mp->eid_type = rmt_eid->type;
16830 mp->dp_table = clib_host_to_net_u32 (dp_table);
16831 mp->vni = clib_host_to_net_u32 (vni);
16832 mp->rmt_len = rmt_eid->len;
16833 mp->lcl_len = lcl_eid->len;
16834 mp->action = action;
16836 if (0 != rmt_locs && 0 != lcl_locs)
16838 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
16839 clib_memcpy (mp->locs, lcl_locs,
16840 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
16842 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
16843 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
16844 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
16846 vec_free (lcl_locs);
16847 vec_free (rmt_locs);
16852 /* Wait for a reply... */
16858 api_one_add_del_map_server (vat_main_t * vam)
16860 unformat_input_t *input = vam->input;
16861 vl_api_one_add_del_map_server_t *mp;
16865 ip4_address_t ipv4;
16866 ip6_address_t ipv6;
16869 /* Parse args required to build the message */
16870 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16872 if (unformat (input, "del"))
16876 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
16880 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
16888 if (ipv4_set && ipv6_set)
16890 errmsg ("both eid v4 and v6 addresses set");
16894 if (!ipv4_set && !ipv6_set)
16896 errmsg ("eid addresses not set");
16900 /* Construct the API message */
16901 M (ONE_ADD_DEL_MAP_SERVER, mp);
16903 mp->is_add = is_add;
16907 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
16912 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
16918 /* Wait for a reply... */
16923 #define api_lisp_add_del_map_server api_one_add_del_map_server
16926 api_one_add_del_map_resolver (vat_main_t * vam)
16928 unformat_input_t *input = vam->input;
16929 vl_api_one_add_del_map_resolver_t *mp;
16933 ip4_address_t ipv4;
16934 ip6_address_t ipv6;
16937 /* Parse args required to build the message */
16938 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16940 if (unformat (input, "del"))
16944 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
16948 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
16956 if (ipv4_set && ipv6_set)
16958 errmsg ("both eid v4 and v6 addresses set");
16962 if (!ipv4_set && !ipv6_set)
16964 errmsg ("eid addresses not set");
16968 /* Construct the API message */
16969 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
16971 mp->is_add = is_add;
16975 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
16980 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
16986 /* Wait for a reply... */
16991 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
16994 api_lisp_gpe_enable_disable (vat_main_t * vam)
16996 unformat_input_t *input = vam->input;
16997 vl_api_gpe_enable_disable_t *mp;
17002 /* Parse args required to build the message */
17003 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17005 if (unformat (input, "enable"))
17010 else if (unformat (input, "disable"))
17021 errmsg ("Value not set");
17025 /* Construct the API message */
17026 M (GPE_ENABLE_DISABLE, mp);
17033 /* Wait for a reply... */
17039 api_one_rloc_probe_enable_disable (vat_main_t * vam)
17041 unformat_input_t *input = vam->input;
17042 vl_api_one_rloc_probe_enable_disable_t *mp;
17047 /* Parse args required to build the message */
17048 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17050 if (unformat (input, "enable"))
17055 else if (unformat (input, "disable"))
17063 errmsg ("Value not set");
17067 /* Construct the API message */
17068 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
17070 mp->is_enabled = is_en;
17075 /* Wait for a reply... */
17080 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
17083 api_one_map_register_enable_disable (vat_main_t * vam)
17085 unformat_input_t *input = vam->input;
17086 vl_api_one_map_register_enable_disable_t *mp;
17091 /* Parse args required to build the message */
17092 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17094 if (unformat (input, "enable"))
17099 else if (unformat (input, "disable"))
17107 errmsg ("Value not set");
17111 /* Construct the API message */
17112 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
17114 mp->is_enabled = is_en;
17119 /* Wait for a reply... */
17124 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
17127 api_one_enable_disable (vat_main_t * vam)
17129 unformat_input_t *input = vam->input;
17130 vl_api_one_enable_disable_t *mp;
17135 /* Parse args required to build the message */
17136 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17138 if (unformat (input, "enable"))
17143 else if (unformat (input, "disable"))
17153 errmsg ("Value not set");
17157 /* Construct the API message */
17158 M (ONE_ENABLE_DISABLE, mp);
17165 /* Wait for a reply... */
17170 #define api_lisp_enable_disable api_one_enable_disable
17173 api_one_enable_disable_xtr_mode (vat_main_t * vam)
17175 unformat_input_t *input = vam->input;
17176 vl_api_one_enable_disable_xtr_mode_t *mp;
17181 /* Parse args required to build the message */
17182 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17184 if (unformat (input, "enable"))
17189 else if (unformat (input, "disable"))
17199 errmsg ("Value not set");
17203 /* Construct the API message */
17204 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
17211 /* Wait for a reply... */
17217 api_one_show_xtr_mode (vat_main_t * vam)
17219 vl_api_one_show_xtr_mode_t *mp;
17222 /* Construct the API message */
17223 M (ONE_SHOW_XTR_MODE, mp);
17228 /* Wait for a reply... */
17234 api_one_enable_disable_pitr_mode (vat_main_t * vam)
17236 unformat_input_t *input = vam->input;
17237 vl_api_one_enable_disable_pitr_mode_t *mp;
17242 /* Parse args required to build the message */
17243 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17245 if (unformat (input, "enable"))
17250 else if (unformat (input, "disable"))
17260 errmsg ("Value not set");
17264 /* Construct the API message */
17265 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
17272 /* Wait for a reply... */
17278 api_one_show_pitr_mode (vat_main_t * vam)
17280 vl_api_one_show_pitr_mode_t *mp;
17283 /* Construct the API message */
17284 M (ONE_SHOW_PITR_MODE, mp);
17289 /* Wait for a reply... */
17295 api_one_enable_disable_petr_mode (vat_main_t * vam)
17297 unformat_input_t *input = vam->input;
17298 vl_api_one_enable_disable_petr_mode_t *mp;
17303 /* Parse args required to build the message */
17304 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17306 if (unformat (input, "enable"))
17311 else if (unformat (input, "disable"))
17321 errmsg ("Value not set");
17325 /* Construct the API message */
17326 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
17333 /* Wait for a reply... */
17339 api_one_show_petr_mode (vat_main_t * vam)
17341 vl_api_one_show_petr_mode_t *mp;
17344 /* Construct the API message */
17345 M (ONE_SHOW_PETR_MODE, mp);
17350 /* Wait for a reply... */
17356 api_show_one_map_register_state (vat_main_t * vam)
17358 vl_api_show_one_map_register_state_t *mp;
17361 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
17366 /* wait for reply */
17371 #define api_show_lisp_map_register_state api_show_one_map_register_state
17374 api_show_one_rloc_probe_state (vat_main_t * vam)
17376 vl_api_show_one_rloc_probe_state_t *mp;
17379 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
17384 /* wait for reply */
17389 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
17392 api_one_add_del_ndp_entry (vat_main_t * vam)
17394 vl_api_one_add_del_ndp_entry_t *mp;
17395 unformat_input_t *input = vam->input;
17400 u8 mac[6] = { 0, };
17401 u8 ip6[16] = { 0, };
17405 /* Parse args required to build the message */
17406 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17408 if (unformat (input, "del"))
17410 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
17412 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
17414 else if (unformat (input, "bd %d", &bd))
17418 errmsg ("parse error '%U'", format_unformat_error, input);
17423 if (!bd_set || !ip_set || (!mac_set && is_add))
17425 errmsg ("Missing BD, IP or MAC!");
17429 M (ONE_ADD_DEL_NDP_ENTRY, mp);
17430 mp->is_add = is_add;
17431 clib_memcpy (mp->mac, mac, 6);
17432 mp->bd = clib_host_to_net_u32 (bd);
17433 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
17438 /* wait for reply */
17444 api_one_add_del_l2_arp_entry (vat_main_t * vam)
17446 vl_api_one_add_del_l2_arp_entry_t *mp;
17447 unformat_input_t *input = vam->input;
17452 u8 mac[6] = { 0, };
17453 u32 ip4 = 0, bd = ~0;
17456 /* Parse args required to build the message */
17457 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17459 if (unformat (input, "del"))
17461 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
17463 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
17465 else if (unformat (input, "bd %d", &bd))
17469 errmsg ("parse error '%U'", format_unformat_error, input);
17474 if (!bd_set || !ip_set || (!mac_set && is_add))
17476 errmsg ("Missing BD, IP or MAC!");
17480 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
17481 mp->is_add = is_add;
17482 clib_memcpy (mp->mac, mac, 6);
17483 mp->bd = clib_host_to_net_u32 (bd);
17489 /* wait for reply */
17495 api_one_ndp_bd_get (vat_main_t * vam)
17497 vl_api_one_ndp_bd_get_t *mp;
17500 M (ONE_NDP_BD_GET, mp);
17505 /* wait for reply */
17511 api_one_ndp_entries_get (vat_main_t * vam)
17513 vl_api_one_ndp_entries_get_t *mp;
17514 unformat_input_t *input = vam->input;
17519 /* Parse args required to build the message */
17520 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17522 if (unformat (input, "bd %d", &bd))
17526 errmsg ("parse error '%U'", format_unformat_error, input);
17533 errmsg ("Expected bridge domain!");
17537 M (ONE_NDP_ENTRIES_GET, mp);
17538 mp->bd = clib_host_to_net_u32 (bd);
17543 /* wait for reply */
17549 api_one_l2_arp_bd_get (vat_main_t * vam)
17551 vl_api_one_l2_arp_bd_get_t *mp;
17554 M (ONE_L2_ARP_BD_GET, mp);
17559 /* wait for reply */
17565 api_one_l2_arp_entries_get (vat_main_t * vam)
17567 vl_api_one_l2_arp_entries_get_t *mp;
17568 unformat_input_t *input = vam->input;
17573 /* Parse args required to build the message */
17574 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17576 if (unformat (input, "bd %d", &bd))
17580 errmsg ("parse error '%U'", format_unformat_error, input);
17587 errmsg ("Expected bridge domain!");
17591 M (ONE_L2_ARP_ENTRIES_GET, mp);
17592 mp->bd = clib_host_to_net_u32 (bd);
17597 /* wait for reply */
17603 api_one_stats_enable_disable (vat_main_t * vam)
17605 vl_api_one_stats_enable_disable_t *mp;
17606 unformat_input_t *input = vam->input;
17611 /* Parse args required to build the message */
17612 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17614 if (unformat (input, "enable"))
17619 else if (unformat (input, "disable"))
17629 errmsg ("Value not set");
17633 M (ONE_STATS_ENABLE_DISABLE, mp);
17639 /* wait for reply */
17645 api_show_one_stats_enable_disable (vat_main_t * vam)
17647 vl_api_show_one_stats_enable_disable_t *mp;
17650 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
17655 /* wait for reply */
17661 api_show_one_map_request_mode (vat_main_t * vam)
17663 vl_api_show_one_map_request_mode_t *mp;
17666 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
17671 /* wait for reply */
17676 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
17679 api_one_map_request_mode (vat_main_t * vam)
17681 unformat_input_t *input = vam->input;
17682 vl_api_one_map_request_mode_t *mp;
17686 /* Parse args required to build the message */
17687 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17689 if (unformat (input, "dst-only"))
17691 else if (unformat (input, "src-dst"))
17695 errmsg ("parse error '%U'", format_unformat_error, input);
17700 M (ONE_MAP_REQUEST_MODE, mp);
17707 /* wait for reply */
17712 #define api_lisp_map_request_mode api_one_map_request_mode
17715 * Enable/disable ONE proxy ITR.
17717 * @param vam vpp API test context
17718 * @return return code
17721 api_one_pitr_set_locator_set (vat_main_t * vam)
17723 u8 ls_name_set = 0;
17724 unformat_input_t *input = vam->input;
17725 vl_api_one_pitr_set_locator_set_t *mp;
17730 /* Parse args required to build the message */
17731 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17733 if (unformat (input, "del"))
17735 else if (unformat (input, "locator-set %s", &ls_name))
17739 errmsg ("parse error '%U'", format_unformat_error, input);
17746 errmsg ("locator-set name not set!");
17750 M (ONE_PITR_SET_LOCATOR_SET, mp);
17752 mp->is_add = is_add;
17753 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
17754 vec_free (ls_name);
17759 /* wait for reply */
17764 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
17767 api_one_nsh_set_locator_set (vat_main_t * vam)
17769 u8 ls_name_set = 0;
17770 unformat_input_t *input = vam->input;
17771 vl_api_one_nsh_set_locator_set_t *mp;
17776 /* Parse args required to build the message */
17777 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17779 if (unformat (input, "del"))
17781 else if (unformat (input, "ls %s", &ls_name))
17785 errmsg ("parse error '%U'", format_unformat_error, input);
17790 if (!ls_name_set && is_add)
17792 errmsg ("locator-set name not set!");
17796 M (ONE_NSH_SET_LOCATOR_SET, mp);
17798 mp->is_add = is_add;
17799 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
17800 vec_free (ls_name);
17805 /* wait for reply */
17811 api_show_one_pitr (vat_main_t * vam)
17813 vl_api_show_one_pitr_t *mp;
17816 if (!vam->json_output)
17818 print (vam->ofp, "%=20s", "lisp status:");
17821 M (SHOW_ONE_PITR, mp);
17825 /* Wait for a reply... */
17830 #define api_show_lisp_pitr api_show_one_pitr
17833 api_one_use_petr (vat_main_t * vam)
17835 unformat_input_t *input = vam->input;
17836 vl_api_one_use_petr_t *mp;
17841 clib_memset (&ip, 0, sizeof (ip));
17843 /* Parse args required to build the message */
17844 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17846 if (unformat (input, "disable"))
17849 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
17852 ip_addr_version (&ip) = IP4;
17855 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
17858 ip_addr_version (&ip) = IP6;
17862 errmsg ("parse error '%U'", format_unformat_error, input);
17867 M (ONE_USE_PETR, mp);
17869 mp->is_add = is_add;
17872 mp->is_ip4 = ip_addr_version (&ip) == IP4 ? 1 : 0;
17874 clib_memcpy (mp->address, &ip, 4);
17876 clib_memcpy (mp->address, &ip, 16);
17882 /* wait for reply */
17887 #define api_lisp_use_petr api_one_use_petr
17890 api_show_one_nsh_mapping (vat_main_t * vam)
17892 vl_api_show_one_use_petr_t *mp;
17895 if (!vam->json_output)
17897 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
17900 M (SHOW_ONE_NSH_MAPPING, mp);
17904 /* Wait for a reply... */
17910 api_show_one_use_petr (vat_main_t * vam)
17912 vl_api_show_one_use_petr_t *mp;
17915 if (!vam->json_output)
17917 print (vam->ofp, "%=20s", "Proxy-ETR status:");
17920 M (SHOW_ONE_USE_PETR, mp);
17924 /* Wait for a reply... */
17929 #define api_show_lisp_use_petr api_show_one_use_petr
17932 * Add/delete mapping between vni and vrf
17935 api_one_eid_table_add_del_map (vat_main_t * vam)
17937 unformat_input_t *input = vam->input;
17938 vl_api_one_eid_table_add_del_map_t *mp;
17939 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
17940 u32 vni, vrf, bd_index;
17943 /* Parse args required to build the message */
17944 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17946 if (unformat (input, "del"))
17948 else if (unformat (input, "vrf %d", &vrf))
17950 else if (unformat (input, "bd_index %d", &bd_index))
17952 else if (unformat (input, "vni %d", &vni))
17958 if (!vni_set || (!vrf_set && !bd_index_set))
17960 errmsg ("missing arguments!");
17964 if (vrf_set && bd_index_set)
17966 errmsg ("error: both vrf and bd entered!");
17970 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
17972 mp->is_add = is_add;
17973 mp->vni = htonl (vni);
17974 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
17975 mp->is_l2 = bd_index_set;
17980 /* wait for reply */
17985 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
17988 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
17990 u32 *action = va_arg (*args, u32 *);
17993 if (unformat (input, "%s", &s))
17995 if (!strcmp ((char *) s, "no-action"))
17997 else if (!strcmp ((char *) s, "natively-forward"))
17999 else if (!strcmp ((char *) s, "send-map-request"))
18001 else if (!strcmp ((char *) s, "drop"))
18005 clib_warning ("invalid action: '%s'", s);
18017 * Add/del remote mapping to/from ONE control plane
18019 * @param vam vpp API test context
18020 * @return return code
18023 api_one_add_del_remote_mapping (vat_main_t * vam)
18025 unformat_input_t *input = vam->input;
18026 vl_api_one_add_del_remote_mapping_t *mp;
18028 lisp_eid_vat_t _eid, *eid = &_eid;
18029 lisp_eid_vat_t _seid, *seid = &_seid;
18030 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
18031 u32 action = ~0, p, w, data_len;
18032 ip4_address_t rloc4;
18033 ip6_address_t rloc6;
18034 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
18037 clib_memset (&rloc, 0, sizeof (rloc));
18039 /* Parse args required to build the message */
18040 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18042 if (unformat (input, "del-all"))
18046 else if (unformat (input, "del"))
18050 else if (unformat (input, "add"))
18054 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
18058 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
18062 else if (unformat (input, "vni %d", &vni))
18066 else if (unformat (input, "p %d w %d", &p, &w))
18070 errmsg ("No RLOC configured for setting priority/weight!");
18073 curr_rloc->priority = p;
18074 curr_rloc->weight = w;
18076 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
18079 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
18080 vec_add1 (rlocs, rloc);
18081 curr_rloc = &rlocs[vec_len (rlocs) - 1];
18083 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
18086 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
18087 vec_add1 (rlocs, rloc);
18088 curr_rloc = &rlocs[vec_len (rlocs) - 1];
18090 else if (unformat (input, "action %U",
18091 unformat_negative_mapping_action, &action))
18097 clib_warning ("parse error '%U'", format_unformat_error, input);
18104 errmsg ("missing params!");
18108 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
18110 errmsg ("no action set for negative map-reply!");
18114 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
18116 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
18117 mp->is_add = is_add;
18118 mp->vni = htonl (vni);
18119 mp->action = (u8) action;
18120 mp->is_src_dst = seid_set;
18121 mp->eid_len = eid->len;
18122 mp->seid_len = seid->len;
18123 mp->del_all = del_all;
18124 mp->eid_type = eid->type;
18125 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
18126 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
18128 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
18129 clib_memcpy (mp->rlocs, rlocs, data_len);
18135 /* Wait for a reply... */
18140 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
18143 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
18144 * forwarding entries in data-plane accordingly.
18146 * @param vam vpp API test context
18147 * @return return code
18150 api_one_add_del_adjacency (vat_main_t * vam)
18152 unformat_input_t *input = vam->input;
18153 vl_api_one_add_del_adjacency_t *mp;
18155 ip4_address_t leid4, reid4;
18156 ip6_address_t leid6, reid6;
18157 u8 reid_mac[6] = { 0 };
18158 u8 leid_mac[6] = { 0 };
18159 u8 reid_type, leid_type;
18160 u32 leid_len = 0, reid_len = 0, len;
18164 leid_type = reid_type = (u8) ~ 0;
18166 /* Parse args required to build the message */
18167 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18169 if (unformat (input, "del"))
18173 else if (unformat (input, "add"))
18177 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
18180 reid_type = 0; /* ipv4 */
18183 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
18186 reid_type = 1; /* ipv6 */
18189 else if (unformat (input, "reid %U", unformat_ethernet_address,
18192 reid_type = 2; /* mac */
18194 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
18197 leid_type = 0; /* ipv4 */
18200 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
18203 leid_type = 1; /* ipv6 */
18206 else if (unformat (input, "leid %U", unformat_ethernet_address,
18209 leid_type = 2; /* mac */
18211 else if (unformat (input, "vni %d", &vni))
18217 errmsg ("parse error '%U'", format_unformat_error, input);
18222 if ((u8) ~ 0 == reid_type)
18224 errmsg ("missing params!");
18228 if (leid_type != reid_type)
18230 errmsg ("remote and local EIDs are of different types!");
18234 M (ONE_ADD_DEL_ADJACENCY, mp);
18235 mp->is_add = is_add;
18236 mp->vni = htonl (vni);
18237 mp->leid_len = leid_len;
18238 mp->reid_len = reid_len;
18239 mp->eid_type = reid_type;
18241 switch (mp->eid_type)
18244 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
18245 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
18248 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
18249 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
18252 clib_memcpy (mp->leid, leid_mac, 6);
18253 clib_memcpy (mp->reid, reid_mac, 6);
18256 errmsg ("unknown EID type %d!", mp->eid_type);
18263 /* Wait for a reply... */
18268 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
18271 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
18273 u32 *mode = va_arg (*args, u32 *);
18275 if (unformat (input, "lisp"))
18277 else if (unformat (input, "vxlan"))
18286 api_gpe_get_encap_mode (vat_main_t * vam)
18288 vl_api_gpe_get_encap_mode_t *mp;
18291 /* Construct the API message */
18292 M (GPE_GET_ENCAP_MODE, mp);
18297 /* Wait for a reply... */
18303 api_gpe_set_encap_mode (vat_main_t * vam)
18305 unformat_input_t *input = vam->input;
18306 vl_api_gpe_set_encap_mode_t *mp;
18310 /* Parse args required to build the message */
18311 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18313 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
18319 /* Construct the API message */
18320 M (GPE_SET_ENCAP_MODE, mp);
18327 /* Wait for a reply... */
18333 api_lisp_gpe_add_del_iface (vat_main_t * vam)
18335 unformat_input_t *input = vam->input;
18336 vl_api_gpe_add_del_iface_t *mp;
18337 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
18338 u32 dp_table = 0, vni = 0;
18341 /* Parse args required to build the message */
18342 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18344 if (unformat (input, "up"))
18349 else if (unformat (input, "down"))
18354 else if (unformat (input, "table_id %d", &dp_table))
18358 else if (unformat (input, "bd_id %d", &dp_table))
18363 else if (unformat (input, "vni %d", &vni))
18371 if (action_set == 0)
18373 errmsg ("Action not set");
18376 if (dp_table_set == 0 || vni_set == 0)
18378 errmsg ("vni and dp_table must be set");
18382 /* Construct the API message */
18383 M (GPE_ADD_DEL_IFACE, mp);
18385 mp->is_add = is_add;
18386 mp->dp_table = clib_host_to_net_u32 (dp_table);
18388 mp->vni = clib_host_to_net_u32 (vni);
18393 /* Wait for a reply... */
18399 api_one_map_register_fallback_threshold (vat_main_t * vam)
18401 unformat_input_t *input = vam->input;
18402 vl_api_one_map_register_fallback_threshold_t *mp;
18407 /* Parse args required to build the message */
18408 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18410 if (unformat (input, "%u", &value))
18414 clib_warning ("parse error '%U'", format_unformat_error, input);
18421 errmsg ("fallback threshold value is missing!");
18425 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
18426 mp->value = clib_host_to_net_u32 (value);
18431 /* Wait for a reply... */
18437 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
18439 vl_api_show_one_map_register_fallback_threshold_t *mp;
18442 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
18447 /* Wait for a reply... */
18453 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
18455 u32 *proto = va_arg (*args, u32 *);
18457 if (unformat (input, "udp"))
18459 else if (unformat (input, "api"))
18468 api_one_set_transport_protocol (vat_main_t * vam)
18470 unformat_input_t *input = vam->input;
18471 vl_api_one_set_transport_protocol_t *mp;
18476 /* Parse args required to build the message */
18477 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18479 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
18483 clib_warning ("parse error '%U'", format_unformat_error, input);
18490 errmsg ("Transport protocol missing!");
18494 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
18495 mp->protocol = (u8) protocol;
18500 /* Wait for a reply... */
18506 api_one_get_transport_protocol (vat_main_t * vam)
18508 vl_api_one_get_transport_protocol_t *mp;
18511 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
18516 /* Wait for a reply... */
18522 api_one_map_register_set_ttl (vat_main_t * vam)
18524 unformat_input_t *input = vam->input;
18525 vl_api_one_map_register_set_ttl_t *mp;
18530 /* Parse args required to build the message */
18531 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18533 if (unformat (input, "%u", &ttl))
18537 clib_warning ("parse error '%U'", format_unformat_error, input);
18544 errmsg ("TTL value missing!");
18548 M (ONE_MAP_REGISTER_SET_TTL, mp);
18549 mp->ttl = clib_host_to_net_u32 (ttl);
18554 /* Wait for a reply... */
18560 api_show_one_map_register_ttl (vat_main_t * vam)
18562 vl_api_show_one_map_register_ttl_t *mp;
18565 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
18570 /* Wait for a reply... */
18576 * Add/del map request itr rlocs from ONE control plane and updates
18578 * @param vam vpp API test context
18579 * @return return code
18582 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
18584 unformat_input_t *input = vam->input;
18585 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
18586 u8 *locator_set_name = 0;
18587 u8 locator_set_name_set = 0;
18591 /* Parse args required to build the message */
18592 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18594 if (unformat (input, "del"))
18598 else if (unformat (input, "%_%v%_", &locator_set_name))
18600 locator_set_name_set = 1;
18604 clib_warning ("parse error '%U'", format_unformat_error, input);
18609 if (is_add && !locator_set_name_set)
18611 errmsg ("itr-rloc is not set!");
18615 if (is_add && vec_len (locator_set_name) > 64)
18617 errmsg ("itr-rloc locator-set name too long");
18618 vec_free (locator_set_name);
18622 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
18623 mp->is_add = is_add;
18626 clib_memcpy (mp->locator_set_name, locator_set_name,
18627 vec_len (locator_set_name));
18631 clib_memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
18633 vec_free (locator_set_name);
18638 /* Wait for a reply... */
18643 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
18646 api_one_locator_dump (vat_main_t * vam)
18648 unformat_input_t *input = vam->input;
18649 vl_api_one_locator_dump_t *mp;
18650 vl_api_control_ping_t *mp_ping;
18651 u8 is_index_set = 0, is_name_set = 0;
18656 /* Parse args required to build the message */
18657 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18659 if (unformat (input, "ls_name %_%v%_", &ls_name))
18663 else if (unformat (input, "ls_index %d", &ls_index))
18669 errmsg ("parse error '%U'", format_unformat_error, input);
18674 if (!is_index_set && !is_name_set)
18676 errmsg ("error: expected one of index or name!");
18680 if (is_index_set && is_name_set)
18682 errmsg ("error: only one param expected!");
18686 if (vec_len (ls_name) > 62)
18688 errmsg ("error: locator set name too long!");
18692 if (!vam->json_output)
18694 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
18697 M (ONE_LOCATOR_DUMP, mp);
18698 mp->is_index_set = is_index_set;
18701 mp->ls_index = clib_host_to_net_u32 (ls_index);
18704 vec_add1 (ls_name, 0);
18705 strncpy ((char *) mp->ls_name, (char *) ls_name,
18706 sizeof (mp->ls_name) - 1);
18712 /* Use a control ping for synchronization */
18713 MPING (CONTROL_PING, mp_ping);
18716 /* Wait for a reply... */
18721 #define api_lisp_locator_dump api_one_locator_dump
18724 api_one_locator_set_dump (vat_main_t * vam)
18726 vl_api_one_locator_set_dump_t *mp;
18727 vl_api_control_ping_t *mp_ping;
18728 unformat_input_t *input = vam->input;
18732 /* Parse args required to build the message */
18733 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18735 if (unformat (input, "local"))
18739 else if (unformat (input, "remote"))
18745 errmsg ("parse error '%U'", format_unformat_error, input);
18750 if (!vam->json_output)
18752 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
18755 M (ONE_LOCATOR_SET_DUMP, mp);
18757 mp->filter = filter;
18762 /* Use a control ping for synchronization */
18763 MPING (CONTROL_PING, mp_ping);
18766 /* Wait for a reply... */
18771 #define api_lisp_locator_set_dump api_one_locator_set_dump
18774 api_one_eid_table_map_dump (vat_main_t * vam)
18778 unformat_input_t *input = vam->input;
18779 vl_api_one_eid_table_map_dump_t *mp;
18780 vl_api_control_ping_t *mp_ping;
18783 /* Parse args required to build the message */
18784 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18786 if (unformat (input, "l2"))
18791 else if (unformat (input, "l3"))
18798 errmsg ("parse error '%U'", format_unformat_error, input);
18805 errmsg ("expected one of 'l2' or 'l3' parameter!");
18809 if (!vam->json_output)
18811 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
18814 M (ONE_EID_TABLE_MAP_DUMP, mp);
18820 /* Use a control ping for synchronization */
18821 MPING (CONTROL_PING, mp_ping);
18824 /* Wait for a reply... */
18829 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
18832 api_one_eid_table_vni_dump (vat_main_t * vam)
18834 vl_api_one_eid_table_vni_dump_t *mp;
18835 vl_api_control_ping_t *mp_ping;
18838 if (!vam->json_output)
18840 print (vam->ofp, "VNI");
18843 M (ONE_EID_TABLE_VNI_DUMP, mp);
18848 /* Use a control ping for synchronization */
18849 MPING (CONTROL_PING, mp_ping);
18852 /* Wait for a reply... */
18857 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
18860 api_one_eid_table_dump (vat_main_t * vam)
18862 unformat_input_t *i = vam->input;
18863 vl_api_one_eid_table_dump_t *mp;
18864 vl_api_control_ping_t *mp_ping;
18865 struct in_addr ip4;
18866 struct in6_addr ip6;
18868 u8 eid_type = ~0, eid_set = 0;
18869 u32 prefix_length = ~0, t, vni = 0;
18872 lisp_nsh_api_t nsh;
18874 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18876 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
18882 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
18888 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
18893 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
18898 else if (unformat (i, "vni %d", &t))
18902 else if (unformat (i, "local"))
18906 else if (unformat (i, "remote"))
18912 errmsg ("parse error '%U'", format_unformat_error, i);
18917 if (!vam->json_output)
18919 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
18920 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
18923 M (ONE_EID_TABLE_DUMP, mp);
18925 mp->filter = filter;
18929 mp->vni = htonl (vni);
18930 mp->eid_type = eid_type;
18934 mp->prefix_length = prefix_length;
18935 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
18938 mp->prefix_length = prefix_length;
18939 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
18942 clib_memcpy (mp->eid, mac, sizeof (mac));
18945 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
18948 errmsg ("unknown EID type %d!", eid_type);
18956 /* Use a control ping for synchronization */
18957 MPING (CONTROL_PING, mp_ping);
18960 /* Wait for a reply... */
18965 #define api_lisp_eid_table_dump api_one_eid_table_dump
18968 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
18970 unformat_input_t *i = vam->input;
18971 vl_api_gpe_fwd_entries_get_t *mp;
18976 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18978 if (unformat (i, "vni %d", &vni))
18984 errmsg ("parse error '%U'", format_unformat_error, i);
18991 errmsg ("vni not set!");
18995 if (!vam->json_output)
18997 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
19001 M (GPE_FWD_ENTRIES_GET, mp);
19002 mp->vni = clib_host_to_net_u32 (vni);
19007 /* Wait for a reply... */
19012 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
19013 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
19014 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
19015 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
19016 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
19017 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
19018 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
19019 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
19022 api_one_adjacencies_get (vat_main_t * vam)
19024 unformat_input_t *i = vam->input;
19025 vl_api_one_adjacencies_get_t *mp;
19030 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19032 if (unformat (i, "vni %d", &vni))
19038 errmsg ("parse error '%U'", format_unformat_error, i);
19045 errmsg ("vni not set!");
19049 if (!vam->json_output)
19051 print (vam->ofp, "%s %40s", "leid", "reid");
19054 M (ONE_ADJACENCIES_GET, mp);
19055 mp->vni = clib_host_to_net_u32 (vni);
19060 /* Wait for a reply... */
19065 #define api_lisp_adjacencies_get api_one_adjacencies_get
19068 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
19070 unformat_input_t *i = vam->input;
19071 vl_api_gpe_native_fwd_rpaths_get_t *mp;
19073 u8 ip_family_set = 0, is_ip4 = 1;
19075 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19077 if (unformat (i, "ip4"))
19082 else if (unformat (i, "ip6"))
19089 errmsg ("parse error '%U'", format_unformat_error, i);
19094 if (!ip_family_set)
19096 errmsg ("ip family not set!");
19100 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
19101 mp->is_ip4 = is_ip4;
19106 /* Wait for a reply... */
19112 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
19114 vl_api_gpe_fwd_entry_vnis_get_t *mp;
19117 if (!vam->json_output)
19119 print (vam->ofp, "VNIs");
19122 M (GPE_FWD_ENTRY_VNIS_GET, mp);
19127 /* Wait for a reply... */
19133 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
19135 unformat_input_t *i = vam->input;
19136 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
19138 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
19139 struct in_addr ip4;
19140 struct in6_addr ip6;
19141 u32 table_id = 0, nh_sw_if_index = ~0;
19143 clib_memset (&ip4, 0, sizeof (ip4));
19144 clib_memset (&ip6, 0, sizeof (ip6));
19146 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19148 if (unformat (i, "del"))
19150 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
19151 api_unformat_sw_if_index, vam, &nh_sw_if_index))
19156 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
19157 api_unformat_sw_if_index, vam, &nh_sw_if_index))
19162 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
19166 nh_sw_if_index = ~0;
19168 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
19172 nh_sw_if_index = ~0;
19174 else if (unformat (i, "table %d", &table_id))
19178 errmsg ("parse error '%U'", format_unformat_error, i);
19185 errmsg ("nh addr not set!");
19189 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
19190 mp->is_add = is_add;
19191 mp->table_id = clib_host_to_net_u32 (table_id);
19192 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
19193 mp->is_ip4 = is_ip4;
19195 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
19197 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
19202 /* Wait for a reply... */
19208 api_one_map_server_dump (vat_main_t * vam)
19210 vl_api_one_map_server_dump_t *mp;
19211 vl_api_control_ping_t *mp_ping;
19214 if (!vam->json_output)
19216 print (vam->ofp, "%=20s", "Map server");
19219 M (ONE_MAP_SERVER_DUMP, mp);
19223 /* Use a control ping for synchronization */
19224 MPING (CONTROL_PING, mp_ping);
19227 /* Wait for a reply... */
19232 #define api_lisp_map_server_dump api_one_map_server_dump
19235 api_one_map_resolver_dump (vat_main_t * vam)
19237 vl_api_one_map_resolver_dump_t *mp;
19238 vl_api_control_ping_t *mp_ping;
19241 if (!vam->json_output)
19243 print (vam->ofp, "%=20s", "Map resolver");
19246 M (ONE_MAP_RESOLVER_DUMP, mp);
19250 /* Use a control ping for synchronization */
19251 MPING (CONTROL_PING, mp_ping);
19254 /* Wait for a reply... */
19259 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
19262 api_one_stats_flush (vat_main_t * vam)
19264 vl_api_one_stats_flush_t *mp;
19267 M (ONE_STATS_FLUSH, mp);
19274 api_one_stats_dump (vat_main_t * vam)
19276 vl_api_one_stats_dump_t *mp;
19277 vl_api_control_ping_t *mp_ping;
19280 M (ONE_STATS_DUMP, mp);
19284 /* Use a control ping for synchronization */
19285 MPING (CONTROL_PING, mp_ping);
19288 /* Wait for a reply... */
19294 api_show_one_status (vat_main_t * vam)
19296 vl_api_show_one_status_t *mp;
19299 if (!vam->json_output)
19301 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
19304 M (SHOW_ONE_STATUS, mp);
19307 /* Wait for a reply... */
19312 #define api_show_lisp_status api_show_one_status
19315 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
19317 vl_api_gpe_fwd_entry_path_dump_t *mp;
19318 vl_api_control_ping_t *mp_ping;
19319 unformat_input_t *i = vam->input;
19320 u32 fwd_entry_index = ~0;
19323 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19325 if (unformat (i, "index %d", &fwd_entry_index))
19331 if (~0 == fwd_entry_index)
19333 errmsg ("no index specified!");
19337 if (!vam->json_output)
19339 print (vam->ofp, "first line");
19342 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
19346 /* Use a control ping for synchronization */
19347 MPING (CONTROL_PING, mp_ping);
19350 /* Wait for a reply... */
19356 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
19358 vl_api_one_get_map_request_itr_rlocs_t *mp;
19361 if (!vam->json_output)
19363 print (vam->ofp, "%=20s", "itr-rlocs:");
19366 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
19369 /* Wait for a reply... */
19374 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
19377 api_af_packet_create (vat_main_t * vam)
19379 unformat_input_t *i = vam->input;
19380 vl_api_af_packet_create_t *mp;
19381 u8 *host_if_name = 0;
19383 u8 random_hw_addr = 1;
19386 clib_memset (hw_addr, 0, sizeof (hw_addr));
19388 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19390 if (unformat (i, "name %s", &host_if_name))
19391 vec_add1 (host_if_name, 0);
19392 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
19393 random_hw_addr = 0;
19398 if (!vec_len (host_if_name))
19400 errmsg ("host-interface name must be specified");
19404 if (vec_len (host_if_name) > 64)
19406 errmsg ("host-interface name too long");
19410 M (AF_PACKET_CREATE, mp);
19412 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
19413 clib_memcpy (mp->hw_addr, hw_addr, 6);
19414 mp->use_random_hw_addr = random_hw_addr;
19415 vec_free (host_if_name);
19423 fprintf (vam->ofp ? vam->ofp : stderr,
19424 " new sw_if_index = %d\n", vam->sw_if_index);
19431 api_af_packet_delete (vat_main_t * vam)
19433 unformat_input_t *i = vam->input;
19434 vl_api_af_packet_delete_t *mp;
19435 u8 *host_if_name = 0;
19438 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19440 if (unformat (i, "name %s", &host_if_name))
19441 vec_add1 (host_if_name, 0);
19446 if (!vec_len (host_if_name))
19448 errmsg ("host-interface name must be specified");
19452 if (vec_len (host_if_name) > 64)
19454 errmsg ("host-interface name too long");
19458 M (AF_PACKET_DELETE, mp);
19460 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
19461 vec_free (host_if_name);
19468 static void vl_api_af_packet_details_t_handler
19469 (vl_api_af_packet_details_t * mp)
19471 vat_main_t *vam = &vat_main;
19473 print (vam->ofp, "%-16s %d",
19474 mp->host_if_name, clib_net_to_host_u32 (mp->sw_if_index));
19477 static void vl_api_af_packet_details_t_handler_json
19478 (vl_api_af_packet_details_t * mp)
19480 vat_main_t *vam = &vat_main;
19481 vat_json_node_t *node = NULL;
19483 if (VAT_JSON_ARRAY != vam->json_tree.type)
19485 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19486 vat_json_init_array (&vam->json_tree);
19488 node = vat_json_array_add (&vam->json_tree);
19490 vat_json_init_object (node);
19491 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
19492 vat_json_object_add_string_copy (node, "dev_name", mp->host_if_name);
19496 api_af_packet_dump (vat_main_t * vam)
19498 vl_api_af_packet_dump_t *mp;
19499 vl_api_control_ping_t *mp_ping;
19502 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
19503 /* Get list of tap interfaces */
19504 M (AF_PACKET_DUMP, mp);
19507 /* Use a control ping for synchronization */
19508 MPING (CONTROL_PING, mp_ping);
19516 api_policer_add_del (vat_main_t * vam)
19518 unformat_input_t *i = vam->input;
19519 vl_api_policer_add_del_t *mp;
19529 u8 color_aware = 0;
19530 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
19533 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
19534 conform_action.dscp = 0;
19535 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
19536 exceed_action.dscp = 0;
19537 violate_action.action_type = SSE2_QOS_ACTION_DROP;
19538 violate_action.dscp = 0;
19540 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19542 if (unformat (i, "del"))
19544 else if (unformat (i, "name %s", &name))
19545 vec_add1 (name, 0);
19546 else if (unformat (i, "cir %u", &cir))
19548 else if (unformat (i, "eir %u", &eir))
19550 else if (unformat (i, "cb %u", &cb))
19552 else if (unformat (i, "eb %u", &eb))
19554 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
19557 else if (unformat (i, "round_type %U", unformat_policer_round_type,
19560 else if (unformat (i, "type %U", unformat_policer_type, &type))
19562 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
19565 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
19568 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
19571 else if (unformat (i, "color-aware"))
19577 if (!vec_len (name))
19579 errmsg ("policer name must be specified");
19583 if (vec_len (name) > 64)
19585 errmsg ("policer name too long");
19589 M (POLICER_ADD_DEL, mp);
19591 clib_memcpy (mp->name, name, vec_len (name));
19593 mp->is_add = is_add;
19594 mp->cir = ntohl (cir);
19595 mp->eir = ntohl (eir);
19596 mp->cb = clib_net_to_host_u64 (cb);
19597 mp->eb = clib_net_to_host_u64 (eb);
19598 mp->rate_type = rate_type;
19599 mp->round_type = round_type;
19601 mp->conform_action_type = conform_action.action_type;
19602 mp->conform_dscp = conform_action.dscp;
19603 mp->exceed_action_type = exceed_action.action_type;
19604 mp->exceed_dscp = exceed_action.dscp;
19605 mp->violate_action_type = violate_action.action_type;
19606 mp->violate_dscp = violate_action.dscp;
19607 mp->color_aware = color_aware;
19615 api_policer_dump (vat_main_t * vam)
19617 unformat_input_t *i = vam->input;
19618 vl_api_policer_dump_t *mp;
19619 vl_api_control_ping_t *mp_ping;
19620 u8 *match_name = 0;
19621 u8 match_name_valid = 0;
19624 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19626 if (unformat (i, "name %s", &match_name))
19628 vec_add1 (match_name, 0);
19629 match_name_valid = 1;
19635 M (POLICER_DUMP, mp);
19636 mp->match_name_valid = match_name_valid;
19637 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
19638 vec_free (match_name);
19642 /* Use a control ping for synchronization */
19643 MPING (CONTROL_PING, mp_ping);
19646 /* Wait for a reply... */
19652 api_policer_classify_set_interface (vat_main_t * vam)
19654 unformat_input_t *i = vam->input;
19655 vl_api_policer_classify_set_interface_t *mp;
19657 int sw_if_index_set;
19658 u32 ip4_table_index = ~0;
19659 u32 ip6_table_index = ~0;
19660 u32 l2_table_index = ~0;
19664 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19666 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19667 sw_if_index_set = 1;
19668 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19669 sw_if_index_set = 1;
19670 else if (unformat (i, "del"))
19672 else if (unformat (i, "ip4-table %d", &ip4_table_index))
19674 else if (unformat (i, "ip6-table %d", &ip6_table_index))
19676 else if (unformat (i, "l2-table %d", &l2_table_index))
19680 clib_warning ("parse error '%U'", format_unformat_error, i);
19685 if (sw_if_index_set == 0)
19687 errmsg ("missing interface name or sw_if_index");
19691 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
19693 mp->sw_if_index = ntohl (sw_if_index);
19694 mp->ip4_table_index = ntohl (ip4_table_index);
19695 mp->ip6_table_index = ntohl (ip6_table_index);
19696 mp->l2_table_index = ntohl (l2_table_index);
19697 mp->is_add = is_add;
19705 api_policer_classify_dump (vat_main_t * vam)
19707 unformat_input_t *i = vam->input;
19708 vl_api_policer_classify_dump_t *mp;
19709 vl_api_control_ping_t *mp_ping;
19710 u8 type = POLICER_CLASSIFY_N_TABLES;
19713 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
19717 errmsg ("classify table type must be specified");
19721 if (!vam->json_output)
19723 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
19726 M (POLICER_CLASSIFY_DUMP, mp);
19731 /* Use a control ping for synchronization */
19732 MPING (CONTROL_PING, mp_ping);
19735 /* Wait for a reply... */
19741 api_netmap_create (vat_main_t * vam)
19743 unformat_input_t *i = vam->input;
19744 vl_api_netmap_create_t *mp;
19747 u8 random_hw_addr = 1;
19752 clib_memset (hw_addr, 0, sizeof (hw_addr));
19754 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19756 if (unformat (i, "name %s", &if_name))
19757 vec_add1 (if_name, 0);
19758 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
19759 random_hw_addr = 0;
19760 else if (unformat (i, "pipe"))
19762 else if (unformat (i, "master"))
19764 else if (unformat (i, "slave"))
19770 if (!vec_len (if_name))
19772 errmsg ("interface name must be specified");
19776 if (vec_len (if_name) > 64)
19778 errmsg ("interface name too long");
19782 M (NETMAP_CREATE, mp);
19784 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
19785 clib_memcpy (mp->hw_addr, hw_addr, 6);
19786 mp->use_random_hw_addr = random_hw_addr;
19787 mp->is_pipe = is_pipe;
19788 mp->is_master = is_master;
19789 vec_free (if_name);
19797 api_netmap_delete (vat_main_t * vam)
19799 unformat_input_t *i = vam->input;
19800 vl_api_netmap_delete_t *mp;
19804 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19806 if (unformat (i, "name %s", &if_name))
19807 vec_add1 (if_name, 0);
19812 if (!vec_len (if_name))
19814 errmsg ("interface name must be specified");
19818 if (vec_len (if_name) > 64)
19820 errmsg ("interface name too long");
19824 M (NETMAP_DELETE, mp);
19826 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
19827 vec_free (if_name);
19835 vl_api_mpls_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
19837 if (fp->afi == IP46_TYPE_IP6)
19839 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19840 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19841 fp->weight, ntohl (fp->sw_if_index), fp->is_local,
19842 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19843 format_ip6_address, fp->next_hop);
19844 else if (fp->afi == IP46_TYPE_IP4)
19846 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19847 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19848 fp->weight, ntohl (fp->sw_if_index), fp->is_local,
19849 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19850 format_ip4_address, fp->next_hop);
19854 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
19855 vl_api_fib_path_t * fp)
19857 struct in_addr ip4;
19858 struct in6_addr ip6;
19860 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19861 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19862 vat_json_object_add_uint (node, "is_local", fp->is_local);
19863 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19864 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19865 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19866 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19867 if (fp->afi == IP46_TYPE_IP4)
19869 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19870 vat_json_object_add_ip4 (node, "next_hop", ip4);
19872 else if (fp->afi == IP46_TYPE_IP6)
19874 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19875 vat_json_object_add_ip6 (node, "next_hop", ip6);
19880 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
19882 vat_main_t *vam = &vat_main;
19883 int count = ntohl (mp->mt_count);
19884 vl_api_fib_path_t *fp;
19887 print (vam->ofp, "[%d]: sw_if_index %d via:",
19888 ntohl (mp->mt_tunnel_index), ntohl (mp->mt_sw_if_index));
19890 for (i = 0; i < count; i++)
19892 vl_api_mpls_fib_path_print (vam, fp);
19896 print (vam->ofp, "");
19899 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
19900 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
19903 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
19905 vat_main_t *vam = &vat_main;
19906 vat_json_node_t *node = NULL;
19907 int count = ntohl (mp->mt_count);
19908 vl_api_fib_path_t *fp;
19911 if (VAT_JSON_ARRAY != vam->json_tree.type)
19913 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19914 vat_json_init_array (&vam->json_tree);
19916 node = vat_json_array_add (&vam->json_tree);
19918 vat_json_init_object (node);
19919 vat_json_object_add_uint (node, "tunnel_index",
19920 ntohl (mp->mt_tunnel_index));
19921 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->mt_sw_if_index));
19923 vat_json_object_add_uint (node, "l2_only", mp->mt_l2_only);
19926 for (i = 0; i < count; i++)
19928 vl_api_mpls_fib_path_json_print (node, fp);
19934 api_mpls_tunnel_dump (vat_main_t * vam)
19936 vl_api_mpls_tunnel_dump_t *mp;
19937 vl_api_control_ping_t *mp_ping;
19938 u32 sw_if_index = ~0;
19941 /* Parse args required to build the message */
19942 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
19944 if (unformat (vam->input, "sw_if_index %d", &sw_if_index))
19948 print (vam->ofp, " sw_if_index %d", sw_if_index);
19950 M (MPLS_TUNNEL_DUMP, mp);
19951 mp->sw_if_index = htonl (sw_if_index);
19954 /* Use a control ping for synchronization */
19955 MPING (CONTROL_PING, mp_ping);
19962 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
19963 #define vl_api_mpls_fib_details_t_print vl_noop_handler
19967 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
19969 vat_main_t *vam = &vat_main;
19970 int count = ntohl (mp->count);
19971 vl_api_fib_path_t *fp;
19975 "table-id %d, label %u, ess_bit %u",
19976 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
19978 for (i = 0; i < count; i++)
19980 vl_api_mpls_fib_path_print (vam, fp);
19985 static void vl_api_mpls_fib_details_t_handler_json
19986 (vl_api_mpls_fib_details_t * mp)
19988 vat_main_t *vam = &vat_main;
19989 int count = ntohl (mp->count);
19990 vat_json_node_t *node = NULL;
19991 vl_api_fib_path_t *fp;
19994 if (VAT_JSON_ARRAY != vam->json_tree.type)
19996 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19997 vat_json_init_array (&vam->json_tree);
19999 node = vat_json_array_add (&vam->json_tree);
20001 vat_json_init_object (node);
20002 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
20003 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
20004 vat_json_object_add_uint (node, "label", ntohl (mp->label));
20005 vat_json_object_add_uint (node, "path_count", count);
20007 for (i = 0; i < count; i++)
20009 vl_api_mpls_fib_path_json_print (node, fp);
20015 api_mpls_fib_dump (vat_main_t * vam)
20017 vl_api_mpls_fib_dump_t *mp;
20018 vl_api_control_ping_t *mp_ping;
20021 M (MPLS_FIB_DUMP, mp);
20024 /* Use a control ping for synchronization */
20025 MPING (CONTROL_PING, mp_ping);
20032 #define vl_api_ip_fib_details_t_endian vl_noop_handler
20033 #define vl_api_ip_fib_details_t_print vl_noop_handler
20036 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
20038 vat_main_t *vam = &vat_main;
20039 int count = ntohl (mp->count);
20040 vl_api_fib_path_t *fp;
20044 "table-id %d, prefix %U/%d stats-index %d",
20045 ntohl (mp->table_id), format_ip4_address, mp->address,
20046 mp->address_length, ntohl (mp->stats_index));
20048 for (i = 0; i < count; i++)
20050 if (fp->afi == IP46_TYPE_IP6)
20052 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
20053 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U, "
20054 "next_hop_table %d",
20055 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
20056 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
20057 format_ip6_address, fp->next_hop, ntohl (fp->table_id));
20058 else if (fp->afi == IP46_TYPE_IP4)
20060 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
20061 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U, "
20062 "next_hop_table %d",
20063 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
20064 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
20065 format_ip4_address, fp->next_hop, ntohl (fp->table_id));
20070 static void vl_api_ip_fib_details_t_handler_json
20071 (vl_api_ip_fib_details_t * mp)
20073 vat_main_t *vam = &vat_main;
20074 int count = ntohl (mp->count);
20075 vat_json_node_t *node = NULL;
20076 struct in_addr ip4;
20077 struct in6_addr ip6;
20078 vl_api_fib_path_t *fp;
20081 if (VAT_JSON_ARRAY != vam->json_tree.type)
20083 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20084 vat_json_init_array (&vam->json_tree);
20086 node = vat_json_array_add (&vam->json_tree);
20088 vat_json_init_object (node);
20089 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
20090 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
20091 vat_json_object_add_ip4 (node, "prefix", ip4);
20092 vat_json_object_add_uint (node, "mask_length", mp->address_length);
20093 vat_json_object_add_uint (node, "path_count", count);
20095 for (i = 0; i < count; i++)
20097 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
20098 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
20099 vat_json_object_add_uint (node, "is_local", fp->is_local);
20100 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
20101 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
20102 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
20103 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
20104 if (fp->afi == IP46_TYPE_IP4)
20106 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
20107 vat_json_object_add_ip4 (node, "next_hop", ip4);
20109 else if (fp->afi == IP46_TYPE_IP6)
20111 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
20112 vat_json_object_add_ip6 (node, "next_hop", ip6);
20118 api_ip_fib_dump (vat_main_t * vam)
20120 vl_api_ip_fib_dump_t *mp;
20121 vl_api_control_ping_t *mp_ping;
20124 M (IP_FIB_DUMP, mp);
20127 /* Use a control ping for synchronization */
20128 MPING (CONTROL_PING, mp_ping);
20136 api_ip_mfib_dump (vat_main_t * vam)
20138 vl_api_ip_mfib_dump_t *mp;
20139 vl_api_control_ping_t *mp_ping;
20142 M (IP_MFIB_DUMP, mp);
20145 /* Use a control ping for synchronization */
20146 MPING (CONTROL_PING, mp_ping);
20153 static void vl_api_ip_neighbor_details_t_handler
20154 (vl_api_ip_neighbor_details_t * mp)
20156 vat_main_t *vam = &vat_main;
20158 print (vam->ofp, "%c %U %U",
20159 (ntohl (mp->neighbor.flags) & IP_NEIGHBOR_FLAG_STATIC) ? 'S' : 'D',
20160 format_vl_api_mac_address, &mp->neighbor.mac_address,
20161 format_vl_api_address, &mp->neighbor.ip_address);
20164 static void vl_api_ip_neighbor_details_t_handler_json
20165 (vl_api_ip_neighbor_details_t * mp)
20168 vat_main_t *vam = &vat_main;
20169 vat_json_node_t *node;
20170 struct in_addr ip4;
20171 struct in6_addr ip6;
20173 if (VAT_JSON_ARRAY != vam->json_tree.type)
20175 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20176 vat_json_init_array (&vam->json_tree);
20178 node = vat_json_array_add (&vam->json_tree);
20180 vat_json_init_object (node);
20181 vat_json_object_add_string_copy
20183 ((ntohl (mp->neighbor.flags) & IP_NEIGHBOR_FLAG_STATIC) ?
20184 (u8 *) "static" : (u8 *) "dynamic"));
20186 vat_json_object_add_string_copy (node, "link_layer",
20187 format (0, "%U", format_vl_api_mac_address,
20188 &mp->neighbor.mac_address));
20190 if (ADDRESS_IP6 == mp->neighbor.ip_address.af)
20192 clib_memcpy (&ip6, &mp->neighbor.ip_address.un.ip6, sizeof (ip6));
20193 vat_json_object_add_ip6 (node, "ip_address", ip6);
20197 clib_memcpy (&ip4, &mp->neighbor.ip_address.un.ip4, sizeof (ip4));
20198 vat_json_object_add_ip4 (node, "ip_address", ip4);
20203 api_ip_neighbor_dump (vat_main_t * vam)
20205 unformat_input_t *i = vam->input;
20206 vl_api_ip_neighbor_dump_t *mp;
20207 vl_api_control_ping_t *mp_ping;
20209 u32 sw_if_index = ~0;
20212 /* Parse args required to build the message */
20213 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20215 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20217 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20219 else if (unformat (i, "ip6"))
20225 if (sw_if_index == ~0)
20227 errmsg ("missing interface name or sw_if_index");
20231 M (IP_NEIGHBOR_DUMP, mp);
20232 mp->is_ipv6 = (u8) is_ipv6;
20233 mp->sw_if_index = ntohl (sw_if_index);
20236 /* Use a control ping for synchronization */
20237 MPING (CONTROL_PING, mp_ping);
20244 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
20245 #define vl_api_ip6_fib_details_t_print vl_noop_handler
20248 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
20250 vat_main_t *vam = &vat_main;
20251 int count = ntohl (mp->count);
20252 vl_api_fib_path_t *fp;
20256 "table-id %d, prefix %U/%d stats-index %d",
20257 ntohl (mp->table_id), format_ip6_address, mp->address,
20258 mp->address_length, ntohl (mp->stats_index));
20260 for (i = 0; i < count; i++)
20262 if (fp->afi == IP46_TYPE_IP6)
20264 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
20265 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
20266 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
20267 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
20268 format_ip6_address, fp->next_hop);
20269 else if (fp->afi == IP46_TYPE_IP4)
20271 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
20272 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
20273 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
20274 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
20275 format_ip4_address, fp->next_hop);
20280 static void vl_api_ip6_fib_details_t_handler_json
20281 (vl_api_ip6_fib_details_t * mp)
20283 vat_main_t *vam = &vat_main;
20284 int count = ntohl (mp->count);
20285 vat_json_node_t *node = NULL;
20286 struct in_addr ip4;
20287 struct in6_addr ip6;
20288 vl_api_fib_path_t *fp;
20291 if (VAT_JSON_ARRAY != vam->json_tree.type)
20293 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20294 vat_json_init_array (&vam->json_tree);
20296 node = vat_json_array_add (&vam->json_tree);
20298 vat_json_init_object (node);
20299 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
20300 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
20301 vat_json_object_add_ip6 (node, "prefix", ip6);
20302 vat_json_object_add_uint (node, "mask_length", mp->address_length);
20303 vat_json_object_add_uint (node, "path_count", count);
20305 for (i = 0; i < count; i++)
20307 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
20308 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
20309 vat_json_object_add_uint (node, "is_local", fp->is_local);
20310 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
20311 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
20312 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
20313 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
20314 if (fp->afi == IP46_TYPE_IP4)
20316 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
20317 vat_json_object_add_ip4 (node, "next_hop", ip4);
20319 else if (fp->afi == IP46_TYPE_IP6)
20321 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
20322 vat_json_object_add_ip6 (node, "next_hop", ip6);
20328 api_ip6_fib_dump (vat_main_t * vam)
20330 vl_api_ip6_fib_dump_t *mp;
20331 vl_api_control_ping_t *mp_ping;
20334 M (IP6_FIB_DUMP, mp);
20337 /* Use a control ping for synchronization */
20338 MPING (CONTROL_PING, mp_ping);
20346 api_ip6_mfib_dump (vat_main_t * vam)
20348 vl_api_ip6_mfib_dump_t *mp;
20349 vl_api_control_ping_t *mp_ping;
20352 M (IP6_MFIB_DUMP, mp);
20355 /* Use a control ping for synchronization */
20356 MPING (CONTROL_PING, mp_ping);
20364 api_classify_table_ids (vat_main_t * vam)
20366 vl_api_classify_table_ids_t *mp;
20369 /* Construct the API message */
20370 M (CLASSIFY_TABLE_IDS, mp);
20379 api_classify_table_by_interface (vat_main_t * vam)
20381 unformat_input_t *input = vam->input;
20382 vl_api_classify_table_by_interface_t *mp;
20384 u32 sw_if_index = ~0;
20386 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20388 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20390 else if (unformat (input, "sw_if_index %d", &sw_if_index))
20395 if (sw_if_index == ~0)
20397 errmsg ("missing interface name or sw_if_index");
20401 /* Construct the API message */
20402 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
20404 mp->sw_if_index = ntohl (sw_if_index);
20412 api_classify_table_info (vat_main_t * vam)
20414 unformat_input_t *input = vam->input;
20415 vl_api_classify_table_info_t *mp;
20419 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20421 if (unformat (input, "table_id %d", &table_id))
20426 if (table_id == ~0)
20428 errmsg ("missing table id");
20432 /* Construct the API message */
20433 M (CLASSIFY_TABLE_INFO, mp);
20435 mp->table_id = ntohl (table_id);
20443 api_classify_session_dump (vat_main_t * vam)
20445 unformat_input_t *input = vam->input;
20446 vl_api_classify_session_dump_t *mp;
20447 vl_api_control_ping_t *mp_ping;
20451 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20453 if (unformat (input, "table_id %d", &table_id))
20458 if (table_id == ~0)
20460 errmsg ("missing table id");
20464 /* Construct the API message */
20465 M (CLASSIFY_SESSION_DUMP, mp);
20467 mp->table_id = ntohl (table_id);
20470 /* Use a control ping for synchronization */
20471 MPING (CONTROL_PING, mp_ping);
20479 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
20481 vat_main_t *vam = &vat_main;
20483 print (vam->ofp, "collector_address %U, collector_port %d, "
20484 "src_address %U, vrf_id %d, path_mtu %u, "
20485 "template_interval %u, udp_checksum %d",
20486 format_ip4_address, mp->collector_address,
20487 ntohs (mp->collector_port),
20488 format_ip4_address, mp->src_address,
20489 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
20490 ntohl (mp->template_interval), mp->udp_checksum);
20493 vam->result_ready = 1;
20497 vl_api_ipfix_exporter_details_t_handler_json
20498 (vl_api_ipfix_exporter_details_t * mp)
20500 vat_main_t *vam = &vat_main;
20501 vat_json_node_t node;
20502 struct in_addr collector_address;
20503 struct in_addr src_address;
20505 vat_json_init_object (&node);
20506 clib_memcpy (&collector_address, &mp->collector_address,
20507 sizeof (collector_address));
20508 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
20509 vat_json_object_add_uint (&node, "collector_port",
20510 ntohs (mp->collector_port));
20511 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
20512 vat_json_object_add_ip4 (&node, "src_address", src_address);
20513 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
20514 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
20515 vat_json_object_add_uint (&node, "template_interval",
20516 ntohl (mp->template_interval));
20517 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
20519 vat_json_print (vam->ofp, &node);
20520 vat_json_free (&node);
20522 vam->result_ready = 1;
20526 api_ipfix_exporter_dump (vat_main_t * vam)
20528 vl_api_ipfix_exporter_dump_t *mp;
20531 /* Construct the API message */
20532 M (IPFIX_EXPORTER_DUMP, mp);
20541 api_ipfix_classify_stream_dump (vat_main_t * vam)
20543 vl_api_ipfix_classify_stream_dump_t *mp;
20546 /* Construct the API message */
20547 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
20558 vl_api_ipfix_classify_stream_details_t_handler
20559 (vl_api_ipfix_classify_stream_details_t * mp)
20561 vat_main_t *vam = &vat_main;
20562 print (vam->ofp, "domain_id %d, src_port %d",
20563 ntohl (mp->domain_id), ntohs (mp->src_port));
20565 vam->result_ready = 1;
20569 vl_api_ipfix_classify_stream_details_t_handler_json
20570 (vl_api_ipfix_classify_stream_details_t * mp)
20572 vat_main_t *vam = &vat_main;
20573 vat_json_node_t node;
20575 vat_json_init_object (&node);
20576 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
20577 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
20579 vat_json_print (vam->ofp, &node);
20580 vat_json_free (&node);
20582 vam->result_ready = 1;
20586 api_ipfix_classify_table_dump (vat_main_t * vam)
20588 vl_api_ipfix_classify_table_dump_t *mp;
20589 vl_api_control_ping_t *mp_ping;
20592 if (!vam->json_output)
20594 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
20595 "transport_protocol");
20598 /* Construct the API message */
20599 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
20604 /* Use a control ping for synchronization */
20605 MPING (CONTROL_PING, mp_ping);
20613 vl_api_ipfix_classify_table_details_t_handler
20614 (vl_api_ipfix_classify_table_details_t * mp)
20616 vat_main_t *vam = &vat_main;
20617 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
20618 mp->transport_protocol);
20622 vl_api_ipfix_classify_table_details_t_handler_json
20623 (vl_api_ipfix_classify_table_details_t * mp)
20625 vat_json_node_t *node = NULL;
20626 vat_main_t *vam = &vat_main;
20628 if (VAT_JSON_ARRAY != vam->json_tree.type)
20630 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20631 vat_json_init_array (&vam->json_tree);
20634 node = vat_json_array_add (&vam->json_tree);
20635 vat_json_init_object (node);
20637 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
20638 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
20639 vat_json_object_add_uint (node, "transport_protocol",
20640 mp->transport_protocol);
20644 api_sw_interface_span_enable_disable (vat_main_t * vam)
20646 unformat_input_t *i = vam->input;
20647 vl_api_sw_interface_span_enable_disable_t *mp;
20648 u32 src_sw_if_index = ~0;
20649 u32 dst_sw_if_index = ~0;
20654 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20657 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
20659 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
20663 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
20665 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
20667 else if (unformat (i, "disable"))
20669 else if (unformat (i, "rx"))
20671 else if (unformat (i, "tx"))
20673 else if (unformat (i, "both"))
20675 else if (unformat (i, "l2"))
20681 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
20683 mp->sw_if_index_from = htonl (src_sw_if_index);
20684 mp->sw_if_index_to = htonl (dst_sw_if_index);
20694 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
20697 vat_main_t *vam = &vat_main;
20698 u8 *sw_if_from_name = 0;
20699 u8 *sw_if_to_name = 0;
20700 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
20701 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
20702 char *states[] = { "none", "rx", "tx", "both" };
20706 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
20708 if ((u32) p->value[0] == sw_if_index_from)
20710 sw_if_from_name = (u8 *)(p->key);
20714 if ((u32) p->value[0] == sw_if_index_to)
20716 sw_if_to_name = (u8 *)(p->key);
20717 if (sw_if_from_name)
20722 print (vam->ofp, "%20s => %20s (%s) %s",
20723 sw_if_from_name, sw_if_to_name, states[mp->state],
20724 mp->is_l2 ? "l2" : "device");
20728 vl_api_sw_interface_span_details_t_handler_json
20729 (vl_api_sw_interface_span_details_t * mp)
20731 vat_main_t *vam = &vat_main;
20732 vat_json_node_t *node = NULL;
20733 u8 *sw_if_from_name = 0;
20734 u8 *sw_if_to_name = 0;
20735 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
20736 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
20740 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
20742 if ((u32) p->value[0] == sw_if_index_from)
20744 sw_if_from_name = (u8 *)(p->key);
20748 if ((u32) p->value[0] == sw_if_index_to)
20750 sw_if_to_name = (u8 *)(p->key);
20751 if (sw_if_from_name)
20757 if (VAT_JSON_ARRAY != vam->json_tree.type)
20759 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20760 vat_json_init_array (&vam->json_tree);
20762 node = vat_json_array_add (&vam->json_tree);
20764 vat_json_init_object (node);
20765 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
20766 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
20767 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
20768 if (0 != sw_if_to_name)
20770 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
20772 vat_json_object_add_uint (node, "state", mp->state);
20773 vat_json_object_add_uint (node, "is-l2", mp->is_l2);
20777 api_sw_interface_span_dump (vat_main_t * vam)
20779 unformat_input_t *input = vam->input;
20780 vl_api_sw_interface_span_dump_t *mp;
20781 vl_api_control_ping_t *mp_ping;
20785 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20787 if (unformat (input, "l2"))
20793 M (SW_INTERFACE_SPAN_DUMP, mp);
20797 /* Use a control ping for synchronization */
20798 MPING (CONTROL_PING, mp_ping);
20806 api_pg_create_interface (vat_main_t * vam)
20808 unformat_input_t *input = vam->input;
20809 vl_api_pg_create_interface_t *mp;
20813 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20815 if (unformat (input, "if_id %d", &if_id))
20822 errmsg ("missing pg interface index");
20826 /* Construct the API message */
20827 M (PG_CREATE_INTERFACE, mp);
20829 mp->interface_id = ntohl (if_id);
20837 api_pg_capture (vat_main_t * vam)
20839 unformat_input_t *input = vam->input;
20840 vl_api_pg_capture_t *mp;
20845 u8 pcap_file_set = 0;
20848 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20850 if (unformat (input, "if_id %d", &if_id))
20852 else if (unformat (input, "pcap %s", &pcap_file))
20854 else if (unformat (input, "count %d", &count))
20856 else if (unformat (input, "disable"))
20863 errmsg ("missing pg interface index");
20866 if (pcap_file_set > 0)
20868 if (vec_len (pcap_file) > 255)
20870 errmsg ("pcap file name is too long");
20875 u32 name_len = vec_len (pcap_file);
20876 /* Construct the API message */
20877 M (PG_CAPTURE, mp);
20879 mp->interface_id = ntohl (if_id);
20880 mp->is_enabled = enable;
20881 mp->count = ntohl (count);
20882 mp->pcap_name_length = ntohl (name_len);
20883 if (pcap_file_set != 0)
20885 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
20887 vec_free (pcap_file);
20895 api_pg_enable_disable (vat_main_t * vam)
20897 unformat_input_t *input = vam->input;
20898 vl_api_pg_enable_disable_t *mp;
20901 u8 stream_name_set = 0;
20902 u8 *stream_name = 0;
20904 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20906 if (unformat (input, "stream %s", &stream_name))
20907 stream_name_set = 1;
20908 else if (unformat (input, "disable"))
20914 if (stream_name_set > 0)
20916 if (vec_len (stream_name) > 255)
20918 errmsg ("stream name too long");
20923 u32 name_len = vec_len (stream_name);
20924 /* Construct the API message */
20925 M (PG_ENABLE_DISABLE, mp);
20927 mp->is_enabled = enable;
20928 if (stream_name_set != 0)
20930 mp->stream_name_length = ntohl (name_len);
20931 clib_memcpy (mp->stream_name, stream_name, name_len);
20933 vec_free (stream_name);
20941 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
20943 unformat_input_t *input = vam->input;
20944 vl_api_ip_source_and_port_range_check_add_del_t *mp;
20946 u16 *low_ports = 0;
20947 u16 *high_ports = 0;
20950 vl_api_prefix_t prefix;
20958 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20960 if (unformat (input, "%U", unformat_vl_api_prefix, &prefix))
20962 else if (unformat (input, "vrf %d", &vrf_id))
20964 else if (unformat (input, "del"))
20966 else if (unformat (input, "port %d", &tmp))
20968 if (tmp == 0 || tmp > 65535)
20970 errmsg ("port %d out of range", tmp);
20974 this_hi = this_low + 1;
20975 vec_add1 (low_ports, this_low);
20976 vec_add1 (high_ports, this_hi);
20978 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
20980 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
20982 errmsg ("incorrect range parameters");
20986 /* Note: in debug CLI +1 is added to high before
20987 passing to real fn that does "the work"
20988 (ip_source_and_port_range_check_add_del).
20989 This fn is a wrapper around the binary API fn a
20990 control plane will call, which expects this increment
20991 to have occurred. Hence letting the binary API control
20992 plane fn do the increment for consistency between VAT
20993 and other control planes.
20996 vec_add1 (low_ports, this_low);
20997 vec_add1 (high_ports, this_hi);
21003 if (prefix_set == 0)
21005 errmsg ("<address>/<mask> not specified");
21011 errmsg ("VRF ID required, not specified");
21018 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
21022 if (vec_len (low_ports) == 0)
21024 errmsg ("At least one port or port range required");
21028 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
21030 mp->is_add = is_add;
21032 clib_memcpy (&mp->prefix, &prefix, sizeof (prefix));
21034 mp->number_of_ranges = vec_len (low_ports);
21036 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
21037 vec_free (low_ports);
21039 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
21040 vec_free (high_ports);
21042 mp->vrf_id = ntohl (vrf_id);
21050 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
21052 unformat_input_t *input = vam->input;
21053 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
21054 u32 sw_if_index = ~0;
21056 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
21057 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
21061 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
21063 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21065 else if (unformat (input, "sw_if_index %d", &sw_if_index))
21067 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
21069 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
21071 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
21073 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
21075 else if (unformat (input, "del"))
21081 if (sw_if_index == ~0)
21083 errmsg ("Interface required but not specified");
21089 errmsg ("VRF ID required but not specified");
21093 if (tcp_out_vrf_id == 0
21094 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
21097 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
21101 /* Construct the API message */
21102 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
21104 mp->sw_if_index = ntohl (sw_if_index);
21105 mp->is_add = is_add;
21106 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
21107 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
21108 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
21109 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
21114 /* Wait for a reply... */
21120 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
21122 unformat_input_t *i = vam->input;
21123 vl_api_ipsec_gre_add_del_tunnel_t *mp;
21124 u32 local_sa_id = 0;
21125 u32 remote_sa_id = 0;
21126 ip4_address_t src_address;
21127 ip4_address_t dst_address;
21131 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21133 if (unformat (i, "local_sa %d", &local_sa_id))
21135 else if (unformat (i, "remote_sa %d", &remote_sa_id))
21137 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
21139 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
21141 else if (unformat (i, "del"))
21145 clib_warning ("parse error '%U'", format_unformat_error, i);
21150 M (IPSEC_GRE_ADD_DEL_TUNNEL, mp);
21152 mp->local_sa_id = ntohl (local_sa_id);
21153 mp->remote_sa_id = ntohl (remote_sa_id);
21154 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
21155 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
21156 mp->is_add = is_add;
21164 api_set_punt (vat_main_t * vam)
21166 unformat_input_t *i = vam->input;
21167 vl_api_set_punt_t *mp;
21174 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21176 if (unformat (i, "ip %d", &ipv))
21178 else if (unformat (i, "protocol %d", &protocol))
21180 else if (unformat (i, "port %d", &port))
21182 else if (unformat (i, "del"))
21186 clib_warning ("parse error '%U'", format_unformat_error, i);
21193 mp->is_add = (u8) is_add;
21194 mp->punt.ipv = (u8) ipv;
21195 mp->punt.l4_protocol = (u8) protocol;
21196 mp->punt.l4_port = htons ((u16) port);
21203 static void vl_api_ipsec_gre_tunnel_details_t_handler
21204 (vl_api_ipsec_gre_tunnel_details_t * mp)
21206 vat_main_t *vam = &vat_main;
21208 print (vam->ofp, "%11d%15U%15U%14d%14d",
21209 ntohl (mp->sw_if_index),
21210 format_ip4_address, &mp->src_address,
21211 format_ip4_address, &mp->dst_address,
21212 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
21215 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
21216 (vl_api_ipsec_gre_tunnel_details_t * mp)
21218 vat_main_t *vam = &vat_main;
21219 vat_json_node_t *node = NULL;
21220 struct in_addr ip4;
21222 if (VAT_JSON_ARRAY != vam->json_tree.type)
21224 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
21225 vat_json_init_array (&vam->json_tree);
21227 node = vat_json_array_add (&vam->json_tree);
21229 vat_json_init_object (node);
21230 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
21231 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
21232 vat_json_object_add_ip4 (node, "src_address", ip4);
21233 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
21234 vat_json_object_add_ip4 (node, "dst_address", ip4);
21235 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
21236 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
21240 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
21242 unformat_input_t *i = vam->input;
21243 vl_api_ipsec_gre_tunnel_dump_t *mp;
21244 vl_api_control_ping_t *mp_ping;
21246 u8 sw_if_index_set = 0;
21249 /* Parse args required to build the message */
21250 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21252 if (unformat (i, "sw_if_index %d", &sw_if_index))
21253 sw_if_index_set = 1;
21258 if (sw_if_index_set == 0)
21263 if (!vam->json_output)
21265 print (vam->ofp, "%11s%15s%15s%14s%14s",
21266 "sw_if_index", "src_address", "dst_address",
21267 "local_sa_id", "remote_sa_id");
21270 /* Get list of gre-tunnel interfaces */
21271 M (IPSEC_GRE_TUNNEL_DUMP, mp);
21273 mp->sw_if_index = htonl (sw_if_index);
21277 /* Use a control ping for synchronization */
21278 MPING (CONTROL_PING, mp_ping);
21286 api_delete_subif (vat_main_t * vam)
21288 unformat_input_t *i = vam->input;
21289 vl_api_delete_subif_t *mp;
21290 u32 sw_if_index = ~0;
21293 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21295 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21297 if (unformat (i, "sw_if_index %d", &sw_if_index))
21303 if (sw_if_index == ~0)
21305 errmsg ("missing sw_if_index");
21309 /* Construct the API message */
21310 M (DELETE_SUBIF, mp);
21311 mp->sw_if_index = ntohl (sw_if_index);
21318 #define foreach_pbb_vtr_op \
21319 _("disable", L2_VTR_DISABLED) \
21320 _("pop", L2_VTR_POP_2) \
21321 _("push", L2_VTR_PUSH_2)
21324 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
21326 unformat_input_t *i = vam->input;
21327 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
21328 u32 sw_if_index = ~0, vtr_op = ~0;
21329 u16 outer_tag = ~0;
21330 u8 dmac[6], smac[6];
21331 u8 dmac_set = 0, smac_set = 0;
21337 /* Shut up coverity */
21338 clib_memset (dmac, 0, sizeof (dmac));
21339 clib_memset (smac, 0, sizeof (smac));
21341 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21343 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21345 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21347 else if (unformat (i, "vtr_op %d", &vtr_op))
21349 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
21352 else if (unformat (i, "translate_pbb_stag"))
21354 if (unformat (i, "%d", &tmp))
21356 vtr_op = L2_VTR_TRANSLATE_2_1;
21362 ("translate_pbb_stag operation requires outer tag definition");
21366 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
21368 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
21370 else if (unformat (i, "sid %d", &sid))
21372 else if (unformat (i, "vlanid %d", &tmp))
21376 clib_warning ("parse error '%U'", format_unformat_error, i);
21381 if ((sw_if_index == ~0) || (vtr_op == ~0))
21383 errmsg ("missing sw_if_index or vtr operation");
21386 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
21387 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
21390 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
21394 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
21395 mp->sw_if_index = ntohl (sw_if_index);
21396 mp->vtr_op = ntohl (vtr_op);
21397 mp->outer_tag = ntohs (outer_tag);
21398 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
21399 clib_memcpy (mp->b_smac, smac, sizeof (smac));
21400 mp->b_vlanid = ntohs (vlanid);
21401 mp->i_sid = ntohl (sid);
21409 api_flow_classify_set_interface (vat_main_t * vam)
21411 unformat_input_t *i = vam->input;
21412 vl_api_flow_classify_set_interface_t *mp;
21414 int sw_if_index_set;
21415 u32 ip4_table_index = ~0;
21416 u32 ip6_table_index = ~0;
21420 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21422 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21423 sw_if_index_set = 1;
21424 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21425 sw_if_index_set = 1;
21426 else if (unformat (i, "del"))
21428 else if (unformat (i, "ip4-table %d", &ip4_table_index))
21430 else if (unformat (i, "ip6-table %d", &ip6_table_index))
21434 clib_warning ("parse error '%U'", format_unformat_error, i);
21439 if (sw_if_index_set == 0)
21441 errmsg ("missing interface name or sw_if_index");
21445 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
21447 mp->sw_if_index = ntohl (sw_if_index);
21448 mp->ip4_table_index = ntohl (ip4_table_index);
21449 mp->ip6_table_index = ntohl (ip6_table_index);
21450 mp->is_add = is_add;
21458 api_flow_classify_dump (vat_main_t * vam)
21460 unformat_input_t *i = vam->input;
21461 vl_api_flow_classify_dump_t *mp;
21462 vl_api_control_ping_t *mp_ping;
21463 u8 type = FLOW_CLASSIFY_N_TABLES;
21466 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
21470 errmsg ("classify table type must be specified");
21474 if (!vam->json_output)
21476 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
21479 M (FLOW_CLASSIFY_DUMP, mp);
21484 /* Use a control ping for synchronization */
21485 MPING (CONTROL_PING, mp_ping);
21488 /* Wait for a reply... */
21494 api_feature_enable_disable (vat_main_t * vam)
21496 unformat_input_t *i = vam->input;
21497 vl_api_feature_enable_disable_t *mp;
21499 u8 *feature_name = 0;
21500 u32 sw_if_index = ~0;
21504 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21506 if (unformat (i, "arc_name %s", &arc_name))
21508 else if (unformat (i, "feature_name %s", &feature_name))
21511 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21513 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21515 else if (unformat (i, "disable"))
21523 errmsg ("missing arc name");
21526 if (vec_len (arc_name) > 63)
21528 errmsg ("arc name too long");
21531 if (feature_name == 0)
21533 errmsg ("missing feature name");
21536 if (vec_len (feature_name) > 63)
21538 errmsg ("feature name too long");
21541 if (sw_if_index == ~0)
21543 errmsg ("missing interface name or sw_if_index");
21547 /* Construct the API message */
21548 M (FEATURE_ENABLE_DISABLE, mp);
21549 mp->sw_if_index = ntohl (sw_if_index);
21550 mp->enable = enable;
21551 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
21552 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
21553 vec_free (arc_name);
21554 vec_free (feature_name);
21562 api_sw_interface_tag_add_del (vat_main_t * vam)
21564 unformat_input_t *i = vam->input;
21565 vl_api_sw_interface_tag_add_del_t *mp;
21566 u32 sw_if_index = ~0;
21571 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21573 if (unformat (i, "tag %s", &tag))
21575 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21577 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21579 else if (unformat (i, "del"))
21585 if (sw_if_index == ~0)
21587 errmsg ("missing interface name or sw_if_index");
21591 if (enable && (tag == 0))
21593 errmsg ("no tag specified");
21597 /* Construct the API message */
21598 M (SW_INTERFACE_TAG_ADD_DEL, mp);
21599 mp->sw_if_index = ntohl (sw_if_index);
21600 mp->is_add = enable;
21602 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
21610 static void vl_api_l2_xconnect_details_t_handler
21611 (vl_api_l2_xconnect_details_t * mp)
21613 vat_main_t *vam = &vat_main;
21615 print (vam->ofp, "%15d%15d",
21616 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
21619 static void vl_api_l2_xconnect_details_t_handler_json
21620 (vl_api_l2_xconnect_details_t * mp)
21622 vat_main_t *vam = &vat_main;
21623 vat_json_node_t *node = NULL;
21625 if (VAT_JSON_ARRAY != vam->json_tree.type)
21627 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
21628 vat_json_init_array (&vam->json_tree);
21630 node = vat_json_array_add (&vam->json_tree);
21632 vat_json_init_object (node);
21633 vat_json_object_add_uint (node, "rx_sw_if_index",
21634 ntohl (mp->rx_sw_if_index));
21635 vat_json_object_add_uint (node, "tx_sw_if_index",
21636 ntohl (mp->tx_sw_if_index));
21640 api_l2_xconnect_dump (vat_main_t * vam)
21642 vl_api_l2_xconnect_dump_t *mp;
21643 vl_api_control_ping_t *mp_ping;
21646 if (!vam->json_output)
21648 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
21651 M (L2_XCONNECT_DUMP, mp);
21655 /* Use a control ping for synchronization */
21656 MPING (CONTROL_PING, mp_ping);
21664 api_hw_interface_set_mtu (vat_main_t * vam)
21666 unformat_input_t *i = vam->input;
21667 vl_api_hw_interface_set_mtu_t *mp;
21668 u32 sw_if_index = ~0;
21672 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21674 if (unformat (i, "mtu %d", &mtu))
21676 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21678 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21684 if (sw_if_index == ~0)
21686 errmsg ("missing interface name or sw_if_index");
21692 errmsg ("no mtu specified");
21696 /* Construct the API message */
21697 M (HW_INTERFACE_SET_MTU, mp);
21698 mp->sw_if_index = ntohl (sw_if_index);
21699 mp->mtu = ntohs ((u16) mtu);
21707 api_p2p_ethernet_add (vat_main_t * vam)
21709 unformat_input_t *i = vam->input;
21710 vl_api_p2p_ethernet_add_t *mp;
21711 u32 parent_if_index = ~0;
21717 clib_memset (remote_mac, 0, sizeof (remote_mac));
21718 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21720 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
21722 else if (unformat (i, "sw_if_index %d", &parent_if_index))
21726 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
21728 else if (unformat (i, "sub_id %d", &sub_id))
21732 clib_warning ("parse error '%U'", format_unformat_error, i);
21737 if (parent_if_index == ~0)
21739 errmsg ("missing interface name or sw_if_index");
21744 errmsg ("missing remote mac address");
21749 errmsg ("missing sub-interface id");
21753 M (P2P_ETHERNET_ADD, mp);
21754 mp->parent_if_index = ntohl (parent_if_index);
21755 mp->subif_id = ntohl (sub_id);
21756 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
21764 api_p2p_ethernet_del (vat_main_t * vam)
21766 unformat_input_t *i = vam->input;
21767 vl_api_p2p_ethernet_del_t *mp;
21768 u32 parent_if_index = ~0;
21773 clib_memset (remote_mac, 0, sizeof (remote_mac));
21774 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21776 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
21778 else if (unformat (i, "sw_if_index %d", &parent_if_index))
21782 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
21786 clib_warning ("parse error '%U'", format_unformat_error, i);
21791 if (parent_if_index == ~0)
21793 errmsg ("missing interface name or sw_if_index");
21798 errmsg ("missing remote mac address");
21802 M (P2P_ETHERNET_DEL, mp);
21803 mp->parent_if_index = ntohl (parent_if_index);
21804 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
21812 api_lldp_config (vat_main_t * vam)
21814 unformat_input_t *i = vam->input;
21815 vl_api_lldp_config_t *mp;
21817 int tx_interval = 0;
21818 u8 *sys_name = NULL;
21821 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21823 if (unformat (i, "system-name %s", &sys_name))
21825 else if (unformat (i, "tx-hold %d", &tx_hold))
21827 else if (unformat (i, "tx-interval %d", &tx_interval))
21831 clib_warning ("parse error '%U'", format_unformat_error, i);
21836 vec_add1 (sys_name, 0);
21838 M (LLDP_CONFIG, mp);
21839 mp->tx_hold = htonl (tx_hold);
21840 mp->tx_interval = htonl (tx_interval);
21841 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
21842 vec_free (sys_name);
21850 api_sw_interface_set_lldp (vat_main_t * vam)
21852 unformat_input_t *i = vam->input;
21853 vl_api_sw_interface_set_lldp_t *mp;
21854 u32 sw_if_index = ~0;
21856 u8 *port_desc = NULL, *mgmt_oid = NULL;
21857 ip4_address_t ip4_addr;
21858 ip6_address_t ip6_addr;
21861 clib_memset (&ip4_addr, 0, sizeof (ip4_addr));
21862 clib_memset (&ip6_addr, 0, sizeof (ip6_addr));
21864 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21866 if (unformat (i, "disable"))
21869 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21871 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21873 else if (unformat (i, "port-desc %s", &port_desc))
21875 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
21877 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
21879 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
21885 if (sw_if_index == ~0)
21887 errmsg ("missing interface name or sw_if_index");
21891 /* Construct the API message */
21892 vec_add1 (port_desc, 0);
21893 vec_add1 (mgmt_oid, 0);
21894 M (SW_INTERFACE_SET_LLDP, mp);
21895 mp->sw_if_index = ntohl (sw_if_index);
21896 mp->enable = enable;
21897 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
21898 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
21899 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
21900 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
21901 vec_free (port_desc);
21902 vec_free (mgmt_oid);
21910 api_tcp_configure_src_addresses (vat_main_t * vam)
21912 vl_api_tcp_configure_src_addresses_t *mp;
21913 unformat_input_t *i = vam->input;
21914 ip4_address_t v4first, v4last;
21915 ip6_address_t v6first, v6last;
21920 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21922 if (unformat (i, "%U - %U",
21923 unformat_ip4_address, &v4first,
21924 unformat_ip4_address, &v4last))
21928 errmsg ("one range per message (range already set)");
21933 else if (unformat (i, "%U - %U",
21934 unformat_ip6_address, &v6first,
21935 unformat_ip6_address, &v6last))
21939 errmsg ("one range per message (range already set)");
21944 else if (unformat (i, "vrf %d", &vrf_id))
21950 if (range_set == 0)
21952 errmsg ("address range not set");
21956 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
21957 mp->vrf_id = ntohl (vrf_id);
21959 if (range_set == 2)
21962 clib_memcpy (mp->first_address, &v6first, sizeof (v6first));
21963 clib_memcpy (mp->last_address, &v6last, sizeof (v6last));
21968 clib_memcpy (mp->first_address, &v4first, sizeof (v4first));
21969 clib_memcpy (mp->last_address, &v4last, sizeof (v4last));
21976 static void vl_api_app_namespace_add_del_reply_t_handler
21977 (vl_api_app_namespace_add_del_reply_t * mp)
21979 vat_main_t *vam = &vat_main;
21980 i32 retval = ntohl (mp->retval);
21981 if (vam->async_mode)
21983 vam->async_errors += (retval < 0);
21987 vam->retval = retval;
21989 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
21990 vam->result_ready = 1;
21994 static void vl_api_app_namespace_add_del_reply_t_handler_json
21995 (vl_api_app_namespace_add_del_reply_t * mp)
21997 vat_main_t *vam = &vat_main;
21998 vat_json_node_t node;
22000 vat_json_init_object (&node);
22001 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
22002 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
22004 vat_json_print (vam->ofp, &node);
22005 vat_json_free (&node);
22007 vam->retval = ntohl (mp->retval);
22008 vam->result_ready = 1;
22012 api_app_namespace_add_del (vat_main_t * vam)
22014 vl_api_app_namespace_add_del_t *mp;
22015 unformat_input_t *i = vam->input;
22016 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
22017 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
22021 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22023 if (unformat (i, "id %_%v%_", &ns_id))
22025 else if (unformat (i, "secret %lu", &secret))
22027 else if (unformat (i, "sw_if_index %d", &sw_if_index))
22028 sw_if_index_set = 1;
22029 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
22031 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
22036 if (!ns_id || !secret_set || !sw_if_index_set)
22038 errmsg ("namespace id, secret and sw_if_index must be set");
22041 if (vec_len (ns_id) > 64)
22043 errmsg ("namespace id too long");
22046 M (APP_NAMESPACE_ADD_DEL, mp);
22048 clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
22049 mp->namespace_id_len = vec_len (ns_id);
22050 mp->secret = clib_host_to_net_u64 (secret);
22051 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
22052 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
22053 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
22061 api_sock_init_shm (vat_main_t * vam)
22063 #if VPP_API_TEST_BUILTIN == 0
22064 unformat_input_t *i = vam->input;
22065 vl_api_shm_elem_config_t *config = 0;
22066 u64 size = 64 << 20;
22069 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22071 if (unformat (i, "size %U", unformat_memory_size, &size))
22078 * Canned custom ring allocator config.
22079 * Should probably parse all of this
22081 vec_validate (config, 6);
22082 config[0].type = VL_API_VLIB_RING;
22083 config[0].size = 256;
22084 config[0].count = 32;
22086 config[1].type = VL_API_VLIB_RING;
22087 config[1].size = 1024;
22088 config[1].count = 16;
22090 config[2].type = VL_API_VLIB_RING;
22091 config[2].size = 4096;
22092 config[2].count = 2;
22094 config[3].type = VL_API_CLIENT_RING;
22095 config[3].size = 256;
22096 config[3].count = 32;
22098 config[4].type = VL_API_CLIENT_RING;
22099 config[4].size = 1024;
22100 config[4].count = 16;
22102 config[5].type = VL_API_CLIENT_RING;
22103 config[5].size = 4096;
22104 config[5].count = 2;
22106 config[6].type = VL_API_QUEUE;
22107 config[6].count = 128;
22108 config[6].size = sizeof (uword);
22110 rv = vl_socket_client_init_shm (config);
22112 vam->client_index_invalid = 1;
22120 api_dns_enable_disable (vat_main_t * vam)
22122 unformat_input_t *line_input = vam->input;
22123 vl_api_dns_enable_disable_t *mp;
22124 u8 enable_disable = 1;
22127 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
22129 if (unformat (line_input, "disable"))
22130 enable_disable = 0;
22131 if (unformat (line_input, "enable"))
22132 enable_disable = 1;
22137 /* Construct the API message */
22138 M (DNS_ENABLE_DISABLE, mp);
22139 mp->enable = enable_disable;
22143 /* Wait for the reply */
22149 api_dns_resolve_name (vat_main_t * vam)
22151 unformat_input_t *line_input = vam->input;
22152 vl_api_dns_resolve_name_t *mp;
22156 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
22158 if (unformat (line_input, "%s", &name))
22164 if (vec_len (name) > 127)
22166 errmsg ("name too long");
22170 /* Construct the API message */
22171 M (DNS_RESOLVE_NAME, mp);
22172 memcpy (mp->name, name, vec_len (name));
22177 /* Wait for the reply */
22183 api_dns_resolve_ip (vat_main_t * vam)
22185 unformat_input_t *line_input = vam->input;
22186 vl_api_dns_resolve_ip_t *mp;
22188 ip4_address_t addr4;
22189 ip6_address_t addr6;
22192 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
22194 if (unformat (line_input, "%U", unformat_ip6_address, &addr6))
22196 else if (unformat (line_input, "%U", unformat_ip4_address, &addr4))
22204 errmsg ("missing address");
22208 /* Construct the API message */
22209 M (DNS_RESOLVE_IP, mp);
22210 mp->is_ip6 = is_ip6;
22212 memcpy (mp->address, &addr6, sizeof (addr6));
22214 memcpy (mp->address, &addr4, sizeof (addr4));
22218 /* Wait for the reply */
22224 api_dns_name_server_add_del (vat_main_t * vam)
22226 unformat_input_t *i = vam->input;
22227 vl_api_dns_name_server_add_del_t *mp;
22229 ip6_address_t ip6_server;
22230 ip4_address_t ip4_server;
22235 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22237 if (unformat (i, "%U", unformat_ip6_address, &ip6_server))
22239 else if (unformat (i, "%U", unformat_ip4_address, &ip4_server))
22241 else if (unformat (i, "del"))
22245 clib_warning ("parse error '%U'", format_unformat_error, i);
22250 if (ip4_set && ip6_set)
22252 errmsg ("Only one server address allowed per message");
22255 if ((ip4_set + ip6_set) == 0)
22257 errmsg ("Server address required");
22261 /* Construct the API message */
22262 M (DNS_NAME_SERVER_ADD_DEL, mp);
22266 memcpy (mp->server_address, &ip6_server, sizeof (ip6_address_t));
22271 memcpy (mp->server_address, &ip4_server, sizeof (ip4_address_t));
22275 mp->is_add = is_add;
22280 /* Wait for a reply, return good/bad news */
22286 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
22288 vat_main_t *vam = &vat_main;
22293 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
22294 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
22295 mp->scope, format_ip4_address, &mp->lcl_ip, mp->lcl_plen,
22296 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
22297 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
22298 clib_net_to_host_u32 (mp->action_index), mp->tag);
22303 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
22304 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
22305 mp->scope, format_ip6_address, &mp->lcl_ip, mp->lcl_plen,
22306 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
22307 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
22308 clib_net_to_host_u32 (mp->action_index), mp->tag);
22313 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
22316 vat_main_t *vam = &vat_main;
22317 vat_json_node_t *node = NULL;
22318 struct in6_addr ip6;
22319 struct in_addr ip4;
22321 if (VAT_JSON_ARRAY != vam->json_tree.type)
22323 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
22324 vat_json_init_array (&vam->json_tree);
22326 node = vat_json_array_add (&vam->json_tree);
22327 vat_json_init_object (node);
22329 vat_json_object_add_uint (node, "is_ip4", mp->is_ip4 ? 1 : 0);
22330 vat_json_object_add_uint (node, "appns_index",
22331 clib_net_to_host_u32 (mp->appns_index));
22332 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
22333 vat_json_object_add_uint (node, "scope", mp->scope);
22334 vat_json_object_add_uint (node, "action_index",
22335 clib_net_to_host_u32 (mp->action_index));
22336 vat_json_object_add_uint (node, "lcl_port",
22337 clib_net_to_host_u16 (mp->lcl_port));
22338 vat_json_object_add_uint (node, "rmt_port",
22339 clib_net_to_host_u16 (mp->rmt_port));
22340 vat_json_object_add_uint (node, "lcl_plen", mp->lcl_plen);
22341 vat_json_object_add_uint (node, "rmt_plen", mp->rmt_plen);
22342 vat_json_object_add_string_copy (node, "tag", mp->tag);
22345 clib_memcpy (&ip4, mp->lcl_ip, sizeof (ip4));
22346 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
22347 clib_memcpy (&ip4, mp->rmt_ip, sizeof (ip4));
22348 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
22352 clib_memcpy (&ip6, mp->lcl_ip, sizeof (ip6));
22353 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
22354 clib_memcpy (&ip6, mp->rmt_ip, sizeof (ip6));
22355 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
22360 api_session_rule_add_del (vat_main_t * vam)
22362 vl_api_session_rule_add_del_t *mp;
22363 unformat_input_t *i = vam->input;
22364 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
22365 u32 appns_index = 0, scope = 0;
22366 ip4_address_t lcl_ip4, rmt_ip4;
22367 ip6_address_t lcl_ip6, rmt_ip6;
22368 u8 is_ip4 = 1, conn_set = 0;
22369 u8 is_add = 1, *tag = 0;
22372 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22374 if (unformat (i, "del"))
22376 else if (unformat (i, "add"))
22378 else if (unformat (i, "proto tcp"))
22380 else if (unformat (i, "proto udp"))
22382 else if (unformat (i, "appns %d", &appns_index))
22384 else if (unformat (i, "scope %d", &scope))
22386 else if (unformat (i, "tag %_%v%_", &tag))
22390 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
22391 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
22399 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
22400 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
22406 else if (unformat (i, "action %d", &action))
22411 if (proto == ~0 || !conn_set || action == ~0)
22413 errmsg ("transport proto, connection and action must be set");
22419 errmsg ("scope should be 0-3");
22423 M (SESSION_RULE_ADD_DEL, mp);
22425 mp->is_ip4 = is_ip4;
22426 mp->transport_proto = proto;
22427 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
22428 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
22429 mp->lcl_plen = lcl_plen;
22430 mp->rmt_plen = rmt_plen;
22431 mp->action_index = clib_host_to_net_u32 (action);
22432 mp->appns_index = clib_host_to_net_u32 (appns_index);
22434 mp->is_add = is_add;
22437 clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
22438 clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
22442 clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
22443 clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
22447 clib_memcpy (mp->tag, tag, vec_len (tag));
22457 api_session_rules_dump (vat_main_t * vam)
22459 vl_api_session_rules_dump_t *mp;
22460 vl_api_control_ping_t *mp_ping;
22463 if (!vam->json_output)
22465 print (vam->ofp, "%=20s", "Session Rules");
22468 M (SESSION_RULES_DUMP, mp);
22472 /* Use a control ping for synchronization */
22473 MPING (CONTROL_PING, mp_ping);
22476 /* Wait for a reply... */
22482 api_ip_container_proxy_add_del (vat_main_t * vam)
22484 vl_api_ip_container_proxy_add_del_t *mp;
22485 unformat_input_t *i = vam->input;
22486 u32 sw_if_index = ~0;
22487 vl_api_prefix_t pfx = { };
22491 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22493 if (unformat (i, "del"))
22495 else if (unformat (i, "add"))
22497 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
22499 else if (unformat (i, "sw_if_index %u", &sw_if_index))
22504 if (sw_if_index == ~0 || pfx.address_length == 0)
22506 errmsg ("address and sw_if_index must be set");
22510 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
22512 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
22513 mp->is_add = is_add;
22514 clib_memcpy (&mp->pfx, &pfx, sizeof (pfx));
22522 api_qos_record_enable_disable (vat_main_t * vam)
22524 unformat_input_t *i = vam->input;
22525 vl_api_qos_record_enable_disable_t *mp;
22526 u32 sw_if_index, qs = 0xff;
22527 u8 sw_if_index_set = 0;
22531 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22533 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
22534 sw_if_index_set = 1;
22535 else if (unformat (i, "sw_if_index %d", &sw_if_index))
22536 sw_if_index_set = 1;
22537 else if (unformat (i, "%U", unformat_qos_source, &qs))
22539 else if (unformat (i, "disable"))
22543 clib_warning ("parse error '%U'", format_unformat_error, i);
22548 if (sw_if_index_set == 0)
22550 errmsg ("missing interface name or sw_if_index");
22555 errmsg ("input location must be specified");
22559 M (QOS_RECORD_ENABLE_DISABLE, mp);
22561 mp->sw_if_index = ntohl (sw_if_index);
22562 mp->input_source = qs;
22563 mp->enable = enable;
22572 q_or_quit (vat_main_t * vam)
22574 #if VPP_API_TEST_BUILTIN == 0
22575 longjmp (vam->jump_buf, 1);
22577 return 0; /* not so much */
22581 q (vat_main_t * vam)
22583 return q_or_quit (vam);
22587 quit (vat_main_t * vam)
22589 return q_or_quit (vam);
22593 comment (vat_main_t * vam)
22599 statseg (vat_main_t * vam)
22601 ssvm_private_t *ssvmp = &vam->stat_segment;
22602 ssvm_shared_header_t *shared_header = ssvmp->sh;
22603 vlib_counter_t **counters;
22604 u64 thread0_index1_packets;
22605 u64 thread0_index1_bytes;
22606 f64 vector_rate, input_rate;
22609 uword *counter_vector_by_name;
22610 if (vam->stat_segment_lockp == 0)
22612 errmsg ("Stat segment not mapped...");
22616 /* look up "/if/rx for sw_if_index 1 as a test */
22618 clib_spinlock_lock (vam->stat_segment_lockp);
22620 counter_vector_by_name = (uword *) shared_header->opaque[1];
22622 p = hash_get_mem (counter_vector_by_name, "/if/rx");
22625 clib_spinlock_unlock (vam->stat_segment_lockp);
22626 errmsg ("/if/tx not found?");
22630 /* Fish per-thread vector of combined counters from shared memory */
22631 counters = (vlib_counter_t **) p[0];
22633 if (vec_len (counters[0]) < 2)
22635 clib_spinlock_unlock (vam->stat_segment_lockp);
22636 errmsg ("/if/tx vector length %d", vec_len (counters[0]));
22640 /* Read thread 0 sw_if_index 1 counter */
22641 thread0_index1_packets = counters[0][1].packets;
22642 thread0_index1_bytes = counters[0][1].bytes;
22644 p = hash_get_mem (counter_vector_by_name, "vector_rate");
22647 clib_spinlock_unlock (vam->stat_segment_lockp);
22648 errmsg ("vector_rate not found?");
22652 vector_rate = *(f64 *) (p[0]);
22653 p = hash_get_mem (counter_vector_by_name, "input_rate");
22656 clib_spinlock_unlock (vam->stat_segment_lockp);
22657 errmsg ("input_rate not found?");
22660 input_rate = *(f64 *) (p[0]);
22662 clib_spinlock_unlock (vam->stat_segment_lockp);
22664 print (vam->ofp, "vector_rate %.2f input_rate %.2f",
22665 vector_rate, input_rate);
22666 print (vam->ofp, "thread 0 sw_if_index 1 rx pkts %lld, bytes %lld",
22667 thread0_index1_packets, thread0_index1_bytes);
22673 cmd_cmp (void *a1, void *a2)
22678 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
22682 help (vat_main_t * vam)
22687 unformat_input_t *i = vam->input;
22690 if (unformat (i, "%s", &name))
22694 vec_add1 (name, 0);
22696 hs = hash_get_mem (vam->help_by_name, name);
22698 print (vam->ofp, "usage: %s %s", name, hs[0]);
22700 print (vam->ofp, "No such msg / command '%s'", name);
22705 print (vam->ofp, "Help is available for the following:");
22708 hash_foreach_pair (p, vam->function_by_name,
22710 vec_add1 (cmds, (u8 *)(p->key));
22714 vec_sort_with_function (cmds, cmd_cmp);
22716 for (j = 0; j < vec_len (cmds); j++)
22717 print (vam->ofp, "%s", cmds[j]);
22724 set (vat_main_t * vam)
22726 u8 *name = 0, *value = 0;
22727 unformat_input_t *i = vam->input;
22729 if (unformat (i, "%s", &name))
22731 /* The input buffer is a vector, not a string. */
22732 value = vec_dup (i->buffer);
22733 vec_delete (value, i->index, 0);
22734 /* Almost certainly has a trailing newline */
22735 if (value[vec_len (value) - 1] == '\n')
22736 value[vec_len (value) - 1] = 0;
22737 /* Make sure it's a proper string, one way or the other */
22738 vec_add1 (value, 0);
22739 (void) clib_macro_set_value (&vam->macro_main,
22740 (char *) name, (char *) value);
22743 errmsg ("usage: set <name> <value>");
22751 unset (vat_main_t * vam)
22755 if (unformat (vam->input, "%s", &name))
22756 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
22757 errmsg ("unset: %s wasn't set", name);
22770 macro_sort_cmp (void *a1, void *a2)
22772 macro_sort_t *s1 = a1;
22773 macro_sort_t *s2 = a2;
22775 return strcmp ((char *) (s1->name), (char *) (s2->name));
22779 dump_macro_table (vat_main_t * vam)
22781 macro_sort_t *sort_me = 0, *sm;
22786 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
22788 vec_add2 (sort_me, sm, 1);
22789 sm->name = (u8 *)(p->key);
22790 sm->value = (u8 *) (p->value[0]);
22794 vec_sort_with_function (sort_me, macro_sort_cmp);
22796 if (vec_len (sort_me))
22797 print (vam->ofp, "%-15s%s", "Name", "Value");
22799 print (vam->ofp, "The macro table is empty...");
22801 for (i = 0; i < vec_len (sort_me); i++)
22802 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
22807 dump_node_table (vat_main_t * vam)
22810 vlib_node_t *node, *next_node;
22812 if (vec_len (vam->graph_nodes) == 0)
22814 print (vam->ofp, "Node table empty, issue get_node_graph...");
22818 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
22820 node = vam->graph_nodes[0][i];
22821 print (vam->ofp, "[%d] %s", i, node->name);
22822 for (j = 0; j < vec_len (node->next_nodes); j++)
22824 if (node->next_nodes[j] != ~0)
22826 next_node = vam->graph_nodes[0][node->next_nodes[j]];
22827 print (vam->ofp, " [%d] %s", j, next_node->name);
22835 value_sort_cmp (void *a1, void *a2)
22837 name_sort_t *n1 = a1;
22838 name_sort_t *n2 = a2;
22840 if (n1->value < n2->value)
22842 if (n1->value > n2->value)
22849 dump_msg_api_table (vat_main_t * vam)
22851 api_main_t *am = &api_main;
22852 name_sort_t *nses = 0, *ns;
22857 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
22859 vec_add2 (nses, ns, 1);
22860 ns->name = (u8 *)(hp->key);
22861 ns->value = (u32) hp->value[0];
22865 vec_sort_with_function (nses, value_sort_cmp);
22867 for (i = 0; i < vec_len (nses); i++)
22868 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
22874 get_msg_id (vat_main_t * vam)
22879 if (unformat (vam->input, "%s", &name_and_crc))
22881 message_index = vl_msg_api_get_msg_index (name_and_crc);
22882 if (message_index == ~0)
22884 print (vam->ofp, " '%s' not found", name_and_crc);
22887 print (vam->ofp, " '%s' has message index %d",
22888 name_and_crc, message_index);
22891 errmsg ("name_and_crc required...");
22896 search_node_table (vat_main_t * vam)
22898 unformat_input_t *line_input = vam->input;
22901 vlib_node_t *node, *next_node;
22904 if (vam->graph_node_index_by_name == 0)
22906 print (vam->ofp, "Node table empty, issue get_node_graph...");
22910 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
22912 if (unformat (line_input, "%s", &node_to_find))
22914 vec_add1 (node_to_find, 0);
22915 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
22918 print (vam->ofp, "%s not found...", node_to_find);
22921 node = vam->graph_nodes[0][p[0]];
22922 print (vam->ofp, "[%d] %s", p[0], node->name);
22923 for (j = 0; j < vec_len (node->next_nodes); j++)
22925 if (node->next_nodes[j] != ~0)
22927 next_node = vam->graph_nodes[0][node->next_nodes[j]];
22928 print (vam->ofp, " [%d] %s", j, next_node->name);
22935 clib_warning ("parse error '%U'", format_unformat_error,
22941 vec_free (node_to_find);
22950 script (vat_main_t * vam)
22952 #if (VPP_API_TEST_BUILTIN==0)
22954 char *save_current_file;
22955 unformat_input_t save_input;
22956 jmp_buf save_jump_buf;
22957 u32 save_line_number;
22959 FILE *new_fp, *save_ifp;
22961 if (unformat (vam->input, "%s", &s))
22963 new_fp = fopen ((char *) s, "r");
22966 errmsg ("Couldn't open script file %s", s);
22973 errmsg ("Missing script name");
22977 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
22978 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
22979 save_ifp = vam->ifp;
22980 save_line_number = vam->input_line_number;
22981 save_current_file = (char *) vam->current_file;
22983 vam->input_line_number = 0;
22985 vam->current_file = s;
22988 clib_memcpy (&vam->input, &save_input, sizeof (save_input));
22989 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
22990 vam->ifp = save_ifp;
22991 vam->input_line_number = save_line_number;
22992 vam->current_file = (u8 *) save_current_file;
22997 clib_warning ("use the exec command...");
23003 echo (vat_main_t * vam)
23005 print (vam->ofp, "%v", vam->input->buffer);
23009 /* List of API message constructors, CLI names map to api_xxx */
23010 #define foreach_vpe_api_msg \
23011 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
23012 _(sw_interface_dump,"") \
23013 _(sw_interface_set_flags, \
23014 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
23015 _(sw_interface_add_del_address, \
23016 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
23017 _(sw_interface_set_rx_mode, \
23018 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
23019 _(sw_interface_set_rx_placement, \
23020 "<intfc> | sw_if_index <id> [queue <id>] [worker <id> | main]") \
23021 _(sw_interface_rx_placement_dump, \
23022 "[<intfc> | sw_if_index <id>]") \
23023 _(sw_interface_set_table, \
23024 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
23025 _(sw_interface_set_mpls_enable, \
23026 "<intfc> | sw_if_index [disable | dis]") \
23027 _(sw_interface_set_vpath, \
23028 "<intfc> | sw_if_index <id> enable | disable") \
23029 _(sw_interface_set_vxlan_bypass, \
23030 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
23031 _(sw_interface_set_geneve_bypass, \
23032 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
23033 _(sw_interface_set_l2_xconnect, \
23034 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
23035 "enable | disable") \
23036 _(sw_interface_set_l2_bridge, \
23037 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
23038 "[shg <split-horizon-group>] [bvi]\n" \
23039 "enable | disable") \
23040 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
23041 _(bridge_domain_add_del, \
23042 "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") \
23043 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
23045 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
23046 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
23047 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
23049 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
23051 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
23053 "id <num> [hw-addr <mac-addr>] [host-ns <name>] [rx-ring-size <num> [tx-ring-size <num>]") \
23055 "<vpp-if-name> | sw_if_index <id>") \
23056 _(sw_interface_tap_v2_dump, "") \
23057 _(virtio_pci_create, \
23058 "pci-addr <pci-address> [use_random_mac | hw-addr <mac-addr>] [tx-ring-size <num> [rx-ring-size <num>] [features <hex-value>]") \
23059 _(virtio_pci_delete, \
23060 "<vpp-if-name> | sw_if_index <id>") \
23061 _(sw_interface_virtio_pci_dump, "") \
23063 "[hw-addr <mac-addr>] {round-robin | active-backup | " \
23064 "broadcast | {lacp | xor} [load-balance { l2 | l23 | l34 }]} " \
23067 "<vpp-if-name> | sw_if_index <id>") \
23069 "sw_if_index <n> bond <sw_if_index> [is_passive] [is_long_timeout]") \
23070 _(bond_detach_slave, \
23071 "sw_if_index <n>") \
23072 _(sw_interface_bond_dump, "") \
23073 _(sw_interface_slave_dump, \
23074 "<vpp-if-name> | sw_if_index <id>") \
23075 _(ip_table_add_del, \
23076 "table <n> [ipv6] [add | del]\n") \
23077 _(ip_add_del_route, \
23078 "<addr>/<mask> via <<addr>|<intfc>|sw_if_index <id>|via-label <n>>\n" \
23079 "[table-id <n>] [<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n"\
23080 "[weight <n>] [drop] [local] [classify <n>] [out-label <n>]\n" \
23081 "[multipath] [count <n>] [del]") \
23082 _(ip_mroute_add_del, \
23083 "<src> <grp>/<mask> [table-id <n>]\n" \
23084 "[<intfc> | sw_if_index <id>] [local] [del]") \
23085 _(mpls_table_add_del, \
23086 "table <n> [add | del]\n") \
23087 _(mpls_route_add_del, \
23088 "<label> <eos> via <addr | next-hop-table <n> | via-label <n> |\n" \
23089 "lookup-ip4-table <n> | lookup-in-ip6-table <n> |\n" \
23090 "l2-input-on <intfc> | l2-input-on sw_if_index <id>>\n" \
23091 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>] [weight <n>]\n" \
23092 "[drop] [local] [classify <n>] [out-label <n>] [multipath]\n" \
23093 "[count <n>] [del]") \
23094 _(mpls_ip_bind_unbind, \
23095 "<label> <addr/len>") \
23096 _(mpls_tunnel_add_del, \
23097 "[add | del <intfc | sw_if_index <id>>] via <addr | via-label <n>>\n" \
23098 "[<intfc> | sw_if_index <id> | next-hop-table <id>]\n" \
23099 "[l2-only] [out-label <n>]") \
23100 _(sr_mpls_policy_add, \
23101 "bsid <id> [weight <n>] [spray] next <sid> [next <sid>]") \
23102 _(sr_mpls_policy_del, \
23104 _(bier_table_add_del, \
23105 "<label> <sub-domain> <set> <bsl> [del]") \
23106 _(bier_route_add_del, \
23107 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
23108 "[<intfc> | sw_if_index <id>]" \
23109 "[weight <n>] [del] [multipath]") \
23110 _(proxy_arp_add_del, \
23111 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
23112 _(proxy_arp_intfc_enable_disable, \
23113 "<intfc> | sw_if_index <id> enable | disable") \
23114 _(sw_interface_set_unnumbered, \
23115 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
23116 _(ip_neighbor_add_del, \
23117 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
23118 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
23119 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
23120 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
23121 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
23122 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
23123 "[outer_vlan_id_any][inner_vlan_id_any]") \
23124 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
23125 _(reset_fib, "vrf <n> [ipv6]") \
23126 _(dhcp_proxy_config, \
23127 "svr <v46-address> src <v46-address>\n" \
23128 "rx_vrf_id <nn> server_vrf_id <nn> [del]") \
23129 _(dhcp_proxy_set_vss, \
23130 "tbl_id <n> [fib_id <n> oui <n> | vpn_ascii_id <text>] [ipv6] [del]") \
23131 _(dhcp_proxy_dump, "ip6") \
23132 _(dhcp_client_config, \
23133 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
23134 _(set_ip_flow_hash, \
23135 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
23136 _(sw_interface_ip6_enable_disable, \
23137 "<intfc> | sw_if_index <id> enable | disable") \
23138 _(ip6nd_proxy_add_del, \
23139 "<intfc> | sw_if_index <id> <ip6-address>") \
23140 _(ip6nd_proxy_dump, "") \
23141 _(sw_interface_ip6nd_ra_prefix, \
23142 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
23143 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
23144 "[nolink] [isno]") \
23145 _(sw_interface_ip6nd_ra_config, \
23146 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
23147 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
23148 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
23149 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
23150 _(l2_patch_add_del, \
23151 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
23152 "enable | disable") \
23153 _(sr_localsid_add_del, \
23154 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
23155 "fib-table <num> (end.psp) sw_if_index <num>") \
23156 _(classify_add_del_table, \
23157 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
23158 " [del] [del-chain] mask <mask-value>\n" \
23159 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
23160 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
23161 _(classify_add_del_session, \
23162 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
23163 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
23164 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
23165 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
23166 _(classify_set_interface_ip_table, \
23167 "<intfc> | sw_if_index <nn> table <nn>") \
23168 _(classify_set_interface_l2_tables, \
23169 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
23170 " [other-table <nn>]") \
23171 _(get_node_index, "node <node-name") \
23172 _(add_node_next, "node <node-name> next <next-node-name>") \
23173 _(l2tpv3_create_tunnel, \
23174 "client_address <ip6-addr> our_address <ip6-addr>\n" \
23175 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
23176 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
23177 _(l2tpv3_set_tunnel_cookies, \
23178 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
23179 "[new_remote_cookie <nn>]\n") \
23180 _(l2tpv3_interface_enable_disable, \
23181 "<intfc> | sw_if_index <nn> enable | disable") \
23182 _(l2tpv3_set_lookup_key, \
23183 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
23184 _(sw_if_l2tpv3_tunnel_dump, "") \
23185 _(vxlan_offload_rx, \
23186 "hw { <interface name> | hw_if_index <nn>} " \
23187 "rx { <vxlan tunnel name> | sw_if_index <nn> } [del]") \
23188 _(vxlan_add_del_tunnel, \
23189 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
23190 "{ <intfc> | mcast_sw_if_index <nn> } [instance <id>]}\n" \
23191 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
23192 _(geneve_add_del_tunnel, \
23193 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
23194 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
23195 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
23196 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
23197 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
23198 _(gre_add_del_tunnel, \
23199 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [instance <n>]\n" \
23200 "[teb | erspan <session-id>] [del]") \
23201 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
23202 _(l2_fib_clear_table, "") \
23203 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
23204 _(l2_interface_vlan_tag_rewrite, \
23205 "<intfc> | sw_if_index <nn> \n" \
23206 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
23207 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
23208 _(create_vhost_user_if, \
23209 "socket <filename> [server] [renumber <dev_instance>] " \
23210 "[disable_mrg_rxbuf] [disable_indirect_desc] " \
23211 "[mac <mac_address>]") \
23212 _(modify_vhost_user_if, \
23213 "<intfc> | sw_if_index <nn> socket <filename>\n" \
23214 "[server] [renumber <dev_instance>]") \
23215 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
23216 _(sw_interface_vhost_user_dump, "") \
23217 _(show_version, "") \
23218 _(show_threads, "") \
23219 _(vxlan_gpe_add_del_tunnel, \
23220 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
23221 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
23222 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
23223 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
23224 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
23225 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
23226 _(interface_name_renumber, \
23227 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
23228 _(input_acl_set_interface, \
23229 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
23230 " [l2-table <nn>] [del]") \
23231 _(ip_probe_neighbor, "(<intc> | sw_if_index <nn>) address <ip4|ip6-addr>") \
23232 _(ip_scan_neighbor_enable_disable, "[ip4|ip6|both|disable] [interval <n-min>]\n" \
23233 " [max-time <n-usec>] [max-update <n>] [delay <n-msec>] [stale <n-min>]") \
23234 _(want_ip4_arp_events, "address <ip4-address> [del]") \
23235 _(want_ip6_nd_events, "address <ip6-address> [del]") \
23236 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
23237 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
23238 _(ip_dump, "ipv4 | ipv6") \
23239 _(ipsec_spd_add_del, "spd_id <n> [del]") \
23240 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
23242 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
23243 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
23244 " integ_alg <alg> integ_key <hex>") \
23245 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
23246 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
23247 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
23248 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
23249 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
23250 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
23251 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
23252 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
23253 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n" \
23254 " [instance <n>]") \
23255 _(ipsec_sa_dump, "[sa_id <n>]") \
23256 _(ipsec_tunnel_if_set_key, "<intfc> <local|remote> <crypto|integ>\n" \
23257 " <alg> <hex>\n") \
23258 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
23259 _(ikev2_profile_add_del, "name <profile_name> [del]") \
23260 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
23261 "(auth_data 0x<data> | auth_data <data>)") \
23262 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
23263 "(id_data 0x<data> | id_data <data>) (local|remote)") \
23264 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
23265 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
23266 "(local|remote)") \
23267 _(ikev2_set_local_key, "file <absolute_file_path>") \
23268 _(ikev2_set_responder, "<profile_name> interface <interface> address <addr>") \
23269 _(ikev2_set_ike_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
23270 _(ikev2_set_esp_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
23271 _(ikev2_set_sa_lifetime, "<profile_name> <seconds> <jitter> <handover> <max bytes>") \
23272 _(ikev2_initiate_sa_init, "<profile_name>") \
23273 _(ikev2_initiate_del_ike_sa, "<ispi>") \
23274 _(ikev2_initiate_del_child_sa, "<ispi>") \
23275 _(ikev2_initiate_rekey_child_sa, "<ispi>") \
23276 _(delete_loopback,"sw_if_index <nn>") \
23277 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
23278 _(bd_ip_mac_flush, "bd_id <bridge-domain-id>") \
23279 _(bd_ip_mac_dump, "[bd_id] <bridge-domain-id>") \
23280 _(want_interface_events, "enable|disable") \
23281 _(get_first_msg_id, "client <name>") \
23282 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
23283 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
23284 "fib-id <nn> [ip4][ip6][default]") \
23285 _(get_node_graph, " ") \
23286 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
23287 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
23288 _(ioam_disable, "") \
23289 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
23290 " sw_if_index <sw_if_index> p <priority> " \
23291 "w <weight>] [del]") \
23292 _(one_add_del_locator, "locator-set <locator_name> " \
23293 "iface <intf> | sw_if_index <sw_if_index> " \
23294 "p <priority> w <weight> [del]") \
23295 _(one_add_del_local_eid,"vni <vni> eid " \
23296 "<ipv4|ipv6>/<prefix> | <L2 address> " \
23297 "locator-set <locator_name> [del]" \
23298 "[key-id sha1|sha256 secret-key <secret-key>]")\
23299 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
23300 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
23301 _(one_enable_disable, "enable|disable") \
23302 _(one_map_register_enable_disable, "enable|disable") \
23303 _(one_map_register_fallback_threshold, "<value>") \
23304 _(one_rloc_probe_enable_disable, "enable|disable") \
23305 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
23307 "rloc <locator> p <prio> " \
23308 "w <weight> [rloc <loc> ... ] " \
23309 "action <action> [del-all]") \
23310 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
23312 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
23313 _(one_use_petr, "ip-address> | disable") \
23314 _(one_map_request_mode, "src-dst|dst-only") \
23315 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
23316 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
23317 _(one_locator_set_dump, "[local | remote]") \
23318 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
23319 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
23320 "[local] | [remote]") \
23321 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
23322 _(one_ndp_bd_get, "") \
23323 _(one_ndp_entries_get, "bd <bridge-domain>") \
23324 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
23325 _(one_l2_arp_bd_get, "") \
23326 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
23327 _(one_stats_enable_disable, "enable|disable") \
23328 _(show_one_stats_enable_disable, "") \
23329 _(one_eid_table_vni_dump, "") \
23330 _(one_eid_table_map_dump, "l2|l3") \
23331 _(one_map_resolver_dump, "") \
23332 _(one_map_server_dump, "") \
23333 _(one_adjacencies_get, "vni <vni>") \
23334 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
23335 _(show_one_rloc_probe_state, "") \
23336 _(show_one_map_register_state, "") \
23337 _(show_one_status, "") \
23338 _(one_stats_dump, "") \
23339 _(one_stats_flush, "") \
23340 _(one_get_map_request_itr_rlocs, "") \
23341 _(one_map_register_set_ttl, "<ttl>") \
23342 _(one_set_transport_protocol, "udp|api") \
23343 _(one_get_transport_protocol, "") \
23344 _(one_enable_disable_xtr_mode, "enable|disable") \
23345 _(one_show_xtr_mode, "") \
23346 _(one_enable_disable_pitr_mode, "enable|disable") \
23347 _(one_show_pitr_mode, "") \
23348 _(one_enable_disable_petr_mode, "enable|disable") \
23349 _(one_show_petr_mode, "") \
23350 _(show_one_nsh_mapping, "") \
23351 _(show_one_pitr, "") \
23352 _(show_one_use_petr, "") \
23353 _(show_one_map_request_mode, "") \
23354 _(show_one_map_register_ttl, "") \
23355 _(show_one_map_register_fallback_threshold, "") \
23356 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
23357 " sw_if_index <sw_if_index> p <priority> " \
23358 "w <weight>] [del]") \
23359 _(lisp_add_del_locator, "locator-set <locator_name> " \
23360 "iface <intf> | sw_if_index <sw_if_index> " \
23361 "p <priority> w <weight> [del]") \
23362 _(lisp_add_del_local_eid,"vni <vni> eid " \
23363 "<ipv4|ipv6>/<prefix> | <L2 address> " \
23364 "locator-set <locator_name> [del]" \
23365 "[key-id sha1|sha256 secret-key <secret-key>]") \
23366 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
23367 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
23368 _(lisp_enable_disable, "enable|disable") \
23369 _(lisp_map_register_enable_disable, "enable|disable") \
23370 _(lisp_rloc_probe_enable_disable, "enable|disable") \
23371 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
23373 "rloc <locator> p <prio> " \
23374 "w <weight> [rloc <loc> ... ] " \
23375 "action <action> [del-all]") \
23376 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
23378 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
23379 _(lisp_use_petr, "<ip-address> | disable") \
23380 _(lisp_map_request_mode, "src-dst|dst-only") \
23381 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
23382 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
23383 _(lisp_locator_set_dump, "[local | remote]") \
23384 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
23385 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
23386 "[local] | [remote]") \
23387 _(lisp_eid_table_vni_dump, "") \
23388 _(lisp_eid_table_map_dump, "l2|l3") \
23389 _(lisp_map_resolver_dump, "") \
23390 _(lisp_map_server_dump, "") \
23391 _(lisp_adjacencies_get, "vni <vni>") \
23392 _(gpe_fwd_entry_vnis_get, "") \
23393 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
23394 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
23395 "[table <table-id>]") \
23396 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
23397 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
23398 _(gpe_set_encap_mode, "lisp|vxlan") \
23399 _(gpe_get_encap_mode, "") \
23400 _(lisp_gpe_add_del_iface, "up|down") \
23401 _(lisp_gpe_enable_disable, "enable|disable") \
23402 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
23403 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
23404 _(show_lisp_rloc_probe_state, "") \
23405 _(show_lisp_map_register_state, "") \
23406 _(show_lisp_status, "") \
23407 _(lisp_get_map_request_itr_rlocs, "") \
23408 _(show_lisp_pitr, "") \
23409 _(show_lisp_use_petr, "") \
23410 _(show_lisp_map_request_mode, "") \
23411 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
23412 _(af_packet_delete, "name <host interface name>") \
23413 _(af_packet_dump, "") \
23414 _(policer_add_del, "name <policer name> <params> [del]") \
23415 _(policer_dump, "[name <policer name>]") \
23416 _(policer_classify_set_interface, \
23417 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
23418 " [l2-table <nn>] [del]") \
23419 _(policer_classify_dump, "type [ip4|ip6|l2]") \
23420 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
23421 "[master|slave]") \
23422 _(netmap_delete, "name <interface name>") \
23423 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
23424 _(mpls_fib_dump, "") \
23425 _(classify_table_ids, "") \
23426 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
23427 _(classify_table_info, "table_id <nn>") \
23428 _(classify_session_dump, "table_id <nn>") \
23429 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
23430 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
23431 "[template_interval <nn>] [udp_checksum]") \
23432 _(ipfix_exporter_dump, "") \
23433 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
23434 _(ipfix_classify_stream_dump, "") \
23435 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
23436 _(ipfix_classify_table_dump, "") \
23437 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
23438 _(sw_interface_span_dump, "[l2]") \
23439 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
23440 _(pg_create_interface, "if_id <nn>") \
23441 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
23442 _(pg_enable_disable, "[stream <id>] disable") \
23443 _(ip_source_and_port_range_check_add_del, \
23444 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
23445 _(ip_source_and_port_range_check_interface_add_del, \
23446 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
23447 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
23448 _(ipsec_gre_add_del_tunnel, \
23449 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
23450 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
23451 _(delete_subif,"<intfc> | sw_if_index <nn>") \
23452 _(l2_interface_pbb_tag_rewrite, \
23453 "<intfc> | sw_if_index <nn> \n" \
23454 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
23455 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
23456 _(set_punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
23457 _(flow_classify_set_interface, \
23458 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
23459 _(flow_classify_dump, "type [ip4|ip6]") \
23460 _(ip_fib_dump, "") \
23461 _(ip_mfib_dump, "") \
23462 _(ip6_fib_dump, "") \
23463 _(ip6_mfib_dump, "") \
23464 _(feature_enable_disable, "arc_name <arc_name> " \
23465 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
23466 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
23468 _(l2_xconnect_dump, "") \
23469 _(hw_interface_set_mtu, "<intfc> | hw_if_index <nn> mtu <nn>") \
23470 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
23471 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
23472 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
23473 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
23474 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
23475 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
23476 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
23477 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
23478 _(sock_init_shm, "size <nnn>") \
23479 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
23480 _(dns_enable_disable, "[enable][disable]") \
23481 _(dns_name_server_add_del, "<ip-address> [del]") \
23482 _(dns_resolve_name, "<hostname>") \
23483 _(dns_resolve_ip, "<ip4|ip6>") \
23484 _(dns_name_server_add_del, "<ip-address> [del]") \
23485 _(dns_resolve_name, "<hostname>") \
23486 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
23487 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
23488 _(session_rules_dump, "") \
23489 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
23490 _(output_acl_set_interface, \
23491 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
23492 " [l2-table <nn>] [del]") \
23493 _(qos_record_enable_disable, "<record-source> <intfc> | sw_if_index <id> [disable]")
23495 /* List of command functions, CLI names map directly to functions */
23496 #define foreach_cli_function \
23497 _(comment, "usage: comment <ignore-rest-of-line>") \
23498 _(dump_interface_table, "usage: dump_interface_table") \
23499 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
23500 _(dump_ipv4_table, "usage: dump_ipv4_table") \
23501 _(dump_ipv6_table, "usage: dump_ipv6_table") \
23502 _(dump_macro_table, "usage: dump_macro_table ") \
23503 _(dump_node_table, "usage: dump_node_table") \
23504 _(dump_msg_api_table, "usage: dump_msg_api_table") \
23505 _(get_msg_id, "usage: get_msg_id name_and_crc") \
23506 _(echo, "usage: echo <message>") \
23507 _(exec, "usage: exec <vpe-debug-CLI-command>") \
23508 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
23509 _(help, "usage: help") \
23510 _(q, "usage: quit") \
23511 _(quit, "usage: quit") \
23512 _(search_node_table, "usage: search_node_table <name>...") \
23513 _(set, "usage: set <variable-name> <value>") \
23514 _(script, "usage: script <file-name>") \
23515 _(statseg, "usage: statseg"); \
23516 _(unset, "usage: unset <variable-name>")
23519 static void vl_api_##n##_t_handler_uni \
23520 (vl_api_##n##_t * mp) \
23522 vat_main_t * vam = &vat_main; \
23523 if (vam->json_output) { \
23524 vl_api_##n##_t_handler_json(mp); \
23526 vl_api_##n##_t_handler(mp); \
23529 foreach_vpe_api_reply_msg;
23530 #if VPP_API_TEST_BUILTIN == 0
23531 foreach_standalone_reply_msg;
23536 vat_api_hookup (vat_main_t * vam)
23539 vl_msg_api_set_handlers(VL_API_##N, #n, \
23540 vl_api_##n##_t_handler_uni, \
23542 vl_api_##n##_t_endian, \
23543 vl_api_##n##_t_print, \
23544 sizeof(vl_api_##n##_t), 1);
23545 foreach_vpe_api_reply_msg;
23546 #if VPP_API_TEST_BUILTIN == 0
23547 foreach_standalone_reply_msg;
23551 #if (VPP_API_TEST_BUILTIN==0)
23552 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
23554 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
23556 vam->function_by_name = hash_create_string (0, sizeof (uword));
23558 vam->help_by_name = hash_create_string (0, sizeof (uword));
23561 /* API messages we can send */
23562 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
23563 foreach_vpe_api_msg;
23567 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
23568 foreach_vpe_api_msg;
23571 /* CLI functions */
23572 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
23573 foreach_cli_function;
23577 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
23578 foreach_cli_function;
23582 #if VPP_API_TEST_BUILTIN
23583 static clib_error_t *
23584 vat_api_hookup_shim (vlib_main_t * vm)
23586 vat_api_hookup (&vat_main);
23590 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
23594 * fd.io coding-style-patch-verification: ON
23597 * eval: (c-set-style "gnu")