2 *------------------------------------------------------------------
5 * Copyright (c) 2014-2016 Cisco and/or its affiliates.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at:
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *------------------------------------------------------------------
21 #include <vpp/api/types.h>
22 #include <vppinfra/socket.h>
23 #include <vlibapi/api.h>
24 #include <vlibmemory/api.h>
25 #include <vnet/ip/ip.h>
26 #include <vnet/ip/ip_neighbor.h>
27 #include <vnet/ip/ip_types_api.h>
28 #include <vnet/l2/l2_input.h>
29 #include <vnet/l2tp/l2tp.h>
30 #include <vnet/vxlan/vxlan.h>
31 #include <vnet/geneve/geneve.h>
32 #include <vnet/gre/gre.h>
33 #include <vnet/vxlan-gpe/vxlan_gpe.h>
34 #include <vnet/lisp-gpe/lisp_gpe.h>
36 #include <vpp/api/vpe_msg_enum.h>
37 #include <vnet/l2/l2_classify.h>
38 #include <vnet/l2/l2_vtr.h>
39 #include <vnet/classify/in_out_acl.h>
40 #include <vnet/classify/policer_classify.h>
41 #include <vnet/classify/flow_classify.h>
42 #include <vnet/mpls/mpls.h>
43 #include <vnet/ipsec/ipsec.h>
45 #include <vnet/cop/cop.h>
46 #include <vnet/ip/ip6_hop_by_hop.h>
47 #include <vnet/ip/ip_source_and_port_range_check.h>
48 #include <vnet/policer/xlate.h>
49 #include <vnet/span/span.h>
50 #include <vnet/policer/policer.h>
51 #include <vnet/policer/police.h>
52 #include <vnet/mfib/mfib_types.h>
53 #include <vnet/dhcp/dhcp_proxy.h>
54 #include <vnet/bonding/node.h>
55 #include <vnet/qos/qos_types.h>
56 #include <vnet/ethernet/ethernet_types_api.h>
57 #include <vnet/ip/ip_types_api.h>
58 #include "vat/json_format.h"
59 #include <vnet/ip/ip_types_api.h>
60 #include <vnet/ethernet/ethernet_types_api.h>
65 #define vl_typedefs /* define message structures */
66 #include <vpp/api/vpe_all_api_h.h>
69 /* declare message handlers for each api */
71 #define vl_endianfun /* define message structures */
72 #include <vpp/api/vpe_all_api_h.h>
75 /* instantiate all the print functions we know about */
76 #define vl_print(handle, ...)
78 #include <vpp/api/vpe_all_api_h.h>
81 #define __plugin_msg_base 0
82 #include <vlibapi/vat_helper_macros.h>
84 #if VPP_API_TEST_BUILTIN == 0
94 vat_socket_connect (vat_main_t * vam)
97 vam->socket_client_main = &socket_client_main;
98 if ((rv = vl_socket_client_connect ((char *) vam->socket_name,
100 0 /* default socket rx, tx buffer */ )))
102 /* vpp expects the client index in network order */
103 vam->my_client_index = htonl (socket_client_main.client_index);
106 #else /* vpp built-in case, we don't do sockets... */
108 vat_socket_connect (vat_main_t * vam)
114 vl_socket_client_read (int wait)
120 vl_socket_client_write ()
126 vl_socket_client_msg_alloc (int nbytes)
134 vat_time_now (vat_main_t * vam)
136 #if VPP_API_TEST_BUILTIN
137 return vlib_time_now (vam->vlib_main);
139 return clib_time_now (&vam->clib_time);
144 errmsg (char *fmt, ...)
146 vat_main_t *vam = &vat_main;
151 s = va_format (0, fmt, &va);
156 #if VPP_API_TEST_BUILTIN
157 vlib_cli_output (vam->vlib_main, (char *) s);
160 if (vam->ifp != stdin)
161 fformat (vam->ofp, "%s(%d): \n", vam->current_file,
162 vam->input_line_number);
163 fformat (vam->ofp, (char *) s);
171 #if VPP_API_TEST_BUILTIN == 0
173 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
175 vat_main_t *vam = va_arg (*args, vat_main_t *);
176 u32 *result = va_arg (*args, u32 *);
180 if (!unformat (input, "%s", &if_name))
183 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
191 api_unformat_hw_if_index (unformat_input_t * input, va_list * args)
196 /* Parse an IP4 address %d.%d.%d.%d. */
198 unformat_ip4_address (unformat_input_t * input, va_list * args)
200 u8 *result = va_arg (*args, u8 *);
203 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
206 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
218 unformat_ethernet_address (unformat_input_t * input, va_list * args)
220 u8 *result = va_arg (*args, u8 *);
223 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
224 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
228 for (i = 0; i < 6; i++)
229 if (a[i] >= (1 << 8))
232 for (i = 0; i < 6; i++)
238 /* Returns ethernet type as an int in host byte order. */
240 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
243 u16 *result = va_arg (*args, u16 *);
247 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
249 if (type >= (1 << 16))
257 /* Parse an IP6 address. */
259 unformat_ip6_address (unformat_input_t * input, va_list * args)
261 ip6_address_t *result = va_arg (*args, ip6_address_t *);
263 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
264 uword c, n_colon, double_colon_index;
266 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
267 double_colon_index = ARRAY_LEN (hex_quads);
268 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
271 if (c >= '0' && c <= '9')
273 else if (c >= 'a' && c <= 'f')
274 hex_digit = c + 10 - 'a';
275 else if (c >= 'A' && c <= 'F')
276 hex_digit = c + 10 - 'A';
277 else if (c == ':' && n_colon < 2)
281 unformat_put_input (input);
285 /* Too many hex quads. */
286 if (n_hex_quads >= ARRAY_LEN (hex_quads))
291 hex_quad = (hex_quad << 4) | hex_digit;
293 /* Hex quad must fit in 16 bits. */
294 if (n_hex_digits >= 4)
301 /* Save position of :: */
304 /* More than one :: ? */
305 if (double_colon_index < ARRAY_LEN (hex_quads))
307 double_colon_index = n_hex_quads;
310 if (n_colon > 0 && n_hex_digits > 0)
312 hex_quads[n_hex_quads++] = hex_quad;
318 if (n_hex_digits > 0)
319 hex_quads[n_hex_quads++] = hex_quad;
324 /* Expand :: to appropriate number of zero hex quads. */
325 if (double_colon_index < ARRAY_LEN (hex_quads))
327 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
329 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
330 hex_quads[n_zero + i] = hex_quads[i];
332 for (i = 0; i < n_zero; i++)
333 hex_quads[double_colon_index + i] = 0;
335 n_hex_quads = ARRAY_LEN (hex_quads);
338 /* Too few hex quads given. */
339 if (n_hex_quads < ARRAY_LEN (hex_quads))
342 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
343 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
350 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
352 u32 *r = va_arg (*args, u32 *);
355 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
356 foreach_ipsec_policy_action
364 format_ipsec_crypto_alg (u8 * s, va_list * args)
366 u32 i = va_arg (*args, u32);
371 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
372 foreach_ipsec_crypto_alg
375 return format (s, "unknown");
377 return format (s, "%s", t);
381 format_ipsec_integ_alg (u8 * s, va_list * args)
383 u32 i = va_arg (*args, u32);
388 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
389 foreach_ipsec_integ_alg
392 return format (s, "unknown");
394 return format (s, "%s", t);
397 #else /* VPP_API_TEST_BUILTIN == 1 */
399 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
401 vat_main_t *vam __attribute__ ((unused)) = va_arg (*args, vat_main_t *);
402 vnet_main_t *vnm = vnet_get_main ();
403 u32 *result = va_arg (*args, u32 *);
405 return unformat (input, "%U", unformat_vnet_sw_interface, vnm, result);
409 api_unformat_hw_if_index (unformat_input_t * input, va_list * args)
411 vat_main_t *vam __attribute__ ((unused)) = va_arg (*args, vat_main_t *);
412 vnet_main_t *vnm = vnet_get_main ();
413 u32 *result = va_arg (*args, u32 *);
415 return unformat (input, "%U", unformat_vnet_hw_interface, vnm, result);
418 #endif /* VPP_API_TEST_BUILTIN */
421 unformat_ipsec_api_crypto_alg (unformat_input_t * input, va_list * args)
423 u32 *r = va_arg (*args, u32 *);
426 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_API_CRYPTO_ALG_##f;
427 foreach_ipsec_crypto_alg
435 unformat_ipsec_api_integ_alg (unformat_input_t * input, va_list * args)
437 u32 *r = va_arg (*args, u32 *);
440 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_API_INTEG_ALG_##f;
441 foreach_ipsec_integ_alg
449 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
451 u8 *r = va_arg (*args, u8 *);
453 if (unformat (input, "kbps"))
454 *r = SSE2_QOS_RATE_KBPS;
455 else if (unformat (input, "pps"))
456 *r = SSE2_QOS_RATE_PPS;
463 unformat_policer_round_type (unformat_input_t * input, va_list * args)
465 u8 *r = va_arg (*args, u8 *);
467 if (unformat (input, "closest"))
468 *r = SSE2_QOS_ROUND_TO_CLOSEST;
469 else if (unformat (input, "up"))
470 *r = SSE2_QOS_ROUND_TO_UP;
471 else if (unformat (input, "down"))
472 *r = SSE2_QOS_ROUND_TO_DOWN;
479 unformat_policer_type (unformat_input_t * input, va_list * args)
481 u8 *r = va_arg (*args, u8 *);
483 if (unformat (input, "1r2c"))
484 *r = SSE2_QOS_POLICER_TYPE_1R2C;
485 else if (unformat (input, "1r3c"))
486 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
487 else if (unformat (input, "2r3c-2698"))
488 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
489 else if (unformat (input, "2r3c-4115"))
490 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
491 else if (unformat (input, "2r3c-mef5cf1"))
492 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
499 unformat_dscp (unformat_input_t * input, va_list * va)
501 u8 *r = va_arg (*va, u8 *);
504 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
513 unformat_policer_action_type (unformat_input_t * input, va_list * va)
515 sse2_qos_pol_action_params_st *a
516 = va_arg (*va, sse2_qos_pol_action_params_st *);
518 if (unformat (input, "drop"))
519 a->action_type = SSE2_QOS_ACTION_DROP;
520 else if (unformat (input, "transmit"))
521 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
522 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
523 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
530 unformat_policer_classify_table_type (unformat_input_t * input, va_list * va)
532 u32 *r = va_arg (*va, u32 *);
535 if (unformat (input, "ip4"))
536 tid = POLICER_CLASSIFY_TABLE_IP4;
537 else if (unformat (input, "ip6"))
538 tid = POLICER_CLASSIFY_TABLE_IP6;
539 else if (unformat (input, "l2"))
540 tid = POLICER_CLASSIFY_TABLE_L2;
549 unformat_flow_classify_table_type (unformat_input_t * input, va_list * va)
551 u32 *r = va_arg (*va, u32 *);
554 if (unformat (input, "ip4"))
555 tid = FLOW_CLASSIFY_TABLE_IP4;
556 else if (unformat (input, "ip6"))
557 tid = FLOW_CLASSIFY_TABLE_IP6;
565 static const char *mfib_flag_names[] = MFIB_ENTRY_NAMES_SHORT;
566 static const char *mfib_flag_long_names[] = MFIB_ENTRY_NAMES_LONG;
567 static const char *mfib_itf_flag_long_names[] = MFIB_ITF_NAMES_LONG;
568 static const char *mfib_itf_flag_names[] = MFIB_ITF_NAMES_SHORT;
570 #if (VPP_API_TEST_BUILTIN==0)
572 unformat_mfib_itf_flags (unformat_input_t * input, va_list * args)
574 mfib_itf_flags_t old, *iflags = va_arg (*args, mfib_itf_flags_t *);
575 mfib_itf_attribute_t attr;
578 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
580 if (unformat (input, mfib_itf_flag_long_names[attr]))
581 *iflags |= (1 << attr);
583 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
585 if (unformat (input, mfib_itf_flag_names[attr]))
586 *iflags |= (1 << attr);
589 return (old == *iflags ? 0 : 1);
593 unformat_mfib_entry_flags (unformat_input_t * input, va_list * args)
595 mfib_entry_flags_t old, *eflags = va_arg (*args, mfib_entry_flags_t *);
596 mfib_entry_attribute_t attr;
599 FOR_EACH_MFIB_ATTRIBUTE (attr)
601 if (unformat (input, mfib_flag_long_names[attr]))
602 *eflags |= (1 << attr);
604 FOR_EACH_MFIB_ATTRIBUTE (attr)
606 if (unformat (input, mfib_flag_names[attr]))
607 *eflags |= (1 << attr);
610 return (old == *eflags ? 0 : 1);
614 format_ip4_address (u8 * s, va_list * args)
616 u8 *a = va_arg (*args, u8 *);
617 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
621 format_ip6_address (u8 * s, va_list * args)
623 ip6_address_t *a = va_arg (*args, ip6_address_t *);
624 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
626 i_max_n_zero = ARRAY_LEN (a->as_u16);
628 i_first_zero = i_max_n_zero;
630 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
632 u32 is_zero = a->as_u16[i] == 0;
633 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
639 if ((!is_zero && n_zeros > max_n_zeros)
640 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
642 i_max_n_zero = i_first_zero;
643 max_n_zeros = n_zeros;
644 i_first_zero = ARRAY_LEN (a->as_u16);
649 last_double_colon = 0;
650 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
652 if (i == i_max_n_zero && max_n_zeros > 1)
654 s = format (s, "::");
655 i += max_n_zeros - 1;
656 last_double_colon = 1;
660 s = format (s, "%s%x",
661 (last_double_colon || i == 0) ? "" : ":",
662 clib_net_to_host_u16 (a->as_u16[i]));
663 last_double_colon = 0;
670 /* Format an IP46 address. */
672 format_ip46_address (u8 * s, va_list * args)
674 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
675 ip46_type_t type = va_arg (*args, ip46_type_t);
681 is_ip4 = ip46_address_is_ip4 (ip46);
692 format (s, "%U", format_ip4_address, &ip46->ip4) :
693 format (s, "%U", format_ip6_address, &ip46->ip6);
697 format_ethernet_address (u8 * s, va_list * args)
699 u8 *a = va_arg (*args, u8 *);
701 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
702 a[0], a[1], a[2], a[3], a[4], a[5]);
707 increment_v4_address (ip4_address_t * a)
711 v = ntohl (a->as_u32) + 1;
712 a->as_u32 = ntohl (v);
716 increment_vl_v4_address (vl_api_ip4_address_t * a)
724 clib_memcpy (a, &v, sizeof (v));
728 increment_vl_address (vl_api_address_t * a)
730 if (ADDRESS_IP4 == a->af)
731 increment_vl_v4_address (&a->un.ip4);
735 increment_v6_address (ip6_address_t * a)
739 v0 = clib_net_to_host_u64 (a->as_u64[0]);
740 v1 = clib_net_to_host_u64 (a->as_u64[1]);
745 a->as_u64[0] = clib_net_to_host_u64 (v0);
746 a->as_u64[1] = clib_net_to_host_u64 (v1);
750 increment_mac_address (u8 * mac)
752 u64 tmp = *((u64 *) mac);
753 tmp = clib_net_to_host_u64 (tmp);
754 tmp += 1 << 16; /* skip unused (least significant) octets */
755 tmp = clib_host_to_net_u64 (tmp);
757 clib_memcpy (mac, &tmp, 6);
760 static void vl_api_create_loopback_reply_t_handler
761 (vl_api_create_loopback_reply_t * mp)
763 vat_main_t *vam = &vat_main;
764 i32 retval = ntohl (mp->retval);
766 vam->retval = retval;
767 vam->regenerate_interface_table = 1;
768 vam->sw_if_index = ntohl (mp->sw_if_index);
769 vam->result_ready = 1;
772 static void vl_api_create_loopback_reply_t_handler_json
773 (vl_api_create_loopback_reply_t * mp)
775 vat_main_t *vam = &vat_main;
776 vat_json_node_t node;
778 vat_json_init_object (&node);
779 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
780 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
782 vat_json_print (vam->ofp, &node);
783 vat_json_free (&node);
784 vam->retval = ntohl (mp->retval);
785 vam->result_ready = 1;
788 static void vl_api_create_loopback_instance_reply_t_handler
789 (vl_api_create_loopback_instance_reply_t * mp)
791 vat_main_t *vam = &vat_main;
792 i32 retval = ntohl (mp->retval);
794 vam->retval = retval;
795 vam->regenerate_interface_table = 1;
796 vam->sw_if_index = ntohl (mp->sw_if_index);
797 vam->result_ready = 1;
800 static void vl_api_create_loopback_instance_reply_t_handler_json
801 (vl_api_create_loopback_instance_reply_t * mp)
803 vat_main_t *vam = &vat_main;
804 vat_json_node_t node;
806 vat_json_init_object (&node);
807 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
808 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
810 vat_json_print (vam->ofp, &node);
811 vat_json_free (&node);
812 vam->retval = ntohl (mp->retval);
813 vam->result_ready = 1;
816 static void vl_api_af_packet_create_reply_t_handler
817 (vl_api_af_packet_create_reply_t * mp)
819 vat_main_t *vam = &vat_main;
820 i32 retval = ntohl (mp->retval);
822 vam->retval = retval;
823 vam->regenerate_interface_table = 1;
824 vam->sw_if_index = ntohl (mp->sw_if_index);
825 vam->result_ready = 1;
828 static void vl_api_af_packet_create_reply_t_handler_json
829 (vl_api_af_packet_create_reply_t * mp)
831 vat_main_t *vam = &vat_main;
832 vat_json_node_t node;
834 vat_json_init_object (&node);
835 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
836 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
838 vat_json_print (vam->ofp, &node);
839 vat_json_free (&node);
841 vam->retval = ntohl (mp->retval);
842 vam->result_ready = 1;
845 static void vl_api_create_vlan_subif_reply_t_handler
846 (vl_api_create_vlan_subif_reply_t * mp)
848 vat_main_t *vam = &vat_main;
849 i32 retval = ntohl (mp->retval);
851 vam->retval = retval;
852 vam->regenerate_interface_table = 1;
853 vam->sw_if_index = ntohl (mp->sw_if_index);
854 vam->result_ready = 1;
857 static void vl_api_create_vlan_subif_reply_t_handler_json
858 (vl_api_create_vlan_subif_reply_t * mp)
860 vat_main_t *vam = &vat_main;
861 vat_json_node_t node;
863 vat_json_init_object (&node);
864 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
865 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
867 vat_json_print (vam->ofp, &node);
868 vat_json_free (&node);
870 vam->retval = ntohl (mp->retval);
871 vam->result_ready = 1;
874 static void vl_api_create_subif_reply_t_handler
875 (vl_api_create_subif_reply_t * mp)
877 vat_main_t *vam = &vat_main;
878 i32 retval = ntohl (mp->retval);
880 vam->retval = retval;
881 vam->regenerate_interface_table = 1;
882 vam->sw_if_index = ntohl (mp->sw_if_index);
883 vam->result_ready = 1;
886 static void vl_api_create_subif_reply_t_handler_json
887 (vl_api_create_subif_reply_t * mp)
889 vat_main_t *vam = &vat_main;
890 vat_json_node_t node;
892 vat_json_init_object (&node);
893 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
894 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
896 vat_json_print (vam->ofp, &node);
897 vat_json_free (&node);
899 vam->retval = ntohl (mp->retval);
900 vam->result_ready = 1;
903 static void vl_api_interface_name_renumber_reply_t_handler
904 (vl_api_interface_name_renumber_reply_t * mp)
906 vat_main_t *vam = &vat_main;
907 i32 retval = ntohl (mp->retval);
909 vam->retval = retval;
910 vam->regenerate_interface_table = 1;
911 vam->result_ready = 1;
914 static void vl_api_interface_name_renumber_reply_t_handler_json
915 (vl_api_interface_name_renumber_reply_t * mp)
917 vat_main_t *vam = &vat_main;
918 vat_json_node_t node;
920 vat_json_init_object (&node);
921 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
923 vat_json_print (vam->ofp, &node);
924 vat_json_free (&node);
926 vam->retval = ntohl (mp->retval);
927 vam->result_ready = 1;
931 * Special-case: build the interface table, maintain
932 * the next loopback sw_if_index vbl.
934 static void vl_api_sw_interface_details_t_handler
935 (vl_api_sw_interface_details_t * mp)
937 vat_main_t *vam = &vat_main;
938 u8 *s = format (0, "%s%c", mp->interface_name, 0);
940 hash_set_mem (vam->sw_if_index_by_interface_name, s,
941 ntohl (mp->sw_if_index));
943 /* In sub interface case, fill the sub interface table entry */
944 if (mp->sw_if_index != mp->sup_sw_if_index)
946 sw_interface_subif_t *sub = NULL;
948 vec_add2 (vam->sw_if_subif_table, sub, 1);
950 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
951 strncpy ((char *) sub->interface_name, (char *) s,
952 vec_len (sub->interface_name));
953 sub->sw_if_index = ntohl (mp->sw_if_index);
954 sub->sub_id = ntohl (mp->sub_id);
956 sub->sub_dot1ad = mp->sub_dot1ad;
957 sub->sub_number_of_tags = mp->sub_number_of_tags;
958 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
959 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
960 sub->sub_exact_match = mp->sub_exact_match;
961 sub->sub_default = mp->sub_default;
962 sub->sub_outer_vlan_id_any = mp->sub_outer_vlan_id_any;
963 sub->sub_inner_vlan_id_any = mp->sub_inner_vlan_id_any;
965 /* vlan tag rewrite */
966 sub->vtr_op = ntohl (mp->vtr_op);
967 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
968 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
969 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
973 static void vl_api_sw_interface_details_t_handler_json
974 (vl_api_sw_interface_details_t * mp)
976 vat_main_t *vam = &vat_main;
977 vat_json_node_t *node = NULL;
979 if (VAT_JSON_ARRAY != vam->json_tree.type)
981 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
982 vat_json_init_array (&vam->json_tree);
984 node = vat_json_array_add (&vam->json_tree);
986 vat_json_init_object (node);
987 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
988 vat_json_object_add_uint (node, "sup_sw_if_index",
989 ntohl (mp->sup_sw_if_index));
990 vat_json_object_add_uint (node, "l2_address_length",
991 ntohl (mp->l2_address_length));
992 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
993 sizeof (mp->l2_address));
994 vat_json_object_add_string_copy (node, "interface_name",
996 vat_json_object_add_uint (node, "admin_up_down", mp->admin_up_down);
997 vat_json_object_add_uint (node, "link_up_down", mp->link_up_down);
998 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
999 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
1000 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
1001 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
1002 vat_json_object_add_uint (node, "sub_dot1ad", mp->sub_dot1ad);
1003 vat_json_object_add_uint (node, "sub_number_of_tags",
1004 mp->sub_number_of_tags);
1005 vat_json_object_add_uint (node, "sub_outer_vlan_id",
1006 ntohs (mp->sub_outer_vlan_id));
1007 vat_json_object_add_uint (node, "sub_inner_vlan_id",
1008 ntohs (mp->sub_inner_vlan_id));
1009 vat_json_object_add_uint (node, "sub_exact_match", mp->sub_exact_match);
1010 vat_json_object_add_uint (node, "sub_default", mp->sub_default);
1011 vat_json_object_add_uint (node, "sub_outer_vlan_id_any",
1012 mp->sub_outer_vlan_id_any);
1013 vat_json_object_add_uint (node, "sub_inner_vlan_id_any",
1014 mp->sub_inner_vlan_id_any);
1015 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
1016 vat_json_object_add_uint (node, "vtr_push_dot1q",
1017 ntohl (mp->vtr_push_dot1q));
1018 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
1019 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
1022 vat_json_object_add_string_copy (node, "pbb_vtr_dmac",
1024 format_ethernet_address,
1026 vat_json_object_add_string_copy (node, "pbb_vtr_smac",
1028 format_ethernet_address,
1030 vat_json_object_add_uint (node, "pbb_vtr_b_vlanid", mp->b_vlanid);
1031 vat_json_object_add_uint (node, "pbb_vtr_i_sid", mp->i_sid);
1035 #if VPP_API_TEST_BUILTIN == 0
1036 static void vl_api_sw_interface_event_t_handler
1037 (vl_api_sw_interface_event_t * mp)
1039 vat_main_t *vam = &vat_main;
1040 if (vam->interface_event_display)
1041 errmsg ("interface flags: sw_if_index %d %s %s",
1042 ntohl (mp->sw_if_index),
1043 mp->admin_up_down ? "admin-up" : "admin-down",
1044 mp->link_up_down ? "link-up" : "link-down");
1048 static void vl_api_sw_interface_event_t_handler_json
1049 (vl_api_sw_interface_event_t * mp)
1051 /* JSON output not supported */
1055 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
1057 vat_main_t *vam = &vat_main;
1058 i32 retval = ntohl (mp->retval);
1060 vam->retval = retval;
1061 vam->shmem_result = uword_to_pointer (mp->reply_in_shmem, u8 *);
1062 vam->result_ready = 1;
1066 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
1068 vat_main_t *vam = &vat_main;
1069 vat_json_node_t node;
1070 api_main_t *am = &api_main;
1074 vat_json_init_object (&node);
1075 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1076 vat_json_object_add_uint (&node, "reply_in_shmem",
1077 ntohl (mp->reply_in_shmem));
1078 /* Toss the shared-memory original... */
1079 pthread_mutex_lock (&am->vlib_rp->mutex);
1080 oldheap = svm_push_data_heap (am->vlib_rp);
1082 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
1085 svm_pop_heap (oldheap);
1086 pthread_mutex_unlock (&am->vlib_rp->mutex);
1088 vat_json_print (vam->ofp, &node);
1089 vat_json_free (&node);
1091 vam->retval = ntohl (mp->retval);
1092 vam->result_ready = 1;
1096 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
1098 vat_main_t *vam = &vat_main;
1099 i32 retval = ntohl (mp->retval);
1100 u32 length = vl_api_string_len (&mp->reply);
1102 vec_reset_length (vam->cmd_reply);
1104 vam->retval = retval;
1107 vec_validate (vam->cmd_reply, length);
1108 clib_memcpy ((char *) (vam->cmd_reply),
1109 vl_api_from_api_string (&mp->reply), length);
1110 vam->cmd_reply[length] = 0;
1112 vam->result_ready = 1;
1116 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
1118 vat_main_t *vam = &vat_main;
1119 vat_json_node_t node;
1121 vec_reset_length (vam->cmd_reply);
1123 vat_json_init_object (&node);
1124 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1125 vat_json_object_add_string_copy (&node, "reply",
1126 vl_api_from_api_string (&mp->reply));
1128 vat_json_print (vam->ofp, &node);
1129 vat_json_free (&node);
1131 vam->retval = ntohl (mp->retval);
1132 vam->result_ready = 1;
1135 static void vl_api_classify_add_del_table_reply_t_handler
1136 (vl_api_classify_add_del_table_reply_t * mp)
1138 vat_main_t *vam = &vat_main;
1139 i32 retval = ntohl (mp->retval);
1140 if (vam->async_mode)
1142 vam->async_errors += (retval < 0);
1146 vam->retval = retval;
1148 ((mp->new_table_index != 0xFFFFFFFF) ||
1149 (mp->skip_n_vectors != 0xFFFFFFFF) ||
1150 (mp->match_n_vectors != 0xFFFFFFFF)))
1152 * Note: this is just barely thread-safe, depends on
1153 * the main thread spinning waiting for an answer...
1155 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d",
1156 ntohl (mp->new_table_index),
1157 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
1158 vam->result_ready = 1;
1162 static void vl_api_classify_add_del_table_reply_t_handler_json
1163 (vl_api_classify_add_del_table_reply_t * mp)
1165 vat_main_t *vam = &vat_main;
1166 vat_json_node_t node;
1168 vat_json_init_object (&node);
1169 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1170 vat_json_object_add_uint (&node, "new_table_index",
1171 ntohl (mp->new_table_index));
1172 vat_json_object_add_uint (&node, "skip_n_vectors",
1173 ntohl (mp->skip_n_vectors));
1174 vat_json_object_add_uint (&node, "match_n_vectors",
1175 ntohl (mp->match_n_vectors));
1177 vat_json_print (vam->ofp, &node);
1178 vat_json_free (&node);
1180 vam->retval = ntohl (mp->retval);
1181 vam->result_ready = 1;
1184 static void vl_api_get_node_index_reply_t_handler
1185 (vl_api_get_node_index_reply_t * mp)
1187 vat_main_t *vam = &vat_main;
1188 i32 retval = ntohl (mp->retval);
1189 if (vam->async_mode)
1191 vam->async_errors += (retval < 0);
1195 vam->retval = retval;
1197 errmsg ("node index %d", ntohl (mp->node_index));
1198 vam->result_ready = 1;
1202 static void vl_api_get_node_index_reply_t_handler_json
1203 (vl_api_get_node_index_reply_t * mp)
1205 vat_main_t *vam = &vat_main;
1206 vat_json_node_t node;
1208 vat_json_init_object (&node);
1209 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1210 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1212 vat_json_print (vam->ofp, &node);
1213 vat_json_free (&node);
1215 vam->retval = ntohl (mp->retval);
1216 vam->result_ready = 1;
1219 static void vl_api_get_next_index_reply_t_handler
1220 (vl_api_get_next_index_reply_t * mp)
1222 vat_main_t *vam = &vat_main;
1223 i32 retval = ntohl (mp->retval);
1224 if (vam->async_mode)
1226 vam->async_errors += (retval < 0);
1230 vam->retval = retval;
1232 errmsg ("next node index %d", ntohl (mp->next_index));
1233 vam->result_ready = 1;
1237 static void vl_api_get_next_index_reply_t_handler_json
1238 (vl_api_get_next_index_reply_t * mp)
1240 vat_main_t *vam = &vat_main;
1241 vat_json_node_t node;
1243 vat_json_init_object (&node);
1244 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1245 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1247 vat_json_print (vam->ofp, &node);
1248 vat_json_free (&node);
1250 vam->retval = ntohl (mp->retval);
1251 vam->result_ready = 1;
1254 static void vl_api_add_node_next_reply_t_handler
1255 (vl_api_add_node_next_reply_t * mp)
1257 vat_main_t *vam = &vat_main;
1258 i32 retval = ntohl (mp->retval);
1259 if (vam->async_mode)
1261 vam->async_errors += (retval < 0);
1265 vam->retval = retval;
1267 errmsg ("next index %d", ntohl (mp->next_index));
1268 vam->result_ready = 1;
1272 static void vl_api_add_node_next_reply_t_handler_json
1273 (vl_api_add_node_next_reply_t * mp)
1275 vat_main_t *vam = &vat_main;
1276 vat_json_node_t node;
1278 vat_json_init_object (&node);
1279 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1280 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1282 vat_json_print (vam->ofp, &node);
1283 vat_json_free (&node);
1285 vam->retval = ntohl (mp->retval);
1286 vam->result_ready = 1;
1289 static void vl_api_show_version_reply_t_handler
1290 (vl_api_show_version_reply_t * mp)
1292 vat_main_t *vam = &vat_main;
1293 i32 retval = ntohl (mp->retval);
1298 char *p = (char *) &mp->program;
1300 s = vl_api_from_api_string_c ((vl_api_string_t *) p);
1301 errmsg (" program: %s\n", s);
1305 vl_api_string_len ((vl_api_string_t *) p) + sizeof (vl_api_string_t);
1306 s = vl_api_from_api_string_c ((vl_api_string_t *) p);
1307 errmsg (" version: %s\n", s);
1311 vl_api_string_len ((vl_api_string_t *) p) + sizeof (vl_api_string_t);
1312 s = vl_api_from_api_string_c ((vl_api_string_t *) p);
1313 errmsg (" build date: %s\n", s);
1317 vl_api_string_len ((vl_api_string_t *) p) + sizeof (vl_api_string_t);
1318 s = vl_api_from_api_string_c ((vl_api_string_t *) p);
1319 errmsg ("build directory: %s\n", s);
1322 vam->retval = retval;
1323 vam->result_ready = 1;
1326 static void vl_api_show_version_reply_t_handler_json
1327 (vl_api_show_version_reply_t * mp)
1329 vat_main_t *vam = &vat_main;
1330 vat_json_node_t node;
1332 vat_json_init_object (&node);
1333 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1334 char *p = (char *) &mp->program;
1335 vat_json_object_add_string_copy (&node, "program",
1336 vl_api_from_api_string ((vl_api_string_t *)
1338 p += vl_api_string_len ((vl_api_string_t *) p) + sizeof (u32);
1339 vat_json_object_add_string_copy (&node, "version",
1340 vl_api_from_api_string ((vl_api_string_t *)
1342 p += vl_api_string_len ((vl_api_string_t *) p) + sizeof (u32);
1343 vat_json_object_add_string_copy (&node, "build_date",
1344 vl_api_from_api_string ((vl_api_string_t *)
1346 p += vl_api_string_len ((vl_api_string_t *) p) + sizeof (u32);
1347 vat_json_object_add_string_copy (&node, "build_directory",
1348 vl_api_from_api_string ((vl_api_string_t *)
1351 vat_json_print (vam->ofp, &node);
1352 vat_json_free (&node);
1354 vam->retval = ntohl (mp->retval);
1355 vam->result_ready = 1;
1358 static void vl_api_show_threads_reply_t_handler
1359 (vl_api_show_threads_reply_t * mp)
1361 vat_main_t *vam = &vat_main;
1362 i32 retval = ntohl (mp->retval);
1366 count = ntohl (mp->count);
1368 for (i = 0; i < count; i++)
1370 "\n%-2d %-11s %-11s %-5d %-6d %-4d %-6d",
1371 ntohl (mp->thread_data[i].id), mp->thread_data[i].name,
1372 mp->thread_data[i].type, ntohl (mp->thread_data[i].pid),
1373 ntohl (mp->thread_data[i].cpu_id), ntohl (mp->thread_data[i].core),
1374 ntohl (mp->thread_data[i].cpu_socket));
1376 vam->retval = retval;
1377 vam->result_ready = 1;
1380 static void vl_api_show_threads_reply_t_handler_json
1381 (vl_api_show_threads_reply_t * mp)
1383 vat_main_t *vam = &vat_main;
1384 vat_json_node_t node;
1385 vl_api_thread_data_t *td;
1386 i32 retval = ntohl (mp->retval);
1390 count = ntohl (mp->count);
1392 vat_json_init_object (&node);
1393 vat_json_object_add_int (&node, "retval", retval);
1394 vat_json_object_add_uint (&node, "count", count);
1396 for (i = 0; i < count; i++)
1398 td = &mp->thread_data[i];
1399 vat_json_object_add_uint (&node, "id", ntohl (td->id));
1400 vat_json_object_add_string_copy (&node, "name", td->name);
1401 vat_json_object_add_string_copy (&node, "type", td->type);
1402 vat_json_object_add_uint (&node, "pid", ntohl (td->pid));
1403 vat_json_object_add_int (&node, "cpu_id", ntohl (td->cpu_id));
1404 vat_json_object_add_int (&node, "core", ntohl (td->id));
1405 vat_json_object_add_int (&node, "cpu_socket", ntohl (td->cpu_socket));
1408 vat_json_print (vam->ofp, &node);
1409 vat_json_free (&node);
1411 vam->retval = retval;
1412 vam->result_ready = 1;
1416 api_show_threads (vat_main_t * vam)
1418 vl_api_show_threads_t *mp;
1422 "\n%-2s %-11s %-11s %-5s %-6s %-4s %-6s",
1423 "ID", "Name", "Type", "LWP", "cpu_id", "Core", "Socket");
1425 M (SHOW_THREADS, mp);
1433 vl_api_ip4_arp_event_t_handler (vl_api_ip4_arp_event_t * mp)
1435 u32 sw_if_index = ntohl (mp->sw_if_index);
1436 errmsg ("arp %s event: pid %d address %U new mac %U sw_if_index %d\n",
1437 mp->mac_ip ? "mac/ip binding" : "address resolution",
1438 ntohl (mp->pid), format_ip4_address, mp->ip,
1439 format_vl_api_mac_address, &mp->mac, sw_if_index);
1443 vl_api_ip4_arp_event_t_handler_json (vl_api_ip4_arp_event_t * mp)
1445 /* JSON output not supported */
1449 vl_api_ip6_nd_event_t_handler (vl_api_ip6_nd_event_t * mp)
1451 u32 sw_if_index = ntohl (mp->sw_if_index);
1452 errmsg ("ip6 nd %s event: pid %d address %U new mac %U sw_if_index %d\n",
1453 mp->mac_ip ? "mac/ip binding" : "address resolution",
1454 ntohl (mp->pid), format_vl_api_ip6_address, mp->ip,
1455 format_vl_api_mac_address, mp->mac, sw_if_index);
1459 vl_api_ip6_nd_event_t_handler_json (vl_api_ip6_nd_event_t * mp)
1461 /* JSON output not supported */
1465 vl_api_l2_macs_event_t_handler (vl_api_l2_macs_event_t * mp)
1467 u32 n_macs = ntohl (mp->n_macs);
1468 errmsg ("L2MAC event received with pid %d cl-idx %d for %d macs: \n",
1469 ntohl (mp->pid), mp->client_index, n_macs);
1471 for (i = 0; i < n_macs; i++)
1473 vl_api_mac_entry_t *mac = &mp->mac[i];
1474 errmsg (" [%d] sw_if_index %d mac_addr %U action %d \n",
1475 i + 1, ntohl (mac->sw_if_index),
1476 format_ethernet_address, mac->mac_addr, mac->action);
1483 vl_api_l2_macs_event_t_handler_json (vl_api_l2_macs_event_t * mp)
1485 /* JSON output not supported */
1488 #define vl_api_bridge_domain_details_t_endian vl_noop_handler
1489 #define vl_api_bridge_domain_details_t_print vl_noop_handler
1492 * Special-case: build the bridge domain table, maintain
1493 * the next bd id vbl.
1495 static void vl_api_bridge_domain_details_t_handler
1496 (vl_api_bridge_domain_details_t * mp)
1498 vat_main_t *vam = &vat_main;
1499 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1502 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-6s %-3s",
1503 " ID", "LRN", "FWD", "FLD", "BVI", "UU-FWD", "#IF");
1505 print (vam->ofp, "%3d %3d %3d %3d %3d %6d %3d",
1506 ntohl (mp->bd_id), mp->learn, mp->forward,
1507 mp->flood, ntohl (mp->bvi_sw_if_index),
1508 ntohl (mp->uu_fwd_sw_if_index), n_sw_ifs);
1512 vl_api_bridge_domain_sw_if_t *sw_ifs;
1513 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG",
1516 sw_ifs = mp->sw_if_details;
1517 for (i = 0; i < n_sw_ifs; i++)
1523 sw_if_index = ntohl (sw_ifs->sw_if_index);
1526 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1528 if ((u32) p->value[0] == sw_if_index)
1530 sw_if_name = (u8 *)(p->key);
1535 print (vam->ofp, "%7d %3d %s", sw_if_index,
1536 sw_ifs->shg, sw_if_name ? (char *) sw_if_name :
1537 "sw_if_index not found!");
1544 static void vl_api_bridge_domain_details_t_handler_json
1545 (vl_api_bridge_domain_details_t * mp)
1547 vat_main_t *vam = &vat_main;
1548 vat_json_node_t *node, *array = NULL;
1549 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1551 if (VAT_JSON_ARRAY != vam->json_tree.type)
1553 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1554 vat_json_init_array (&vam->json_tree);
1556 node = vat_json_array_add (&vam->json_tree);
1558 vat_json_init_object (node);
1559 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1560 vat_json_object_add_uint (node, "flood", mp->flood);
1561 vat_json_object_add_uint (node, "forward", mp->forward);
1562 vat_json_object_add_uint (node, "learn", mp->learn);
1563 vat_json_object_add_uint (node, "bvi_sw_if_index",
1564 ntohl (mp->bvi_sw_if_index));
1565 vat_json_object_add_uint (node, "n_sw_ifs", n_sw_ifs);
1566 array = vat_json_object_add (node, "sw_if");
1567 vat_json_init_array (array);
1573 vl_api_bridge_domain_sw_if_t *sw_ifs;
1576 sw_ifs = mp->sw_if_details;
1577 for (i = 0; i < n_sw_ifs; i++)
1579 node = vat_json_array_add (array);
1580 vat_json_init_object (node);
1581 vat_json_object_add_uint (node, "sw_if_index",
1582 ntohl (sw_ifs->sw_if_index));
1583 vat_json_object_add_uint (node, "shg", sw_ifs->shg);
1589 static void vl_api_control_ping_reply_t_handler
1590 (vl_api_control_ping_reply_t * mp)
1592 vat_main_t *vam = &vat_main;
1593 i32 retval = ntohl (mp->retval);
1594 if (vam->async_mode)
1596 vam->async_errors += (retval < 0);
1600 vam->retval = retval;
1601 vam->result_ready = 1;
1603 if (vam->socket_client_main)
1604 vam->socket_client_main->control_pings_outstanding--;
1607 static void vl_api_control_ping_reply_t_handler_json
1608 (vl_api_control_ping_reply_t * mp)
1610 vat_main_t *vam = &vat_main;
1611 i32 retval = ntohl (mp->retval);
1613 if (VAT_JSON_NONE != vam->json_tree.type)
1615 vat_json_print (vam->ofp, &vam->json_tree);
1616 vat_json_free (&vam->json_tree);
1617 vam->json_tree.type = VAT_JSON_NONE;
1622 vat_json_init_array (&vam->json_tree);
1623 vat_json_print (vam->ofp, &vam->json_tree);
1624 vam->json_tree.type = VAT_JSON_NONE;
1627 vam->retval = retval;
1628 vam->result_ready = 1;
1632 vl_api_bridge_domain_set_mac_age_reply_t_handler
1633 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1635 vat_main_t *vam = &vat_main;
1636 i32 retval = ntohl (mp->retval);
1637 if (vam->async_mode)
1639 vam->async_errors += (retval < 0);
1643 vam->retval = retval;
1644 vam->result_ready = 1;
1648 static void vl_api_bridge_domain_set_mac_age_reply_t_handler_json
1649 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1651 vat_main_t *vam = &vat_main;
1652 vat_json_node_t node;
1654 vat_json_init_object (&node);
1655 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1657 vat_json_print (vam->ofp, &node);
1658 vat_json_free (&node);
1660 vam->retval = ntohl (mp->retval);
1661 vam->result_ready = 1;
1665 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1667 vat_main_t *vam = &vat_main;
1668 i32 retval = ntohl (mp->retval);
1669 if (vam->async_mode)
1671 vam->async_errors += (retval < 0);
1675 vam->retval = retval;
1676 vam->result_ready = 1;
1680 static void vl_api_l2_flags_reply_t_handler_json
1681 (vl_api_l2_flags_reply_t * mp)
1683 vat_main_t *vam = &vat_main;
1684 vat_json_node_t node;
1686 vat_json_init_object (&node);
1687 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1688 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1689 ntohl (mp->resulting_feature_bitmap));
1691 vat_json_print (vam->ofp, &node);
1692 vat_json_free (&node);
1694 vam->retval = ntohl (mp->retval);
1695 vam->result_ready = 1;
1698 static void vl_api_bridge_flags_reply_t_handler
1699 (vl_api_bridge_flags_reply_t * mp)
1701 vat_main_t *vam = &vat_main;
1702 i32 retval = ntohl (mp->retval);
1703 if (vam->async_mode)
1705 vam->async_errors += (retval < 0);
1709 vam->retval = retval;
1710 vam->result_ready = 1;
1714 static void vl_api_bridge_flags_reply_t_handler_json
1715 (vl_api_bridge_flags_reply_t * mp)
1717 vat_main_t *vam = &vat_main;
1718 vat_json_node_t node;
1720 vat_json_init_object (&node);
1721 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1722 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1723 ntohl (mp->resulting_feature_bitmap));
1725 vat_json_print (vam->ofp, &node);
1726 vat_json_free (&node);
1728 vam->retval = ntohl (mp->retval);
1729 vam->result_ready = 1;
1733 vl_api_tap_create_v2_reply_t_handler (vl_api_tap_create_v2_reply_t * mp)
1735 vat_main_t *vam = &vat_main;
1736 i32 retval = ntohl (mp->retval);
1737 if (vam->async_mode)
1739 vam->async_errors += (retval < 0);
1743 vam->retval = retval;
1744 vam->sw_if_index = ntohl (mp->sw_if_index);
1745 vam->result_ready = 1;
1750 static void vl_api_tap_create_v2_reply_t_handler_json
1751 (vl_api_tap_create_v2_reply_t * mp)
1753 vat_main_t *vam = &vat_main;
1754 vat_json_node_t node;
1756 vat_json_init_object (&node);
1757 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1758 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1760 vat_json_print (vam->ofp, &node);
1761 vat_json_free (&node);
1763 vam->retval = ntohl (mp->retval);
1764 vam->result_ready = 1;
1769 vl_api_tap_delete_v2_reply_t_handler (vl_api_tap_delete_v2_reply_t * mp)
1771 vat_main_t *vam = &vat_main;
1772 i32 retval = ntohl (mp->retval);
1773 if (vam->async_mode)
1775 vam->async_errors += (retval < 0);
1779 vam->retval = retval;
1780 vam->result_ready = 1;
1784 static void vl_api_tap_delete_v2_reply_t_handler_json
1785 (vl_api_tap_delete_v2_reply_t * mp)
1787 vat_main_t *vam = &vat_main;
1788 vat_json_node_t node;
1790 vat_json_init_object (&node);
1791 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1793 vat_json_print (vam->ofp, &node);
1794 vat_json_free (&node);
1796 vam->retval = ntohl (mp->retval);
1797 vam->result_ready = 1;
1801 vl_api_virtio_pci_create_reply_t_handler (vl_api_virtio_pci_create_reply_t *
1804 vat_main_t *vam = &vat_main;
1805 i32 retval = ntohl (mp->retval);
1806 if (vam->async_mode)
1808 vam->async_errors += (retval < 0);
1812 vam->retval = retval;
1813 vam->sw_if_index = ntohl (mp->sw_if_index);
1814 vam->result_ready = 1;
1818 static void vl_api_virtio_pci_create_reply_t_handler_json
1819 (vl_api_virtio_pci_create_reply_t * mp)
1821 vat_main_t *vam = &vat_main;
1822 vat_json_node_t node;
1824 vat_json_init_object (&node);
1825 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1826 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1828 vat_json_print (vam->ofp, &node);
1829 vat_json_free (&node);
1831 vam->retval = ntohl (mp->retval);
1832 vam->result_ready = 1;
1837 vl_api_virtio_pci_delete_reply_t_handler (vl_api_virtio_pci_delete_reply_t *
1840 vat_main_t *vam = &vat_main;
1841 i32 retval = ntohl (mp->retval);
1842 if (vam->async_mode)
1844 vam->async_errors += (retval < 0);
1848 vam->retval = retval;
1849 vam->result_ready = 1;
1853 static void vl_api_virtio_pci_delete_reply_t_handler_json
1854 (vl_api_virtio_pci_delete_reply_t * mp)
1856 vat_main_t *vam = &vat_main;
1857 vat_json_node_t node;
1859 vat_json_init_object (&node);
1860 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1862 vat_json_print (vam->ofp, &node);
1863 vat_json_free (&node);
1865 vam->retval = ntohl (mp->retval);
1866 vam->result_ready = 1;
1870 vl_api_bond_create_reply_t_handler (vl_api_bond_create_reply_t * mp)
1872 vat_main_t *vam = &vat_main;
1873 i32 retval = ntohl (mp->retval);
1875 if (vam->async_mode)
1877 vam->async_errors += (retval < 0);
1881 vam->retval = retval;
1882 vam->sw_if_index = ntohl (mp->sw_if_index);
1883 vam->result_ready = 1;
1887 static void vl_api_bond_create_reply_t_handler_json
1888 (vl_api_bond_create_reply_t * mp)
1890 vat_main_t *vam = &vat_main;
1891 vat_json_node_t node;
1893 vat_json_init_object (&node);
1894 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1895 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1897 vat_json_print (vam->ofp, &node);
1898 vat_json_free (&node);
1900 vam->retval = ntohl (mp->retval);
1901 vam->result_ready = 1;
1905 vl_api_bond_delete_reply_t_handler (vl_api_bond_delete_reply_t * mp)
1907 vat_main_t *vam = &vat_main;
1908 i32 retval = ntohl (mp->retval);
1910 if (vam->async_mode)
1912 vam->async_errors += (retval < 0);
1916 vam->retval = retval;
1917 vam->result_ready = 1;
1921 static void vl_api_bond_delete_reply_t_handler_json
1922 (vl_api_bond_delete_reply_t * mp)
1924 vat_main_t *vam = &vat_main;
1925 vat_json_node_t node;
1927 vat_json_init_object (&node);
1928 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1930 vat_json_print (vam->ofp, &node);
1931 vat_json_free (&node);
1933 vam->retval = ntohl (mp->retval);
1934 vam->result_ready = 1;
1938 vl_api_bond_enslave_reply_t_handler (vl_api_bond_enslave_reply_t * mp)
1940 vat_main_t *vam = &vat_main;
1941 i32 retval = ntohl (mp->retval);
1943 if (vam->async_mode)
1945 vam->async_errors += (retval < 0);
1949 vam->retval = retval;
1950 vam->result_ready = 1;
1954 static void vl_api_bond_enslave_reply_t_handler_json
1955 (vl_api_bond_enslave_reply_t * mp)
1957 vat_main_t *vam = &vat_main;
1958 vat_json_node_t node;
1960 vat_json_init_object (&node);
1961 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1963 vat_json_print (vam->ofp, &node);
1964 vat_json_free (&node);
1966 vam->retval = ntohl (mp->retval);
1967 vam->result_ready = 1;
1971 vl_api_bond_detach_slave_reply_t_handler (vl_api_bond_detach_slave_reply_t *
1974 vat_main_t *vam = &vat_main;
1975 i32 retval = ntohl (mp->retval);
1977 if (vam->async_mode)
1979 vam->async_errors += (retval < 0);
1983 vam->retval = retval;
1984 vam->result_ready = 1;
1988 static void vl_api_bond_detach_slave_reply_t_handler_json
1989 (vl_api_bond_detach_slave_reply_t * mp)
1991 vat_main_t *vam = &vat_main;
1992 vat_json_node_t node;
1994 vat_json_init_object (&node);
1995 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1997 vat_json_print (vam->ofp, &node);
1998 vat_json_free (&node);
2000 vam->retval = ntohl (mp->retval);
2001 vam->result_ready = 1;
2004 static void vl_api_sw_interface_bond_details_t_handler
2005 (vl_api_sw_interface_bond_details_t * mp)
2007 vat_main_t *vam = &vat_main;
2010 "%-16s %-12d %-12U %-13U %-14u %-14u",
2011 mp->interface_name, ntohl (mp->sw_if_index),
2012 format_bond_mode, mp->mode, format_bond_load_balance, mp->lb,
2013 ntohl (mp->active_slaves), ntohl (mp->slaves));
2016 static void vl_api_sw_interface_bond_details_t_handler_json
2017 (vl_api_sw_interface_bond_details_t * mp)
2019 vat_main_t *vam = &vat_main;
2020 vat_json_node_t *node = NULL;
2022 if (VAT_JSON_ARRAY != vam->json_tree.type)
2024 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2025 vat_json_init_array (&vam->json_tree);
2027 node = vat_json_array_add (&vam->json_tree);
2029 vat_json_init_object (node);
2030 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2031 vat_json_object_add_string_copy (node, "interface_name",
2032 mp->interface_name);
2033 vat_json_object_add_uint (node, "mode", mp->mode);
2034 vat_json_object_add_uint (node, "load_balance", mp->lb);
2035 vat_json_object_add_uint (node, "active_slaves", ntohl (mp->active_slaves));
2036 vat_json_object_add_uint (node, "slaves", ntohl (mp->slaves));
2040 api_sw_interface_bond_dump (vat_main_t * vam)
2042 vl_api_sw_interface_bond_dump_t *mp;
2043 vl_api_control_ping_t *mp_ping;
2047 "\n%-16s %-12s %-12s %-13s %-14s %-14s",
2048 "interface name", "sw_if_index", "mode", "load balance",
2049 "active slaves", "slaves");
2051 /* Get list of bond interfaces */
2052 M (SW_INTERFACE_BOND_DUMP, mp);
2055 /* Use a control ping for synchronization */
2056 MPING (CONTROL_PING, mp_ping);
2063 static void vl_api_sw_interface_slave_details_t_handler
2064 (vl_api_sw_interface_slave_details_t * mp)
2066 vat_main_t *vam = &vat_main;
2069 "%-25s %-12d %-12d %d", mp->interface_name,
2070 ntohl (mp->sw_if_index), mp->is_passive, mp->is_long_timeout);
2073 static void vl_api_sw_interface_slave_details_t_handler_json
2074 (vl_api_sw_interface_slave_details_t * mp)
2076 vat_main_t *vam = &vat_main;
2077 vat_json_node_t *node = NULL;
2079 if (VAT_JSON_ARRAY != vam->json_tree.type)
2081 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2082 vat_json_init_array (&vam->json_tree);
2084 node = vat_json_array_add (&vam->json_tree);
2086 vat_json_init_object (node);
2087 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2088 vat_json_object_add_string_copy (node, "interface_name",
2089 mp->interface_name);
2090 vat_json_object_add_uint (node, "passive", mp->is_passive);
2091 vat_json_object_add_uint (node, "long_timeout", mp->is_long_timeout);
2095 api_sw_interface_slave_dump (vat_main_t * vam)
2097 unformat_input_t *i = vam->input;
2098 vl_api_sw_interface_slave_dump_t *mp;
2099 vl_api_control_ping_t *mp_ping;
2100 u32 sw_if_index = ~0;
2101 u8 sw_if_index_set = 0;
2104 /* Parse args required to build the message */
2105 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2107 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2108 sw_if_index_set = 1;
2109 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2110 sw_if_index_set = 1;
2115 if (sw_if_index_set == 0)
2117 errmsg ("missing vpp interface name. ");
2122 "\n%-25s %-12s %-12s %s",
2123 "slave interface name", "sw_if_index", "passive", "long_timeout");
2125 /* Get list of bond interfaces */
2126 M (SW_INTERFACE_SLAVE_DUMP, mp);
2127 mp->sw_if_index = ntohl (sw_if_index);
2130 /* Use a control ping for synchronization */
2131 MPING (CONTROL_PING, mp_ping);
2138 static void vl_api_mpls_tunnel_add_del_reply_t_handler
2139 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2141 vat_main_t *vam = &vat_main;
2142 i32 retval = ntohl (mp->retval);
2143 if (vam->async_mode)
2145 vam->async_errors += (retval < 0);
2149 vam->retval = retval;
2150 vam->sw_if_index = ntohl (mp->sw_if_index);
2151 vam->result_ready = 1;
2153 vam->regenerate_interface_table = 1;
2156 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
2157 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2159 vat_main_t *vam = &vat_main;
2160 vat_json_node_t node;
2162 vat_json_init_object (&node);
2163 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2164 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
2165 ntohl (mp->sw_if_index));
2167 vat_json_print (vam->ofp, &node);
2168 vat_json_free (&node);
2170 vam->retval = ntohl (mp->retval);
2171 vam->result_ready = 1;
2174 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
2175 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2177 vat_main_t *vam = &vat_main;
2178 i32 retval = ntohl (mp->retval);
2179 if (vam->async_mode)
2181 vam->async_errors += (retval < 0);
2185 vam->retval = retval;
2186 vam->sw_if_index = ntohl (mp->sw_if_index);
2187 vam->result_ready = 1;
2191 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
2192 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2194 vat_main_t *vam = &vat_main;
2195 vat_json_node_t node;
2197 vat_json_init_object (&node);
2198 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2199 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2201 vat_json_print (vam->ofp, &node);
2202 vat_json_free (&node);
2204 vam->retval = ntohl (mp->retval);
2205 vam->result_ready = 1;
2208 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler
2209 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2211 vat_main_t *vam = &vat_main;
2212 i32 retval = ntohl (mp->retval);
2213 if (vam->async_mode)
2215 vam->async_errors += (retval < 0);
2219 vam->retval = retval;
2220 vam->result_ready = 1;
2224 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler_json
2225 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2227 vat_main_t *vam = &vat_main;
2228 vat_json_node_t node;
2230 vat_json_init_object (&node);
2231 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2232 vat_json_object_add_uint (&node, "fwd_entry_index",
2233 clib_net_to_host_u32 (mp->fwd_entry_index));
2235 vat_json_print (vam->ofp, &node);
2236 vat_json_free (&node);
2238 vam->retval = ntohl (mp->retval);
2239 vam->result_ready = 1;
2243 format_lisp_transport_protocol (u8 * s, va_list * args)
2245 u32 proto = va_arg (*args, u32);
2250 return format (s, "udp");
2252 return format (s, "api");
2259 static void vl_api_one_get_transport_protocol_reply_t_handler
2260 (vl_api_one_get_transport_protocol_reply_t * mp)
2262 vat_main_t *vam = &vat_main;
2263 i32 retval = ntohl (mp->retval);
2264 if (vam->async_mode)
2266 vam->async_errors += (retval < 0);
2270 u32 proto = mp->protocol;
2271 print (vam->ofp, "Transport protocol: %U",
2272 format_lisp_transport_protocol, proto);
2273 vam->retval = retval;
2274 vam->result_ready = 1;
2278 static void vl_api_one_get_transport_protocol_reply_t_handler_json
2279 (vl_api_one_get_transport_protocol_reply_t * mp)
2281 vat_main_t *vam = &vat_main;
2282 vat_json_node_t node;
2285 s = format (0, "%U", format_lisp_transport_protocol, mp->protocol);
2288 vat_json_init_object (&node);
2289 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2290 vat_json_object_add_string_copy (&node, "transport-protocol", s);
2293 vat_json_print (vam->ofp, &node);
2294 vat_json_free (&node);
2296 vam->retval = ntohl (mp->retval);
2297 vam->result_ready = 1;
2300 static void vl_api_one_add_del_locator_set_reply_t_handler
2301 (vl_api_one_add_del_locator_set_reply_t * mp)
2303 vat_main_t *vam = &vat_main;
2304 i32 retval = ntohl (mp->retval);
2305 if (vam->async_mode)
2307 vam->async_errors += (retval < 0);
2311 vam->retval = retval;
2312 vam->result_ready = 1;
2316 static void vl_api_one_add_del_locator_set_reply_t_handler_json
2317 (vl_api_one_add_del_locator_set_reply_t * mp)
2319 vat_main_t *vam = &vat_main;
2320 vat_json_node_t node;
2322 vat_json_init_object (&node);
2323 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2324 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
2326 vat_json_print (vam->ofp, &node);
2327 vat_json_free (&node);
2329 vam->retval = ntohl (mp->retval);
2330 vam->result_ready = 1;
2333 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
2334 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2336 vat_main_t *vam = &vat_main;
2337 i32 retval = ntohl (mp->retval);
2338 if (vam->async_mode)
2340 vam->async_errors += (retval < 0);
2344 vam->retval = retval;
2345 vam->sw_if_index = ntohl (mp->sw_if_index);
2346 vam->result_ready = 1;
2348 vam->regenerate_interface_table = 1;
2351 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
2352 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2354 vat_main_t *vam = &vat_main;
2355 vat_json_node_t node;
2357 vat_json_init_object (&node);
2358 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2359 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2361 vat_json_print (vam->ofp, &node);
2362 vat_json_free (&node);
2364 vam->retval = ntohl (mp->retval);
2365 vam->result_ready = 1;
2368 static void vl_api_vxlan_offload_rx_reply_t_handler
2369 (vl_api_vxlan_offload_rx_reply_t * mp)
2371 vat_main_t *vam = &vat_main;
2372 i32 retval = ntohl (mp->retval);
2373 if (vam->async_mode)
2375 vam->async_errors += (retval < 0);
2379 vam->retval = retval;
2380 vam->result_ready = 1;
2384 static void vl_api_vxlan_offload_rx_reply_t_handler_json
2385 (vl_api_vxlan_offload_rx_reply_t * mp)
2387 vat_main_t *vam = &vat_main;
2388 vat_json_node_t node;
2390 vat_json_init_object (&node);
2391 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2393 vat_json_print (vam->ofp, &node);
2394 vat_json_free (&node);
2396 vam->retval = ntohl (mp->retval);
2397 vam->result_ready = 1;
2400 static void vl_api_geneve_add_del_tunnel_reply_t_handler
2401 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2403 vat_main_t *vam = &vat_main;
2404 i32 retval = ntohl (mp->retval);
2405 if (vam->async_mode)
2407 vam->async_errors += (retval < 0);
2411 vam->retval = retval;
2412 vam->sw_if_index = ntohl (mp->sw_if_index);
2413 vam->result_ready = 1;
2417 static void vl_api_geneve_add_del_tunnel_reply_t_handler_json
2418 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2420 vat_main_t *vam = &vat_main;
2421 vat_json_node_t node;
2423 vat_json_init_object (&node);
2424 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2425 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2427 vat_json_print (vam->ofp, &node);
2428 vat_json_free (&node);
2430 vam->retval = ntohl (mp->retval);
2431 vam->result_ready = 1;
2434 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler
2435 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2437 vat_main_t *vam = &vat_main;
2438 i32 retval = ntohl (mp->retval);
2439 if (vam->async_mode)
2441 vam->async_errors += (retval < 0);
2445 vam->retval = retval;
2446 vam->sw_if_index = ntohl (mp->sw_if_index);
2447 vam->result_ready = 1;
2449 vam->regenerate_interface_table = 1;
2452 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler_json
2453 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2455 vat_main_t *vam = &vat_main;
2456 vat_json_node_t node;
2458 vat_json_init_object (&node);
2459 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2460 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2462 vat_json_print (vam->ofp, &node);
2463 vat_json_free (&node);
2465 vam->retval = ntohl (mp->retval);
2466 vam->result_ready = 1;
2469 static void vl_api_gre_tunnel_add_del_reply_t_handler
2470 (vl_api_gre_tunnel_add_del_reply_t * mp)
2472 vat_main_t *vam = &vat_main;
2473 i32 retval = ntohl (mp->retval);
2474 if (vam->async_mode)
2476 vam->async_errors += (retval < 0);
2480 vam->retval = retval;
2481 vam->sw_if_index = ntohl (mp->sw_if_index);
2482 vam->result_ready = 1;
2486 static void vl_api_gre_tunnel_add_del_reply_t_handler_json
2487 (vl_api_gre_tunnel_add_del_reply_t * mp)
2489 vat_main_t *vam = &vat_main;
2490 vat_json_node_t node;
2492 vat_json_init_object (&node);
2493 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2494 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2496 vat_json_print (vam->ofp, &node);
2497 vat_json_free (&node);
2499 vam->retval = ntohl (mp->retval);
2500 vam->result_ready = 1;
2503 static void vl_api_create_vhost_user_if_reply_t_handler
2504 (vl_api_create_vhost_user_if_reply_t * mp)
2506 vat_main_t *vam = &vat_main;
2507 i32 retval = ntohl (mp->retval);
2508 if (vam->async_mode)
2510 vam->async_errors += (retval < 0);
2514 vam->retval = retval;
2515 vam->sw_if_index = ntohl (mp->sw_if_index);
2516 vam->result_ready = 1;
2518 vam->regenerate_interface_table = 1;
2521 static void vl_api_create_vhost_user_if_reply_t_handler_json
2522 (vl_api_create_vhost_user_if_reply_t * mp)
2524 vat_main_t *vam = &vat_main;
2525 vat_json_node_t node;
2527 vat_json_init_object (&node);
2528 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2529 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2531 vat_json_print (vam->ofp, &node);
2532 vat_json_free (&node);
2534 vam->retval = ntohl (mp->retval);
2535 vam->result_ready = 1;
2538 static void vl_api_dns_resolve_name_reply_t_handler
2539 (vl_api_dns_resolve_name_reply_t * mp)
2541 vat_main_t *vam = &vat_main;
2542 i32 retval = ntohl (mp->retval);
2543 if (vam->async_mode)
2545 vam->async_errors += (retval < 0);
2549 vam->retval = retval;
2550 vam->result_ready = 1;
2555 clib_warning ("ip4 address %U", format_ip4_address,
2556 (ip4_address_t *) mp->ip4_address);
2558 clib_warning ("ip6 address %U", format_ip6_address,
2559 (ip6_address_t *) mp->ip6_address);
2562 clib_warning ("retval %d", retval);
2566 static void vl_api_dns_resolve_name_reply_t_handler_json
2567 (vl_api_dns_resolve_name_reply_t * mp)
2569 clib_warning ("not implemented");
2572 static void vl_api_dns_resolve_ip_reply_t_handler
2573 (vl_api_dns_resolve_ip_reply_t * mp)
2575 vat_main_t *vam = &vat_main;
2576 i32 retval = ntohl (mp->retval);
2577 if (vam->async_mode)
2579 vam->async_errors += (retval < 0);
2583 vam->retval = retval;
2584 vam->result_ready = 1;
2588 clib_warning ("canonical name %s", mp->name);
2591 clib_warning ("retval %d", retval);
2595 static void vl_api_dns_resolve_ip_reply_t_handler_json
2596 (vl_api_dns_resolve_ip_reply_t * mp)
2598 clib_warning ("not implemented");
2602 static void vl_api_ip_address_details_t_handler
2603 (vl_api_ip_address_details_t * mp)
2605 vat_main_t *vam = &vat_main;
2606 static ip_address_details_t empty_ip_address_details = { {0} };
2607 ip_address_details_t *address = NULL;
2608 ip_details_t *current_ip_details = NULL;
2609 ip_details_t *details = NULL;
2611 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
2613 if (!details || vam->current_sw_if_index >= vec_len (details)
2614 || !details[vam->current_sw_if_index].present)
2616 errmsg ("ip address details arrived but not stored");
2617 errmsg ("ip_dump should be called first");
2621 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
2623 #define addresses (current_ip_details->addr)
2625 vec_validate_init_empty (addresses, vec_len (addresses),
2626 empty_ip_address_details);
2628 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
2630 clib_memcpy (&address->ip, &mp->ip, sizeof (address->ip));
2631 address->prefix_length = mp->prefix_length;
2635 static void vl_api_ip_address_details_t_handler_json
2636 (vl_api_ip_address_details_t * mp)
2638 vat_main_t *vam = &vat_main;
2639 vat_json_node_t *node = NULL;
2640 struct in6_addr ip6;
2643 if (VAT_JSON_ARRAY != vam->json_tree.type)
2645 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2646 vat_json_init_array (&vam->json_tree);
2648 node = vat_json_array_add (&vam->json_tree);
2650 vat_json_init_object (node);
2653 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
2654 vat_json_object_add_ip6 (node, "ip", ip6);
2658 clib_memcpy (&ip4, mp->ip, sizeof (ip4));
2659 vat_json_object_add_ip4 (node, "ip", ip4);
2661 vat_json_object_add_uint (node, "prefix_length", mp->prefix_length);
2665 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
2667 vat_main_t *vam = &vat_main;
2668 static ip_details_t empty_ip_details = { 0 };
2669 ip_details_t *ip = NULL;
2670 u32 sw_if_index = ~0;
2672 sw_if_index = ntohl (mp->sw_if_index);
2674 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2675 sw_if_index, empty_ip_details);
2677 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2684 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
2686 vat_main_t *vam = &vat_main;
2688 if (VAT_JSON_ARRAY != vam->json_tree.type)
2690 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2691 vat_json_init_array (&vam->json_tree);
2693 vat_json_array_add_uint (&vam->json_tree,
2694 clib_net_to_host_u32 (mp->sw_if_index));
2698 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
2700 errmsg ("DHCP compl event: pid %d %s hostname %s host_addr %U "
2701 "router_addr %U host_mac %U",
2702 ntohl (mp->pid), mp->lease.is_ipv6 ? "ipv6" : "ipv4",
2704 format_ip4_address, &mp->lease.host_address,
2705 format_ip4_address, &mp->lease.router_address,
2706 format_ethernet_address, mp->lease.host_mac);
2709 static void vl_api_dhcp_compl_event_t_handler_json
2710 (vl_api_dhcp_compl_event_t * mp)
2712 /* JSON output not supported */
2715 static void vl_api_get_first_msg_id_reply_t_handler
2716 (vl_api_get_first_msg_id_reply_t * mp)
2718 vat_main_t *vam = &vat_main;
2719 i32 retval = ntohl (mp->retval);
2721 if (vam->async_mode)
2723 vam->async_errors += (retval < 0);
2727 vam->retval = retval;
2728 vam->result_ready = 1;
2732 errmsg ("first message id %d", ntohs (mp->first_msg_id));
2736 static void vl_api_get_first_msg_id_reply_t_handler_json
2737 (vl_api_get_first_msg_id_reply_t * mp)
2739 vat_main_t *vam = &vat_main;
2740 vat_json_node_t node;
2742 vat_json_init_object (&node);
2743 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2744 vat_json_object_add_uint (&node, "first_msg_id",
2745 (uint) ntohs (mp->first_msg_id));
2747 vat_json_print (vam->ofp, &node);
2748 vat_json_free (&node);
2750 vam->retval = ntohl (mp->retval);
2751 vam->result_ready = 1;
2754 static void vl_api_get_node_graph_reply_t_handler
2755 (vl_api_get_node_graph_reply_t * mp)
2757 vat_main_t *vam = &vat_main;
2758 api_main_t *am = &api_main;
2759 i32 retval = ntohl (mp->retval);
2760 u8 *pvt_copy, *reply;
2765 if (vam->async_mode)
2767 vam->async_errors += (retval < 0);
2771 vam->retval = retval;
2772 vam->result_ready = 1;
2775 /* "Should never happen..." */
2779 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2780 pvt_copy = vec_dup (reply);
2782 /* Toss the shared-memory original... */
2783 pthread_mutex_lock (&am->vlib_rp->mutex);
2784 oldheap = svm_push_data_heap (am->vlib_rp);
2788 svm_pop_heap (oldheap);
2789 pthread_mutex_unlock (&am->vlib_rp->mutex);
2791 if (vam->graph_nodes)
2793 hash_free (vam->graph_node_index_by_name);
2795 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2797 node = vam->graph_nodes[0][i];
2798 vec_free (node->name);
2799 vec_free (node->next_nodes);
2802 vec_free (vam->graph_nodes[0]);
2803 vec_free (vam->graph_nodes);
2806 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2807 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2808 vec_free (pvt_copy);
2810 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2812 node = vam->graph_nodes[0][i];
2813 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2817 static void vl_api_get_node_graph_reply_t_handler_json
2818 (vl_api_get_node_graph_reply_t * mp)
2820 vat_main_t *vam = &vat_main;
2821 api_main_t *am = &api_main;
2823 vat_json_node_t node;
2826 /* $$$$ make this real? */
2827 vat_json_init_object (&node);
2828 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2829 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2831 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2833 /* Toss the shared-memory original... */
2834 pthread_mutex_lock (&am->vlib_rp->mutex);
2835 oldheap = svm_push_data_heap (am->vlib_rp);
2839 svm_pop_heap (oldheap);
2840 pthread_mutex_unlock (&am->vlib_rp->mutex);
2842 vat_json_print (vam->ofp, &node);
2843 vat_json_free (&node);
2845 vam->retval = ntohl (mp->retval);
2846 vam->result_ready = 1;
2850 vl_api_one_locator_details_t_handler (vl_api_one_locator_details_t * mp)
2852 vat_main_t *vam = &vat_main;
2857 s = format (s, "%=16d%=16d%=16d",
2858 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2862 s = format (s, "%=16U%=16d%=16d",
2863 mp->is_ipv6 ? format_ip6_address :
2865 mp->ip_address, mp->priority, mp->weight);
2868 print (vam->ofp, "%v", s);
2873 vl_api_one_locator_details_t_handler_json (vl_api_one_locator_details_t * mp)
2875 vat_main_t *vam = &vat_main;
2876 vat_json_node_t *node = NULL;
2877 struct in6_addr ip6;
2880 if (VAT_JSON_ARRAY != vam->json_tree.type)
2882 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2883 vat_json_init_array (&vam->json_tree);
2885 node = vat_json_array_add (&vam->json_tree);
2886 vat_json_init_object (node);
2888 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2889 vat_json_object_add_uint (node, "priority", mp->priority);
2890 vat_json_object_add_uint (node, "weight", mp->weight);
2893 vat_json_object_add_uint (node, "sw_if_index",
2894 clib_net_to_host_u32 (mp->sw_if_index));
2899 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2900 vat_json_object_add_ip6 (node, "address", ip6);
2904 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2905 vat_json_object_add_ip4 (node, "address", ip4);
2911 vl_api_one_locator_set_details_t_handler (vl_api_one_locator_set_details_t *
2914 vat_main_t *vam = &vat_main;
2917 ls_name = format (0, "%s", mp->ls_name);
2919 print (vam->ofp, "%=10d%=15v", clib_net_to_host_u32 (mp->ls_index),
2925 vl_api_one_locator_set_details_t_handler_json
2926 (vl_api_one_locator_set_details_t * mp)
2928 vat_main_t *vam = &vat_main;
2929 vat_json_node_t *node = 0;
2932 ls_name = format (0, "%s", mp->ls_name);
2933 vec_add1 (ls_name, 0);
2935 if (VAT_JSON_ARRAY != vam->json_tree.type)
2937 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2938 vat_json_init_array (&vam->json_tree);
2940 node = vat_json_array_add (&vam->json_tree);
2942 vat_json_init_object (node);
2943 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2944 vat_json_object_add_uint (node, "ls_index",
2945 clib_net_to_host_u32 (mp->ls_index));
2953 } __attribute__ ((__packed__)) lisp_nsh_api_t;
2956 unformat_nsh_address (unformat_input_t * input, va_list * args)
2958 lisp_nsh_api_t *nsh = va_arg (*args, lisp_nsh_api_t *);
2959 return unformat (input, "SPI:%d SI:%d", &nsh->spi, &nsh->si);
2963 format_nsh_address_vat (u8 * s, va_list * args)
2965 nsh_t *a = va_arg (*args, nsh_t *);
2966 return format (s, "SPI:%d SI:%d", clib_net_to_host_u32 (a->spi), a->si);
2970 format_lisp_flat_eid (u8 * s, va_list * args)
2972 u32 type = va_arg (*args, u32);
2973 u8 *eid = va_arg (*args, u8 *);
2974 u32 eid_len = va_arg (*args, u32);
2979 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
2981 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
2983 return format (s, "%U", format_ethernet_address, eid);
2985 return format (s, "%U", format_nsh_address_vat, eid);
2991 format_lisp_eid_vat (u8 * s, va_list * args)
2993 u32 type = va_arg (*args, u32);
2994 u8 *eid = va_arg (*args, u8 *);
2995 u32 eid_len = va_arg (*args, u32);
2996 u8 *seid = va_arg (*args, u8 *);
2997 u32 seid_len = va_arg (*args, u32);
2998 u32 is_src_dst = va_arg (*args, u32);
3001 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
3003 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
3009 vl_api_one_eid_table_details_t_handler (vl_api_one_eid_table_details_t * mp)
3011 vat_main_t *vam = &vat_main;
3012 u8 *s = 0, *eid = 0;
3014 if (~0 == mp->locator_set_index)
3015 s = format (0, "action: %d", mp->action);
3017 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
3019 eid = format (0, "%U", format_lisp_eid_vat,
3023 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
3026 print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
3027 clib_net_to_host_u32 (mp->vni),
3029 mp->is_local ? "local" : "remote",
3030 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
3031 clib_net_to_host_u16 (mp->key_id), mp->key);
3038 vl_api_one_eid_table_details_t_handler_json (vl_api_one_eid_table_details_t
3041 vat_main_t *vam = &vat_main;
3042 vat_json_node_t *node = 0;
3045 if (VAT_JSON_ARRAY != vam->json_tree.type)
3047 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3048 vat_json_init_array (&vam->json_tree);
3050 node = vat_json_array_add (&vam->json_tree);
3052 vat_json_init_object (node);
3053 if (~0 == mp->locator_set_index)
3054 vat_json_object_add_uint (node, "action", mp->action);
3056 vat_json_object_add_uint (node, "locator_set_index",
3057 clib_net_to_host_u32 (mp->locator_set_index));
3059 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
3060 if (mp->eid_type == 3)
3062 vat_json_node_t *nsh_json = vat_json_object_add (node, "eid");
3063 vat_json_init_object (nsh_json);
3064 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) mp->eid;
3065 vat_json_object_add_uint (nsh_json, "spi",
3066 clib_net_to_host_u32 (nsh->spi));
3067 vat_json_object_add_uint (nsh_json, "si", nsh->si);
3071 eid = format (0, "%U", format_lisp_eid_vat,
3075 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
3077 vat_json_object_add_string_copy (node, "eid", eid);
3080 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3081 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
3082 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
3086 vat_json_object_add_uint (node, "key_id",
3087 clib_net_to_host_u16 (mp->key_id));
3088 vat_json_object_add_string_copy (node, "key", mp->key);
3093 vl_api_one_stats_details_t_handler (vl_api_one_stats_details_t * mp)
3095 vat_main_t *vam = &vat_main;
3096 u8 *seid = 0, *deid = 0;
3097 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3099 deid = format (0, "%U", format_lisp_eid_vat,
3100 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3102 seid = format (0, "%U", format_lisp_eid_vat,
3103 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3109 format_ip_address_fcn = format_ip4_address;
3111 format_ip_address_fcn = format_ip6_address;
3114 print (vam->ofp, "([%d] %s %s) (%U %U) %u %u",
3115 clib_net_to_host_u32 (mp->vni),
3117 format_ip_address_fcn, mp->lloc,
3118 format_ip_address_fcn, mp->rloc,
3119 clib_net_to_host_u32 (mp->pkt_count),
3120 clib_net_to_host_u32 (mp->bytes));
3127 vl_api_one_stats_details_t_handler_json (vl_api_one_stats_details_t * mp)
3129 struct in6_addr ip6;
3131 vat_main_t *vam = &vat_main;
3132 vat_json_node_t *node = 0;
3133 u8 *deid = 0, *seid = 0;
3135 if (VAT_JSON_ARRAY != vam->json_tree.type)
3137 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3138 vat_json_init_array (&vam->json_tree);
3140 node = vat_json_array_add (&vam->json_tree);
3142 vat_json_init_object (node);
3143 deid = format (0, "%U", format_lisp_eid_vat,
3144 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3146 seid = format (0, "%U", format_lisp_eid_vat,
3147 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3152 vat_json_object_add_string_copy (node, "seid", seid);
3153 vat_json_object_add_string_copy (node, "deid", deid);
3154 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3158 clib_memcpy (&ip4, mp->lloc, sizeof (ip4));
3159 vat_json_object_add_ip4 (node, "lloc", ip4);
3160 clib_memcpy (&ip4, mp->rloc, sizeof (ip4));
3161 vat_json_object_add_ip4 (node, "rloc", ip4);
3165 clib_memcpy (&ip6, mp->lloc, sizeof (ip6));
3166 vat_json_object_add_ip6 (node, "lloc", ip6);
3167 clib_memcpy (&ip6, mp->rloc, sizeof (ip6));
3168 vat_json_object_add_ip6 (node, "rloc", ip6);
3170 vat_json_object_add_uint (node, "pkt_count",
3171 clib_net_to_host_u32 (mp->pkt_count));
3172 vat_json_object_add_uint (node, "bytes", clib_net_to_host_u32 (mp->bytes));
3179 vl_api_one_eid_table_map_details_t_handler
3180 (vl_api_one_eid_table_map_details_t * mp)
3182 vat_main_t *vam = &vat_main;
3184 u8 *line = format (0, "%=10d%=10d",
3185 clib_net_to_host_u32 (mp->vni),
3186 clib_net_to_host_u32 (mp->dp_table));
3187 print (vam->ofp, "%v", line);
3192 vl_api_one_eid_table_map_details_t_handler_json
3193 (vl_api_one_eid_table_map_details_t * mp)
3195 vat_main_t *vam = &vat_main;
3196 vat_json_node_t *node = NULL;
3198 if (VAT_JSON_ARRAY != vam->json_tree.type)
3200 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3201 vat_json_init_array (&vam->json_tree);
3203 node = vat_json_array_add (&vam->json_tree);
3204 vat_json_init_object (node);
3205 vat_json_object_add_uint (node, "dp_table",
3206 clib_net_to_host_u32 (mp->dp_table));
3207 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3211 vl_api_one_eid_table_vni_details_t_handler
3212 (vl_api_one_eid_table_vni_details_t * mp)
3214 vat_main_t *vam = &vat_main;
3216 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
3217 print (vam->ofp, "%v", line);
3222 vl_api_one_eid_table_vni_details_t_handler_json
3223 (vl_api_one_eid_table_vni_details_t * mp)
3225 vat_main_t *vam = &vat_main;
3226 vat_json_node_t *node = NULL;
3228 if (VAT_JSON_ARRAY != vam->json_tree.type)
3230 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3231 vat_json_init_array (&vam->json_tree);
3233 node = vat_json_array_add (&vam->json_tree);
3234 vat_json_init_object (node);
3235 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3239 vl_api_show_one_map_register_fallback_threshold_reply_t_handler
3240 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3242 vat_main_t *vam = &vat_main;
3243 int retval = clib_net_to_host_u32 (mp->retval);
3245 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3246 print (vam->ofp, "fallback threshold value: %d", mp->value);
3248 vam->retval = retval;
3249 vam->result_ready = 1;
3253 vl_api_show_one_map_register_fallback_threshold_reply_t_handler_json
3254 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3256 vat_main_t *vam = &vat_main;
3257 vat_json_node_t _node, *node = &_node;
3258 int retval = clib_net_to_host_u32 (mp->retval);
3260 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3261 vat_json_init_object (node);
3262 vat_json_object_add_uint (node, "value", mp->value);
3264 vat_json_print (vam->ofp, node);
3265 vat_json_free (node);
3267 vam->retval = retval;
3268 vam->result_ready = 1;
3272 vl_api_show_one_map_register_state_reply_t_handler
3273 (vl_api_show_one_map_register_state_reply_t * mp)
3275 vat_main_t *vam = &vat_main;
3276 int retval = clib_net_to_host_u32 (mp->retval);
3278 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3280 vam->retval = retval;
3281 vam->result_ready = 1;
3285 vl_api_show_one_map_register_state_reply_t_handler_json
3286 (vl_api_show_one_map_register_state_reply_t * mp)
3288 vat_main_t *vam = &vat_main;
3289 vat_json_node_t _node, *node = &_node;
3290 int retval = clib_net_to_host_u32 (mp->retval);
3292 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3294 vat_json_init_object (node);
3295 vat_json_object_add_string_copy (node, "state", s);
3297 vat_json_print (vam->ofp, node);
3298 vat_json_free (node);
3300 vam->retval = retval;
3301 vam->result_ready = 1;
3306 vl_api_show_one_rloc_probe_state_reply_t_handler
3307 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3309 vat_main_t *vam = &vat_main;
3310 int retval = clib_net_to_host_u32 (mp->retval);
3315 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3317 vam->retval = retval;
3318 vam->result_ready = 1;
3322 vl_api_show_one_rloc_probe_state_reply_t_handler_json
3323 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3325 vat_main_t *vam = &vat_main;
3326 vat_json_node_t _node, *node = &_node;
3327 int retval = clib_net_to_host_u32 (mp->retval);
3329 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3330 vat_json_init_object (node);
3331 vat_json_object_add_string_copy (node, "state", s);
3333 vat_json_print (vam->ofp, node);
3334 vat_json_free (node);
3336 vam->retval = retval;
3337 vam->result_ready = 1;
3342 vl_api_show_one_stats_enable_disable_reply_t_handler
3343 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3345 vat_main_t *vam = &vat_main;
3346 int retval = clib_net_to_host_u32 (mp->retval);
3351 print (vam->ofp, "%s", mp->is_en ? "enabled" : "disabled");
3353 vam->retval = retval;
3354 vam->result_ready = 1;
3358 vl_api_show_one_stats_enable_disable_reply_t_handler_json
3359 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3361 vat_main_t *vam = &vat_main;
3362 vat_json_node_t _node, *node = &_node;
3363 int retval = clib_net_to_host_u32 (mp->retval);
3365 u8 *s = format (0, "%s", mp->is_en ? "enabled" : "disabled");
3366 vat_json_init_object (node);
3367 vat_json_object_add_string_copy (node, "state", s);
3369 vat_json_print (vam->ofp, node);
3370 vat_json_free (node);
3372 vam->retval = retval;
3373 vam->result_ready = 1;
3378 api_gpe_fwd_entry_net_to_host (vl_api_gpe_fwd_entry_t * e)
3380 e->dp_table = clib_net_to_host_u32 (e->dp_table);
3381 e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
3382 e->vni = clib_net_to_host_u32 (e->vni);
3386 gpe_fwd_entries_get_reply_t_net_to_host
3387 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3391 mp->count = clib_net_to_host_u32 (mp->count);
3392 for (i = 0; i < mp->count; i++)
3394 api_gpe_fwd_entry_net_to_host (&mp->entries[i]);
3399 format_gpe_encap_mode (u8 * s, va_list * args)
3401 u32 mode = va_arg (*args, u32);
3406 return format (s, "lisp");
3408 return format (s, "vxlan");
3414 vl_api_gpe_get_encap_mode_reply_t_handler
3415 (vl_api_gpe_get_encap_mode_reply_t * mp)
3417 vat_main_t *vam = &vat_main;
3419 print (vam->ofp, "gpe mode: %U", format_gpe_encap_mode, mp->encap_mode);
3420 vam->retval = ntohl (mp->retval);
3421 vam->result_ready = 1;
3425 vl_api_gpe_get_encap_mode_reply_t_handler_json
3426 (vl_api_gpe_get_encap_mode_reply_t * mp)
3428 vat_main_t *vam = &vat_main;
3429 vat_json_node_t node;
3431 u8 *encap_mode = format (0, "%U", format_gpe_encap_mode, mp->encap_mode);
3432 vec_add1 (encap_mode, 0);
3434 vat_json_init_object (&node);
3435 vat_json_object_add_string_copy (&node, "gpe_mode", encap_mode);
3437 vec_free (encap_mode);
3438 vat_json_print (vam->ofp, &node);
3439 vat_json_free (&node);
3441 vam->retval = ntohl (mp->retval);
3442 vam->result_ready = 1;
3446 vl_api_gpe_fwd_entry_path_details_t_handler
3447 (vl_api_gpe_fwd_entry_path_details_t * mp)
3449 vat_main_t *vam = &vat_main;
3450 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3452 if (mp->lcl_loc.is_ip4)
3453 format_ip_address_fcn = format_ip4_address;
3455 format_ip_address_fcn = format_ip6_address;
3457 print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
3458 format_ip_address_fcn, &mp->lcl_loc,
3459 format_ip_address_fcn, &mp->rmt_loc);
3463 lisp_fill_locator_node (vat_json_node_t * n, vl_api_gpe_locator_t * loc)
3465 struct in6_addr ip6;
3470 clib_memcpy (&ip4, loc->addr, sizeof (ip4));
3471 vat_json_object_add_ip4 (n, "address", ip4);
3475 clib_memcpy (&ip6, loc->addr, sizeof (ip6));
3476 vat_json_object_add_ip6 (n, "address", ip6);
3478 vat_json_object_add_uint (n, "weight", loc->weight);
3482 vl_api_gpe_fwd_entry_path_details_t_handler_json
3483 (vl_api_gpe_fwd_entry_path_details_t * mp)
3485 vat_main_t *vam = &vat_main;
3486 vat_json_node_t *node = NULL;
3487 vat_json_node_t *loc_node;
3489 if (VAT_JSON_ARRAY != vam->json_tree.type)
3491 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3492 vat_json_init_array (&vam->json_tree);
3494 node = vat_json_array_add (&vam->json_tree);
3495 vat_json_init_object (node);
3497 loc_node = vat_json_object_add (node, "local_locator");
3498 vat_json_init_object (loc_node);
3499 lisp_fill_locator_node (loc_node, &mp->lcl_loc);
3501 loc_node = vat_json_object_add (node, "remote_locator");
3502 vat_json_init_object (loc_node);
3503 lisp_fill_locator_node (loc_node, &mp->rmt_loc);
3507 vl_api_gpe_fwd_entries_get_reply_t_handler
3508 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3510 vat_main_t *vam = &vat_main;
3512 int retval = clib_net_to_host_u32 (mp->retval);
3513 vl_api_gpe_fwd_entry_t *e;
3518 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3520 for (i = 0; i < mp->count; i++)
3522 e = &mp->entries[i];
3523 print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
3524 format_lisp_flat_eid, e->eid_type, e->leid, e->leid_prefix_len,
3525 format_lisp_flat_eid, e->eid_type, e->reid, e->reid_prefix_len);
3529 vam->retval = retval;
3530 vam->result_ready = 1;
3534 vl_api_gpe_fwd_entries_get_reply_t_handler_json
3535 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3538 vat_main_t *vam = &vat_main;
3539 vat_json_node_t *e = 0, root;
3541 int retval = clib_net_to_host_u32 (mp->retval);
3542 vl_api_gpe_fwd_entry_t *fwd;
3547 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3548 vat_json_init_array (&root);
3550 for (i = 0; i < mp->count; i++)
3552 e = vat_json_array_add (&root);
3553 fwd = &mp->entries[i];
3555 vat_json_init_object (e);
3556 vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
3557 vat_json_object_add_int (e, "dp_table", fwd->dp_table);
3558 vat_json_object_add_int (e, "vni", fwd->vni);
3559 vat_json_object_add_int (e, "action", fwd->action);
3561 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->leid,
3562 fwd->leid_prefix_len);
3564 vat_json_object_add_string_copy (e, "leid", s);
3567 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->reid,
3568 fwd->reid_prefix_len);
3570 vat_json_object_add_string_copy (e, "reid", s);
3574 vat_json_print (vam->ofp, &root);
3575 vat_json_free (&root);
3578 vam->retval = retval;
3579 vam->result_ready = 1;
3583 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler
3584 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3586 vat_main_t *vam = &vat_main;
3588 int retval = clib_net_to_host_u32 (mp->retval);
3589 vl_api_gpe_native_fwd_rpath_t *r;
3594 n = clib_net_to_host_u32 (mp->count);
3596 for (i = 0; i < n; i++)
3598 r = &mp->entries[i];
3599 print (vam->ofp, "fib_index: %d sw_if_index %d nh %U",
3600 clib_net_to_host_u32 (r->fib_index),
3601 clib_net_to_host_u32 (r->nh_sw_if_index),
3602 r->is_ip4 ? format_ip4_address : format_ip6_address, r->nh_addr);
3606 vam->retval = retval;
3607 vam->result_ready = 1;
3611 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler_json
3612 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3614 vat_main_t *vam = &vat_main;
3615 vat_json_node_t root, *e;
3617 int retval = clib_net_to_host_u32 (mp->retval);
3618 vl_api_gpe_native_fwd_rpath_t *r;
3624 n = clib_net_to_host_u32 (mp->count);
3625 vat_json_init_array (&root);
3627 for (i = 0; i < n; i++)
3629 e = vat_json_array_add (&root);
3630 vat_json_init_object (e);
3631 r = &mp->entries[i];
3633 format (0, "%U", r->is_ip4 ? format_ip4_address : format_ip6_address,
3636 vat_json_object_add_string_copy (e, "ip4", s);
3639 vat_json_object_add_uint (e, "fib_index",
3640 clib_net_to_host_u32 (r->fib_index));
3641 vat_json_object_add_uint (e, "nh_sw_if_index",
3642 clib_net_to_host_u32 (r->nh_sw_if_index));
3645 vat_json_print (vam->ofp, &root);
3646 vat_json_free (&root);
3649 vam->retval = retval;
3650 vam->result_ready = 1;
3654 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler
3655 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3657 vat_main_t *vam = &vat_main;
3659 int retval = clib_net_to_host_u32 (mp->retval);
3664 n = clib_net_to_host_u32 (mp->count);
3666 for (i = 0; i < n; i++)
3667 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->vnis[i]));
3670 vam->retval = retval;
3671 vam->result_ready = 1;
3675 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler_json
3676 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3678 vat_main_t *vam = &vat_main;
3679 vat_json_node_t root;
3681 int retval = clib_net_to_host_u32 (mp->retval);
3686 n = clib_net_to_host_u32 (mp->count);
3687 vat_json_init_array (&root);
3689 for (i = 0; i < n; i++)
3690 vat_json_array_add_uint (&root, clib_net_to_host_u32 (mp->vnis[i]));
3692 vat_json_print (vam->ofp, &root);
3693 vat_json_free (&root);
3696 vam->retval = retval;
3697 vam->result_ready = 1;
3701 vl_api_one_ndp_entries_get_reply_t_handler
3702 (vl_api_one_ndp_entries_get_reply_t * mp)
3704 vat_main_t *vam = &vat_main;
3706 int retval = clib_net_to_host_u32 (mp->retval);
3711 n = clib_net_to_host_u32 (mp->count);
3713 for (i = 0; i < n; i++)
3714 print (vam->ofp, "%U -> %U", format_ip6_address, &mp->entries[i].ip6,
3715 format_ethernet_address, mp->entries[i].mac);
3718 vam->retval = retval;
3719 vam->result_ready = 1;
3723 vl_api_one_ndp_entries_get_reply_t_handler_json
3724 (vl_api_one_ndp_entries_get_reply_t * mp)
3727 vat_main_t *vam = &vat_main;
3728 vat_json_node_t *e = 0, root;
3730 int retval = clib_net_to_host_u32 (mp->retval);
3731 vl_api_one_ndp_entry_t *arp_entry;
3736 n = clib_net_to_host_u32 (mp->count);
3737 vat_json_init_array (&root);
3739 for (i = 0; i < n; i++)
3741 e = vat_json_array_add (&root);
3742 arp_entry = &mp->entries[i];
3744 vat_json_init_object (e);
3745 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3748 vat_json_object_add_string_copy (e, "mac", s);
3751 s = format (0, "%U", format_ip6_address, &arp_entry->ip6);
3753 vat_json_object_add_string_copy (e, "ip6", s);
3757 vat_json_print (vam->ofp, &root);
3758 vat_json_free (&root);
3761 vam->retval = retval;
3762 vam->result_ready = 1;
3766 vl_api_one_l2_arp_entries_get_reply_t_handler
3767 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3769 vat_main_t *vam = &vat_main;
3771 int retval = clib_net_to_host_u32 (mp->retval);
3776 n = clib_net_to_host_u32 (mp->count);
3778 for (i = 0; i < n; i++)
3779 print (vam->ofp, "%U -> %U", format_ip4_address, &mp->entries[i].ip4,
3780 format_ethernet_address, mp->entries[i].mac);
3783 vam->retval = retval;
3784 vam->result_ready = 1;
3788 vl_api_one_l2_arp_entries_get_reply_t_handler_json
3789 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3792 vat_main_t *vam = &vat_main;
3793 vat_json_node_t *e = 0, root;
3795 int retval = clib_net_to_host_u32 (mp->retval);
3796 vl_api_one_l2_arp_entry_t *arp_entry;
3801 n = clib_net_to_host_u32 (mp->count);
3802 vat_json_init_array (&root);
3804 for (i = 0; i < n; i++)
3806 e = vat_json_array_add (&root);
3807 arp_entry = &mp->entries[i];
3809 vat_json_init_object (e);
3810 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3813 vat_json_object_add_string_copy (e, "mac", s);
3816 s = format (0, "%U", format_ip4_address, &arp_entry->ip4);
3818 vat_json_object_add_string_copy (e, "ip4", s);
3822 vat_json_print (vam->ofp, &root);
3823 vat_json_free (&root);
3826 vam->retval = retval;
3827 vam->result_ready = 1;
3831 vl_api_one_ndp_bd_get_reply_t_handler (vl_api_one_ndp_bd_get_reply_t * mp)
3833 vat_main_t *vam = &vat_main;
3835 int retval = clib_net_to_host_u32 (mp->retval);
3840 n = clib_net_to_host_u32 (mp->count);
3842 for (i = 0; i < n; i++)
3844 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3848 vam->retval = retval;
3849 vam->result_ready = 1;
3853 vl_api_one_ndp_bd_get_reply_t_handler_json
3854 (vl_api_one_ndp_bd_get_reply_t * mp)
3856 vat_main_t *vam = &vat_main;
3857 vat_json_node_t root;
3859 int retval = clib_net_to_host_u32 (mp->retval);
3864 n = clib_net_to_host_u32 (mp->count);
3865 vat_json_init_array (&root);
3867 for (i = 0; i < n; i++)
3869 vat_json_array_add_uint (&root,
3870 clib_net_to_host_u32 (mp->bridge_domains[i]));
3873 vat_json_print (vam->ofp, &root);
3874 vat_json_free (&root);
3877 vam->retval = retval;
3878 vam->result_ready = 1;
3882 vl_api_one_l2_arp_bd_get_reply_t_handler
3883 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3885 vat_main_t *vam = &vat_main;
3887 int retval = clib_net_to_host_u32 (mp->retval);
3892 n = clib_net_to_host_u32 (mp->count);
3894 for (i = 0; i < n; i++)
3896 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3900 vam->retval = retval;
3901 vam->result_ready = 1;
3905 vl_api_one_l2_arp_bd_get_reply_t_handler_json
3906 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3908 vat_main_t *vam = &vat_main;
3909 vat_json_node_t root;
3911 int retval = clib_net_to_host_u32 (mp->retval);
3916 n = clib_net_to_host_u32 (mp->count);
3917 vat_json_init_array (&root);
3919 for (i = 0; i < n; i++)
3921 vat_json_array_add_uint (&root,
3922 clib_net_to_host_u32 (mp->bridge_domains[i]));
3925 vat_json_print (vam->ofp, &root);
3926 vat_json_free (&root);
3929 vam->retval = retval;
3930 vam->result_ready = 1;
3934 vl_api_one_adjacencies_get_reply_t_handler
3935 (vl_api_one_adjacencies_get_reply_t * mp)
3937 vat_main_t *vam = &vat_main;
3939 int retval = clib_net_to_host_u32 (mp->retval);
3940 vl_api_one_adjacency_t *a;
3945 n = clib_net_to_host_u32 (mp->count);
3947 for (i = 0; i < n; i++)
3949 a = &mp->adjacencies[i];
3950 print (vam->ofp, "%U %40U",
3951 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
3952 format_lisp_flat_eid, a->eid_type, a->reid, a->reid_prefix_len);
3956 vam->retval = retval;
3957 vam->result_ready = 1;
3961 vl_api_one_adjacencies_get_reply_t_handler_json
3962 (vl_api_one_adjacencies_get_reply_t * mp)
3965 vat_main_t *vam = &vat_main;
3966 vat_json_node_t *e = 0, root;
3968 int retval = clib_net_to_host_u32 (mp->retval);
3969 vl_api_one_adjacency_t *a;
3974 n = clib_net_to_host_u32 (mp->count);
3975 vat_json_init_array (&root);
3977 for (i = 0; i < n; i++)
3979 e = vat_json_array_add (&root);
3980 a = &mp->adjacencies[i];
3982 vat_json_init_object (e);
3983 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
3984 a->leid_prefix_len);
3986 vat_json_object_add_string_copy (e, "leid", s);
3989 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
3990 a->reid_prefix_len);
3992 vat_json_object_add_string_copy (e, "reid", s);
3996 vat_json_print (vam->ofp, &root);
3997 vat_json_free (&root);
4000 vam->retval = retval;
4001 vam->result_ready = 1;
4005 vl_api_one_map_server_details_t_handler (vl_api_one_map_server_details_t * mp)
4007 vat_main_t *vam = &vat_main;
4009 print (vam->ofp, "%=20U",
4010 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
4015 vl_api_one_map_server_details_t_handler_json
4016 (vl_api_one_map_server_details_t * mp)
4018 vat_main_t *vam = &vat_main;
4019 vat_json_node_t *node = NULL;
4020 struct in6_addr ip6;
4023 if (VAT_JSON_ARRAY != vam->json_tree.type)
4025 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4026 vat_json_init_array (&vam->json_tree);
4028 node = vat_json_array_add (&vam->json_tree);
4030 vat_json_init_object (node);
4033 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
4034 vat_json_object_add_ip6 (node, "map-server", ip6);
4038 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
4039 vat_json_object_add_ip4 (node, "map-server", ip4);
4044 vl_api_one_map_resolver_details_t_handler (vl_api_one_map_resolver_details_t
4047 vat_main_t *vam = &vat_main;
4049 print (vam->ofp, "%=20U",
4050 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
4055 vl_api_one_map_resolver_details_t_handler_json
4056 (vl_api_one_map_resolver_details_t * mp)
4058 vat_main_t *vam = &vat_main;
4059 vat_json_node_t *node = NULL;
4060 struct in6_addr ip6;
4063 if (VAT_JSON_ARRAY != vam->json_tree.type)
4065 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4066 vat_json_init_array (&vam->json_tree);
4068 node = vat_json_array_add (&vam->json_tree);
4070 vat_json_init_object (node);
4073 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
4074 vat_json_object_add_ip6 (node, "map resolver", ip6);
4078 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
4079 vat_json_object_add_ip4 (node, "map resolver", ip4);
4084 vl_api_show_one_status_reply_t_handler (vl_api_show_one_status_reply_t * mp)
4086 vat_main_t *vam = &vat_main;
4087 i32 retval = ntohl (mp->retval);
4091 print (vam->ofp, "feature: %s\ngpe: %s",
4092 mp->feature_status ? "enabled" : "disabled",
4093 mp->gpe_status ? "enabled" : "disabled");
4096 vam->retval = retval;
4097 vam->result_ready = 1;
4101 vl_api_show_one_status_reply_t_handler_json
4102 (vl_api_show_one_status_reply_t * mp)
4104 vat_main_t *vam = &vat_main;
4105 vat_json_node_t node;
4106 u8 *gpe_status = NULL;
4107 u8 *feature_status = NULL;
4109 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
4110 feature_status = format (0, "%s",
4111 mp->feature_status ? "enabled" : "disabled");
4112 vec_add1 (gpe_status, 0);
4113 vec_add1 (feature_status, 0);
4115 vat_json_init_object (&node);
4116 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
4117 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
4119 vec_free (gpe_status);
4120 vec_free (feature_status);
4122 vat_json_print (vam->ofp, &node);
4123 vat_json_free (&node);
4125 vam->retval = ntohl (mp->retval);
4126 vam->result_ready = 1;
4130 vl_api_one_get_map_request_itr_rlocs_reply_t_handler
4131 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4133 vat_main_t *vam = &vat_main;
4134 i32 retval = ntohl (mp->retval);
4138 print (vam->ofp, "%=20s", mp->locator_set_name);
4141 vam->retval = retval;
4142 vam->result_ready = 1;
4146 vl_api_one_get_map_request_itr_rlocs_reply_t_handler_json
4147 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4149 vat_main_t *vam = &vat_main;
4150 vat_json_node_t *node = NULL;
4152 if (VAT_JSON_ARRAY != vam->json_tree.type)
4154 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4155 vat_json_init_array (&vam->json_tree);
4157 node = vat_json_array_add (&vam->json_tree);
4159 vat_json_init_object (node);
4160 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
4162 vat_json_print (vam->ofp, node);
4163 vat_json_free (node);
4165 vam->retval = ntohl (mp->retval);
4166 vam->result_ready = 1;
4170 format_lisp_map_request_mode (u8 * s, va_list * args)
4172 u32 mode = va_arg (*args, u32);
4177 return format (0, "dst-only");
4179 return format (0, "src-dst");
4185 vl_api_show_one_map_request_mode_reply_t_handler
4186 (vl_api_show_one_map_request_mode_reply_t * mp)
4188 vat_main_t *vam = &vat_main;
4189 i32 retval = ntohl (mp->retval);
4193 u32 mode = mp->mode;
4194 print (vam->ofp, "map_request_mode: %U",
4195 format_lisp_map_request_mode, mode);
4198 vam->retval = retval;
4199 vam->result_ready = 1;
4203 vl_api_show_one_map_request_mode_reply_t_handler_json
4204 (vl_api_show_one_map_request_mode_reply_t * mp)
4206 vat_main_t *vam = &vat_main;
4207 vat_json_node_t node;
4212 s = format (0, "%U", format_lisp_map_request_mode, mode);
4215 vat_json_init_object (&node);
4216 vat_json_object_add_string_copy (&node, "map_request_mode", s);
4217 vat_json_print (vam->ofp, &node);
4218 vat_json_free (&node);
4221 vam->retval = ntohl (mp->retval);
4222 vam->result_ready = 1;
4226 vl_api_one_show_xtr_mode_reply_t_handler
4227 (vl_api_one_show_xtr_mode_reply_t * mp)
4229 vat_main_t *vam = &vat_main;
4230 i32 retval = ntohl (mp->retval);
4234 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4237 vam->retval = retval;
4238 vam->result_ready = 1;
4242 vl_api_one_show_xtr_mode_reply_t_handler_json
4243 (vl_api_one_show_xtr_mode_reply_t * mp)
4245 vat_main_t *vam = &vat_main;
4246 vat_json_node_t node;
4249 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4250 vec_add1 (status, 0);
4252 vat_json_init_object (&node);
4253 vat_json_object_add_string_copy (&node, "status", status);
4257 vat_json_print (vam->ofp, &node);
4258 vat_json_free (&node);
4260 vam->retval = ntohl (mp->retval);
4261 vam->result_ready = 1;
4265 vl_api_one_show_pitr_mode_reply_t_handler
4266 (vl_api_one_show_pitr_mode_reply_t * mp)
4268 vat_main_t *vam = &vat_main;
4269 i32 retval = ntohl (mp->retval);
4273 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4276 vam->retval = retval;
4277 vam->result_ready = 1;
4281 vl_api_one_show_pitr_mode_reply_t_handler_json
4282 (vl_api_one_show_pitr_mode_reply_t * mp)
4284 vat_main_t *vam = &vat_main;
4285 vat_json_node_t node;
4288 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4289 vec_add1 (status, 0);
4291 vat_json_init_object (&node);
4292 vat_json_object_add_string_copy (&node, "status", status);
4296 vat_json_print (vam->ofp, &node);
4297 vat_json_free (&node);
4299 vam->retval = ntohl (mp->retval);
4300 vam->result_ready = 1;
4304 vl_api_one_show_petr_mode_reply_t_handler
4305 (vl_api_one_show_petr_mode_reply_t * mp)
4307 vat_main_t *vam = &vat_main;
4308 i32 retval = ntohl (mp->retval);
4312 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4315 vam->retval = retval;
4316 vam->result_ready = 1;
4320 vl_api_one_show_petr_mode_reply_t_handler_json
4321 (vl_api_one_show_petr_mode_reply_t * mp)
4323 vat_main_t *vam = &vat_main;
4324 vat_json_node_t node;
4327 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4328 vec_add1 (status, 0);
4330 vat_json_init_object (&node);
4331 vat_json_object_add_string_copy (&node, "status", status);
4335 vat_json_print (vam->ofp, &node);
4336 vat_json_free (&node);
4338 vam->retval = ntohl (mp->retval);
4339 vam->result_ready = 1;
4343 vl_api_show_one_use_petr_reply_t_handler
4344 (vl_api_show_one_use_petr_reply_t * mp)
4346 vat_main_t *vam = &vat_main;
4347 i32 retval = ntohl (mp->retval);
4351 print (vam->ofp, "%s\n", mp->status ? "enabled" : "disabled");
4354 print (vam->ofp, "Proxy-ETR address; %U",
4355 mp->is_ip4 ? format_ip4_address : format_ip6_address,
4360 vam->retval = retval;
4361 vam->result_ready = 1;
4365 vl_api_show_one_use_petr_reply_t_handler_json
4366 (vl_api_show_one_use_petr_reply_t * mp)
4368 vat_main_t *vam = &vat_main;
4369 vat_json_node_t node;
4372 struct in6_addr ip6;
4374 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4375 vec_add1 (status, 0);
4377 vat_json_init_object (&node);
4378 vat_json_object_add_string_copy (&node, "status", status);
4383 clib_memcpy (&ip6, mp->address, sizeof (ip6));
4384 vat_json_object_add_ip6 (&node, "address", ip6);
4388 clib_memcpy (&ip4, mp->address, sizeof (ip4));
4389 vat_json_object_add_ip4 (&node, "address", ip4);
4395 vat_json_print (vam->ofp, &node);
4396 vat_json_free (&node);
4398 vam->retval = ntohl (mp->retval);
4399 vam->result_ready = 1;
4403 vl_api_show_one_nsh_mapping_reply_t_handler
4404 (vl_api_show_one_nsh_mapping_reply_t * mp)
4406 vat_main_t *vam = &vat_main;
4407 i32 retval = ntohl (mp->retval);
4411 print (vam->ofp, "%-20s%-16s",
4412 mp->is_set ? "set" : "not-set",
4413 mp->is_set ? (char *) mp->locator_set_name : "");
4416 vam->retval = retval;
4417 vam->result_ready = 1;
4421 vl_api_show_one_nsh_mapping_reply_t_handler_json
4422 (vl_api_show_one_nsh_mapping_reply_t * mp)
4424 vat_main_t *vam = &vat_main;
4425 vat_json_node_t node;
4428 status = format (0, "%s", mp->is_set ? "yes" : "no");
4429 vec_add1 (status, 0);
4431 vat_json_init_object (&node);
4432 vat_json_object_add_string_copy (&node, "is_set", status);
4435 vat_json_object_add_string_copy (&node, "locator_set",
4436 mp->locator_set_name);
4441 vat_json_print (vam->ofp, &node);
4442 vat_json_free (&node);
4444 vam->retval = ntohl (mp->retval);
4445 vam->result_ready = 1;
4449 vl_api_show_one_map_register_ttl_reply_t_handler
4450 (vl_api_show_one_map_register_ttl_reply_t * mp)
4452 vat_main_t *vam = &vat_main;
4453 i32 retval = ntohl (mp->retval);
4455 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4459 print (vam->ofp, "ttl: %u", mp->ttl);
4462 vam->retval = retval;
4463 vam->result_ready = 1;
4467 vl_api_show_one_map_register_ttl_reply_t_handler_json
4468 (vl_api_show_one_map_register_ttl_reply_t * mp)
4470 vat_main_t *vam = &vat_main;
4471 vat_json_node_t node;
4473 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4474 vat_json_init_object (&node);
4475 vat_json_object_add_uint (&node, "ttl", mp->ttl);
4477 vat_json_print (vam->ofp, &node);
4478 vat_json_free (&node);
4480 vam->retval = ntohl (mp->retval);
4481 vam->result_ready = 1;
4485 vl_api_show_one_pitr_reply_t_handler (vl_api_show_one_pitr_reply_t * mp)
4487 vat_main_t *vam = &vat_main;
4488 i32 retval = ntohl (mp->retval);
4492 print (vam->ofp, "%-20s%-16s",
4493 mp->status ? "enabled" : "disabled",
4494 mp->status ? (char *) mp->locator_set_name : "");
4497 vam->retval = retval;
4498 vam->result_ready = 1;
4502 vl_api_show_one_pitr_reply_t_handler_json (vl_api_show_one_pitr_reply_t * mp)
4504 vat_main_t *vam = &vat_main;
4505 vat_json_node_t node;
4508 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4509 vec_add1 (status, 0);
4511 vat_json_init_object (&node);
4512 vat_json_object_add_string_copy (&node, "status", status);
4515 vat_json_object_add_string_copy (&node, "locator_set",
4516 mp->locator_set_name);
4521 vat_json_print (vam->ofp, &node);
4522 vat_json_free (&node);
4524 vam->retval = ntohl (mp->retval);
4525 vam->result_ready = 1;
4529 format_policer_type (u8 * s, va_list * va)
4531 u32 i = va_arg (*va, u32);
4533 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
4534 s = format (s, "1r2c");
4535 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
4536 s = format (s, "1r3c");
4537 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
4538 s = format (s, "2r3c-2698");
4539 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
4540 s = format (s, "2r3c-4115");
4541 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
4542 s = format (s, "2r3c-mef5cf1");
4544 s = format (s, "ILLEGAL");
4549 format_policer_rate_type (u8 * s, va_list * va)
4551 u32 i = va_arg (*va, u32);
4553 if (i == SSE2_QOS_RATE_KBPS)
4554 s = format (s, "kbps");
4555 else if (i == SSE2_QOS_RATE_PPS)
4556 s = format (s, "pps");
4558 s = format (s, "ILLEGAL");
4563 format_policer_round_type (u8 * s, va_list * va)
4565 u32 i = va_arg (*va, u32);
4567 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
4568 s = format (s, "closest");
4569 else if (i == SSE2_QOS_ROUND_TO_UP)
4570 s = format (s, "up");
4571 else if (i == SSE2_QOS_ROUND_TO_DOWN)
4572 s = format (s, "down");
4574 s = format (s, "ILLEGAL");
4579 format_policer_action_type (u8 * s, va_list * va)
4581 u32 i = va_arg (*va, u32);
4583 if (i == SSE2_QOS_ACTION_DROP)
4584 s = format (s, "drop");
4585 else if (i == SSE2_QOS_ACTION_TRANSMIT)
4586 s = format (s, "transmit");
4587 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4588 s = format (s, "mark-and-transmit");
4590 s = format (s, "ILLEGAL");
4595 format_dscp (u8 * s, va_list * va)
4597 u32 i = va_arg (*va, u32);
4602 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
4606 return format (s, "ILLEGAL");
4608 s = format (s, "%s", t);
4613 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
4615 vat_main_t *vam = &vat_main;
4616 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
4618 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4619 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4621 conform_dscp_str = format (0, "");
4623 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4624 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4626 exceed_dscp_str = format (0, "");
4628 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4629 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4631 violate_dscp_str = format (0, "");
4633 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
4634 "rate type %U, round type %U, %s rate, %s color-aware, "
4635 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
4636 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
4637 "conform action %U%s, exceed action %U%s, violate action %U%s",
4639 format_policer_type, mp->type,
4642 clib_net_to_host_u64 (mp->cb),
4643 clib_net_to_host_u64 (mp->eb),
4644 format_policer_rate_type, mp->rate_type,
4645 format_policer_round_type, mp->round_type,
4646 mp->single_rate ? "single" : "dual",
4647 mp->color_aware ? "is" : "not",
4648 ntohl (mp->cir_tokens_per_period),
4649 ntohl (mp->pir_tokens_per_period),
4651 ntohl (mp->current_limit),
4652 ntohl (mp->current_bucket),
4653 ntohl (mp->extended_limit),
4654 ntohl (mp->extended_bucket),
4655 clib_net_to_host_u64 (mp->last_update_time),
4656 format_policer_action_type, mp->conform_action_type,
4658 format_policer_action_type, mp->exceed_action_type,
4660 format_policer_action_type, mp->violate_action_type,
4663 vec_free (conform_dscp_str);
4664 vec_free (exceed_dscp_str);
4665 vec_free (violate_dscp_str);
4668 static void vl_api_policer_details_t_handler_json
4669 (vl_api_policer_details_t * mp)
4671 vat_main_t *vam = &vat_main;
4672 vat_json_node_t *node;
4673 u8 *rate_type_str, *round_type_str, *type_str;
4674 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
4676 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
4678 format (0, "%U", format_policer_round_type, mp->round_type);
4679 type_str = format (0, "%U", format_policer_type, mp->type);
4680 conform_action_str = format (0, "%U", format_policer_action_type,
4681 mp->conform_action_type);
4682 exceed_action_str = format (0, "%U", format_policer_action_type,
4683 mp->exceed_action_type);
4684 violate_action_str = format (0, "%U", format_policer_action_type,
4685 mp->violate_action_type);
4687 if (VAT_JSON_ARRAY != vam->json_tree.type)
4689 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4690 vat_json_init_array (&vam->json_tree);
4692 node = vat_json_array_add (&vam->json_tree);
4694 vat_json_init_object (node);
4695 vat_json_object_add_string_copy (node, "name", mp->name);
4696 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
4697 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
4698 vat_json_object_add_uint (node, "cb", clib_net_to_host_u64 (mp->cb));
4699 vat_json_object_add_uint (node, "eb", clib_net_to_host_u64 (mp->eb));
4700 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
4701 vat_json_object_add_string_copy (node, "round_type", round_type_str);
4702 vat_json_object_add_string_copy (node, "type", type_str);
4703 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
4704 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
4705 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
4706 vat_json_object_add_uint (node, "cir_tokens_per_period",
4707 ntohl (mp->cir_tokens_per_period));
4708 vat_json_object_add_uint (node, "eir_tokens_per_period",
4709 ntohl (mp->pir_tokens_per_period));
4710 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
4711 vat_json_object_add_uint (node, "current_bucket",
4712 ntohl (mp->current_bucket));
4713 vat_json_object_add_uint (node, "extended_limit",
4714 ntohl (mp->extended_limit));
4715 vat_json_object_add_uint (node, "extended_bucket",
4716 ntohl (mp->extended_bucket));
4717 vat_json_object_add_uint (node, "last_update_time",
4718 ntohl (mp->last_update_time));
4719 vat_json_object_add_string_copy (node, "conform_action",
4720 conform_action_str);
4721 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4723 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4724 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
4725 vec_free (dscp_str);
4727 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
4728 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4730 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4731 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
4732 vec_free (dscp_str);
4734 vat_json_object_add_string_copy (node, "violate_action",
4735 violate_action_str);
4736 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4738 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4739 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
4740 vec_free (dscp_str);
4743 vec_free (rate_type_str);
4744 vec_free (round_type_str);
4745 vec_free (type_str);
4746 vec_free (conform_action_str);
4747 vec_free (exceed_action_str);
4748 vec_free (violate_action_str);
4752 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
4755 vat_main_t *vam = &vat_main;
4756 int i, count = ntohl (mp->count);
4759 print (vam->ofp, "classify table ids (%d) : ", count);
4760 for (i = 0; i < count; i++)
4762 print (vam->ofp, "%d", ntohl (mp->ids[i]));
4763 print (vam->ofp, (i < count - 1) ? "," : "");
4765 vam->retval = ntohl (mp->retval);
4766 vam->result_ready = 1;
4770 vl_api_classify_table_ids_reply_t_handler_json
4771 (vl_api_classify_table_ids_reply_t * mp)
4773 vat_main_t *vam = &vat_main;
4774 int i, count = ntohl (mp->count);
4778 vat_json_node_t node;
4780 vat_json_init_object (&node);
4781 for (i = 0; i < count; i++)
4783 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
4785 vat_json_print (vam->ofp, &node);
4786 vat_json_free (&node);
4788 vam->retval = ntohl (mp->retval);
4789 vam->result_ready = 1;
4793 vl_api_classify_table_by_interface_reply_t_handler
4794 (vl_api_classify_table_by_interface_reply_t * mp)
4796 vat_main_t *vam = &vat_main;
4799 table_id = ntohl (mp->l2_table_id);
4801 print (vam->ofp, "l2 table id : %d", table_id);
4803 print (vam->ofp, "l2 table id : No input ACL tables configured");
4804 table_id = ntohl (mp->ip4_table_id);
4806 print (vam->ofp, "ip4 table id : %d", table_id);
4808 print (vam->ofp, "ip4 table id : No input ACL tables configured");
4809 table_id = ntohl (mp->ip6_table_id);
4811 print (vam->ofp, "ip6 table id : %d", table_id);
4813 print (vam->ofp, "ip6 table id : No input ACL tables configured");
4814 vam->retval = ntohl (mp->retval);
4815 vam->result_ready = 1;
4819 vl_api_classify_table_by_interface_reply_t_handler_json
4820 (vl_api_classify_table_by_interface_reply_t * mp)
4822 vat_main_t *vam = &vat_main;
4823 vat_json_node_t node;
4825 vat_json_init_object (&node);
4827 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
4828 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
4829 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
4831 vat_json_print (vam->ofp, &node);
4832 vat_json_free (&node);
4834 vam->retval = ntohl (mp->retval);
4835 vam->result_ready = 1;
4838 static void vl_api_policer_add_del_reply_t_handler
4839 (vl_api_policer_add_del_reply_t * mp)
4841 vat_main_t *vam = &vat_main;
4842 i32 retval = ntohl (mp->retval);
4843 if (vam->async_mode)
4845 vam->async_errors += (retval < 0);
4849 vam->retval = retval;
4850 vam->result_ready = 1;
4851 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
4853 * Note: this is just barely thread-safe, depends on
4854 * the main thread spinning waiting for an answer...
4856 errmsg ("policer index %d", ntohl (mp->policer_index));
4860 static void vl_api_policer_add_del_reply_t_handler_json
4861 (vl_api_policer_add_del_reply_t * mp)
4863 vat_main_t *vam = &vat_main;
4864 vat_json_node_t node;
4866 vat_json_init_object (&node);
4867 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
4868 vat_json_object_add_uint (&node, "policer_index",
4869 ntohl (mp->policer_index));
4871 vat_json_print (vam->ofp, &node);
4872 vat_json_free (&node);
4874 vam->retval = ntohl (mp->retval);
4875 vam->result_ready = 1;
4878 /* Format hex dump. */
4880 format_hex_bytes (u8 * s, va_list * va)
4882 u8 *bytes = va_arg (*va, u8 *);
4883 int n_bytes = va_arg (*va, int);
4886 /* Print short or long form depending on byte count. */
4887 uword short_form = n_bytes <= 32;
4888 u32 indent = format_get_indent (s);
4893 for (i = 0; i < n_bytes; i++)
4895 if (!short_form && (i % 32) == 0)
4896 s = format (s, "%08x: ", i);
4897 s = format (s, "%02x", bytes[i]);
4898 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
4899 s = format (s, "\n%U", format_white_space, indent);
4906 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
4909 vat_main_t *vam = &vat_main;
4910 i32 retval = ntohl (mp->retval);
4913 print (vam->ofp, "classify table info :");
4914 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
4915 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
4916 ntohl (mp->miss_next_index));
4917 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
4918 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
4919 ntohl (mp->match_n_vectors));
4920 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
4921 ntohl (mp->mask_length));
4923 vam->retval = retval;
4924 vam->result_ready = 1;
4928 vl_api_classify_table_info_reply_t_handler_json
4929 (vl_api_classify_table_info_reply_t * mp)
4931 vat_main_t *vam = &vat_main;
4932 vat_json_node_t node;
4934 i32 retval = ntohl (mp->retval);
4937 vat_json_init_object (&node);
4939 vat_json_object_add_int (&node, "sessions",
4940 ntohl (mp->active_sessions));
4941 vat_json_object_add_int (&node, "nexttbl",
4942 ntohl (mp->next_table_index));
4943 vat_json_object_add_int (&node, "nextnode",
4944 ntohl (mp->miss_next_index));
4945 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
4946 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
4947 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
4948 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
4949 ntohl (mp->mask_length), 0);
4950 vat_json_object_add_string_copy (&node, "mask", s);
4952 vat_json_print (vam->ofp, &node);
4953 vat_json_free (&node);
4955 vam->retval = ntohl (mp->retval);
4956 vam->result_ready = 1;
4960 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
4963 vat_main_t *vam = &vat_main;
4965 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
4966 ntohl (mp->hit_next_index), ntohl (mp->advance),
4967 ntohl (mp->opaque_index));
4968 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
4969 ntohl (mp->match_length));
4973 vl_api_classify_session_details_t_handler_json
4974 (vl_api_classify_session_details_t * mp)
4976 vat_main_t *vam = &vat_main;
4977 vat_json_node_t *node = NULL;
4979 if (VAT_JSON_ARRAY != vam->json_tree.type)
4981 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4982 vat_json_init_array (&vam->json_tree);
4984 node = vat_json_array_add (&vam->json_tree);
4986 vat_json_init_object (node);
4987 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
4988 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
4989 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
4991 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
4993 vat_json_object_add_string_copy (node, "match", s);
4996 static void vl_api_pg_create_interface_reply_t_handler
4997 (vl_api_pg_create_interface_reply_t * mp)
4999 vat_main_t *vam = &vat_main;
5001 vam->retval = ntohl (mp->retval);
5002 vam->result_ready = 1;
5005 static void vl_api_pg_create_interface_reply_t_handler_json
5006 (vl_api_pg_create_interface_reply_t * mp)
5008 vat_main_t *vam = &vat_main;
5009 vat_json_node_t node;
5011 i32 retval = ntohl (mp->retval);
5014 vat_json_init_object (&node);
5016 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
5018 vat_json_print (vam->ofp, &node);
5019 vat_json_free (&node);
5021 vam->retval = ntohl (mp->retval);
5022 vam->result_ready = 1;
5025 static void vl_api_policer_classify_details_t_handler
5026 (vl_api_policer_classify_details_t * mp)
5028 vat_main_t *vam = &vat_main;
5030 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
5031 ntohl (mp->table_index));
5034 static void vl_api_policer_classify_details_t_handler_json
5035 (vl_api_policer_classify_details_t * mp)
5037 vat_main_t *vam = &vat_main;
5038 vat_json_node_t *node;
5040 if (VAT_JSON_ARRAY != vam->json_tree.type)
5042 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5043 vat_json_init_array (&vam->json_tree);
5045 node = vat_json_array_add (&vam->json_tree);
5047 vat_json_init_object (node);
5048 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5049 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5052 static void vl_api_ipsec_gre_tunnel_add_del_reply_t_handler
5053 (vl_api_ipsec_gre_tunnel_add_del_reply_t * mp)
5055 vat_main_t *vam = &vat_main;
5056 i32 retval = ntohl (mp->retval);
5057 if (vam->async_mode)
5059 vam->async_errors += (retval < 0);
5063 vam->retval = retval;
5064 vam->sw_if_index = ntohl (mp->sw_if_index);
5065 vam->result_ready = 1;
5067 vam->regenerate_interface_table = 1;
5070 static void vl_api_ipsec_gre_tunnel_add_del_reply_t_handler_json
5071 (vl_api_ipsec_gre_tunnel_add_del_reply_t * mp)
5073 vat_main_t *vam = &vat_main;
5074 vat_json_node_t node;
5076 vat_json_init_object (&node);
5077 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
5078 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
5080 vat_json_print (vam->ofp, &node);
5081 vat_json_free (&node);
5083 vam->retval = ntohl (mp->retval);
5084 vam->result_ready = 1;
5087 static void vl_api_flow_classify_details_t_handler
5088 (vl_api_flow_classify_details_t * mp)
5090 vat_main_t *vam = &vat_main;
5092 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
5093 ntohl (mp->table_index));
5096 static void vl_api_flow_classify_details_t_handler_json
5097 (vl_api_flow_classify_details_t * mp)
5099 vat_main_t *vam = &vat_main;
5100 vat_json_node_t *node;
5102 if (VAT_JSON_ARRAY != vam->json_tree.type)
5104 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5105 vat_json_init_array (&vam->json_tree);
5107 node = vat_json_array_add (&vam->json_tree);
5109 vat_json_init_object (node);
5110 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5111 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5114 #define vl_api_one_adjacencies_get_reply_t_endian vl_noop_handler
5115 #define vl_api_one_adjacencies_get_reply_t_print vl_noop_handler
5116 #define vl_api_one_l2_arp_bd_get_reply_t_print vl_noop_handler
5117 #define vl_api_one_l2_arp_entries_get_reply_t_endian vl_noop_handler
5118 #define vl_api_one_l2_arp_entries_get_reply_t_print vl_noop_handler
5119 #define vl_api_one_l2_arp_bd_get_reply_t_endian vl_noop_handler
5120 #define vl_api_one_ndp_bd_get_reply_t_endian vl_noop_handler
5121 #define vl_api_one_ndp_bd_get_reply_t_print vl_noop_handler
5122 #define vl_api_one_ndp_entries_get_reply_t_print vl_noop_handler
5123 #define vl_api_one_ndp_entries_get_reply_t_endian vl_noop_handler
5126 * Generate boilerplate reply handlers, which
5127 * dig the return value out of the xxx_reply_t API message,
5128 * stick it into vam->retval, and set vam->result_ready
5130 * Could also do this by pointing N message decode slots at
5131 * a single function, but that could break in subtle ways.
5134 #define foreach_standard_reply_retval_handler \
5135 _(sw_interface_set_flags_reply) \
5136 _(sw_interface_add_del_address_reply) \
5137 _(sw_interface_set_rx_mode_reply) \
5138 _(sw_interface_set_rx_placement_reply) \
5139 _(sw_interface_set_table_reply) \
5140 _(sw_interface_set_mpls_enable_reply) \
5141 _(sw_interface_set_vpath_reply) \
5142 _(sw_interface_set_vxlan_bypass_reply) \
5143 _(sw_interface_set_geneve_bypass_reply) \
5144 _(sw_interface_set_vxlan_gpe_bypass_reply) \
5145 _(sw_interface_set_l2_bridge_reply) \
5146 _(bridge_domain_add_del_reply) \
5147 _(sw_interface_set_l2_xconnect_reply) \
5148 _(l2fib_add_del_reply) \
5149 _(l2fib_flush_int_reply) \
5150 _(l2fib_flush_bd_reply) \
5151 _(ip_add_del_route_reply) \
5152 _(ip_table_add_del_reply) \
5153 _(ip_mroute_add_del_reply) \
5154 _(mpls_route_add_del_reply) \
5155 _(mpls_table_add_del_reply) \
5156 _(mpls_ip_bind_unbind_reply) \
5157 _(bier_route_add_del_reply) \
5158 _(bier_table_add_del_reply) \
5159 _(proxy_arp_add_del_reply) \
5160 _(proxy_arp_intfc_enable_disable_reply) \
5161 _(sw_interface_set_unnumbered_reply) \
5162 _(ip_neighbor_add_del_reply) \
5163 _(oam_add_del_reply) \
5164 _(reset_fib_reply) \
5165 _(dhcp_proxy_config_reply) \
5166 _(dhcp_proxy_set_vss_reply) \
5167 _(dhcp_client_config_reply) \
5168 _(set_ip_flow_hash_reply) \
5169 _(sw_interface_ip6_enable_disable_reply) \
5170 _(ip6nd_proxy_add_del_reply) \
5171 _(sw_interface_ip6nd_ra_prefix_reply) \
5172 _(sw_interface_ip6nd_ra_config_reply) \
5173 _(set_arp_neighbor_limit_reply) \
5174 _(l2_patch_add_del_reply) \
5175 _(sr_mpls_policy_add_reply) \
5176 _(sr_mpls_policy_mod_reply) \
5177 _(sr_mpls_policy_del_reply) \
5178 _(sr_policy_add_reply) \
5179 _(sr_policy_mod_reply) \
5180 _(sr_policy_del_reply) \
5181 _(sr_localsid_add_del_reply) \
5182 _(sr_steering_add_del_reply) \
5183 _(classify_add_del_session_reply) \
5184 _(classify_set_interface_ip_table_reply) \
5185 _(classify_set_interface_l2_tables_reply) \
5186 _(l2tpv3_set_tunnel_cookies_reply) \
5187 _(l2tpv3_interface_enable_disable_reply) \
5188 _(l2tpv3_set_lookup_key_reply) \
5189 _(l2_fib_clear_table_reply) \
5190 _(l2_interface_efp_filter_reply) \
5191 _(l2_interface_vlan_tag_rewrite_reply) \
5192 _(modify_vhost_user_if_reply) \
5193 _(delete_vhost_user_if_reply) \
5194 _(ip_probe_neighbor_reply) \
5195 _(ip_scan_neighbor_enable_disable_reply) \
5196 _(want_ip4_arp_events_reply) \
5197 _(want_ip6_nd_events_reply) \
5198 _(want_l2_macs_events_reply) \
5199 _(input_acl_set_interface_reply) \
5200 _(ipsec_spd_add_del_reply) \
5201 _(ipsec_interface_add_del_spd_reply) \
5202 _(ipsec_spd_entry_add_del_reply) \
5203 _(ipsec_sad_entry_add_del_reply) \
5204 _(ipsec_sa_set_key_reply) \
5205 _(ipsec_tunnel_if_add_del_reply) \
5206 _(ipsec_tunnel_if_set_key_reply) \
5207 _(ipsec_tunnel_if_set_sa_reply) \
5208 _(delete_loopback_reply) \
5209 _(bd_ip_mac_add_del_reply) \
5210 _(bd_ip_mac_flush_reply) \
5211 _(want_interface_events_reply) \
5212 _(cop_interface_enable_disable_reply) \
5213 _(cop_whitelist_enable_disable_reply) \
5214 _(sw_interface_clear_stats_reply) \
5215 _(ioam_enable_reply) \
5216 _(ioam_disable_reply) \
5217 _(one_add_del_locator_reply) \
5218 _(one_add_del_local_eid_reply) \
5219 _(one_add_del_remote_mapping_reply) \
5220 _(one_add_del_adjacency_reply) \
5221 _(one_add_del_map_resolver_reply) \
5222 _(one_add_del_map_server_reply) \
5223 _(one_enable_disable_reply) \
5224 _(one_rloc_probe_enable_disable_reply) \
5225 _(one_map_register_enable_disable_reply) \
5226 _(one_map_register_set_ttl_reply) \
5227 _(one_set_transport_protocol_reply) \
5228 _(one_map_register_fallback_threshold_reply) \
5229 _(one_pitr_set_locator_set_reply) \
5230 _(one_map_request_mode_reply) \
5231 _(one_add_del_map_request_itr_rlocs_reply) \
5232 _(one_eid_table_add_del_map_reply) \
5233 _(one_use_petr_reply) \
5234 _(one_stats_enable_disable_reply) \
5235 _(one_add_del_l2_arp_entry_reply) \
5236 _(one_add_del_ndp_entry_reply) \
5237 _(one_stats_flush_reply) \
5238 _(one_enable_disable_xtr_mode_reply) \
5239 _(one_enable_disable_pitr_mode_reply) \
5240 _(one_enable_disable_petr_mode_reply) \
5241 _(gpe_enable_disable_reply) \
5242 _(gpe_set_encap_mode_reply) \
5243 _(gpe_add_del_iface_reply) \
5244 _(gpe_add_del_native_fwd_rpath_reply) \
5245 _(af_packet_delete_reply) \
5246 _(policer_classify_set_interface_reply) \
5247 _(netmap_create_reply) \
5248 _(netmap_delete_reply) \
5249 _(set_ipfix_exporter_reply) \
5250 _(set_ipfix_classify_stream_reply) \
5251 _(ipfix_classify_table_add_del_reply) \
5252 _(flow_classify_set_interface_reply) \
5253 _(sw_interface_span_enable_disable_reply) \
5254 _(pg_capture_reply) \
5255 _(pg_enable_disable_reply) \
5256 _(ip_source_and_port_range_check_add_del_reply) \
5257 _(ip_source_and_port_range_check_interface_add_del_reply)\
5258 _(delete_subif_reply) \
5259 _(l2_interface_pbb_tag_rewrite_reply) \
5261 _(feature_enable_disable_reply) \
5262 _(sw_interface_tag_add_del_reply) \
5263 _(hw_interface_set_mtu_reply) \
5264 _(p2p_ethernet_add_reply) \
5265 _(p2p_ethernet_del_reply) \
5266 _(lldp_config_reply) \
5267 _(sw_interface_set_lldp_reply) \
5268 _(tcp_configure_src_addresses_reply) \
5269 _(dns_enable_disable_reply) \
5270 _(dns_name_server_add_del_reply) \
5271 _(session_rule_add_del_reply) \
5272 _(ip_container_proxy_add_del_reply) \
5273 _(output_acl_set_interface_reply) \
5274 _(qos_record_enable_disable_reply)
5277 static void vl_api_##n##_t_handler \
5278 (vl_api_##n##_t * mp) \
5280 vat_main_t * vam = &vat_main; \
5281 i32 retval = ntohl(mp->retval); \
5282 if (vam->async_mode) { \
5283 vam->async_errors += (retval < 0); \
5285 vam->retval = retval; \
5286 vam->result_ready = 1; \
5289 foreach_standard_reply_retval_handler;
5293 static void vl_api_##n##_t_handler_json \
5294 (vl_api_##n##_t * mp) \
5296 vat_main_t * vam = &vat_main; \
5297 vat_json_node_t node; \
5298 vat_json_init_object(&node); \
5299 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
5300 vat_json_print(vam->ofp, &node); \
5301 vam->retval = ntohl(mp->retval); \
5302 vam->result_ready = 1; \
5304 foreach_standard_reply_retval_handler;
5308 * Table of message reply handlers, must include boilerplate handlers
5312 #define foreach_vpe_api_reply_msg \
5313 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
5314 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
5315 _(SW_INTERFACE_DETAILS, sw_interface_details) \
5316 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
5317 _(CONTROL_PING_REPLY, control_ping_reply) \
5318 _(CLI_REPLY, cli_reply) \
5319 _(CLI_INBAND_REPLY, cli_inband_reply) \
5320 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
5321 sw_interface_add_del_address_reply) \
5322 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
5323 _(SW_INTERFACE_SET_RX_PLACEMENT_REPLY, sw_interface_set_rx_placement_reply) \
5324 _(SW_INTERFACE_RX_PLACEMENT_DETAILS, sw_interface_rx_placement_details) \
5325 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
5326 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
5327 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
5328 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
5329 _(SW_INTERFACE_SET_GENEVE_BYPASS_REPLY, sw_interface_set_geneve_bypass_reply) \
5330 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
5331 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
5332 sw_interface_set_l2_xconnect_reply) \
5333 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
5334 sw_interface_set_l2_bridge_reply) \
5335 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
5336 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
5337 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
5338 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
5339 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
5340 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
5341 _(L2_FLAGS_REPLY, l2_flags_reply) \
5342 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
5343 _(TAP_CREATE_V2_REPLY, tap_create_v2_reply) \
5344 _(TAP_DELETE_V2_REPLY, tap_delete_v2_reply) \
5345 _(SW_INTERFACE_TAP_V2_DETAILS, sw_interface_tap_v2_details) \
5346 _(VIRTIO_PCI_CREATE_REPLY, virtio_pci_create_reply) \
5347 _(VIRTIO_PCI_DELETE_REPLY, virtio_pci_delete_reply) \
5348 _(SW_INTERFACE_VIRTIO_PCI_DETAILS, sw_interface_virtio_pci_details) \
5349 _(BOND_CREATE_REPLY, bond_create_reply) \
5350 _(BOND_DELETE_REPLY, bond_delete_reply) \
5351 _(BOND_ENSLAVE_REPLY, bond_enslave_reply) \
5352 _(BOND_DETACH_SLAVE_REPLY, bond_detach_slave_reply) \
5353 _(SW_INTERFACE_BOND_DETAILS, sw_interface_bond_details) \
5354 _(SW_INTERFACE_SLAVE_DETAILS, sw_interface_slave_details) \
5355 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
5356 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
5357 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
5358 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
5359 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
5360 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
5361 _(BIER_ROUTE_ADD_DEL_REPLY, bier_route_add_del_reply) \
5362 _(BIER_TABLE_ADD_DEL_REPLY, bier_table_add_del_reply) \
5363 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
5364 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
5365 proxy_arp_intfc_enable_disable_reply) \
5366 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
5367 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
5368 sw_interface_set_unnumbered_reply) \
5369 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
5370 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
5371 _(CREATE_SUBIF_REPLY, create_subif_reply) \
5372 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
5373 _(RESET_FIB_REPLY, reset_fib_reply) \
5374 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
5375 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
5376 _(DHCP_PROXY_DETAILS, dhcp_proxy_details) \
5377 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
5378 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
5379 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
5380 sw_interface_ip6_enable_disable_reply) \
5381 _(IP6ND_PROXY_ADD_DEL_REPLY, ip6nd_proxy_add_del_reply) \
5382 _(IP6ND_PROXY_DETAILS, ip6nd_proxy_details) \
5383 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
5384 sw_interface_ip6nd_ra_prefix_reply) \
5385 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
5386 sw_interface_ip6nd_ra_config_reply) \
5387 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
5388 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
5389 _(SR_MPLS_POLICY_ADD_REPLY, sr_mpls_policy_add_reply) \
5390 _(SR_MPLS_POLICY_MOD_REPLY, sr_mpls_policy_mod_reply) \
5391 _(SR_MPLS_POLICY_DEL_REPLY, sr_mpls_policy_del_reply) \
5392 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
5393 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
5394 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
5395 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
5396 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
5397 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
5398 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
5399 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
5400 classify_set_interface_ip_table_reply) \
5401 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
5402 classify_set_interface_l2_tables_reply) \
5403 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
5404 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
5405 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
5406 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
5407 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
5408 l2tpv3_interface_enable_disable_reply) \
5409 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
5410 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
5411 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
5412 _(VXLAN_OFFLOAD_RX_REPLY, vxlan_offload_rx_reply) \
5413 _(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
5414 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
5415 _(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
5416 _(GRE_TUNNEL_ADD_DEL_REPLY, gre_tunnel_add_del_reply) \
5417 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
5418 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
5419 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
5420 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
5421 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
5422 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
5423 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
5424 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
5425 _(SHOW_VERSION_REPLY, show_version_reply) \
5426 _(SHOW_THREADS_REPLY, show_threads_reply) \
5427 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
5428 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
5429 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
5430 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
5431 _(IP_PROBE_NEIGHBOR_REPLY, ip_probe_neighbor_reply) \
5432 _(IP_SCAN_NEIGHBOR_ENABLE_DISABLE_REPLY, ip_scan_neighbor_enable_disable_reply) \
5433 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
5434 _(IP4_ARP_EVENT, ip4_arp_event) \
5435 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
5436 _(IP6_ND_EVENT, ip6_nd_event) \
5437 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
5438 _(L2_MACS_EVENT, l2_macs_event) \
5439 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
5440 _(IP_ADDRESS_DETAILS, ip_address_details) \
5441 _(IP_DETAILS, ip_details) \
5442 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
5443 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
5444 _(IPSEC_SPD_ENTRY_ADD_DEL_REPLY, ipsec_spd_entry_add_del_reply) \
5445 _(IPSEC_SAD_ENTRY_ADD_DEL_REPLY, ipsec_sad_entry_add_del_reply) \
5446 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
5447 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
5448 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
5449 _(IPSEC_TUNNEL_IF_SET_KEY_REPLY, ipsec_tunnel_if_set_key_reply) \
5450 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
5451 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
5452 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
5453 _(BD_IP_MAC_FLUSH_REPLY, bd_ip_mac_flush_reply) \
5454 _(BD_IP_MAC_DETAILS, bd_ip_mac_details) \
5455 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
5456 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
5457 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
5458 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
5459 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
5460 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
5461 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
5462 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
5463 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
5464 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
5465 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
5466 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
5467 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
5468 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
5469 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
5470 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
5471 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
5472 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
5473 one_map_register_enable_disable_reply) \
5474 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
5475 _(ONE_SET_TRANSPORT_PROTOCOL_REPLY, one_set_transport_protocol_reply) \
5476 _(ONE_GET_TRANSPORT_PROTOCOL_REPLY, one_get_transport_protocol_reply) \
5477 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5478 one_map_register_fallback_threshold_reply) \
5479 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
5480 one_rloc_probe_enable_disable_reply) \
5481 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
5482 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
5483 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
5484 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
5485 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
5486 _(ONE_LOCATOR_DETAILS, one_locator_details) \
5487 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
5488 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
5489 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
5490 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
5491 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
5492 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
5493 _(ONE_STATS_DETAILS, one_stats_details) \
5494 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
5495 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
5496 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
5497 show_one_stats_enable_disable_reply) \
5498 _(ONE_ADD_DEL_NDP_ENTRY_REPLY, one_add_del_ndp_entry_reply) \
5499 _(ONE_NDP_BD_GET_REPLY, one_ndp_bd_get_reply) \
5500 _(ONE_NDP_ENTRIES_GET_REPLY, one_ndp_entries_get_reply) \
5501 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
5502 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
5503 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
5504 _(ONE_ENABLE_DISABLE_XTR_MODE_REPLY, one_enable_disable_xtr_mode_reply) \
5505 _(ONE_ENABLE_DISABLE_PITR_MODE_REPLY, \
5506 one_enable_disable_pitr_mode_reply) \
5507 _(ONE_ENABLE_DISABLE_PETR_MODE_REPLY, \
5508 one_enable_disable_petr_mode_reply) \
5509 _(ONE_SHOW_XTR_MODE_REPLY, one_show_xtr_mode_reply) \
5510 _(ONE_SHOW_PITR_MODE_REPLY, one_show_pitr_mode_reply) \
5511 _(ONE_SHOW_PETR_MODE_REPLY, one_show_petr_mode_reply) \
5512 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
5513 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
5514 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
5515 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
5516 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
5517 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
5518 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
5519 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
5520 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
5521 gpe_add_del_native_fwd_rpath_reply) \
5522 _(GPE_FWD_ENTRY_PATH_DETAILS, \
5523 gpe_fwd_entry_path_details) \
5524 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
5525 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
5526 one_add_del_map_request_itr_rlocs_reply) \
5527 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
5528 one_get_map_request_itr_rlocs_reply) \
5529 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
5530 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
5531 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
5532 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
5533 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
5534 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
5535 show_one_map_register_state_reply) \
5536 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
5537 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5538 show_one_map_register_fallback_threshold_reply) \
5539 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
5540 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
5541 _(AF_PACKET_DETAILS, af_packet_details) \
5542 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
5543 _(POLICER_DETAILS, policer_details) \
5544 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
5545 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
5546 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
5547 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
5548 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
5549 _(MPLS_FIB_DETAILS, mpls_fib_details) \
5550 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
5551 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
5552 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
5553 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
5554 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
5555 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
5556 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
5557 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5558 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5559 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5560 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5561 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5562 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5563 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5564 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5565 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5566 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5567 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5568 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5569 ip_source_and_port_range_check_add_del_reply) \
5570 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5571 ip_source_and_port_range_check_interface_add_del_reply) \
5572 _(IPSEC_GRE_TUNNEL_ADD_DEL_REPLY, ipsec_gre_tunnel_add_del_reply) \
5573 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
5574 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5575 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5576 _(SET_PUNT_REPLY, set_punt_reply) \
5577 _(IP_FIB_DETAILS, ip_fib_details) \
5578 _(IP6_FIB_DETAILS, ip6_fib_details) \
5579 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5580 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5581 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5582 _(HW_INTERFACE_SET_MTU_REPLY, hw_interface_set_mtu_reply) \
5583 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
5584 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5585 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5586 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5587 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5588 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply) \
5589 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
5590 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
5591 _(DNS_ENABLE_DISABLE_REPLY, dns_enable_disable_reply) \
5592 _(DNS_NAME_SERVER_ADD_DEL_REPLY, dns_name_server_add_del_reply) \
5593 _(DNS_RESOLVE_NAME_REPLY, dns_resolve_name_reply) \
5594 _(DNS_RESOLVE_IP_REPLY, dns_resolve_ip_reply) \
5595 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
5596 _(SESSION_RULES_DETAILS, session_rules_details) \
5597 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
5598 _(OUTPUT_ACL_SET_INTERFACE_REPLY, output_acl_set_interface_reply) \
5599 _(QOS_RECORD_ENABLE_DISABLE_REPLY, qos_record_enable_disable_reply)
5601 #define foreach_standalone_reply_msg \
5602 _(SW_INTERFACE_EVENT, sw_interface_event)
5610 #define STR_VTR_OP_CASE(op) \
5611 case L2_VTR_ ## op: \
5615 str_vtr_op (u32 vtr_op)
5619 STR_VTR_OP_CASE (DISABLED);
5620 STR_VTR_OP_CASE (PUSH_1);
5621 STR_VTR_OP_CASE (PUSH_2);
5622 STR_VTR_OP_CASE (POP_1);
5623 STR_VTR_OP_CASE (POP_2);
5624 STR_VTR_OP_CASE (TRANSLATE_1_1);
5625 STR_VTR_OP_CASE (TRANSLATE_1_2);
5626 STR_VTR_OP_CASE (TRANSLATE_2_1);
5627 STR_VTR_OP_CASE (TRANSLATE_2_2);
5634 dump_sub_interface_table (vat_main_t * vam)
5636 const sw_interface_subif_t *sub = NULL;
5638 if (vam->json_output)
5641 ("JSON output supported only for VPE API calls and dump_stats_table");
5646 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5647 "Interface", "sw_if_index",
5648 "sub id", "dot1ad", "tags", "outer id",
5649 "inner id", "exact", "default", "outer any", "inner any");
5651 vec_foreach (sub, vam->sw_if_subif_table)
5654 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5655 sub->interface_name,
5657 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5658 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5659 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5660 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5661 if (sub->vtr_op != L2_VTR_DISABLED)
5664 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
5665 "tag1: %d tag2: %d ]",
5666 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
5667 sub->vtr_tag1, sub->vtr_tag2);
5675 name_sort_cmp (void *a1, void *a2)
5677 name_sort_t *n1 = a1;
5678 name_sort_t *n2 = a2;
5680 return strcmp ((char *) n1->name, (char *) n2->name);
5684 dump_interface_table (vat_main_t * vam)
5687 name_sort_t *nses = 0, *ns;
5689 if (vam->json_output)
5692 ("JSON output supported only for VPE API calls and dump_stats_table");
5697 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5699 vec_add2 (nses, ns, 1);
5700 ns->name = (u8 *)(p->key);
5701 ns->value = (u32) p->value[0];
5705 vec_sort_with_function (nses, name_sort_cmp);
5707 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
5708 vec_foreach (ns, nses)
5710 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
5717 dump_ip_table (vat_main_t * vam, int is_ipv6)
5719 const ip_details_t *det = NULL;
5720 const ip_address_details_t *address = NULL;
5723 print (vam->ofp, "%-12s", "sw_if_index");
5725 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
5732 print (vam->ofp, "%-12d", i);
5733 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
5738 vec_foreach (address, det->addr)
5742 is_ipv6 ? format_ip6_address : format_ip4_address,
5743 address->ip, address->prefix_length);
5751 dump_ipv4_table (vat_main_t * vam)
5753 if (vam->json_output)
5756 ("JSON output supported only for VPE API calls and dump_stats_table");
5760 return dump_ip_table (vam, 0);
5764 dump_ipv6_table (vat_main_t * vam)
5766 if (vam->json_output)
5769 ("JSON output supported only for VPE API calls and dump_stats_table");
5773 return dump_ip_table (vam, 1);
5777 * Pass CLI buffers directly in the CLI_INBAND API message,
5778 * instead of an additional shared memory area.
5781 exec_inband (vat_main_t * vam)
5783 vl_api_cli_inband_t *mp;
5784 unformat_input_t *i = vam->input;
5787 if (vec_len (i->buffer) == 0)
5790 if (vam->exec_mode == 0 && unformat (i, "mode"))
5795 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
5802 * In order for the CLI command to work, it
5803 * must be a vector ending in \n, not a C-string ending
5806 u32 len = vec_len (vam->input->buffer);
5807 M2 (CLI_INBAND, mp, len);
5808 vl_api_to_api_string (len - 1, (const char *) vam->input->buffer, &mp->cmd);
5812 /* json responses may or may not include a useful reply... */
5813 if (vec_len (vam->cmd_reply))
5814 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
5819 exec (vat_main_t * vam)
5821 return exec_inband (vam);
5825 api_create_loopback (vat_main_t * vam)
5827 unformat_input_t *i = vam->input;
5828 vl_api_create_loopback_t *mp;
5829 vl_api_create_loopback_instance_t *mp_lbi;
5832 u8 is_specified = 0;
5833 u32 user_instance = 0;
5836 clib_memset (mac_address, 0, sizeof (mac_address));
5838 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5840 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5842 if (unformat (i, "instance %d", &user_instance))
5850 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
5851 mp_lbi->is_specified = is_specified;
5853 mp_lbi->user_instance = htonl (user_instance);
5855 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
5860 /* Construct the API message */
5861 M (CREATE_LOOPBACK, mp);
5863 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
5872 api_delete_loopback (vat_main_t * vam)
5874 unformat_input_t *i = vam->input;
5875 vl_api_delete_loopback_t *mp;
5876 u32 sw_if_index = ~0;
5879 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5881 if (unformat (i, "sw_if_index %d", &sw_if_index))
5887 if (sw_if_index == ~0)
5889 errmsg ("missing sw_if_index");
5893 /* Construct the API message */
5894 M (DELETE_LOOPBACK, mp);
5895 mp->sw_if_index = ntohl (sw_if_index);
5903 api_want_interface_events (vat_main_t * vam)
5905 unformat_input_t *i = vam->input;
5906 vl_api_want_interface_events_t *mp;
5910 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5912 if (unformat (i, "enable"))
5914 else if (unformat (i, "disable"))
5922 errmsg ("missing enable|disable");
5926 M (WANT_INTERFACE_EVENTS, mp);
5927 mp->enable_disable = enable;
5929 vam->interface_event_display = enable;
5937 /* Note: non-static, called once to set up the initial intfc table */
5939 api_sw_interface_dump (vat_main_t * vam)
5941 vl_api_sw_interface_dump_t *mp;
5942 vl_api_control_ping_t *mp_ping;
5944 name_sort_t *nses = 0, *ns;
5945 sw_interface_subif_t *sub = NULL;
5948 /* Toss the old name table */
5950 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5952 vec_add2 (nses, ns, 1);
5953 ns->name = (u8 *)(p->key);
5954 ns->value = (u32) p->value[0];
5958 hash_free (vam->sw_if_index_by_interface_name);
5960 vec_foreach (ns, nses) vec_free (ns->name);
5964 vec_foreach (sub, vam->sw_if_subif_table)
5966 vec_free (sub->interface_name);
5968 vec_free (vam->sw_if_subif_table);
5970 /* recreate the interface name hash table */
5971 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
5974 * Ask for all interface names. Otherwise, the epic catalog of
5975 * name filters becomes ridiculously long, and vat ends up needing
5976 * to be taught about new interface types.
5978 M (SW_INTERFACE_DUMP, mp);
5981 /* Use a control ping for synchronization */
5982 MPING (CONTROL_PING, mp_ping);
5990 api_sw_interface_set_flags (vat_main_t * vam)
5992 unformat_input_t *i = vam->input;
5993 vl_api_sw_interface_set_flags_t *mp;
5995 u8 sw_if_index_set = 0;
5999 /* Parse args required to build the message */
6000 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6002 if (unformat (i, "admin-up"))
6004 else if (unformat (i, "admin-down"))
6007 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6008 sw_if_index_set = 1;
6009 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6010 sw_if_index_set = 1;
6015 if (sw_if_index_set == 0)
6017 errmsg ("missing interface name or sw_if_index");
6021 /* Construct the API message */
6022 M (SW_INTERFACE_SET_FLAGS, mp);
6023 mp->sw_if_index = ntohl (sw_if_index);
6024 mp->admin_up_down = admin_up;
6029 /* Wait for a reply, return the good/bad news... */
6035 api_sw_interface_set_rx_mode (vat_main_t * vam)
6037 unformat_input_t *i = vam->input;
6038 vl_api_sw_interface_set_rx_mode_t *mp;
6040 u8 sw_if_index_set = 0;
6042 u8 queue_id_valid = 0;
6044 vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN;
6046 /* Parse args required to build the message */
6047 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6049 if (unformat (i, "queue %d", &queue_id))
6051 else if (unformat (i, "polling"))
6052 mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
6053 else if (unformat (i, "interrupt"))
6054 mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT;
6055 else if (unformat (i, "adaptive"))
6056 mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE;
6058 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6059 sw_if_index_set = 1;
6060 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6061 sw_if_index_set = 1;
6066 if (sw_if_index_set == 0)
6068 errmsg ("missing interface name or sw_if_index");
6071 if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
6073 errmsg ("missing rx-mode");
6077 /* Construct the API message */
6078 M (SW_INTERFACE_SET_RX_MODE, mp);
6079 mp->sw_if_index = ntohl (sw_if_index);
6081 mp->queue_id_valid = queue_id_valid;
6082 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
6087 /* Wait for a reply, return the good/bad news... */
6093 api_sw_interface_set_rx_placement (vat_main_t * vam)
6095 unformat_input_t *i = vam->input;
6096 vl_api_sw_interface_set_rx_placement_t *mp;
6098 u8 sw_if_index_set = 0;
6101 u32 queue_id, thread_index;
6103 /* Parse args required to build the message */
6104 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6106 if (unformat (i, "queue %d", &queue_id))
6108 else if (unformat (i, "main"))
6110 else if (unformat (i, "worker %d", &thread_index))
6113 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6114 sw_if_index_set = 1;
6115 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6116 sw_if_index_set = 1;
6121 if (sw_if_index_set == 0)
6123 errmsg ("missing interface name or sw_if_index");
6129 /* Construct the API message */
6130 M (SW_INTERFACE_SET_RX_PLACEMENT, mp);
6131 mp->sw_if_index = ntohl (sw_if_index);
6132 mp->worker_id = ntohl (thread_index);
6133 mp->queue_id = ntohl (queue_id);
6134 mp->is_main = is_main;
6138 /* Wait for a reply, return the good/bad news... */
6143 static void vl_api_sw_interface_rx_placement_details_t_handler
6144 (vl_api_sw_interface_rx_placement_details_t * mp)
6146 vat_main_t *vam = &vat_main;
6147 u32 worker_id = ntohl (mp->worker_id);
6150 "\n%-11d %-11s %-6d %-5d %-9s",
6151 ntohl (mp->sw_if_index), (worker_id == 0) ? "main" : "worker",
6152 worker_id, ntohl (mp->queue_id),
6154 1) ? "polling" : ((mp->mode == 2) ? "interrupt" : "adaptive"));
6157 static void vl_api_sw_interface_rx_placement_details_t_handler_json
6158 (vl_api_sw_interface_rx_placement_details_t * mp)
6160 vat_main_t *vam = &vat_main;
6161 vat_json_node_t *node = NULL;
6163 if (VAT_JSON_ARRAY != vam->json_tree.type)
6165 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
6166 vat_json_init_array (&vam->json_tree);
6168 node = vat_json_array_add (&vam->json_tree);
6170 vat_json_init_object (node);
6171 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
6172 vat_json_object_add_uint (node, "worker_id", ntohl (mp->worker_id));
6173 vat_json_object_add_uint (node, "queue_id", ntohl (mp->queue_id));
6174 vat_json_object_add_uint (node, "mode", mp->mode);
6178 api_sw_interface_rx_placement_dump (vat_main_t * vam)
6180 unformat_input_t *i = vam->input;
6181 vl_api_sw_interface_rx_placement_dump_t *mp;
6182 vl_api_control_ping_t *mp_ping;
6185 u8 sw_if_index_set = 0;
6187 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6189 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6191 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6198 "\n%-11s %-11s %-6s %-5s %-4s",
6199 "sw_if_index", "main/worker", "thread", "queue", "mode");
6201 /* Dump Interface rx placement */
6202 M (SW_INTERFACE_RX_PLACEMENT_DUMP, mp);
6204 if (sw_if_index_set)
6205 mp->sw_if_index = htonl (sw_if_index);
6207 mp->sw_if_index = ~0;
6211 /* Use a control ping for synchronization */
6212 MPING (CONTROL_PING, mp_ping);
6220 api_sw_interface_clear_stats (vat_main_t * vam)
6222 unformat_input_t *i = vam->input;
6223 vl_api_sw_interface_clear_stats_t *mp;
6225 u8 sw_if_index_set = 0;
6228 /* Parse args required to build the message */
6229 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6231 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6232 sw_if_index_set = 1;
6233 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6234 sw_if_index_set = 1;
6239 /* Construct the API message */
6240 M (SW_INTERFACE_CLEAR_STATS, mp);
6242 if (sw_if_index_set == 1)
6243 mp->sw_if_index = ntohl (sw_if_index);
6245 mp->sw_if_index = ~0;
6250 /* Wait for a reply, return the good/bad news... */
6256 api_sw_interface_add_del_address (vat_main_t * vam)
6258 unformat_input_t *i = vam->input;
6259 vl_api_sw_interface_add_del_address_t *mp;
6261 u8 sw_if_index_set = 0;
6262 u8 is_add = 1, del_all = 0;
6263 u32 address_length = 0;
6264 u8 v4_address_set = 0;
6265 u8 v6_address_set = 0;
6266 ip4_address_t v4address;
6267 ip6_address_t v6address;
6270 /* Parse args required to build the message */
6271 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6273 if (unformat (i, "del-all"))
6275 else if (unformat (i, "del"))
6278 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6279 sw_if_index_set = 1;
6280 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6281 sw_if_index_set = 1;
6282 else if (unformat (i, "%U/%d",
6283 unformat_ip4_address, &v4address, &address_length))
6285 else if (unformat (i, "%U/%d",
6286 unformat_ip6_address, &v6address, &address_length))
6292 if (sw_if_index_set == 0)
6294 errmsg ("missing interface name or sw_if_index");
6297 if (v4_address_set && v6_address_set)
6299 errmsg ("both v4 and v6 addresses set");
6302 if (!v4_address_set && !v6_address_set && !del_all)
6304 errmsg ("no addresses set");
6308 /* Construct the API message */
6309 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
6311 mp->sw_if_index = ntohl (sw_if_index);
6312 mp->is_add = is_add;
6313 mp->del_all = del_all;
6317 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6321 clib_memcpy (mp->address, &v4address, sizeof (v4address));
6323 mp->address_length = address_length;
6328 /* Wait for a reply, return good/bad news */
6334 api_sw_interface_set_mpls_enable (vat_main_t * vam)
6336 unformat_input_t *i = vam->input;
6337 vl_api_sw_interface_set_mpls_enable_t *mp;
6339 u8 sw_if_index_set = 0;
6343 /* Parse args required to build the message */
6344 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6346 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6347 sw_if_index_set = 1;
6348 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6349 sw_if_index_set = 1;
6350 else if (unformat (i, "disable"))
6352 else if (unformat (i, "dis"))
6358 if (sw_if_index_set == 0)
6360 errmsg ("missing interface name or sw_if_index");
6364 /* Construct the API message */
6365 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
6367 mp->sw_if_index = ntohl (sw_if_index);
6368 mp->enable = enable;
6373 /* Wait for a reply... */
6379 api_sw_interface_set_table (vat_main_t * vam)
6381 unformat_input_t *i = vam->input;
6382 vl_api_sw_interface_set_table_t *mp;
6383 u32 sw_if_index, vrf_id = 0;
6384 u8 sw_if_index_set = 0;
6388 /* Parse args required to build the message */
6389 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6391 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6392 sw_if_index_set = 1;
6393 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6394 sw_if_index_set = 1;
6395 else if (unformat (i, "vrf %d", &vrf_id))
6397 else if (unformat (i, "ipv6"))
6403 if (sw_if_index_set == 0)
6405 errmsg ("missing interface name or sw_if_index");
6409 /* Construct the API message */
6410 M (SW_INTERFACE_SET_TABLE, mp);
6412 mp->sw_if_index = ntohl (sw_if_index);
6413 mp->is_ipv6 = is_ipv6;
6414 mp->vrf_id = ntohl (vrf_id);
6419 /* Wait for a reply... */
6424 static void vl_api_sw_interface_get_table_reply_t_handler
6425 (vl_api_sw_interface_get_table_reply_t * mp)
6427 vat_main_t *vam = &vat_main;
6429 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6431 vam->retval = ntohl (mp->retval);
6432 vam->result_ready = 1;
6436 static void vl_api_sw_interface_get_table_reply_t_handler_json
6437 (vl_api_sw_interface_get_table_reply_t * mp)
6439 vat_main_t *vam = &vat_main;
6440 vat_json_node_t node;
6442 vat_json_init_object (&node);
6443 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6444 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6446 vat_json_print (vam->ofp, &node);
6447 vat_json_free (&node);
6449 vam->retval = ntohl (mp->retval);
6450 vam->result_ready = 1;
6454 api_sw_interface_get_table (vat_main_t * vam)
6456 unformat_input_t *i = vam->input;
6457 vl_api_sw_interface_get_table_t *mp;
6459 u8 sw_if_index_set = 0;
6463 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6465 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6466 sw_if_index_set = 1;
6467 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6468 sw_if_index_set = 1;
6469 else if (unformat (i, "ipv6"))
6475 if (sw_if_index_set == 0)
6477 errmsg ("missing interface name or sw_if_index");
6481 M (SW_INTERFACE_GET_TABLE, mp);
6482 mp->sw_if_index = htonl (sw_if_index);
6483 mp->is_ipv6 = is_ipv6;
6491 api_sw_interface_set_vpath (vat_main_t * vam)
6493 unformat_input_t *i = vam->input;
6494 vl_api_sw_interface_set_vpath_t *mp;
6495 u32 sw_if_index = 0;
6496 u8 sw_if_index_set = 0;
6500 /* Parse args required to build the message */
6501 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6503 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6504 sw_if_index_set = 1;
6505 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6506 sw_if_index_set = 1;
6507 else if (unformat (i, "enable"))
6509 else if (unformat (i, "disable"))
6515 if (sw_if_index_set == 0)
6517 errmsg ("missing interface name or sw_if_index");
6521 /* Construct the API message */
6522 M (SW_INTERFACE_SET_VPATH, mp);
6524 mp->sw_if_index = ntohl (sw_if_index);
6525 mp->enable = is_enable;
6530 /* Wait for a reply... */
6536 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
6538 unformat_input_t *i = vam->input;
6539 vl_api_sw_interface_set_vxlan_bypass_t *mp;
6540 u32 sw_if_index = 0;
6541 u8 sw_if_index_set = 0;
6546 /* Parse args required to build the message */
6547 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6549 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6550 sw_if_index_set = 1;
6551 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6552 sw_if_index_set = 1;
6553 else if (unformat (i, "enable"))
6555 else if (unformat (i, "disable"))
6557 else if (unformat (i, "ip4"))
6559 else if (unformat (i, "ip6"))
6565 if (sw_if_index_set == 0)
6567 errmsg ("missing interface name or sw_if_index");
6571 /* Construct the API message */
6572 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
6574 mp->sw_if_index = ntohl (sw_if_index);
6575 mp->enable = is_enable;
6576 mp->is_ipv6 = is_ipv6;
6581 /* Wait for a reply... */
6587 api_sw_interface_set_geneve_bypass (vat_main_t * vam)
6589 unformat_input_t *i = vam->input;
6590 vl_api_sw_interface_set_geneve_bypass_t *mp;
6591 u32 sw_if_index = 0;
6592 u8 sw_if_index_set = 0;
6597 /* Parse args required to build the message */
6598 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6600 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6601 sw_if_index_set = 1;
6602 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6603 sw_if_index_set = 1;
6604 else if (unformat (i, "enable"))
6606 else if (unformat (i, "disable"))
6608 else if (unformat (i, "ip4"))
6610 else if (unformat (i, "ip6"))
6616 if (sw_if_index_set == 0)
6618 errmsg ("missing interface name or sw_if_index");
6622 /* Construct the API message */
6623 M (SW_INTERFACE_SET_GENEVE_BYPASS, mp);
6625 mp->sw_if_index = ntohl (sw_if_index);
6626 mp->enable = is_enable;
6627 mp->is_ipv6 = is_ipv6;
6632 /* Wait for a reply... */
6638 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
6640 unformat_input_t *i = vam->input;
6641 vl_api_sw_interface_set_l2_xconnect_t *mp;
6643 u8 rx_sw_if_index_set = 0;
6645 u8 tx_sw_if_index_set = 0;
6649 /* Parse args required to build the message */
6650 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6652 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6653 rx_sw_if_index_set = 1;
6654 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6655 tx_sw_if_index_set = 1;
6656 else if (unformat (i, "rx"))
6658 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6660 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6662 rx_sw_if_index_set = 1;
6667 else if (unformat (i, "tx"))
6669 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6671 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6673 tx_sw_if_index_set = 1;
6678 else if (unformat (i, "enable"))
6680 else if (unformat (i, "disable"))
6686 if (rx_sw_if_index_set == 0)
6688 errmsg ("missing rx interface name or rx_sw_if_index");
6692 if (enable && (tx_sw_if_index_set == 0))
6694 errmsg ("missing tx interface name or tx_sw_if_index");
6698 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
6700 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6701 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6702 mp->enable = enable;
6710 api_sw_interface_set_l2_bridge (vat_main_t * vam)
6712 unformat_input_t *i = vam->input;
6713 vl_api_sw_interface_set_l2_bridge_t *mp;
6714 vl_api_l2_port_type_t port_type;
6716 u8 rx_sw_if_index_set = 0;
6723 port_type = L2_API_PORT_TYPE_NORMAL;
6725 /* Parse args required to build the message */
6726 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6728 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
6729 rx_sw_if_index_set = 1;
6730 else if (unformat (i, "bd_id %d", &bd_id))
6734 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
6735 rx_sw_if_index_set = 1;
6736 else if (unformat (i, "shg %d", &shg))
6738 else if (unformat (i, "bvi"))
6739 port_type = L2_API_PORT_TYPE_BVI;
6740 else if (unformat (i, "uu-fwd"))
6741 port_type = L2_API_PORT_TYPE_UU_FWD;
6742 else if (unformat (i, "enable"))
6744 else if (unformat (i, "disable"))
6750 if (rx_sw_if_index_set == 0)
6752 errmsg ("missing rx interface name or sw_if_index");
6756 if (enable && (bd_id_set == 0))
6758 errmsg ("missing bridge domain");
6762 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
6764 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6765 mp->bd_id = ntohl (bd_id);
6767 mp->port_type = ntohl (port_type);
6768 mp->enable = enable;
6776 api_bridge_domain_dump (vat_main_t * vam)
6778 unformat_input_t *i = vam->input;
6779 vl_api_bridge_domain_dump_t *mp;
6780 vl_api_control_ping_t *mp_ping;
6784 /* Parse args required to build the message */
6785 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6787 if (unformat (i, "bd_id %d", &bd_id))
6793 M (BRIDGE_DOMAIN_DUMP, mp);
6794 mp->bd_id = ntohl (bd_id);
6797 /* Use a control ping for synchronization */
6798 MPING (CONTROL_PING, mp_ping);
6806 api_bridge_domain_add_del (vat_main_t * vam)
6808 unformat_input_t *i = vam->input;
6809 vl_api_bridge_domain_add_del_t *mp;
6812 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
6817 /* Parse args required to build the message */
6818 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6820 if (unformat (i, "bd_id %d", &bd_id))
6822 else if (unformat (i, "flood %d", &flood))
6824 else if (unformat (i, "uu-flood %d", &uu_flood))
6826 else if (unformat (i, "forward %d", &forward))
6828 else if (unformat (i, "learn %d", &learn))
6830 else if (unformat (i, "arp-term %d", &arp_term))
6832 else if (unformat (i, "mac-age %d", &mac_age))
6834 else if (unformat (i, "bd-tag %s", &bd_tag))
6836 else if (unformat (i, "del"))
6839 flood = uu_flood = forward = learn = 0;
6847 errmsg ("missing bridge domain");
6854 errmsg ("mac age must be less than 256 ");
6859 if ((bd_tag) && (vec_len (bd_tag) > 63))
6861 errmsg ("bd-tag cannot be longer than 63");
6866 M (BRIDGE_DOMAIN_ADD_DEL, mp);
6868 mp->bd_id = ntohl (bd_id);
6870 mp->uu_flood = uu_flood;
6871 mp->forward = forward;
6873 mp->arp_term = arp_term;
6874 mp->is_add = is_add;
6875 mp->mac_age = (u8) mac_age;
6878 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
6879 mp->bd_tag[vec_len (bd_tag)] = 0;
6890 api_l2fib_flush_bd (vat_main_t * vam)
6892 unformat_input_t *i = vam->input;
6893 vl_api_l2fib_flush_bd_t *mp;
6897 /* Parse args required to build the message */
6898 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6900 if (unformat (i, "bd_id %d", &bd_id));
6907 errmsg ("missing bridge domain");
6911 M (L2FIB_FLUSH_BD, mp);
6913 mp->bd_id = htonl (bd_id);
6921 api_l2fib_flush_int (vat_main_t * vam)
6923 unformat_input_t *i = vam->input;
6924 vl_api_l2fib_flush_int_t *mp;
6925 u32 sw_if_index = ~0;
6928 /* Parse args required to build the message */
6929 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6931 if (unformat (i, "sw_if_index %d", &sw_if_index));
6933 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
6938 if (sw_if_index == ~0)
6940 errmsg ("missing interface name or sw_if_index");
6944 M (L2FIB_FLUSH_INT, mp);
6946 mp->sw_if_index = ntohl (sw_if_index);
6954 api_l2fib_add_del (vat_main_t * vam)
6956 unformat_input_t *i = vam->input;
6957 vl_api_l2fib_add_del_t *mp;
6963 u32 sw_if_index = 0;
6964 u8 sw_if_index_set = 0;
6973 /* Parse args required to build the message */
6974 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6976 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
6978 else if (unformat (i, "bd_id %d", &bd_id))
6980 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6981 sw_if_index_set = 1;
6982 else if (unformat (i, "sw_if"))
6984 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6987 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6988 sw_if_index_set = 1;
6993 else if (unformat (i, "static"))
6995 else if (unformat (i, "filter"))
7000 else if (unformat (i, "bvi"))
7005 else if (unformat (i, "del"))
7007 else if (unformat (i, "count %d", &count))
7015 errmsg ("missing mac address");
7021 errmsg ("missing bridge domain");
7025 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
7027 errmsg ("missing interface name or sw_if_index");
7033 /* Turn on async mode */
7034 vam->async_mode = 1;
7035 vam->async_errors = 0;
7036 before = vat_time_now (vam);
7039 for (j = 0; j < count; j++)
7041 M (L2FIB_ADD_DEL, mp);
7043 clib_memcpy (mp->mac, mac, 6);
7044 mp->bd_id = ntohl (bd_id);
7045 mp->is_add = is_add;
7046 mp->sw_if_index = ntohl (sw_if_index);
7050 mp->static_mac = static_mac;
7051 mp->filter_mac = filter_mac;
7052 mp->bvi_mac = bvi_mac;
7054 increment_mac_address (mac);
7061 vl_api_control_ping_t *mp_ping;
7064 /* Shut off async mode */
7065 vam->async_mode = 0;
7067 MPING (CONTROL_PING, mp_ping);
7070 timeout = vat_time_now (vam) + 1.0;
7071 while (vat_time_now (vam) < timeout)
7072 if (vam->result_ready == 1)
7077 if (vam->retval == -99)
7080 if (vam->async_errors > 0)
7082 errmsg ("%d asynchronous errors", vam->async_errors);
7085 vam->async_errors = 0;
7086 after = vat_time_now (vam);
7088 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
7089 count, after - before, count / (after - before));
7095 /* Wait for a reply... */
7099 /* Return the good/bad news */
7100 return (vam->retval);
7104 api_bridge_domain_set_mac_age (vat_main_t * vam)
7106 unformat_input_t *i = vam->input;
7107 vl_api_bridge_domain_set_mac_age_t *mp;
7112 /* Parse args required to build the message */
7113 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7115 if (unformat (i, "bd_id %d", &bd_id));
7116 else if (unformat (i, "mac-age %d", &mac_age));
7123 errmsg ("missing bridge domain");
7129 errmsg ("mac age must be less than 256 ");
7133 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
7135 mp->bd_id = htonl (bd_id);
7136 mp->mac_age = (u8) mac_age;
7144 api_l2_flags (vat_main_t * vam)
7146 unformat_input_t *i = vam->input;
7147 vl_api_l2_flags_t *mp;
7150 u8 sw_if_index_set = 0;
7154 /* Parse args required to build the message */
7155 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7157 if (unformat (i, "sw_if_index %d", &sw_if_index))
7158 sw_if_index_set = 1;
7159 else if (unformat (i, "sw_if"))
7161 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7164 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7165 sw_if_index_set = 1;
7170 else if (unformat (i, "learn"))
7172 else if (unformat (i, "forward"))
7174 else if (unformat (i, "flood"))
7176 else if (unformat (i, "uu-flood"))
7177 flags |= L2_UU_FLOOD;
7178 else if (unformat (i, "arp-term"))
7179 flags |= L2_ARP_TERM;
7180 else if (unformat (i, "off"))
7182 else if (unformat (i, "disable"))
7188 if (sw_if_index_set == 0)
7190 errmsg ("missing interface name or sw_if_index");
7196 mp->sw_if_index = ntohl (sw_if_index);
7197 mp->feature_bitmap = ntohl (flags);
7198 mp->is_set = is_set;
7206 api_bridge_flags (vat_main_t * vam)
7208 unformat_input_t *i = vam->input;
7209 vl_api_bridge_flags_t *mp;
7213 bd_flags_t flags = 0;
7216 /* Parse args required to build the message */
7217 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7219 if (unformat (i, "bd_id %d", &bd_id))
7221 else if (unformat (i, "learn"))
7222 flags |= BRIDGE_API_FLAG_LEARN;
7223 else if (unformat (i, "forward"))
7224 flags |= BRIDGE_API_FLAG_FWD;
7225 else if (unformat (i, "flood"))
7226 flags |= BRIDGE_API_FLAG_FLOOD;
7227 else if (unformat (i, "uu-flood"))
7228 flags |= BRIDGE_API_FLAG_UU_FLOOD;
7229 else if (unformat (i, "arp-term"))
7230 flags |= BRIDGE_API_FLAG_ARP_TERM;
7231 else if (unformat (i, "off"))
7233 else if (unformat (i, "disable"))
7241 errmsg ("missing bridge domain");
7245 M (BRIDGE_FLAGS, mp);
7247 mp->bd_id = ntohl (bd_id);
7248 mp->flags = ntohl (flags);
7249 mp->is_set = is_set;
7257 api_bd_ip_mac_add_del (vat_main_t * vam)
7259 vl_api_address_t ip = VL_API_ZERO_ADDRESS;
7260 vl_api_mac_address_t mac = { 0 };
7261 unformat_input_t *i = vam->input;
7262 vl_api_bd_ip_mac_add_del_t *mp;
7274 /* Parse args required to build the message */
7275 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7277 if (unformat (i, "bd_id %d", &bd_id))
7281 else if (unformat (i, "%U", unformat_vl_api_address, &ip))
7285 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
7289 else if (unformat (i, "del"))
7297 errmsg ("missing bridge domain");
7300 else if (ip_set == 0)
7302 errmsg ("missing IP address");
7305 else if (mac_set == 0)
7307 errmsg ("missing MAC address");
7311 M (BD_IP_MAC_ADD_DEL, mp);
7313 mp->bd_id = ntohl (bd_id);
7314 mp->is_add = is_add;
7316 clib_memcpy (&mp->ip, &ip, sizeof (ip));
7317 clib_memcpy (&mp->mac, &mac, sizeof (mac));
7325 api_bd_ip_mac_flush (vat_main_t * vam)
7327 unformat_input_t *i = vam->input;
7328 vl_api_bd_ip_mac_flush_t *mp;
7333 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7335 if (unformat (i, "bd_id %d", &bd_id))
7345 errmsg ("missing bridge domain");
7349 M (BD_IP_MAC_FLUSH, mp);
7351 mp->bd_id = ntohl (bd_id);
7358 static void vl_api_bd_ip_mac_details_t_handler
7359 (vl_api_bd_ip_mac_details_t * mp)
7361 vat_main_t *vam = &vat_main;
7366 format (0, "%U", format_ip4_address, (ip4_address_t *) mp->ip_address);
7369 format (0, "%U", format_ip6_address, (ip6_address_t *) mp->ip_address);
7372 "\n%-5d %-7s %-20U %-30s",
7373 ntohl (mp->bd_id), mp->is_ipv6 ? "ip6" : "ip4",
7374 format_ethernet_address, mp->mac_address, ip);
7379 static void vl_api_bd_ip_mac_details_t_handler_json
7380 (vl_api_bd_ip_mac_details_t * mp)
7382 vat_main_t *vam = &vat_main;
7383 vat_json_node_t *node = NULL;
7385 if (VAT_JSON_ARRAY != vam->json_tree.type)
7387 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7388 vat_json_init_array (&vam->json_tree);
7390 node = vat_json_array_add (&vam->json_tree);
7392 vat_json_init_object (node);
7393 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
7394 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6);
7395 vat_json_object_add_string_copy (node, "mac_address",
7396 format (0, "%U", format_ethernet_address,
7402 format (0, "%U", format_ip4_address, (ip4_address_t *) mp->ip_address);
7405 format (0, "%U", format_ip6_address, (ip6_address_t *) mp->ip_address);
7406 vat_json_object_add_string_copy (node, "ip_address", ip);
7411 api_bd_ip_mac_dump (vat_main_t * vam)
7413 unformat_input_t *i = vam->input;
7414 vl_api_bd_ip_mac_dump_t *mp;
7415 vl_api_control_ping_t *mp_ping;
7420 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7422 if (unformat (i, "bd_id %d", &bd_id))
7431 "\n%-5s %-7s %-20s %-30s",
7432 "bd_id", "is_ipv6", "mac_address", "ip_address");
7434 /* Dump Bridge Domain Ip to Mac entries */
7435 M (BD_IP_MAC_DUMP, mp);
7438 mp->bd_id = htonl (bd_id);
7444 /* Use a control ping for synchronization */
7445 MPING (CONTROL_PING, mp_ping);
7453 api_tap_create_v2 (vat_main_t * vam)
7455 unformat_input_t *i = vam->input;
7456 vl_api_tap_create_v2_t *mp;
7460 u8 *host_if_name = 0;
7462 u8 host_mac_addr[6];
7463 u8 host_mac_addr_set = 0;
7464 u8 *host_bridge = 0;
7465 ip4_address_t host_ip4_addr;
7466 ip4_address_t host_ip4_gw;
7467 u8 host_ip4_gw_set = 0;
7468 u32 host_ip4_prefix_len = 0;
7469 ip6_address_t host_ip6_addr;
7470 ip6_address_t host_ip6_gw;
7471 u8 host_ip6_gw_set = 0;
7472 u32 host_ip6_prefix_len = 0;
7474 u32 rx_ring_sz = 0, tx_ring_sz = 0;
7476 clib_memset (mac_address, 0, sizeof (mac_address));
7478 /* Parse args required to build the message */
7479 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7481 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7485 else if (unformat (i, "id %u", &id))
7487 else if (unformat (i, "host-if-name %s", &host_if_name))
7489 else if (unformat (i, "host-ns %s", &host_ns))
7491 else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
7493 host_mac_addr_set = 1;
7494 else if (unformat (i, "host-bridge %s", &host_bridge))
7496 else if (unformat (i, "host-ip4-addr %U/%d", unformat_ip4_address,
7497 &host_ip4_addr, &host_ip4_prefix_len))
7499 else if (unformat (i, "host-ip6-addr %U/%d", unformat_ip6_address,
7500 &host_ip6_addr, &host_ip6_prefix_len))
7502 else if (unformat (i, "host-ip4-gw %U", unformat_ip4_address,
7504 host_ip4_gw_set = 1;
7505 else if (unformat (i, "host-ip6-gw %U", unformat_ip6_address,
7507 host_ip6_gw_set = 1;
7508 else if (unformat (i, "rx-ring-size %d", &rx_ring_sz))
7510 else if (unformat (i, "tx-ring-size %d", &tx_ring_sz))
7516 if (vec_len (host_if_name) > 63)
7518 errmsg ("tap name too long. ");
7521 if (vec_len (host_ns) > 63)
7523 errmsg ("host name space too long. ");
7526 if (vec_len (host_bridge) > 63)
7528 errmsg ("host bridge name too long. ");
7531 if (host_ip4_prefix_len > 32)
7533 errmsg ("host ip4 prefix length not valid. ");
7536 if (host_ip6_prefix_len > 128)
7538 errmsg ("host ip6 prefix length not valid. ");
7541 if (!is_pow2 (rx_ring_sz))
7543 errmsg ("rx ring size must be power of 2. ");
7546 if (rx_ring_sz > 32768)
7548 errmsg ("rx ring size must be 32768 or lower. ");
7551 if (!is_pow2 (tx_ring_sz))
7553 errmsg ("tx ring size must be power of 2. ");
7556 if (tx_ring_sz > 32768)
7558 errmsg ("tx ring size must be 32768 or lower. ");
7562 /* Construct the API message */
7563 M (TAP_CREATE_V2, mp);
7565 mp->use_random_mac = random_mac;
7567 mp->id = ntohl (id);
7568 mp->host_namespace_set = host_ns != 0;
7569 mp->host_bridge_set = host_bridge != 0;
7570 mp->host_ip4_addr_set = host_ip4_prefix_len != 0;
7571 mp->host_ip6_addr_set = host_ip6_prefix_len != 0;
7572 mp->rx_ring_sz = ntohs (rx_ring_sz);
7573 mp->tx_ring_sz = ntohs (tx_ring_sz);
7575 if (random_mac == 0)
7576 clib_memcpy (mp->mac_address, mac_address, 6);
7577 if (host_mac_addr_set)
7578 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
7580 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
7582 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
7584 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
7585 if (host_ip4_prefix_len)
7586 clib_memcpy (mp->host_ip4_addr, &host_ip4_addr, 4);
7587 if (host_ip6_prefix_len)
7588 clib_memcpy (mp->host_ip6_addr, &host_ip6_addr, 16);
7589 if (host_ip4_gw_set)
7590 clib_memcpy (mp->host_ip4_gw, &host_ip4_gw, 4);
7591 if (host_ip6_gw_set)
7592 clib_memcpy (mp->host_ip6_gw, &host_ip6_gw, 16);
7595 vec_free (host_if_name);
7596 vec_free (host_bridge);
7601 /* Wait for a reply... */
7607 api_tap_delete_v2 (vat_main_t * vam)
7609 unformat_input_t *i = vam->input;
7610 vl_api_tap_delete_v2_t *mp;
7611 u32 sw_if_index = ~0;
7612 u8 sw_if_index_set = 0;
7615 /* Parse args required to build the message */
7616 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7618 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7619 sw_if_index_set = 1;
7620 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7621 sw_if_index_set = 1;
7626 if (sw_if_index_set == 0)
7628 errmsg ("missing vpp interface name. ");
7632 /* Construct the API message */
7633 M (TAP_DELETE_V2, mp);
7635 mp->sw_if_index = ntohl (sw_if_index);
7640 /* Wait for a reply... */
7646 unformat_pci_addr (unformat_input_t * input, va_list * args)
7655 addr = va_arg (*args, struct pci_addr_t *);
7658 if (!unformat (input, "%x:%x:%x.%x", &x[0], &x[1], &x[2], &x[3]))
7661 addr->domain = x[0];
7664 addr->function = x[3];
7670 api_virtio_pci_create (vat_main_t * vam)
7672 unformat_input_t *i = vam->input;
7673 vl_api_virtio_pci_create_t *mp;
7677 u64 features = (u64) ~ (0ULL);
7678 u32 rx_ring_sz = 0, tx_ring_sz = 0;
7681 clib_memset (mac_address, 0, sizeof (mac_address));
7683 /* Parse args required to build the message */
7684 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7686 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7690 else if (unformat (i, "pci-addr %U", unformat_pci_addr, &pci_addr))
7692 else if (unformat (i, "features 0x%llx", &features))
7694 else if (unformat (i, "rx-ring-size %u", &rx_ring_sz))
7696 else if (unformat (i, "tx-ring-size %u", &tx_ring_sz))
7704 errmsg ("pci address must be non zero. ");
7707 if (!is_pow2 (rx_ring_sz))
7709 errmsg ("rx ring size must be power of 2. ");
7712 if (rx_ring_sz > 32768)
7714 errmsg ("rx ring size must be 32768 or lower. ");
7717 if (!is_pow2 (tx_ring_sz))
7719 errmsg ("tx ring size must be power of 2. ");
7722 if (tx_ring_sz > 32768)
7724 errmsg ("tx ring size must be 32768 or lower. ");
7728 /* Construct the API message */
7729 M (VIRTIO_PCI_CREATE, mp);
7731 mp->use_random_mac = random_mac;
7733 mp->pci_addr = htonl (pci_addr);
7734 mp->features = clib_host_to_net_u64 (features);
7736 if (random_mac == 0)
7737 clib_memcpy (mp->mac_address, mac_address, 6);
7742 /* Wait for a reply... */
7748 api_virtio_pci_delete (vat_main_t * vam)
7750 unformat_input_t *i = vam->input;
7751 vl_api_virtio_pci_delete_t *mp;
7752 u32 sw_if_index = ~0;
7753 u8 sw_if_index_set = 0;
7756 /* Parse args required to build the message */
7757 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7759 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7760 sw_if_index_set = 1;
7761 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7762 sw_if_index_set = 1;
7767 if (sw_if_index_set == 0)
7769 errmsg ("missing vpp interface name. ");
7773 /* Construct the API message */
7774 M (VIRTIO_PCI_DELETE, mp);
7776 mp->sw_if_index = htonl (sw_if_index);
7781 /* Wait for a reply... */
7787 api_bond_create (vat_main_t * vam)
7789 unformat_input_t *i = vam->input;
7790 vl_api_bond_create_t *mp;
7799 clib_memset (mac_address, 0, sizeof (mac_address));
7802 /* Parse args required to build the message */
7803 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7805 if (unformat (i, "mode %U", unformat_bond_mode, &mode))
7807 else if (((mode == BOND_MODE_LACP) || (mode == BOND_MODE_XOR))
7808 && unformat (i, "lb %U", unformat_bond_load_balance, &lb))
7810 else if (unformat (i, "hw-addr %U", unformat_ethernet_address,
7813 else if (unformat (i, "id %u", &id))
7819 if (mode_is_set == 0)
7821 errmsg ("Missing bond mode. ");
7825 /* Construct the API message */
7826 M (BOND_CREATE, mp);
7828 mp->use_custom_mac = custom_mac;
7832 mp->id = htonl (id);
7835 clib_memcpy (mp->mac_address, mac_address, 6);
7840 /* Wait for a reply... */
7846 api_bond_delete (vat_main_t * vam)
7848 unformat_input_t *i = vam->input;
7849 vl_api_bond_delete_t *mp;
7850 u32 sw_if_index = ~0;
7851 u8 sw_if_index_set = 0;
7854 /* Parse args required to build the message */
7855 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7857 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7858 sw_if_index_set = 1;
7859 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7860 sw_if_index_set = 1;
7865 if (sw_if_index_set == 0)
7867 errmsg ("missing vpp interface name. ");
7871 /* Construct the API message */
7872 M (BOND_DELETE, mp);
7874 mp->sw_if_index = ntohl (sw_if_index);
7879 /* Wait for a reply... */
7885 api_bond_enslave (vat_main_t * vam)
7887 unformat_input_t *i = vam->input;
7888 vl_api_bond_enslave_t *mp;
7889 u32 bond_sw_if_index;
7893 u32 bond_sw_if_index_is_set = 0;
7895 u8 sw_if_index_is_set = 0;
7897 /* Parse args required to build the message */
7898 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7900 if (unformat (i, "sw_if_index %d", &sw_if_index))
7901 sw_if_index_is_set = 1;
7902 else if (unformat (i, "bond %u", &bond_sw_if_index))
7903 bond_sw_if_index_is_set = 1;
7904 else if (unformat (i, "passive %d", &is_passive))
7906 else if (unformat (i, "long-timeout %d", &is_long_timeout))
7912 if (bond_sw_if_index_is_set == 0)
7914 errmsg ("Missing bond sw_if_index. ");
7917 if (sw_if_index_is_set == 0)
7919 errmsg ("Missing slave sw_if_index. ");
7923 /* Construct the API message */
7924 M (BOND_ENSLAVE, mp);
7926 mp->bond_sw_if_index = ntohl (bond_sw_if_index);
7927 mp->sw_if_index = ntohl (sw_if_index);
7928 mp->is_long_timeout = is_long_timeout;
7929 mp->is_passive = is_passive;
7934 /* Wait for a reply... */
7940 api_bond_detach_slave (vat_main_t * vam)
7942 unformat_input_t *i = vam->input;
7943 vl_api_bond_detach_slave_t *mp;
7944 u32 sw_if_index = ~0;
7945 u8 sw_if_index_set = 0;
7948 /* Parse args required to build the message */
7949 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7951 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7952 sw_if_index_set = 1;
7953 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7954 sw_if_index_set = 1;
7959 if (sw_if_index_set == 0)
7961 errmsg ("missing vpp interface name. ");
7965 /* Construct the API message */
7966 M (BOND_DETACH_SLAVE, mp);
7968 mp->sw_if_index = ntohl (sw_if_index);
7973 /* Wait for a reply... */
7979 api_ip_table_add_del (vat_main_t * vam)
7981 unformat_input_t *i = vam->input;
7982 vl_api_ip_table_add_del_t *mp;
7988 /* Parse args required to build the message */
7989 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7991 if (unformat (i, "ipv6"))
7993 else if (unformat (i, "del"))
7995 else if (unformat (i, "add"))
7997 else if (unformat (i, "table %d", &table_id))
8001 clib_warning ("parse error '%U'", format_unformat_error, i);
8008 errmsg ("missing table-ID");
8012 /* Construct the API message */
8013 M (IP_TABLE_ADD_DEL, mp);
8015 mp->table_id = ntohl (table_id);
8016 mp->is_ipv6 = is_ipv6;
8017 mp->is_add = is_add;
8022 /* Wait for a reply... */
8029 api_ip_add_del_route (vat_main_t * vam)
8031 unformat_input_t *i = vam->input;
8032 vl_api_ip_add_del_route_t *mp;
8033 u32 sw_if_index = ~0, vrf_id = 0;
8035 u8 is_local = 0, is_drop = 0;
8036 u8 is_unreach = 0, is_prohibit = 0;
8038 u32 next_hop_weight = 1;
8039 u8 is_multipath = 0;
8041 u8 address_length_set = 0;
8042 u32 next_hop_table_id = 0;
8043 u32 resolve_attempts = 0;
8044 u32 dst_address_length = 0;
8045 u8 next_hop_set = 0;
8046 ip4_address_t v4_dst_address, v4_next_hop_address;
8047 ip6_address_t v6_dst_address, v6_next_hop_address;
8051 u32 random_add_del = 0;
8052 u32 *random_vector = 0;
8054 u32 random_seed = 0xdeaddabe;
8055 u32 classify_table_index = ~0;
8057 u8 resolve_host = 0, resolve_attached = 0;
8058 vl_api_fib_mpls_label_t *next_hop_out_label_stack = NULL;
8059 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8060 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
8062 clib_memset (&v4_next_hop_address, 0, sizeof (ip4_address_t));
8063 clib_memset (&v6_next_hop_address, 0, sizeof (ip6_address_t));
8064 /* Parse args required to build the message */
8065 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8067 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8069 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8071 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
8076 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
8081 else if (unformat (i, "/%d", &dst_address_length))
8083 address_length_set = 1;
8086 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
8087 &v4_next_hop_address))
8091 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
8092 &v6_next_hop_address))
8098 (i, "via %U", api_unformat_sw_if_index, vam, &sw_if_index))
8102 else if (unformat (i, "via sw_if_index %d", &sw_if_index))
8106 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
8108 else if (unformat (i, "weight %d", &next_hop_weight))
8110 else if (unformat (i, "drop"))
8114 else if (unformat (i, "null-send-unreach"))
8118 else if (unformat (i, "null-send-prohibit"))
8122 else if (unformat (i, "local"))
8126 else if (unformat (i, "classify %d", &classify_table_index))
8130 else if (unformat (i, "del"))
8132 else if (unformat (i, "add"))
8134 else if (unformat (i, "resolve-via-host"))
8136 else if (unformat (i, "resolve-via-attached"))
8137 resolve_attached = 1;
8138 else if (unformat (i, "multipath"))
8140 else if (unformat (i, "vrf %d", &vrf_id))
8142 else if (unformat (i, "count %d", &count))
8144 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
8146 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
8148 else if (unformat (i, "out-label %d", &next_hop_out_label))
8150 vl_api_fib_mpls_label_t fib_label = {
8151 .label = ntohl (next_hop_out_label),
8155 vec_add1 (next_hop_out_label_stack, fib_label);
8157 else if (unformat (i, "via via-label %d", &next_hop_via_label))
8159 else if (unformat (i, "random"))
8161 else if (unformat (i, "seed %d", &random_seed))
8165 clib_warning ("parse error '%U'", format_unformat_error, i);
8170 if (!next_hop_set && !is_drop && !is_local &&
8171 !is_classify && !is_unreach && !is_prohibit &&
8172 MPLS_LABEL_INVALID == next_hop_via_label)
8175 ("next hop / local / drop / unreach / prohibit / classify not set");
8179 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
8181 errmsg ("next hop and next-hop via label set");
8184 if (address_set == 0)
8186 errmsg ("missing addresses");
8190 if (address_length_set == 0)
8192 errmsg ("missing address length");
8196 /* Generate a pile of unique, random routes */
8199 u32 this_random_address;
8200 random_hash = hash_create (count, sizeof (uword));
8202 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
8203 for (j = 0; j <= count; j++)
8207 this_random_address = random_u32 (&random_seed);
8208 this_random_address =
8209 clib_host_to_net_u32 (this_random_address);
8211 while (hash_get (random_hash, this_random_address));
8212 vec_add1 (random_vector, this_random_address);
8213 hash_set (random_hash, this_random_address, 1);
8215 hash_free (random_hash);
8216 v4_dst_address.as_u32 = random_vector[0];
8221 /* Turn on async mode */
8222 vam->async_mode = 1;
8223 vam->async_errors = 0;
8224 before = vat_time_now (vam);
8227 for (j = 0; j < count; j++)
8229 /* Construct the API message */
8230 M2 (IP_ADD_DEL_ROUTE, mp, sizeof (vl_api_fib_mpls_label_t) *
8231 vec_len (next_hop_out_label_stack));
8233 mp->next_hop_sw_if_index = ntohl (sw_if_index);
8234 mp->table_id = ntohl (vrf_id);
8236 mp->is_add = is_add;
8237 mp->is_drop = is_drop;
8238 mp->is_unreach = is_unreach;
8239 mp->is_prohibit = is_prohibit;
8240 mp->is_ipv6 = is_ipv6;
8241 mp->is_local = is_local;
8242 mp->is_classify = is_classify;
8243 mp->is_multipath = is_multipath;
8244 mp->is_resolve_host = resolve_host;
8245 mp->is_resolve_attached = resolve_attached;
8246 mp->next_hop_weight = next_hop_weight;
8247 mp->next_hop_preference = 0;
8248 mp->dst_address_length = dst_address_length;
8249 mp->next_hop_table_id = ntohl (next_hop_table_id);
8250 mp->classify_table_index = ntohl (classify_table_index);
8251 mp->next_hop_via_label = ntohl (next_hop_via_label);
8252 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
8253 if (0 != mp->next_hop_n_out_labels)
8255 memcpy (mp->next_hop_out_label_stack,
8256 next_hop_out_label_stack,
8257 (vec_len (next_hop_out_label_stack) *
8258 sizeof (vl_api_fib_mpls_label_t)));
8259 vec_free (next_hop_out_label_stack);
8264 clib_memcpy (mp->dst_address, &v6_dst_address,
8265 sizeof (v6_dst_address));
8267 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
8268 sizeof (v6_next_hop_address));
8269 increment_v6_address (&v6_dst_address);
8273 clib_memcpy (mp->dst_address, &v4_dst_address,
8274 sizeof (v4_dst_address));
8276 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
8277 sizeof (v4_next_hop_address));
8279 v4_dst_address.as_u32 = random_vector[j + 1];
8281 increment_v4_address (&v4_dst_address);
8285 /* If we receive SIGTERM, stop now... */
8290 /* When testing multiple add/del ops, use a control-ping to sync */
8293 vl_api_control_ping_t *mp_ping;
8297 /* Shut off async mode */
8298 vam->async_mode = 0;
8300 MPING (CONTROL_PING, mp_ping);
8303 timeout = vat_time_now (vam) + 1.0;
8304 while (vat_time_now (vam) < timeout)
8305 if (vam->result_ready == 1)
8310 if (vam->retval == -99)
8313 if (vam->async_errors > 0)
8315 errmsg ("%d asynchronous errors", vam->async_errors);
8318 vam->async_errors = 0;
8319 after = vat_time_now (vam);
8321 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8325 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8326 count, after - before, count / (after - before));
8332 /* Wait for a reply... */
8337 /* Return the good/bad news */
8338 return (vam->retval);
8342 api_ip_mroute_add_del (vat_main_t * vam)
8344 unformat_input_t *i = vam->input;
8345 vl_api_ip_mroute_add_del_t *mp;
8346 u32 sw_if_index = ~0, vrf_id = 0;
8351 u32 grp_address_length = 0;
8352 ip4_address_t v4_grp_address, v4_src_address;
8353 ip6_address_t v6_grp_address, v6_src_address;
8354 mfib_itf_flags_t iflags = 0;
8355 mfib_entry_flags_t eflags = 0;
8358 /* Parse args required to build the message */
8359 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8361 if (unformat (i, "sw_if_index %d", &sw_if_index))
8363 else if (unformat (i, "%U %U",
8364 unformat_ip4_address, &v4_src_address,
8365 unformat_ip4_address, &v4_grp_address))
8367 grp_address_length = 64;
8371 else if (unformat (i, "%U %U",
8372 unformat_ip6_address, &v6_src_address,
8373 unformat_ip6_address, &v6_grp_address))
8375 grp_address_length = 256;
8379 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
8381 clib_memset (&v4_src_address, 0, sizeof (v4_src_address));
8382 grp_address_length = 32;
8386 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
8388 clib_memset (&v6_src_address, 0, sizeof (v6_src_address));
8389 grp_address_length = 128;
8393 else if (unformat (i, "/%d", &grp_address_length))
8395 else if (unformat (i, "local"))
8399 else if (unformat (i, "del"))
8401 else if (unformat (i, "add"))
8403 else if (unformat (i, "vrf %d", &vrf_id))
8405 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
8407 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8411 clib_warning ("parse error '%U'", format_unformat_error, i);
8416 if (address_set == 0)
8418 errmsg ("missing addresses\n");
8422 /* Construct the API message */
8423 M (IP_MROUTE_ADD_DEL, mp);
8425 mp->next_hop_sw_if_index = ntohl (sw_if_index);
8426 mp->table_id = ntohl (vrf_id);
8428 mp->is_add = is_add;
8429 mp->is_ipv6 = is_ipv6;
8430 mp->is_local = is_local;
8431 mp->itf_flags = ntohl (iflags);
8432 mp->entry_flags = ntohl (eflags);
8433 mp->grp_address_length = grp_address_length;
8434 mp->grp_address_length = ntohs (mp->grp_address_length);
8438 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
8439 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
8443 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
8444 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
8450 /* Wait for a reply... */
8456 api_mpls_table_add_del (vat_main_t * vam)
8458 unformat_input_t *i = vam->input;
8459 vl_api_mpls_table_add_del_t *mp;
8464 /* Parse args required to build the message */
8465 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8467 if (unformat (i, "table %d", &table_id))
8469 else if (unformat (i, "del"))
8471 else if (unformat (i, "add"))
8475 clib_warning ("parse error '%U'", format_unformat_error, i);
8482 errmsg ("missing table-ID");
8486 /* Construct the API message */
8487 M (MPLS_TABLE_ADD_DEL, mp);
8489 mp->mt_table_id = ntohl (table_id);
8490 mp->mt_is_add = is_add;
8495 /* Wait for a reply... */
8502 api_mpls_route_add_del (vat_main_t * vam)
8504 unformat_input_t *i = vam->input;
8505 vl_api_mpls_route_add_del_t *mp;
8506 u32 sw_if_index = ~0, table_id = 0;
8508 u32 next_hop_weight = 1;
8509 u8 is_multipath = 0;
8510 u32 next_hop_table_id = 0;
8511 u8 next_hop_set = 0;
8512 ip4_address_t v4_next_hop_address = {
8515 ip6_address_t v6_next_hop_address = { {0} };
8519 u32 classify_table_index = ~0;
8521 u8 resolve_host = 0, resolve_attached = 0;
8522 u8 is_interface_rx = 0;
8523 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
8524 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8525 vl_api_fib_mpls_label_t *next_hop_out_label_stack = NULL;
8526 mpls_label_t local_label = MPLS_LABEL_INVALID;
8528 dpo_proto_t next_hop_proto = DPO_PROTO_MPLS;
8530 /* Parse args required to build the message */
8531 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8533 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8535 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8537 else if (unformat (i, "%d", &local_label))
8539 else if (unformat (i, "eos"))
8541 else if (unformat (i, "non-eos"))
8543 else if (unformat (i, "via %U", unformat_ip4_address,
8544 &v4_next_hop_address))
8547 next_hop_proto = DPO_PROTO_IP4;
8549 else if (unformat (i, "via %U", unformat_ip6_address,
8550 &v6_next_hop_address))
8553 next_hop_proto = DPO_PROTO_IP6;
8555 else if (unformat (i, "weight %d", &next_hop_weight))
8557 else if (unformat (i, "classify %d", &classify_table_index))
8561 else if (unformat (i, "del"))
8563 else if (unformat (i, "add"))
8565 else if (unformat (i, "resolve-via-host"))
8567 else if (unformat (i, "resolve-via-attached"))
8568 resolve_attached = 1;
8569 else if (unformat (i, "multipath"))
8571 else if (unformat (i, "count %d", &count))
8573 else if (unformat (i, "via lookup-in-ip4-table %d", &next_hop_table_id))
8576 next_hop_proto = DPO_PROTO_IP4;
8578 else if (unformat (i, "via lookup-in-ip6-table %d", &next_hop_table_id))
8581 next_hop_proto = DPO_PROTO_IP6;
8585 (i, "via l2-input-on %U", api_unformat_sw_if_index, vam,
8589 next_hop_proto = DPO_PROTO_ETHERNET;
8590 is_interface_rx = 1;
8592 else if (unformat (i, "via l2-input-on sw_if_index %d", &sw_if_index))
8595 next_hop_proto = DPO_PROTO_ETHERNET;
8596 is_interface_rx = 1;
8598 else if (unformat (i, "via next-hop-table %d", &next_hop_table_id))
8600 else if (unformat (i, "via via-label %d", &next_hop_via_label))
8602 else if (unformat (i, "out-label %d", &next_hop_out_label))
8604 vl_api_fib_mpls_label_t fib_label = {
8605 .label = ntohl (next_hop_out_label),
8609 vec_add1 (next_hop_out_label_stack, fib_label);
8613 clib_warning ("parse error '%U'", format_unformat_error, i);
8618 if (!next_hop_set && !is_classify)
8620 errmsg ("next hop / classify not set");
8624 if (MPLS_LABEL_INVALID == local_label)
8626 errmsg ("missing label");
8632 /* Turn on async mode */
8633 vam->async_mode = 1;
8634 vam->async_errors = 0;
8635 before = vat_time_now (vam);
8638 for (j = 0; j < count; j++)
8640 /* Construct the API message */
8641 M2 (MPLS_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_mpls_label_t) *
8642 vec_len (next_hop_out_label_stack));
8644 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
8645 mp->mr_table_id = ntohl (table_id);
8647 mp->mr_is_add = is_add;
8648 mp->mr_next_hop_proto = next_hop_proto;
8649 mp->mr_is_classify = is_classify;
8650 mp->mr_is_multipath = is_multipath;
8651 mp->mr_is_resolve_host = resolve_host;
8652 mp->mr_is_resolve_attached = resolve_attached;
8653 mp->mr_is_interface_rx = is_interface_rx;
8654 mp->mr_next_hop_weight = next_hop_weight;
8655 mp->mr_next_hop_preference = 0;
8656 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
8657 mp->mr_classify_table_index = ntohl (classify_table_index);
8658 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
8659 mp->mr_label = ntohl (local_label);
8660 mp->mr_eos = is_eos;
8662 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
8663 if (0 != mp->mr_next_hop_n_out_labels)
8665 memcpy (mp->mr_next_hop_out_label_stack,
8666 next_hop_out_label_stack,
8667 vec_len (next_hop_out_label_stack) *
8668 sizeof (vl_api_fib_mpls_label_t));
8669 vec_free (next_hop_out_label_stack);
8674 if (DPO_PROTO_IP4 == next_hop_proto)
8676 clib_memcpy (mp->mr_next_hop,
8677 &v4_next_hop_address,
8678 sizeof (v4_next_hop_address));
8680 else if (DPO_PROTO_IP6 == next_hop_proto)
8683 clib_memcpy (mp->mr_next_hop,
8684 &v6_next_hop_address,
8685 sizeof (v6_next_hop_address));
8692 /* If we receive SIGTERM, stop now... */
8697 /* When testing multiple add/del ops, use a control-ping to sync */
8700 vl_api_control_ping_t *mp_ping;
8704 /* Shut off async mode */
8705 vam->async_mode = 0;
8707 MPING (CONTROL_PING, mp_ping);
8710 timeout = vat_time_now (vam) + 1.0;
8711 while (vat_time_now (vam) < timeout)
8712 if (vam->result_ready == 1)
8717 if (vam->retval == -99)
8720 if (vam->async_errors > 0)
8722 errmsg ("%d asynchronous errors", vam->async_errors);
8725 vam->async_errors = 0;
8726 after = vat_time_now (vam);
8728 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8732 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8733 count, after - before, count / (after - before));
8739 /* Wait for a reply... */
8744 /* Return the good/bad news */
8745 return (vam->retval);
8749 api_mpls_ip_bind_unbind (vat_main_t * vam)
8751 unformat_input_t *i = vam->input;
8752 vl_api_mpls_ip_bind_unbind_t *mp;
8753 u32 ip_table_id = 0;
8756 ip4_address_t v4_address;
8757 ip6_address_t v6_address;
8760 mpls_label_t local_label = MPLS_LABEL_INVALID;
8763 /* Parse args required to build the message */
8764 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8766 if (unformat (i, "%U/%d", unformat_ip4_address,
8767 &v4_address, &address_length))
8772 else if (unformat (i, "%U/%d", unformat_ip6_address,
8773 &v6_address, &address_length))
8778 else if (unformat (i, "%d", &local_label))
8780 else if (unformat (i, "table-id %d", &ip_table_id))
8782 else if (unformat (i, "unbind"))
8784 else if (unformat (i, "bind"))
8788 clib_warning ("parse error '%U'", format_unformat_error, i);
8795 errmsg ("IP address not set");
8799 if (MPLS_LABEL_INVALID == local_label)
8801 errmsg ("missing label");
8805 /* Construct the API message */
8806 M (MPLS_IP_BIND_UNBIND, mp);
8808 mp->mb_is_bind = is_bind;
8809 mp->mb_is_ip4 = is_ip4;
8810 mp->mb_ip_table_id = ntohl (ip_table_id);
8811 mp->mb_mpls_table_id = 0;
8812 mp->mb_label = ntohl (local_label);
8813 mp->mb_address_length = address_length;
8816 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
8818 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
8823 /* Wait for a reply... */
8829 api_sr_mpls_policy_add (vat_main_t * vam)
8831 unformat_input_t *i = vam->input;
8832 vl_api_sr_mpls_policy_add_t *mp;
8838 u32 *segments = NULL;
8841 /* Parse args required to build the message */
8842 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8844 if (unformat (i, "bsid %d", &bsid))
8846 else if (unformat (i, "weight %d", &weight))
8848 else if (unformat (i, "spray"))
8850 else if (unformat (i, "next %d", &sid))
8853 vec_add1 (segments, htonl (sid));
8857 clib_warning ("parse error '%U'", format_unformat_error, i);
8864 errmsg ("bsid not set");
8868 if (n_segments == 0)
8870 errmsg ("no sid in segment stack");
8874 /* Construct the API message */
8875 M2 (SR_MPLS_POLICY_ADD, mp, sizeof (u32) * n_segments);
8877 mp->bsid = htonl (bsid);
8878 mp->weight = htonl (weight);
8880 mp->n_segments = n_segments;
8881 memcpy (mp->segments, segments, sizeof (u32) * n_segments);
8882 vec_free (segments);
8887 /* Wait for a reply... */
8893 api_sr_mpls_policy_del (vat_main_t * vam)
8895 unformat_input_t *i = vam->input;
8896 vl_api_sr_mpls_policy_del_t *mp;
8900 /* Parse args required to build the message */
8901 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8903 if (unformat (i, "bsid %d", &bsid))
8907 clib_warning ("parse error '%U'", format_unformat_error, i);
8914 errmsg ("bsid not set");
8918 /* Construct the API message */
8919 M (SR_MPLS_POLICY_DEL, mp);
8921 mp->bsid = htonl (bsid);
8926 /* Wait for a reply... */
8932 api_bier_table_add_del (vat_main_t * vam)
8934 unformat_input_t *i = vam->input;
8935 vl_api_bier_table_add_del_t *mp;
8937 u32 set = 0, sub_domain = 0, hdr_len = 3;
8938 mpls_label_t local_label = MPLS_LABEL_INVALID;
8941 /* Parse args required to build the message */
8942 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8944 if (unformat (i, "sub-domain %d", &sub_domain))
8946 else if (unformat (i, "set %d", &set))
8948 else if (unformat (i, "label %d", &local_label))
8950 else if (unformat (i, "hdr-len %d", &hdr_len))
8952 else if (unformat (i, "add"))
8954 else if (unformat (i, "del"))
8958 clib_warning ("parse error '%U'", format_unformat_error, i);
8963 if (MPLS_LABEL_INVALID == local_label)
8965 errmsg ("missing label\n");
8969 /* Construct the API message */
8970 M (BIER_TABLE_ADD_DEL, mp);
8972 mp->bt_is_add = is_add;
8973 mp->bt_label = ntohl (local_label);
8974 mp->bt_tbl_id.bt_set = set;
8975 mp->bt_tbl_id.bt_sub_domain = sub_domain;
8976 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
8981 /* Wait for a reply... */
8988 api_bier_route_add_del (vat_main_t * vam)
8990 unformat_input_t *i = vam->input;
8991 vl_api_bier_route_add_del_t *mp;
8993 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
8994 ip4_address_t v4_next_hop_address;
8995 ip6_address_t v6_next_hop_address;
8996 u8 next_hop_set = 0;
8997 u8 next_hop_proto_is_ip4 = 1;
8998 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
9001 /* Parse args required to build the message */
9002 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9004 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
9006 next_hop_proto_is_ip4 = 1;
9009 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
9011 next_hop_proto_is_ip4 = 0;
9014 if (unformat (i, "sub-domain %d", &sub_domain))
9016 else if (unformat (i, "set %d", &set))
9018 else if (unformat (i, "hdr-len %d", &hdr_len))
9020 else if (unformat (i, "bp %d", &bp))
9022 else if (unformat (i, "add"))
9024 else if (unformat (i, "del"))
9026 else if (unformat (i, "out-label %d", &next_hop_out_label))
9030 clib_warning ("parse error '%U'", format_unformat_error, i);
9035 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
9037 errmsg ("next hop / label set\n");
9042 errmsg ("bit=position not set\n");
9046 /* Construct the API message */
9047 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t));
9049 mp->br_is_add = is_add;
9050 mp->br_tbl_id.bt_set = set;
9051 mp->br_tbl_id.bt_sub_domain = sub_domain;
9052 mp->br_tbl_id.bt_hdr_len_id = hdr_len;
9053 mp->br_bp = ntohs (bp);
9055 mp->br_paths[0].n_labels = 1;
9056 mp->br_paths[0].label_stack[0].label = ntohl (next_hop_out_label);
9057 mp->br_paths[0].afi = (next_hop_proto_is_ip4 ? 0 : 1);
9059 if (next_hop_proto_is_ip4)
9061 clib_memcpy (mp->br_paths[0].next_hop,
9062 &v4_next_hop_address, sizeof (v4_next_hop_address));
9066 clib_memcpy (mp->br_paths[0].next_hop,
9067 &v6_next_hop_address, sizeof (v6_next_hop_address));
9073 /* Wait for a reply... */
9080 api_proxy_arp_add_del (vat_main_t * vam)
9082 unformat_input_t *i = vam->input;
9083 vl_api_proxy_arp_add_del_t *mp;
9086 vl_api_ip4_address_t lo, hi;
9090 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9092 if (unformat (i, "vrf %d", &vrf_id))
9094 else if (unformat (i, "%U - %U", unformat_vl_api_ip4_address, &lo,
9095 unformat_vl_api_ip4_address, &hi))
9097 else if (unformat (i, "del"))
9101 clib_warning ("parse error '%U'", format_unformat_error, i);
9108 errmsg ("address range not set");
9112 M (PROXY_ARP_ADD_DEL, mp);
9114 mp->proxy.table_id = ntohl (vrf_id);
9115 mp->is_add = is_add;
9116 clib_memcpy (mp->proxy.low, &lo, sizeof (lo));
9117 clib_memcpy (mp->proxy.hi, &hi, sizeof (hi));
9125 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
9127 unformat_input_t *i = vam->input;
9128 vl_api_proxy_arp_intfc_enable_disable_t *mp;
9131 u8 sw_if_index_set = 0;
9134 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9136 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9137 sw_if_index_set = 1;
9138 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9139 sw_if_index_set = 1;
9140 else if (unformat (i, "enable"))
9142 else if (unformat (i, "disable"))
9146 clib_warning ("parse error '%U'", format_unformat_error, i);
9151 if (sw_if_index_set == 0)
9153 errmsg ("missing interface name or sw_if_index");
9157 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
9159 mp->sw_if_index = ntohl (sw_if_index);
9160 mp->enable_disable = enable;
9168 api_mpls_tunnel_add_del (vat_main_t * vam)
9170 unformat_input_t *i = vam->input;
9171 vl_api_mpls_tunnel_add_del_t *mp;
9175 u32 sw_if_index = ~0;
9176 u32 next_hop_sw_if_index = ~0;
9177 u32 next_hop_proto_is_ip4 = 1;
9179 u32 next_hop_table_id = 0;
9180 ip4_address_t v4_next_hop_address = {
9183 ip6_address_t v6_next_hop_address = { {0} };
9184 vl_api_fib_mpls_label_t *next_hop_out_label_stack = NULL;
9185 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
9186 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
9189 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9191 if (unformat (i, "add"))
9195 (i, "del %U", api_unformat_sw_if_index, vam, &sw_if_index))
9197 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
9199 else if (unformat (i, "via %U",
9200 unformat_ip4_address, &v4_next_hop_address))
9202 next_hop_proto_is_ip4 = 1;
9204 else if (unformat (i, "via %U",
9205 unformat_ip6_address, &v6_next_hop_address))
9207 next_hop_proto_is_ip4 = 0;
9209 else if (unformat (i, "via-label %d", &next_hop_via_label))
9213 (i, "%U", api_unformat_sw_if_index, vam, &next_hop_sw_if_index))
9215 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
9217 else if (unformat (i, "l2-only"))
9219 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
9221 else if (unformat (i, "out-label %d", &next_hop_out_label))
9223 vl_api_fib_mpls_label_t fib_label = {
9224 .label = ntohl (next_hop_out_label),
9228 vec_add1 (next_hop_out_label_stack, fib_label);
9232 clib_warning ("parse error '%U'", format_unformat_error, i);
9237 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (vl_api_fib_mpls_label_t) *
9238 vec_len (next_hop_out_label_stack));
9240 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
9241 mp->mt_sw_if_index = ntohl (sw_if_index);
9242 mp->mt_is_add = is_add;
9243 mp->mt_l2_only = l2_only;
9244 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
9245 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
9246 mp->mt_next_hop_via_label = ntohl (next_hop_via_label);
9247 mp->mt_next_hop_weight = 1;
9248 mp->mt_next_hop_preference = 0;
9250 mp->mt_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
9252 if (0 != mp->mt_next_hop_n_out_labels)
9254 clib_memcpy (mp->mt_next_hop_out_label_stack,
9255 next_hop_out_label_stack,
9256 (vec_len (next_hop_out_label_stack) *
9257 sizeof (vl_api_fib_mpls_label_t)));
9258 vec_free (next_hop_out_label_stack);
9261 if (next_hop_proto_is_ip4)
9263 clib_memcpy (mp->mt_next_hop,
9264 &v4_next_hop_address, sizeof (v4_next_hop_address));
9268 clib_memcpy (mp->mt_next_hop,
9269 &v6_next_hop_address, sizeof (v6_next_hop_address));
9278 api_sw_interface_set_unnumbered (vat_main_t * vam)
9280 unformat_input_t *i = vam->input;
9281 vl_api_sw_interface_set_unnumbered_t *mp;
9283 u32 unnum_sw_index = ~0;
9285 u8 sw_if_index_set = 0;
9288 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9290 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9291 sw_if_index_set = 1;
9292 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9293 sw_if_index_set = 1;
9294 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
9296 else if (unformat (i, "del"))
9300 clib_warning ("parse error '%U'", format_unformat_error, i);
9305 if (sw_if_index_set == 0)
9307 errmsg ("missing interface name or sw_if_index");
9311 M (SW_INTERFACE_SET_UNNUMBERED, mp);
9313 mp->sw_if_index = ntohl (sw_if_index);
9314 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
9315 mp->is_add = is_add;
9323 api_ip_neighbor_add_del (vat_main_t * vam)
9325 vl_api_mac_address_t mac_address;
9326 unformat_input_t *i = vam->input;
9327 vl_api_ip_neighbor_add_del_t *mp;
9328 vl_api_address_t ip_address;
9330 u8 sw_if_index_set = 0;
9335 ip_neighbor_flags_t flags;
9337 flags = IP_NEIGHBOR_FLAG_NONE;
9338 clib_memset (&ip_address, 0, sizeof (ip_address));
9339 clib_memset (&mac_address, 0, sizeof (mac_address));
9340 /* Parse args required to build the message */
9341 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9343 if (unformat (i, "mac %U", unformat_vl_api_mac_address, &mac_address))
9347 else if (unformat (i, "del"))
9350 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9351 sw_if_index_set = 1;
9352 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9353 sw_if_index_set = 1;
9354 else if (unformat (i, "static"))
9355 flags |= IP_NEIGHBOR_FLAG_STATIC;
9356 else if (unformat (i, "no-fib-entry"))
9357 flags |= IP_NEIGHBOR_FLAG_NO_FIB_ENTRY;
9358 else if (unformat (i, "dst %U", unformat_vl_api_address, &ip_address))
9362 clib_warning ("parse error '%U'", format_unformat_error, i);
9367 if (sw_if_index_set == 0)
9369 errmsg ("missing interface name or sw_if_index");
9374 errmsg ("no address set");
9378 /* Construct the API message */
9379 M (IP_NEIGHBOR_ADD_DEL, mp);
9381 mp->neighbor.sw_if_index = ntohl (sw_if_index);
9382 mp->is_add = is_add;
9383 mp->neighbor.flags = htonl (flags);
9385 clib_memcpy (&mp->neighbor.mac_address, &mac_address,
9386 sizeof (mac_address));
9388 clib_memcpy (&mp->neighbor.ip_address, &ip_address, sizeof (ip_address));
9393 /* Wait for a reply, return good/bad news */
9399 api_create_vlan_subif (vat_main_t * vam)
9401 unformat_input_t *i = vam->input;
9402 vl_api_create_vlan_subif_t *mp;
9404 u8 sw_if_index_set = 0;
9409 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9411 if (unformat (i, "sw_if_index %d", &sw_if_index))
9412 sw_if_index_set = 1;
9414 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9415 sw_if_index_set = 1;
9416 else if (unformat (i, "vlan %d", &vlan_id))
9420 clib_warning ("parse error '%U'", format_unformat_error, i);
9425 if (sw_if_index_set == 0)
9427 errmsg ("missing interface name or sw_if_index");
9431 if (vlan_id_set == 0)
9433 errmsg ("missing vlan_id");
9436 M (CREATE_VLAN_SUBIF, mp);
9438 mp->sw_if_index = ntohl (sw_if_index);
9439 mp->vlan_id = ntohl (vlan_id);
9446 #define foreach_create_subif_bit \
9453 _(outer_vlan_id_any) \
9454 _(inner_vlan_id_any)
9457 api_create_subif (vat_main_t * vam)
9459 unformat_input_t *i = vam->input;
9460 vl_api_create_subif_t *mp;
9462 u8 sw_if_index_set = 0;
9469 u32 exact_match = 0;
9470 u32 default_sub = 0;
9471 u32 outer_vlan_id_any = 0;
9472 u32 inner_vlan_id_any = 0;
9474 u16 outer_vlan_id = 0;
9475 u16 inner_vlan_id = 0;
9478 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9480 if (unformat (i, "sw_if_index %d", &sw_if_index))
9481 sw_if_index_set = 1;
9483 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9484 sw_if_index_set = 1;
9485 else if (unformat (i, "sub_id %d", &sub_id))
9487 else if (unformat (i, "outer_vlan_id %d", &tmp))
9488 outer_vlan_id = tmp;
9489 else if (unformat (i, "inner_vlan_id %d", &tmp))
9490 inner_vlan_id = tmp;
9492 #define _(a) else if (unformat (i, #a)) a = 1 ;
9493 foreach_create_subif_bit
9497 clib_warning ("parse error '%U'", format_unformat_error, i);
9502 if (sw_if_index_set == 0)
9504 errmsg ("missing interface name or sw_if_index");
9508 if (sub_id_set == 0)
9510 errmsg ("missing sub_id");
9513 M (CREATE_SUBIF, mp);
9515 mp->sw_if_index = ntohl (sw_if_index);
9516 mp->sub_id = ntohl (sub_id);
9518 #define _(a) mp->a = a;
9519 foreach_create_subif_bit;
9522 mp->outer_vlan_id = ntohs (outer_vlan_id);
9523 mp->inner_vlan_id = ntohs (inner_vlan_id);
9531 api_oam_add_del (vat_main_t * vam)
9533 unformat_input_t *i = vam->input;
9534 vl_api_oam_add_del_t *mp;
9537 ip4_address_t src, dst;
9542 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9544 if (unformat (i, "vrf %d", &vrf_id))
9546 else if (unformat (i, "src %U", unformat_ip4_address, &src))
9548 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
9550 else if (unformat (i, "del"))
9554 clib_warning ("parse error '%U'", format_unformat_error, i);
9561 errmsg ("missing src addr");
9567 errmsg ("missing dst addr");
9571 M (OAM_ADD_DEL, mp);
9573 mp->vrf_id = ntohl (vrf_id);
9574 mp->is_add = is_add;
9575 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
9576 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
9584 api_reset_fib (vat_main_t * vam)
9586 unformat_input_t *i = vam->input;
9587 vl_api_reset_fib_t *mp;
9593 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9595 if (unformat (i, "vrf %d", &vrf_id))
9597 else if (unformat (i, "ipv6"))
9601 clib_warning ("parse error '%U'", format_unformat_error, i);
9606 if (vrf_id_set == 0)
9608 errmsg ("missing vrf id");
9614 mp->vrf_id = ntohl (vrf_id);
9615 mp->is_ipv6 = is_ipv6;
9623 api_dhcp_proxy_config (vat_main_t * vam)
9625 unformat_input_t *i = vam->input;
9626 vl_api_dhcp_proxy_config_t *mp;
9628 u32 server_vrf_id = 0;
9630 u8 v4_address_set = 0;
9631 u8 v6_address_set = 0;
9632 ip4_address_t v4address;
9633 ip6_address_t v6address;
9634 u8 v4_src_address_set = 0;
9635 u8 v6_src_address_set = 0;
9636 ip4_address_t v4srcaddress;
9637 ip6_address_t v6srcaddress;
9640 /* Parse args required to build the message */
9641 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9643 if (unformat (i, "del"))
9645 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
9647 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
9649 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
9651 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
9653 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
9654 v4_src_address_set = 1;
9655 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
9656 v6_src_address_set = 1;
9661 if (v4_address_set && v6_address_set)
9663 errmsg ("both v4 and v6 server addresses set");
9666 if (!v4_address_set && !v6_address_set)
9668 errmsg ("no server addresses set");
9672 if (v4_src_address_set && v6_src_address_set)
9674 errmsg ("both v4 and v6 src addresses set");
9677 if (!v4_src_address_set && !v6_src_address_set)
9679 errmsg ("no src addresses set");
9683 if (!(v4_src_address_set && v4_address_set) &&
9684 !(v6_src_address_set && v6_address_set))
9686 errmsg ("no matching server and src addresses set");
9690 /* Construct the API message */
9691 M (DHCP_PROXY_CONFIG, mp);
9693 mp->is_add = is_add;
9694 mp->rx_vrf_id = ntohl (rx_vrf_id);
9695 mp->server_vrf_id = ntohl (server_vrf_id);
9699 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
9700 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
9704 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
9705 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
9711 /* Wait for a reply, return good/bad news */
9716 #define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
9717 #define vl_api_dhcp_proxy_details_t_print vl_noop_handler
9720 vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
9722 vat_main_t *vam = &vat_main;
9723 u32 i, count = mp->count;
9724 vl_api_dhcp_server_t *s;
9728 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9729 "VSS ASCII VPN-ID '%s', VSS RFC2685 VPN-ID (oui:id) %d:%d",
9730 ntohl (mp->rx_vrf_id),
9731 format_ip6_address, mp->dhcp_src_address,
9732 mp->vss_type, mp->vss_vpn_ascii_id,
9733 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9736 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9737 "VSS ASCII VPN-ID '%s', VSS RFC2685 VPN-ID (oui:id) %d:%d",
9738 ntohl (mp->rx_vrf_id),
9739 format_ip4_address, mp->dhcp_src_address,
9740 mp->vss_type, mp->vss_vpn_ascii_id,
9741 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9743 for (i = 0; i < count; i++)
9745 s = &mp->servers[i];
9749 " Server Table-ID %d, Server Address %U",
9750 ntohl (s->server_vrf_id), format_ip6_address, s->dhcp_server);
9753 " Server Table-ID %d, Server Address %U",
9754 ntohl (s->server_vrf_id), format_ip4_address, s->dhcp_server);
9758 static void vl_api_dhcp_proxy_details_t_handler_json
9759 (vl_api_dhcp_proxy_details_t * mp)
9761 vat_main_t *vam = &vat_main;
9762 vat_json_node_t *node = NULL;
9763 u32 i, count = mp->count;
9765 struct in6_addr ip6;
9766 vl_api_dhcp_server_t *s;
9768 if (VAT_JSON_ARRAY != vam->json_tree.type)
9770 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9771 vat_json_init_array (&vam->json_tree);
9773 node = vat_json_array_add (&vam->json_tree);
9775 vat_json_init_object (node);
9776 vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
9777 vat_json_object_add_bytes (node, "vss-type", &mp->vss_type,
9778 sizeof (mp->vss_type));
9779 vat_json_object_add_string_copy (node, "vss-vpn-ascii-id",
9780 mp->vss_vpn_ascii_id);
9781 vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
9782 vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
9786 clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
9787 vat_json_object_add_ip6 (node, "src_address", ip6);
9791 clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
9792 vat_json_object_add_ip4 (node, "src_address", ip4);
9795 for (i = 0; i < count; i++)
9797 s = &mp->servers[i];
9799 vat_json_object_add_uint (node, "server-table-id",
9800 ntohl (s->server_vrf_id));
9804 clib_memcpy (&ip4, &s->dhcp_server, sizeof (ip4));
9805 vat_json_object_add_ip4 (node, "src_address", ip4);
9809 clib_memcpy (&ip6, &s->dhcp_server, sizeof (ip6));
9810 vat_json_object_add_ip6 (node, "server_address", ip6);
9816 api_dhcp_proxy_dump (vat_main_t * vam)
9818 unformat_input_t *i = vam->input;
9819 vl_api_control_ping_t *mp_ping;
9820 vl_api_dhcp_proxy_dump_t *mp;
9824 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9826 if (unformat (i, "ipv6"))
9830 clib_warning ("parse error '%U'", format_unformat_error, i);
9835 M (DHCP_PROXY_DUMP, mp);
9837 mp->is_ip6 = is_ipv6;
9840 /* Use a control ping for synchronization */
9841 MPING (CONTROL_PING, mp_ping);
9849 api_dhcp_proxy_set_vss (vat_main_t * vam)
9851 unformat_input_t *i = vam->input;
9852 vl_api_dhcp_proxy_set_vss_t *mp;
9856 u8 vss_type = VSS_TYPE_DEFAULT;
9857 u8 *vpn_ascii_id = 0;
9862 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9864 if (unformat (i, "tbl_id %d", &tbl_id))
9866 else if (unformat (i, "vpn_ascii_id %s", &vpn_ascii_id))
9867 vss_type = VSS_TYPE_ASCII;
9868 else if (unformat (i, "fib_id %d", &fib_id))
9869 vss_type = VSS_TYPE_VPN_ID;
9870 else if (unformat (i, "oui %d", &oui))
9871 vss_type = VSS_TYPE_VPN_ID;
9872 else if (unformat (i, "ipv6"))
9874 else if (unformat (i, "del"))
9882 errmsg ("missing tbl_id ");
9883 vec_free (vpn_ascii_id);
9887 if ((vpn_ascii_id) && (vec_len (vpn_ascii_id) > 128))
9889 errmsg ("vpn_ascii_id cannot be longer than 128 ");
9890 vec_free (vpn_ascii_id);
9894 M (DHCP_PROXY_SET_VSS, mp);
9895 mp->tbl_id = ntohl (tbl_id);
9896 mp->vss_type = vss_type;
9899 clib_memcpy (mp->vpn_ascii_id, vpn_ascii_id, vec_len (vpn_ascii_id));
9900 mp->vpn_ascii_id[vec_len (vpn_ascii_id)] = 0;
9902 mp->vpn_index = ntohl (fib_id);
9903 mp->oui = ntohl (oui);
9904 mp->is_ipv6 = is_ipv6;
9905 mp->is_add = is_add;
9910 vec_free (vpn_ascii_id);
9915 api_dhcp_client_config (vat_main_t * vam)
9917 unformat_input_t *i = vam->input;
9918 vl_api_dhcp_client_config_t *mp;
9920 u8 sw_if_index_set = 0;
9923 u8 disable_event = 0;
9926 /* Parse args required to build the message */
9927 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9929 if (unformat (i, "del"))
9932 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9933 sw_if_index_set = 1;
9934 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9935 sw_if_index_set = 1;
9936 else if (unformat (i, "hostname %s", &hostname))
9938 else if (unformat (i, "disable_event"))
9944 if (sw_if_index_set == 0)
9946 errmsg ("missing interface name or sw_if_index");
9950 if (vec_len (hostname) > 63)
9952 errmsg ("hostname too long");
9954 vec_add1 (hostname, 0);
9956 /* Construct the API message */
9957 M (DHCP_CLIENT_CONFIG, mp);
9959 mp->is_add = is_add;
9960 mp->client.sw_if_index = htonl (sw_if_index);
9961 clib_memcpy (mp->client.hostname, hostname, vec_len (hostname));
9962 vec_free (hostname);
9963 mp->client.want_dhcp_event = disable_event ? 0 : 1;
9964 mp->client.pid = htonl (getpid ());
9969 /* Wait for a reply, return good/bad news */
9975 api_set_ip_flow_hash (vat_main_t * vam)
9977 unformat_input_t *i = vam->input;
9978 vl_api_set_ip_flow_hash_t *mp;
9990 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9992 if (unformat (i, "vrf %d", &vrf_id))
9994 else if (unformat (i, "ipv6"))
9996 else if (unformat (i, "src"))
9998 else if (unformat (i, "dst"))
10000 else if (unformat (i, "sport"))
10002 else if (unformat (i, "dport"))
10004 else if (unformat (i, "proto"))
10006 else if (unformat (i, "reverse"))
10011 clib_warning ("parse error '%U'", format_unformat_error, i);
10016 if (vrf_id_set == 0)
10018 errmsg ("missing vrf id");
10022 M (SET_IP_FLOW_HASH, mp);
10028 mp->reverse = reverse;
10029 mp->vrf_id = ntohl (vrf_id);
10030 mp->is_ipv6 = is_ipv6;
10038 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
10040 unformat_input_t *i = vam->input;
10041 vl_api_sw_interface_ip6_enable_disable_t *mp;
10043 u8 sw_if_index_set = 0;
10047 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10049 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10050 sw_if_index_set = 1;
10051 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10052 sw_if_index_set = 1;
10053 else if (unformat (i, "enable"))
10055 else if (unformat (i, "disable"))
10059 clib_warning ("parse error '%U'", format_unformat_error, i);
10064 if (sw_if_index_set == 0)
10066 errmsg ("missing interface name or sw_if_index");
10070 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
10072 mp->sw_if_index = ntohl (sw_if_index);
10073 mp->enable = enable;
10081 api_ip6nd_proxy_add_del (vat_main_t * vam)
10083 unformat_input_t *i = vam->input;
10084 vl_api_ip6nd_proxy_add_del_t *mp;
10085 u32 sw_if_index = ~0;
10086 u8 v6_address_set = 0;
10087 vl_api_ip6_address_t v6address;
10091 /* Parse args required to build the message */
10092 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10094 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10096 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10098 else if (unformat (i, "%U", unformat_vl_api_ip6_address, &v6address))
10099 v6_address_set = 1;
10100 if (unformat (i, "del"))
10104 clib_warning ("parse error '%U'", format_unformat_error, i);
10109 if (sw_if_index == ~0)
10111 errmsg ("missing interface name or sw_if_index");
10114 if (!v6_address_set)
10116 errmsg ("no address set");
10120 /* Construct the API message */
10121 M (IP6ND_PROXY_ADD_DEL, mp);
10123 mp->is_del = is_del;
10124 mp->sw_if_index = ntohl (sw_if_index);
10125 clib_memcpy (mp->ip, v6address, sizeof (v6address));
10130 /* Wait for a reply, return good/bad news */
10136 api_ip6nd_proxy_dump (vat_main_t * vam)
10138 vl_api_ip6nd_proxy_dump_t *mp;
10139 vl_api_control_ping_t *mp_ping;
10142 M (IP6ND_PROXY_DUMP, mp);
10146 /* Use a control ping for synchronization */
10147 MPING (CONTROL_PING, mp_ping);
10154 static void vl_api_ip6nd_proxy_details_t_handler
10155 (vl_api_ip6nd_proxy_details_t * mp)
10157 vat_main_t *vam = &vat_main;
10159 print (vam->ofp, "host %U sw_if_index %d",
10160 format_vl_api_ip6_address, mp->ip, ntohl (mp->sw_if_index));
10163 static void vl_api_ip6nd_proxy_details_t_handler_json
10164 (vl_api_ip6nd_proxy_details_t * mp)
10166 vat_main_t *vam = &vat_main;
10167 struct in6_addr ip6;
10168 vat_json_node_t *node = NULL;
10170 if (VAT_JSON_ARRAY != vam->json_tree.type)
10172 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10173 vat_json_init_array (&vam->json_tree);
10175 node = vat_json_array_add (&vam->json_tree);
10177 vat_json_init_object (node);
10178 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10180 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
10181 vat_json_object_add_ip6 (node, "host", ip6);
10185 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
10187 unformat_input_t *i = vam->input;
10188 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
10190 u8 sw_if_index_set = 0;
10191 u32 address_length = 0;
10192 u8 v6_address_set = 0;
10193 vl_api_prefix_t pfx;
10194 u8 use_default = 0;
10195 u8 no_advertise = 0;
10197 u8 no_autoconfig = 0;
10200 u32 val_lifetime = 0;
10201 u32 pref_lifetime = 0;
10204 /* Parse args required to build the message */
10205 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10207 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10208 sw_if_index_set = 1;
10209 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10210 sw_if_index_set = 1;
10211 else if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
10212 v6_address_set = 1;
10213 else if (unformat (i, "val_life %d", &val_lifetime))
10215 else if (unformat (i, "pref_life %d", &pref_lifetime))
10217 else if (unformat (i, "def"))
10219 else if (unformat (i, "noadv"))
10221 else if (unformat (i, "offl"))
10223 else if (unformat (i, "noauto"))
10225 else if (unformat (i, "nolink"))
10227 else if (unformat (i, "isno"))
10231 clib_warning ("parse error '%U'", format_unformat_error, i);
10236 if (sw_if_index_set == 0)
10238 errmsg ("missing interface name or sw_if_index");
10241 if (!v6_address_set)
10243 errmsg ("no address set");
10247 /* Construct the API message */
10248 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
10250 mp->sw_if_index = ntohl (sw_if_index);
10251 clib_memcpy (&mp->prefix, &pfx, sizeof (pfx));
10252 mp->use_default = use_default;
10253 mp->no_advertise = no_advertise;
10254 mp->off_link = off_link;
10255 mp->no_autoconfig = no_autoconfig;
10256 mp->no_onlink = no_onlink;
10258 mp->val_lifetime = ntohl (val_lifetime);
10259 mp->pref_lifetime = ntohl (pref_lifetime);
10264 /* Wait for a reply, return good/bad news */
10270 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
10272 unformat_input_t *i = vam->input;
10273 vl_api_sw_interface_ip6nd_ra_config_t *mp;
10275 u8 sw_if_index_set = 0;
10280 u8 send_unicast = 0;
10283 u8 default_router = 0;
10284 u32 max_interval = 0;
10285 u32 min_interval = 0;
10287 u32 initial_count = 0;
10288 u32 initial_interval = 0;
10292 /* Parse args required to build the message */
10293 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10295 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10296 sw_if_index_set = 1;
10297 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10298 sw_if_index_set = 1;
10299 else if (unformat (i, "maxint %d", &max_interval))
10301 else if (unformat (i, "minint %d", &min_interval))
10303 else if (unformat (i, "life %d", &lifetime))
10305 else if (unformat (i, "count %d", &initial_count))
10307 else if (unformat (i, "interval %d", &initial_interval))
10309 else if (unformat (i, "suppress") || unformat (i, "surpress"))
10311 else if (unformat (i, "managed"))
10313 else if (unformat (i, "other"))
10315 else if (unformat (i, "ll"))
10317 else if (unformat (i, "send"))
10319 else if (unformat (i, "cease"))
10321 else if (unformat (i, "isno"))
10323 else if (unformat (i, "def"))
10324 default_router = 1;
10327 clib_warning ("parse error '%U'", format_unformat_error, i);
10332 if (sw_if_index_set == 0)
10334 errmsg ("missing interface name or sw_if_index");
10338 /* Construct the API message */
10339 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
10341 mp->sw_if_index = ntohl (sw_if_index);
10342 mp->max_interval = ntohl (max_interval);
10343 mp->min_interval = ntohl (min_interval);
10344 mp->lifetime = ntohl (lifetime);
10345 mp->initial_count = ntohl (initial_count);
10346 mp->initial_interval = ntohl (initial_interval);
10347 mp->suppress = suppress;
10348 mp->managed = managed;
10350 mp->ll_option = ll_option;
10351 mp->send_unicast = send_unicast;
10354 mp->default_router = default_router;
10359 /* Wait for a reply, return good/bad news */
10365 api_set_arp_neighbor_limit (vat_main_t * vam)
10367 unformat_input_t *i = vam->input;
10368 vl_api_set_arp_neighbor_limit_t *mp;
10374 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10376 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
10378 else if (unformat (i, "ipv6"))
10382 clib_warning ("parse error '%U'", format_unformat_error, i);
10387 if (limit_set == 0)
10389 errmsg ("missing limit value");
10393 M (SET_ARP_NEIGHBOR_LIMIT, mp);
10395 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
10396 mp->is_ipv6 = is_ipv6;
10404 api_l2_patch_add_del (vat_main_t * vam)
10406 unformat_input_t *i = vam->input;
10407 vl_api_l2_patch_add_del_t *mp;
10408 u32 rx_sw_if_index;
10409 u8 rx_sw_if_index_set = 0;
10410 u32 tx_sw_if_index;
10411 u8 tx_sw_if_index_set = 0;
10415 /* Parse args required to build the message */
10416 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10418 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
10419 rx_sw_if_index_set = 1;
10420 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
10421 tx_sw_if_index_set = 1;
10422 else if (unformat (i, "rx"))
10424 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10426 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10428 rx_sw_if_index_set = 1;
10433 else if (unformat (i, "tx"))
10435 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10437 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10439 tx_sw_if_index_set = 1;
10444 else if (unformat (i, "del"))
10450 if (rx_sw_if_index_set == 0)
10452 errmsg ("missing rx interface name or rx_sw_if_index");
10456 if (tx_sw_if_index_set == 0)
10458 errmsg ("missing tx interface name or tx_sw_if_index");
10462 M (L2_PATCH_ADD_DEL, mp);
10464 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
10465 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
10466 mp->is_add = is_add;
10474 u8 localsid_addr[16];
10483 api_sr_localsid_add_del (vat_main_t * vam)
10485 unformat_input_t *i = vam->input;
10486 vl_api_sr_localsid_add_del_t *mp;
10489 ip6_address_t localsid;
10493 u32 fib_table = ~(u32) 0;
10494 ip6_address_t nh_addr6;
10495 ip4_address_t nh_addr4;
10496 clib_memset (&nh_addr6, 0, sizeof (ip6_address_t));
10497 clib_memset (&nh_addr4, 0, sizeof (ip4_address_t));
10499 bool nexthop_set = 0;
10503 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10505 if (unformat (i, "del"))
10507 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
10508 else if (unformat (i, "next-hop %U", unformat_ip4_address, &nh_addr4))
10510 else if (unformat (i, "next-hop %U", unformat_ip6_address, &nh_addr6))
10512 else if (unformat (i, "behavior %u", &behavior));
10513 else if (unformat (i, "sw_if_index %u", &sw_if_index));
10514 else if (unformat (i, "fib-table %u", &fib_table));
10515 else if (unformat (i, "end.psp %u", &behavior));
10520 M (SR_LOCALSID_ADD_DEL, mp);
10522 clib_memcpy (mp->localsid.addr, &localsid, sizeof (mp->localsid));
10525 clib_memcpy (mp->nh_addr6, &nh_addr6, sizeof (mp->nh_addr6));
10526 clib_memcpy (mp->nh_addr4, &nh_addr4, sizeof (mp->nh_addr4));
10528 mp->behavior = behavior;
10529 mp->sw_if_index = ntohl (sw_if_index);
10530 mp->fib_table = ntohl (fib_table);
10531 mp->end_psp = end_psp;
10532 mp->is_del = is_del;
10540 api_ioam_enable (vat_main_t * vam)
10542 unformat_input_t *input = vam->input;
10543 vl_api_ioam_enable_t *mp;
10545 int has_trace_option = 0;
10546 int has_pot_option = 0;
10547 int has_seqno_option = 0;
10548 int has_analyse_option = 0;
10551 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10553 if (unformat (input, "trace"))
10554 has_trace_option = 1;
10555 else if (unformat (input, "pot"))
10556 has_pot_option = 1;
10557 else if (unformat (input, "seqno"))
10558 has_seqno_option = 1;
10559 else if (unformat (input, "analyse"))
10560 has_analyse_option = 1;
10564 M (IOAM_ENABLE, mp);
10565 mp->id = htons (id);
10566 mp->seqno = has_seqno_option;
10567 mp->analyse = has_analyse_option;
10568 mp->pot_enable = has_pot_option;
10569 mp->trace_enable = has_trace_option;
10578 api_ioam_disable (vat_main_t * vam)
10580 vl_api_ioam_disable_t *mp;
10583 M (IOAM_DISABLE, mp);
10589 #define foreach_tcp_proto_field \
10593 #define foreach_udp_proto_field \
10597 #define foreach_ip4_proto_field \
10609 u16 src_port, dst_port;
10612 #if VPP_API_TEST_BUILTIN == 0
10614 unformat_tcp_mask (unformat_input_t * input, va_list * args)
10616 u8 **maskp = va_arg (*args, u8 **);
10618 u8 found_something = 0;
10621 #define _(a) u8 a=0;
10622 foreach_tcp_proto_field;
10625 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10628 #define _(a) else if (unformat (input, #a)) a=1;
10629 foreach_tcp_proto_field
10635 #define _(a) found_something += a;
10636 foreach_tcp_proto_field;
10639 if (found_something == 0)
10642 vec_validate (mask, sizeof (*tcp) - 1);
10644 tcp = (tcp_header_t *) mask;
10646 #define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
10647 foreach_tcp_proto_field;
10655 unformat_udp_mask (unformat_input_t * input, va_list * args)
10657 u8 **maskp = va_arg (*args, u8 **);
10659 u8 found_something = 0;
10662 #define _(a) u8 a=0;
10663 foreach_udp_proto_field;
10666 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10669 #define _(a) else if (unformat (input, #a)) a=1;
10670 foreach_udp_proto_field
10676 #define _(a) found_something += a;
10677 foreach_udp_proto_field;
10680 if (found_something == 0)
10683 vec_validate (mask, sizeof (*udp) - 1);
10685 udp = (udp_header_t *) mask;
10687 #define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
10688 foreach_udp_proto_field;
10696 unformat_l4_mask (unformat_input_t * input, va_list * args)
10698 u8 **maskp = va_arg (*args, u8 **);
10699 u16 src_port = 0, dst_port = 0;
10700 tcpudp_header_t *tcpudp;
10702 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10704 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
10706 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
10708 else if (unformat (input, "src_port"))
10710 else if (unformat (input, "dst_port"))
10716 if (!src_port && !dst_port)
10720 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
10722 tcpudp = (tcpudp_header_t *) mask;
10723 tcpudp->src_port = src_port;
10724 tcpudp->dst_port = dst_port;
10732 unformat_ip4_mask (unformat_input_t * input, va_list * args)
10734 u8 **maskp = va_arg (*args, u8 **);
10736 u8 found_something = 0;
10739 #define _(a) u8 a=0;
10740 foreach_ip4_proto_field;
10746 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10748 if (unformat (input, "version"))
10750 else if (unformat (input, "hdr_length"))
10752 else if (unformat (input, "src"))
10754 else if (unformat (input, "dst"))
10756 else if (unformat (input, "proto"))
10759 #define _(a) else if (unformat (input, #a)) a=1;
10760 foreach_ip4_proto_field
10766 #define _(a) found_something += a;
10767 foreach_ip4_proto_field;
10770 if (found_something == 0)
10773 vec_validate (mask, sizeof (*ip) - 1);
10775 ip = (ip4_header_t *) mask;
10777 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
10778 foreach_ip4_proto_field;
10781 ip->ip_version_and_header_length = 0;
10784 ip->ip_version_and_header_length |= 0xF0;
10787 ip->ip_version_and_header_length |= 0x0F;
10793 #define foreach_ip6_proto_field \
10796 _(payload_length) \
10801 unformat_ip6_mask (unformat_input_t * input, va_list * args)
10803 u8 **maskp = va_arg (*args, u8 **);
10805 u8 found_something = 0;
10807 u32 ip_version_traffic_class_and_flow_label;
10809 #define _(a) u8 a=0;
10810 foreach_ip6_proto_field;
10813 u8 traffic_class = 0;
10816 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10818 if (unformat (input, "version"))
10820 else if (unformat (input, "traffic-class"))
10822 else if (unformat (input, "flow-label"))
10824 else if (unformat (input, "src"))
10826 else if (unformat (input, "dst"))
10828 else if (unformat (input, "proto"))
10831 #define _(a) else if (unformat (input, #a)) a=1;
10832 foreach_ip6_proto_field
10838 #define _(a) found_something += a;
10839 foreach_ip6_proto_field;
10842 if (found_something == 0)
10845 vec_validate (mask, sizeof (*ip) - 1);
10847 ip = (ip6_header_t *) mask;
10849 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
10850 foreach_ip6_proto_field;
10853 ip_version_traffic_class_and_flow_label = 0;
10856 ip_version_traffic_class_and_flow_label |= 0xF0000000;
10859 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
10862 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
10864 ip->ip_version_traffic_class_and_flow_label =
10865 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10872 unformat_l3_mask (unformat_input_t * input, va_list * args)
10874 u8 **maskp = va_arg (*args, u8 **);
10876 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10878 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
10880 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
10889 unformat_l2_mask (unformat_input_t * input, va_list * args)
10891 u8 **maskp = va_arg (*args, u8 **);
10898 u8 ignore_tag1 = 0;
10899 u8 ignore_tag2 = 0;
10906 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10908 if (unformat (input, "src"))
10910 else if (unformat (input, "dst"))
10912 else if (unformat (input, "proto"))
10914 else if (unformat (input, "tag1"))
10916 else if (unformat (input, "tag2"))
10918 else if (unformat (input, "ignore-tag1"))
10920 else if (unformat (input, "ignore-tag2"))
10922 else if (unformat (input, "cos1"))
10924 else if (unformat (input, "cos2"))
10926 else if (unformat (input, "dot1q"))
10928 else if (unformat (input, "dot1ad"))
10933 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
10934 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10937 if (tag1 || ignore_tag1 || cos1 || dot1q)
10939 if (tag2 || ignore_tag2 || cos2 || dot1ad)
10942 vec_validate (mask, len - 1);
10945 clib_memset (mask, 0xff, 6);
10948 clib_memset (mask + 6, 0xff, 6);
10950 if (tag2 || dot1ad)
10952 /* inner vlan tag */
10961 mask[21] = mask[20] = 0xff;
10982 mask[16] = mask[17] = 0xff;
10992 mask[12] = mask[13] = 0xff;
10999 unformat_classify_mask (unformat_input_t * input, va_list * args)
11001 u8 **maskp = va_arg (*args, u8 **);
11002 u32 *skipp = va_arg (*args, u32 *);
11003 u32 *matchp = va_arg (*args, u32 *);
11011 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11013 if (unformat (input, "hex %U", unformat_hex_string, &mask))
11015 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
11017 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
11019 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
11033 if (mask || l2 || l3 || l4)
11035 if (l2 || l3 || l4)
11037 /* "With a free Ethernet header in every package" */
11039 vec_validate (l2, 13);
11043 vec_append (mask, l3);
11048 vec_append (mask, l4);
11053 /* Scan forward looking for the first significant mask octet */
11054 for (i = 0; i < vec_len (mask); i++)
11058 /* compute (skip, match) params */
11059 *skipp = i / sizeof (u32x4);
11060 vec_delete (mask, *skipp * sizeof (u32x4), 0);
11062 /* Pad mask to an even multiple of the vector size */
11063 while (vec_len (mask) % sizeof (u32x4))
11064 vec_add1 (mask, 0);
11066 match = vec_len (mask) / sizeof (u32x4);
11068 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
11070 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
11071 if (*tmp || *(tmp + 1))
11076 clib_warning ("BUG: match 0");
11078 _vec_len (mask) = match * sizeof (u32x4);
11088 #endif /* VPP_API_TEST_BUILTIN */
11090 #define foreach_l2_next \
11092 _(ethernet, ETHERNET_INPUT) \
11093 _(ip4, IP4_INPUT) \
11097 unformat_l2_next_index (unformat_input_t * input, va_list * args)
11099 u32 *miss_next_indexp = va_arg (*args, u32 *);
11100 u32 next_index = 0;
11104 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
11108 if (unformat (input, "%d", &tmp))
11117 *miss_next_indexp = next_index;
11121 #define foreach_ip_next \
11124 _(rewrite, REWRITE)
11127 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
11129 u32 *miss_next_indexp = va_arg (*args, u32 *);
11130 u32 next_index = 0;
11134 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
11138 if (unformat (input, "%d", &tmp))
11147 *miss_next_indexp = next_index;
11151 #define foreach_acl_next \
11155 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
11157 u32 *miss_next_indexp = va_arg (*args, u32 *);
11158 u32 next_index = 0;
11162 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
11166 if (unformat (input, "permit"))
11171 else if (unformat (input, "%d", &tmp))
11180 *miss_next_indexp = next_index;
11185 unformat_policer_precolor (unformat_input_t * input, va_list * args)
11187 u32 *r = va_arg (*args, u32 *);
11189 if (unformat (input, "conform-color"))
11190 *r = POLICE_CONFORM;
11191 else if (unformat (input, "exceed-color"))
11192 *r = POLICE_EXCEED;
11200 api_classify_add_del_table (vat_main_t * vam)
11202 unformat_input_t *i = vam->input;
11203 vl_api_classify_add_del_table_t *mp;
11210 u32 table_index = ~0;
11211 u32 next_table_index = ~0;
11212 u32 miss_next_index = ~0;
11213 u32 memory_size = 32 << 20;
11215 u32 current_data_flag = 0;
11216 int current_data_offset = 0;
11219 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11221 if (unformat (i, "del"))
11223 else if (unformat (i, "del-chain"))
11228 else if (unformat (i, "buckets %d", &nbuckets))
11230 else if (unformat (i, "memory_size %d", &memory_size))
11232 else if (unformat (i, "skip %d", &skip))
11234 else if (unformat (i, "match %d", &match))
11236 else if (unformat (i, "table %d", &table_index))
11238 else if (unformat (i, "mask %U", unformat_classify_mask,
11239 &mask, &skip, &match))
11241 else if (unformat (i, "next-table %d", &next_table_index))
11243 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
11246 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
11249 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
11252 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
11254 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
11260 if (is_add && mask == 0)
11262 errmsg ("Mask required");
11266 if (is_add && skip == ~0)
11268 errmsg ("skip count required");
11272 if (is_add && match == ~0)
11274 errmsg ("match count required");
11278 if (!is_add && table_index == ~0)
11280 errmsg ("table index required for delete");
11284 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
11286 mp->is_add = is_add;
11287 mp->del_chain = del_chain;
11288 mp->table_index = ntohl (table_index);
11289 mp->nbuckets = ntohl (nbuckets);
11290 mp->memory_size = ntohl (memory_size);
11291 mp->skip_n_vectors = ntohl (skip);
11292 mp->match_n_vectors = ntohl (match);
11293 mp->next_table_index = ntohl (next_table_index);
11294 mp->miss_next_index = ntohl (miss_next_index);
11295 mp->current_data_flag = ntohl (current_data_flag);
11296 mp->current_data_offset = ntohl (current_data_offset);
11297 mp->mask_len = ntohl (vec_len (mask));
11298 clib_memcpy (mp->mask, mask, vec_len (mask));
11307 #if VPP_API_TEST_BUILTIN == 0
11309 unformat_l4_match (unformat_input_t * input, va_list * args)
11311 u8 **matchp = va_arg (*args, u8 **);
11313 u8 *proto_header = 0;
11319 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11321 if (unformat (input, "src_port %d", &src_port))
11323 else if (unformat (input, "dst_port %d", &dst_port))
11329 h.src_port = clib_host_to_net_u16 (src_port);
11330 h.dst_port = clib_host_to_net_u16 (dst_port);
11331 vec_validate (proto_header, sizeof (h) - 1);
11332 memcpy (proto_header, &h, sizeof (h));
11334 *matchp = proto_header;
11340 unformat_ip4_match (unformat_input_t * input, va_list * args)
11342 u8 **matchp = va_arg (*args, u8 **);
11347 int hdr_length = 0;
11348 u32 hdr_length_val;
11349 int src = 0, dst = 0;
11350 ip4_address_t src_val, dst_val;
11357 int fragment_id = 0;
11358 u32 fragment_id_val;
11364 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11366 if (unformat (input, "version %d", &version_val))
11368 else if (unformat (input, "hdr_length %d", &hdr_length_val))
11370 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
11372 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
11374 else if (unformat (input, "proto %d", &proto_val))
11376 else if (unformat (input, "tos %d", &tos_val))
11378 else if (unformat (input, "length %d", &length_val))
11380 else if (unformat (input, "fragment_id %d", &fragment_id_val))
11382 else if (unformat (input, "ttl %d", &ttl_val))
11384 else if (unformat (input, "checksum %d", &checksum_val))
11390 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
11391 + ttl + checksum == 0)
11395 * Aligned because we use the real comparison functions
11397 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11399 ip = (ip4_header_t *) match;
11401 /* These are realistically matched in practice */
11403 ip->src_address.as_u32 = src_val.as_u32;
11406 ip->dst_address.as_u32 = dst_val.as_u32;
11409 ip->protocol = proto_val;
11412 /* These are not, but they're included for completeness */
11414 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
11417 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
11423 ip->length = clib_host_to_net_u16 (length_val);
11429 ip->checksum = clib_host_to_net_u16 (checksum_val);
11436 unformat_ip6_match (unformat_input_t * input, va_list * args)
11438 u8 **matchp = va_arg (*args, u8 **);
11443 u8 traffic_class = 0;
11444 u32 traffic_class_val = 0;
11447 int src = 0, dst = 0;
11448 ip6_address_t src_val, dst_val;
11451 int payload_length = 0;
11452 u32 payload_length_val;
11455 u32 ip_version_traffic_class_and_flow_label;
11457 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11459 if (unformat (input, "version %d", &version_val))
11461 else if (unformat (input, "traffic_class %d", &traffic_class_val))
11463 else if (unformat (input, "flow_label %d", &flow_label_val))
11465 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
11467 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
11469 else if (unformat (input, "proto %d", &proto_val))
11471 else if (unformat (input, "payload_length %d", &payload_length_val))
11472 payload_length = 1;
11473 else if (unformat (input, "hop_limit %d", &hop_limit_val))
11479 if (version + traffic_class + flow_label + src + dst + proto +
11480 payload_length + hop_limit == 0)
11484 * Aligned because we use the real comparison functions
11486 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11488 ip = (ip6_header_t *) match;
11491 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
11494 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
11497 ip->protocol = proto_val;
11499 ip_version_traffic_class_and_flow_label = 0;
11502 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
11505 ip_version_traffic_class_and_flow_label |=
11506 (traffic_class_val & 0xFF) << 20;
11509 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
11511 ip->ip_version_traffic_class_and_flow_label =
11512 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
11514 if (payload_length)
11515 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
11518 ip->hop_limit = hop_limit_val;
11525 unformat_l3_match (unformat_input_t * input, va_list * args)
11527 u8 **matchp = va_arg (*args, u8 **);
11529 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11531 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
11533 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
11542 unformat_vlan_tag (unformat_input_t * input, va_list * args)
11544 u8 *tagp = va_arg (*args, u8 *);
11547 if (unformat (input, "%d", &tag))
11549 tagp[0] = (tag >> 8) & 0x0F;
11550 tagp[1] = tag & 0xFF;
11558 unformat_l2_match (unformat_input_t * input, va_list * args)
11560 u8 **matchp = va_arg (*args, u8 **);
11573 u8 ignore_tag1 = 0;
11574 u8 ignore_tag2 = 0;
11580 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11582 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
11585 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
11587 else if (unformat (input, "proto %U",
11588 unformat_ethernet_type_host_byte_order, &proto_val))
11590 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
11592 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
11594 else if (unformat (input, "ignore-tag1"))
11596 else if (unformat (input, "ignore-tag2"))
11598 else if (unformat (input, "cos1 %d", &cos1_val))
11600 else if (unformat (input, "cos2 %d", &cos2_val))
11605 if ((src + dst + proto + tag1 + tag2 +
11606 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
11609 if (tag1 || ignore_tag1 || cos1)
11611 if (tag2 || ignore_tag2 || cos2)
11614 vec_validate_aligned (match, len - 1, sizeof (u32x4));
11617 clib_memcpy (match, dst_val, 6);
11620 clib_memcpy (match + 6, src_val, 6);
11624 /* inner vlan tag */
11625 match[19] = tag2_val[1];
11626 match[18] = tag2_val[0];
11628 match[18] |= (cos2_val & 0x7) << 5;
11631 match[21] = proto_val & 0xff;
11632 match[20] = proto_val >> 8;
11636 match[15] = tag1_val[1];
11637 match[14] = tag1_val[0];
11640 match[14] |= (cos1_val & 0x7) << 5;
11646 match[15] = tag1_val[1];
11647 match[14] = tag1_val[0];
11650 match[17] = proto_val & 0xff;
11651 match[16] = proto_val >> 8;
11654 match[14] |= (cos1_val & 0x7) << 5;
11660 match[18] |= (cos2_val & 0x7) << 5;
11662 match[14] |= (cos1_val & 0x7) << 5;
11665 match[13] = proto_val & 0xff;
11666 match[12] = proto_val >> 8;
11674 unformat_qos_source (unformat_input_t * input, va_list * args)
11676 int *qs = va_arg (*args, int *);
11678 if (unformat (input, "ip"))
11679 *qs = QOS_SOURCE_IP;
11680 else if (unformat (input, "mpls"))
11681 *qs = QOS_SOURCE_MPLS;
11682 else if (unformat (input, "ext"))
11683 *qs = QOS_SOURCE_EXT;
11684 else if (unformat (input, "vlan"))
11685 *qs = QOS_SOURCE_VLAN;
11694 api_unformat_classify_match (unformat_input_t * input, va_list * args)
11696 u8 **matchp = va_arg (*args, u8 **);
11697 u32 skip_n_vectors = va_arg (*args, u32);
11698 u32 match_n_vectors = va_arg (*args, u32);
11705 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11707 if (unformat (input, "hex %U", unformat_hex_string, &match))
11709 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
11711 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
11713 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
11727 if (match || l2 || l3 || l4)
11729 if (l2 || l3 || l4)
11731 /* "Win a free Ethernet header in every packet" */
11733 vec_validate_aligned (l2, 13, sizeof (u32x4));
11737 vec_append_aligned (match, l3, sizeof (u32x4));
11742 vec_append_aligned (match, l4, sizeof (u32x4));
11747 /* Make sure the vector is big enough even if key is all 0's */
11748 vec_validate_aligned
11749 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
11752 /* Set size, include skipped vectors */
11753 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
11764 api_classify_add_del_session (vat_main_t * vam)
11766 unformat_input_t *i = vam->input;
11767 vl_api_classify_add_del_session_t *mp;
11769 u32 table_index = ~0;
11770 u32 hit_next_index = ~0;
11771 u32 opaque_index = ~0;
11774 u32 skip_n_vectors = 0;
11775 u32 match_n_vectors = 0;
11781 * Warning: you have to supply skip_n and match_n
11782 * because the API client cant simply look at the classify
11786 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11788 if (unformat (i, "del"))
11790 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
11793 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
11796 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
11799 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
11801 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
11803 else if (unformat (i, "opaque-index %d", &opaque_index))
11805 else if (unformat (i, "skip_n %d", &skip_n_vectors))
11807 else if (unformat (i, "match_n %d", &match_n_vectors))
11809 else if (unformat (i, "match %U", api_unformat_classify_match,
11810 &match, skip_n_vectors, match_n_vectors))
11812 else if (unformat (i, "advance %d", &advance))
11814 else if (unformat (i, "table-index %d", &table_index))
11816 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
11818 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
11820 else if (unformat (i, "action %d", &action))
11822 else if (unformat (i, "metadata %d", &metadata))
11828 if (table_index == ~0)
11830 errmsg ("Table index required");
11834 if (is_add && match == 0)
11836 errmsg ("Match value required");
11840 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
11842 mp->is_add = is_add;
11843 mp->table_index = ntohl (table_index);
11844 mp->hit_next_index = ntohl (hit_next_index);
11845 mp->opaque_index = ntohl (opaque_index);
11846 mp->advance = ntohl (advance);
11847 mp->action = action;
11848 mp->metadata = ntohl (metadata);
11849 mp->match_len = ntohl (vec_len (match));
11850 clib_memcpy (mp->match, match, vec_len (match));
11859 api_classify_set_interface_ip_table (vat_main_t * vam)
11861 unformat_input_t *i = vam->input;
11862 vl_api_classify_set_interface_ip_table_t *mp;
11864 int sw_if_index_set;
11865 u32 table_index = ~0;
11869 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11871 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11872 sw_if_index_set = 1;
11873 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11874 sw_if_index_set = 1;
11875 else if (unformat (i, "table %d", &table_index))
11879 clib_warning ("parse error '%U'", format_unformat_error, i);
11884 if (sw_if_index_set == 0)
11886 errmsg ("missing interface name or sw_if_index");
11891 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
11893 mp->sw_if_index = ntohl (sw_if_index);
11894 mp->table_index = ntohl (table_index);
11895 mp->is_ipv6 = is_ipv6;
11903 api_classify_set_interface_l2_tables (vat_main_t * vam)
11905 unformat_input_t *i = vam->input;
11906 vl_api_classify_set_interface_l2_tables_t *mp;
11908 int sw_if_index_set;
11909 u32 ip4_table_index = ~0;
11910 u32 ip6_table_index = ~0;
11911 u32 other_table_index = ~0;
11915 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11917 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11918 sw_if_index_set = 1;
11919 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11920 sw_if_index_set = 1;
11921 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11923 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11925 else if (unformat (i, "other-table %d", &other_table_index))
11927 else if (unformat (i, "is-input %d", &is_input))
11931 clib_warning ("parse error '%U'", format_unformat_error, i);
11936 if (sw_if_index_set == 0)
11938 errmsg ("missing interface name or sw_if_index");
11943 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
11945 mp->sw_if_index = ntohl (sw_if_index);
11946 mp->ip4_table_index = ntohl (ip4_table_index);
11947 mp->ip6_table_index = ntohl (ip6_table_index);
11948 mp->other_table_index = ntohl (other_table_index);
11949 mp->is_input = (u8) is_input;
11957 api_set_ipfix_exporter (vat_main_t * vam)
11959 unformat_input_t *i = vam->input;
11960 vl_api_set_ipfix_exporter_t *mp;
11961 ip4_address_t collector_address;
11962 u8 collector_address_set = 0;
11963 u32 collector_port = ~0;
11964 ip4_address_t src_address;
11965 u8 src_address_set = 0;
11968 u32 template_interval = ~0;
11969 u8 udp_checksum = 0;
11972 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11974 if (unformat (i, "collector_address %U", unformat_ip4_address,
11975 &collector_address))
11976 collector_address_set = 1;
11977 else if (unformat (i, "collector_port %d", &collector_port))
11979 else if (unformat (i, "src_address %U", unformat_ip4_address,
11981 src_address_set = 1;
11982 else if (unformat (i, "vrf_id %d", &vrf_id))
11984 else if (unformat (i, "path_mtu %d", &path_mtu))
11986 else if (unformat (i, "template_interval %d", &template_interval))
11988 else if (unformat (i, "udp_checksum"))
11994 if (collector_address_set == 0)
11996 errmsg ("collector_address required");
12000 if (src_address_set == 0)
12002 errmsg ("src_address required");
12006 M (SET_IPFIX_EXPORTER, mp);
12008 memcpy (mp->collector_address, collector_address.data,
12009 sizeof (collector_address.data));
12010 mp->collector_port = htons ((u16) collector_port);
12011 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
12012 mp->vrf_id = htonl (vrf_id);
12013 mp->path_mtu = htonl (path_mtu);
12014 mp->template_interval = htonl (template_interval);
12015 mp->udp_checksum = udp_checksum;
12023 api_set_ipfix_classify_stream (vat_main_t * vam)
12025 unformat_input_t *i = vam->input;
12026 vl_api_set_ipfix_classify_stream_t *mp;
12028 u32 src_port = UDP_DST_PORT_ipfix;
12031 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12033 if (unformat (i, "domain %d", &domain_id))
12035 else if (unformat (i, "src_port %d", &src_port))
12039 errmsg ("unknown input `%U'", format_unformat_error, i);
12044 M (SET_IPFIX_CLASSIFY_STREAM, mp);
12046 mp->domain_id = htonl (domain_id);
12047 mp->src_port = htons ((u16) src_port);
12055 api_ipfix_classify_table_add_del (vat_main_t * vam)
12057 unformat_input_t *i = vam->input;
12058 vl_api_ipfix_classify_table_add_del_t *mp;
12060 u32 classify_table_index = ~0;
12062 u8 transport_protocol = 255;
12065 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12067 if (unformat (i, "add"))
12069 else if (unformat (i, "del"))
12071 else if (unformat (i, "table %d", &classify_table_index))
12073 else if (unformat (i, "ip4"))
12075 else if (unformat (i, "ip6"))
12077 else if (unformat (i, "tcp"))
12078 transport_protocol = 6;
12079 else if (unformat (i, "udp"))
12080 transport_protocol = 17;
12083 errmsg ("unknown input `%U'", format_unformat_error, i);
12090 errmsg ("expecting: add|del");
12093 if (classify_table_index == ~0)
12095 errmsg ("classifier table not specified");
12098 if (ip_version == 0)
12100 errmsg ("IP version not specified");
12104 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
12106 mp->is_add = is_add;
12107 mp->table_id = htonl (classify_table_index);
12108 mp->ip_version = ip_version;
12109 mp->transport_protocol = transport_protocol;
12117 api_get_node_index (vat_main_t * vam)
12119 unformat_input_t *i = vam->input;
12120 vl_api_get_node_index_t *mp;
12124 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12126 if (unformat (i, "node %s", &name))
12133 errmsg ("node name required");
12136 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
12138 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12142 M (GET_NODE_INDEX, mp);
12143 clib_memcpy (mp->node_name, name, vec_len (name));
12152 api_get_next_index (vat_main_t * vam)
12154 unformat_input_t *i = vam->input;
12155 vl_api_get_next_index_t *mp;
12156 u8 *node_name = 0, *next_node_name = 0;
12159 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12161 if (unformat (i, "node-name %s", &node_name))
12163 else if (unformat (i, "next-node-name %s", &next_node_name))
12167 if (node_name == 0)
12169 errmsg ("node name required");
12172 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
12174 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12178 if (next_node_name == 0)
12180 errmsg ("next node name required");
12183 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
12185 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
12189 M (GET_NEXT_INDEX, mp);
12190 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
12191 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
12192 vec_free (node_name);
12193 vec_free (next_node_name);
12201 api_add_node_next (vat_main_t * vam)
12203 unformat_input_t *i = vam->input;
12204 vl_api_add_node_next_t *mp;
12209 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12211 if (unformat (i, "node %s", &name))
12213 else if (unformat (i, "next %s", &next))
12220 errmsg ("node name required");
12223 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
12225 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12230 errmsg ("next node required");
12233 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
12235 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
12239 M (ADD_NODE_NEXT, mp);
12240 clib_memcpy (mp->node_name, name, vec_len (name));
12241 clib_memcpy (mp->next_name, next, vec_len (next));
12251 api_l2tpv3_create_tunnel (vat_main_t * vam)
12253 unformat_input_t *i = vam->input;
12254 ip6_address_t client_address, our_address;
12255 int client_address_set = 0;
12256 int our_address_set = 0;
12257 u32 local_session_id = 0;
12258 u32 remote_session_id = 0;
12259 u64 local_cookie = 0;
12260 u64 remote_cookie = 0;
12261 u8 l2_sublayer_present = 0;
12262 vl_api_l2tpv3_create_tunnel_t *mp;
12265 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12267 if (unformat (i, "client_address %U", unformat_ip6_address,
12269 client_address_set = 1;
12270 else if (unformat (i, "our_address %U", unformat_ip6_address,
12272 our_address_set = 1;
12273 else if (unformat (i, "local_session_id %d", &local_session_id))
12275 else if (unformat (i, "remote_session_id %d", &remote_session_id))
12277 else if (unformat (i, "local_cookie %lld", &local_cookie))
12279 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
12281 else if (unformat (i, "l2-sublayer-present"))
12282 l2_sublayer_present = 1;
12287 if (client_address_set == 0)
12289 errmsg ("client_address required");
12293 if (our_address_set == 0)
12295 errmsg ("our_address required");
12299 M (L2TPV3_CREATE_TUNNEL, mp);
12301 clib_memcpy (mp->client_address, client_address.as_u8,
12302 sizeof (mp->client_address));
12304 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
12306 mp->local_session_id = ntohl (local_session_id);
12307 mp->remote_session_id = ntohl (remote_session_id);
12308 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
12309 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
12310 mp->l2_sublayer_present = l2_sublayer_present;
12319 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
12321 unformat_input_t *i = vam->input;
12323 u8 sw_if_index_set = 0;
12324 u64 new_local_cookie = 0;
12325 u64 new_remote_cookie = 0;
12326 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
12329 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12331 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12332 sw_if_index_set = 1;
12333 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12334 sw_if_index_set = 1;
12335 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
12337 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
12343 if (sw_if_index_set == 0)
12345 errmsg ("missing interface name or sw_if_index");
12349 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
12351 mp->sw_if_index = ntohl (sw_if_index);
12352 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
12353 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
12361 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
12363 unformat_input_t *i = vam->input;
12364 vl_api_l2tpv3_interface_enable_disable_t *mp;
12366 u8 sw_if_index_set = 0;
12367 u8 enable_disable = 1;
12370 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12372 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12373 sw_if_index_set = 1;
12374 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12375 sw_if_index_set = 1;
12376 else if (unformat (i, "enable"))
12377 enable_disable = 1;
12378 else if (unformat (i, "disable"))
12379 enable_disable = 0;
12384 if (sw_if_index_set == 0)
12386 errmsg ("missing interface name or sw_if_index");
12390 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
12392 mp->sw_if_index = ntohl (sw_if_index);
12393 mp->enable_disable = enable_disable;
12401 api_l2tpv3_set_lookup_key (vat_main_t * vam)
12403 unformat_input_t *i = vam->input;
12404 vl_api_l2tpv3_set_lookup_key_t *mp;
12408 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12410 if (unformat (i, "lookup_v6_src"))
12411 key = L2T_LOOKUP_SRC_ADDRESS;
12412 else if (unformat (i, "lookup_v6_dst"))
12413 key = L2T_LOOKUP_DST_ADDRESS;
12414 else if (unformat (i, "lookup_session_id"))
12415 key = L2T_LOOKUP_SESSION_ID;
12420 if (key == (u8) ~ 0)
12422 errmsg ("l2tp session lookup key unset");
12426 M (L2TPV3_SET_LOOKUP_KEY, mp);
12435 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
12436 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12438 vat_main_t *vam = &vat_main;
12440 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
12441 format_ip6_address, mp->our_address,
12442 format_ip6_address, mp->client_address,
12443 clib_net_to_host_u32 (mp->sw_if_index));
12446 " local cookies %016llx %016llx remote cookie %016llx",
12447 clib_net_to_host_u64 (mp->local_cookie[0]),
12448 clib_net_to_host_u64 (mp->local_cookie[1]),
12449 clib_net_to_host_u64 (mp->remote_cookie));
12451 print (vam->ofp, " local session-id %d remote session-id %d",
12452 clib_net_to_host_u32 (mp->local_session_id),
12453 clib_net_to_host_u32 (mp->remote_session_id));
12455 print (vam->ofp, " l2 specific sublayer %s\n",
12456 mp->l2_sublayer_present ? "preset" : "absent");
12460 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
12461 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12463 vat_main_t *vam = &vat_main;
12464 vat_json_node_t *node = NULL;
12465 struct in6_addr addr;
12467 if (VAT_JSON_ARRAY != vam->json_tree.type)
12469 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12470 vat_json_init_array (&vam->json_tree);
12472 node = vat_json_array_add (&vam->json_tree);
12474 vat_json_init_object (node);
12476 clib_memcpy (&addr, mp->our_address, sizeof (addr));
12477 vat_json_object_add_ip6 (node, "our_address", addr);
12478 clib_memcpy (&addr, mp->client_address, sizeof (addr));
12479 vat_json_object_add_ip6 (node, "client_address", addr);
12481 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
12482 vat_json_init_array (lc);
12483 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
12484 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
12485 vat_json_object_add_uint (node, "remote_cookie",
12486 clib_net_to_host_u64 (mp->remote_cookie));
12488 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
12489 vat_json_object_add_uint (node, "local_session_id",
12490 clib_net_to_host_u32 (mp->local_session_id));
12491 vat_json_object_add_uint (node, "remote_session_id",
12492 clib_net_to_host_u32 (mp->remote_session_id));
12493 vat_json_object_add_string_copy (node, "l2_sublayer",
12494 mp->l2_sublayer_present ? (u8 *) "present"
12495 : (u8 *) "absent");
12499 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
12501 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
12502 vl_api_control_ping_t *mp_ping;
12505 /* Get list of l2tpv3-tunnel interfaces */
12506 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
12509 /* Use a control ping for synchronization */
12510 MPING (CONTROL_PING, mp_ping);
12518 static void vl_api_sw_interface_tap_v2_details_t_handler
12519 (vl_api_sw_interface_tap_v2_details_t * mp)
12521 vat_main_t *vam = &vat_main;
12523 u8 *ip4 = format (0, "%U/%d", format_ip4_address, mp->host_ip4_addr,
12524 mp->host_ip4_prefix_len);
12525 u8 *ip6 = format (0, "%U/%d", format_ip6_address, mp->host_ip6_addr,
12526 mp->host_ip6_prefix_len);
12529 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s 0x%-08x",
12530 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
12531 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
12532 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
12533 mp->host_bridge, ip4, ip6, ntohl (mp->tap_flags));
12539 static void vl_api_sw_interface_tap_v2_details_t_handler_json
12540 (vl_api_sw_interface_tap_v2_details_t * mp)
12542 vat_main_t *vam = &vat_main;
12543 vat_json_node_t *node = NULL;
12545 if (VAT_JSON_ARRAY != vam->json_tree.type)
12547 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12548 vat_json_init_array (&vam->json_tree);
12550 node = vat_json_array_add (&vam->json_tree);
12552 vat_json_init_object (node);
12553 vat_json_object_add_uint (node, "id", ntohl (mp->id));
12554 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12555 vat_json_object_add_uint (node, "tap_flags", ntohl (mp->tap_flags));
12556 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
12557 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
12558 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
12559 vat_json_object_add_string_copy (node, "host_mac_addr",
12560 format (0, "%U", format_ethernet_address,
12561 &mp->host_mac_addr));
12562 vat_json_object_add_string_copy (node, "host_namespace",
12563 mp->host_namespace);
12564 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
12565 vat_json_object_add_string_copy (node, "host_ip4_addr",
12566 format (0, "%U/%d", format_ip4_address,
12568 mp->host_ip4_prefix_len));
12569 vat_json_object_add_string_copy (node, "host_ip6_addr",
12570 format (0, "%U/%d", format_ip6_address,
12572 mp->host_ip6_prefix_len));
12577 api_sw_interface_tap_v2_dump (vat_main_t * vam)
12579 vl_api_sw_interface_tap_v2_dump_t *mp;
12580 vl_api_control_ping_t *mp_ping;
12584 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
12585 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
12586 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
12589 /* Get list of tap interfaces */
12590 M (SW_INTERFACE_TAP_V2_DUMP, mp);
12593 /* Use a control ping for synchronization */
12594 MPING (CONTROL_PING, mp_ping);
12601 static void vl_api_sw_interface_virtio_pci_details_t_handler
12602 (vl_api_sw_interface_virtio_pci_details_t * mp)
12604 vat_main_t *vam = &vat_main;
12618 addr.as_u32 = ntohl (mp->pci_addr);
12619 u8 *pci_addr = format (0, "%04x:%02x:%02x.%x", addr.domain, addr.bus,
12620 addr.slot, addr.function);
12623 "\n%-12s %-12d %-12d %-12d %-17U 0x%-08llx",
12624 pci_addr, ntohl (mp->sw_if_index),
12625 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
12626 format_ethernet_address, mp->mac_addr,
12627 clib_net_to_host_u64 (mp->features));
12628 vec_free (pci_addr);
12631 static void vl_api_sw_interface_virtio_pci_details_t_handler_json
12632 (vl_api_sw_interface_virtio_pci_details_t * mp)
12634 vat_main_t *vam = &vat_main;
12635 vat_json_node_t *node = NULL;
12637 if (VAT_JSON_ARRAY != vam->json_tree.type)
12639 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12640 vat_json_init_array (&vam->json_tree);
12642 node = vat_json_array_add (&vam->json_tree);
12644 vat_json_init_object (node);
12645 vat_json_object_add_uint (node, "pci-addr", ntohl (mp->pci_addr));
12646 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12647 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
12648 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
12649 vat_json_object_add_uint (node, "features",
12650 clib_net_to_host_u64 (mp->features));
12651 vat_json_object_add_string_copy (node, "mac_addr",
12652 format (0, "%U", format_ethernet_address,
12657 api_sw_interface_virtio_pci_dump (vat_main_t * vam)
12659 vl_api_sw_interface_virtio_pci_dump_t *mp;
12660 vl_api_control_ping_t *mp_ping;
12664 "\n%-12s %-12s %-12s %-12s %-17s %-08s",
12665 "pci_addr", "sw_if_index", "rx_ring_sz", "tx_ring_sz",
12666 "mac_addr", "features");
12668 /* Get list of tap interfaces */
12669 M (SW_INTERFACE_VIRTIO_PCI_DUMP, mp);
12672 /* Use a control ping for synchronization */
12673 MPING (CONTROL_PING, mp_ping);
12681 api_vxlan_offload_rx (vat_main_t * vam)
12683 unformat_input_t *line_input = vam->input;
12684 vl_api_vxlan_offload_rx_t *mp;
12685 u32 hw_if_index = ~0, rx_if_index = ~0;
12689 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12691 if (unformat (line_input, "del"))
12693 else if (unformat (line_input, "hw %U", api_unformat_hw_if_index, vam,
12696 else if (unformat (line_input, "hw hw_if_index %u", &hw_if_index))
12698 else if (unformat (line_input, "rx %U", api_unformat_sw_if_index, vam,
12701 else if (unformat (line_input, "rx sw_if_index %u", &rx_if_index))
12705 errmsg ("parse error '%U'", format_unformat_error, line_input);
12710 if (hw_if_index == ~0)
12712 errmsg ("no hw interface");
12716 if (rx_if_index == ~0)
12718 errmsg ("no rx tunnel");
12722 M (VXLAN_OFFLOAD_RX, mp);
12724 mp->hw_if_index = ntohl (hw_if_index);
12725 mp->sw_if_index = ntohl (rx_if_index);
12726 mp->enable = is_add;
12733 static uword unformat_vxlan_decap_next
12734 (unformat_input_t * input, va_list * args)
12736 u32 *result = va_arg (*args, u32 *);
12739 if (unformat (input, "l2"))
12740 *result = VXLAN_INPUT_NEXT_L2_INPUT;
12741 else if (unformat (input, "%d", &tmp))
12749 api_vxlan_add_del_tunnel (vat_main_t * vam)
12751 unformat_input_t *line_input = vam->input;
12752 vl_api_vxlan_add_del_tunnel_t *mp;
12753 ip46_address_t src, dst;
12755 u8 ipv4_set = 0, ipv6_set = 0;
12760 u32 mcast_sw_if_index = ~0;
12761 u32 encap_vrf_id = 0;
12762 u32 decap_next_index = ~0;
12766 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12767 clib_memset (&src, 0, sizeof src);
12768 clib_memset (&dst, 0, sizeof dst);
12770 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12772 if (unformat (line_input, "del"))
12774 else if (unformat (line_input, "instance %d", &instance))
12777 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12783 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12789 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12795 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12800 else if (unformat (line_input, "group %U %U",
12801 unformat_ip4_address, &dst.ip4,
12802 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12804 grp_set = dst_set = 1;
12807 else if (unformat (line_input, "group %U",
12808 unformat_ip4_address, &dst.ip4))
12810 grp_set = dst_set = 1;
12813 else if (unformat (line_input, "group %U %U",
12814 unformat_ip6_address, &dst.ip6,
12815 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12817 grp_set = dst_set = 1;
12820 else if (unformat (line_input, "group %U",
12821 unformat_ip6_address, &dst.ip6))
12823 grp_set = dst_set = 1;
12827 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12829 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12831 else if (unformat (line_input, "decap-next %U",
12832 unformat_vxlan_decap_next, &decap_next_index))
12834 else if (unformat (line_input, "vni %d", &vni))
12838 errmsg ("parse error '%U'", format_unformat_error, line_input);
12845 errmsg ("tunnel src address not specified");
12850 errmsg ("tunnel dst address not specified");
12854 if (grp_set && !ip46_address_is_multicast (&dst))
12856 errmsg ("tunnel group address not multicast");
12859 if (grp_set && mcast_sw_if_index == ~0)
12861 errmsg ("tunnel nonexistent multicast device");
12864 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12866 errmsg ("tunnel dst address must be unicast");
12871 if (ipv4_set && ipv6_set)
12873 errmsg ("both IPv4 and IPv6 addresses specified");
12877 if ((vni == 0) || (vni >> 24))
12879 errmsg ("vni not specified or out of range");
12883 M (VXLAN_ADD_DEL_TUNNEL, mp);
12887 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
12888 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
12892 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
12893 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
12896 mp->instance = htonl (instance);
12897 mp->encap_vrf_id = ntohl (encap_vrf_id);
12898 mp->decap_next_index = ntohl (decap_next_index);
12899 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12900 mp->vni = ntohl (vni);
12901 mp->is_add = is_add;
12902 mp->is_ipv6 = ipv6_set;
12909 static void vl_api_vxlan_tunnel_details_t_handler
12910 (vl_api_vxlan_tunnel_details_t * mp)
12912 vat_main_t *vam = &vat_main;
12913 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12914 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12916 print (vam->ofp, "%11d%11d%24U%24U%14d%18d%13d%19d",
12917 ntohl (mp->sw_if_index),
12918 ntohl (mp->instance),
12919 format_ip46_address, &src, IP46_TYPE_ANY,
12920 format_ip46_address, &dst, IP46_TYPE_ANY,
12921 ntohl (mp->encap_vrf_id),
12922 ntohl (mp->decap_next_index), ntohl (mp->vni),
12923 ntohl (mp->mcast_sw_if_index));
12926 static void vl_api_vxlan_tunnel_details_t_handler_json
12927 (vl_api_vxlan_tunnel_details_t * mp)
12929 vat_main_t *vam = &vat_main;
12930 vat_json_node_t *node = NULL;
12932 if (VAT_JSON_ARRAY != vam->json_tree.type)
12934 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12935 vat_json_init_array (&vam->json_tree);
12937 node = vat_json_array_add (&vam->json_tree);
12939 vat_json_init_object (node);
12940 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12942 vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
12946 struct in6_addr ip6;
12948 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12949 vat_json_object_add_ip6 (node, "src_address", ip6);
12950 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12951 vat_json_object_add_ip6 (node, "dst_address", ip6);
12955 struct in_addr ip4;
12957 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12958 vat_json_object_add_ip4 (node, "src_address", ip4);
12959 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12960 vat_json_object_add_ip4 (node, "dst_address", ip4);
12962 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12963 vat_json_object_add_uint (node, "decap_next_index",
12964 ntohl (mp->decap_next_index));
12965 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12966 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12967 vat_json_object_add_uint (node, "mcast_sw_if_index",
12968 ntohl (mp->mcast_sw_if_index));
12972 api_vxlan_tunnel_dump (vat_main_t * vam)
12974 unformat_input_t *i = vam->input;
12975 vl_api_vxlan_tunnel_dump_t *mp;
12976 vl_api_control_ping_t *mp_ping;
12978 u8 sw_if_index_set = 0;
12981 /* Parse args required to build the message */
12982 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12984 if (unformat (i, "sw_if_index %d", &sw_if_index))
12985 sw_if_index_set = 1;
12990 if (sw_if_index_set == 0)
12995 if (!vam->json_output)
12997 print (vam->ofp, "%11s%11s%24s%24s%14s%18s%13s%19s",
12998 "sw_if_index", "instance", "src_address", "dst_address",
12999 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
13002 /* Get list of vxlan-tunnel interfaces */
13003 M (VXLAN_TUNNEL_DUMP, mp);
13005 mp->sw_if_index = htonl (sw_if_index);
13009 /* Use a control ping for synchronization */
13010 MPING (CONTROL_PING, mp_ping);
13017 static uword unformat_geneve_decap_next
13018 (unformat_input_t * input, va_list * args)
13020 u32 *result = va_arg (*args, u32 *);
13023 if (unformat (input, "l2"))
13024 *result = GENEVE_INPUT_NEXT_L2_INPUT;
13025 else if (unformat (input, "%d", &tmp))
13033 api_geneve_add_del_tunnel (vat_main_t * vam)
13035 unformat_input_t *line_input = vam->input;
13036 vl_api_geneve_add_del_tunnel_t *mp;
13037 ip46_address_t src, dst;
13039 u8 ipv4_set = 0, ipv6_set = 0;
13043 u32 mcast_sw_if_index = ~0;
13044 u32 encap_vrf_id = 0;
13045 u32 decap_next_index = ~0;
13049 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
13050 clib_memset (&src, 0, sizeof src);
13051 clib_memset (&dst, 0, sizeof dst);
13053 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13055 if (unformat (line_input, "del"))
13058 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
13064 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
13070 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
13076 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
13081 else if (unformat (line_input, "group %U %U",
13082 unformat_ip4_address, &dst.ip4,
13083 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13085 grp_set = dst_set = 1;
13088 else if (unformat (line_input, "group %U",
13089 unformat_ip4_address, &dst.ip4))
13091 grp_set = dst_set = 1;
13094 else if (unformat (line_input, "group %U %U",
13095 unformat_ip6_address, &dst.ip6,
13096 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13098 grp_set = dst_set = 1;
13101 else if (unformat (line_input, "group %U",
13102 unformat_ip6_address, &dst.ip6))
13104 grp_set = dst_set = 1;
13108 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13110 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13112 else if (unformat (line_input, "decap-next %U",
13113 unformat_geneve_decap_next, &decap_next_index))
13115 else if (unformat (line_input, "vni %d", &vni))
13119 errmsg ("parse error '%U'", format_unformat_error, line_input);
13126 errmsg ("tunnel src address not specified");
13131 errmsg ("tunnel dst address not specified");
13135 if (grp_set && !ip46_address_is_multicast (&dst))
13137 errmsg ("tunnel group address not multicast");
13140 if (grp_set && mcast_sw_if_index == ~0)
13142 errmsg ("tunnel nonexistent multicast device");
13145 if (grp_set == 0 && ip46_address_is_multicast (&dst))
13147 errmsg ("tunnel dst address must be unicast");
13152 if (ipv4_set && ipv6_set)
13154 errmsg ("both IPv4 and IPv6 addresses specified");
13158 if ((vni == 0) || (vni >> 24))
13160 errmsg ("vni not specified or out of range");
13164 M (GENEVE_ADD_DEL_TUNNEL, mp);
13168 clib_memcpy (mp->local_address, &src.ip6, sizeof (src.ip6));
13169 clib_memcpy (mp->remote_address, &dst.ip6, sizeof (dst.ip6));
13173 clib_memcpy (mp->local_address, &src.ip4, sizeof (src.ip4));
13174 clib_memcpy (mp->remote_address, &dst.ip4, sizeof (dst.ip4));
13176 mp->encap_vrf_id = ntohl (encap_vrf_id);
13177 mp->decap_next_index = ntohl (decap_next_index);
13178 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
13179 mp->vni = ntohl (vni);
13180 mp->is_add = is_add;
13181 mp->is_ipv6 = ipv6_set;
13188 static void vl_api_geneve_tunnel_details_t_handler
13189 (vl_api_geneve_tunnel_details_t * mp)
13191 vat_main_t *vam = &vat_main;
13192 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
13193 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
13195 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
13196 ntohl (mp->sw_if_index),
13197 format_ip46_address, &src, IP46_TYPE_ANY,
13198 format_ip46_address, &dst, IP46_TYPE_ANY,
13199 ntohl (mp->encap_vrf_id),
13200 ntohl (mp->decap_next_index), ntohl (mp->vni),
13201 ntohl (mp->mcast_sw_if_index));
13204 static void vl_api_geneve_tunnel_details_t_handler_json
13205 (vl_api_geneve_tunnel_details_t * mp)
13207 vat_main_t *vam = &vat_main;
13208 vat_json_node_t *node = NULL;
13210 if (VAT_JSON_ARRAY != vam->json_tree.type)
13212 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13213 vat_json_init_array (&vam->json_tree);
13215 node = vat_json_array_add (&vam->json_tree);
13217 vat_json_init_object (node);
13218 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13221 struct in6_addr ip6;
13223 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
13224 vat_json_object_add_ip6 (node, "src_address", ip6);
13225 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
13226 vat_json_object_add_ip6 (node, "dst_address", ip6);
13230 struct in_addr ip4;
13232 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
13233 vat_json_object_add_ip4 (node, "src_address", ip4);
13234 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
13235 vat_json_object_add_ip4 (node, "dst_address", ip4);
13237 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
13238 vat_json_object_add_uint (node, "decap_next_index",
13239 ntohl (mp->decap_next_index));
13240 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
13241 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
13242 vat_json_object_add_uint (node, "mcast_sw_if_index",
13243 ntohl (mp->mcast_sw_if_index));
13247 api_geneve_tunnel_dump (vat_main_t * vam)
13249 unformat_input_t *i = vam->input;
13250 vl_api_geneve_tunnel_dump_t *mp;
13251 vl_api_control_ping_t *mp_ping;
13253 u8 sw_if_index_set = 0;
13256 /* Parse args required to build the message */
13257 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13259 if (unformat (i, "sw_if_index %d", &sw_if_index))
13260 sw_if_index_set = 1;
13265 if (sw_if_index_set == 0)
13270 if (!vam->json_output)
13272 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
13273 "sw_if_index", "local_address", "remote_address",
13274 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
13277 /* Get list of geneve-tunnel interfaces */
13278 M (GENEVE_TUNNEL_DUMP, mp);
13280 mp->sw_if_index = htonl (sw_if_index);
13284 /* Use a control ping for synchronization */
13285 M (CONTROL_PING, mp_ping);
13293 api_gre_tunnel_add_del (vat_main_t * vam)
13295 unformat_input_t *line_input = vam->input;
13296 vl_api_address_t src = { }, dst =
13299 vl_api_gre_tunnel_add_del_t *mp;
13300 vl_api_gre_tunnel_type_t t_type;
13306 u32 outer_fib_id = 0;
13307 u32 session_id = 0;
13311 t_type = GRE_API_TUNNEL_TYPE_L3;
13313 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13315 if (unformat (line_input, "del"))
13317 else if (unformat (line_input, "instance %d", &instance))
13319 else if (unformat (line_input, "src %U", unformat_vl_api_address, &src))
13323 else if (unformat (line_input, "dst %U", unformat_vl_api_address, &dst))
13327 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
13329 else if (unformat (line_input, "teb"))
13330 t_type = GRE_API_TUNNEL_TYPE_TEB;
13331 else if (unformat (line_input, "erspan %d", &session_id))
13332 t_type = GRE_API_TUNNEL_TYPE_ERSPAN;
13335 errmsg ("parse error '%U'", format_unformat_error, line_input);
13342 errmsg ("tunnel src address not specified");
13347 errmsg ("tunnel dst address not specified");
13351 M (GRE_TUNNEL_ADD_DEL, mp);
13353 clib_memcpy (&mp->tunnel.src, &src, sizeof (mp->tunnel.src));
13354 clib_memcpy (&mp->tunnel.dst, &dst, sizeof (mp->tunnel.dst));
13356 mp->tunnel.instance = htonl (instance);
13357 mp->tunnel.outer_fib_id = htonl (outer_fib_id);
13358 mp->is_add = is_add;
13359 mp->tunnel.session_id = htons ((u16) session_id);
13360 mp->tunnel.type = htonl (t_type);
13367 static void vl_api_gre_tunnel_details_t_handler
13368 (vl_api_gre_tunnel_details_t * mp)
13370 vat_main_t *vam = &vat_main;
13372 print (vam->ofp, "%11d%11d%24U%24U%13d%14d%12d",
13373 ntohl (mp->tunnel.sw_if_index),
13374 ntohl (mp->tunnel.instance),
13375 format_vl_api_address, &mp->tunnel.src,
13376 format_vl_api_address, &mp->tunnel.dst,
13377 mp->tunnel.type, ntohl (mp->tunnel.outer_fib_id),
13378 ntohl (mp->tunnel.session_id));
13382 vat_json_object_add_address (vat_json_node_t * node,
13383 const char *str, const vl_api_address_t * addr)
13385 if (ADDRESS_IP6 == addr->af)
13387 struct in6_addr ip6;
13389 clib_memcpy (&ip6, &addr->un.ip6, sizeof (ip6));
13390 vat_json_object_add_ip6 (node, str, ip6);
13394 struct in_addr ip4;
13396 clib_memcpy (&ip4, &addr->un.ip4, sizeof (ip4));
13397 vat_json_object_add_ip4 (node, str, ip4);
13401 static void vl_api_gre_tunnel_details_t_handler_json
13402 (vl_api_gre_tunnel_details_t * mp)
13404 vat_main_t *vam = &vat_main;
13405 vat_json_node_t *node = NULL;
13406 struct in_addr ip4;
13407 struct in6_addr ip6;
13409 if (VAT_JSON_ARRAY != vam->json_tree.type)
13411 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13412 vat_json_init_array (&vam->json_tree);
13414 node = vat_json_array_add (&vam->json_tree);
13416 vat_json_init_object (node);
13417 vat_json_object_add_uint (node, "sw_if_index",
13418 ntohl (mp->tunnel.sw_if_index));
13419 vat_json_object_add_uint (node, "instance", ntohl (mp->tunnel.instance));
13421 vat_json_object_add_address (node, "src", &mp->tunnel.src);
13422 vat_json_object_add_address (node, "dst", &mp->tunnel.dst);
13423 vat_json_object_add_uint (node, "tunnel_type", mp->tunnel.type);
13424 vat_json_object_add_uint (node, "outer_fib_id",
13425 ntohl (mp->tunnel.outer_fib_id));
13426 vat_json_object_add_uint (node, "session_id", mp->tunnel.session_id);
13430 api_gre_tunnel_dump (vat_main_t * vam)
13432 unformat_input_t *i = vam->input;
13433 vl_api_gre_tunnel_dump_t *mp;
13434 vl_api_control_ping_t *mp_ping;
13436 u8 sw_if_index_set = 0;
13439 /* Parse args required to build the message */
13440 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13442 if (unformat (i, "sw_if_index %d", &sw_if_index))
13443 sw_if_index_set = 1;
13448 if (sw_if_index_set == 0)
13453 if (!vam->json_output)
13455 print (vam->ofp, "%11s%11s%24s%24s%13s%14s%12s",
13456 "sw_if_index", "instance", "src_address", "dst_address",
13457 "tunnel_type", "outer_fib_id", "session_id");
13460 /* Get list of gre-tunnel interfaces */
13461 M (GRE_TUNNEL_DUMP, mp);
13463 mp->sw_if_index = htonl (sw_if_index);
13467 /* Use a control ping for synchronization */
13468 MPING (CONTROL_PING, mp_ping);
13476 api_l2_fib_clear_table (vat_main_t * vam)
13478 // unformat_input_t * i = vam->input;
13479 vl_api_l2_fib_clear_table_t *mp;
13482 M (L2_FIB_CLEAR_TABLE, mp);
13490 api_l2_interface_efp_filter (vat_main_t * vam)
13492 unformat_input_t *i = vam->input;
13493 vl_api_l2_interface_efp_filter_t *mp;
13496 u8 sw_if_index_set = 0;
13499 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13501 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13502 sw_if_index_set = 1;
13503 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13504 sw_if_index_set = 1;
13505 else if (unformat (i, "enable"))
13507 else if (unformat (i, "disable"))
13511 clib_warning ("parse error '%U'", format_unformat_error, i);
13516 if (sw_if_index_set == 0)
13518 errmsg ("missing sw_if_index");
13522 M (L2_INTERFACE_EFP_FILTER, mp);
13524 mp->sw_if_index = ntohl (sw_if_index);
13525 mp->enable_disable = enable;
13532 #define foreach_vtr_op \
13533 _("disable", L2_VTR_DISABLED) \
13534 _("push-1", L2_VTR_PUSH_1) \
13535 _("push-2", L2_VTR_PUSH_2) \
13536 _("pop-1", L2_VTR_POP_1) \
13537 _("pop-2", L2_VTR_POP_2) \
13538 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
13539 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
13540 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
13541 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
13544 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
13546 unformat_input_t *i = vam->input;
13547 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
13549 u8 sw_if_index_set = 0;
13552 u32 push_dot1q = 1;
13557 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13559 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13560 sw_if_index_set = 1;
13561 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13562 sw_if_index_set = 1;
13563 else if (unformat (i, "vtr_op %d", &vtr_op))
13565 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
13568 else if (unformat (i, "push_dot1q %d", &push_dot1q))
13570 else if (unformat (i, "tag1 %d", &tag1))
13572 else if (unformat (i, "tag2 %d", &tag2))
13576 clib_warning ("parse error '%U'", format_unformat_error, i);
13581 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
13583 errmsg ("missing vtr operation or sw_if_index");
13587 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
13588 mp->sw_if_index = ntohl (sw_if_index);
13589 mp->vtr_op = ntohl (vtr_op);
13590 mp->push_dot1q = ntohl (push_dot1q);
13591 mp->tag1 = ntohl (tag1);
13592 mp->tag2 = ntohl (tag2);
13600 api_create_vhost_user_if (vat_main_t * vam)
13602 unformat_input_t *i = vam->input;
13603 vl_api_create_vhost_user_if_t *mp;
13606 u8 file_name_set = 0;
13607 u32 custom_dev_instance = ~0;
13609 u8 use_custom_mac = 0;
13610 u8 disable_mrg_rxbuf = 0;
13611 u8 disable_indirect_desc = 0;
13615 /* Shut up coverity */
13616 clib_memset (hwaddr, 0, sizeof (hwaddr));
13618 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13620 if (unformat (i, "socket %s", &file_name))
13624 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13626 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
13627 use_custom_mac = 1;
13628 else if (unformat (i, "server"))
13630 else if (unformat (i, "disable_mrg_rxbuf"))
13631 disable_mrg_rxbuf = 1;
13632 else if (unformat (i, "disable_indirect_desc"))
13633 disable_indirect_desc = 1;
13634 else if (unformat (i, "tag %s", &tag))
13640 if (file_name_set == 0)
13642 errmsg ("missing socket file name");
13646 if (vec_len (file_name) > 255)
13648 errmsg ("socket file name too long");
13651 vec_add1 (file_name, 0);
13653 M (CREATE_VHOST_USER_IF, mp);
13655 mp->is_server = is_server;
13656 mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
13657 mp->disable_indirect_desc = disable_indirect_desc;
13658 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13659 vec_free (file_name);
13660 if (custom_dev_instance != ~0)
13663 mp->custom_dev_instance = ntohl (custom_dev_instance);
13666 mp->use_custom_mac = use_custom_mac;
13667 clib_memcpy (mp->mac_address, hwaddr, 6);
13669 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
13678 api_modify_vhost_user_if (vat_main_t * vam)
13680 unformat_input_t *i = vam->input;
13681 vl_api_modify_vhost_user_if_t *mp;
13684 u8 file_name_set = 0;
13685 u32 custom_dev_instance = ~0;
13686 u8 sw_if_index_set = 0;
13687 u32 sw_if_index = (u32) ~ 0;
13690 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13692 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13693 sw_if_index_set = 1;
13694 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13695 sw_if_index_set = 1;
13696 else if (unformat (i, "socket %s", &file_name))
13700 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13702 else if (unformat (i, "server"))
13708 if (sw_if_index_set == 0)
13710 errmsg ("missing sw_if_index or interface name");
13714 if (file_name_set == 0)
13716 errmsg ("missing socket file name");
13720 if (vec_len (file_name) > 255)
13722 errmsg ("socket file name too long");
13725 vec_add1 (file_name, 0);
13727 M (MODIFY_VHOST_USER_IF, mp);
13729 mp->sw_if_index = ntohl (sw_if_index);
13730 mp->is_server = is_server;
13731 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13732 vec_free (file_name);
13733 if (custom_dev_instance != ~0)
13736 mp->custom_dev_instance = ntohl (custom_dev_instance);
13745 api_delete_vhost_user_if (vat_main_t * vam)
13747 unformat_input_t *i = vam->input;
13748 vl_api_delete_vhost_user_if_t *mp;
13749 u32 sw_if_index = ~0;
13750 u8 sw_if_index_set = 0;
13753 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13755 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13756 sw_if_index_set = 1;
13757 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13758 sw_if_index_set = 1;
13763 if (sw_if_index_set == 0)
13765 errmsg ("missing sw_if_index or interface name");
13770 M (DELETE_VHOST_USER_IF, mp);
13772 mp->sw_if_index = ntohl (sw_if_index);
13779 static void vl_api_sw_interface_vhost_user_details_t_handler
13780 (vl_api_sw_interface_vhost_user_details_t * mp)
13782 vat_main_t *vam = &vat_main;
13784 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
13785 (char *) mp->interface_name,
13786 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
13787 clib_net_to_host_u64 (mp->features), mp->is_server,
13788 ntohl (mp->num_regions), (char *) mp->sock_filename);
13789 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
13792 static void vl_api_sw_interface_vhost_user_details_t_handler_json
13793 (vl_api_sw_interface_vhost_user_details_t * mp)
13795 vat_main_t *vam = &vat_main;
13796 vat_json_node_t *node = NULL;
13798 if (VAT_JSON_ARRAY != vam->json_tree.type)
13800 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13801 vat_json_init_array (&vam->json_tree);
13803 node = vat_json_array_add (&vam->json_tree);
13805 vat_json_init_object (node);
13806 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13807 vat_json_object_add_string_copy (node, "interface_name",
13808 mp->interface_name);
13809 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
13810 ntohl (mp->virtio_net_hdr_sz));
13811 vat_json_object_add_uint (node, "features",
13812 clib_net_to_host_u64 (mp->features));
13813 vat_json_object_add_uint (node, "is_server", mp->is_server);
13814 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
13815 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
13816 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
13820 api_sw_interface_vhost_user_dump (vat_main_t * vam)
13822 vl_api_sw_interface_vhost_user_dump_t *mp;
13823 vl_api_control_ping_t *mp_ping;
13826 "Interface name idx hdr_sz features server regions filename");
13828 /* Get list of vhost-user interfaces */
13829 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
13832 /* Use a control ping for synchronization */
13833 MPING (CONTROL_PING, mp_ping);
13841 api_show_version (vat_main_t * vam)
13843 vl_api_show_version_t *mp;
13846 M (SHOW_VERSION, mp);
13855 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
13857 unformat_input_t *line_input = vam->input;
13858 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
13859 ip4_address_t local4, remote4;
13860 ip6_address_t local6, remote6;
13862 u8 ipv4_set = 0, ipv6_set = 0;
13866 u32 mcast_sw_if_index = ~0;
13867 u32 encap_vrf_id = 0;
13868 u32 decap_vrf_id = 0;
13874 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
13875 clib_memset (&local4, 0, sizeof local4);
13876 clib_memset (&remote4, 0, sizeof remote4);
13877 clib_memset (&local6, 0, sizeof local6);
13878 clib_memset (&remote6, 0, sizeof remote6);
13880 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13882 if (unformat (line_input, "del"))
13884 else if (unformat (line_input, "local %U",
13885 unformat_ip4_address, &local4))
13890 else if (unformat (line_input, "remote %U",
13891 unformat_ip4_address, &remote4))
13896 else if (unformat (line_input, "local %U",
13897 unformat_ip6_address, &local6))
13902 else if (unformat (line_input, "remote %U",
13903 unformat_ip6_address, &remote6))
13908 else if (unformat (line_input, "group %U %U",
13909 unformat_ip4_address, &remote4,
13910 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13912 grp_set = remote_set = 1;
13915 else if (unformat (line_input, "group %U",
13916 unformat_ip4_address, &remote4))
13918 grp_set = remote_set = 1;
13921 else if (unformat (line_input, "group %U %U",
13922 unformat_ip6_address, &remote6,
13923 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13925 grp_set = remote_set = 1;
13928 else if (unformat (line_input, "group %U",
13929 unformat_ip6_address, &remote6))
13931 grp_set = remote_set = 1;
13935 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13937 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13939 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
13941 else if (unformat (line_input, "vni %d", &vni))
13943 else if (unformat (line_input, "next-ip4"))
13945 else if (unformat (line_input, "next-ip6"))
13947 else if (unformat (line_input, "next-ethernet"))
13949 else if (unformat (line_input, "next-nsh"))
13953 errmsg ("parse error '%U'", format_unformat_error, line_input);
13958 if (local_set == 0)
13960 errmsg ("tunnel local address not specified");
13963 if (remote_set == 0)
13965 errmsg ("tunnel remote address not specified");
13968 if (grp_set && mcast_sw_if_index == ~0)
13970 errmsg ("tunnel nonexistent multicast device");
13973 if (ipv4_set && ipv6_set)
13975 errmsg ("both IPv4 and IPv6 addresses specified");
13981 errmsg ("vni not specified");
13985 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
13990 clib_memcpy (&mp->local, &local6, sizeof (local6));
13991 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
13995 clib_memcpy (&mp->local, &local4, sizeof (local4));
13996 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
13999 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
14000 mp->encap_vrf_id = ntohl (encap_vrf_id);
14001 mp->decap_vrf_id = ntohl (decap_vrf_id);
14002 mp->protocol = protocol;
14003 mp->vni = ntohl (vni);
14004 mp->is_add = is_add;
14005 mp->is_ipv6 = ipv6_set;
14012 static void vl_api_vxlan_gpe_tunnel_details_t_handler
14013 (vl_api_vxlan_gpe_tunnel_details_t * mp)
14015 vat_main_t *vam = &vat_main;
14016 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
14017 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
14019 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
14020 ntohl (mp->sw_if_index),
14021 format_ip46_address, &local, IP46_TYPE_ANY,
14022 format_ip46_address, &remote, IP46_TYPE_ANY,
14023 ntohl (mp->vni), mp->protocol,
14024 ntohl (mp->mcast_sw_if_index),
14025 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
14029 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
14030 (vl_api_vxlan_gpe_tunnel_details_t * mp)
14032 vat_main_t *vam = &vat_main;
14033 vat_json_node_t *node = NULL;
14034 struct in_addr ip4;
14035 struct in6_addr ip6;
14037 if (VAT_JSON_ARRAY != vam->json_tree.type)
14039 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14040 vat_json_init_array (&vam->json_tree);
14042 node = vat_json_array_add (&vam->json_tree);
14044 vat_json_init_object (node);
14045 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14048 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
14049 vat_json_object_add_ip6 (node, "local", ip6);
14050 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
14051 vat_json_object_add_ip6 (node, "remote", ip6);
14055 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
14056 vat_json_object_add_ip4 (node, "local", ip4);
14057 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
14058 vat_json_object_add_ip4 (node, "remote", ip4);
14060 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
14061 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
14062 vat_json_object_add_uint (node, "mcast_sw_if_index",
14063 ntohl (mp->mcast_sw_if_index));
14064 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
14065 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
14066 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
14070 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
14072 unformat_input_t *i = vam->input;
14073 vl_api_vxlan_gpe_tunnel_dump_t *mp;
14074 vl_api_control_ping_t *mp_ping;
14076 u8 sw_if_index_set = 0;
14079 /* Parse args required to build the message */
14080 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14082 if (unformat (i, "sw_if_index %d", &sw_if_index))
14083 sw_if_index_set = 1;
14088 if (sw_if_index_set == 0)
14093 if (!vam->json_output)
14095 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
14096 "sw_if_index", "local", "remote", "vni",
14097 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
14100 /* Get list of vxlan-tunnel interfaces */
14101 M (VXLAN_GPE_TUNNEL_DUMP, mp);
14103 mp->sw_if_index = htonl (sw_if_index);
14107 /* Use a control ping for synchronization */
14108 MPING (CONTROL_PING, mp_ping);
14115 static void vl_api_l2_fib_table_details_t_handler
14116 (vl_api_l2_fib_table_details_t * mp)
14118 vat_main_t *vam = &vat_main;
14120 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
14122 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
14123 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
14127 static void vl_api_l2_fib_table_details_t_handler_json
14128 (vl_api_l2_fib_table_details_t * mp)
14130 vat_main_t *vam = &vat_main;
14131 vat_json_node_t *node = NULL;
14133 if (VAT_JSON_ARRAY != vam->json_tree.type)
14135 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14136 vat_json_init_array (&vam->json_tree);
14138 node = vat_json_array_add (&vam->json_tree);
14140 vat_json_init_object (node);
14141 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
14142 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
14143 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14144 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
14145 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
14146 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
14150 api_l2_fib_table_dump (vat_main_t * vam)
14152 unformat_input_t *i = vam->input;
14153 vl_api_l2_fib_table_dump_t *mp;
14154 vl_api_control_ping_t *mp_ping;
14159 /* Parse args required to build the message */
14160 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14162 if (unformat (i, "bd_id %d", &bd_id))
14168 if (bd_id_set == 0)
14170 errmsg ("missing bridge domain");
14174 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
14176 /* Get list of l2 fib entries */
14177 M (L2_FIB_TABLE_DUMP, mp);
14179 mp->bd_id = ntohl (bd_id);
14182 /* Use a control ping for synchronization */
14183 MPING (CONTROL_PING, mp_ping);
14192 api_interface_name_renumber (vat_main_t * vam)
14194 unformat_input_t *line_input = vam->input;
14195 vl_api_interface_name_renumber_t *mp;
14196 u32 sw_if_index = ~0;
14197 u32 new_show_dev_instance = ~0;
14200 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14202 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
14205 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14207 else if (unformat (line_input, "new_show_dev_instance %d",
14208 &new_show_dev_instance))
14214 if (sw_if_index == ~0)
14216 errmsg ("missing interface name or sw_if_index");
14220 if (new_show_dev_instance == ~0)
14222 errmsg ("missing new_show_dev_instance");
14226 M (INTERFACE_NAME_RENUMBER, mp);
14228 mp->sw_if_index = ntohl (sw_if_index);
14229 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
14237 api_ip_probe_neighbor (vat_main_t * vam)
14239 unformat_input_t *i = vam->input;
14240 vl_api_ip_probe_neighbor_t *mp;
14241 vl_api_address_t dst_adr;
14247 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14249 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14251 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14253 else if (unformat (i, "address %U", unformat_vl_api_address, dst_adr))
14261 errmsg ("missing interface");
14267 errmsg ("missing addresses");
14271 M (IP_PROBE_NEIGHBOR, mp);
14273 mp->sw_if_index = ntohl (sw_if_index);
14274 clib_memcpy (&mp->dst, &dst_adr, sizeof (dst_adr));
14282 api_ip_scan_neighbor_enable_disable (vat_main_t * vam)
14284 unformat_input_t *i = vam->input;
14285 vl_api_ip_scan_neighbor_enable_disable_t *mp;
14286 u8 mode = IP_SCAN_V46_NEIGHBORS;
14287 u32 interval = 0, time = 0, update = 0, delay = 0, stale = 0;
14290 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14292 if (unformat (i, "ip4"))
14293 mode = IP_SCAN_V4_NEIGHBORS;
14294 else if (unformat (i, "ip6"))
14295 mode = IP_SCAN_V6_NEIGHBORS;
14296 if (unformat (i, "both"))
14297 mode = IP_SCAN_V46_NEIGHBORS;
14298 else if (unformat (i, "disable"))
14299 mode = IP_SCAN_DISABLED;
14300 else if (unformat (i, "interval %d", &interval))
14302 else if (unformat (i, "max-time %d", &time))
14304 else if (unformat (i, "max-update %d", &update))
14306 else if (unformat (i, "delay %d", &delay))
14308 else if (unformat (i, "stale %d", &stale))
14314 if (interval > 255)
14316 errmsg ("interval cannot exceed 255 minutes.");
14321 errmsg ("max-time cannot exceed 255 usec.");
14326 errmsg ("max-update cannot exceed 255.");
14331 errmsg ("delay cannot exceed 255 msec.");
14336 errmsg ("stale cannot exceed 255 minutes.");
14340 M (IP_SCAN_NEIGHBOR_ENABLE_DISABLE, mp);
14342 mp->scan_interval = interval;
14343 mp->max_proc_time = time;
14344 mp->max_update = update;
14345 mp->scan_int_delay = delay;
14346 mp->stale_threshold = stale;
14354 api_want_ip4_arp_events (vat_main_t * vam)
14356 unformat_input_t *line_input = vam->input;
14357 vl_api_want_ip4_arp_events_t *mp;
14358 ip4_address_t address;
14359 int address_set = 0;
14360 u32 enable_disable = 1;
14363 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14365 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
14367 else if (unformat (line_input, "del"))
14368 enable_disable = 0;
14373 if (address_set == 0)
14375 errmsg ("missing addresses");
14379 M (WANT_IP4_ARP_EVENTS, mp);
14380 mp->enable_disable = enable_disable;
14381 mp->pid = htonl (getpid ());
14382 clib_memcpy (mp->ip, &address, sizeof (address));
14390 api_want_ip6_nd_events (vat_main_t * vam)
14392 unformat_input_t *line_input = vam->input;
14393 vl_api_want_ip6_nd_events_t *mp;
14394 vl_api_ip6_address_t address;
14395 int address_set = 0;
14396 u32 enable_disable = 1;
14399 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14402 (line_input, "address %U", unformat_vl_api_ip6_address, &address))
14404 else if (unformat (line_input, "del"))
14405 enable_disable = 0;
14410 if (address_set == 0)
14412 errmsg ("missing addresses");
14416 M (WANT_IP6_ND_EVENTS, mp);
14417 mp->enable_disable = enable_disable;
14418 mp->pid = htonl (getpid ());
14419 clib_memcpy (&mp->ip, &address, sizeof (address));
14427 api_want_l2_macs_events (vat_main_t * vam)
14429 unformat_input_t *line_input = vam->input;
14430 vl_api_want_l2_macs_events_t *mp;
14431 u8 enable_disable = 1;
14432 u32 scan_delay = 0;
14433 u32 max_macs_in_event = 0;
14434 u32 learn_limit = 0;
14437 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14439 if (unformat (line_input, "learn-limit %d", &learn_limit))
14441 else if (unformat (line_input, "scan-delay %d", &scan_delay))
14443 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
14445 else if (unformat (line_input, "disable"))
14446 enable_disable = 0;
14451 M (WANT_L2_MACS_EVENTS, mp);
14452 mp->enable_disable = enable_disable;
14453 mp->pid = htonl (getpid ());
14454 mp->learn_limit = htonl (learn_limit);
14455 mp->scan_delay = (u8) scan_delay;
14456 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
14463 api_input_acl_set_interface (vat_main_t * vam)
14465 unformat_input_t *i = vam->input;
14466 vl_api_input_acl_set_interface_t *mp;
14468 int sw_if_index_set;
14469 u32 ip4_table_index = ~0;
14470 u32 ip6_table_index = ~0;
14471 u32 l2_table_index = ~0;
14475 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14477 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14478 sw_if_index_set = 1;
14479 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14480 sw_if_index_set = 1;
14481 else if (unformat (i, "del"))
14483 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14485 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14487 else if (unformat (i, "l2-table %d", &l2_table_index))
14491 clib_warning ("parse error '%U'", format_unformat_error, i);
14496 if (sw_if_index_set == 0)
14498 errmsg ("missing interface name or sw_if_index");
14502 M (INPUT_ACL_SET_INTERFACE, mp);
14504 mp->sw_if_index = ntohl (sw_if_index);
14505 mp->ip4_table_index = ntohl (ip4_table_index);
14506 mp->ip6_table_index = ntohl (ip6_table_index);
14507 mp->l2_table_index = ntohl (l2_table_index);
14508 mp->is_add = is_add;
14516 api_output_acl_set_interface (vat_main_t * vam)
14518 unformat_input_t *i = vam->input;
14519 vl_api_output_acl_set_interface_t *mp;
14521 int sw_if_index_set;
14522 u32 ip4_table_index = ~0;
14523 u32 ip6_table_index = ~0;
14524 u32 l2_table_index = ~0;
14528 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14530 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14531 sw_if_index_set = 1;
14532 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14533 sw_if_index_set = 1;
14534 else if (unformat (i, "del"))
14536 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14538 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14540 else if (unformat (i, "l2-table %d", &l2_table_index))
14544 clib_warning ("parse error '%U'", format_unformat_error, i);
14549 if (sw_if_index_set == 0)
14551 errmsg ("missing interface name or sw_if_index");
14555 M (OUTPUT_ACL_SET_INTERFACE, mp);
14557 mp->sw_if_index = ntohl (sw_if_index);
14558 mp->ip4_table_index = ntohl (ip4_table_index);
14559 mp->ip6_table_index = ntohl (ip6_table_index);
14560 mp->l2_table_index = ntohl (l2_table_index);
14561 mp->is_add = is_add;
14569 api_ip_address_dump (vat_main_t * vam)
14571 unformat_input_t *i = vam->input;
14572 vl_api_ip_address_dump_t *mp;
14573 vl_api_control_ping_t *mp_ping;
14574 u32 sw_if_index = ~0;
14575 u8 sw_if_index_set = 0;
14580 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14582 if (unformat (i, "sw_if_index %d", &sw_if_index))
14583 sw_if_index_set = 1;
14585 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14586 sw_if_index_set = 1;
14587 else if (unformat (i, "ipv4"))
14589 else if (unformat (i, "ipv6"))
14595 if (ipv4_set && ipv6_set)
14597 errmsg ("ipv4 and ipv6 flags cannot be both set");
14601 if ((!ipv4_set) && (!ipv6_set))
14603 errmsg ("no ipv4 nor ipv6 flag set");
14607 if (sw_if_index_set == 0)
14609 errmsg ("missing interface name or sw_if_index");
14613 vam->current_sw_if_index = sw_if_index;
14614 vam->is_ipv6 = ipv6_set;
14616 M (IP_ADDRESS_DUMP, mp);
14617 mp->sw_if_index = ntohl (sw_if_index);
14618 mp->is_ipv6 = ipv6_set;
14621 /* Use a control ping for synchronization */
14622 MPING (CONTROL_PING, mp_ping);
14630 api_ip_dump (vat_main_t * vam)
14632 vl_api_ip_dump_t *mp;
14633 vl_api_control_ping_t *mp_ping;
14634 unformat_input_t *in = vam->input;
14641 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
14643 if (unformat (in, "ipv4"))
14645 else if (unformat (in, "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 is_ipv6 = ipv6_set;
14664 vam->is_ipv6 = is_ipv6;
14666 /* free old data */
14667 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
14669 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
14671 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
14674 mp->is_ipv6 = ipv6_set;
14677 /* Use a control ping for synchronization */
14678 MPING (CONTROL_PING, mp_ping);
14686 api_ipsec_spd_add_del (vat_main_t * vam)
14688 unformat_input_t *i = vam->input;
14689 vl_api_ipsec_spd_add_del_t *mp;
14694 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14696 if (unformat (i, "spd_id %d", &spd_id))
14698 else if (unformat (i, "del"))
14702 clib_warning ("parse error '%U'", format_unformat_error, i);
14708 errmsg ("spd_id must be set");
14712 M (IPSEC_SPD_ADD_DEL, mp);
14714 mp->spd_id = ntohl (spd_id);
14715 mp->is_add = is_add;
14723 api_ipsec_interface_add_del_spd (vat_main_t * vam)
14725 unformat_input_t *i = vam->input;
14726 vl_api_ipsec_interface_add_del_spd_t *mp;
14728 u8 sw_if_index_set = 0;
14729 u32 spd_id = (u32) ~ 0;
14733 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14735 if (unformat (i, "del"))
14737 else if (unformat (i, "spd_id %d", &spd_id))
14740 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14741 sw_if_index_set = 1;
14742 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14743 sw_if_index_set = 1;
14746 clib_warning ("parse error '%U'", format_unformat_error, i);
14752 if (spd_id == (u32) ~ 0)
14754 errmsg ("spd_id must be set");
14758 if (sw_if_index_set == 0)
14760 errmsg ("missing interface name or sw_if_index");
14764 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
14766 mp->spd_id = ntohl (spd_id);
14767 mp->sw_if_index = ntohl (sw_if_index);
14768 mp->is_add = is_add;
14776 api_ipsec_spd_entry_add_del (vat_main_t * vam)
14778 unformat_input_t *i = vam->input;
14779 vl_api_ipsec_spd_entry_add_del_t *mp;
14780 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
14781 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
14783 u32 rport_start = 0, rport_stop = (u32) ~ 0;
14784 u32 lport_start = 0, lport_stop = (u32) ~ 0;
14785 vl_api_address_t laddr_start = { }, laddr_stop =
14794 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14796 if (unformat (i, "del"))
14798 if (unformat (i, "outbound"))
14800 if (unformat (i, "inbound"))
14802 else if (unformat (i, "spd_id %d", &spd_id))
14804 else if (unformat (i, "sa_id %d", &sa_id))
14806 else if (unformat (i, "priority %d", &priority))
14808 else if (unformat (i, "protocol %d", &protocol))
14810 else if (unformat (i, "lport_start %d", &lport_start))
14812 else if (unformat (i, "lport_stop %d", &lport_stop))
14814 else if (unformat (i, "rport_start %d", &rport_start))
14816 else if (unformat (i, "rport_stop %d", &rport_stop))
14818 else if (unformat (i, "laddr_start %U",
14819 unformat_vl_api_address, &laddr_start))
14821 else if (unformat (i, "laddr_stop %U", unformat_vl_api_address,
14824 else if (unformat (i, "raddr_start %U", unformat_vl_api_address,
14827 else if (unformat (i, "raddr_stop %U", unformat_vl_api_address,
14831 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
14833 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
14835 clib_warning ("unsupported action: 'resolve'");
14841 clib_warning ("parse error '%U'", format_unformat_error, i);
14847 M (IPSEC_SPD_ENTRY_ADD_DEL, mp);
14849 mp->is_add = is_add;
14851 mp->entry.spd_id = ntohl (spd_id);
14852 mp->entry.priority = ntohl (priority);
14853 mp->entry.is_outbound = is_outbound;
14855 clib_memcpy (&mp->entry.remote_address_start, &raddr_start,
14856 sizeof (vl_api_address_t));
14857 clib_memcpy (&mp->entry.remote_address_stop, &raddr_stop,
14858 sizeof (vl_api_address_t));
14859 clib_memcpy (&mp->entry.local_address_start, &laddr_start,
14860 sizeof (vl_api_address_t));
14861 clib_memcpy (&mp->entry.local_address_stop, &laddr_stop,
14862 sizeof (vl_api_address_t));
14864 mp->entry.protocol = (u8) protocol;
14865 mp->entry.local_port_start = ntohs ((u16) lport_start);
14866 mp->entry.local_port_stop = ntohs ((u16) lport_stop);
14867 mp->entry.remote_port_start = ntohs ((u16) rport_start);
14868 mp->entry.remote_port_stop = ntohs ((u16) rport_stop);
14869 mp->entry.policy = (u8) policy;
14870 mp->entry.sa_id = ntohl (sa_id);
14878 api_ipsec_sad_entry_add_del (vat_main_t * vam)
14880 unformat_input_t *i = vam->input;
14881 vl_api_ipsec_sad_entry_add_del_t *mp;
14882 u32 sad_id = 0, spi = 0;
14883 u8 *ck = 0, *ik = 0;
14886 vl_api_ipsec_crypto_alg_t crypto_alg = IPSEC_API_CRYPTO_ALG_NONE;
14887 vl_api_ipsec_integ_alg_t integ_alg = IPSEC_API_INTEG_ALG_NONE;
14888 vl_api_ipsec_sad_flags_t flags = IPSEC_API_SAD_FLAG_NONE;
14889 vl_api_ipsec_proto_t protocol = IPSEC_API_PROTO_AH;
14890 vl_api_address_t tun_src, tun_dst;
14893 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14895 if (unformat (i, "del"))
14897 else if (unformat (i, "sad_id %d", &sad_id))
14899 else if (unformat (i, "spi %d", &spi))
14901 else if (unformat (i, "esp"))
14902 protocol = IPSEC_API_PROTO_ESP;
14904 if (unformat (i, "tunnel_src %U", unformat_vl_api_address, &tun_src))
14906 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
14907 if (ADDRESS_IP6 == tun_src.af)
14908 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
14911 if (unformat (i, "tunnel_dst %U", unformat_vl_api_address, &tun_dst))
14913 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
14914 if (ADDRESS_IP6 == tun_src.af)
14915 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
14918 if (unformat (i, "crypto_alg %U",
14919 unformat_ipsec_api_crypto_alg, &crypto_alg))
14921 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14923 else if (unformat (i, "integ_alg %U",
14924 unformat_ipsec_api_integ_alg, &integ_alg))
14926 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14930 clib_warning ("parse error '%U'", format_unformat_error, i);
14936 M (IPSEC_SAD_ENTRY_ADD_DEL, mp);
14938 mp->is_add = is_add;
14939 mp->entry.sad_id = ntohl (sad_id);
14940 mp->entry.protocol = protocol;
14941 mp->entry.spi = ntohl (spi);
14942 mp->entry.flags = flags;
14944 mp->entry.crypto_algorithm = crypto_alg;
14945 mp->entry.integrity_algorithm = integ_alg;
14946 mp->entry.crypto_key.length = vec_len (ck);
14947 mp->entry.integrity_key.length = vec_len (ik);
14949 if (mp->entry.crypto_key.length > sizeof (mp->entry.crypto_key.data))
14950 mp->entry.crypto_key.length = sizeof (mp->entry.crypto_key.data);
14952 if (mp->entry.integrity_key.length > sizeof (mp->entry.integrity_key.data))
14953 mp->entry.integrity_key.length = sizeof (mp->entry.integrity_key.data);
14956 clib_memcpy (mp->entry.crypto_key.data, ck, mp->entry.crypto_key.length);
14958 clib_memcpy (mp->entry.integrity_key.data, ik,
14959 mp->entry.integrity_key.length);
14961 if (flags & IPSEC_API_SAD_FLAG_IS_TUNNEL)
14963 clib_memcpy (&mp->entry.tunnel_src, &tun_src,
14964 sizeof (mp->entry.tunnel_src));
14965 clib_memcpy (&mp->entry.tunnel_dst, &tun_dst,
14966 sizeof (mp->entry.tunnel_dst));
14975 api_ipsec_sa_set_key (vat_main_t * vam)
14977 unformat_input_t *i = vam->input;
14978 vl_api_ipsec_sa_set_key_t *mp;
14980 u8 *ck = 0, *ik = 0;
14983 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14985 if (unformat (i, "sa_id %d", &sa_id))
14987 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14989 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14993 clib_warning ("parse error '%U'", format_unformat_error, i);
14998 M (IPSEC_SA_SET_KEY, mp);
15000 mp->sa_id = ntohl (sa_id);
15001 mp->crypto_key.length = vec_len (ck);
15002 mp->integrity_key.length = vec_len (ik);
15004 if (mp->crypto_key.length > sizeof (mp->crypto_key.data))
15005 mp->crypto_key.length = sizeof (mp->crypto_key.data);
15007 if (mp->integrity_key.length > sizeof (mp->integrity_key.data))
15008 mp->integrity_key.length = sizeof (mp->integrity_key.data);
15011 clib_memcpy (mp->crypto_key.data, ck, mp->crypto_key.length);
15013 clib_memcpy (mp->integrity_key.data, ik, mp->integrity_key.length);
15021 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
15023 unformat_input_t *i = vam->input;
15024 vl_api_ipsec_tunnel_if_add_del_t *mp;
15025 u32 local_spi = 0, remote_spi = 0;
15026 u32 crypto_alg = 0, integ_alg = 0;
15027 u8 *lck = NULL, *rck = NULL;
15028 u8 *lik = NULL, *rik = NULL;
15029 vl_api_address_t local_ip = { 0 };
15030 vl_api_address_t remote_ip = { 0 };
15034 u8 anti_replay = 0;
15040 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15042 if (unformat (i, "del"))
15044 else if (unformat (i, "esn"))
15046 else if (unformat (i, "anti-replay"))
15048 else if (unformat (i, "count %d", &count))
15050 else if (unformat (i, "local_spi %d", &local_spi))
15052 else if (unformat (i, "remote_spi %d", &remote_spi))
15055 if (unformat (i, "local_ip %U", unformat_vl_api_address, &local_ip))
15058 if (unformat (i, "remote_ip %U", unformat_vl_api_address, &remote_ip))
15060 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
15063 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
15065 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
15067 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
15071 (i, "crypto_alg %U", unformat_ipsec_api_crypto_alg, &crypto_alg))
15073 if (crypto_alg >= IPSEC_CRYPTO_N_ALG)
15075 errmsg ("unsupported crypto-alg: '%U'\n",
15076 format_ipsec_crypto_alg, crypto_alg);
15082 (i, "integ_alg %U", unformat_ipsec_api_integ_alg, &integ_alg))
15084 if (integ_alg >= IPSEC_INTEG_N_ALG)
15086 errmsg ("unsupported integ-alg: '%U'\n",
15087 format_ipsec_integ_alg, integ_alg);
15091 else if (unformat (i, "instance %u", &instance))
15095 errmsg ("parse error '%U'\n", format_unformat_error, i);
15102 /* Turn on async mode */
15103 vam->async_mode = 1;
15104 vam->async_errors = 0;
15105 before = vat_time_now (vam);
15108 for (jj = 0; jj < count; jj++)
15110 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
15112 mp->is_add = is_add;
15114 mp->anti_replay = anti_replay;
15117 increment_vl_address (&remote_ip);
15119 clib_memcpy (&mp->local_ip, &local_ip, sizeof (local_ip));
15120 clib_memcpy (&mp->remote_ip, &remote_ip, sizeof (remote_ip));
15122 mp->local_spi = htonl (local_spi + jj);
15123 mp->remote_spi = htonl (remote_spi + jj);
15124 mp->crypto_alg = (u8) crypto_alg;
15126 mp->local_crypto_key_len = 0;
15129 mp->local_crypto_key_len = vec_len (lck);
15130 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
15131 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
15132 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
15135 mp->remote_crypto_key_len = 0;
15138 mp->remote_crypto_key_len = vec_len (rck);
15139 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
15140 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
15141 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
15144 mp->integ_alg = (u8) integ_alg;
15146 mp->local_integ_key_len = 0;
15149 mp->local_integ_key_len = vec_len (lik);
15150 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
15151 mp->local_integ_key_len = sizeof (mp->local_integ_key);
15152 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
15155 mp->remote_integ_key_len = 0;
15158 mp->remote_integ_key_len = vec_len (rik);
15159 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
15160 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
15161 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
15166 mp->renumber = renumber;
15167 mp->show_instance = ntohl (instance);
15172 /* When testing multiple add/del ops, use a control-ping to sync */
15175 vl_api_control_ping_t *mp_ping;
15179 /* Shut off async mode */
15180 vam->async_mode = 0;
15182 MPING (CONTROL_PING, mp_ping);
15185 timeout = vat_time_now (vam) + 1.0;
15186 while (vat_time_now (vam) < timeout)
15187 if (vam->result_ready == 1)
15192 if (vam->retval == -99)
15193 errmsg ("timeout");
15195 if (vam->async_errors > 0)
15197 errmsg ("%d asynchronous errors", vam->async_errors);
15200 vam->async_errors = 0;
15201 after = vat_time_now (vam);
15203 /* slim chance, but we might have eaten SIGTERM on the first iteration */
15207 print (vam->ofp, "%d tunnels in %.6f secs, %.2f tunnels/sec",
15208 count, after - before, count / (after - before));
15212 /* Wait for a reply... */
15221 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
15223 vat_main_t *vam = &vat_main;
15225 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
15226 "crypto_key %U integ_alg %u integ_key %U flags %x "
15227 "tunnel_src_addr %U tunnel_dst_addr %U "
15228 "salt %u seq_outbound %lu last_seq_inbound %lu "
15229 "replay_window %lu\n",
15230 ntohl (mp->entry.sad_id),
15231 ntohl (mp->sw_if_index),
15232 ntohl (mp->entry.spi),
15233 ntohl (mp->entry.protocol),
15234 ntohl (mp->entry.crypto_algorithm),
15235 format_hex_bytes, mp->entry.crypto_key.data,
15236 mp->entry.crypto_key.length, ntohl (mp->entry.integrity_algorithm),
15237 format_hex_bytes, mp->entry.integrity_key.data,
15238 mp->entry.integrity_key.length, ntohl (mp->entry.flags),
15239 format_vl_api_address, &mp->entry.tunnel_src, format_vl_api_address,
15240 &mp->entry.tunnel_dst, ntohl (mp->salt),
15241 clib_net_to_host_u64 (mp->seq_outbound),
15242 clib_net_to_host_u64 (mp->last_seq_inbound),
15243 clib_net_to_host_u64 (mp->replay_window));
15246 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
15247 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
15249 static void vl_api_ipsec_sa_details_t_handler_json
15250 (vl_api_ipsec_sa_details_t * mp)
15252 vat_main_t *vam = &vat_main;
15253 vat_json_node_t *node = NULL;
15254 vl_api_ipsec_sad_flags_t flags;
15256 if (VAT_JSON_ARRAY != vam->json_tree.type)
15258 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15259 vat_json_init_array (&vam->json_tree);
15261 node = vat_json_array_add (&vam->json_tree);
15263 vat_json_init_object (node);
15264 vat_json_object_add_uint (node, "sa_id", ntohl (mp->entry.sad_id));
15265 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
15266 vat_json_object_add_uint (node, "spi", ntohl (mp->entry.spi));
15267 vat_json_object_add_uint (node, "proto", ntohl (mp->entry.protocol));
15268 vat_json_object_add_uint (node, "crypto_alg",
15269 ntohl (mp->entry.crypto_algorithm));
15270 vat_json_object_add_uint (node, "integ_alg",
15271 ntohl (mp->entry.integrity_algorithm));
15272 flags = ntohl (mp->entry.flags);
15273 vat_json_object_add_uint (node, "use_esn",
15274 ! !(flags & IPSEC_API_SAD_FLAG_USE_ESN));
15275 vat_json_object_add_uint (node, "use_anti_replay",
15276 ! !(flags & IPSEC_API_SAD_FLAG_USE_ANTI_REPLAY));
15277 vat_json_object_add_uint (node, "is_tunnel",
15278 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL));
15279 vat_json_object_add_uint (node, "is_tunnel_ip6",
15280 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL_V6));
15281 vat_json_object_add_uint (node, "udp_encap",
15282 ! !(flags & IPSEC_API_SAD_FLAG_UDP_ENCAP));
15283 vat_json_object_add_bytes (node, "crypto_key", mp->entry.crypto_key.data,
15284 mp->entry.crypto_key.length);
15285 vat_json_object_add_bytes (node, "integ_key", mp->entry.integrity_key.data,
15286 mp->entry.integrity_key.length);
15287 vat_json_object_add_address (node, "src", &mp->entry.tunnel_src);
15288 vat_json_object_add_address (node, "dst", &mp->entry.tunnel_dst);
15289 vat_json_object_add_uint (node, "replay_window",
15290 clib_net_to_host_u64 (mp->replay_window));
15294 api_ipsec_sa_dump (vat_main_t * vam)
15296 unformat_input_t *i = vam->input;
15297 vl_api_ipsec_sa_dump_t *mp;
15298 vl_api_control_ping_t *mp_ping;
15302 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15304 if (unformat (i, "sa_id %d", &sa_id))
15308 clib_warning ("parse error '%U'", format_unformat_error, i);
15313 M (IPSEC_SA_DUMP, mp);
15315 mp->sa_id = ntohl (sa_id);
15319 /* Use a control ping for synchronization */
15320 M (CONTROL_PING, mp_ping);
15328 api_ipsec_tunnel_if_set_key (vat_main_t * vam)
15330 unformat_input_t *i = vam->input;
15331 vl_api_ipsec_tunnel_if_set_key_t *mp;
15332 u32 sw_if_index = ~0;
15333 u8 key_type = IPSEC_IF_SET_KEY_TYPE_NONE;
15338 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15340 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15344 (i, "local crypto %U", unformat_ipsec_api_crypto_alg, &alg))
15345 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_CRYPTO;
15348 (i, "remote crypto %U", unformat_ipsec_api_crypto_alg, &alg))
15349 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_CRYPTO;
15352 (i, "local integ %U", unformat_ipsec_api_integ_alg, &alg))
15353 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_INTEG;
15356 (i, "remote integ %U", unformat_ipsec_api_integ_alg, &alg))
15357 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_INTEG;
15358 else if (unformat (i, "%U", unformat_hex_string, &key))
15362 clib_warning ("parse error '%U'", format_unformat_error, i);
15367 if (sw_if_index == ~0)
15369 errmsg ("interface must be specified");
15373 if (key_type == IPSEC_IF_SET_KEY_TYPE_NONE)
15375 errmsg ("key type must be specified");
15381 errmsg ("algorithm must be specified");
15385 if (vec_len (key) == 0)
15387 errmsg ("key must be specified");
15391 M (IPSEC_TUNNEL_IF_SET_KEY, mp);
15393 mp->sw_if_index = htonl (sw_if_index);
15395 mp->key_type = key_type;
15396 mp->key_len = vec_len (key);
15397 clib_memcpy (mp->key, key, vec_len (key));
15406 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
15408 unformat_input_t *i = vam->input;
15409 vl_api_ipsec_tunnel_if_set_sa_t *mp;
15410 u32 sw_if_index = ~0;
15412 u8 is_outbound = (u8) ~ 0;
15415 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15417 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15419 else if (unformat (i, "sa_id %d", &sa_id))
15421 else if (unformat (i, "outbound"))
15423 else if (unformat (i, "inbound"))
15427 clib_warning ("parse error '%U'", format_unformat_error, i);
15432 if (sw_if_index == ~0)
15434 errmsg ("interface must be specified");
15440 errmsg ("SA ID must be specified");
15444 M (IPSEC_TUNNEL_IF_SET_SA, mp);
15446 mp->sw_if_index = htonl (sw_if_index);
15447 mp->sa_id = htonl (sa_id);
15448 mp->is_outbound = is_outbound;
15457 api_get_first_msg_id (vat_main_t * vam)
15459 vl_api_get_first_msg_id_t *mp;
15460 unformat_input_t *i = vam->input;
15465 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15467 if (unformat (i, "client %s", &name))
15475 errmsg ("missing client name");
15478 vec_add1 (name, 0);
15480 if (vec_len (name) > 63)
15482 errmsg ("client name too long");
15486 M (GET_FIRST_MSG_ID, mp);
15487 clib_memcpy (mp->name, name, vec_len (name));
15494 api_cop_interface_enable_disable (vat_main_t * vam)
15496 unformat_input_t *line_input = vam->input;
15497 vl_api_cop_interface_enable_disable_t *mp;
15498 u32 sw_if_index = ~0;
15499 u8 enable_disable = 1;
15502 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15504 if (unformat (line_input, "disable"))
15505 enable_disable = 0;
15506 if (unformat (line_input, "enable"))
15507 enable_disable = 1;
15508 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
15509 vam, &sw_if_index))
15511 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
15517 if (sw_if_index == ~0)
15519 errmsg ("missing interface name or sw_if_index");
15523 /* Construct the API message */
15524 M (COP_INTERFACE_ENABLE_DISABLE, mp);
15525 mp->sw_if_index = ntohl (sw_if_index);
15526 mp->enable_disable = enable_disable;
15530 /* Wait for the reply */
15536 api_cop_whitelist_enable_disable (vat_main_t * vam)
15538 unformat_input_t *line_input = vam->input;
15539 vl_api_cop_whitelist_enable_disable_t *mp;
15540 u32 sw_if_index = ~0;
15541 u8 ip4 = 0, ip6 = 0, default_cop = 0;
15545 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15547 if (unformat (line_input, "ip4"))
15549 else if (unformat (line_input, "ip6"))
15551 else if (unformat (line_input, "default"))
15553 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
15554 vam, &sw_if_index))
15556 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
15558 else if (unformat (line_input, "fib-id %d", &fib_id))
15564 if (sw_if_index == ~0)
15566 errmsg ("missing interface name or sw_if_index");
15570 /* Construct the API message */
15571 M (COP_WHITELIST_ENABLE_DISABLE, mp);
15572 mp->sw_if_index = ntohl (sw_if_index);
15573 mp->fib_id = ntohl (fib_id);
15576 mp->default_cop = default_cop;
15580 /* Wait for the reply */
15586 api_get_node_graph (vat_main_t * vam)
15588 vl_api_get_node_graph_t *mp;
15591 M (GET_NODE_GRAPH, mp);
15595 /* Wait for the reply */
15601 /** Used for parsing LISP eids */
15602 typedef CLIB_PACKED(struct{
15603 u8 addr[16]; /**< eid address */
15604 u32 len; /**< prefix length if IP */
15605 u8 type; /**< type of eid */
15610 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
15612 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
15614 clib_memset (a, 0, sizeof (a[0]));
15616 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
15618 a->type = 0; /* ipv4 type */
15620 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
15622 a->type = 1; /* ipv6 type */
15624 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
15626 a->type = 2; /* mac type */
15628 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
15630 a->type = 3; /* NSH type */
15631 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
15632 nsh->spi = clib_host_to_net_u32 (nsh->spi);
15639 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
15648 lisp_eid_size_vat (u8 type)
15665 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
15667 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
15671 api_one_add_del_locator_set (vat_main_t * vam)
15673 unformat_input_t *input = vam->input;
15674 vl_api_one_add_del_locator_set_t *mp;
15676 u8 *locator_set_name = NULL;
15677 u8 locator_set_name_set = 0;
15678 vl_api_local_locator_t locator, *locators = 0;
15679 u32 sw_if_index, priority, weight;
15683 /* Parse args required to build the message */
15684 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15686 if (unformat (input, "del"))
15690 else if (unformat (input, "locator-set %s", &locator_set_name))
15692 locator_set_name_set = 1;
15694 else if (unformat (input, "sw_if_index %u p %u w %u",
15695 &sw_if_index, &priority, &weight))
15697 locator.sw_if_index = htonl (sw_if_index);
15698 locator.priority = priority;
15699 locator.weight = weight;
15700 vec_add1 (locators, locator);
15704 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
15705 &sw_if_index, &priority, &weight))
15707 locator.sw_if_index = htonl (sw_if_index);
15708 locator.priority = priority;
15709 locator.weight = weight;
15710 vec_add1 (locators, locator);
15716 if (locator_set_name_set == 0)
15718 errmsg ("missing locator-set name");
15719 vec_free (locators);
15723 if (vec_len (locator_set_name) > 64)
15725 errmsg ("locator-set name too long");
15726 vec_free (locator_set_name);
15727 vec_free (locators);
15730 vec_add1 (locator_set_name, 0);
15732 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
15734 /* Construct the API message */
15735 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
15737 mp->is_add = is_add;
15738 clib_memcpy (mp->locator_set_name, locator_set_name,
15739 vec_len (locator_set_name));
15740 vec_free (locator_set_name);
15742 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
15744 clib_memcpy (mp->locators, locators, data_len);
15745 vec_free (locators);
15750 /* Wait for a reply... */
15755 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
15758 api_one_add_del_locator (vat_main_t * vam)
15760 unformat_input_t *input = vam->input;
15761 vl_api_one_add_del_locator_t *mp;
15762 u32 tmp_if_index = ~0;
15763 u32 sw_if_index = ~0;
15764 u8 sw_if_index_set = 0;
15765 u8 sw_if_index_if_name_set = 0;
15767 u8 priority_set = 0;
15771 u8 *locator_set_name = NULL;
15772 u8 locator_set_name_set = 0;
15775 /* Parse args required to build the message */
15776 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15778 if (unformat (input, "del"))
15782 else if (unformat (input, "locator-set %s", &locator_set_name))
15784 locator_set_name_set = 1;
15786 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
15789 sw_if_index_if_name_set = 1;
15790 sw_if_index = tmp_if_index;
15792 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
15794 sw_if_index_set = 1;
15795 sw_if_index = tmp_if_index;
15797 else if (unformat (input, "p %d", &priority))
15801 else if (unformat (input, "w %d", &weight))
15809 if (locator_set_name_set == 0)
15811 errmsg ("missing locator-set name");
15815 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
15817 errmsg ("missing sw_if_index");
15818 vec_free (locator_set_name);
15822 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
15824 errmsg ("cannot use both params interface name and sw_if_index");
15825 vec_free (locator_set_name);
15829 if (priority_set == 0)
15831 errmsg ("missing locator-set priority");
15832 vec_free (locator_set_name);
15836 if (weight_set == 0)
15838 errmsg ("missing locator-set weight");
15839 vec_free (locator_set_name);
15843 if (vec_len (locator_set_name) > 64)
15845 errmsg ("locator-set name too long");
15846 vec_free (locator_set_name);
15849 vec_add1 (locator_set_name, 0);
15851 /* Construct the API message */
15852 M (ONE_ADD_DEL_LOCATOR, mp);
15854 mp->is_add = is_add;
15855 mp->sw_if_index = ntohl (sw_if_index);
15856 mp->priority = priority;
15857 mp->weight = weight;
15858 clib_memcpy (mp->locator_set_name, locator_set_name,
15859 vec_len (locator_set_name));
15860 vec_free (locator_set_name);
15865 /* Wait for a reply... */
15870 #define api_lisp_add_del_locator api_one_add_del_locator
15873 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
15875 u32 *key_id = va_arg (*args, u32 *);
15878 if (unformat (input, "%s", &s))
15880 if (!strcmp ((char *) s, "sha1"))
15881 key_id[0] = HMAC_SHA_1_96;
15882 else if (!strcmp ((char *) s, "sha256"))
15883 key_id[0] = HMAC_SHA_256_128;
15886 clib_warning ("invalid key_id: '%s'", s);
15887 key_id[0] = HMAC_NO_KEY;
15898 api_one_add_del_local_eid (vat_main_t * vam)
15900 unformat_input_t *input = vam->input;
15901 vl_api_one_add_del_local_eid_t *mp;
15904 lisp_eid_vat_t _eid, *eid = &_eid;
15905 u8 *locator_set_name = 0;
15906 u8 locator_set_name_set = 0;
15912 /* Parse args required to build the message */
15913 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15915 if (unformat (input, "del"))
15919 else if (unformat (input, "vni %d", &vni))
15923 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
15927 else if (unformat (input, "locator-set %s", &locator_set_name))
15929 locator_set_name_set = 1;
15931 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
15933 else if (unformat (input, "secret-key %_%v%_", &key))
15939 if (locator_set_name_set == 0)
15941 errmsg ("missing locator-set name");
15947 errmsg ("EID address not set!");
15948 vec_free (locator_set_name);
15952 if (key && (0 == key_id))
15954 errmsg ("invalid key_id!");
15958 if (vec_len (key) > 64)
15960 errmsg ("key too long");
15965 if (vec_len (locator_set_name) > 64)
15967 errmsg ("locator-set name too long");
15968 vec_free (locator_set_name);
15971 vec_add1 (locator_set_name, 0);
15973 /* Construct the API message */
15974 M (ONE_ADD_DEL_LOCAL_EID, mp);
15976 mp->is_add = is_add;
15977 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
15978 mp->eid_type = eid->type;
15979 mp->prefix_len = eid->len;
15980 mp->vni = clib_host_to_net_u32 (vni);
15981 mp->key_id = clib_host_to_net_u16 (key_id);
15982 clib_memcpy (mp->locator_set_name, locator_set_name,
15983 vec_len (locator_set_name));
15984 clib_memcpy (mp->key, key, vec_len (key));
15986 vec_free (locator_set_name);
15992 /* Wait for a reply... */
15997 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
16000 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
16002 u32 dp_table = 0, vni = 0;;
16003 unformat_input_t *input = vam->input;
16004 vl_api_gpe_add_del_fwd_entry_t *mp;
16006 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
16007 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
16008 u8 rmt_eid_set = 0, lcl_eid_set = 0;
16009 u32 action = ~0, w;
16010 ip4_address_t rmt_rloc4, lcl_rloc4;
16011 ip6_address_t rmt_rloc6, lcl_rloc6;
16012 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
16015 clib_memset (&rloc, 0, sizeof (rloc));
16017 /* Parse args required to build the message */
16018 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16020 if (unformat (input, "del"))
16022 else if (unformat (input, "add"))
16024 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
16028 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
16032 else if (unformat (input, "vrf %d", &dp_table))
16034 else if (unformat (input, "bd %d", &dp_table))
16036 else if (unformat (input, "vni %d", &vni))
16038 else if (unformat (input, "w %d", &w))
16042 errmsg ("No RLOC configured for setting priority/weight!");
16045 curr_rloc->weight = w;
16047 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
16048 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
16052 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
16054 vec_add1 (lcl_locs, rloc);
16056 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
16057 vec_add1 (rmt_locs, rloc);
16058 /* weight saved in rmt loc */
16059 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
16061 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
16062 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
16065 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
16067 vec_add1 (lcl_locs, rloc);
16069 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
16070 vec_add1 (rmt_locs, rloc);
16071 /* weight saved in rmt loc */
16072 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
16074 else if (unformat (input, "action %d", &action))
16080 clib_warning ("parse error '%U'", format_unformat_error, input);
16087 errmsg ("remote eid addresses not set");
16091 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
16093 errmsg ("eid types don't match");
16097 if (0 == rmt_locs && (u32) ~ 0 == action)
16099 errmsg ("action not set for negative mapping");
16103 /* Construct the API message */
16104 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
16105 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
16107 mp->is_add = is_add;
16108 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
16109 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
16110 mp->eid_type = rmt_eid->type;
16111 mp->dp_table = clib_host_to_net_u32 (dp_table);
16112 mp->vni = clib_host_to_net_u32 (vni);
16113 mp->rmt_len = rmt_eid->len;
16114 mp->lcl_len = lcl_eid->len;
16115 mp->action = action;
16117 if (0 != rmt_locs && 0 != lcl_locs)
16119 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
16120 clib_memcpy (mp->locs, lcl_locs,
16121 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
16123 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
16124 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
16125 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
16127 vec_free (lcl_locs);
16128 vec_free (rmt_locs);
16133 /* Wait for a reply... */
16139 api_one_add_del_map_server (vat_main_t * vam)
16141 unformat_input_t *input = vam->input;
16142 vl_api_one_add_del_map_server_t *mp;
16146 ip4_address_t ipv4;
16147 ip6_address_t ipv6;
16150 /* Parse args required to build the message */
16151 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16153 if (unformat (input, "del"))
16157 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
16161 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
16169 if (ipv4_set && ipv6_set)
16171 errmsg ("both eid v4 and v6 addresses set");
16175 if (!ipv4_set && !ipv6_set)
16177 errmsg ("eid addresses not set");
16181 /* Construct the API message */
16182 M (ONE_ADD_DEL_MAP_SERVER, mp);
16184 mp->is_add = is_add;
16188 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
16193 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
16199 /* Wait for a reply... */
16204 #define api_lisp_add_del_map_server api_one_add_del_map_server
16207 api_one_add_del_map_resolver (vat_main_t * vam)
16209 unformat_input_t *input = vam->input;
16210 vl_api_one_add_del_map_resolver_t *mp;
16214 ip4_address_t ipv4;
16215 ip6_address_t ipv6;
16218 /* Parse args required to build the message */
16219 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16221 if (unformat (input, "del"))
16225 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
16229 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
16237 if (ipv4_set && ipv6_set)
16239 errmsg ("both eid v4 and v6 addresses set");
16243 if (!ipv4_set && !ipv6_set)
16245 errmsg ("eid addresses not set");
16249 /* Construct the API message */
16250 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
16252 mp->is_add = is_add;
16256 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
16261 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
16267 /* Wait for a reply... */
16272 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
16275 api_lisp_gpe_enable_disable (vat_main_t * vam)
16277 unformat_input_t *input = vam->input;
16278 vl_api_gpe_enable_disable_t *mp;
16283 /* Parse args required to build the message */
16284 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16286 if (unformat (input, "enable"))
16291 else if (unformat (input, "disable"))
16302 errmsg ("Value not set");
16306 /* Construct the API message */
16307 M (GPE_ENABLE_DISABLE, mp);
16314 /* Wait for a reply... */
16320 api_one_rloc_probe_enable_disable (vat_main_t * vam)
16322 unformat_input_t *input = vam->input;
16323 vl_api_one_rloc_probe_enable_disable_t *mp;
16328 /* Parse args required to build the message */
16329 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16331 if (unformat (input, "enable"))
16336 else if (unformat (input, "disable"))
16344 errmsg ("Value not set");
16348 /* Construct the API message */
16349 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
16351 mp->is_enabled = is_en;
16356 /* Wait for a reply... */
16361 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
16364 api_one_map_register_enable_disable (vat_main_t * vam)
16366 unformat_input_t *input = vam->input;
16367 vl_api_one_map_register_enable_disable_t *mp;
16372 /* Parse args required to build the message */
16373 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16375 if (unformat (input, "enable"))
16380 else if (unformat (input, "disable"))
16388 errmsg ("Value not set");
16392 /* Construct the API message */
16393 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
16395 mp->is_enabled = is_en;
16400 /* Wait for a reply... */
16405 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
16408 api_one_enable_disable (vat_main_t * vam)
16410 unformat_input_t *input = vam->input;
16411 vl_api_one_enable_disable_t *mp;
16416 /* Parse args required to build the message */
16417 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16419 if (unformat (input, "enable"))
16424 else if (unformat (input, "disable"))
16434 errmsg ("Value not set");
16438 /* Construct the API message */
16439 M (ONE_ENABLE_DISABLE, mp);
16446 /* Wait for a reply... */
16451 #define api_lisp_enable_disable api_one_enable_disable
16454 api_one_enable_disable_xtr_mode (vat_main_t * vam)
16456 unformat_input_t *input = vam->input;
16457 vl_api_one_enable_disable_xtr_mode_t *mp;
16462 /* Parse args required to build the message */
16463 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16465 if (unformat (input, "enable"))
16470 else if (unformat (input, "disable"))
16480 errmsg ("Value not set");
16484 /* Construct the API message */
16485 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
16492 /* Wait for a reply... */
16498 api_one_show_xtr_mode (vat_main_t * vam)
16500 vl_api_one_show_xtr_mode_t *mp;
16503 /* Construct the API message */
16504 M (ONE_SHOW_XTR_MODE, mp);
16509 /* Wait for a reply... */
16515 api_one_enable_disable_pitr_mode (vat_main_t * vam)
16517 unformat_input_t *input = vam->input;
16518 vl_api_one_enable_disable_pitr_mode_t *mp;
16523 /* Parse args required to build the message */
16524 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16526 if (unformat (input, "enable"))
16531 else if (unformat (input, "disable"))
16541 errmsg ("Value not set");
16545 /* Construct the API message */
16546 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
16553 /* Wait for a reply... */
16559 api_one_show_pitr_mode (vat_main_t * vam)
16561 vl_api_one_show_pitr_mode_t *mp;
16564 /* Construct the API message */
16565 M (ONE_SHOW_PITR_MODE, mp);
16570 /* Wait for a reply... */
16576 api_one_enable_disable_petr_mode (vat_main_t * vam)
16578 unformat_input_t *input = vam->input;
16579 vl_api_one_enable_disable_petr_mode_t *mp;
16584 /* Parse args required to build the message */
16585 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16587 if (unformat (input, "enable"))
16592 else if (unformat (input, "disable"))
16602 errmsg ("Value not set");
16606 /* Construct the API message */
16607 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
16614 /* Wait for a reply... */
16620 api_one_show_petr_mode (vat_main_t * vam)
16622 vl_api_one_show_petr_mode_t *mp;
16625 /* Construct the API message */
16626 M (ONE_SHOW_PETR_MODE, mp);
16631 /* Wait for a reply... */
16637 api_show_one_map_register_state (vat_main_t * vam)
16639 vl_api_show_one_map_register_state_t *mp;
16642 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
16647 /* wait for reply */
16652 #define api_show_lisp_map_register_state api_show_one_map_register_state
16655 api_show_one_rloc_probe_state (vat_main_t * vam)
16657 vl_api_show_one_rloc_probe_state_t *mp;
16660 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
16665 /* wait for reply */
16670 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
16673 api_one_add_del_ndp_entry (vat_main_t * vam)
16675 vl_api_one_add_del_ndp_entry_t *mp;
16676 unformat_input_t *input = vam->input;
16681 u8 mac[6] = { 0, };
16682 u8 ip6[16] = { 0, };
16686 /* Parse args required to build the message */
16687 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16689 if (unformat (input, "del"))
16691 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
16693 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
16695 else if (unformat (input, "bd %d", &bd))
16699 errmsg ("parse error '%U'", format_unformat_error, input);
16704 if (!bd_set || !ip_set || (!mac_set && is_add))
16706 errmsg ("Missing BD, IP or MAC!");
16710 M (ONE_ADD_DEL_NDP_ENTRY, mp);
16711 mp->is_add = is_add;
16712 clib_memcpy (mp->mac, mac, 6);
16713 mp->bd = clib_host_to_net_u32 (bd);
16714 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
16719 /* wait for reply */
16725 api_one_add_del_l2_arp_entry (vat_main_t * vam)
16727 vl_api_one_add_del_l2_arp_entry_t *mp;
16728 unformat_input_t *input = vam->input;
16733 u8 mac[6] = { 0, };
16734 u32 ip4 = 0, bd = ~0;
16737 /* Parse args required to build the message */
16738 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16740 if (unformat (input, "del"))
16742 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
16744 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
16746 else if (unformat (input, "bd %d", &bd))
16750 errmsg ("parse error '%U'", format_unformat_error, input);
16755 if (!bd_set || !ip_set || (!mac_set && is_add))
16757 errmsg ("Missing BD, IP or MAC!");
16761 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
16762 mp->is_add = is_add;
16763 clib_memcpy (mp->mac, mac, 6);
16764 mp->bd = clib_host_to_net_u32 (bd);
16770 /* wait for reply */
16776 api_one_ndp_bd_get (vat_main_t * vam)
16778 vl_api_one_ndp_bd_get_t *mp;
16781 M (ONE_NDP_BD_GET, mp);
16786 /* wait for reply */
16792 api_one_ndp_entries_get (vat_main_t * vam)
16794 vl_api_one_ndp_entries_get_t *mp;
16795 unformat_input_t *input = vam->input;
16800 /* Parse args required to build the message */
16801 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16803 if (unformat (input, "bd %d", &bd))
16807 errmsg ("parse error '%U'", format_unformat_error, input);
16814 errmsg ("Expected bridge domain!");
16818 M (ONE_NDP_ENTRIES_GET, mp);
16819 mp->bd = clib_host_to_net_u32 (bd);
16824 /* wait for reply */
16830 api_one_l2_arp_bd_get (vat_main_t * vam)
16832 vl_api_one_l2_arp_bd_get_t *mp;
16835 M (ONE_L2_ARP_BD_GET, mp);
16840 /* wait for reply */
16846 api_one_l2_arp_entries_get (vat_main_t * vam)
16848 vl_api_one_l2_arp_entries_get_t *mp;
16849 unformat_input_t *input = vam->input;
16854 /* Parse args required to build the message */
16855 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16857 if (unformat (input, "bd %d", &bd))
16861 errmsg ("parse error '%U'", format_unformat_error, input);
16868 errmsg ("Expected bridge domain!");
16872 M (ONE_L2_ARP_ENTRIES_GET, mp);
16873 mp->bd = clib_host_to_net_u32 (bd);
16878 /* wait for reply */
16884 api_one_stats_enable_disable (vat_main_t * vam)
16886 vl_api_one_stats_enable_disable_t *mp;
16887 unformat_input_t *input = vam->input;
16892 /* Parse args required to build the message */
16893 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16895 if (unformat (input, "enable"))
16900 else if (unformat (input, "disable"))
16910 errmsg ("Value not set");
16914 M (ONE_STATS_ENABLE_DISABLE, mp);
16920 /* wait for reply */
16926 api_show_one_stats_enable_disable (vat_main_t * vam)
16928 vl_api_show_one_stats_enable_disable_t *mp;
16931 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
16936 /* wait for reply */
16942 api_show_one_map_request_mode (vat_main_t * vam)
16944 vl_api_show_one_map_request_mode_t *mp;
16947 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
16952 /* wait for reply */
16957 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
16960 api_one_map_request_mode (vat_main_t * vam)
16962 unformat_input_t *input = vam->input;
16963 vl_api_one_map_request_mode_t *mp;
16967 /* Parse args required to build the message */
16968 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16970 if (unformat (input, "dst-only"))
16972 else if (unformat (input, "src-dst"))
16976 errmsg ("parse error '%U'", format_unformat_error, input);
16981 M (ONE_MAP_REQUEST_MODE, mp);
16988 /* wait for reply */
16993 #define api_lisp_map_request_mode api_one_map_request_mode
16996 * Enable/disable ONE proxy ITR.
16998 * @param vam vpp API test context
16999 * @return return code
17002 api_one_pitr_set_locator_set (vat_main_t * vam)
17004 u8 ls_name_set = 0;
17005 unformat_input_t *input = vam->input;
17006 vl_api_one_pitr_set_locator_set_t *mp;
17011 /* Parse args required to build the message */
17012 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17014 if (unformat (input, "del"))
17016 else if (unformat (input, "locator-set %s", &ls_name))
17020 errmsg ("parse error '%U'", format_unformat_error, input);
17027 errmsg ("locator-set name not set!");
17031 M (ONE_PITR_SET_LOCATOR_SET, mp);
17033 mp->is_add = is_add;
17034 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
17035 vec_free (ls_name);
17040 /* wait for reply */
17045 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
17048 api_one_nsh_set_locator_set (vat_main_t * vam)
17050 u8 ls_name_set = 0;
17051 unformat_input_t *input = vam->input;
17052 vl_api_one_nsh_set_locator_set_t *mp;
17057 /* Parse args required to build the message */
17058 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17060 if (unformat (input, "del"))
17062 else if (unformat (input, "ls %s", &ls_name))
17066 errmsg ("parse error '%U'", format_unformat_error, input);
17071 if (!ls_name_set && is_add)
17073 errmsg ("locator-set name not set!");
17077 M (ONE_NSH_SET_LOCATOR_SET, mp);
17079 mp->is_add = is_add;
17080 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
17081 vec_free (ls_name);
17086 /* wait for reply */
17092 api_show_one_pitr (vat_main_t * vam)
17094 vl_api_show_one_pitr_t *mp;
17097 if (!vam->json_output)
17099 print (vam->ofp, "%=20s", "lisp status:");
17102 M (SHOW_ONE_PITR, mp);
17106 /* Wait for a reply... */
17111 #define api_show_lisp_pitr api_show_one_pitr
17114 api_one_use_petr (vat_main_t * vam)
17116 unformat_input_t *input = vam->input;
17117 vl_api_one_use_petr_t *mp;
17122 clib_memset (&ip, 0, sizeof (ip));
17124 /* Parse args required to build the message */
17125 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17127 if (unformat (input, "disable"))
17130 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
17133 ip_addr_version (&ip) = IP4;
17136 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
17139 ip_addr_version (&ip) = IP6;
17143 errmsg ("parse error '%U'", format_unformat_error, input);
17148 M (ONE_USE_PETR, mp);
17150 mp->is_add = is_add;
17153 mp->is_ip4 = ip_addr_version (&ip) == IP4 ? 1 : 0;
17155 clib_memcpy (mp->address, &ip, 4);
17157 clib_memcpy (mp->address, &ip, 16);
17163 /* wait for reply */
17168 #define api_lisp_use_petr api_one_use_petr
17171 api_show_one_nsh_mapping (vat_main_t * vam)
17173 vl_api_show_one_use_petr_t *mp;
17176 if (!vam->json_output)
17178 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
17181 M (SHOW_ONE_NSH_MAPPING, mp);
17185 /* Wait for a reply... */
17191 api_show_one_use_petr (vat_main_t * vam)
17193 vl_api_show_one_use_petr_t *mp;
17196 if (!vam->json_output)
17198 print (vam->ofp, "%=20s", "Proxy-ETR status:");
17201 M (SHOW_ONE_USE_PETR, mp);
17205 /* Wait for a reply... */
17210 #define api_show_lisp_use_petr api_show_one_use_petr
17213 * Add/delete mapping between vni and vrf
17216 api_one_eid_table_add_del_map (vat_main_t * vam)
17218 unformat_input_t *input = vam->input;
17219 vl_api_one_eid_table_add_del_map_t *mp;
17220 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
17221 u32 vni, vrf, bd_index;
17224 /* Parse args required to build the message */
17225 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17227 if (unformat (input, "del"))
17229 else if (unformat (input, "vrf %d", &vrf))
17231 else if (unformat (input, "bd_index %d", &bd_index))
17233 else if (unformat (input, "vni %d", &vni))
17239 if (!vni_set || (!vrf_set && !bd_index_set))
17241 errmsg ("missing arguments!");
17245 if (vrf_set && bd_index_set)
17247 errmsg ("error: both vrf and bd entered!");
17251 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
17253 mp->is_add = is_add;
17254 mp->vni = htonl (vni);
17255 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
17256 mp->is_l2 = bd_index_set;
17261 /* wait for reply */
17266 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
17269 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
17271 u32 *action = va_arg (*args, u32 *);
17274 if (unformat (input, "%s", &s))
17276 if (!strcmp ((char *) s, "no-action"))
17278 else if (!strcmp ((char *) s, "natively-forward"))
17280 else if (!strcmp ((char *) s, "send-map-request"))
17282 else if (!strcmp ((char *) s, "drop"))
17286 clib_warning ("invalid action: '%s'", s);
17298 * Add/del remote mapping to/from ONE control plane
17300 * @param vam vpp API test context
17301 * @return return code
17304 api_one_add_del_remote_mapping (vat_main_t * vam)
17306 unformat_input_t *input = vam->input;
17307 vl_api_one_add_del_remote_mapping_t *mp;
17309 lisp_eid_vat_t _eid, *eid = &_eid;
17310 lisp_eid_vat_t _seid, *seid = &_seid;
17311 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
17312 u32 action = ~0, p, w, data_len;
17313 ip4_address_t rloc4;
17314 ip6_address_t rloc6;
17315 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
17318 clib_memset (&rloc, 0, sizeof (rloc));
17320 /* Parse args required to build the message */
17321 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17323 if (unformat (input, "del-all"))
17327 else if (unformat (input, "del"))
17331 else if (unformat (input, "add"))
17335 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
17339 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
17343 else if (unformat (input, "vni %d", &vni))
17347 else if (unformat (input, "p %d w %d", &p, &w))
17351 errmsg ("No RLOC configured for setting priority/weight!");
17354 curr_rloc->priority = p;
17355 curr_rloc->weight = w;
17357 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
17360 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
17361 vec_add1 (rlocs, rloc);
17362 curr_rloc = &rlocs[vec_len (rlocs) - 1];
17364 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
17367 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
17368 vec_add1 (rlocs, rloc);
17369 curr_rloc = &rlocs[vec_len (rlocs) - 1];
17371 else if (unformat (input, "action %U",
17372 unformat_negative_mapping_action, &action))
17378 clib_warning ("parse error '%U'", format_unformat_error, input);
17385 errmsg ("missing params!");
17389 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
17391 errmsg ("no action set for negative map-reply!");
17395 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
17397 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
17398 mp->is_add = is_add;
17399 mp->vni = htonl (vni);
17400 mp->action = (u8) action;
17401 mp->is_src_dst = seid_set;
17402 mp->eid_len = eid->len;
17403 mp->seid_len = seid->len;
17404 mp->del_all = del_all;
17405 mp->eid_type = eid->type;
17406 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
17407 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
17409 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
17410 clib_memcpy (mp->rlocs, rlocs, data_len);
17416 /* Wait for a reply... */
17421 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
17424 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
17425 * forwarding entries in data-plane accordingly.
17427 * @param vam vpp API test context
17428 * @return return code
17431 api_one_add_del_adjacency (vat_main_t * vam)
17433 unformat_input_t *input = vam->input;
17434 vl_api_one_add_del_adjacency_t *mp;
17436 ip4_address_t leid4, reid4;
17437 ip6_address_t leid6, reid6;
17438 u8 reid_mac[6] = { 0 };
17439 u8 leid_mac[6] = { 0 };
17440 u8 reid_type, leid_type;
17441 u32 leid_len = 0, reid_len = 0, len;
17445 leid_type = reid_type = (u8) ~ 0;
17447 /* Parse args required to build the message */
17448 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17450 if (unformat (input, "del"))
17454 else if (unformat (input, "add"))
17458 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
17461 reid_type = 0; /* ipv4 */
17464 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
17467 reid_type = 1; /* ipv6 */
17470 else if (unformat (input, "reid %U", unformat_ethernet_address,
17473 reid_type = 2; /* mac */
17475 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
17478 leid_type = 0; /* ipv4 */
17481 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
17484 leid_type = 1; /* ipv6 */
17487 else if (unformat (input, "leid %U", unformat_ethernet_address,
17490 leid_type = 2; /* mac */
17492 else if (unformat (input, "vni %d", &vni))
17498 errmsg ("parse error '%U'", format_unformat_error, input);
17503 if ((u8) ~ 0 == reid_type)
17505 errmsg ("missing params!");
17509 if (leid_type != reid_type)
17511 errmsg ("remote and local EIDs are of different types!");
17515 M (ONE_ADD_DEL_ADJACENCY, mp);
17516 mp->is_add = is_add;
17517 mp->vni = htonl (vni);
17518 mp->leid_len = leid_len;
17519 mp->reid_len = reid_len;
17520 mp->eid_type = reid_type;
17522 switch (mp->eid_type)
17525 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
17526 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
17529 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
17530 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
17533 clib_memcpy (mp->leid, leid_mac, 6);
17534 clib_memcpy (mp->reid, reid_mac, 6);
17537 errmsg ("unknown EID type %d!", mp->eid_type);
17544 /* Wait for a reply... */
17549 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
17552 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
17554 u32 *mode = va_arg (*args, u32 *);
17556 if (unformat (input, "lisp"))
17558 else if (unformat (input, "vxlan"))
17567 api_gpe_get_encap_mode (vat_main_t * vam)
17569 vl_api_gpe_get_encap_mode_t *mp;
17572 /* Construct the API message */
17573 M (GPE_GET_ENCAP_MODE, mp);
17578 /* Wait for a reply... */
17584 api_gpe_set_encap_mode (vat_main_t * vam)
17586 unformat_input_t *input = vam->input;
17587 vl_api_gpe_set_encap_mode_t *mp;
17591 /* Parse args required to build the message */
17592 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17594 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
17600 /* Construct the API message */
17601 M (GPE_SET_ENCAP_MODE, mp);
17608 /* Wait for a reply... */
17614 api_lisp_gpe_add_del_iface (vat_main_t * vam)
17616 unformat_input_t *input = vam->input;
17617 vl_api_gpe_add_del_iface_t *mp;
17618 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
17619 u32 dp_table = 0, vni = 0;
17622 /* Parse args required to build the message */
17623 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17625 if (unformat (input, "up"))
17630 else if (unformat (input, "down"))
17635 else if (unformat (input, "table_id %d", &dp_table))
17639 else if (unformat (input, "bd_id %d", &dp_table))
17644 else if (unformat (input, "vni %d", &vni))
17652 if (action_set == 0)
17654 errmsg ("Action not set");
17657 if (dp_table_set == 0 || vni_set == 0)
17659 errmsg ("vni and dp_table must be set");
17663 /* Construct the API message */
17664 M (GPE_ADD_DEL_IFACE, mp);
17666 mp->is_add = is_add;
17667 mp->dp_table = clib_host_to_net_u32 (dp_table);
17669 mp->vni = clib_host_to_net_u32 (vni);
17674 /* Wait for a reply... */
17680 api_one_map_register_fallback_threshold (vat_main_t * vam)
17682 unformat_input_t *input = vam->input;
17683 vl_api_one_map_register_fallback_threshold_t *mp;
17688 /* Parse args required to build the message */
17689 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17691 if (unformat (input, "%u", &value))
17695 clib_warning ("parse error '%U'", format_unformat_error, input);
17702 errmsg ("fallback threshold value is missing!");
17706 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
17707 mp->value = clib_host_to_net_u32 (value);
17712 /* Wait for a reply... */
17718 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
17720 vl_api_show_one_map_register_fallback_threshold_t *mp;
17723 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
17728 /* Wait for a reply... */
17734 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
17736 u32 *proto = va_arg (*args, u32 *);
17738 if (unformat (input, "udp"))
17740 else if (unformat (input, "api"))
17749 api_one_set_transport_protocol (vat_main_t * vam)
17751 unformat_input_t *input = vam->input;
17752 vl_api_one_set_transport_protocol_t *mp;
17757 /* Parse args required to build the message */
17758 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17760 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
17764 clib_warning ("parse error '%U'", format_unformat_error, input);
17771 errmsg ("Transport protocol missing!");
17775 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
17776 mp->protocol = (u8) protocol;
17781 /* Wait for a reply... */
17787 api_one_get_transport_protocol (vat_main_t * vam)
17789 vl_api_one_get_transport_protocol_t *mp;
17792 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
17797 /* Wait for a reply... */
17803 api_one_map_register_set_ttl (vat_main_t * vam)
17805 unformat_input_t *input = vam->input;
17806 vl_api_one_map_register_set_ttl_t *mp;
17811 /* Parse args required to build the message */
17812 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17814 if (unformat (input, "%u", &ttl))
17818 clib_warning ("parse error '%U'", format_unformat_error, input);
17825 errmsg ("TTL value missing!");
17829 M (ONE_MAP_REGISTER_SET_TTL, mp);
17830 mp->ttl = clib_host_to_net_u32 (ttl);
17835 /* Wait for a reply... */
17841 api_show_one_map_register_ttl (vat_main_t * vam)
17843 vl_api_show_one_map_register_ttl_t *mp;
17846 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
17851 /* Wait for a reply... */
17857 * Add/del map request itr rlocs from ONE control plane and updates
17859 * @param vam vpp API test context
17860 * @return return code
17863 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
17865 unformat_input_t *input = vam->input;
17866 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
17867 u8 *locator_set_name = 0;
17868 u8 locator_set_name_set = 0;
17872 /* Parse args required to build the message */
17873 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17875 if (unformat (input, "del"))
17879 else if (unformat (input, "%_%v%_", &locator_set_name))
17881 locator_set_name_set = 1;
17885 clib_warning ("parse error '%U'", format_unformat_error, input);
17890 if (is_add && !locator_set_name_set)
17892 errmsg ("itr-rloc is not set!");
17896 if (is_add && vec_len (locator_set_name) > 64)
17898 errmsg ("itr-rloc locator-set name too long");
17899 vec_free (locator_set_name);
17903 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
17904 mp->is_add = is_add;
17907 clib_memcpy (mp->locator_set_name, locator_set_name,
17908 vec_len (locator_set_name));
17912 clib_memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
17914 vec_free (locator_set_name);
17919 /* Wait for a reply... */
17924 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
17927 api_one_locator_dump (vat_main_t * vam)
17929 unformat_input_t *input = vam->input;
17930 vl_api_one_locator_dump_t *mp;
17931 vl_api_control_ping_t *mp_ping;
17932 u8 is_index_set = 0, is_name_set = 0;
17937 /* Parse args required to build the message */
17938 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17940 if (unformat (input, "ls_name %_%v%_", &ls_name))
17944 else if (unformat (input, "ls_index %d", &ls_index))
17950 errmsg ("parse error '%U'", format_unformat_error, input);
17955 if (!is_index_set && !is_name_set)
17957 errmsg ("error: expected one of index or name!");
17961 if (is_index_set && is_name_set)
17963 errmsg ("error: only one param expected!");
17967 if (vec_len (ls_name) > 62)
17969 errmsg ("error: locator set name too long!");
17973 if (!vam->json_output)
17975 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
17978 M (ONE_LOCATOR_DUMP, mp);
17979 mp->is_index_set = is_index_set;
17982 mp->ls_index = clib_host_to_net_u32 (ls_index);
17985 vec_add1 (ls_name, 0);
17986 strncpy ((char *) mp->ls_name, (char *) ls_name,
17987 sizeof (mp->ls_name) - 1);
17993 /* Use a control ping for synchronization */
17994 MPING (CONTROL_PING, mp_ping);
17997 /* Wait for a reply... */
18002 #define api_lisp_locator_dump api_one_locator_dump
18005 api_one_locator_set_dump (vat_main_t * vam)
18007 vl_api_one_locator_set_dump_t *mp;
18008 vl_api_control_ping_t *mp_ping;
18009 unformat_input_t *input = vam->input;
18013 /* Parse args required to build the message */
18014 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18016 if (unformat (input, "local"))
18020 else if (unformat (input, "remote"))
18026 errmsg ("parse error '%U'", format_unformat_error, input);
18031 if (!vam->json_output)
18033 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
18036 M (ONE_LOCATOR_SET_DUMP, mp);
18038 mp->filter = filter;
18043 /* Use a control ping for synchronization */
18044 MPING (CONTROL_PING, mp_ping);
18047 /* Wait for a reply... */
18052 #define api_lisp_locator_set_dump api_one_locator_set_dump
18055 api_one_eid_table_map_dump (vat_main_t * vam)
18059 unformat_input_t *input = vam->input;
18060 vl_api_one_eid_table_map_dump_t *mp;
18061 vl_api_control_ping_t *mp_ping;
18064 /* Parse args required to build the message */
18065 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18067 if (unformat (input, "l2"))
18072 else if (unformat (input, "l3"))
18079 errmsg ("parse error '%U'", format_unformat_error, input);
18086 errmsg ("expected one of 'l2' or 'l3' parameter!");
18090 if (!vam->json_output)
18092 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
18095 M (ONE_EID_TABLE_MAP_DUMP, mp);
18101 /* Use a control ping for synchronization */
18102 MPING (CONTROL_PING, mp_ping);
18105 /* Wait for a reply... */
18110 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
18113 api_one_eid_table_vni_dump (vat_main_t * vam)
18115 vl_api_one_eid_table_vni_dump_t *mp;
18116 vl_api_control_ping_t *mp_ping;
18119 if (!vam->json_output)
18121 print (vam->ofp, "VNI");
18124 M (ONE_EID_TABLE_VNI_DUMP, mp);
18129 /* Use a control ping for synchronization */
18130 MPING (CONTROL_PING, mp_ping);
18133 /* Wait for a reply... */
18138 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
18141 api_one_eid_table_dump (vat_main_t * vam)
18143 unformat_input_t *i = vam->input;
18144 vl_api_one_eid_table_dump_t *mp;
18145 vl_api_control_ping_t *mp_ping;
18146 struct in_addr ip4;
18147 struct in6_addr ip6;
18149 u8 eid_type = ~0, eid_set = 0;
18150 u32 prefix_length = ~0, t, vni = 0;
18153 lisp_nsh_api_t nsh;
18155 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18157 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
18163 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
18169 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
18174 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
18179 else if (unformat (i, "vni %d", &t))
18183 else if (unformat (i, "local"))
18187 else if (unformat (i, "remote"))
18193 errmsg ("parse error '%U'", format_unformat_error, i);
18198 if (!vam->json_output)
18200 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
18201 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
18204 M (ONE_EID_TABLE_DUMP, mp);
18206 mp->filter = filter;
18210 mp->vni = htonl (vni);
18211 mp->eid_type = eid_type;
18215 mp->prefix_length = prefix_length;
18216 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
18219 mp->prefix_length = prefix_length;
18220 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
18223 clib_memcpy (mp->eid, mac, sizeof (mac));
18226 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
18229 errmsg ("unknown EID type %d!", eid_type);
18237 /* Use a control ping for synchronization */
18238 MPING (CONTROL_PING, mp_ping);
18241 /* Wait for a reply... */
18246 #define api_lisp_eid_table_dump api_one_eid_table_dump
18249 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
18251 unformat_input_t *i = vam->input;
18252 vl_api_gpe_fwd_entries_get_t *mp;
18257 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18259 if (unformat (i, "vni %d", &vni))
18265 errmsg ("parse error '%U'", format_unformat_error, i);
18272 errmsg ("vni not set!");
18276 if (!vam->json_output)
18278 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
18282 M (GPE_FWD_ENTRIES_GET, mp);
18283 mp->vni = clib_host_to_net_u32 (vni);
18288 /* Wait for a reply... */
18293 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
18294 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
18295 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
18296 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
18297 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
18298 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
18299 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
18300 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
18303 api_one_adjacencies_get (vat_main_t * vam)
18305 unformat_input_t *i = vam->input;
18306 vl_api_one_adjacencies_get_t *mp;
18311 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18313 if (unformat (i, "vni %d", &vni))
18319 errmsg ("parse error '%U'", format_unformat_error, i);
18326 errmsg ("vni not set!");
18330 if (!vam->json_output)
18332 print (vam->ofp, "%s %40s", "leid", "reid");
18335 M (ONE_ADJACENCIES_GET, mp);
18336 mp->vni = clib_host_to_net_u32 (vni);
18341 /* Wait for a reply... */
18346 #define api_lisp_adjacencies_get api_one_adjacencies_get
18349 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
18351 unformat_input_t *i = vam->input;
18352 vl_api_gpe_native_fwd_rpaths_get_t *mp;
18354 u8 ip_family_set = 0, is_ip4 = 1;
18356 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18358 if (unformat (i, "ip4"))
18363 else if (unformat (i, "ip6"))
18370 errmsg ("parse error '%U'", format_unformat_error, i);
18375 if (!ip_family_set)
18377 errmsg ("ip family not set!");
18381 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
18382 mp->is_ip4 = is_ip4;
18387 /* Wait for a reply... */
18393 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
18395 vl_api_gpe_fwd_entry_vnis_get_t *mp;
18398 if (!vam->json_output)
18400 print (vam->ofp, "VNIs");
18403 M (GPE_FWD_ENTRY_VNIS_GET, mp);
18408 /* Wait for a reply... */
18414 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
18416 unformat_input_t *i = vam->input;
18417 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
18419 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
18420 struct in_addr ip4;
18421 struct in6_addr ip6;
18422 u32 table_id = 0, nh_sw_if_index = ~0;
18424 clib_memset (&ip4, 0, sizeof (ip4));
18425 clib_memset (&ip6, 0, sizeof (ip6));
18427 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18429 if (unformat (i, "del"))
18431 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
18432 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18437 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
18438 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18443 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
18447 nh_sw_if_index = ~0;
18449 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
18453 nh_sw_if_index = ~0;
18455 else if (unformat (i, "table %d", &table_id))
18459 errmsg ("parse error '%U'", format_unformat_error, i);
18466 errmsg ("nh addr not set!");
18470 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
18471 mp->is_add = is_add;
18472 mp->table_id = clib_host_to_net_u32 (table_id);
18473 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
18474 mp->is_ip4 = is_ip4;
18476 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
18478 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
18483 /* Wait for a reply... */
18489 api_one_map_server_dump (vat_main_t * vam)
18491 vl_api_one_map_server_dump_t *mp;
18492 vl_api_control_ping_t *mp_ping;
18495 if (!vam->json_output)
18497 print (vam->ofp, "%=20s", "Map server");
18500 M (ONE_MAP_SERVER_DUMP, mp);
18504 /* Use a control ping for synchronization */
18505 MPING (CONTROL_PING, mp_ping);
18508 /* Wait for a reply... */
18513 #define api_lisp_map_server_dump api_one_map_server_dump
18516 api_one_map_resolver_dump (vat_main_t * vam)
18518 vl_api_one_map_resolver_dump_t *mp;
18519 vl_api_control_ping_t *mp_ping;
18522 if (!vam->json_output)
18524 print (vam->ofp, "%=20s", "Map resolver");
18527 M (ONE_MAP_RESOLVER_DUMP, mp);
18531 /* Use a control ping for synchronization */
18532 MPING (CONTROL_PING, mp_ping);
18535 /* Wait for a reply... */
18540 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
18543 api_one_stats_flush (vat_main_t * vam)
18545 vl_api_one_stats_flush_t *mp;
18548 M (ONE_STATS_FLUSH, mp);
18555 api_one_stats_dump (vat_main_t * vam)
18557 vl_api_one_stats_dump_t *mp;
18558 vl_api_control_ping_t *mp_ping;
18561 M (ONE_STATS_DUMP, mp);
18565 /* Use a control ping for synchronization */
18566 MPING (CONTROL_PING, mp_ping);
18569 /* Wait for a reply... */
18575 api_show_one_status (vat_main_t * vam)
18577 vl_api_show_one_status_t *mp;
18580 if (!vam->json_output)
18582 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
18585 M (SHOW_ONE_STATUS, mp);
18588 /* Wait for a reply... */
18593 #define api_show_lisp_status api_show_one_status
18596 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
18598 vl_api_gpe_fwd_entry_path_dump_t *mp;
18599 vl_api_control_ping_t *mp_ping;
18600 unformat_input_t *i = vam->input;
18601 u32 fwd_entry_index = ~0;
18604 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18606 if (unformat (i, "index %d", &fwd_entry_index))
18612 if (~0 == fwd_entry_index)
18614 errmsg ("no index specified!");
18618 if (!vam->json_output)
18620 print (vam->ofp, "first line");
18623 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
18627 /* Use a control ping for synchronization */
18628 MPING (CONTROL_PING, mp_ping);
18631 /* Wait for a reply... */
18637 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
18639 vl_api_one_get_map_request_itr_rlocs_t *mp;
18642 if (!vam->json_output)
18644 print (vam->ofp, "%=20s", "itr-rlocs:");
18647 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
18650 /* Wait for a reply... */
18655 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
18658 api_af_packet_create (vat_main_t * vam)
18660 unformat_input_t *i = vam->input;
18661 vl_api_af_packet_create_t *mp;
18662 u8 *host_if_name = 0;
18664 u8 random_hw_addr = 1;
18667 clib_memset (hw_addr, 0, sizeof (hw_addr));
18669 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18671 if (unformat (i, "name %s", &host_if_name))
18672 vec_add1 (host_if_name, 0);
18673 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
18674 random_hw_addr = 0;
18679 if (!vec_len (host_if_name))
18681 errmsg ("host-interface name must be specified");
18685 if (vec_len (host_if_name) > 64)
18687 errmsg ("host-interface name too long");
18691 M (AF_PACKET_CREATE, mp);
18693 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
18694 clib_memcpy (mp->hw_addr, hw_addr, 6);
18695 mp->use_random_hw_addr = random_hw_addr;
18696 vec_free (host_if_name);
18704 fprintf (vam->ofp ? vam->ofp : stderr,
18705 " new sw_if_index = %d\n", vam->sw_if_index);
18712 api_af_packet_delete (vat_main_t * vam)
18714 unformat_input_t *i = vam->input;
18715 vl_api_af_packet_delete_t *mp;
18716 u8 *host_if_name = 0;
18719 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18721 if (unformat (i, "name %s", &host_if_name))
18722 vec_add1 (host_if_name, 0);
18727 if (!vec_len (host_if_name))
18729 errmsg ("host-interface name must be specified");
18733 if (vec_len (host_if_name) > 64)
18735 errmsg ("host-interface name too long");
18739 M (AF_PACKET_DELETE, mp);
18741 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
18742 vec_free (host_if_name);
18749 static void vl_api_af_packet_details_t_handler
18750 (vl_api_af_packet_details_t * mp)
18752 vat_main_t *vam = &vat_main;
18754 print (vam->ofp, "%-16s %d",
18755 mp->host_if_name, clib_net_to_host_u32 (mp->sw_if_index));
18758 static void vl_api_af_packet_details_t_handler_json
18759 (vl_api_af_packet_details_t * mp)
18761 vat_main_t *vam = &vat_main;
18762 vat_json_node_t *node = NULL;
18764 if (VAT_JSON_ARRAY != vam->json_tree.type)
18766 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18767 vat_json_init_array (&vam->json_tree);
18769 node = vat_json_array_add (&vam->json_tree);
18771 vat_json_init_object (node);
18772 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
18773 vat_json_object_add_string_copy (node, "dev_name", mp->host_if_name);
18777 api_af_packet_dump (vat_main_t * vam)
18779 vl_api_af_packet_dump_t *mp;
18780 vl_api_control_ping_t *mp_ping;
18783 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
18784 /* Get list of tap interfaces */
18785 M (AF_PACKET_DUMP, mp);
18788 /* Use a control ping for synchronization */
18789 MPING (CONTROL_PING, mp_ping);
18797 api_policer_add_del (vat_main_t * vam)
18799 unformat_input_t *i = vam->input;
18800 vl_api_policer_add_del_t *mp;
18810 u8 color_aware = 0;
18811 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
18814 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
18815 conform_action.dscp = 0;
18816 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
18817 exceed_action.dscp = 0;
18818 violate_action.action_type = SSE2_QOS_ACTION_DROP;
18819 violate_action.dscp = 0;
18821 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18823 if (unformat (i, "del"))
18825 else if (unformat (i, "name %s", &name))
18826 vec_add1 (name, 0);
18827 else if (unformat (i, "cir %u", &cir))
18829 else if (unformat (i, "eir %u", &eir))
18831 else if (unformat (i, "cb %u", &cb))
18833 else if (unformat (i, "eb %u", &eb))
18835 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
18838 else if (unformat (i, "round_type %U", unformat_policer_round_type,
18841 else if (unformat (i, "type %U", unformat_policer_type, &type))
18843 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
18846 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
18849 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
18852 else if (unformat (i, "color-aware"))
18858 if (!vec_len (name))
18860 errmsg ("policer name must be specified");
18864 if (vec_len (name) > 64)
18866 errmsg ("policer name too long");
18870 M (POLICER_ADD_DEL, mp);
18872 clib_memcpy (mp->name, name, vec_len (name));
18874 mp->is_add = is_add;
18875 mp->cir = ntohl (cir);
18876 mp->eir = ntohl (eir);
18877 mp->cb = clib_net_to_host_u64 (cb);
18878 mp->eb = clib_net_to_host_u64 (eb);
18879 mp->rate_type = rate_type;
18880 mp->round_type = round_type;
18882 mp->conform_action_type = conform_action.action_type;
18883 mp->conform_dscp = conform_action.dscp;
18884 mp->exceed_action_type = exceed_action.action_type;
18885 mp->exceed_dscp = exceed_action.dscp;
18886 mp->violate_action_type = violate_action.action_type;
18887 mp->violate_dscp = violate_action.dscp;
18888 mp->color_aware = color_aware;
18896 api_policer_dump (vat_main_t * vam)
18898 unformat_input_t *i = vam->input;
18899 vl_api_policer_dump_t *mp;
18900 vl_api_control_ping_t *mp_ping;
18901 u8 *match_name = 0;
18902 u8 match_name_valid = 0;
18905 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18907 if (unformat (i, "name %s", &match_name))
18909 vec_add1 (match_name, 0);
18910 match_name_valid = 1;
18916 M (POLICER_DUMP, mp);
18917 mp->match_name_valid = match_name_valid;
18918 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
18919 vec_free (match_name);
18923 /* Use a control ping for synchronization */
18924 MPING (CONTROL_PING, mp_ping);
18927 /* Wait for a reply... */
18933 api_policer_classify_set_interface (vat_main_t * vam)
18935 unformat_input_t *i = vam->input;
18936 vl_api_policer_classify_set_interface_t *mp;
18938 int sw_if_index_set;
18939 u32 ip4_table_index = ~0;
18940 u32 ip6_table_index = ~0;
18941 u32 l2_table_index = ~0;
18945 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18947 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18948 sw_if_index_set = 1;
18949 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18950 sw_if_index_set = 1;
18951 else if (unformat (i, "del"))
18953 else if (unformat (i, "ip4-table %d", &ip4_table_index))
18955 else if (unformat (i, "ip6-table %d", &ip6_table_index))
18957 else if (unformat (i, "l2-table %d", &l2_table_index))
18961 clib_warning ("parse error '%U'", format_unformat_error, i);
18966 if (sw_if_index_set == 0)
18968 errmsg ("missing interface name or sw_if_index");
18972 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
18974 mp->sw_if_index = ntohl (sw_if_index);
18975 mp->ip4_table_index = ntohl (ip4_table_index);
18976 mp->ip6_table_index = ntohl (ip6_table_index);
18977 mp->l2_table_index = ntohl (l2_table_index);
18978 mp->is_add = is_add;
18986 api_policer_classify_dump (vat_main_t * vam)
18988 unformat_input_t *i = vam->input;
18989 vl_api_policer_classify_dump_t *mp;
18990 vl_api_control_ping_t *mp_ping;
18991 u8 type = POLICER_CLASSIFY_N_TABLES;
18994 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
18998 errmsg ("classify table type must be specified");
19002 if (!vam->json_output)
19004 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
19007 M (POLICER_CLASSIFY_DUMP, mp);
19012 /* Use a control ping for synchronization */
19013 MPING (CONTROL_PING, mp_ping);
19016 /* Wait for a reply... */
19022 api_netmap_create (vat_main_t * vam)
19024 unformat_input_t *i = vam->input;
19025 vl_api_netmap_create_t *mp;
19028 u8 random_hw_addr = 1;
19033 clib_memset (hw_addr, 0, sizeof (hw_addr));
19035 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19037 if (unformat (i, "name %s", &if_name))
19038 vec_add1 (if_name, 0);
19039 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
19040 random_hw_addr = 0;
19041 else if (unformat (i, "pipe"))
19043 else if (unformat (i, "master"))
19045 else if (unformat (i, "slave"))
19051 if (!vec_len (if_name))
19053 errmsg ("interface name must be specified");
19057 if (vec_len (if_name) > 64)
19059 errmsg ("interface name too long");
19063 M (NETMAP_CREATE, mp);
19065 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
19066 clib_memcpy (mp->hw_addr, hw_addr, 6);
19067 mp->use_random_hw_addr = random_hw_addr;
19068 mp->is_pipe = is_pipe;
19069 mp->is_master = is_master;
19070 vec_free (if_name);
19078 api_netmap_delete (vat_main_t * vam)
19080 unformat_input_t *i = vam->input;
19081 vl_api_netmap_delete_t *mp;
19085 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19087 if (unformat (i, "name %s", &if_name))
19088 vec_add1 (if_name, 0);
19093 if (!vec_len (if_name))
19095 errmsg ("interface name must be specified");
19099 if (vec_len (if_name) > 64)
19101 errmsg ("interface name too long");
19105 M (NETMAP_DELETE, mp);
19107 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
19108 vec_free (if_name);
19116 vl_api_mpls_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
19118 if (fp->afi == IP46_TYPE_IP6)
19120 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19121 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19122 fp->weight, ntohl (fp->sw_if_index), fp->is_local,
19123 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19124 format_ip6_address, fp->next_hop);
19125 else if (fp->afi == IP46_TYPE_IP4)
19127 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19128 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19129 fp->weight, ntohl (fp->sw_if_index), fp->is_local,
19130 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19131 format_ip4_address, fp->next_hop);
19135 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
19136 vl_api_fib_path_t * fp)
19138 struct in_addr ip4;
19139 struct in6_addr ip6;
19141 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19142 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19143 vat_json_object_add_uint (node, "is_local", fp->is_local);
19144 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19145 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19146 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19147 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19148 if (fp->afi == IP46_TYPE_IP4)
19150 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19151 vat_json_object_add_ip4 (node, "next_hop", ip4);
19153 else if (fp->afi == IP46_TYPE_IP6)
19155 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19156 vat_json_object_add_ip6 (node, "next_hop", ip6);
19161 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
19163 vat_main_t *vam = &vat_main;
19164 int count = ntohl (mp->mt_count);
19165 vl_api_fib_path_t *fp;
19168 print (vam->ofp, "[%d]: sw_if_index %d via:",
19169 ntohl (mp->mt_tunnel_index), ntohl (mp->mt_sw_if_index));
19171 for (i = 0; i < count; i++)
19173 vl_api_mpls_fib_path_print (vam, fp);
19177 print (vam->ofp, "");
19180 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
19181 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
19184 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
19186 vat_main_t *vam = &vat_main;
19187 vat_json_node_t *node = NULL;
19188 int count = ntohl (mp->mt_count);
19189 vl_api_fib_path_t *fp;
19192 if (VAT_JSON_ARRAY != vam->json_tree.type)
19194 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19195 vat_json_init_array (&vam->json_tree);
19197 node = vat_json_array_add (&vam->json_tree);
19199 vat_json_init_object (node);
19200 vat_json_object_add_uint (node, "tunnel_index",
19201 ntohl (mp->mt_tunnel_index));
19202 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->mt_sw_if_index));
19204 vat_json_object_add_uint (node, "l2_only", mp->mt_l2_only);
19207 for (i = 0; i < count; i++)
19209 vl_api_mpls_fib_path_json_print (node, fp);
19215 api_mpls_tunnel_dump (vat_main_t * vam)
19217 vl_api_mpls_tunnel_dump_t *mp;
19218 vl_api_control_ping_t *mp_ping;
19219 u32 sw_if_index = ~0;
19222 /* Parse args required to build the message */
19223 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
19225 if (unformat (vam->input, "sw_if_index %d", &sw_if_index))
19229 print (vam->ofp, " sw_if_index %d", sw_if_index);
19231 M (MPLS_TUNNEL_DUMP, mp);
19232 mp->sw_if_index = htonl (sw_if_index);
19235 /* Use a control ping for synchronization */
19236 MPING (CONTROL_PING, mp_ping);
19243 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
19244 #define vl_api_mpls_fib_details_t_print vl_noop_handler
19248 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
19250 vat_main_t *vam = &vat_main;
19251 int count = ntohl (mp->count);
19252 vl_api_fib_path_t *fp;
19256 "table-id %d, label %u, ess_bit %u",
19257 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
19259 for (i = 0; i < count; i++)
19261 vl_api_mpls_fib_path_print (vam, fp);
19266 static void vl_api_mpls_fib_details_t_handler_json
19267 (vl_api_mpls_fib_details_t * mp)
19269 vat_main_t *vam = &vat_main;
19270 int count = ntohl (mp->count);
19271 vat_json_node_t *node = NULL;
19272 vl_api_fib_path_t *fp;
19275 if (VAT_JSON_ARRAY != vam->json_tree.type)
19277 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19278 vat_json_init_array (&vam->json_tree);
19280 node = vat_json_array_add (&vam->json_tree);
19282 vat_json_init_object (node);
19283 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19284 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
19285 vat_json_object_add_uint (node, "label", ntohl (mp->label));
19286 vat_json_object_add_uint (node, "path_count", count);
19288 for (i = 0; i < count; i++)
19290 vl_api_mpls_fib_path_json_print (node, fp);
19296 api_mpls_fib_dump (vat_main_t * vam)
19298 vl_api_mpls_fib_dump_t *mp;
19299 vl_api_control_ping_t *mp_ping;
19302 M (MPLS_FIB_DUMP, mp);
19305 /* Use a control ping for synchronization */
19306 MPING (CONTROL_PING, mp_ping);
19313 #define vl_api_ip_fib_details_t_endian vl_noop_handler
19314 #define vl_api_ip_fib_details_t_print vl_noop_handler
19317 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
19319 vat_main_t *vam = &vat_main;
19320 int count = ntohl (mp->count);
19321 vl_api_fib_path_t *fp;
19325 "table-id %d, prefix %U/%d stats-index %d",
19326 ntohl (mp->table_id), format_ip4_address, mp->address,
19327 mp->address_length, ntohl (mp->stats_index));
19329 for (i = 0; i < count; i++)
19331 if (fp->afi == IP46_TYPE_IP6)
19333 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19334 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U, "
19335 "next_hop_table %d",
19336 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19337 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19338 format_ip6_address, fp->next_hop, ntohl (fp->table_id));
19339 else if (fp->afi == IP46_TYPE_IP4)
19341 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19342 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U, "
19343 "next_hop_table %d",
19344 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19345 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19346 format_ip4_address, fp->next_hop, ntohl (fp->table_id));
19351 static void vl_api_ip_fib_details_t_handler_json
19352 (vl_api_ip_fib_details_t * mp)
19354 vat_main_t *vam = &vat_main;
19355 int count = ntohl (mp->count);
19356 vat_json_node_t *node = NULL;
19357 struct in_addr ip4;
19358 struct in6_addr ip6;
19359 vl_api_fib_path_t *fp;
19362 if (VAT_JSON_ARRAY != vam->json_tree.type)
19364 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19365 vat_json_init_array (&vam->json_tree);
19367 node = vat_json_array_add (&vam->json_tree);
19369 vat_json_init_object (node);
19370 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19371 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
19372 vat_json_object_add_ip4 (node, "prefix", ip4);
19373 vat_json_object_add_uint (node, "mask_length", mp->address_length);
19374 vat_json_object_add_uint (node, "path_count", count);
19376 for (i = 0; i < count; i++)
19378 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19379 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19380 vat_json_object_add_uint (node, "is_local", fp->is_local);
19381 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19382 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19383 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19384 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19385 if (fp->afi == IP46_TYPE_IP4)
19387 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19388 vat_json_object_add_ip4 (node, "next_hop", ip4);
19390 else if (fp->afi == IP46_TYPE_IP6)
19392 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19393 vat_json_object_add_ip6 (node, "next_hop", ip6);
19399 api_ip_fib_dump (vat_main_t * vam)
19401 vl_api_ip_fib_dump_t *mp;
19402 vl_api_control_ping_t *mp_ping;
19405 M (IP_FIB_DUMP, mp);
19408 /* Use a control ping for synchronization */
19409 MPING (CONTROL_PING, mp_ping);
19417 api_ip_mfib_dump (vat_main_t * vam)
19419 vl_api_ip_mfib_dump_t *mp;
19420 vl_api_control_ping_t *mp_ping;
19423 M (IP_MFIB_DUMP, mp);
19426 /* Use a control ping for synchronization */
19427 MPING (CONTROL_PING, mp_ping);
19434 static void vl_api_ip_neighbor_details_t_handler
19435 (vl_api_ip_neighbor_details_t * mp)
19437 vat_main_t *vam = &vat_main;
19439 print (vam->ofp, "%c %U %U",
19440 (ntohl (mp->neighbor.flags) & IP_NEIGHBOR_FLAG_STATIC) ? 'S' : 'D',
19441 format_vl_api_mac_address, &mp->neighbor.mac_address,
19442 format_vl_api_address, &mp->neighbor.ip_address);
19445 static void vl_api_ip_neighbor_details_t_handler_json
19446 (vl_api_ip_neighbor_details_t * mp)
19449 vat_main_t *vam = &vat_main;
19450 vat_json_node_t *node;
19452 if (VAT_JSON_ARRAY != vam->json_tree.type)
19454 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19455 vat_json_init_array (&vam->json_tree);
19457 node = vat_json_array_add (&vam->json_tree);
19459 vat_json_init_object (node);
19460 vat_json_object_add_string_copy
19462 ((ntohl (mp->neighbor.flags) & IP_NEIGHBOR_FLAG_STATIC) ?
19463 (u8 *) "static" : (u8 *) "dynamic"));
19465 vat_json_object_add_string_copy (node, "link_layer",
19466 format (0, "%U", format_vl_api_mac_address,
19467 &mp->neighbor.mac_address));
19468 vat_json_object_add_address (node, "ip", &mp->neighbor.ip_address);
19472 api_ip_neighbor_dump (vat_main_t * vam)
19474 unformat_input_t *i = vam->input;
19475 vl_api_ip_neighbor_dump_t *mp;
19476 vl_api_control_ping_t *mp_ping;
19478 u32 sw_if_index = ~0;
19481 /* Parse args required to build the message */
19482 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19484 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19486 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19488 else if (unformat (i, "ip6"))
19494 if (sw_if_index == ~0)
19496 errmsg ("missing interface name or sw_if_index");
19500 M (IP_NEIGHBOR_DUMP, mp);
19501 mp->is_ipv6 = (u8) is_ipv6;
19502 mp->sw_if_index = ntohl (sw_if_index);
19505 /* Use a control ping for synchronization */
19506 MPING (CONTROL_PING, mp_ping);
19513 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
19514 #define vl_api_ip6_fib_details_t_print vl_noop_handler
19517 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
19519 vat_main_t *vam = &vat_main;
19520 int count = ntohl (mp->count);
19521 vl_api_fib_path_t *fp;
19525 "table-id %d, prefix %U/%d stats-index %d",
19526 ntohl (mp->table_id), format_ip6_address, mp->address,
19527 mp->address_length, ntohl (mp->stats_index));
19529 for (i = 0; i < count; i++)
19531 if (fp->afi == IP46_TYPE_IP6)
19533 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19534 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19535 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19536 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19537 format_ip6_address, fp->next_hop);
19538 else if (fp->afi == IP46_TYPE_IP4)
19540 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19541 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19542 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19543 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19544 format_ip4_address, fp->next_hop);
19549 static void vl_api_ip6_fib_details_t_handler_json
19550 (vl_api_ip6_fib_details_t * mp)
19552 vat_main_t *vam = &vat_main;
19553 int count = ntohl (mp->count);
19554 vat_json_node_t *node = NULL;
19555 struct in_addr ip4;
19556 struct in6_addr ip6;
19557 vl_api_fib_path_t *fp;
19560 if (VAT_JSON_ARRAY != vam->json_tree.type)
19562 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19563 vat_json_init_array (&vam->json_tree);
19565 node = vat_json_array_add (&vam->json_tree);
19567 vat_json_init_object (node);
19568 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19569 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
19570 vat_json_object_add_ip6 (node, "prefix", ip6);
19571 vat_json_object_add_uint (node, "mask_length", mp->address_length);
19572 vat_json_object_add_uint (node, "path_count", count);
19574 for (i = 0; i < count; i++)
19576 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19577 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19578 vat_json_object_add_uint (node, "is_local", fp->is_local);
19579 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19580 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19581 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19582 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19583 if (fp->afi == IP46_TYPE_IP4)
19585 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19586 vat_json_object_add_ip4 (node, "next_hop", ip4);
19588 else if (fp->afi == IP46_TYPE_IP6)
19590 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19591 vat_json_object_add_ip6 (node, "next_hop", ip6);
19597 api_ip6_fib_dump (vat_main_t * vam)
19599 vl_api_ip6_fib_dump_t *mp;
19600 vl_api_control_ping_t *mp_ping;
19603 M (IP6_FIB_DUMP, mp);
19606 /* Use a control ping for synchronization */
19607 MPING (CONTROL_PING, mp_ping);
19615 api_ip6_mfib_dump (vat_main_t * vam)
19617 vl_api_ip6_mfib_dump_t *mp;
19618 vl_api_control_ping_t *mp_ping;
19621 M (IP6_MFIB_DUMP, mp);
19624 /* Use a control ping for synchronization */
19625 MPING (CONTROL_PING, mp_ping);
19633 api_classify_table_ids (vat_main_t * vam)
19635 vl_api_classify_table_ids_t *mp;
19638 /* Construct the API message */
19639 M (CLASSIFY_TABLE_IDS, mp);
19648 api_classify_table_by_interface (vat_main_t * vam)
19650 unformat_input_t *input = vam->input;
19651 vl_api_classify_table_by_interface_t *mp;
19653 u32 sw_if_index = ~0;
19655 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19657 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19659 else if (unformat (input, "sw_if_index %d", &sw_if_index))
19664 if (sw_if_index == ~0)
19666 errmsg ("missing interface name or sw_if_index");
19670 /* Construct the API message */
19671 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
19673 mp->sw_if_index = ntohl (sw_if_index);
19681 api_classify_table_info (vat_main_t * vam)
19683 unformat_input_t *input = vam->input;
19684 vl_api_classify_table_info_t *mp;
19688 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19690 if (unformat (input, "table_id %d", &table_id))
19695 if (table_id == ~0)
19697 errmsg ("missing table id");
19701 /* Construct the API message */
19702 M (CLASSIFY_TABLE_INFO, mp);
19704 mp->table_id = ntohl (table_id);
19712 api_classify_session_dump (vat_main_t * vam)
19714 unformat_input_t *input = vam->input;
19715 vl_api_classify_session_dump_t *mp;
19716 vl_api_control_ping_t *mp_ping;
19720 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19722 if (unformat (input, "table_id %d", &table_id))
19727 if (table_id == ~0)
19729 errmsg ("missing table id");
19733 /* Construct the API message */
19734 M (CLASSIFY_SESSION_DUMP, mp);
19736 mp->table_id = ntohl (table_id);
19739 /* Use a control ping for synchronization */
19740 MPING (CONTROL_PING, mp_ping);
19748 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
19750 vat_main_t *vam = &vat_main;
19752 print (vam->ofp, "collector_address %U, collector_port %d, "
19753 "src_address %U, vrf_id %d, path_mtu %u, "
19754 "template_interval %u, udp_checksum %d",
19755 format_ip4_address, mp->collector_address,
19756 ntohs (mp->collector_port),
19757 format_ip4_address, mp->src_address,
19758 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
19759 ntohl (mp->template_interval), mp->udp_checksum);
19762 vam->result_ready = 1;
19766 vl_api_ipfix_exporter_details_t_handler_json
19767 (vl_api_ipfix_exporter_details_t * mp)
19769 vat_main_t *vam = &vat_main;
19770 vat_json_node_t node;
19771 struct in_addr collector_address;
19772 struct in_addr src_address;
19774 vat_json_init_object (&node);
19775 clib_memcpy (&collector_address, &mp->collector_address,
19776 sizeof (collector_address));
19777 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
19778 vat_json_object_add_uint (&node, "collector_port",
19779 ntohs (mp->collector_port));
19780 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
19781 vat_json_object_add_ip4 (&node, "src_address", src_address);
19782 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
19783 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
19784 vat_json_object_add_uint (&node, "template_interval",
19785 ntohl (mp->template_interval));
19786 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
19788 vat_json_print (vam->ofp, &node);
19789 vat_json_free (&node);
19791 vam->result_ready = 1;
19795 api_ipfix_exporter_dump (vat_main_t * vam)
19797 vl_api_ipfix_exporter_dump_t *mp;
19800 /* Construct the API message */
19801 M (IPFIX_EXPORTER_DUMP, mp);
19810 api_ipfix_classify_stream_dump (vat_main_t * vam)
19812 vl_api_ipfix_classify_stream_dump_t *mp;
19815 /* Construct the API message */
19816 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
19827 vl_api_ipfix_classify_stream_details_t_handler
19828 (vl_api_ipfix_classify_stream_details_t * mp)
19830 vat_main_t *vam = &vat_main;
19831 print (vam->ofp, "domain_id %d, src_port %d",
19832 ntohl (mp->domain_id), ntohs (mp->src_port));
19834 vam->result_ready = 1;
19838 vl_api_ipfix_classify_stream_details_t_handler_json
19839 (vl_api_ipfix_classify_stream_details_t * mp)
19841 vat_main_t *vam = &vat_main;
19842 vat_json_node_t node;
19844 vat_json_init_object (&node);
19845 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
19846 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
19848 vat_json_print (vam->ofp, &node);
19849 vat_json_free (&node);
19851 vam->result_ready = 1;
19855 api_ipfix_classify_table_dump (vat_main_t * vam)
19857 vl_api_ipfix_classify_table_dump_t *mp;
19858 vl_api_control_ping_t *mp_ping;
19861 if (!vam->json_output)
19863 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
19864 "transport_protocol");
19867 /* Construct the API message */
19868 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
19873 /* Use a control ping for synchronization */
19874 MPING (CONTROL_PING, mp_ping);
19882 vl_api_ipfix_classify_table_details_t_handler
19883 (vl_api_ipfix_classify_table_details_t * mp)
19885 vat_main_t *vam = &vat_main;
19886 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
19887 mp->transport_protocol);
19891 vl_api_ipfix_classify_table_details_t_handler_json
19892 (vl_api_ipfix_classify_table_details_t * mp)
19894 vat_json_node_t *node = NULL;
19895 vat_main_t *vam = &vat_main;
19897 if (VAT_JSON_ARRAY != vam->json_tree.type)
19899 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19900 vat_json_init_array (&vam->json_tree);
19903 node = vat_json_array_add (&vam->json_tree);
19904 vat_json_init_object (node);
19906 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
19907 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
19908 vat_json_object_add_uint (node, "transport_protocol",
19909 mp->transport_protocol);
19913 api_sw_interface_span_enable_disable (vat_main_t * vam)
19915 unformat_input_t *i = vam->input;
19916 vl_api_sw_interface_span_enable_disable_t *mp;
19917 u32 src_sw_if_index = ~0;
19918 u32 dst_sw_if_index = ~0;
19923 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19926 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
19928 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
19932 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
19934 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
19936 else if (unformat (i, "disable"))
19938 else if (unformat (i, "rx"))
19940 else if (unformat (i, "tx"))
19942 else if (unformat (i, "both"))
19944 else if (unformat (i, "l2"))
19950 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
19952 mp->sw_if_index_from = htonl (src_sw_if_index);
19953 mp->sw_if_index_to = htonl (dst_sw_if_index);
19963 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
19966 vat_main_t *vam = &vat_main;
19967 u8 *sw_if_from_name = 0;
19968 u8 *sw_if_to_name = 0;
19969 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
19970 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
19971 char *states[] = { "none", "rx", "tx", "both" };
19975 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
19977 if ((u32) p->value[0] == sw_if_index_from)
19979 sw_if_from_name = (u8 *)(p->key);
19983 if ((u32) p->value[0] == sw_if_index_to)
19985 sw_if_to_name = (u8 *)(p->key);
19986 if (sw_if_from_name)
19991 print (vam->ofp, "%20s => %20s (%s) %s",
19992 sw_if_from_name, sw_if_to_name, states[mp->state],
19993 mp->is_l2 ? "l2" : "device");
19997 vl_api_sw_interface_span_details_t_handler_json
19998 (vl_api_sw_interface_span_details_t * mp)
20000 vat_main_t *vam = &vat_main;
20001 vat_json_node_t *node = NULL;
20002 u8 *sw_if_from_name = 0;
20003 u8 *sw_if_to_name = 0;
20004 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
20005 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
20009 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
20011 if ((u32) p->value[0] == sw_if_index_from)
20013 sw_if_from_name = (u8 *)(p->key);
20017 if ((u32) p->value[0] == sw_if_index_to)
20019 sw_if_to_name = (u8 *)(p->key);
20020 if (sw_if_from_name)
20026 if (VAT_JSON_ARRAY != vam->json_tree.type)
20028 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20029 vat_json_init_array (&vam->json_tree);
20031 node = vat_json_array_add (&vam->json_tree);
20033 vat_json_init_object (node);
20034 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
20035 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
20036 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
20037 if (0 != sw_if_to_name)
20039 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
20041 vat_json_object_add_uint (node, "state", mp->state);
20042 vat_json_object_add_uint (node, "is-l2", mp->is_l2);
20046 api_sw_interface_span_dump (vat_main_t * vam)
20048 unformat_input_t *input = vam->input;
20049 vl_api_sw_interface_span_dump_t *mp;
20050 vl_api_control_ping_t *mp_ping;
20054 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20056 if (unformat (input, "l2"))
20062 M (SW_INTERFACE_SPAN_DUMP, mp);
20066 /* Use a control ping for synchronization */
20067 MPING (CONTROL_PING, mp_ping);
20075 api_pg_create_interface (vat_main_t * vam)
20077 unformat_input_t *input = vam->input;
20078 vl_api_pg_create_interface_t *mp;
20082 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20084 if (unformat (input, "if_id %d", &if_id))
20091 errmsg ("missing pg interface index");
20095 /* Construct the API message */
20096 M (PG_CREATE_INTERFACE, mp);
20098 mp->interface_id = ntohl (if_id);
20106 api_pg_capture (vat_main_t * vam)
20108 unformat_input_t *input = vam->input;
20109 vl_api_pg_capture_t *mp;
20114 u8 pcap_file_set = 0;
20117 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20119 if (unformat (input, "if_id %d", &if_id))
20121 else if (unformat (input, "pcap %s", &pcap_file))
20123 else if (unformat (input, "count %d", &count))
20125 else if (unformat (input, "disable"))
20132 errmsg ("missing pg interface index");
20135 if (pcap_file_set > 0)
20137 if (vec_len (pcap_file) > 255)
20139 errmsg ("pcap file name is too long");
20144 u32 name_len = vec_len (pcap_file);
20145 /* Construct the API message */
20146 M (PG_CAPTURE, mp);
20148 mp->interface_id = ntohl (if_id);
20149 mp->is_enabled = enable;
20150 mp->count = ntohl (count);
20151 mp->pcap_name_length = ntohl (name_len);
20152 if (pcap_file_set != 0)
20154 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
20156 vec_free (pcap_file);
20164 api_pg_enable_disable (vat_main_t * vam)
20166 unformat_input_t *input = vam->input;
20167 vl_api_pg_enable_disable_t *mp;
20170 u8 stream_name_set = 0;
20171 u8 *stream_name = 0;
20173 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20175 if (unformat (input, "stream %s", &stream_name))
20176 stream_name_set = 1;
20177 else if (unformat (input, "disable"))
20183 if (stream_name_set > 0)
20185 if (vec_len (stream_name) > 255)
20187 errmsg ("stream name too long");
20192 u32 name_len = vec_len (stream_name);
20193 /* Construct the API message */
20194 M (PG_ENABLE_DISABLE, mp);
20196 mp->is_enabled = enable;
20197 if (stream_name_set != 0)
20199 mp->stream_name_length = ntohl (name_len);
20200 clib_memcpy (mp->stream_name, stream_name, name_len);
20202 vec_free (stream_name);
20210 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
20212 unformat_input_t *input = vam->input;
20213 vl_api_ip_source_and_port_range_check_add_del_t *mp;
20215 u16 *low_ports = 0;
20216 u16 *high_ports = 0;
20219 vl_api_prefix_t prefix;
20227 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20229 if (unformat (input, "%U", unformat_vl_api_prefix, &prefix))
20231 else if (unformat (input, "vrf %d", &vrf_id))
20233 else if (unformat (input, "del"))
20235 else if (unformat (input, "port %d", &tmp))
20237 if (tmp == 0 || tmp > 65535)
20239 errmsg ("port %d out of range", tmp);
20243 this_hi = this_low + 1;
20244 vec_add1 (low_ports, this_low);
20245 vec_add1 (high_ports, this_hi);
20247 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
20249 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
20251 errmsg ("incorrect range parameters");
20255 /* Note: in debug CLI +1 is added to high before
20256 passing to real fn that does "the work"
20257 (ip_source_and_port_range_check_add_del).
20258 This fn is a wrapper around the binary API fn a
20259 control plane will call, which expects this increment
20260 to have occurred. Hence letting the binary API control
20261 plane fn do the increment for consistency between VAT
20262 and other control planes.
20265 vec_add1 (low_ports, this_low);
20266 vec_add1 (high_ports, this_hi);
20272 if (prefix_set == 0)
20274 errmsg ("<address>/<mask> not specified");
20280 errmsg ("VRF ID required, not specified");
20287 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
20291 if (vec_len (low_ports) == 0)
20293 errmsg ("At least one port or port range required");
20297 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
20299 mp->is_add = is_add;
20301 clib_memcpy (&mp->prefix, &prefix, sizeof (prefix));
20303 mp->number_of_ranges = vec_len (low_ports);
20305 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
20306 vec_free (low_ports);
20308 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
20309 vec_free (high_ports);
20311 mp->vrf_id = ntohl (vrf_id);
20319 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
20321 unformat_input_t *input = vam->input;
20322 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
20323 u32 sw_if_index = ~0;
20325 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
20326 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
20330 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20332 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20334 else if (unformat (input, "sw_if_index %d", &sw_if_index))
20336 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
20338 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
20340 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
20342 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
20344 else if (unformat (input, "del"))
20350 if (sw_if_index == ~0)
20352 errmsg ("Interface required but not specified");
20358 errmsg ("VRF ID required but not specified");
20362 if (tcp_out_vrf_id == 0
20363 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
20366 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
20370 /* Construct the API message */
20371 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
20373 mp->sw_if_index = ntohl (sw_if_index);
20374 mp->is_add = is_add;
20375 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
20376 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
20377 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
20378 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
20383 /* Wait for a reply... */
20389 api_ipsec_gre_tunnel_add_del (vat_main_t * vam)
20391 unformat_input_t *i = vam->input;
20392 vl_api_ipsec_gre_tunnel_add_del_t *mp;
20393 u32 local_sa_id = 0;
20394 u32 remote_sa_id = 0;
20395 vl_api_ip4_address_t src_address;
20396 vl_api_ip4_address_t dst_address;
20400 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20402 if (unformat (i, "local_sa %d", &local_sa_id))
20404 else if (unformat (i, "remote_sa %d", &remote_sa_id))
20407 if (unformat (i, "src %U", unformat_vl_api_ip4_address, &src_address))
20410 if (unformat (i, "dst %U", unformat_vl_api_ip4_address, &dst_address))
20412 else if (unformat (i, "del"))
20416 clib_warning ("parse error '%U'", format_unformat_error, i);
20421 M (IPSEC_GRE_TUNNEL_ADD_DEL, mp);
20423 mp->tunnel.local_sa_id = ntohl (local_sa_id);
20424 mp->tunnel.remote_sa_id = ntohl (remote_sa_id);
20425 clib_memcpy (mp->tunnel.src, &src_address, sizeof (src_address));
20426 clib_memcpy (mp->tunnel.dst, &dst_address, sizeof (dst_address));
20427 mp->is_add = is_add;
20435 api_set_punt (vat_main_t * vam)
20437 unformat_input_t *i = vam->input;
20438 vl_api_set_punt_t *mp;
20445 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20447 if (unformat (i, "ip %d", &ipv))
20449 else if (unformat (i, "protocol %d", &protocol))
20451 else if (unformat (i, "port %d", &port))
20453 else if (unformat (i, "del"))
20457 clib_warning ("parse error '%U'", format_unformat_error, i);
20464 mp->is_add = (u8) is_add;
20465 mp->punt.ipv = (u8) ipv;
20466 mp->punt.l4_protocol = (u8) protocol;
20467 mp->punt.l4_port = htons ((u16) port);
20474 static void vl_api_ipsec_gre_tunnel_details_t_handler
20475 (vl_api_ipsec_gre_tunnel_details_t * mp)
20477 vat_main_t *vam = &vat_main;
20479 print (vam->ofp, "%11d%15U%15U%14d%14d",
20480 ntohl (mp->tunnel.sw_if_index),
20481 format_vl_api_ip4_address, mp->tunnel.src,
20482 format_vl_api_ip4_address, mp->tunnel.dst,
20483 ntohl (mp->tunnel.local_sa_id), ntohl (mp->tunnel.remote_sa_id));
20487 vat_json_object_add_vl_api_ip4 (vat_json_node_t * node,
20489 const vl_api_ip4_address_t addr)
20491 struct in_addr ip4;
20493 clib_memcpy (&ip4, addr, sizeof (ip4));
20494 vat_json_object_add_ip4 (node, name, ip4);
20497 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
20498 (vl_api_ipsec_gre_tunnel_details_t * mp)
20500 vat_main_t *vam = &vat_main;
20501 vat_json_node_t *node = NULL;
20502 struct in_addr ip4;
20504 if (VAT_JSON_ARRAY != vam->json_tree.type)
20506 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20507 vat_json_init_array (&vam->json_tree);
20509 node = vat_json_array_add (&vam->json_tree);
20511 vat_json_init_object (node);
20512 vat_json_object_add_uint (node, "sw_if_index",
20513 ntohl (mp->tunnel.sw_if_index));
20514 vat_json_object_add_vl_api_ip4 (node, "src", mp->tunnel.src);
20515 vat_json_object_add_vl_api_ip4 (node, "src", mp->tunnel.dst);
20516 vat_json_object_add_uint (node, "local_sa_id",
20517 ntohl (mp->tunnel.local_sa_id));
20518 vat_json_object_add_uint (node, "remote_sa_id",
20519 ntohl (mp->tunnel.remote_sa_id));
20523 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
20525 unformat_input_t *i = vam->input;
20526 vl_api_ipsec_gre_tunnel_dump_t *mp;
20527 vl_api_control_ping_t *mp_ping;
20529 u8 sw_if_index_set = 0;
20532 /* Parse args required to build the message */
20533 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20535 if (unformat (i, "sw_if_index %d", &sw_if_index))
20536 sw_if_index_set = 1;
20541 if (sw_if_index_set == 0)
20546 if (!vam->json_output)
20548 print (vam->ofp, "%11s%15s%15s%14s%14s",
20549 "sw_if_index", "src_address", "dst_address",
20550 "local_sa_id", "remote_sa_id");
20553 /* Get list of gre-tunnel interfaces */
20554 M (IPSEC_GRE_TUNNEL_DUMP, mp);
20556 mp->sw_if_index = htonl (sw_if_index);
20560 /* Use a control ping for synchronization */
20561 MPING (CONTROL_PING, mp_ping);
20569 api_delete_subif (vat_main_t * vam)
20571 unformat_input_t *i = vam->input;
20572 vl_api_delete_subif_t *mp;
20573 u32 sw_if_index = ~0;
20576 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20578 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20580 if (unformat (i, "sw_if_index %d", &sw_if_index))
20586 if (sw_if_index == ~0)
20588 errmsg ("missing sw_if_index");
20592 /* Construct the API message */
20593 M (DELETE_SUBIF, mp);
20594 mp->sw_if_index = ntohl (sw_if_index);
20601 #define foreach_pbb_vtr_op \
20602 _("disable", L2_VTR_DISABLED) \
20603 _("pop", L2_VTR_POP_2) \
20604 _("push", L2_VTR_PUSH_2)
20607 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
20609 unformat_input_t *i = vam->input;
20610 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
20611 u32 sw_if_index = ~0, vtr_op = ~0;
20612 u16 outer_tag = ~0;
20613 u8 dmac[6], smac[6];
20614 u8 dmac_set = 0, smac_set = 0;
20620 /* Shut up coverity */
20621 clib_memset (dmac, 0, sizeof (dmac));
20622 clib_memset (smac, 0, sizeof (smac));
20624 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20626 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20628 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20630 else if (unformat (i, "vtr_op %d", &vtr_op))
20632 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
20635 else if (unformat (i, "translate_pbb_stag"))
20637 if (unformat (i, "%d", &tmp))
20639 vtr_op = L2_VTR_TRANSLATE_2_1;
20645 ("translate_pbb_stag operation requires outer tag definition");
20649 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
20651 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
20653 else if (unformat (i, "sid %d", &sid))
20655 else if (unformat (i, "vlanid %d", &tmp))
20659 clib_warning ("parse error '%U'", format_unformat_error, i);
20664 if ((sw_if_index == ~0) || (vtr_op == ~0))
20666 errmsg ("missing sw_if_index or vtr operation");
20669 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
20670 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
20673 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
20677 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
20678 mp->sw_if_index = ntohl (sw_if_index);
20679 mp->vtr_op = ntohl (vtr_op);
20680 mp->outer_tag = ntohs (outer_tag);
20681 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
20682 clib_memcpy (mp->b_smac, smac, sizeof (smac));
20683 mp->b_vlanid = ntohs (vlanid);
20684 mp->i_sid = ntohl (sid);
20692 api_flow_classify_set_interface (vat_main_t * vam)
20694 unformat_input_t *i = vam->input;
20695 vl_api_flow_classify_set_interface_t *mp;
20697 int sw_if_index_set;
20698 u32 ip4_table_index = ~0;
20699 u32 ip6_table_index = ~0;
20703 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20705 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20706 sw_if_index_set = 1;
20707 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20708 sw_if_index_set = 1;
20709 else if (unformat (i, "del"))
20711 else if (unformat (i, "ip4-table %d", &ip4_table_index))
20713 else if (unformat (i, "ip6-table %d", &ip6_table_index))
20717 clib_warning ("parse error '%U'", format_unformat_error, i);
20722 if (sw_if_index_set == 0)
20724 errmsg ("missing interface name or sw_if_index");
20728 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
20730 mp->sw_if_index = ntohl (sw_if_index);
20731 mp->ip4_table_index = ntohl (ip4_table_index);
20732 mp->ip6_table_index = ntohl (ip6_table_index);
20733 mp->is_add = is_add;
20741 api_flow_classify_dump (vat_main_t * vam)
20743 unformat_input_t *i = vam->input;
20744 vl_api_flow_classify_dump_t *mp;
20745 vl_api_control_ping_t *mp_ping;
20746 u8 type = FLOW_CLASSIFY_N_TABLES;
20749 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
20753 errmsg ("classify table type must be specified");
20757 if (!vam->json_output)
20759 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
20762 M (FLOW_CLASSIFY_DUMP, mp);
20767 /* Use a control ping for synchronization */
20768 MPING (CONTROL_PING, mp_ping);
20771 /* Wait for a reply... */
20777 api_feature_enable_disable (vat_main_t * vam)
20779 unformat_input_t *i = vam->input;
20780 vl_api_feature_enable_disable_t *mp;
20782 u8 *feature_name = 0;
20783 u32 sw_if_index = ~0;
20787 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20789 if (unformat (i, "arc_name %s", &arc_name))
20791 else if (unformat (i, "feature_name %s", &feature_name))
20794 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20796 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20798 else if (unformat (i, "disable"))
20806 errmsg ("missing arc name");
20809 if (vec_len (arc_name) > 63)
20811 errmsg ("arc name too long");
20814 if (feature_name == 0)
20816 errmsg ("missing feature name");
20819 if (vec_len (feature_name) > 63)
20821 errmsg ("feature name too long");
20824 if (sw_if_index == ~0)
20826 errmsg ("missing interface name or sw_if_index");
20830 /* Construct the API message */
20831 M (FEATURE_ENABLE_DISABLE, mp);
20832 mp->sw_if_index = ntohl (sw_if_index);
20833 mp->enable = enable;
20834 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
20835 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
20836 vec_free (arc_name);
20837 vec_free (feature_name);
20845 api_sw_interface_tag_add_del (vat_main_t * vam)
20847 unformat_input_t *i = vam->input;
20848 vl_api_sw_interface_tag_add_del_t *mp;
20849 u32 sw_if_index = ~0;
20854 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20856 if (unformat (i, "tag %s", &tag))
20858 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20860 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20862 else if (unformat (i, "del"))
20868 if (sw_if_index == ~0)
20870 errmsg ("missing interface name or sw_if_index");
20874 if (enable && (tag == 0))
20876 errmsg ("no tag specified");
20880 /* Construct the API message */
20881 M (SW_INTERFACE_TAG_ADD_DEL, mp);
20882 mp->sw_if_index = ntohl (sw_if_index);
20883 mp->is_add = enable;
20885 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
20893 static void vl_api_l2_xconnect_details_t_handler
20894 (vl_api_l2_xconnect_details_t * mp)
20896 vat_main_t *vam = &vat_main;
20898 print (vam->ofp, "%15d%15d",
20899 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
20902 static void vl_api_l2_xconnect_details_t_handler_json
20903 (vl_api_l2_xconnect_details_t * mp)
20905 vat_main_t *vam = &vat_main;
20906 vat_json_node_t *node = NULL;
20908 if (VAT_JSON_ARRAY != vam->json_tree.type)
20910 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20911 vat_json_init_array (&vam->json_tree);
20913 node = vat_json_array_add (&vam->json_tree);
20915 vat_json_init_object (node);
20916 vat_json_object_add_uint (node, "rx_sw_if_index",
20917 ntohl (mp->rx_sw_if_index));
20918 vat_json_object_add_uint (node, "tx_sw_if_index",
20919 ntohl (mp->tx_sw_if_index));
20923 api_l2_xconnect_dump (vat_main_t * vam)
20925 vl_api_l2_xconnect_dump_t *mp;
20926 vl_api_control_ping_t *mp_ping;
20929 if (!vam->json_output)
20931 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
20934 M (L2_XCONNECT_DUMP, mp);
20938 /* Use a control ping for synchronization */
20939 MPING (CONTROL_PING, mp_ping);
20947 api_hw_interface_set_mtu (vat_main_t * vam)
20949 unformat_input_t *i = vam->input;
20950 vl_api_hw_interface_set_mtu_t *mp;
20951 u32 sw_if_index = ~0;
20955 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20957 if (unformat (i, "mtu %d", &mtu))
20959 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20961 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20967 if (sw_if_index == ~0)
20969 errmsg ("missing interface name or sw_if_index");
20975 errmsg ("no mtu specified");
20979 /* Construct the API message */
20980 M (HW_INTERFACE_SET_MTU, mp);
20981 mp->sw_if_index = ntohl (sw_if_index);
20982 mp->mtu = ntohs ((u16) mtu);
20990 api_p2p_ethernet_add (vat_main_t * vam)
20992 unformat_input_t *i = vam->input;
20993 vl_api_p2p_ethernet_add_t *mp;
20994 u32 parent_if_index = ~0;
21000 clib_memset (remote_mac, 0, sizeof (remote_mac));
21001 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21003 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
21005 else if (unformat (i, "sw_if_index %d", &parent_if_index))
21009 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
21011 else if (unformat (i, "sub_id %d", &sub_id))
21015 clib_warning ("parse error '%U'", format_unformat_error, i);
21020 if (parent_if_index == ~0)
21022 errmsg ("missing interface name or sw_if_index");
21027 errmsg ("missing remote mac address");
21032 errmsg ("missing sub-interface id");
21036 M (P2P_ETHERNET_ADD, mp);
21037 mp->parent_if_index = ntohl (parent_if_index);
21038 mp->subif_id = ntohl (sub_id);
21039 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
21047 api_p2p_ethernet_del (vat_main_t * vam)
21049 unformat_input_t *i = vam->input;
21050 vl_api_p2p_ethernet_del_t *mp;
21051 u32 parent_if_index = ~0;
21056 clib_memset (remote_mac, 0, sizeof (remote_mac));
21057 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21059 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
21061 else if (unformat (i, "sw_if_index %d", &parent_if_index))
21065 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
21069 clib_warning ("parse error '%U'", format_unformat_error, i);
21074 if (parent_if_index == ~0)
21076 errmsg ("missing interface name or sw_if_index");
21081 errmsg ("missing remote mac address");
21085 M (P2P_ETHERNET_DEL, mp);
21086 mp->parent_if_index = ntohl (parent_if_index);
21087 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
21095 api_lldp_config (vat_main_t * vam)
21097 unformat_input_t *i = vam->input;
21098 vl_api_lldp_config_t *mp;
21100 int tx_interval = 0;
21101 u8 *sys_name = NULL;
21104 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21106 if (unformat (i, "system-name %s", &sys_name))
21108 else if (unformat (i, "tx-hold %d", &tx_hold))
21110 else if (unformat (i, "tx-interval %d", &tx_interval))
21114 clib_warning ("parse error '%U'", format_unformat_error, i);
21119 vec_add1 (sys_name, 0);
21121 M (LLDP_CONFIG, mp);
21122 mp->tx_hold = htonl (tx_hold);
21123 mp->tx_interval = htonl (tx_interval);
21124 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
21125 vec_free (sys_name);
21133 api_sw_interface_set_lldp (vat_main_t * vam)
21135 unformat_input_t *i = vam->input;
21136 vl_api_sw_interface_set_lldp_t *mp;
21137 u32 sw_if_index = ~0;
21139 u8 *port_desc = NULL, *mgmt_oid = NULL;
21140 ip4_address_t ip4_addr;
21141 ip6_address_t ip6_addr;
21144 clib_memset (&ip4_addr, 0, sizeof (ip4_addr));
21145 clib_memset (&ip6_addr, 0, sizeof (ip6_addr));
21147 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21149 if (unformat (i, "disable"))
21152 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21154 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21156 else if (unformat (i, "port-desc %s", &port_desc))
21158 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
21160 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
21162 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
21168 if (sw_if_index == ~0)
21170 errmsg ("missing interface name or sw_if_index");
21174 /* Construct the API message */
21175 vec_add1 (port_desc, 0);
21176 vec_add1 (mgmt_oid, 0);
21177 M (SW_INTERFACE_SET_LLDP, mp);
21178 mp->sw_if_index = ntohl (sw_if_index);
21179 mp->enable = enable;
21180 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
21181 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
21182 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
21183 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
21184 vec_free (port_desc);
21185 vec_free (mgmt_oid);
21193 api_tcp_configure_src_addresses (vat_main_t * vam)
21195 vl_api_tcp_configure_src_addresses_t *mp;
21196 unformat_input_t *i = vam->input;
21197 ip4_address_t v4first, v4last;
21198 ip6_address_t v6first, v6last;
21203 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21205 if (unformat (i, "%U - %U",
21206 unformat_ip4_address, &v4first,
21207 unformat_ip4_address, &v4last))
21211 errmsg ("one range per message (range already set)");
21216 else if (unformat (i, "%U - %U",
21217 unformat_ip6_address, &v6first,
21218 unformat_ip6_address, &v6last))
21222 errmsg ("one range per message (range already set)");
21227 else if (unformat (i, "vrf %d", &vrf_id))
21233 if (range_set == 0)
21235 errmsg ("address range not set");
21239 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
21240 mp->vrf_id = ntohl (vrf_id);
21242 if (range_set == 2)
21245 clib_memcpy (mp->first_address, &v6first, sizeof (v6first));
21246 clib_memcpy (mp->last_address, &v6last, sizeof (v6last));
21251 clib_memcpy (mp->first_address, &v4first, sizeof (v4first));
21252 clib_memcpy (mp->last_address, &v4last, sizeof (v4last));
21259 static void vl_api_app_namespace_add_del_reply_t_handler
21260 (vl_api_app_namespace_add_del_reply_t * mp)
21262 vat_main_t *vam = &vat_main;
21263 i32 retval = ntohl (mp->retval);
21264 if (vam->async_mode)
21266 vam->async_errors += (retval < 0);
21270 vam->retval = retval;
21272 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
21273 vam->result_ready = 1;
21277 static void vl_api_app_namespace_add_del_reply_t_handler_json
21278 (vl_api_app_namespace_add_del_reply_t * mp)
21280 vat_main_t *vam = &vat_main;
21281 vat_json_node_t node;
21283 vat_json_init_object (&node);
21284 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
21285 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
21287 vat_json_print (vam->ofp, &node);
21288 vat_json_free (&node);
21290 vam->retval = ntohl (mp->retval);
21291 vam->result_ready = 1;
21295 api_app_namespace_add_del (vat_main_t * vam)
21297 vl_api_app_namespace_add_del_t *mp;
21298 unformat_input_t *i = vam->input;
21299 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
21300 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
21304 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21306 if (unformat (i, "id %_%v%_", &ns_id))
21308 else if (unformat (i, "secret %lu", &secret))
21310 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21311 sw_if_index_set = 1;
21312 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
21314 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
21319 if (!ns_id || !secret_set || !sw_if_index_set)
21321 errmsg ("namespace id, secret and sw_if_index must be set");
21324 if (vec_len (ns_id) > 64)
21326 errmsg ("namespace id too long");
21329 M (APP_NAMESPACE_ADD_DEL, mp);
21331 clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
21332 mp->namespace_id_len = vec_len (ns_id);
21333 mp->secret = clib_host_to_net_u64 (secret);
21334 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
21335 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
21336 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
21344 api_sock_init_shm (vat_main_t * vam)
21346 #if VPP_API_TEST_BUILTIN == 0
21347 unformat_input_t *i = vam->input;
21348 vl_api_shm_elem_config_t *config = 0;
21349 u64 size = 64 << 20;
21352 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21354 if (unformat (i, "size %U", unformat_memory_size, &size))
21361 * Canned custom ring allocator config.
21362 * Should probably parse all of this
21364 vec_validate (config, 6);
21365 config[0].type = VL_API_VLIB_RING;
21366 config[0].size = 256;
21367 config[0].count = 32;
21369 config[1].type = VL_API_VLIB_RING;
21370 config[1].size = 1024;
21371 config[1].count = 16;
21373 config[2].type = VL_API_VLIB_RING;
21374 config[2].size = 4096;
21375 config[2].count = 2;
21377 config[3].type = VL_API_CLIENT_RING;
21378 config[3].size = 256;
21379 config[3].count = 32;
21381 config[4].type = VL_API_CLIENT_RING;
21382 config[4].size = 1024;
21383 config[4].count = 16;
21385 config[5].type = VL_API_CLIENT_RING;
21386 config[5].size = 4096;
21387 config[5].count = 2;
21389 config[6].type = VL_API_QUEUE;
21390 config[6].count = 128;
21391 config[6].size = sizeof (uword);
21393 rv = vl_socket_client_init_shm (config, 1 /* want_pthread */ );
21395 vam->client_index_invalid = 1;
21403 api_dns_enable_disable (vat_main_t * vam)
21405 unformat_input_t *line_input = vam->input;
21406 vl_api_dns_enable_disable_t *mp;
21407 u8 enable_disable = 1;
21410 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21412 if (unformat (line_input, "disable"))
21413 enable_disable = 0;
21414 if (unformat (line_input, "enable"))
21415 enable_disable = 1;
21420 /* Construct the API message */
21421 M (DNS_ENABLE_DISABLE, mp);
21422 mp->enable = enable_disable;
21426 /* Wait for the reply */
21432 api_dns_resolve_name (vat_main_t * vam)
21434 unformat_input_t *line_input = vam->input;
21435 vl_api_dns_resolve_name_t *mp;
21439 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21441 if (unformat (line_input, "%s", &name))
21447 if (vec_len (name) > 127)
21449 errmsg ("name too long");
21453 /* Construct the API message */
21454 M (DNS_RESOLVE_NAME, mp);
21455 memcpy (mp->name, name, vec_len (name));
21460 /* Wait for the reply */
21466 api_dns_resolve_ip (vat_main_t * vam)
21468 unformat_input_t *line_input = vam->input;
21469 vl_api_dns_resolve_ip_t *mp;
21471 ip4_address_t addr4;
21472 ip6_address_t addr6;
21475 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21477 if (unformat (line_input, "%U", unformat_ip6_address, &addr6))
21479 else if (unformat (line_input, "%U", unformat_ip4_address, &addr4))
21487 errmsg ("missing address");
21491 /* Construct the API message */
21492 M (DNS_RESOLVE_IP, mp);
21493 mp->is_ip6 = is_ip6;
21495 memcpy (mp->address, &addr6, sizeof (addr6));
21497 memcpy (mp->address, &addr4, sizeof (addr4));
21501 /* Wait for the reply */
21507 api_dns_name_server_add_del (vat_main_t * vam)
21509 unformat_input_t *i = vam->input;
21510 vl_api_dns_name_server_add_del_t *mp;
21512 ip6_address_t ip6_server;
21513 ip4_address_t ip4_server;
21518 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21520 if (unformat (i, "%U", unformat_ip6_address, &ip6_server))
21522 else if (unformat (i, "%U", unformat_ip4_address, &ip4_server))
21524 else if (unformat (i, "del"))
21528 clib_warning ("parse error '%U'", format_unformat_error, i);
21533 if (ip4_set && ip6_set)
21535 errmsg ("Only one server address allowed per message");
21538 if ((ip4_set + ip6_set) == 0)
21540 errmsg ("Server address required");
21544 /* Construct the API message */
21545 M (DNS_NAME_SERVER_ADD_DEL, mp);
21549 memcpy (mp->server_address, &ip6_server, sizeof (ip6_address_t));
21554 memcpy (mp->server_address, &ip4_server, sizeof (ip4_address_t));
21558 mp->is_add = is_add;
21563 /* Wait for a reply, return good/bad news */
21569 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
21571 vat_main_t *vam = &vat_main;
21576 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
21577 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
21578 mp->scope, format_ip4_address, &mp->lcl_ip, mp->lcl_plen,
21579 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
21580 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
21581 clib_net_to_host_u32 (mp->action_index), mp->tag);
21586 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
21587 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
21588 mp->scope, format_ip6_address, &mp->lcl_ip, mp->lcl_plen,
21589 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
21590 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
21591 clib_net_to_host_u32 (mp->action_index), mp->tag);
21596 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
21599 vat_main_t *vam = &vat_main;
21600 vat_json_node_t *node = NULL;
21601 struct in6_addr ip6;
21602 struct in_addr ip4;
21604 if (VAT_JSON_ARRAY != vam->json_tree.type)
21606 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
21607 vat_json_init_array (&vam->json_tree);
21609 node = vat_json_array_add (&vam->json_tree);
21610 vat_json_init_object (node);
21612 vat_json_object_add_uint (node, "is_ip4", mp->is_ip4 ? 1 : 0);
21613 vat_json_object_add_uint (node, "appns_index",
21614 clib_net_to_host_u32 (mp->appns_index));
21615 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
21616 vat_json_object_add_uint (node, "scope", mp->scope);
21617 vat_json_object_add_uint (node, "action_index",
21618 clib_net_to_host_u32 (mp->action_index));
21619 vat_json_object_add_uint (node, "lcl_port",
21620 clib_net_to_host_u16 (mp->lcl_port));
21621 vat_json_object_add_uint (node, "rmt_port",
21622 clib_net_to_host_u16 (mp->rmt_port));
21623 vat_json_object_add_uint (node, "lcl_plen", mp->lcl_plen);
21624 vat_json_object_add_uint (node, "rmt_plen", mp->rmt_plen);
21625 vat_json_object_add_string_copy (node, "tag", mp->tag);
21628 clib_memcpy (&ip4, mp->lcl_ip, sizeof (ip4));
21629 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
21630 clib_memcpy (&ip4, mp->rmt_ip, sizeof (ip4));
21631 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
21635 clib_memcpy (&ip6, mp->lcl_ip, sizeof (ip6));
21636 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
21637 clib_memcpy (&ip6, mp->rmt_ip, sizeof (ip6));
21638 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
21643 api_session_rule_add_del (vat_main_t * vam)
21645 vl_api_session_rule_add_del_t *mp;
21646 unformat_input_t *i = vam->input;
21647 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
21648 u32 appns_index = 0, scope = 0;
21649 ip4_address_t lcl_ip4, rmt_ip4;
21650 ip6_address_t lcl_ip6, rmt_ip6;
21651 u8 is_ip4 = 1, conn_set = 0;
21652 u8 is_add = 1, *tag = 0;
21655 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21657 if (unformat (i, "del"))
21659 else if (unformat (i, "add"))
21661 else if (unformat (i, "proto tcp"))
21663 else if (unformat (i, "proto udp"))
21665 else if (unformat (i, "appns %d", &appns_index))
21667 else if (unformat (i, "scope %d", &scope))
21669 else if (unformat (i, "tag %_%v%_", &tag))
21673 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
21674 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
21682 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
21683 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
21689 else if (unformat (i, "action %d", &action))
21694 if (proto == ~0 || !conn_set || action == ~0)
21696 errmsg ("transport proto, connection and action must be set");
21702 errmsg ("scope should be 0-3");
21706 M (SESSION_RULE_ADD_DEL, mp);
21708 mp->is_ip4 = is_ip4;
21709 mp->transport_proto = proto;
21710 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
21711 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
21712 mp->lcl_plen = lcl_plen;
21713 mp->rmt_plen = rmt_plen;
21714 mp->action_index = clib_host_to_net_u32 (action);
21715 mp->appns_index = clib_host_to_net_u32 (appns_index);
21717 mp->is_add = is_add;
21720 clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
21721 clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
21725 clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
21726 clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
21730 clib_memcpy (mp->tag, tag, vec_len (tag));
21740 api_session_rules_dump (vat_main_t * vam)
21742 vl_api_session_rules_dump_t *mp;
21743 vl_api_control_ping_t *mp_ping;
21746 if (!vam->json_output)
21748 print (vam->ofp, "%=20s", "Session Rules");
21751 M (SESSION_RULES_DUMP, mp);
21755 /* Use a control ping for synchronization */
21756 MPING (CONTROL_PING, mp_ping);
21759 /* Wait for a reply... */
21765 api_ip_container_proxy_add_del (vat_main_t * vam)
21767 vl_api_ip_container_proxy_add_del_t *mp;
21768 unformat_input_t *i = vam->input;
21769 u32 sw_if_index = ~0;
21770 vl_api_prefix_t pfx = { };
21774 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21776 if (unformat (i, "del"))
21778 else if (unformat (i, "add"))
21780 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
21782 else if (unformat (i, "sw_if_index %u", &sw_if_index))
21787 if (sw_if_index == ~0 || pfx.address_length == 0)
21789 errmsg ("address and sw_if_index must be set");
21793 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
21795 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
21796 mp->is_add = is_add;
21797 clib_memcpy (&mp->pfx, &pfx, sizeof (pfx));
21805 api_qos_record_enable_disable (vat_main_t * vam)
21807 unformat_input_t *i = vam->input;
21808 vl_api_qos_record_enable_disable_t *mp;
21809 u32 sw_if_index, qs = 0xff;
21810 u8 sw_if_index_set = 0;
21814 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21816 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21817 sw_if_index_set = 1;
21818 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21819 sw_if_index_set = 1;
21820 else if (unformat (i, "%U", unformat_qos_source, &qs))
21822 else if (unformat (i, "disable"))
21826 clib_warning ("parse error '%U'", format_unformat_error, i);
21831 if (sw_if_index_set == 0)
21833 errmsg ("missing interface name or sw_if_index");
21838 errmsg ("input location must be specified");
21842 M (QOS_RECORD_ENABLE_DISABLE, mp);
21844 mp->sw_if_index = ntohl (sw_if_index);
21845 mp->input_source = qs;
21846 mp->enable = enable;
21855 q_or_quit (vat_main_t * vam)
21857 #if VPP_API_TEST_BUILTIN == 0
21858 longjmp (vam->jump_buf, 1);
21860 return 0; /* not so much */
21864 q (vat_main_t * vam)
21866 return q_or_quit (vam);
21870 quit (vat_main_t * vam)
21872 return q_or_quit (vam);
21876 comment (vat_main_t * vam)
21882 statseg (vat_main_t * vam)
21884 ssvm_private_t *ssvmp = &vam->stat_segment;
21885 ssvm_shared_header_t *shared_header = ssvmp->sh;
21886 vlib_counter_t **counters;
21887 u64 thread0_index1_packets;
21888 u64 thread0_index1_bytes;
21889 f64 vector_rate, input_rate;
21892 uword *counter_vector_by_name;
21893 if (vam->stat_segment_lockp == 0)
21895 errmsg ("Stat segment not mapped...");
21899 /* look up "/if/rx for sw_if_index 1 as a test */
21901 clib_spinlock_lock (vam->stat_segment_lockp);
21903 counter_vector_by_name = (uword *) shared_header->opaque[1];
21905 p = hash_get_mem (counter_vector_by_name, "/if/rx");
21908 clib_spinlock_unlock (vam->stat_segment_lockp);
21909 errmsg ("/if/tx not found?");
21913 /* Fish per-thread vector of combined counters from shared memory */
21914 counters = (vlib_counter_t **) p[0];
21916 if (vec_len (counters[0]) < 2)
21918 clib_spinlock_unlock (vam->stat_segment_lockp);
21919 errmsg ("/if/tx vector length %d", vec_len (counters[0]));
21923 /* Read thread 0 sw_if_index 1 counter */
21924 thread0_index1_packets = counters[0][1].packets;
21925 thread0_index1_bytes = counters[0][1].bytes;
21927 p = hash_get_mem (counter_vector_by_name, "vector_rate");
21930 clib_spinlock_unlock (vam->stat_segment_lockp);
21931 errmsg ("vector_rate not found?");
21935 vector_rate = *(f64 *) (p[0]);
21936 p = hash_get_mem (counter_vector_by_name, "input_rate");
21939 clib_spinlock_unlock (vam->stat_segment_lockp);
21940 errmsg ("input_rate not found?");
21943 input_rate = *(f64 *) (p[0]);
21945 clib_spinlock_unlock (vam->stat_segment_lockp);
21947 print (vam->ofp, "vector_rate %.2f input_rate %.2f",
21948 vector_rate, input_rate);
21949 print (vam->ofp, "thread 0 sw_if_index 1 rx pkts %lld, bytes %lld",
21950 thread0_index1_packets, thread0_index1_bytes);
21956 cmd_cmp (void *a1, void *a2)
21961 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
21965 help (vat_main_t * vam)
21970 unformat_input_t *i = vam->input;
21973 if (unformat (i, "%s", &name))
21977 vec_add1 (name, 0);
21979 hs = hash_get_mem (vam->help_by_name, name);
21981 print (vam->ofp, "usage: %s %s", name, hs[0]);
21983 print (vam->ofp, "No such msg / command '%s'", name);
21988 print (vam->ofp, "Help is available for the following:");
21991 hash_foreach_pair (p, vam->function_by_name,
21993 vec_add1 (cmds, (u8 *)(p->key));
21997 vec_sort_with_function (cmds, cmd_cmp);
21999 for (j = 0; j < vec_len (cmds); j++)
22000 print (vam->ofp, "%s", cmds[j]);
22007 set (vat_main_t * vam)
22009 u8 *name = 0, *value = 0;
22010 unformat_input_t *i = vam->input;
22012 if (unformat (i, "%s", &name))
22014 /* The input buffer is a vector, not a string. */
22015 value = vec_dup (i->buffer);
22016 vec_delete (value, i->index, 0);
22017 /* Almost certainly has a trailing newline */
22018 if (value[vec_len (value) - 1] == '\n')
22019 value[vec_len (value) - 1] = 0;
22020 /* Make sure it's a proper string, one way or the other */
22021 vec_add1 (value, 0);
22022 (void) clib_macro_set_value (&vam->macro_main,
22023 (char *) name, (char *) value);
22026 errmsg ("usage: set <name> <value>");
22034 unset (vat_main_t * vam)
22038 if (unformat (vam->input, "%s", &name))
22039 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
22040 errmsg ("unset: %s wasn't set", name);
22053 macro_sort_cmp (void *a1, void *a2)
22055 macro_sort_t *s1 = a1;
22056 macro_sort_t *s2 = a2;
22058 return strcmp ((char *) (s1->name), (char *) (s2->name));
22062 dump_macro_table (vat_main_t * vam)
22064 macro_sort_t *sort_me = 0, *sm;
22069 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
22071 vec_add2 (sort_me, sm, 1);
22072 sm->name = (u8 *)(p->key);
22073 sm->value = (u8 *) (p->value[0]);
22077 vec_sort_with_function (sort_me, macro_sort_cmp);
22079 if (vec_len (sort_me))
22080 print (vam->ofp, "%-15s%s", "Name", "Value");
22082 print (vam->ofp, "The macro table is empty...");
22084 for (i = 0; i < vec_len (sort_me); i++)
22085 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
22090 dump_node_table (vat_main_t * vam)
22093 vlib_node_t *node, *next_node;
22095 if (vec_len (vam->graph_nodes) == 0)
22097 print (vam->ofp, "Node table empty, issue get_node_graph...");
22101 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
22103 node = vam->graph_nodes[0][i];
22104 print (vam->ofp, "[%d] %s", i, node->name);
22105 for (j = 0; j < vec_len (node->next_nodes); j++)
22107 if (node->next_nodes[j] != ~0)
22109 next_node = vam->graph_nodes[0][node->next_nodes[j]];
22110 print (vam->ofp, " [%d] %s", j, next_node->name);
22118 value_sort_cmp (void *a1, void *a2)
22120 name_sort_t *n1 = a1;
22121 name_sort_t *n2 = a2;
22123 if (n1->value < n2->value)
22125 if (n1->value > n2->value)
22132 dump_msg_api_table (vat_main_t * vam)
22134 api_main_t *am = &api_main;
22135 name_sort_t *nses = 0, *ns;
22140 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
22142 vec_add2 (nses, ns, 1);
22143 ns->name = (u8 *)(hp->key);
22144 ns->value = (u32) hp->value[0];
22148 vec_sort_with_function (nses, value_sort_cmp);
22150 for (i = 0; i < vec_len (nses); i++)
22151 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
22157 get_msg_id (vat_main_t * vam)
22162 if (unformat (vam->input, "%s", &name_and_crc))
22164 message_index = vl_msg_api_get_msg_index (name_and_crc);
22165 if (message_index == ~0)
22167 print (vam->ofp, " '%s' not found", name_and_crc);
22170 print (vam->ofp, " '%s' has message index %d",
22171 name_and_crc, message_index);
22174 errmsg ("name_and_crc required...");
22179 search_node_table (vat_main_t * vam)
22181 unformat_input_t *line_input = vam->input;
22184 vlib_node_t *node, *next_node;
22187 if (vam->graph_node_index_by_name == 0)
22189 print (vam->ofp, "Node table empty, issue get_node_graph...");
22193 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
22195 if (unformat (line_input, "%s", &node_to_find))
22197 vec_add1 (node_to_find, 0);
22198 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
22201 print (vam->ofp, "%s not found...", node_to_find);
22204 node = vam->graph_nodes[0][p[0]];
22205 print (vam->ofp, "[%d] %s", p[0], node->name);
22206 for (j = 0; j < vec_len (node->next_nodes); j++)
22208 if (node->next_nodes[j] != ~0)
22210 next_node = vam->graph_nodes[0][node->next_nodes[j]];
22211 print (vam->ofp, " [%d] %s", j, next_node->name);
22218 clib_warning ("parse error '%U'", format_unformat_error,
22224 vec_free (node_to_find);
22233 script (vat_main_t * vam)
22235 #if (VPP_API_TEST_BUILTIN==0)
22237 char *save_current_file;
22238 unformat_input_t save_input;
22239 jmp_buf save_jump_buf;
22240 u32 save_line_number;
22242 FILE *new_fp, *save_ifp;
22244 if (unformat (vam->input, "%s", &s))
22246 new_fp = fopen ((char *) s, "r");
22249 errmsg ("Couldn't open script file %s", s);
22256 errmsg ("Missing script name");
22260 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
22261 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
22262 save_ifp = vam->ifp;
22263 save_line_number = vam->input_line_number;
22264 save_current_file = (char *) vam->current_file;
22266 vam->input_line_number = 0;
22268 vam->current_file = s;
22271 clib_memcpy (&vam->input, &save_input, sizeof (save_input));
22272 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
22273 vam->ifp = save_ifp;
22274 vam->input_line_number = save_line_number;
22275 vam->current_file = (u8 *) save_current_file;
22280 clib_warning ("use the exec command...");
22286 echo (vat_main_t * vam)
22288 print (vam->ofp, "%v", vam->input->buffer);
22292 /* List of API message constructors, CLI names map to api_xxx */
22293 #define foreach_vpe_api_msg \
22294 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
22295 _(sw_interface_dump,"") \
22296 _(sw_interface_set_flags, \
22297 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
22298 _(sw_interface_add_del_address, \
22299 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
22300 _(sw_interface_set_rx_mode, \
22301 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
22302 _(sw_interface_set_rx_placement, \
22303 "<intfc> | sw_if_index <id> [queue <id>] [worker <id> | main]") \
22304 _(sw_interface_rx_placement_dump, \
22305 "[<intfc> | sw_if_index <id>]") \
22306 _(sw_interface_set_table, \
22307 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
22308 _(sw_interface_set_mpls_enable, \
22309 "<intfc> | sw_if_index [disable | dis]") \
22310 _(sw_interface_set_vpath, \
22311 "<intfc> | sw_if_index <id> enable | disable") \
22312 _(sw_interface_set_vxlan_bypass, \
22313 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
22314 _(sw_interface_set_geneve_bypass, \
22315 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
22316 _(sw_interface_set_l2_xconnect, \
22317 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
22318 "enable | disable") \
22319 _(sw_interface_set_l2_bridge, \
22320 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
22321 "[shg <split-horizon-group>] [bvi]\n" \
22322 "enable | disable") \
22323 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
22324 _(bridge_domain_add_del, \
22325 "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") \
22326 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
22328 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
22329 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
22330 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
22332 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
22334 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
22336 "id <num> [hw-addr <mac-addr>] [host-ns <name>] [rx-ring-size <num> [tx-ring-size <num>]") \
22338 "<vpp-if-name> | sw_if_index <id>") \
22339 _(sw_interface_tap_v2_dump, "") \
22340 _(virtio_pci_create, \
22341 "pci-addr <pci-address> [use_random_mac | hw-addr <mac-addr>] [tx-ring-size <num> [rx-ring-size <num>] [features <hex-value>]") \
22342 _(virtio_pci_delete, \
22343 "<vpp-if-name> | sw_if_index <id>") \
22344 _(sw_interface_virtio_pci_dump, "") \
22346 "[hw-addr <mac-addr>] {round-robin | active-backup | " \
22347 "broadcast | {lacp | xor} [load-balance { l2 | l23 | l34 }]} " \
22350 "<vpp-if-name> | sw_if_index <id>") \
22352 "sw_if_index <n> bond <sw_if_index> [is_passive] [is_long_timeout]") \
22353 _(bond_detach_slave, \
22354 "sw_if_index <n>") \
22355 _(sw_interface_bond_dump, "") \
22356 _(sw_interface_slave_dump, \
22357 "<vpp-if-name> | sw_if_index <id>") \
22358 _(ip_table_add_del, \
22359 "table <n> [ipv6] [add | del]\n") \
22360 _(ip_add_del_route, \
22361 "<addr>/<mask> via <<addr>|<intfc>|sw_if_index <id>|via-label <n>>\n" \
22362 "[table-id <n>] [<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n"\
22363 "[weight <n>] [drop] [local] [classify <n>] [out-label <n>]\n" \
22364 "[multipath] [count <n>] [del]") \
22365 _(ip_mroute_add_del, \
22366 "<src> <grp>/<mask> [table-id <n>]\n" \
22367 "[<intfc> | sw_if_index <id>] [local] [del]") \
22368 _(mpls_table_add_del, \
22369 "table <n> [add | del]\n") \
22370 _(mpls_route_add_del, \
22371 "<label> <eos> via <addr | next-hop-table <n> | via-label <n> |\n" \
22372 "lookup-ip4-table <n> | lookup-in-ip6-table <n> |\n" \
22373 "l2-input-on <intfc> | l2-input-on sw_if_index <id>>\n" \
22374 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>] [weight <n>]\n" \
22375 "[drop] [local] [classify <n>] [out-label <n>] [multipath]\n" \
22376 "[count <n>] [del]") \
22377 _(mpls_ip_bind_unbind, \
22378 "<label> <addr/len>") \
22379 _(mpls_tunnel_add_del, \
22380 "[add | del <intfc | sw_if_index <id>>] via <addr | via-label <n>>\n" \
22381 "[<intfc> | sw_if_index <id> | next-hop-table <id>]\n" \
22382 "[l2-only] [out-label <n>]") \
22383 _(sr_mpls_policy_add, \
22384 "bsid <id> [weight <n>] [spray] next <sid> [next <sid>]") \
22385 _(sr_mpls_policy_del, \
22387 _(bier_table_add_del, \
22388 "<label> <sub-domain> <set> <bsl> [del]") \
22389 _(bier_route_add_del, \
22390 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
22391 "[<intfc> | sw_if_index <id>]" \
22392 "[weight <n>] [del] [multipath]") \
22393 _(proxy_arp_add_del, \
22394 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
22395 _(proxy_arp_intfc_enable_disable, \
22396 "<intfc> | sw_if_index <id> enable | disable") \
22397 _(sw_interface_set_unnumbered, \
22398 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
22399 _(ip_neighbor_add_del, \
22400 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
22401 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
22402 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
22403 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
22404 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
22405 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
22406 "[outer_vlan_id_any][inner_vlan_id_any]") \
22407 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
22408 _(reset_fib, "vrf <n> [ipv6]") \
22409 _(dhcp_proxy_config, \
22410 "svr <v46-address> src <v46-address>\n" \
22411 "rx_vrf_id <nn> server_vrf_id <nn> [del]") \
22412 _(dhcp_proxy_set_vss, \
22413 "tbl_id <n> [fib_id <n> oui <n> | vpn_ascii_id <text>] [ipv6] [del]") \
22414 _(dhcp_proxy_dump, "ip6") \
22415 _(dhcp_client_config, \
22416 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
22417 _(set_ip_flow_hash, \
22418 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
22419 _(sw_interface_ip6_enable_disable, \
22420 "<intfc> | sw_if_index <id> enable | disable") \
22421 _(ip6nd_proxy_add_del, \
22422 "<intfc> | sw_if_index <id> <ip6-address>") \
22423 _(ip6nd_proxy_dump, "") \
22424 _(sw_interface_ip6nd_ra_prefix, \
22425 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
22426 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
22427 "[nolink] [isno]") \
22428 _(sw_interface_ip6nd_ra_config, \
22429 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
22430 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
22431 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
22432 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
22433 _(l2_patch_add_del, \
22434 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
22435 "enable | disable") \
22436 _(sr_localsid_add_del, \
22437 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
22438 "fib-table <num> (end.psp) sw_if_index <num>") \
22439 _(classify_add_del_table, \
22440 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
22441 " [del] [del-chain] mask <mask-value>\n" \
22442 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
22443 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
22444 _(classify_add_del_session, \
22445 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
22446 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
22447 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
22448 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
22449 _(classify_set_interface_ip_table, \
22450 "<intfc> | sw_if_index <nn> table <nn>") \
22451 _(classify_set_interface_l2_tables, \
22452 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22453 " [other-table <nn>]") \
22454 _(get_node_index, "node <node-name") \
22455 _(add_node_next, "node <node-name> next <next-node-name>") \
22456 _(l2tpv3_create_tunnel, \
22457 "client_address <ip6-addr> our_address <ip6-addr>\n" \
22458 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
22459 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
22460 _(l2tpv3_set_tunnel_cookies, \
22461 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
22462 "[new_remote_cookie <nn>]\n") \
22463 _(l2tpv3_interface_enable_disable, \
22464 "<intfc> | sw_if_index <nn> enable | disable") \
22465 _(l2tpv3_set_lookup_key, \
22466 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
22467 _(sw_if_l2tpv3_tunnel_dump, "") \
22468 _(vxlan_offload_rx, \
22469 "hw { <interface name> | hw_if_index <nn>} " \
22470 "rx { <vxlan tunnel name> | sw_if_index <nn> } [del]") \
22471 _(vxlan_add_del_tunnel, \
22472 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
22473 "{ <intfc> | mcast_sw_if_index <nn> } [instance <id>]}\n" \
22474 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
22475 _(geneve_add_del_tunnel, \
22476 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
22477 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22478 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
22479 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22480 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22481 _(gre_tunnel_add_del, \
22482 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [instance <n>]\n" \
22483 "[teb | erspan <session-id>] [del]") \
22484 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22485 _(l2_fib_clear_table, "") \
22486 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
22487 _(l2_interface_vlan_tag_rewrite, \
22488 "<intfc> | sw_if_index <nn> \n" \
22489 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
22490 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
22491 _(create_vhost_user_if, \
22492 "socket <filename> [server] [renumber <dev_instance>] " \
22493 "[disable_mrg_rxbuf] [disable_indirect_desc] " \
22494 "[mac <mac_address>]") \
22495 _(modify_vhost_user_if, \
22496 "<intfc> | sw_if_index <nn> socket <filename>\n" \
22497 "[server] [renumber <dev_instance>]") \
22498 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
22499 _(sw_interface_vhost_user_dump, "") \
22500 _(show_version, "") \
22501 _(show_threads, "") \
22502 _(vxlan_gpe_add_del_tunnel, \
22503 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
22504 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22505 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
22506 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
22507 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22508 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
22509 _(interface_name_renumber, \
22510 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
22511 _(input_acl_set_interface, \
22512 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22513 " [l2-table <nn>] [del]") \
22514 _(ip_probe_neighbor, "(<intc> | sw_if_index <nn>) address <ip4|ip6-addr>") \
22515 _(ip_scan_neighbor_enable_disable, "[ip4|ip6|both|disable] [interval <n-min>]\n" \
22516 " [max-time <n-usec>] [max-update <n>] [delay <n-msec>] [stale <n-min>]") \
22517 _(want_ip4_arp_events, "address <ip4-address> [del]") \
22518 _(want_ip6_nd_events, "address <ip6-address> [del]") \
22519 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
22520 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
22521 _(ip_dump, "ipv4 | ipv6") \
22522 _(ipsec_spd_add_del, "spd_id <n> [del]") \
22523 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
22525 _(ipsec_sad_entry_add_del, "sad_id <n> spi <n> crypto_alg <alg>\n" \
22526 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
22527 " integ_alg <alg> integ_key <hex>") \
22528 _(ipsec_spd_entry_add_del, "spd_id <n> priority <n> action <action>\n" \
22529 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
22530 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
22531 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
22532 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
22533 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
22534 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
22535 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
22536 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n" \
22537 " [instance <n>]") \
22538 _(ipsec_sa_dump, "[sa_id <n>]") \
22539 _(ipsec_tunnel_if_set_key, "<intfc> <local|remote> <crypto|integ>\n" \
22540 " <alg> <hex>\n") \
22541 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
22542 _(delete_loopback,"sw_if_index <nn>") \
22543 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
22544 _(bd_ip_mac_flush, "bd_id <bridge-domain-id>") \
22545 _(bd_ip_mac_dump, "[bd_id] <bridge-domain-id>") \
22546 _(want_interface_events, "enable|disable") \
22547 _(get_first_msg_id, "client <name>") \
22548 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
22549 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
22550 "fib-id <nn> [ip4][ip6][default]") \
22551 _(get_node_graph, " ") \
22552 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
22553 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
22554 _(ioam_disable, "") \
22555 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
22556 " sw_if_index <sw_if_index> p <priority> " \
22557 "w <weight>] [del]") \
22558 _(one_add_del_locator, "locator-set <locator_name> " \
22559 "iface <intf> | sw_if_index <sw_if_index> " \
22560 "p <priority> w <weight> [del]") \
22561 _(one_add_del_local_eid,"vni <vni> eid " \
22562 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22563 "locator-set <locator_name> [del]" \
22564 "[key-id sha1|sha256 secret-key <secret-key>]")\
22565 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
22566 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
22567 _(one_enable_disable, "enable|disable") \
22568 _(one_map_register_enable_disable, "enable|disable") \
22569 _(one_map_register_fallback_threshold, "<value>") \
22570 _(one_rloc_probe_enable_disable, "enable|disable") \
22571 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22573 "rloc <locator> p <prio> " \
22574 "w <weight> [rloc <loc> ... ] " \
22575 "action <action> [del-all]") \
22576 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22578 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22579 _(one_use_petr, "ip-address> | disable") \
22580 _(one_map_request_mode, "src-dst|dst-only") \
22581 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22582 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22583 _(one_locator_set_dump, "[local | remote]") \
22584 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
22585 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22586 "[local] | [remote]") \
22587 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
22588 _(one_ndp_bd_get, "") \
22589 _(one_ndp_entries_get, "bd <bridge-domain>") \
22590 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
22591 _(one_l2_arp_bd_get, "") \
22592 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
22593 _(one_stats_enable_disable, "enable|disable") \
22594 _(show_one_stats_enable_disable, "") \
22595 _(one_eid_table_vni_dump, "") \
22596 _(one_eid_table_map_dump, "l2|l3") \
22597 _(one_map_resolver_dump, "") \
22598 _(one_map_server_dump, "") \
22599 _(one_adjacencies_get, "vni <vni>") \
22600 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
22601 _(show_one_rloc_probe_state, "") \
22602 _(show_one_map_register_state, "") \
22603 _(show_one_status, "") \
22604 _(one_stats_dump, "") \
22605 _(one_stats_flush, "") \
22606 _(one_get_map_request_itr_rlocs, "") \
22607 _(one_map_register_set_ttl, "<ttl>") \
22608 _(one_set_transport_protocol, "udp|api") \
22609 _(one_get_transport_protocol, "") \
22610 _(one_enable_disable_xtr_mode, "enable|disable") \
22611 _(one_show_xtr_mode, "") \
22612 _(one_enable_disable_pitr_mode, "enable|disable") \
22613 _(one_show_pitr_mode, "") \
22614 _(one_enable_disable_petr_mode, "enable|disable") \
22615 _(one_show_petr_mode, "") \
22616 _(show_one_nsh_mapping, "") \
22617 _(show_one_pitr, "") \
22618 _(show_one_use_petr, "") \
22619 _(show_one_map_request_mode, "") \
22620 _(show_one_map_register_ttl, "") \
22621 _(show_one_map_register_fallback_threshold, "") \
22622 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
22623 " sw_if_index <sw_if_index> p <priority> " \
22624 "w <weight>] [del]") \
22625 _(lisp_add_del_locator, "locator-set <locator_name> " \
22626 "iface <intf> | sw_if_index <sw_if_index> " \
22627 "p <priority> w <weight> [del]") \
22628 _(lisp_add_del_local_eid,"vni <vni> eid " \
22629 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22630 "locator-set <locator_name> [del]" \
22631 "[key-id sha1|sha256 secret-key <secret-key>]") \
22632 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
22633 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
22634 _(lisp_enable_disable, "enable|disable") \
22635 _(lisp_map_register_enable_disable, "enable|disable") \
22636 _(lisp_rloc_probe_enable_disable, "enable|disable") \
22637 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22639 "rloc <locator> p <prio> " \
22640 "w <weight> [rloc <loc> ... ] " \
22641 "action <action> [del-all]") \
22642 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22644 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22645 _(lisp_use_petr, "<ip-address> | disable") \
22646 _(lisp_map_request_mode, "src-dst|dst-only") \
22647 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22648 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22649 _(lisp_locator_set_dump, "[local | remote]") \
22650 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
22651 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22652 "[local] | [remote]") \
22653 _(lisp_eid_table_vni_dump, "") \
22654 _(lisp_eid_table_map_dump, "l2|l3") \
22655 _(lisp_map_resolver_dump, "") \
22656 _(lisp_map_server_dump, "") \
22657 _(lisp_adjacencies_get, "vni <vni>") \
22658 _(gpe_fwd_entry_vnis_get, "") \
22659 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
22660 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
22661 "[table <table-id>]") \
22662 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
22663 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
22664 _(gpe_set_encap_mode, "lisp|vxlan") \
22665 _(gpe_get_encap_mode, "") \
22666 _(lisp_gpe_add_del_iface, "up|down") \
22667 _(lisp_gpe_enable_disable, "enable|disable") \
22668 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
22669 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
22670 _(show_lisp_rloc_probe_state, "") \
22671 _(show_lisp_map_register_state, "") \
22672 _(show_lisp_status, "") \
22673 _(lisp_get_map_request_itr_rlocs, "") \
22674 _(show_lisp_pitr, "") \
22675 _(show_lisp_use_petr, "") \
22676 _(show_lisp_map_request_mode, "") \
22677 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
22678 _(af_packet_delete, "name <host interface name>") \
22679 _(af_packet_dump, "") \
22680 _(policer_add_del, "name <policer name> <params> [del]") \
22681 _(policer_dump, "[name <policer name>]") \
22682 _(policer_classify_set_interface, \
22683 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22684 " [l2-table <nn>] [del]") \
22685 _(policer_classify_dump, "type [ip4|ip6|l2]") \
22686 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
22687 "[master|slave]") \
22688 _(netmap_delete, "name <interface name>") \
22689 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
22690 _(mpls_fib_dump, "") \
22691 _(classify_table_ids, "") \
22692 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
22693 _(classify_table_info, "table_id <nn>") \
22694 _(classify_session_dump, "table_id <nn>") \
22695 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
22696 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
22697 "[template_interval <nn>] [udp_checksum]") \
22698 _(ipfix_exporter_dump, "") \
22699 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
22700 _(ipfix_classify_stream_dump, "") \
22701 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
22702 _(ipfix_classify_table_dump, "") \
22703 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
22704 _(sw_interface_span_dump, "[l2]") \
22705 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
22706 _(pg_create_interface, "if_id <nn>") \
22707 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
22708 _(pg_enable_disable, "[stream <id>] disable") \
22709 _(ip_source_and_port_range_check_add_del, \
22710 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
22711 _(ip_source_and_port_range_check_interface_add_del, \
22712 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
22713 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
22714 _(ipsec_gre_tunnel_add_del, \
22715 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
22716 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
22717 _(delete_subif,"<intfc> | sw_if_index <nn>") \
22718 _(l2_interface_pbb_tag_rewrite, \
22719 "<intfc> | sw_if_index <nn> \n" \
22720 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
22721 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
22722 _(set_punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
22723 _(flow_classify_set_interface, \
22724 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
22725 _(flow_classify_dump, "type [ip4|ip6]") \
22726 _(ip_fib_dump, "") \
22727 _(ip_mfib_dump, "") \
22728 _(ip6_fib_dump, "") \
22729 _(ip6_mfib_dump, "") \
22730 _(feature_enable_disable, "arc_name <arc_name> " \
22731 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
22732 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
22734 _(l2_xconnect_dump, "") \
22735 _(hw_interface_set_mtu, "<intfc> | hw_if_index <nn> mtu <nn>") \
22736 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
22737 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
22738 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
22739 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
22740 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
22741 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
22742 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
22743 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
22744 _(sock_init_shm, "size <nnn>") \
22745 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
22746 _(dns_enable_disable, "[enable][disable]") \
22747 _(dns_name_server_add_del, "<ip-address> [del]") \
22748 _(dns_resolve_name, "<hostname>") \
22749 _(dns_resolve_ip, "<ip4|ip6>") \
22750 _(dns_name_server_add_del, "<ip-address> [del]") \
22751 _(dns_resolve_name, "<hostname>") \
22752 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
22753 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
22754 _(session_rules_dump, "") \
22755 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
22756 _(output_acl_set_interface, \
22757 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22758 " [l2-table <nn>] [del]") \
22759 _(qos_record_enable_disable, "<record-source> <intfc> | sw_if_index <id> [disable]")
22761 /* List of command functions, CLI names map directly to functions */
22762 #define foreach_cli_function \
22763 _(comment, "usage: comment <ignore-rest-of-line>") \
22764 _(dump_interface_table, "usage: dump_interface_table") \
22765 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
22766 _(dump_ipv4_table, "usage: dump_ipv4_table") \
22767 _(dump_ipv6_table, "usage: dump_ipv6_table") \
22768 _(dump_macro_table, "usage: dump_macro_table ") \
22769 _(dump_node_table, "usage: dump_node_table") \
22770 _(dump_msg_api_table, "usage: dump_msg_api_table") \
22771 _(get_msg_id, "usage: get_msg_id name_and_crc") \
22772 _(echo, "usage: echo <message>") \
22773 _(exec, "usage: exec <vpe-debug-CLI-command>") \
22774 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
22775 _(help, "usage: help") \
22776 _(q, "usage: quit") \
22777 _(quit, "usage: quit") \
22778 _(search_node_table, "usage: search_node_table <name>...") \
22779 _(set, "usage: set <variable-name> <value>") \
22780 _(script, "usage: script <file-name>") \
22781 _(statseg, "usage: statseg"); \
22782 _(unset, "usage: unset <variable-name>")
22785 static void vl_api_##n##_t_handler_uni \
22786 (vl_api_##n##_t * mp) \
22788 vat_main_t * vam = &vat_main; \
22789 if (vam->json_output) { \
22790 vl_api_##n##_t_handler_json(mp); \
22792 vl_api_##n##_t_handler(mp); \
22795 foreach_vpe_api_reply_msg;
22796 #if VPP_API_TEST_BUILTIN == 0
22797 foreach_standalone_reply_msg;
22802 vat_api_hookup (vat_main_t * vam)
22805 vl_msg_api_set_handlers(VL_API_##N, #n, \
22806 vl_api_##n##_t_handler_uni, \
22808 vl_api_##n##_t_endian, \
22809 vl_api_##n##_t_print, \
22810 sizeof(vl_api_##n##_t), 1);
22811 foreach_vpe_api_reply_msg;
22812 #if VPP_API_TEST_BUILTIN == 0
22813 foreach_standalone_reply_msg;
22817 #if (VPP_API_TEST_BUILTIN==0)
22818 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
22820 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
22822 vam->function_by_name = hash_create_string (0, sizeof (uword));
22824 vam->help_by_name = hash_create_string (0, sizeof (uword));
22827 /* API messages we can send */
22828 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
22829 foreach_vpe_api_msg;
22833 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
22834 foreach_vpe_api_msg;
22837 /* CLI functions */
22838 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
22839 foreach_cli_function;
22843 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
22844 foreach_cli_function;
22848 #if VPP_API_TEST_BUILTIN
22849 static clib_error_t *
22850 vat_api_hookup_shim (vlib_main_t * vm)
22852 vat_api_hookup (&vat_main);
22856 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
22860 * fd.io coding-style-patch-verification: ON
22863 * eval: (c-set-style "gnu")