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)
2702 s = format (0, "DHCP compl event: pid %d %s hostname %s host_addr %U "
2703 "host_mac %U router_addr %U",
2704 ntohl (mp->pid), mp->lease.is_ipv6 ? "ipv6" : "ipv4",
2706 format_ip4_address, mp->lease.host_address,
2707 format_ethernet_address, mp->lease.host_mac,
2708 format_ip4_address, mp->lease.router_address);
2710 for (i = 0; i < mp->lease.count; i++)
2712 format (s, " domain_server_addr %U", format_ip4_address,
2713 mp->lease.domain_server[i].address);
2715 errmsg ((char *) s);
2719 static void vl_api_dhcp_compl_event_t_handler_json
2720 (vl_api_dhcp_compl_event_t * mp)
2722 /* JSON output not supported */
2725 static void vl_api_get_first_msg_id_reply_t_handler
2726 (vl_api_get_first_msg_id_reply_t * mp)
2728 vat_main_t *vam = &vat_main;
2729 i32 retval = ntohl (mp->retval);
2731 if (vam->async_mode)
2733 vam->async_errors += (retval < 0);
2737 vam->retval = retval;
2738 vam->result_ready = 1;
2742 errmsg ("first message id %d", ntohs (mp->first_msg_id));
2746 static void vl_api_get_first_msg_id_reply_t_handler_json
2747 (vl_api_get_first_msg_id_reply_t * mp)
2749 vat_main_t *vam = &vat_main;
2750 vat_json_node_t node;
2752 vat_json_init_object (&node);
2753 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2754 vat_json_object_add_uint (&node, "first_msg_id",
2755 (uint) ntohs (mp->first_msg_id));
2757 vat_json_print (vam->ofp, &node);
2758 vat_json_free (&node);
2760 vam->retval = ntohl (mp->retval);
2761 vam->result_ready = 1;
2764 static void vl_api_get_node_graph_reply_t_handler
2765 (vl_api_get_node_graph_reply_t * mp)
2767 vat_main_t *vam = &vat_main;
2768 api_main_t *am = &api_main;
2769 i32 retval = ntohl (mp->retval);
2770 u8 *pvt_copy, *reply;
2775 if (vam->async_mode)
2777 vam->async_errors += (retval < 0);
2781 vam->retval = retval;
2782 vam->result_ready = 1;
2785 /* "Should never happen..." */
2789 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2790 pvt_copy = vec_dup (reply);
2792 /* Toss the shared-memory original... */
2793 pthread_mutex_lock (&am->vlib_rp->mutex);
2794 oldheap = svm_push_data_heap (am->vlib_rp);
2798 svm_pop_heap (oldheap);
2799 pthread_mutex_unlock (&am->vlib_rp->mutex);
2801 if (vam->graph_nodes)
2803 hash_free (vam->graph_node_index_by_name);
2805 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2807 node = vam->graph_nodes[0][i];
2808 vec_free (node->name);
2809 vec_free (node->next_nodes);
2812 vec_free (vam->graph_nodes[0]);
2813 vec_free (vam->graph_nodes);
2816 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2817 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2818 vec_free (pvt_copy);
2820 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2822 node = vam->graph_nodes[0][i];
2823 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2827 static void vl_api_get_node_graph_reply_t_handler_json
2828 (vl_api_get_node_graph_reply_t * mp)
2830 vat_main_t *vam = &vat_main;
2831 api_main_t *am = &api_main;
2833 vat_json_node_t node;
2836 /* $$$$ make this real? */
2837 vat_json_init_object (&node);
2838 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2839 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2841 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2843 /* Toss the shared-memory original... */
2844 pthread_mutex_lock (&am->vlib_rp->mutex);
2845 oldheap = svm_push_data_heap (am->vlib_rp);
2849 svm_pop_heap (oldheap);
2850 pthread_mutex_unlock (&am->vlib_rp->mutex);
2852 vat_json_print (vam->ofp, &node);
2853 vat_json_free (&node);
2855 vam->retval = ntohl (mp->retval);
2856 vam->result_ready = 1;
2860 vl_api_one_locator_details_t_handler (vl_api_one_locator_details_t * mp)
2862 vat_main_t *vam = &vat_main;
2867 s = format (s, "%=16d%=16d%=16d",
2868 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2872 s = format (s, "%=16U%=16d%=16d",
2873 mp->is_ipv6 ? format_ip6_address :
2875 mp->ip_address, mp->priority, mp->weight);
2878 print (vam->ofp, "%v", s);
2883 vl_api_one_locator_details_t_handler_json (vl_api_one_locator_details_t * mp)
2885 vat_main_t *vam = &vat_main;
2886 vat_json_node_t *node = NULL;
2887 struct in6_addr ip6;
2890 if (VAT_JSON_ARRAY != vam->json_tree.type)
2892 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2893 vat_json_init_array (&vam->json_tree);
2895 node = vat_json_array_add (&vam->json_tree);
2896 vat_json_init_object (node);
2898 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2899 vat_json_object_add_uint (node, "priority", mp->priority);
2900 vat_json_object_add_uint (node, "weight", mp->weight);
2903 vat_json_object_add_uint (node, "sw_if_index",
2904 clib_net_to_host_u32 (mp->sw_if_index));
2909 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2910 vat_json_object_add_ip6 (node, "address", ip6);
2914 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2915 vat_json_object_add_ip4 (node, "address", ip4);
2921 vl_api_one_locator_set_details_t_handler (vl_api_one_locator_set_details_t *
2924 vat_main_t *vam = &vat_main;
2927 ls_name = format (0, "%s", mp->ls_name);
2929 print (vam->ofp, "%=10d%=15v", clib_net_to_host_u32 (mp->ls_index),
2935 vl_api_one_locator_set_details_t_handler_json
2936 (vl_api_one_locator_set_details_t * mp)
2938 vat_main_t *vam = &vat_main;
2939 vat_json_node_t *node = 0;
2942 ls_name = format (0, "%s", mp->ls_name);
2943 vec_add1 (ls_name, 0);
2945 if (VAT_JSON_ARRAY != vam->json_tree.type)
2947 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2948 vat_json_init_array (&vam->json_tree);
2950 node = vat_json_array_add (&vam->json_tree);
2952 vat_json_init_object (node);
2953 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2954 vat_json_object_add_uint (node, "ls_index",
2955 clib_net_to_host_u32 (mp->ls_index));
2963 } __attribute__ ((__packed__)) lisp_nsh_api_t;
2966 unformat_nsh_address (unformat_input_t * input, va_list * args)
2968 lisp_nsh_api_t *nsh = va_arg (*args, lisp_nsh_api_t *);
2969 return unformat (input, "SPI:%d SI:%d", &nsh->spi, &nsh->si);
2973 format_nsh_address_vat (u8 * s, va_list * args)
2975 nsh_t *a = va_arg (*args, nsh_t *);
2976 return format (s, "SPI:%d SI:%d", clib_net_to_host_u32 (a->spi), a->si);
2980 format_lisp_flat_eid (u8 * s, va_list * args)
2982 u32 type = va_arg (*args, u32);
2983 u8 *eid = va_arg (*args, u8 *);
2984 u32 eid_len = va_arg (*args, u32);
2989 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
2991 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
2993 return format (s, "%U", format_ethernet_address, eid);
2995 return format (s, "%U", format_nsh_address_vat, eid);
3001 format_lisp_eid_vat (u8 * s, va_list * args)
3003 u32 type = va_arg (*args, u32);
3004 u8 *eid = va_arg (*args, u8 *);
3005 u32 eid_len = va_arg (*args, u32);
3006 u8 *seid = va_arg (*args, u8 *);
3007 u32 seid_len = va_arg (*args, u32);
3008 u32 is_src_dst = va_arg (*args, u32);
3011 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
3013 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
3019 vl_api_one_eid_table_details_t_handler (vl_api_one_eid_table_details_t * mp)
3021 vat_main_t *vam = &vat_main;
3022 u8 *s = 0, *eid = 0;
3024 if (~0 == mp->locator_set_index)
3025 s = format (0, "action: %d", mp->action);
3027 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
3029 eid = format (0, "%U", format_lisp_eid_vat,
3033 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
3036 print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
3037 clib_net_to_host_u32 (mp->vni),
3039 mp->is_local ? "local" : "remote",
3040 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
3041 clib_net_to_host_u16 (mp->key_id), mp->key);
3048 vl_api_one_eid_table_details_t_handler_json (vl_api_one_eid_table_details_t
3051 vat_main_t *vam = &vat_main;
3052 vat_json_node_t *node = 0;
3055 if (VAT_JSON_ARRAY != vam->json_tree.type)
3057 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3058 vat_json_init_array (&vam->json_tree);
3060 node = vat_json_array_add (&vam->json_tree);
3062 vat_json_init_object (node);
3063 if (~0 == mp->locator_set_index)
3064 vat_json_object_add_uint (node, "action", mp->action);
3066 vat_json_object_add_uint (node, "locator_set_index",
3067 clib_net_to_host_u32 (mp->locator_set_index));
3069 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
3070 if (mp->eid_type == 3)
3072 vat_json_node_t *nsh_json = vat_json_object_add (node, "eid");
3073 vat_json_init_object (nsh_json);
3074 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) mp->eid;
3075 vat_json_object_add_uint (nsh_json, "spi",
3076 clib_net_to_host_u32 (nsh->spi));
3077 vat_json_object_add_uint (nsh_json, "si", nsh->si);
3081 eid = format (0, "%U", format_lisp_eid_vat,
3085 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
3087 vat_json_object_add_string_copy (node, "eid", eid);
3090 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3091 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
3092 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
3096 vat_json_object_add_uint (node, "key_id",
3097 clib_net_to_host_u16 (mp->key_id));
3098 vat_json_object_add_string_copy (node, "key", mp->key);
3103 vl_api_one_stats_details_t_handler (vl_api_one_stats_details_t * mp)
3105 vat_main_t *vam = &vat_main;
3106 u8 *seid = 0, *deid = 0;
3107 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3109 deid = format (0, "%U", format_lisp_eid_vat,
3110 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3112 seid = format (0, "%U", format_lisp_eid_vat,
3113 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3119 format_ip_address_fcn = format_ip4_address;
3121 format_ip_address_fcn = format_ip6_address;
3124 print (vam->ofp, "([%d] %s %s) (%U %U) %u %u",
3125 clib_net_to_host_u32 (mp->vni),
3127 format_ip_address_fcn, mp->lloc,
3128 format_ip_address_fcn, mp->rloc,
3129 clib_net_to_host_u32 (mp->pkt_count),
3130 clib_net_to_host_u32 (mp->bytes));
3137 vl_api_one_stats_details_t_handler_json (vl_api_one_stats_details_t * mp)
3139 struct in6_addr ip6;
3141 vat_main_t *vam = &vat_main;
3142 vat_json_node_t *node = 0;
3143 u8 *deid = 0, *seid = 0;
3145 if (VAT_JSON_ARRAY != vam->json_tree.type)
3147 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3148 vat_json_init_array (&vam->json_tree);
3150 node = vat_json_array_add (&vam->json_tree);
3152 vat_json_init_object (node);
3153 deid = format (0, "%U", format_lisp_eid_vat,
3154 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3156 seid = format (0, "%U", format_lisp_eid_vat,
3157 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3162 vat_json_object_add_string_copy (node, "seid", seid);
3163 vat_json_object_add_string_copy (node, "deid", deid);
3164 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3168 clib_memcpy (&ip4, mp->lloc, sizeof (ip4));
3169 vat_json_object_add_ip4 (node, "lloc", ip4);
3170 clib_memcpy (&ip4, mp->rloc, sizeof (ip4));
3171 vat_json_object_add_ip4 (node, "rloc", ip4);
3175 clib_memcpy (&ip6, mp->lloc, sizeof (ip6));
3176 vat_json_object_add_ip6 (node, "lloc", ip6);
3177 clib_memcpy (&ip6, mp->rloc, sizeof (ip6));
3178 vat_json_object_add_ip6 (node, "rloc", ip6);
3180 vat_json_object_add_uint (node, "pkt_count",
3181 clib_net_to_host_u32 (mp->pkt_count));
3182 vat_json_object_add_uint (node, "bytes", clib_net_to_host_u32 (mp->bytes));
3189 vl_api_one_eid_table_map_details_t_handler
3190 (vl_api_one_eid_table_map_details_t * mp)
3192 vat_main_t *vam = &vat_main;
3194 u8 *line = format (0, "%=10d%=10d",
3195 clib_net_to_host_u32 (mp->vni),
3196 clib_net_to_host_u32 (mp->dp_table));
3197 print (vam->ofp, "%v", line);
3202 vl_api_one_eid_table_map_details_t_handler_json
3203 (vl_api_one_eid_table_map_details_t * mp)
3205 vat_main_t *vam = &vat_main;
3206 vat_json_node_t *node = NULL;
3208 if (VAT_JSON_ARRAY != vam->json_tree.type)
3210 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3211 vat_json_init_array (&vam->json_tree);
3213 node = vat_json_array_add (&vam->json_tree);
3214 vat_json_init_object (node);
3215 vat_json_object_add_uint (node, "dp_table",
3216 clib_net_to_host_u32 (mp->dp_table));
3217 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3221 vl_api_one_eid_table_vni_details_t_handler
3222 (vl_api_one_eid_table_vni_details_t * mp)
3224 vat_main_t *vam = &vat_main;
3226 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
3227 print (vam->ofp, "%v", line);
3232 vl_api_one_eid_table_vni_details_t_handler_json
3233 (vl_api_one_eid_table_vni_details_t * mp)
3235 vat_main_t *vam = &vat_main;
3236 vat_json_node_t *node = NULL;
3238 if (VAT_JSON_ARRAY != vam->json_tree.type)
3240 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3241 vat_json_init_array (&vam->json_tree);
3243 node = vat_json_array_add (&vam->json_tree);
3244 vat_json_init_object (node);
3245 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3249 vl_api_show_one_map_register_fallback_threshold_reply_t_handler
3250 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3252 vat_main_t *vam = &vat_main;
3253 int retval = clib_net_to_host_u32 (mp->retval);
3255 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3256 print (vam->ofp, "fallback threshold value: %d", mp->value);
3258 vam->retval = retval;
3259 vam->result_ready = 1;
3263 vl_api_show_one_map_register_fallback_threshold_reply_t_handler_json
3264 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3266 vat_main_t *vam = &vat_main;
3267 vat_json_node_t _node, *node = &_node;
3268 int retval = clib_net_to_host_u32 (mp->retval);
3270 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3271 vat_json_init_object (node);
3272 vat_json_object_add_uint (node, "value", mp->value);
3274 vat_json_print (vam->ofp, node);
3275 vat_json_free (node);
3277 vam->retval = retval;
3278 vam->result_ready = 1;
3282 vl_api_show_one_map_register_state_reply_t_handler
3283 (vl_api_show_one_map_register_state_reply_t * mp)
3285 vat_main_t *vam = &vat_main;
3286 int retval = clib_net_to_host_u32 (mp->retval);
3288 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3290 vam->retval = retval;
3291 vam->result_ready = 1;
3295 vl_api_show_one_map_register_state_reply_t_handler_json
3296 (vl_api_show_one_map_register_state_reply_t * mp)
3298 vat_main_t *vam = &vat_main;
3299 vat_json_node_t _node, *node = &_node;
3300 int retval = clib_net_to_host_u32 (mp->retval);
3302 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3304 vat_json_init_object (node);
3305 vat_json_object_add_string_copy (node, "state", s);
3307 vat_json_print (vam->ofp, node);
3308 vat_json_free (node);
3310 vam->retval = retval;
3311 vam->result_ready = 1;
3316 vl_api_show_one_rloc_probe_state_reply_t_handler
3317 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3319 vat_main_t *vam = &vat_main;
3320 int retval = clib_net_to_host_u32 (mp->retval);
3325 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3327 vam->retval = retval;
3328 vam->result_ready = 1;
3332 vl_api_show_one_rloc_probe_state_reply_t_handler_json
3333 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3335 vat_main_t *vam = &vat_main;
3336 vat_json_node_t _node, *node = &_node;
3337 int retval = clib_net_to_host_u32 (mp->retval);
3339 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3340 vat_json_init_object (node);
3341 vat_json_object_add_string_copy (node, "state", s);
3343 vat_json_print (vam->ofp, node);
3344 vat_json_free (node);
3346 vam->retval = retval;
3347 vam->result_ready = 1;
3352 vl_api_show_one_stats_enable_disable_reply_t_handler
3353 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3355 vat_main_t *vam = &vat_main;
3356 int retval = clib_net_to_host_u32 (mp->retval);
3361 print (vam->ofp, "%s", mp->is_en ? "enabled" : "disabled");
3363 vam->retval = retval;
3364 vam->result_ready = 1;
3368 vl_api_show_one_stats_enable_disable_reply_t_handler_json
3369 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3371 vat_main_t *vam = &vat_main;
3372 vat_json_node_t _node, *node = &_node;
3373 int retval = clib_net_to_host_u32 (mp->retval);
3375 u8 *s = format (0, "%s", mp->is_en ? "enabled" : "disabled");
3376 vat_json_init_object (node);
3377 vat_json_object_add_string_copy (node, "state", s);
3379 vat_json_print (vam->ofp, node);
3380 vat_json_free (node);
3382 vam->retval = retval;
3383 vam->result_ready = 1;
3388 api_gpe_fwd_entry_net_to_host (vl_api_gpe_fwd_entry_t * e)
3390 e->dp_table = clib_net_to_host_u32 (e->dp_table);
3391 e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
3392 e->vni = clib_net_to_host_u32 (e->vni);
3396 gpe_fwd_entries_get_reply_t_net_to_host
3397 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3401 mp->count = clib_net_to_host_u32 (mp->count);
3402 for (i = 0; i < mp->count; i++)
3404 api_gpe_fwd_entry_net_to_host (&mp->entries[i]);
3409 format_gpe_encap_mode (u8 * s, va_list * args)
3411 u32 mode = va_arg (*args, u32);
3416 return format (s, "lisp");
3418 return format (s, "vxlan");
3424 vl_api_gpe_get_encap_mode_reply_t_handler
3425 (vl_api_gpe_get_encap_mode_reply_t * mp)
3427 vat_main_t *vam = &vat_main;
3429 print (vam->ofp, "gpe mode: %U", format_gpe_encap_mode, mp->encap_mode);
3430 vam->retval = ntohl (mp->retval);
3431 vam->result_ready = 1;
3435 vl_api_gpe_get_encap_mode_reply_t_handler_json
3436 (vl_api_gpe_get_encap_mode_reply_t * mp)
3438 vat_main_t *vam = &vat_main;
3439 vat_json_node_t node;
3441 u8 *encap_mode = format (0, "%U", format_gpe_encap_mode, mp->encap_mode);
3442 vec_add1 (encap_mode, 0);
3444 vat_json_init_object (&node);
3445 vat_json_object_add_string_copy (&node, "gpe_mode", encap_mode);
3447 vec_free (encap_mode);
3448 vat_json_print (vam->ofp, &node);
3449 vat_json_free (&node);
3451 vam->retval = ntohl (mp->retval);
3452 vam->result_ready = 1;
3456 vl_api_gpe_fwd_entry_path_details_t_handler
3457 (vl_api_gpe_fwd_entry_path_details_t * mp)
3459 vat_main_t *vam = &vat_main;
3460 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3462 if (mp->lcl_loc.is_ip4)
3463 format_ip_address_fcn = format_ip4_address;
3465 format_ip_address_fcn = format_ip6_address;
3467 print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
3468 format_ip_address_fcn, &mp->lcl_loc,
3469 format_ip_address_fcn, &mp->rmt_loc);
3473 lisp_fill_locator_node (vat_json_node_t * n, vl_api_gpe_locator_t * loc)
3475 struct in6_addr ip6;
3480 clib_memcpy (&ip4, loc->addr, sizeof (ip4));
3481 vat_json_object_add_ip4 (n, "address", ip4);
3485 clib_memcpy (&ip6, loc->addr, sizeof (ip6));
3486 vat_json_object_add_ip6 (n, "address", ip6);
3488 vat_json_object_add_uint (n, "weight", loc->weight);
3492 vl_api_gpe_fwd_entry_path_details_t_handler_json
3493 (vl_api_gpe_fwd_entry_path_details_t * mp)
3495 vat_main_t *vam = &vat_main;
3496 vat_json_node_t *node = NULL;
3497 vat_json_node_t *loc_node;
3499 if (VAT_JSON_ARRAY != vam->json_tree.type)
3501 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3502 vat_json_init_array (&vam->json_tree);
3504 node = vat_json_array_add (&vam->json_tree);
3505 vat_json_init_object (node);
3507 loc_node = vat_json_object_add (node, "local_locator");
3508 vat_json_init_object (loc_node);
3509 lisp_fill_locator_node (loc_node, &mp->lcl_loc);
3511 loc_node = vat_json_object_add (node, "remote_locator");
3512 vat_json_init_object (loc_node);
3513 lisp_fill_locator_node (loc_node, &mp->rmt_loc);
3517 vl_api_gpe_fwd_entries_get_reply_t_handler
3518 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3520 vat_main_t *vam = &vat_main;
3522 int retval = clib_net_to_host_u32 (mp->retval);
3523 vl_api_gpe_fwd_entry_t *e;
3528 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3530 for (i = 0; i < mp->count; i++)
3532 e = &mp->entries[i];
3533 print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
3534 format_lisp_flat_eid, e->eid_type, e->leid, e->leid_prefix_len,
3535 format_lisp_flat_eid, e->eid_type, e->reid, e->reid_prefix_len);
3539 vam->retval = retval;
3540 vam->result_ready = 1;
3544 vl_api_gpe_fwd_entries_get_reply_t_handler_json
3545 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3548 vat_main_t *vam = &vat_main;
3549 vat_json_node_t *e = 0, root;
3551 int retval = clib_net_to_host_u32 (mp->retval);
3552 vl_api_gpe_fwd_entry_t *fwd;
3557 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3558 vat_json_init_array (&root);
3560 for (i = 0; i < mp->count; i++)
3562 e = vat_json_array_add (&root);
3563 fwd = &mp->entries[i];
3565 vat_json_init_object (e);
3566 vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
3567 vat_json_object_add_int (e, "dp_table", fwd->dp_table);
3568 vat_json_object_add_int (e, "vni", fwd->vni);
3569 vat_json_object_add_int (e, "action", fwd->action);
3571 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->leid,
3572 fwd->leid_prefix_len);
3574 vat_json_object_add_string_copy (e, "leid", s);
3577 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->reid,
3578 fwd->reid_prefix_len);
3580 vat_json_object_add_string_copy (e, "reid", s);
3584 vat_json_print (vam->ofp, &root);
3585 vat_json_free (&root);
3588 vam->retval = retval;
3589 vam->result_ready = 1;
3593 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler
3594 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3596 vat_main_t *vam = &vat_main;
3598 int retval = clib_net_to_host_u32 (mp->retval);
3599 vl_api_gpe_native_fwd_rpath_t *r;
3604 n = clib_net_to_host_u32 (mp->count);
3606 for (i = 0; i < n; i++)
3608 r = &mp->entries[i];
3609 print (vam->ofp, "fib_index: %d sw_if_index %d nh %U",
3610 clib_net_to_host_u32 (r->fib_index),
3611 clib_net_to_host_u32 (r->nh_sw_if_index),
3612 r->is_ip4 ? format_ip4_address : format_ip6_address, r->nh_addr);
3616 vam->retval = retval;
3617 vam->result_ready = 1;
3621 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler_json
3622 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3624 vat_main_t *vam = &vat_main;
3625 vat_json_node_t root, *e;
3627 int retval = clib_net_to_host_u32 (mp->retval);
3628 vl_api_gpe_native_fwd_rpath_t *r;
3634 n = clib_net_to_host_u32 (mp->count);
3635 vat_json_init_array (&root);
3637 for (i = 0; i < n; i++)
3639 e = vat_json_array_add (&root);
3640 vat_json_init_object (e);
3641 r = &mp->entries[i];
3643 format (0, "%U", r->is_ip4 ? format_ip4_address : format_ip6_address,
3646 vat_json_object_add_string_copy (e, "ip4", s);
3649 vat_json_object_add_uint (e, "fib_index",
3650 clib_net_to_host_u32 (r->fib_index));
3651 vat_json_object_add_uint (e, "nh_sw_if_index",
3652 clib_net_to_host_u32 (r->nh_sw_if_index));
3655 vat_json_print (vam->ofp, &root);
3656 vat_json_free (&root);
3659 vam->retval = retval;
3660 vam->result_ready = 1;
3664 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler
3665 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3667 vat_main_t *vam = &vat_main;
3669 int retval = clib_net_to_host_u32 (mp->retval);
3674 n = clib_net_to_host_u32 (mp->count);
3676 for (i = 0; i < n; i++)
3677 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->vnis[i]));
3680 vam->retval = retval;
3681 vam->result_ready = 1;
3685 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler_json
3686 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3688 vat_main_t *vam = &vat_main;
3689 vat_json_node_t root;
3691 int retval = clib_net_to_host_u32 (mp->retval);
3696 n = clib_net_to_host_u32 (mp->count);
3697 vat_json_init_array (&root);
3699 for (i = 0; i < n; i++)
3700 vat_json_array_add_uint (&root, clib_net_to_host_u32 (mp->vnis[i]));
3702 vat_json_print (vam->ofp, &root);
3703 vat_json_free (&root);
3706 vam->retval = retval;
3707 vam->result_ready = 1;
3711 vl_api_one_ndp_entries_get_reply_t_handler
3712 (vl_api_one_ndp_entries_get_reply_t * mp)
3714 vat_main_t *vam = &vat_main;
3716 int retval = clib_net_to_host_u32 (mp->retval);
3721 n = clib_net_to_host_u32 (mp->count);
3723 for (i = 0; i < n; i++)
3724 print (vam->ofp, "%U -> %U", format_ip6_address, &mp->entries[i].ip6,
3725 format_ethernet_address, mp->entries[i].mac);
3728 vam->retval = retval;
3729 vam->result_ready = 1;
3733 vl_api_one_ndp_entries_get_reply_t_handler_json
3734 (vl_api_one_ndp_entries_get_reply_t * mp)
3737 vat_main_t *vam = &vat_main;
3738 vat_json_node_t *e = 0, root;
3740 int retval = clib_net_to_host_u32 (mp->retval);
3741 vl_api_one_ndp_entry_t *arp_entry;
3746 n = clib_net_to_host_u32 (mp->count);
3747 vat_json_init_array (&root);
3749 for (i = 0; i < n; i++)
3751 e = vat_json_array_add (&root);
3752 arp_entry = &mp->entries[i];
3754 vat_json_init_object (e);
3755 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3758 vat_json_object_add_string_copy (e, "mac", s);
3761 s = format (0, "%U", format_ip6_address, &arp_entry->ip6);
3763 vat_json_object_add_string_copy (e, "ip6", s);
3767 vat_json_print (vam->ofp, &root);
3768 vat_json_free (&root);
3771 vam->retval = retval;
3772 vam->result_ready = 1;
3776 vl_api_one_l2_arp_entries_get_reply_t_handler
3777 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3779 vat_main_t *vam = &vat_main;
3781 int retval = clib_net_to_host_u32 (mp->retval);
3786 n = clib_net_to_host_u32 (mp->count);
3788 for (i = 0; i < n; i++)
3789 print (vam->ofp, "%U -> %U", format_ip4_address, &mp->entries[i].ip4,
3790 format_ethernet_address, mp->entries[i].mac);
3793 vam->retval = retval;
3794 vam->result_ready = 1;
3798 vl_api_one_l2_arp_entries_get_reply_t_handler_json
3799 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3802 vat_main_t *vam = &vat_main;
3803 vat_json_node_t *e = 0, root;
3805 int retval = clib_net_to_host_u32 (mp->retval);
3806 vl_api_one_l2_arp_entry_t *arp_entry;
3811 n = clib_net_to_host_u32 (mp->count);
3812 vat_json_init_array (&root);
3814 for (i = 0; i < n; i++)
3816 e = vat_json_array_add (&root);
3817 arp_entry = &mp->entries[i];
3819 vat_json_init_object (e);
3820 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3823 vat_json_object_add_string_copy (e, "mac", s);
3826 s = format (0, "%U", format_ip4_address, &arp_entry->ip4);
3828 vat_json_object_add_string_copy (e, "ip4", s);
3832 vat_json_print (vam->ofp, &root);
3833 vat_json_free (&root);
3836 vam->retval = retval;
3837 vam->result_ready = 1;
3841 vl_api_one_ndp_bd_get_reply_t_handler (vl_api_one_ndp_bd_get_reply_t * mp)
3843 vat_main_t *vam = &vat_main;
3845 int retval = clib_net_to_host_u32 (mp->retval);
3850 n = clib_net_to_host_u32 (mp->count);
3852 for (i = 0; i < n; i++)
3854 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3858 vam->retval = retval;
3859 vam->result_ready = 1;
3863 vl_api_one_ndp_bd_get_reply_t_handler_json
3864 (vl_api_one_ndp_bd_get_reply_t * mp)
3866 vat_main_t *vam = &vat_main;
3867 vat_json_node_t root;
3869 int retval = clib_net_to_host_u32 (mp->retval);
3874 n = clib_net_to_host_u32 (mp->count);
3875 vat_json_init_array (&root);
3877 for (i = 0; i < n; i++)
3879 vat_json_array_add_uint (&root,
3880 clib_net_to_host_u32 (mp->bridge_domains[i]));
3883 vat_json_print (vam->ofp, &root);
3884 vat_json_free (&root);
3887 vam->retval = retval;
3888 vam->result_ready = 1;
3892 vl_api_one_l2_arp_bd_get_reply_t_handler
3893 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3895 vat_main_t *vam = &vat_main;
3897 int retval = clib_net_to_host_u32 (mp->retval);
3902 n = clib_net_to_host_u32 (mp->count);
3904 for (i = 0; i < n; i++)
3906 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3910 vam->retval = retval;
3911 vam->result_ready = 1;
3915 vl_api_one_l2_arp_bd_get_reply_t_handler_json
3916 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3918 vat_main_t *vam = &vat_main;
3919 vat_json_node_t root;
3921 int retval = clib_net_to_host_u32 (mp->retval);
3926 n = clib_net_to_host_u32 (mp->count);
3927 vat_json_init_array (&root);
3929 for (i = 0; i < n; i++)
3931 vat_json_array_add_uint (&root,
3932 clib_net_to_host_u32 (mp->bridge_domains[i]));
3935 vat_json_print (vam->ofp, &root);
3936 vat_json_free (&root);
3939 vam->retval = retval;
3940 vam->result_ready = 1;
3944 vl_api_one_adjacencies_get_reply_t_handler
3945 (vl_api_one_adjacencies_get_reply_t * mp)
3947 vat_main_t *vam = &vat_main;
3949 int retval = clib_net_to_host_u32 (mp->retval);
3950 vl_api_one_adjacency_t *a;
3955 n = clib_net_to_host_u32 (mp->count);
3957 for (i = 0; i < n; i++)
3959 a = &mp->adjacencies[i];
3960 print (vam->ofp, "%U %40U",
3961 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
3962 format_lisp_flat_eid, a->eid_type, a->reid, a->reid_prefix_len);
3966 vam->retval = retval;
3967 vam->result_ready = 1;
3971 vl_api_one_adjacencies_get_reply_t_handler_json
3972 (vl_api_one_adjacencies_get_reply_t * mp)
3975 vat_main_t *vam = &vat_main;
3976 vat_json_node_t *e = 0, root;
3978 int retval = clib_net_to_host_u32 (mp->retval);
3979 vl_api_one_adjacency_t *a;
3984 n = clib_net_to_host_u32 (mp->count);
3985 vat_json_init_array (&root);
3987 for (i = 0; i < n; i++)
3989 e = vat_json_array_add (&root);
3990 a = &mp->adjacencies[i];
3992 vat_json_init_object (e);
3993 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
3994 a->leid_prefix_len);
3996 vat_json_object_add_string_copy (e, "leid", s);
3999 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
4000 a->reid_prefix_len);
4002 vat_json_object_add_string_copy (e, "reid", s);
4006 vat_json_print (vam->ofp, &root);
4007 vat_json_free (&root);
4010 vam->retval = retval;
4011 vam->result_ready = 1;
4015 vl_api_one_map_server_details_t_handler (vl_api_one_map_server_details_t * mp)
4017 vat_main_t *vam = &vat_main;
4019 print (vam->ofp, "%=20U",
4020 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
4025 vl_api_one_map_server_details_t_handler_json
4026 (vl_api_one_map_server_details_t * mp)
4028 vat_main_t *vam = &vat_main;
4029 vat_json_node_t *node = NULL;
4030 struct in6_addr ip6;
4033 if (VAT_JSON_ARRAY != vam->json_tree.type)
4035 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4036 vat_json_init_array (&vam->json_tree);
4038 node = vat_json_array_add (&vam->json_tree);
4040 vat_json_init_object (node);
4043 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
4044 vat_json_object_add_ip6 (node, "map-server", ip6);
4048 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
4049 vat_json_object_add_ip4 (node, "map-server", ip4);
4054 vl_api_one_map_resolver_details_t_handler (vl_api_one_map_resolver_details_t
4057 vat_main_t *vam = &vat_main;
4059 print (vam->ofp, "%=20U",
4060 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
4065 vl_api_one_map_resolver_details_t_handler_json
4066 (vl_api_one_map_resolver_details_t * mp)
4068 vat_main_t *vam = &vat_main;
4069 vat_json_node_t *node = NULL;
4070 struct in6_addr ip6;
4073 if (VAT_JSON_ARRAY != vam->json_tree.type)
4075 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4076 vat_json_init_array (&vam->json_tree);
4078 node = vat_json_array_add (&vam->json_tree);
4080 vat_json_init_object (node);
4083 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
4084 vat_json_object_add_ip6 (node, "map resolver", ip6);
4088 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
4089 vat_json_object_add_ip4 (node, "map resolver", ip4);
4094 vl_api_show_one_status_reply_t_handler (vl_api_show_one_status_reply_t * mp)
4096 vat_main_t *vam = &vat_main;
4097 i32 retval = ntohl (mp->retval);
4101 print (vam->ofp, "feature: %s\ngpe: %s",
4102 mp->feature_status ? "enabled" : "disabled",
4103 mp->gpe_status ? "enabled" : "disabled");
4106 vam->retval = retval;
4107 vam->result_ready = 1;
4111 vl_api_show_one_status_reply_t_handler_json
4112 (vl_api_show_one_status_reply_t * mp)
4114 vat_main_t *vam = &vat_main;
4115 vat_json_node_t node;
4116 u8 *gpe_status = NULL;
4117 u8 *feature_status = NULL;
4119 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
4120 feature_status = format (0, "%s",
4121 mp->feature_status ? "enabled" : "disabled");
4122 vec_add1 (gpe_status, 0);
4123 vec_add1 (feature_status, 0);
4125 vat_json_init_object (&node);
4126 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
4127 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
4129 vec_free (gpe_status);
4130 vec_free (feature_status);
4132 vat_json_print (vam->ofp, &node);
4133 vat_json_free (&node);
4135 vam->retval = ntohl (mp->retval);
4136 vam->result_ready = 1;
4140 vl_api_one_get_map_request_itr_rlocs_reply_t_handler
4141 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4143 vat_main_t *vam = &vat_main;
4144 i32 retval = ntohl (mp->retval);
4148 print (vam->ofp, "%=20s", mp->locator_set_name);
4151 vam->retval = retval;
4152 vam->result_ready = 1;
4156 vl_api_one_get_map_request_itr_rlocs_reply_t_handler_json
4157 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4159 vat_main_t *vam = &vat_main;
4160 vat_json_node_t *node = NULL;
4162 if (VAT_JSON_ARRAY != vam->json_tree.type)
4164 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4165 vat_json_init_array (&vam->json_tree);
4167 node = vat_json_array_add (&vam->json_tree);
4169 vat_json_init_object (node);
4170 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
4172 vat_json_print (vam->ofp, node);
4173 vat_json_free (node);
4175 vam->retval = ntohl (mp->retval);
4176 vam->result_ready = 1;
4180 format_lisp_map_request_mode (u8 * s, va_list * args)
4182 u32 mode = va_arg (*args, u32);
4187 return format (0, "dst-only");
4189 return format (0, "src-dst");
4195 vl_api_show_one_map_request_mode_reply_t_handler
4196 (vl_api_show_one_map_request_mode_reply_t * mp)
4198 vat_main_t *vam = &vat_main;
4199 i32 retval = ntohl (mp->retval);
4203 u32 mode = mp->mode;
4204 print (vam->ofp, "map_request_mode: %U",
4205 format_lisp_map_request_mode, mode);
4208 vam->retval = retval;
4209 vam->result_ready = 1;
4213 vl_api_show_one_map_request_mode_reply_t_handler_json
4214 (vl_api_show_one_map_request_mode_reply_t * mp)
4216 vat_main_t *vam = &vat_main;
4217 vat_json_node_t node;
4222 s = format (0, "%U", format_lisp_map_request_mode, mode);
4225 vat_json_init_object (&node);
4226 vat_json_object_add_string_copy (&node, "map_request_mode", s);
4227 vat_json_print (vam->ofp, &node);
4228 vat_json_free (&node);
4231 vam->retval = ntohl (mp->retval);
4232 vam->result_ready = 1;
4236 vl_api_one_show_xtr_mode_reply_t_handler
4237 (vl_api_one_show_xtr_mode_reply_t * mp)
4239 vat_main_t *vam = &vat_main;
4240 i32 retval = ntohl (mp->retval);
4244 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4247 vam->retval = retval;
4248 vam->result_ready = 1;
4252 vl_api_one_show_xtr_mode_reply_t_handler_json
4253 (vl_api_one_show_xtr_mode_reply_t * mp)
4255 vat_main_t *vam = &vat_main;
4256 vat_json_node_t node;
4259 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4260 vec_add1 (status, 0);
4262 vat_json_init_object (&node);
4263 vat_json_object_add_string_copy (&node, "status", status);
4267 vat_json_print (vam->ofp, &node);
4268 vat_json_free (&node);
4270 vam->retval = ntohl (mp->retval);
4271 vam->result_ready = 1;
4275 vl_api_one_show_pitr_mode_reply_t_handler
4276 (vl_api_one_show_pitr_mode_reply_t * mp)
4278 vat_main_t *vam = &vat_main;
4279 i32 retval = ntohl (mp->retval);
4283 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4286 vam->retval = retval;
4287 vam->result_ready = 1;
4291 vl_api_one_show_pitr_mode_reply_t_handler_json
4292 (vl_api_one_show_pitr_mode_reply_t * mp)
4294 vat_main_t *vam = &vat_main;
4295 vat_json_node_t node;
4298 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4299 vec_add1 (status, 0);
4301 vat_json_init_object (&node);
4302 vat_json_object_add_string_copy (&node, "status", status);
4306 vat_json_print (vam->ofp, &node);
4307 vat_json_free (&node);
4309 vam->retval = ntohl (mp->retval);
4310 vam->result_ready = 1;
4314 vl_api_one_show_petr_mode_reply_t_handler
4315 (vl_api_one_show_petr_mode_reply_t * mp)
4317 vat_main_t *vam = &vat_main;
4318 i32 retval = ntohl (mp->retval);
4322 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4325 vam->retval = retval;
4326 vam->result_ready = 1;
4330 vl_api_one_show_petr_mode_reply_t_handler_json
4331 (vl_api_one_show_petr_mode_reply_t * mp)
4333 vat_main_t *vam = &vat_main;
4334 vat_json_node_t node;
4337 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4338 vec_add1 (status, 0);
4340 vat_json_init_object (&node);
4341 vat_json_object_add_string_copy (&node, "status", status);
4345 vat_json_print (vam->ofp, &node);
4346 vat_json_free (&node);
4348 vam->retval = ntohl (mp->retval);
4349 vam->result_ready = 1;
4353 vl_api_show_one_use_petr_reply_t_handler
4354 (vl_api_show_one_use_petr_reply_t * mp)
4356 vat_main_t *vam = &vat_main;
4357 i32 retval = ntohl (mp->retval);
4361 print (vam->ofp, "%s\n", mp->status ? "enabled" : "disabled");
4364 print (vam->ofp, "Proxy-ETR address; %U",
4365 mp->is_ip4 ? format_ip4_address : format_ip6_address,
4370 vam->retval = retval;
4371 vam->result_ready = 1;
4375 vl_api_show_one_use_petr_reply_t_handler_json
4376 (vl_api_show_one_use_petr_reply_t * mp)
4378 vat_main_t *vam = &vat_main;
4379 vat_json_node_t node;
4382 struct in6_addr ip6;
4384 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4385 vec_add1 (status, 0);
4387 vat_json_init_object (&node);
4388 vat_json_object_add_string_copy (&node, "status", status);
4393 clib_memcpy (&ip6, mp->address, sizeof (ip6));
4394 vat_json_object_add_ip6 (&node, "address", ip6);
4398 clib_memcpy (&ip4, mp->address, sizeof (ip4));
4399 vat_json_object_add_ip4 (&node, "address", ip4);
4405 vat_json_print (vam->ofp, &node);
4406 vat_json_free (&node);
4408 vam->retval = ntohl (mp->retval);
4409 vam->result_ready = 1;
4413 vl_api_show_one_nsh_mapping_reply_t_handler
4414 (vl_api_show_one_nsh_mapping_reply_t * mp)
4416 vat_main_t *vam = &vat_main;
4417 i32 retval = ntohl (mp->retval);
4421 print (vam->ofp, "%-20s%-16s",
4422 mp->is_set ? "set" : "not-set",
4423 mp->is_set ? (char *) mp->locator_set_name : "");
4426 vam->retval = retval;
4427 vam->result_ready = 1;
4431 vl_api_show_one_nsh_mapping_reply_t_handler_json
4432 (vl_api_show_one_nsh_mapping_reply_t * mp)
4434 vat_main_t *vam = &vat_main;
4435 vat_json_node_t node;
4438 status = format (0, "%s", mp->is_set ? "yes" : "no");
4439 vec_add1 (status, 0);
4441 vat_json_init_object (&node);
4442 vat_json_object_add_string_copy (&node, "is_set", status);
4445 vat_json_object_add_string_copy (&node, "locator_set",
4446 mp->locator_set_name);
4451 vat_json_print (vam->ofp, &node);
4452 vat_json_free (&node);
4454 vam->retval = ntohl (mp->retval);
4455 vam->result_ready = 1;
4459 vl_api_show_one_map_register_ttl_reply_t_handler
4460 (vl_api_show_one_map_register_ttl_reply_t * mp)
4462 vat_main_t *vam = &vat_main;
4463 i32 retval = ntohl (mp->retval);
4465 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4469 print (vam->ofp, "ttl: %u", mp->ttl);
4472 vam->retval = retval;
4473 vam->result_ready = 1;
4477 vl_api_show_one_map_register_ttl_reply_t_handler_json
4478 (vl_api_show_one_map_register_ttl_reply_t * mp)
4480 vat_main_t *vam = &vat_main;
4481 vat_json_node_t node;
4483 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4484 vat_json_init_object (&node);
4485 vat_json_object_add_uint (&node, "ttl", mp->ttl);
4487 vat_json_print (vam->ofp, &node);
4488 vat_json_free (&node);
4490 vam->retval = ntohl (mp->retval);
4491 vam->result_ready = 1;
4495 vl_api_show_one_pitr_reply_t_handler (vl_api_show_one_pitr_reply_t * mp)
4497 vat_main_t *vam = &vat_main;
4498 i32 retval = ntohl (mp->retval);
4502 print (vam->ofp, "%-20s%-16s",
4503 mp->status ? "enabled" : "disabled",
4504 mp->status ? (char *) mp->locator_set_name : "");
4507 vam->retval = retval;
4508 vam->result_ready = 1;
4512 vl_api_show_one_pitr_reply_t_handler_json (vl_api_show_one_pitr_reply_t * mp)
4514 vat_main_t *vam = &vat_main;
4515 vat_json_node_t node;
4518 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4519 vec_add1 (status, 0);
4521 vat_json_init_object (&node);
4522 vat_json_object_add_string_copy (&node, "status", status);
4525 vat_json_object_add_string_copy (&node, "locator_set",
4526 mp->locator_set_name);
4531 vat_json_print (vam->ofp, &node);
4532 vat_json_free (&node);
4534 vam->retval = ntohl (mp->retval);
4535 vam->result_ready = 1;
4539 format_policer_type (u8 * s, va_list * va)
4541 u32 i = va_arg (*va, u32);
4543 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
4544 s = format (s, "1r2c");
4545 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
4546 s = format (s, "1r3c");
4547 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
4548 s = format (s, "2r3c-2698");
4549 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
4550 s = format (s, "2r3c-4115");
4551 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
4552 s = format (s, "2r3c-mef5cf1");
4554 s = format (s, "ILLEGAL");
4559 format_policer_rate_type (u8 * s, va_list * va)
4561 u32 i = va_arg (*va, u32);
4563 if (i == SSE2_QOS_RATE_KBPS)
4564 s = format (s, "kbps");
4565 else if (i == SSE2_QOS_RATE_PPS)
4566 s = format (s, "pps");
4568 s = format (s, "ILLEGAL");
4573 format_policer_round_type (u8 * s, va_list * va)
4575 u32 i = va_arg (*va, u32);
4577 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
4578 s = format (s, "closest");
4579 else if (i == SSE2_QOS_ROUND_TO_UP)
4580 s = format (s, "up");
4581 else if (i == SSE2_QOS_ROUND_TO_DOWN)
4582 s = format (s, "down");
4584 s = format (s, "ILLEGAL");
4589 format_policer_action_type (u8 * s, va_list * va)
4591 u32 i = va_arg (*va, u32);
4593 if (i == SSE2_QOS_ACTION_DROP)
4594 s = format (s, "drop");
4595 else if (i == SSE2_QOS_ACTION_TRANSMIT)
4596 s = format (s, "transmit");
4597 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4598 s = format (s, "mark-and-transmit");
4600 s = format (s, "ILLEGAL");
4605 format_dscp (u8 * s, va_list * va)
4607 u32 i = va_arg (*va, u32);
4612 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
4616 return format (s, "ILLEGAL");
4618 s = format (s, "%s", t);
4623 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
4625 vat_main_t *vam = &vat_main;
4626 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
4628 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4629 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4631 conform_dscp_str = format (0, "");
4633 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4634 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4636 exceed_dscp_str = format (0, "");
4638 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4639 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4641 violate_dscp_str = format (0, "");
4643 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
4644 "rate type %U, round type %U, %s rate, %s color-aware, "
4645 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
4646 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
4647 "conform action %U%s, exceed action %U%s, violate action %U%s",
4649 format_policer_type, mp->type,
4652 clib_net_to_host_u64 (mp->cb),
4653 clib_net_to_host_u64 (mp->eb),
4654 format_policer_rate_type, mp->rate_type,
4655 format_policer_round_type, mp->round_type,
4656 mp->single_rate ? "single" : "dual",
4657 mp->color_aware ? "is" : "not",
4658 ntohl (mp->cir_tokens_per_period),
4659 ntohl (mp->pir_tokens_per_period),
4661 ntohl (mp->current_limit),
4662 ntohl (mp->current_bucket),
4663 ntohl (mp->extended_limit),
4664 ntohl (mp->extended_bucket),
4665 clib_net_to_host_u64 (mp->last_update_time),
4666 format_policer_action_type, mp->conform_action_type,
4668 format_policer_action_type, mp->exceed_action_type,
4670 format_policer_action_type, mp->violate_action_type,
4673 vec_free (conform_dscp_str);
4674 vec_free (exceed_dscp_str);
4675 vec_free (violate_dscp_str);
4678 static void vl_api_policer_details_t_handler_json
4679 (vl_api_policer_details_t * mp)
4681 vat_main_t *vam = &vat_main;
4682 vat_json_node_t *node;
4683 u8 *rate_type_str, *round_type_str, *type_str;
4684 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
4686 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
4688 format (0, "%U", format_policer_round_type, mp->round_type);
4689 type_str = format (0, "%U", format_policer_type, mp->type);
4690 conform_action_str = format (0, "%U", format_policer_action_type,
4691 mp->conform_action_type);
4692 exceed_action_str = format (0, "%U", format_policer_action_type,
4693 mp->exceed_action_type);
4694 violate_action_str = format (0, "%U", format_policer_action_type,
4695 mp->violate_action_type);
4697 if (VAT_JSON_ARRAY != vam->json_tree.type)
4699 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4700 vat_json_init_array (&vam->json_tree);
4702 node = vat_json_array_add (&vam->json_tree);
4704 vat_json_init_object (node);
4705 vat_json_object_add_string_copy (node, "name", mp->name);
4706 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
4707 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
4708 vat_json_object_add_uint (node, "cb", clib_net_to_host_u64 (mp->cb));
4709 vat_json_object_add_uint (node, "eb", clib_net_to_host_u64 (mp->eb));
4710 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
4711 vat_json_object_add_string_copy (node, "round_type", round_type_str);
4712 vat_json_object_add_string_copy (node, "type", type_str);
4713 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
4714 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
4715 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
4716 vat_json_object_add_uint (node, "cir_tokens_per_period",
4717 ntohl (mp->cir_tokens_per_period));
4718 vat_json_object_add_uint (node, "eir_tokens_per_period",
4719 ntohl (mp->pir_tokens_per_period));
4720 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
4721 vat_json_object_add_uint (node, "current_bucket",
4722 ntohl (mp->current_bucket));
4723 vat_json_object_add_uint (node, "extended_limit",
4724 ntohl (mp->extended_limit));
4725 vat_json_object_add_uint (node, "extended_bucket",
4726 ntohl (mp->extended_bucket));
4727 vat_json_object_add_uint (node, "last_update_time",
4728 ntohl (mp->last_update_time));
4729 vat_json_object_add_string_copy (node, "conform_action",
4730 conform_action_str);
4731 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4733 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4734 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
4735 vec_free (dscp_str);
4737 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
4738 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4740 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4741 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
4742 vec_free (dscp_str);
4744 vat_json_object_add_string_copy (node, "violate_action",
4745 violate_action_str);
4746 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4748 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4749 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
4750 vec_free (dscp_str);
4753 vec_free (rate_type_str);
4754 vec_free (round_type_str);
4755 vec_free (type_str);
4756 vec_free (conform_action_str);
4757 vec_free (exceed_action_str);
4758 vec_free (violate_action_str);
4762 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
4765 vat_main_t *vam = &vat_main;
4766 int i, count = ntohl (mp->count);
4769 print (vam->ofp, "classify table ids (%d) : ", count);
4770 for (i = 0; i < count; i++)
4772 print (vam->ofp, "%d", ntohl (mp->ids[i]));
4773 print (vam->ofp, (i < count - 1) ? "," : "");
4775 vam->retval = ntohl (mp->retval);
4776 vam->result_ready = 1;
4780 vl_api_classify_table_ids_reply_t_handler_json
4781 (vl_api_classify_table_ids_reply_t * mp)
4783 vat_main_t *vam = &vat_main;
4784 int i, count = ntohl (mp->count);
4788 vat_json_node_t node;
4790 vat_json_init_object (&node);
4791 for (i = 0; i < count; i++)
4793 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
4795 vat_json_print (vam->ofp, &node);
4796 vat_json_free (&node);
4798 vam->retval = ntohl (mp->retval);
4799 vam->result_ready = 1;
4803 vl_api_classify_table_by_interface_reply_t_handler
4804 (vl_api_classify_table_by_interface_reply_t * mp)
4806 vat_main_t *vam = &vat_main;
4809 table_id = ntohl (mp->l2_table_id);
4811 print (vam->ofp, "l2 table id : %d", table_id);
4813 print (vam->ofp, "l2 table id : No input ACL tables configured");
4814 table_id = ntohl (mp->ip4_table_id);
4816 print (vam->ofp, "ip4 table id : %d", table_id);
4818 print (vam->ofp, "ip4 table id : No input ACL tables configured");
4819 table_id = ntohl (mp->ip6_table_id);
4821 print (vam->ofp, "ip6 table id : %d", table_id);
4823 print (vam->ofp, "ip6 table id : No input ACL tables configured");
4824 vam->retval = ntohl (mp->retval);
4825 vam->result_ready = 1;
4829 vl_api_classify_table_by_interface_reply_t_handler_json
4830 (vl_api_classify_table_by_interface_reply_t * mp)
4832 vat_main_t *vam = &vat_main;
4833 vat_json_node_t node;
4835 vat_json_init_object (&node);
4837 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
4838 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
4839 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
4841 vat_json_print (vam->ofp, &node);
4842 vat_json_free (&node);
4844 vam->retval = ntohl (mp->retval);
4845 vam->result_ready = 1;
4848 static void vl_api_policer_add_del_reply_t_handler
4849 (vl_api_policer_add_del_reply_t * mp)
4851 vat_main_t *vam = &vat_main;
4852 i32 retval = ntohl (mp->retval);
4853 if (vam->async_mode)
4855 vam->async_errors += (retval < 0);
4859 vam->retval = retval;
4860 vam->result_ready = 1;
4861 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
4863 * Note: this is just barely thread-safe, depends on
4864 * the main thread spinning waiting for an answer...
4866 errmsg ("policer index %d", ntohl (mp->policer_index));
4870 static void vl_api_policer_add_del_reply_t_handler_json
4871 (vl_api_policer_add_del_reply_t * mp)
4873 vat_main_t *vam = &vat_main;
4874 vat_json_node_t node;
4876 vat_json_init_object (&node);
4877 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
4878 vat_json_object_add_uint (&node, "policer_index",
4879 ntohl (mp->policer_index));
4881 vat_json_print (vam->ofp, &node);
4882 vat_json_free (&node);
4884 vam->retval = ntohl (mp->retval);
4885 vam->result_ready = 1;
4888 /* Format hex dump. */
4890 format_hex_bytes (u8 * s, va_list * va)
4892 u8 *bytes = va_arg (*va, u8 *);
4893 int n_bytes = va_arg (*va, int);
4896 /* Print short or long form depending on byte count. */
4897 uword short_form = n_bytes <= 32;
4898 u32 indent = format_get_indent (s);
4903 for (i = 0; i < n_bytes; i++)
4905 if (!short_form && (i % 32) == 0)
4906 s = format (s, "%08x: ", i);
4907 s = format (s, "%02x", bytes[i]);
4908 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
4909 s = format (s, "\n%U", format_white_space, indent);
4916 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
4919 vat_main_t *vam = &vat_main;
4920 i32 retval = ntohl (mp->retval);
4923 print (vam->ofp, "classify table info :");
4924 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
4925 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
4926 ntohl (mp->miss_next_index));
4927 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
4928 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
4929 ntohl (mp->match_n_vectors));
4930 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
4931 ntohl (mp->mask_length));
4933 vam->retval = retval;
4934 vam->result_ready = 1;
4938 vl_api_classify_table_info_reply_t_handler_json
4939 (vl_api_classify_table_info_reply_t * mp)
4941 vat_main_t *vam = &vat_main;
4942 vat_json_node_t node;
4944 i32 retval = ntohl (mp->retval);
4947 vat_json_init_object (&node);
4949 vat_json_object_add_int (&node, "sessions",
4950 ntohl (mp->active_sessions));
4951 vat_json_object_add_int (&node, "nexttbl",
4952 ntohl (mp->next_table_index));
4953 vat_json_object_add_int (&node, "nextnode",
4954 ntohl (mp->miss_next_index));
4955 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
4956 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
4957 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
4958 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
4959 ntohl (mp->mask_length), 0);
4960 vat_json_object_add_string_copy (&node, "mask", s);
4962 vat_json_print (vam->ofp, &node);
4963 vat_json_free (&node);
4965 vam->retval = ntohl (mp->retval);
4966 vam->result_ready = 1;
4970 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
4973 vat_main_t *vam = &vat_main;
4975 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
4976 ntohl (mp->hit_next_index), ntohl (mp->advance),
4977 ntohl (mp->opaque_index));
4978 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
4979 ntohl (mp->match_length));
4983 vl_api_classify_session_details_t_handler_json
4984 (vl_api_classify_session_details_t * mp)
4986 vat_main_t *vam = &vat_main;
4987 vat_json_node_t *node = NULL;
4989 if (VAT_JSON_ARRAY != vam->json_tree.type)
4991 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4992 vat_json_init_array (&vam->json_tree);
4994 node = vat_json_array_add (&vam->json_tree);
4996 vat_json_init_object (node);
4997 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
4998 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
4999 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
5001 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
5003 vat_json_object_add_string_copy (node, "match", s);
5006 static void vl_api_pg_create_interface_reply_t_handler
5007 (vl_api_pg_create_interface_reply_t * mp)
5009 vat_main_t *vam = &vat_main;
5011 vam->retval = ntohl (mp->retval);
5012 vam->result_ready = 1;
5015 static void vl_api_pg_create_interface_reply_t_handler_json
5016 (vl_api_pg_create_interface_reply_t * mp)
5018 vat_main_t *vam = &vat_main;
5019 vat_json_node_t node;
5021 i32 retval = ntohl (mp->retval);
5024 vat_json_init_object (&node);
5026 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
5028 vat_json_print (vam->ofp, &node);
5029 vat_json_free (&node);
5031 vam->retval = ntohl (mp->retval);
5032 vam->result_ready = 1;
5035 static void vl_api_policer_classify_details_t_handler
5036 (vl_api_policer_classify_details_t * mp)
5038 vat_main_t *vam = &vat_main;
5040 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
5041 ntohl (mp->table_index));
5044 static void vl_api_policer_classify_details_t_handler_json
5045 (vl_api_policer_classify_details_t * mp)
5047 vat_main_t *vam = &vat_main;
5048 vat_json_node_t *node;
5050 if (VAT_JSON_ARRAY != vam->json_tree.type)
5052 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5053 vat_json_init_array (&vam->json_tree);
5055 node = vat_json_array_add (&vam->json_tree);
5057 vat_json_init_object (node);
5058 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5059 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5062 static void vl_api_ipsec_gre_tunnel_add_del_reply_t_handler
5063 (vl_api_ipsec_gre_tunnel_add_del_reply_t * mp)
5065 vat_main_t *vam = &vat_main;
5066 i32 retval = ntohl (mp->retval);
5067 if (vam->async_mode)
5069 vam->async_errors += (retval < 0);
5073 vam->retval = retval;
5074 vam->sw_if_index = ntohl (mp->sw_if_index);
5075 vam->result_ready = 1;
5077 vam->regenerate_interface_table = 1;
5080 static void vl_api_ipsec_gre_tunnel_add_del_reply_t_handler_json
5081 (vl_api_ipsec_gre_tunnel_add_del_reply_t * mp)
5083 vat_main_t *vam = &vat_main;
5084 vat_json_node_t node;
5086 vat_json_init_object (&node);
5087 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
5088 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
5090 vat_json_print (vam->ofp, &node);
5091 vat_json_free (&node);
5093 vam->retval = ntohl (mp->retval);
5094 vam->result_ready = 1;
5097 static void vl_api_flow_classify_details_t_handler
5098 (vl_api_flow_classify_details_t * mp)
5100 vat_main_t *vam = &vat_main;
5102 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
5103 ntohl (mp->table_index));
5106 static void vl_api_flow_classify_details_t_handler_json
5107 (vl_api_flow_classify_details_t * mp)
5109 vat_main_t *vam = &vat_main;
5110 vat_json_node_t *node;
5112 if (VAT_JSON_ARRAY != vam->json_tree.type)
5114 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5115 vat_json_init_array (&vam->json_tree);
5117 node = vat_json_array_add (&vam->json_tree);
5119 vat_json_init_object (node);
5120 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5121 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5124 #define vl_api_one_adjacencies_get_reply_t_endian vl_noop_handler
5125 #define vl_api_one_adjacencies_get_reply_t_print vl_noop_handler
5126 #define vl_api_one_l2_arp_bd_get_reply_t_print vl_noop_handler
5127 #define vl_api_one_l2_arp_entries_get_reply_t_endian vl_noop_handler
5128 #define vl_api_one_l2_arp_entries_get_reply_t_print vl_noop_handler
5129 #define vl_api_one_l2_arp_bd_get_reply_t_endian vl_noop_handler
5130 #define vl_api_one_ndp_bd_get_reply_t_endian vl_noop_handler
5131 #define vl_api_one_ndp_bd_get_reply_t_print vl_noop_handler
5132 #define vl_api_one_ndp_entries_get_reply_t_print vl_noop_handler
5133 #define vl_api_one_ndp_entries_get_reply_t_endian vl_noop_handler
5136 * Generate boilerplate reply handlers, which
5137 * dig the return value out of the xxx_reply_t API message,
5138 * stick it into vam->retval, and set vam->result_ready
5140 * Could also do this by pointing N message decode slots at
5141 * a single function, but that could break in subtle ways.
5144 #define foreach_standard_reply_retval_handler \
5145 _(sw_interface_set_flags_reply) \
5146 _(sw_interface_add_del_address_reply) \
5147 _(sw_interface_set_rx_mode_reply) \
5148 _(sw_interface_set_rx_placement_reply) \
5149 _(sw_interface_set_table_reply) \
5150 _(sw_interface_set_mpls_enable_reply) \
5151 _(sw_interface_set_vpath_reply) \
5152 _(sw_interface_set_vxlan_bypass_reply) \
5153 _(sw_interface_set_geneve_bypass_reply) \
5154 _(sw_interface_set_vxlan_gpe_bypass_reply) \
5155 _(sw_interface_set_l2_bridge_reply) \
5156 _(bridge_domain_add_del_reply) \
5157 _(sw_interface_set_l2_xconnect_reply) \
5158 _(l2fib_add_del_reply) \
5159 _(l2fib_flush_int_reply) \
5160 _(l2fib_flush_bd_reply) \
5161 _(ip_add_del_route_reply) \
5162 _(ip_table_add_del_reply) \
5163 _(ip_mroute_add_del_reply) \
5164 _(mpls_route_add_del_reply) \
5165 _(mpls_table_add_del_reply) \
5166 _(mpls_ip_bind_unbind_reply) \
5167 _(bier_route_add_del_reply) \
5168 _(bier_table_add_del_reply) \
5169 _(proxy_arp_add_del_reply) \
5170 _(proxy_arp_intfc_enable_disable_reply) \
5171 _(sw_interface_set_unnumbered_reply) \
5172 _(ip_neighbor_add_del_reply) \
5173 _(oam_add_del_reply) \
5174 _(reset_fib_reply) \
5175 _(dhcp_proxy_config_reply) \
5176 _(dhcp_proxy_set_vss_reply) \
5177 _(dhcp_client_config_reply) \
5178 _(set_ip_flow_hash_reply) \
5179 _(sw_interface_ip6_enable_disable_reply) \
5180 _(ip6nd_proxy_add_del_reply) \
5181 _(sw_interface_ip6nd_ra_prefix_reply) \
5182 _(sw_interface_ip6nd_ra_config_reply) \
5183 _(set_arp_neighbor_limit_reply) \
5184 _(l2_patch_add_del_reply) \
5185 _(sr_mpls_policy_add_reply) \
5186 _(sr_mpls_policy_mod_reply) \
5187 _(sr_mpls_policy_del_reply) \
5188 _(sr_policy_add_reply) \
5189 _(sr_policy_mod_reply) \
5190 _(sr_policy_del_reply) \
5191 _(sr_localsid_add_del_reply) \
5192 _(sr_steering_add_del_reply) \
5193 _(classify_add_del_session_reply) \
5194 _(classify_set_interface_ip_table_reply) \
5195 _(classify_set_interface_l2_tables_reply) \
5196 _(l2tpv3_set_tunnel_cookies_reply) \
5197 _(l2tpv3_interface_enable_disable_reply) \
5198 _(l2tpv3_set_lookup_key_reply) \
5199 _(l2_fib_clear_table_reply) \
5200 _(l2_interface_efp_filter_reply) \
5201 _(l2_interface_vlan_tag_rewrite_reply) \
5202 _(modify_vhost_user_if_reply) \
5203 _(delete_vhost_user_if_reply) \
5204 _(ip_probe_neighbor_reply) \
5205 _(ip_scan_neighbor_enable_disable_reply) \
5206 _(want_ip4_arp_events_reply) \
5207 _(want_ip6_nd_events_reply) \
5208 _(want_l2_macs_events_reply) \
5209 _(input_acl_set_interface_reply) \
5210 _(ipsec_spd_add_del_reply) \
5211 _(ipsec_interface_add_del_spd_reply) \
5212 _(ipsec_spd_entry_add_del_reply) \
5213 _(ipsec_sad_entry_add_del_reply) \
5214 _(ipsec_sa_set_key_reply) \
5215 _(ipsec_tunnel_if_add_del_reply) \
5216 _(ipsec_tunnel_if_set_key_reply) \
5217 _(ipsec_tunnel_if_set_sa_reply) \
5218 _(delete_loopback_reply) \
5219 _(bd_ip_mac_add_del_reply) \
5220 _(bd_ip_mac_flush_reply) \
5221 _(want_interface_events_reply) \
5222 _(cop_interface_enable_disable_reply) \
5223 _(cop_whitelist_enable_disable_reply) \
5224 _(sw_interface_clear_stats_reply) \
5225 _(ioam_enable_reply) \
5226 _(ioam_disable_reply) \
5227 _(one_add_del_locator_reply) \
5228 _(one_add_del_local_eid_reply) \
5229 _(one_add_del_remote_mapping_reply) \
5230 _(one_add_del_adjacency_reply) \
5231 _(one_add_del_map_resolver_reply) \
5232 _(one_add_del_map_server_reply) \
5233 _(one_enable_disable_reply) \
5234 _(one_rloc_probe_enable_disable_reply) \
5235 _(one_map_register_enable_disable_reply) \
5236 _(one_map_register_set_ttl_reply) \
5237 _(one_set_transport_protocol_reply) \
5238 _(one_map_register_fallback_threshold_reply) \
5239 _(one_pitr_set_locator_set_reply) \
5240 _(one_map_request_mode_reply) \
5241 _(one_add_del_map_request_itr_rlocs_reply) \
5242 _(one_eid_table_add_del_map_reply) \
5243 _(one_use_petr_reply) \
5244 _(one_stats_enable_disable_reply) \
5245 _(one_add_del_l2_arp_entry_reply) \
5246 _(one_add_del_ndp_entry_reply) \
5247 _(one_stats_flush_reply) \
5248 _(one_enable_disable_xtr_mode_reply) \
5249 _(one_enable_disable_pitr_mode_reply) \
5250 _(one_enable_disable_petr_mode_reply) \
5251 _(gpe_enable_disable_reply) \
5252 _(gpe_set_encap_mode_reply) \
5253 _(gpe_add_del_iface_reply) \
5254 _(gpe_add_del_native_fwd_rpath_reply) \
5255 _(af_packet_delete_reply) \
5256 _(policer_classify_set_interface_reply) \
5257 _(netmap_create_reply) \
5258 _(netmap_delete_reply) \
5259 _(set_ipfix_exporter_reply) \
5260 _(set_ipfix_classify_stream_reply) \
5261 _(ipfix_classify_table_add_del_reply) \
5262 _(flow_classify_set_interface_reply) \
5263 _(sw_interface_span_enable_disable_reply) \
5264 _(pg_capture_reply) \
5265 _(pg_enable_disable_reply) \
5266 _(ip_source_and_port_range_check_add_del_reply) \
5267 _(ip_source_and_port_range_check_interface_add_del_reply)\
5268 _(delete_subif_reply) \
5269 _(l2_interface_pbb_tag_rewrite_reply) \
5271 _(feature_enable_disable_reply) \
5272 _(sw_interface_tag_add_del_reply) \
5273 _(hw_interface_set_mtu_reply) \
5274 _(p2p_ethernet_add_reply) \
5275 _(p2p_ethernet_del_reply) \
5276 _(lldp_config_reply) \
5277 _(sw_interface_set_lldp_reply) \
5278 _(tcp_configure_src_addresses_reply) \
5279 _(dns_enable_disable_reply) \
5280 _(dns_name_server_add_del_reply) \
5281 _(session_rule_add_del_reply) \
5282 _(ip_container_proxy_add_del_reply) \
5283 _(output_acl_set_interface_reply) \
5284 _(qos_record_enable_disable_reply)
5287 static void vl_api_##n##_t_handler \
5288 (vl_api_##n##_t * mp) \
5290 vat_main_t * vam = &vat_main; \
5291 i32 retval = ntohl(mp->retval); \
5292 if (vam->async_mode) { \
5293 vam->async_errors += (retval < 0); \
5295 vam->retval = retval; \
5296 vam->result_ready = 1; \
5299 foreach_standard_reply_retval_handler;
5303 static void vl_api_##n##_t_handler_json \
5304 (vl_api_##n##_t * mp) \
5306 vat_main_t * vam = &vat_main; \
5307 vat_json_node_t node; \
5308 vat_json_init_object(&node); \
5309 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
5310 vat_json_print(vam->ofp, &node); \
5311 vam->retval = ntohl(mp->retval); \
5312 vam->result_ready = 1; \
5314 foreach_standard_reply_retval_handler;
5318 * Table of message reply handlers, must include boilerplate handlers
5322 #define foreach_vpe_api_reply_msg \
5323 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
5324 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
5325 _(SW_INTERFACE_DETAILS, sw_interface_details) \
5326 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
5327 _(CONTROL_PING_REPLY, control_ping_reply) \
5328 _(CLI_REPLY, cli_reply) \
5329 _(CLI_INBAND_REPLY, cli_inband_reply) \
5330 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
5331 sw_interface_add_del_address_reply) \
5332 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
5333 _(SW_INTERFACE_SET_RX_PLACEMENT_REPLY, sw_interface_set_rx_placement_reply) \
5334 _(SW_INTERFACE_RX_PLACEMENT_DETAILS, sw_interface_rx_placement_details) \
5335 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
5336 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
5337 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
5338 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
5339 _(SW_INTERFACE_SET_GENEVE_BYPASS_REPLY, sw_interface_set_geneve_bypass_reply) \
5340 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
5341 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
5342 sw_interface_set_l2_xconnect_reply) \
5343 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
5344 sw_interface_set_l2_bridge_reply) \
5345 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
5346 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
5347 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
5348 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
5349 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
5350 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
5351 _(L2_FLAGS_REPLY, l2_flags_reply) \
5352 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
5353 _(TAP_CREATE_V2_REPLY, tap_create_v2_reply) \
5354 _(TAP_DELETE_V2_REPLY, tap_delete_v2_reply) \
5355 _(SW_INTERFACE_TAP_V2_DETAILS, sw_interface_tap_v2_details) \
5356 _(VIRTIO_PCI_CREATE_REPLY, virtio_pci_create_reply) \
5357 _(VIRTIO_PCI_DELETE_REPLY, virtio_pci_delete_reply) \
5358 _(SW_INTERFACE_VIRTIO_PCI_DETAILS, sw_interface_virtio_pci_details) \
5359 _(BOND_CREATE_REPLY, bond_create_reply) \
5360 _(BOND_DELETE_REPLY, bond_delete_reply) \
5361 _(BOND_ENSLAVE_REPLY, bond_enslave_reply) \
5362 _(BOND_DETACH_SLAVE_REPLY, bond_detach_slave_reply) \
5363 _(SW_INTERFACE_BOND_DETAILS, sw_interface_bond_details) \
5364 _(SW_INTERFACE_SLAVE_DETAILS, sw_interface_slave_details) \
5365 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
5366 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
5367 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
5368 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
5369 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
5370 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
5371 _(BIER_ROUTE_ADD_DEL_REPLY, bier_route_add_del_reply) \
5372 _(BIER_TABLE_ADD_DEL_REPLY, bier_table_add_del_reply) \
5373 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
5374 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
5375 proxy_arp_intfc_enable_disable_reply) \
5376 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
5377 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
5378 sw_interface_set_unnumbered_reply) \
5379 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
5380 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
5381 _(CREATE_SUBIF_REPLY, create_subif_reply) \
5382 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
5383 _(RESET_FIB_REPLY, reset_fib_reply) \
5384 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
5385 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
5386 _(DHCP_PROXY_DETAILS, dhcp_proxy_details) \
5387 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
5388 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
5389 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
5390 sw_interface_ip6_enable_disable_reply) \
5391 _(IP6ND_PROXY_ADD_DEL_REPLY, ip6nd_proxy_add_del_reply) \
5392 _(IP6ND_PROXY_DETAILS, ip6nd_proxy_details) \
5393 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
5394 sw_interface_ip6nd_ra_prefix_reply) \
5395 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
5396 sw_interface_ip6nd_ra_config_reply) \
5397 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
5398 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
5399 _(SR_MPLS_POLICY_ADD_REPLY, sr_mpls_policy_add_reply) \
5400 _(SR_MPLS_POLICY_MOD_REPLY, sr_mpls_policy_mod_reply) \
5401 _(SR_MPLS_POLICY_DEL_REPLY, sr_mpls_policy_del_reply) \
5402 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
5403 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
5404 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
5405 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
5406 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
5407 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
5408 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
5409 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
5410 classify_set_interface_ip_table_reply) \
5411 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
5412 classify_set_interface_l2_tables_reply) \
5413 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
5414 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
5415 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
5416 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
5417 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
5418 l2tpv3_interface_enable_disable_reply) \
5419 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
5420 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
5421 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
5422 _(VXLAN_OFFLOAD_RX_REPLY, vxlan_offload_rx_reply) \
5423 _(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
5424 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
5425 _(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
5426 _(GRE_TUNNEL_ADD_DEL_REPLY, gre_tunnel_add_del_reply) \
5427 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
5428 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
5429 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
5430 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
5431 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
5432 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
5433 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
5434 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
5435 _(SHOW_VERSION_REPLY, show_version_reply) \
5436 _(SHOW_THREADS_REPLY, show_threads_reply) \
5437 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
5438 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
5439 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
5440 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
5441 _(IP_PROBE_NEIGHBOR_REPLY, ip_probe_neighbor_reply) \
5442 _(IP_SCAN_NEIGHBOR_ENABLE_DISABLE_REPLY, ip_scan_neighbor_enable_disable_reply) \
5443 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
5444 _(IP4_ARP_EVENT, ip4_arp_event) \
5445 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
5446 _(IP6_ND_EVENT, ip6_nd_event) \
5447 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
5448 _(L2_MACS_EVENT, l2_macs_event) \
5449 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
5450 _(IP_ADDRESS_DETAILS, ip_address_details) \
5451 _(IP_DETAILS, ip_details) \
5452 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
5453 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
5454 _(IPSEC_SPD_ENTRY_ADD_DEL_REPLY, ipsec_spd_entry_add_del_reply) \
5455 _(IPSEC_SAD_ENTRY_ADD_DEL_REPLY, ipsec_sad_entry_add_del_reply) \
5456 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
5457 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
5458 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
5459 _(IPSEC_TUNNEL_IF_SET_KEY_REPLY, ipsec_tunnel_if_set_key_reply) \
5460 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
5461 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
5462 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
5463 _(BD_IP_MAC_FLUSH_REPLY, bd_ip_mac_flush_reply) \
5464 _(BD_IP_MAC_DETAILS, bd_ip_mac_details) \
5465 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
5466 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
5467 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
5468 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
5469 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
5470 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
5471 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
5472 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
5473 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
5474 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
5475 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
5476 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
5477 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
5478 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
5479 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
5480 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
5481 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
5482 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
5483 one_map_register_enable_disable_reply) \
5484 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
5485 _(ONE_SET_TRANSPORT_PROTOCOL_REPLY, one_set_transport_protocol_reply) \
5486 _(ONE_GET_TRANSPORT_PROTOCOL_REPLY, one_get_transport_protocol_reply) \
5487 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5488 one_map_register_fallback_threshold_reply) \
5489 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
5490 one_rloc_probe_enable_disable_reply) \
5491 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
5492 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
5493 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
5494 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
5495 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
5496 _(ONE_LOCATOR_DETAILS, one_locator_details) \
5497 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
5498 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
5499 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
5500 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
5501 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
5502 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
5503 _(ONE_STATS_DETAILS, one_stats_details) \
5504 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
5505 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
5506 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
5507 show_one_stats_enable_disable_reply) \
5508 _(ONE_ADD_DEL_NDP_ENTRY_REPLY, one_add_del_ndp_entry_reply) \
5509 _(ONE_NDP_BD_GET_REPLY, one_ndp_bd_get_reply) \
5510 _(ONE_NDP_ENTRIES_GET_REPLY, one_ndp_entries_get_reply) \
5511 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
5512 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
5513 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
5514 _(ONE_ENABLE_DISABLE_XTR_MODE_REPLY, one_enable_disable_xtr_mode_reply) \
5515 _(ONE_ENABLE_DISABLE_PITR_MODE_REPLY, \
5516 one_enable_disable_pitr_mode_reply) \
5517 _(ONE_ENABLE_DISABLE_PETR_MODE_REPLY, \
5518 one_enable_disable_petr_mode_reply) \
5519 _(ONE_SHOW_XTR_MODE_REPLY, one_show_xtr_mode_reply) \
5520 _(ONE_SHOW_PITR_MODE_REPLY, one_show_pitr_mode_reply) \
5521 _(ONE_SHOW_PETR_MODE_REPLY, one_show_petr_mode_reply) \
5522 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
5523 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
5524 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
5525 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
5526 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
5527 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
5528 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
5529 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
5530 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
5531 gpe_add_del_native_fwd_rpath_reply) \
5532 _(GPE_FWD_ENTRY_PATH_DETAILS, \
5533 gpe_fwd_entry_path_details) \
5534 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
5535 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
5536 one_add_del_map_request_itr_rlocs_reply) \
5537 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
5538 one_get_map_request_itr_rlocs_reply) \
5539 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
5540 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
5541 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
5542 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
5543 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
5544 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
5545 show_one_map_register_state_reply) \
5546 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
5547 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5548 show_one_map_register_fallback_threshold_reply) \
5549 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
5550 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
5551 _(AF_PACKET_DETAILS, af_packet_details) \
5552 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
5553 _(POLICER_DETAILS, policer_details) \
5554 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
5555 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
5556 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
5557 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
5558 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
5559 _(MPLS_FIB_DETAILS, mpls_fib_details) \
5560 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
5561 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
5562 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
5563 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
5564 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
5565 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
5566 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
5567 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5568 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5569 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5570 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5571 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5572 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5573 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5574 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5575 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5576 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5577 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5578 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5579 ip_source_and_port_range_check_add_del_reply) \
5580 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5581 ip_source_and_port_range_check_interface_add_del_reply) \
5582 _(IPSEC_GRE_TUNNEL_ADD_DEL_REPLY, ipsec_gre_tunnel_add_del_reply) \
5583 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
5584 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5585 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5586 _(SET_PUNT_REPLY, set_punt_reply) \
5587 _(IP_FIB_DETAILS, ip_fib_details) \
5588 _(IP6_FIB_DETAILS, ip6_fib_details) \
5589 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5590 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5591 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5592 _(HW_INTERFACE_SET_MTU_REPLY, hw_interface_set_mtu_reply) \
5593 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
5594 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5595 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5596 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5597 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5598 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply) \
5599 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
5600 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
5601 _(DNS_ENABLE_DISABLE_REPLY, dns_enable_disable_reply) \
5602 _(DNS_NAME_SERVER_ADD_DEL_REPLY, dns_name_server_add_del_reply) \
5603 _(DNS_RESOLVE_NAME_REPLY, dns_resolve_name_reply) \
5604 _(DNS_RESOLVE_IP_REPLY, dns_resolve_ip_reply) \
5605 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
5606 _(SESSION_RULES_DETAILS, session_rules_details) \
5607 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
5608 _(OUTPUT_ACL_SET_INTERFACE_REPLY, output_acl_set_interface_reply) \
5609 _(QOS_RECORD_ENABLE_DISABLE_REPLY, qos_record_enable_disable_reply)
5611 #define foreach_standalone_reply_msg \
5612 _(SW_INTERFACE_EVENT, sw_interface_event)
5620 #define STR_VTR_OP_CASE(op) \
5621 case L2_VTR_ ## op: \
5625 str_vtr_op (u32 vtr_op)
5629 STR_VTR_OP_CASE (DISABLED);
5630 STR_VTR_OP_CASE (PUSH_1);
5631 STR_VTR_OP_CASE (PUSH_2);
5632 STR_VTR_OP_CASE (POP_1);
5633 STR_VTR_OP_CASE (POP_2);
5634 STR_VTR_OP_CASE (TRANSLATE_1_1);
5635 STR_VTR_OP_CASE (TRANSLATE_1_2);
5636 STR_VTR_OP_CASE (TRANSLATE_2_1);
5637 STR_VTR_OP_CASE (TRANSLATE_2_2);
5644 dump_sub_interface_table (vat_main_t * vam)
5646 const sw_interface_subif_t *sub = NULL;
5648 if (vam->json_output)
5651 ("JSON output supported only for VPE API calls and dump_stats_table");
5656 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5657 "Interface", "sw_if_index",
5658 "sub id", "dot1ad", "tags", "outer id",
5659 "inner id", "exact", "default", "outer any", "inner any");
5661 vec_foreach (sub, vam->sw_if_subif_table)
5664 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5665 sub->interface_name,
5667 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5668 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5669 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5670 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5671 if (sub->vtr_op != L2_VTR_DISABLED)
5674 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
5675 "tag1: %d tag2: %d ]",
5676 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
5677 sub->vtr_tag1, sub->vtr_tag2);
5685 name_sort_cmp (void *a1, void *a2)
5687 name_sort_t *n1 = a1;
5688 name_sort_t *n2 = a2;
5690 return strcmp ((char *) n1->name, (char *) n2->name);
5694 dump_interface_table (vat_main_t * vam)
5697 name_sort_t *nses = 0, *ns;
5699 if (vam->json_output)
5702 ("JSON output supported only for VPE API calls and dump_stats_table");
5707 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5709 vec_add2 (nses, ns, 1);
5710 ns->name = (u8 *)(p->key);
5711 ns->value = (u32) p->value[0];
5715 vec_sort_with_function (nses, name_sort_cmp);
5717 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
5718 vec_foreach (ns, nses)
5720 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
5727 dump_ip_table (vat_main_t * vam, int is_ipv6)
5729 const ip_details_t *det = NULL;
5730 const ip_address_details_t *address = NULL;
5733 print (vam->ofp, "%-12s", "sw_if_index");
5735 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
5742 print (vam->ofp, "%-12d", i);
5743 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
5748 vec_foreach (address, det->addr)
5752 is_ipv6 ? format_ip6_address : format_ip4_address,
5753 address->ip, address->prefix_length);
5761 dump_ipv4_table (vat_main_t * vam)
5763 if (vam->json_output)
5766 ("JSON output supported only for VPE API calls and dump_stats_table");
5770 return dump_ip_table (vam, 0);
5774 dump_ipv6_table (vat_main_t * vam)
5776 if (vam->json_output)
5779 ("JSON output supported only for VPE API calls and dump_stats_table");
5783 return dump_ip_table (vam, 1);
5787 * Pass CLI buffers directly in the CLI_INBAND API message,
5788 * instead of an additional shared memory area.
5791 exec_inband (vat_main_t * vam)
5793 vl_api_cli_inband_t *mp;
5794 unformat_input_t *i = vam->input;
5797 if (vec_len (i->buffer) == 0)
5800 if (vam->exec_mode == 0 && unformat (i, "mode"))
5805 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
5812 * In order for the CLI command to work, it
5813 * must be a vector ending in \n, not a C-string ending
5816 u32 len = vec_len (vam->input->buffer);
5817 M2 (CLI_INBAND, mp, len);
5818 vl_api_to_api_string (len - 1, (const char *) vam->input->buffer, &mp->cmd);
5822 /* json responses may or may not include a useful reply... */
5823 if (vec_len (vam->cmd_reply))
5824 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
5829 exec (vat_main_t * vam)
5831 return exec_inband (vam);
5835 api_create_loopback (vat_main_t * vam)
5837 unformat_input_t *i = vam->input;
5838 vl_api_create_loopback_t *mp;
5839 vl_api_create_loopback_instance_t *mp_lbi;
5842 u8 is_specified = 0;
5843 u32 user_instance = 0;
5846 clib_memset (mac_address, 0, sizeof (mac_address));
5848 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5850 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5852 if (unformat (i, "instance %d", &user_instance))
5860 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
5861 mp_lbi->is_specified = is_specified;
5863 mp_lbi->user_instance = htonl (user_instance);
5865 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
5870 /* Construct the API message */
5871 M (CREATE_LOOPBACK, mp);
5873 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
5882 api_delete_loopback (vat_main_t * vam)
5884 unformat_input_t *i = vam->input;
5885 vl_api_delete_loopback_t *mp;
5886 u32 sw_if_index = ~0;
5889 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5891 if (unformat (i, "sw_if_index %d", &sw_if_index))
5897 if (sw_if_index == ~0)
5899 errmsg ("missing sw_if_index");
5903 /* Construct the API message */
5904 M (DELETE_LOOPBACK, mp);
5905 mp->sw_if_index = ntohl (sw_if_index);
5913 api_want_interface_events (vat_main_t * vam)
5915 unformat_input_t *i = vam->input;
5916 vl_api_want_interface_events_t *mp;
5920 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5922 if (unformat (i, "enable"))
5924 else if (unformat (i, "disable"))
5932 errmsg ("missing enable|disable");
5936 M (WANT_INTERFACE_EVENTS, mp);
5937 mp->enable_disable = enable;
5939 vam->interface_event_display = enable;
5947 /* Note: non-static, called once to set up the initial intfc table */
5949 api_sw_interface_dump (vat_main_t * vam)
5951 vl_api_sw_interface_dump_t *mp;
5952 vl_api_control_ping_t *mp_ping;
5954 name_sort_t *nses = 0, *ns;
5955 sw_interface_subif_t *sub = NULL;
5958 /* Toss the old name table */
5960 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5962 vec_add2 (nses, ns, 1);
5963 ns->name = (u8 *)(p->key);
5964 ns->value = (u32) p->value[0];
5968 hash_free (vam->sw_if_index_by_interface_name);
5970 vec_foreach (ns, nses) vec_free (ns->name);
5974 vec_foreach (sub, vam->sw_if_subif_table)
5976 vec_free (sub->interface_name);
5978 vec_free (vam->sw_if_subif_table);
5980 /* recreate the interface name hash table */
5981 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
5984 * Ask for all interface names. Otherwise, the epic catalog of
5985 * name filters becomes ridiculously long, and vat ends up needing
5986 * to be taught about new interface types.
5988 M (SW_INTERFACE_DUMP, mp);
5991 /* Use a control ping for synchronization */
5992 MPING (CONTROL_PING, mp_ping);
6000 api_sw_interface_set_flags (vat_main_t * vam)
6002 unformat_input_t *i = vam->input;
6003 vl_api_sw_interface_set_flags_t *mp;
6005 u8 sw_if_index_set = 0;
6009 /* Parse args required to build the message */
6010 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6012 if (unformat (i, "admin-up"))
6014 else if (unformat (i, "admin-down"))
6017 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6018 sw_if_index_set = 1;
6019 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6020 sw_if_index_set = 1;
6025 if (sw_if_index_set == 0)
6027 errmsg ("missing interface name or sw_if_index");
6031 /* Construct the API message */
6032 M (SW_INTERFACE_SET_FLAGS, mp);
6033 mp->sw_if_index = ntohl (sw_if_index);
6034 mp->admin_up_down = admin_up;
6039 /* Wait for a reply, return the good/bad news... */
6045 api_sw_interface_set_rx_mode (vat_main_t * vam)
6047 unformat_input_t *i = vam->input;
6048 vl_api_sw_interface_set_rx_mode_t *mp;
6050 u8 sw_if_index_set = 0;
6052 u8 queue_id_valid = 0;
6054 vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN;
6056 /* Parse args required to build the message */
6057 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6059 if (unformat (i, "queue %d", &queue_id))
6061 else if (unformat (i, "polling"))
6062 mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
6063 else if (unformat (i, "interrupt"))
6064 mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT;
6065 else if (unformat (i, "adaptive"))
6066 mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE;
6068 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6069 sw_if_index_set = 1;
6070 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6071 sw_if_index_set = 1;
6076 if (sw_if_index_set == 0)
6078 errmsg ("missing interface name or sw_if_index");
6081 if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
6083 errmsg ("missing rx-mode");
6087 /* Construct the API message */
6088 M (SW_INTERFACE_SET_RX_MODE, mp);
6089 mp->sw_if_index = ntohl (sw_if_index);
6091 mp->queue_id_valid = queue_id_valid;
6092 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
6097 /* Wait for a reply, return the good/bad news... */
6103 api_sw_interface_set_rx_placement (vat_main_t * vam)
6105 unformat_input_t *i = vam->input;
6106 vl_api_sw_interface_set_rx_placement_t *mp;
6108 u8 sw_if_index_set = 0;
6111 u32 queue_id, thread_index;
6113 /* Parse args required to build the message */
6114 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6116 if (unformat (i, "queue %d", &queue_id))
6118 else if (unformat (i, "main"))
6120 else if (unformat (i, "worker %d", &thread_index))
6123 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6124 sw_if_index_set = 1;
6125 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6126 sw_if_index_set = 1;
6131 if (sw_if_index_set == 0)
6133 errmsg ("missing interface name or sw_if_index");
6139 /* Construct the API message */
6140 M (SW_INTERFACE_SET_RX_PLACEMENT, mp);
6141 mp->sw_if_index = ntohl (sw_if_index);
6142 mp->worker_id = ntohl (thread_index);
6143 mp->queue_id = ntohl (queue_id);
6144 mp->is_main = is_main;
6148 /* Wait for a reply, return the good/bad news... */
6153 static void vl_api_sw_interface_rx_placement_details_t_handler
6154 (vl_api_sw_interface_rx_placement_details_t * mp)
6156 vat_main_t *vam = &vat_main;
6157 u32 worker_id = ntohl (mp->worker_id);
6160 "\n%-11d %-11s %-6d %-5d %-9s",
6161 ntohl (mp->sw_if_index), (worker_id == 0) ? "main" : "worker",
6162 worker_id, ntohl (mp->queue_id),
6164 1) ? "polling" : ((mp->mode == 2) ? "interrupt" : "adaptive"));
6167 static void vl_api_sw_interface_rx_placement_details_t_handler_json
6168 (vl_api_sw_interface_rx_placement_details_t * mp)
6170 vat_main_t *vam = &vat_main;
6171 vat_json_node_t *node = NULL;
6173 if (VAT_JSON_ARRAY != vam->json_tree.type)
6175 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
6176 vat_json_init_array (&vam->json_tree);
6178 node = vat_json_array_add (&vam->json_tree);
6180 vat_json_init_object (node);
6181 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
6182 vat_json_object_add_uint (node, "worker_id", ntohl (mp->worker_id));
6183 vat_json_object_add_uint (node, "queue_id", ntohl (mp->queue_id));
6184 vat_json_object_add_uint (node, "mode", mp->mode);
6188 api_sw_interface_rx_placement_dump (vat_main_t * vam)
6190 unformat_input_t *i = vam->input;
6191 vl_api_sw_interface_rx_placement_dump_t *mp;
6192 vl_api_control_ping_t *mp_ping;
6195 u8 sw_if_index_set = 0;
6197 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6199 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6201 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6208 "\n%-11s %-11s %-6s %-5s %-4s",
6209 "sw_if_index", "main/worker", "thread", "queue", "mode");
6211 /* Dump Interface rx placement */
6212 M (SW_INTERFACE_RX_PLACEMENT_DUMP, mp);
6214 if (sw_if_index_set)
6215 mp->sw_if_index = htonl (sw_if_index);
6217 mp->sw_if_index = ~0;
6221 /* Use a control ping for synchronization */
6222 MPING (CONTROL_PING, mp_ping);
6230 api_sw_interface_clear_stats (vat_main_t * vam)
6232 unformat_input_t *i = vam->input;
6233 vl_api_sw_interface_clear_stats_t *mp;
6235 u8 sw_if_index_set = 0;
6238 /* Parse args required to build the message */
6239 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6241 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6242 sw_if_index_set = 1;
6243 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6244 sw_if_index_set = 1;
6249 /* Construct the API message */
6250 M (SW_INTERFACE_CLEAR_STATS, mp);
6252 if (sw_if_index_set == 1)
6253 mp->sw_if_index = ntohl (sw_if_index);
6255 mp->sw_if_index = ~0;
6260 /* Wait for a reply, return the good/bad news... */
6266 api_sw_interface_add_del_address (vat_main_t * vam)
6268 unformat_input_t *i = vam->input;
6269 vl_api_sw_interface_add_del_address_t *mp;
6271 u8 sw_if_index_set = 0;
6272 u8 is_add = 1, del_all = 0;
6273 u32 address_length = 0;
6274 u8 v4_address_set = 0;
6275 u8 v6_address_set = 0;
6276 ip4_address_t v4address;
6277 ip6_address_t v6address;
6280 /* Parse args required to build the message */
6281 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6283 if (unformat (i, "del-all"))
6285 else if (unformat (i, "del"))
6288 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6289 sw_if_index_set = 1;
6290 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6291 sw_if_index_set = 1;
6292 else if (unformat (i, "%U/%d",
6293 unformat_ip4_address, &v4address, &address_length))
6295 else if (unformat (i, "%U/%d",
6296 unformat_ip6_address, &v6address, &address_length))
6302 if (sw_if_index_set == 0)
6304 errmsg ("missing interface name or sw_if_index");
6307 if (v4_address_set && v6_address_set)
6309 errmsg ("both v4 and v6 addresses set");
6312 if (!v4_address_set && !v6_address_set && !del_all)
6314 errmsg ("no addresses set");
6318 /* Construct the API message */
6319 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
6321 mp->sw_if_index = ntohl (sw_if_index);
6322 mp->is_add = is_add;
6323 mp->del_all = del_all;
6327 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6331 clib_memcpy (mp->address, &v4address, sizeof (v4address));
6333 mp->address_length = address_length;
6338 /* Wait for a reply, return good/bad news */
6344 api_sw_interface_set_mpls_enable (vat_main_t * vam)
6346 unformat_input_t *i = vam->input;
6347 vl_api_sw_interface_set_mpls_enable_t *mp;
6349 u8 sw_if_index_set = 0;
6353 /* Parse args required to build the message */
6354 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6356 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6357 sw_if_index_set = 1;
6358 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6359 sw_if_index_set = 1;
6360 else if (unformat (i, "disable"))
6362 else if (unformat (i, "dis"))
6368 if (sw_if_index_set == 0)
6370 errmsg ("missing interface name or sw_if_index");
6374 /* Construct the API message */
6375 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
6377 mp->sw_if_index = ntohl (sw_if_index);
6378 mp->enable = enable;
6383 /* Wait for a reply... */
6389 api_sw_interface_set_table (vat_main_t * vam)
6391 unformat_input_t *i = vam->input;
6392 vl_api_sw_interface_set_table_t *mp;
6393 u32 sw_if_index, vrf_id = 0;
6394 u8 sw_if_index_set = 0;
6398 /* Parse args required to build the message */
6399 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6401 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6402 sw_if_index_set = 1;
6403 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6404 sw_if_index_set = 1;
6405 else if (unformat (i, "vrf %d", &vrf_id))
6407 else if (unformat (i, "ipv6"))
6413 if (sw_if_index_set == 0)
6415 errmsg ("missing interface name or sw_if_index");
6419 /* Construct the API message */
6420 M (SW_INTERFACE_SET_TABLE, mp);
6422 mp->sw_if_index = ntohl (sw_if_index);
6423 mp->is_ipv6 = is_ipv6;
6424 mp->vrf_id = ntohl (vrf_id);
6429 /* Wait for a reply... */
6434 static void vl_api_sw_interface_get_table_reply_t_handler
6435 (vl_api_sw_interface_get_table_reply_t * mp)
6437 vat_main_t *vam = &vat_main;
6439 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6441 vam->retval = ntohl (mp->retval);
6442 vam->result_ready = 1;
6446 static void vl_api_sw_interface_get_table_reply_t_handler_json
6447 (vl_api_sw_interface_get_table_reply_t * mp)
6449 vat_main_t *vam = &vat_main;
6450 vat_json_node_t node;
6452 vat_json_init_object (&node);
6453 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6454 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6456 vat_json_print (vam->ofp, &node);
6457 vat_json_free (&node);
6459 vam->retval = ntohl (mp->retval);
6460 vam->result_ready = 1;
6464 api_sw_interface_get_table (vat_main_t * vam)
6466 unformat_input_t *i = vam->input;
6467 vl_api_sw_interface_get_table_t *mp;
6469 u8 sw_if_index_set = 0;
6473 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6475 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6476 sw_if_index_set = 1;
6477 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6478 sw_if_index_set = 1;
6479 else if (unformat (i, "ipv6"))
6485 if (sw_if_index_set == 0)
6487 errmsg ("missing interface name or sw_if_index");
6491 M (SW_INTERFACE_GET_TABLE, mp);
6492 mp->sw_if_index = htonl (sw_if_index);
6493 mp->is_ipv6 = is_ipv6;
6501 api_sw_interface_set_vpath (vat_main_t * vam)
6503 unformat_input_t *i = vam->input;
6504 vl_api_sw_interface_set_vpath_t *mp;
6505 u32 sw_if_index = 0;
6506 u8 sw_if_index_set = 0;
6510 /* Parse args required to build the message */
6511 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6513 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6514 sw_if_index_set = 1;
6515 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6516 sw_if_index_set = 1;
6517 else if (unformat (i, "enable"))
6519 else if (unformat (i, "disable"))
6525 if (sw_if_index_set == 0)
6527 errmsg ("missing interface name or sw_if_index");
6531 /* Construct the API message */
6532 M (SW_INTERFACE_SET_VPATH, mp);
6534 mp->sw_if_index = ntohl (sw_if_index);
6535 mp->enable = is_enable;
6540 /* Wait for a reply... */
6546 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
6548 unformat_input_t *i = vam->input;
6549 vl_api_sw_interface_set_vxlan_bypass_t *mp;
6550 u32 sw_if_index = 0;
6551 u8 sw_if_index_set = 0;
6556 /* Parse args required to build the message */
6557 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6559 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6560 sw_if_index_set = 1;
6561 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6562 sw_if_index_set = 1;
6563 else if (unformat (i, "enable"))
6565 else if (unformat (i, "disable"))
6567 else if (unformat (i, "ip4"))
6569 else if (unformat (i, "ip6"))
6575 if (sw_if_index_set == 0)
6577 errmsg ("missing interface name or sw_if_index");
6581 /* Construct the API message */
6582 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
6584 mp->sw_if_index = ntohl (sw_if_index);
6585 mp->enable = is_enable;
6586 mp->is_ipv6 = is_ipv6;
6591 /* Wait for a reply... */
6597 api_sw_interface_set_geneve_bypass (vat_main_t * vam)
6599 unformat_input_t *i = vam->input;
6600 vl_api_sw_interface_set_geneve_bypass_t *mp;
6601 u32 sw_if_index = 0;
6602 u8 sw_if_index_set = 0;
6607 /* Parse args required to build the message */
6608 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6610 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6611 sw_if_index_set = 1;
6612 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6613 sw_if_index_set = 1;
6614 else if (unformat (i, "enable"))
6616 else if (unformat (i, "disable"))
6618 else if (unformat (i, "ip4"))
6620 else if (unformat (i, "ip6"))
6626 if (sw_if_index_set == 0)
6628 errmsg ("missing interface name or sw_if_index");
6632 /* Construct the API message */
6633 M (SW_INTERFACE_SET_GENEVE_BYPASS, mp);
6635 mp->sw_if_index = ntohl (sw_if_index);
6636 mp->enable = is_enable;
6637 mp->is_ipv6 = is_ipv6;
6642 /* Wait for a reply... */
6648 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
6650 unformat_input_t *i = vam->input;
6651 vl_api_sw_interface_set_l2_xconnect_t *mp;
6653 u8 rx_sw_if_index_set = 0;
6655 u8 tx_sw_if_index_set = 0;
6659 /* Parse args required to build the message */
6660 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6662 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6663 rx_sw_if_index_set = 1;
6664 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6665 tx_sw_if_index_set = 1;
6666 else if (unformat (i, "rx"))
6668 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6670 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6672 rx_sw_if_index_set = 1;
6677 else if (unformat (i, "tx"))
6679 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6681 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6683 tx_sw_if_index_set = 1;
6688 else if (unformat (i, "enable"))
6690 else if (unformat (i, "disable"))
6696 if (rx_sw_if_index_set == 0)
6698 errmsg ("missing rx interface name or rx_sw_if_index");
6702 if (enable && (tx_sw_if_index_set == 0))
6704 errmsg ("missing tx interface name or tx_sw_if_index");
6708 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
6710 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6711 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6712 mp->enable = enable;
6720 api_sw_interface_set_l2_bridge (vat_main_t * vam)
6722 unformat_input_t *i = vam->input;
6723 vl_api_sw_interface_set_l2_bridge_t *mp;
6724 vl_api_l2_port_type_t port_type;
6726 u8 rx_sw_if_index_set = 0;
6733 port_type = L2_API_PORT_TYPE_NORMAL;
6735 /* Parse args required to build the message */
6736 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6738 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
6739 rx_sw_if_index_set = 1;
6740 else if (unformat (i, "bd_id %d", &bd_id))
6744 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
6745 rx_sw_if_index_set = 1;
6746 else if (unformat (i, "shg %d", &shg))
6748 else if (unformat (i, "bvi"))
6749 port_type = L2_API_PORT_TYPE_BVI;
6750 else if (unformat (i, "uu-fwd"))
6751 port_type = L2_API_PORT_TYPE_UU_FWD;
6752 else if (unformat (i, "enable"))
6754 else if (unformat (i, "disable"))
6760 if (rx_sw_if_index_set == 0)
6762 errmsg ("missing rx interface name or sw_if_index");
6766 if (enable && (bd_id_set == 0))
6768 errmsg ("missing bridge domain");
6772 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
6774 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6775 mp->bd_id = ntohl (bd_id);
6777 mp->port_type = ntohl (port_type);
6778 mp->enable = enable;
6786 api_bridge_domain_dump (vat_main_t * vam)
6788 unformat_input_t *i = vam->input;
6789 vl_api_bridge_domain_dump_t *mp;
6790 vl_api_control_ping_t *mp_ping;
6794 /* Parse args required to build the message */
6795 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6797 if (unformat (i, "bd_id %d", &bd_id))
6803 M (BRIDGE_DOMAIN_DUMP, mp);
6804 mp->bd_id = ntohl (bd_id);
6807 /* Use a control ping for synchronization */
6808 MPING (CONTROL_PING, mp_ping);
6816 api_bridge_domain_add_del (vat_main_t * vam)
6818 unformat_input_t *i = vam->input;
6819 vl_api_bridge_domain_add_del_t *mp;
6822 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
6827 /* Parse args required to build the message */
6828 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6830 if (unformat (i, "bd_id %d", &bd_id))
6832 else if (unformat (i, "flood %d", &flood))
6834 else if (unformat (i, "uu-flood %d", &uu_flood))
6836 else if (unformat (i, "forward %d", &forward))
6838 else if (unformat (i, "learn %d", &learn))
6840 else if (unformat (i, "arp-term %d", &arp_term))
6842 else if (unformat (i, "mac-age %d", &mac_age))
6844 else if (unformat (i, "bd-tag %s", &bd_tag))
6846 else if (unformat (i, "del"))
6849 flood = uu_flood = forward = learn = 0;
6857 errmsg ("missing bridge domain");
6864 errmsg ("mac age must be less than 256 ");
6869 if ((bd_tag) && (vec_len (bd_tag) > 63))
6871 errmsg ("bd-tag cannot be longer than 63");
6876 M (BRIDGE_DOMAIN_ADD_DEL, mp);
6878 mp->bd_id = ntohl (bd_id);
6880 mp->uu_flood = uu_flood;
6881 mp->forward = forward;
6883 mp->arp_term = arp_term;
6884 mp->is_add = is_add;
6885 mp->mac_age = (u8) mac_age;
6888 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
6889 mp->bd_tag[vec_len (bd_tag)] = 0;
6900 api_l2fib_flush_bd (vat_main_t * vam)
6902 unformat_input_t *i = vam->input;
6903 vl_api_l2fib_flush_bd_t *mp;
6907 /* Parse args required to build the message */
6908 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6910 if (unformat (i, "bd_id %d", &bd_id));
6917 errmsg ("missing bridge domain");
6921 M (L2FIB_FLUSH_BD, mp);
6923 mp->bd_id = htonl (bd_id);
6931 api_l2fib_flush_int (vat_main_t * vam)
6933 unformat_input_t *i = vam->input;
6934 vl_api_l2fib_flush_int_t *mp;
6935 u32 sw_if_index = ~0;
6938 /* Parse args required to build the message */
6939 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6941 if (unformat (i, "sw_if_index %d", &sw_if_index));
6943 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
6948 if (sw_if_index == ~0)
6950 errmsg ("missing interface name or sw_if_index");
6954 M (L2FIB_FLUSH_INT, mp);
6956 mp->sw_if_index = ntohl (sw_if_index);
6964 api_l2fib_add_del (vat_main_t * vam)
6966 unformat_input_t *i = vam->input;
6967 vl_api_l2fib_add_del_t *mp;
6973 u32 sw_if_index = 0;
6974 u8 sw_if_index_set = 0;
6983 /* Parse args required to build the message */
6984 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6986 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
6988 else if (unformat (i, "bd_id %d", &bd_id))
6990 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6991 sw_if_index_set = 1;
6992 else if (unformat (i, "sw_if"))
6994 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6997 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6998 sw_if_index_set = 1;
7003 else if (unformat (i, "static"))
7005 else if (unformat (i, "filter"))
7010 else if (unformat (i, "bvi"))
7015 else if (unformat (i, "del"))
7017 else if (unformat (i, "count %d", &count))
7025 errmsg ("missing mac address");
7031 errmsg ("missing bridge domain");
7035 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
7037 errmsg ("missing interface name or sw_if_index");
7043 /* Turn on async mode */
7044 vam->async_mode = 1;
7045 vam->async_errors = 0;
7046 before = vat_time_now (vam);
7049 for (j = 0; j < count; j++)
7051 M (L2FIB_ADD_DEL, mp);
7053 clib_memcpy (mp->mac, mac, 6);
7054 mp->bd_id = ntohl (bd_id);
7055 mp->is_add = is_add;
7056 mp->sw_if_index = ntohl (sw_if_index);
7060 mp->static_mac = static_mac;
7061 mp->filter_mac = filter_mac;
7062 mp->bvi_mac = bvi_mac;
7064 increment_mac_address (mac);
7071 vl_api_control_ping_t *mp_ping;
7074 /* Shut off async mode */
7075 vam->async_mode = 0;
7077 MPING (CONTROL_PING, mp_ping);
7080 timeout = vat_time_now (vam) + 1.0;
7081 while (vat_time_now (vam) < timeout)
7082 if (vam->result_ready == 1)
7087 if (vam->retval == -99)
7090 if (vam->async_errors > 0)
7092 errmsg ("%d asynchronous errors", vam->async_errors);
7095 vam->async_errors = 0;
7096 after = vat_time_now (vam);
7098 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
7099 count, after - before, count / (after - before));
7105 /* Wait for a reply... */
7109 /* Return the good/bad news */
7110 return (vam->retval);
7114 api_bridge_domain_set_mac_age (vat_main_t * vam)
7116 unformat_input_t *i = vam->input;
7117 vl_api_bridge_domain_set_mac_age_t *mp;
7122 /* Parse args required to build the message */
7123 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7125 if (unformat (i, "bd_id %d", &bd_id));
7126 else if (unformat (i, "mac-age %d", &mac_age));
7133 errmsg ("missing bridge domain");
7139 errmsg ("mac age must be less than 256 ");
7143 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
7145 mp->bd_id = htonl (bd_id);
7146 mp->mac_age = (u8) mac_age;
7154 api_l2_flags (vat_main_t * vam)
7156 unformat_input_t *i = vam->input;
7157 vl_api_l2_flags_t *mp;
7160 u8 sw_if_index_set = 0;
7164 /* Parse args required to build the message */
7165 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7167 if (unformat (i, "sw_if_index %d", &sw_if_index))
7168 sw_if_index_set = 1;
7169 else if (unformat (i, "sw_if"))
7171 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7174 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7175 sw_if_index_set = 1;
7180 else if (unformat (i, "learn"))
7182 else if (unformat (i, "forward"))
7184 else if (unformat (i, "flood"))
7186 else if (unformat (i, "uu-flood"))
7187 flags |= L2_UU_FLOOD;
7188 else if (unformat (i, "arp-term"))
7189 flags |= L2_ARP_TERM;
7190 else if (unformat (i, "off"))
7192 else if (unformat (i, "disable"))
7198 if (sw_if_index_set == 0)
7200 errmsg ("missing interface name or sw_if_index");
7206 mp->sw_if_index = ntohl (sw_if_index);
7207 mp->feature_bitmap = ntohl (flags);
7208 mp->is_set = is_set;
7216 api_bridge_flags (vat_main_t * vam)
7218 unformat_input_t *i = vam->input;
7219 vl_api_bridge_flags_t *mp;
7223 bd_flags_t flags = 0;
7226 /* Parse args required to build the message */
7227 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7229 if (unformat (i, "bd_id %d", &bd_id))
7231 else if (unformat (i, "learn"))
7232 flags |= BRIDGE_API_FLAG_LEARN;
7233 else if (unformat (i, "forward"))
7234 flags |= BRIDGE_API_FLAG_FWD;
7235 else if (unformat (i, "flood"))
7236 flags |= BRIDGE_API_FLAG_FLOOD;
7237 else if (unformat (i, "uu-flood"))
7238 flags |= BRIDGE_API_FLAG_UU_FLOOD;
7239 else if (unformat (i, "arp-term"))
7240 flags |= BRIDGE_API_FLAG_ARP_TERM;
7241 else if (unformat (i, "off"))
7243 else if (unformat (i, "disable"))
7251 errmsg ("missing bridge domain");
7255 M (BRIDGE_FLAGS, mp);
7257 mp->bd_id = ntohl (bd_id);
7258 mp->flags = ntohl (flags);
7259 mp->is_set = is_set;
7267 api_bd_ip_mac_add_del (vat_main_t * vam)
7269 vl_api_address_t ip = VL_API_ZERO_ADDRESS;
7270 vl_api_mac_address_t mac = { 0 };
7271 unformat_input_t *i = vam->input;
7272 vl_api_bd_ip_mac_add_del_t *mp;
7284 /* Parse args required to build the message */
7285 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7287 if (unformat (i, "bd_id %d", &bd_id))
7291 else if (unformat (i, "%U", unformat_vl_api_address, &ip))
7295 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
7299 else if (unformat (i, "del"))
7307 errmsg ("missing bridge domain");
7310 else if (ip_set == 0)
7312 errmsg ("missing IP address");
7315 else if (mac_set == 0)
7317 errmsg ("missing MAC address");
7321 M (BD_IP_MAC_ADD_DEL, mp);
7323 mp->bd_id = ntohl (bd_id);
7324 mp->is_add = is_add;
7326 clib_memcpy (&mp->ip, &ip, sizeof (ip));
7327 clib_memcpy (&mp->mac, &mac, sizeof (mac));
7335 api_bd_ip_mac_flush (vat_main_t * vam)
7337 unformat_input_t *i = vam->input;
7338 vl_api_bd_ip_mac_flush_t *mp;
7343 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7345 if (unformat (i, "bd_id %d", &bd_id))
7355 errmsg ("missing bridge domain");
7359 M (BD_IP_MAC_FLUSH, mp);
7361 mp->bd_id = ntohl (bd_id);
7368 static void vl_api_bd_ip_mac_details_t_handler
7369 (vl_api_bd_ip_mac_details_t * mp)
7371 vat_main_t *vam = &vat_main;
7376 format (0, "%U", format_ip4_address, (ip4_address_t *) mp->ip_address);
7379 format (0, "%U", format_ip6_address, (ip6_address_t *) mp->ip_address);
7382 "\n%-5d %-7s %-20U %-30s",
7383 ntohl (mp->bd_id), mp->is_ipv6 ? "ip6" : "ip4",
7384 format_ethernet_address, mp->mac_address, ip);
7389 static void vl_api_bd_ip_mac_details_t_handler_json
7390 (vl_api_bd_ip_mac_details_t * mp)
7392 vat_main_t *vam = &vat_main;
7393 vat_json_node_t *node = NULL;
7395 if (VAT_JSON_ARRAY != vam->json_tree.type)
7397 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7398 vat_json_init_array (&vam->json_tree);
7400 node = vat_json_array_add (&vam->json_tree);
7402 vat_json_init_object (node);
7403 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
7404 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6);
7405 vat_json_object_add_string_copy (node, "mac_address",
7406 format (0, "%U", format_ethernet_address,
7412 format (0, "%U", format_ip4_address, (ip4_address_t *) mp->ip_address);
7415 format (0, "%U", format_ip6_address, (ip6_address_t *) mp->ip_address);
7416 vat_json_object_add_string_copy (node, "ip_address", ip);
7421 api_bd_ip_mac_dump (vat_main_t * vam)
7423 unformat_input_t *i = vam->input;
7424 vl_api_bd_ip_mac_dump_t *mp;
7425 vl_api_control_ping_t *mp_ping;
7430 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7432 if (unformat (i, "bd_id %d", &bd_id))
7441 "\n%-5s %-7s %-20s %-30s",
7442 "bd_id", "is_ipv6", "mac_address", "ip_address");
7444 /* Dump Bridge Domain Ip to Mac entries */
7445 M (BD_IP_MAC_DUMP, mp);
7448 mp->bd_id = htonl (bd_id);
7454 /* Use a control ping for synchronization */
7455 MPING (CONTROL_PING, mp_ping);
7463 api_tap_create_v2 (vat_main_t * vam)
7465 unformat_input_t *i = vam->input;
7466 vl_api_tap_create_v2_t *mp;
7470 u8 *host_if_name = 0;
7472 u8 host_mac_addr[6];
7473 u8 host_mac_addr_set = 0;
7474 u8 *host_bridge = 0;
7475 ip4_address_t host_ip4_addr;
7476 ip4_address_t host_ip4_gw;
7477 u8 host_ip4_gw_set = 0;
7478 u32 host_ip4_prefix_len = 0;
7479 ip6_address_t host_ip6_addr;
7480 ip6_address_t host_ip6_gw;
7481 u8 host_ip6_gw_set = 0;
7482 u32 host_ip6_prefix_len = 0;
7484 u32 rx_ring_sz = 0, tx_ring_sz = 0;
7486 clib_memset (mac_address, 0, sizeof (mac_address));
7488 /* Parse args required to build the message */
7489 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7491 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7495 else if (unformat (i, "id %u", &id))
7497 else if (unformat (i, "host-if-name %s", &host_if_name))
7499 else if (unformat (i, "host-ns %s", &host_ns))
7501 else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
7503 host_mac_addr_set = 1;
7504 else if (unformat (i, "host-bridge %s", &host_bridge))
7506 else if (unformat (i, "host-ip4-addr %U/%d", unformat_ip4_address,
7507 &host_ip4_addr, &host_ip4_prefix_len))
7509 else if (unformat (i, "host-ip6-addr %U/%d", unformat_ip6_address,
7510 &host_ip6_addr, &host_ip6_prefix_len))
7512 else if (unformat (i, "host-ip4-gw %U", unformat_ip4_address,
7514 host_ip4_gw_set = 1;
7515 else if (unformat (i, "host-ip6-gw %U", unformat_ip6_address,
7517 host_ip6_gw_set = 1;
7518 else if (unformat (i, "rx-ring-size %d", &rx_ring_sz))
7520 else if (unformat (i, "tx-ring-size %d", &tx_ring_sz))
7526 if (vec_len (host_if_name) > 63)
7528 errmsg ("tap name too long. ");
7531 if (vec_len (host_ns) > 63)
7533 errmsg ("host name space too long. ");
7536 if (vec_len (host_bridge) > 63)
7538 errmsg ("host bridge name too long. ");
7541 if (host_ip4_prefix_len > 32)
7543 errmsg ("host ip4 prefix length not valid. ");
7546 if (host_ip6_prefix_len > 128)
7548 errmsg ("host ip6 prefix length not valid. ");
7551 if (!is_pow2 (rx_ring_sz))
7553 errmsg ("rx ring size must be power of 2. ");
7556 if (rx_ring_sz > 32768)
7558 errmsg ("rx ring size must be 32768 or lower. ");
7561 if (!is_pow2 (tx_ring_sz))
7563 errmsg ("tx ring size must be power of 2. ");
7566 if (tx_ring_sz > 32768)
7568 errmsg ("tx ring size must be 32768 or lower. ");
7572 /* Construct the API message */
7573 M (TAP_CREATE_V2, mp);
7575 mp->use_random_mac = random_mac;
7577 mp->id = ntohl (id);
7578 mp->host_namespace_set = host_ns != 0;
7579 mp->host_bridge_set = host_bridge != 0;
7580 mp->host_ip4_addr_set = host_ip4_prefix_len != 0;
7581 mp->host_ip6_addr_set = host_ip6_prefix_len != 0;
7582 mp->rx_ring_sz = ntohs (rx_ring_sz);
7583 mp->tx_ring_sz = ntohs (tx_ring_sz);
7585 if (random_mac == 0)
7586 clib_memcpy (mp->mac_address, mac_address, 6);
7587 if (host_mac_addr_set)
7588 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
7590 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
7592 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
7594 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
7595 if (host_ip4_prefix_len)
7596 clib_memcpy (mp->host_ip4_addr, &host_ip4_addr, 4);
7597 if (host_ip6_prefix_len)
7598 clib_memcpy (mp->host_ip6_addr, &host_ip6_addr, 16);
7599 if (host_ip4_gw_set)
7600 clib_memcpy (mp->host_ip4_gw, &host_ip4_gw, 4);
7601 if (host_ip6_gw_set)
7602 clib_memcpy (mp->host_ip6_gw, &host_ip6_gw, 16);
7605 vec_free (host_if_name);
7606 vec_free (host_bridge);
7611 /* Wait for a reply... */
7617 api_tap_delete_v2 (vat_main_t * vam)
7619 unformat_input_t *i = vam->input;
7620 vl_api_tap_delete_v2_t *mp;
7621 u32 sw_if_index = ~0;
7622 u8 sw_if_index_set = 0;
7625 /* Parse args required to build the message */
7626 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7628 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7629 sw_if_index_set = 1;
7630 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7631 sw_if_index_set = 1;
7636 if (sw_if_index_set == 0)
7638 errmsg ("missing vpp interface name. ");
7642 /* Construct the API message */
7643 M (TAP_DELETE_V2, mp);
7645 mp->sw_if_index = ntohl (sw_if_index);
7650 /* Wait for a reply... */
7656 unformat_pci_addr (unformat_input_t * input, va_list * args)
7665 addr = va_arg (*args, struct pci_addr_t *);
7668 if (!unformat (input, "%x:%x:%x.%x", &x[0], &x[1], &x[2], &x[3]))
7671 addr->domain = x[0];
7674 addr->function = x[3];
7680 api_virtio_pci_create (vat_main_t * vam)
7682 unformat_input_t *i = vam->input;
7683 vl_api_virtio_pci_create_t *mp;
7687 u64 features = (u64) ~ (0ULL);
7688 u32 rx_ring_sz = 0, tx_ring_sz = 0;
7691 clib_memset (mac_address, 0, sizeof (mac_address));
7693 /* Parse args required to build the message */
7694 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7696 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7700 else if (unformat (i, "pci-addr %U", unformat_pci_addr, &pci_addr))
7702 else if (unformat (i, "features 0x%llx", &features))
7704 else if (unformat (i, "rx-ring-size %u", &rx_ring_sz))
7706 else if (unformat (i, "tx-ring-size %u", &tx_ring_sz))
7714 errmsg ("pci address must be non zero. ");
7717 if (!is_pow2 (rx_ring_sz))
7719 errmsg ("rx ring size must be power of 2. ");
7722 if (rx_ring_sz > 32768)
7724 errmsg ("rx ring size must be 32768 or lower. ");
7727 if (!is_pow2 (tx_ring_sz))
7729 errmsg ("tx ring size must be power of 2. ");
7732 if (tx_ring_sz > 32768)
7734 errmsg ("tx ring size must be 32768 or lower. ");
7738 /* Construct the API message */
7739 M (VIRTIO_PCI_CREATE, mp);
7741 mp->use_random_mac = random_mac;
7743 mp->pci_addr = htonl (pci_addr);
7744 mp->features = clib_host_to_net_u64 (features);
7746 if (random_mac == 0)
7747 clib_memcpy (mp->mac_address, mac_address, 6);
7752 /* Wait for a reply... */
7758 api_virtio_pci_delete (vat_main_t * vam)
7760 unformat_input_t *i = vam->input;
7761 vl_api_virtio_pci_delete_t *mp;
7762 u32 sw_if_index = ~0;
7763 u8 sw_if_index_set = 0;
7766 /* Parse args required to build the message */
7767 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7769 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7770 sw_if_index_set = 1;
7771 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7772 sw_if_index_set = 1;
7777 if (sw_if_index_set == 0)
7779 errmsg ("missing vpp interface name. ");
7783 /* Construct the API message */
7784 M (VIRTIO_PCI_DELETE, mp);
7786 mp->sw_if_index = htonl (sw_if_index);
7791 /* Wait for a reply... */
7797 api_bond_create (vat_main_t * vam)
7799 unformat_input_t *i = vam->input;
7800 vl_api_bond_create_t *mp;
7809 clib_memset (mac_address, 0, sizeof (mac_address));
7812 /* Parse args required to build the message */
7813 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7815 if (unformat (i, "mode %U", unformat_bond_mode, &mode))
7817 else if (((mode == BOND_MODE_LACP) || (mode == BOND_MODE_XOR))
7818 && unformat (i, "lb %U", unformat_bond_load_balance, &lb))
7820 else if (unformat (i, "hw-addr %U", unformat_ethernet_address,
7823 else if (unformat (i, "id %u", &id))
7829 if (mode_is_set == 0)
7831 errmsg ("Missing bond mode. ");
7835 /* Construct the API message */
7836 M (BOND_CREATE, mp);
7838 mp->use_custom_mac = custom_mac;
7842 mp->id = htonl (id);
7845 clib_memcpy (mp->mac_address, mac_address, 6);
7850 /* Wait for a reply... */
7856 api_bond_delete (vat_main_t * vam)
7858 unformat_input_t *i = vam->input;
7859 vl_api_bond_delete_t *mp;
7860 u32 sw_if_index = ~0;
7861 u8 sw_if_index_set = 0;
7864 /* Parse args required to build the message */
7865 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7867 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7868 sw_if_index_set = 1;
7869 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7870 sw_if_index_set = 1;
7875 if (sw_if_index_set == 0)
7877 errmsg ("missing vpp interface name. ");
7881 /* Construct the API message */
7882 M (BOND_DELETE, mp);
7884 mp->sw_if_index = ntohl (sw_if_index);
7889 /* Wait for a reply... */
7895 api_bond_enslave (vat_main_t * vam)
7897 unformat_input_t *i = vam->input;
7898 vl_api_bond_enslave_t *mp;
7899 u32 bond_sw_if_index;
7903 u32 bond_sw_if_index_is_set = 0;
7905 u8 sw_if_index_is_set = 0;
7907 /* Parse args required to build the message */
7908 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7910 if (unformat (i, "sw_if_index %d", &sw_if_index))
7911 sw_if_index_is_set = 1;
7912 else if (unformat (i, "bond %u", &bond_sw_if_index))
7913 bond_sw_if_index_is_set = 1;
7914 else if (unformat (i, "passive %d", &is_passive))
7916 else if (unformat (i, "long-timeout %d", &is_long_timeout))
7922 if (bond_sw_if_index_is_set == 0)
7924 errmsg ("Missing bond sw_if_index. ");
7927 if (sw_if_index_is_set == 0)
7929 errmsg ("Missing slave sw_if_index. ");
7933 /* Construct the API message */
7934 M (BOND_ENSLAVE, mp);
7936 mp->bond_sw_if_index = ntohl (bond_sw_if_index);
7937 mp->sw_if_index = ntohl (sw_if_index);
7938 mp->is_long_timeout = is_long_timeout;
7939 mp->is_passive = is_passive;
7944 /* Wait for a reply... */
7950 api_bond_detach_slave (vat_main_t * vam)
7952 unformat_input_t *i = vam->input;
7953 vl_api_bond_detach_slave_t *mp;
7954 u32 sw_if_index = ~0;
7955 u8 sw_if_index_set = 0;
7958 /* Parse args required to build the message */
7959 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7961 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7962 sw_if_index_set = 1;
7963 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7964 sw_if_index_set = 1;
7969 if (sw_if_index_set == 0)
7971 errmsg ("missing vpp interface name. ");
7975 /* Construct the API message */
7976 M (BOND_DETACH_SLAVE, mp);
7978 mp->sw_if_index = ntohl (sw_if_index);
7983 /* Wait for a reply... */
7989 api_ip_table_add_del (vat_main_t * vam)
7991 unformat_input_t *i = vam->input;
7992 vl_api_ip_table_add_del_t *mp;
7998 /* Parse args required to build the message */
7999 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8001 if (unformat (i, "ipv6"))
8003 else if (unformat (i, "del"))
8005 else if (unformat (i, "add"))
8007 else if (unformat (i, "table %d", &table_id))
8011 clib_warning ("parse error '%U'", format_unformat_error, i);
8018 errmsg ("missing table-ID");
8022 /* Construct the API message */
8023 M (IP_TABLE_ADD_DEL, mp);
8025 mp->table_id = ntohl (table_id);
8026 mp->is_ipv6 = is_ipv6;
8027 mp->is_add = is_add;
8032 /* Wait for a reply... */
8039 api_ip_add_del_route (vat_main_t * vam)
8041 unformat_input_t *i = vam->input;
8042 vl_api_ip_add_del_route_t *mp;
8043 u32 sw_if_index = ~0, vrf_id = 0;
8045 u8 is_local = 0, is_drop = 0;
8046 u8 is_unreach = 0, is_prohibit = 0;
8048 u32 next_hop_weight = 1;
8049 u8 is_multipath = 0;
8051 u8 address_length_set = 0;
8052 u32 next_hop_table_id = 0;
8053 u32 resolve_attempts = 0;
8054 u32 dst_address_length = 0;
8055 u8 next_hop_set = 0;
8056 ip4_address_t v4_dst_address, v4_next_hop_address;
8057 ip6_address_t v6_dst_address, v6_next_hop_address;
8061 u32 random_add_del = 0;
8062 u32 *random_vector = 0;
8064 u32 random_seed = 0xdeaddabe;
8065 u32 classify_table_index = ~0;
8067 u8 resolve_host = 0, resolve_attached = 0;
8068 vl_api_fib_mpls_label_t *next_hop_out_label_stack = NULL;
8069 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8070 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
8072 clib_memset (&v4_next_hop_address, 0, sizeof (ip4_address_t));
8073 clib_memset (&v6_next_hop_address, 0, sizeof (ip6_address_t));
8074 /* Parse args required to build the message */
8075 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8077 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8079 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8081 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
8086 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
8091 else if (unformat (i, "/%d", &dst_address_length))
8093 address_length_set = 1;
8096 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
8097 &v4_next_hop_address))
8101 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
8102 &v6_next_hop_address))
8108 (i, "via %U", api_unformat_sw_if_index, vam, &sw_if_index))
8112 else if (unformat (i, "via sw_if_index %d", &sw_if_index))
8116 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
8118 else if (unformat (i, "weight %d", &next_hop_weight))
8120 else if (unformat (i, "drop"))
8124 else if (unformat (i, "null-send-unreach"))
8128 else if (unformat (i, "null-send-prohibit"))
8132 else if (unformat (i, "local"))
8136 else if (unformat (i, "classify %d", &classify_table_index))
8140 else if (unformat (i, "del"))
8142 else if (unformat (i, "add"))
8144 else if (unformat (i, "resolve-via-host"))
8146 else if (unformat (i, "resolve-via-attached"))
8147 resolve_attached = 1;
8148 else if (unformat (i, "multipath"))
8150 else if (unformat (i, "vrf %d", &vrf_id))
8152 else if (unformat (i, "count %d", &count))
8154 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
8156 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
8158 else if (unformat (i, "out-label %d", &next_hop_out_label))
8160 vl_api_fib_mpls_label_t fib_label = {
8161 .label = ntohl (next_hop_out_label),
8165 vec_add1 (next_hop_out_label_stack, fib_label);
8167 else if (unformat (i, "via via-label %d", &next_hop_via_label))
8169 else if (unformat (i, "random"))
8171 else if (unformat (i, "seed %d", &random_seed))
8175 clib_warning ("parse error '%U'", format_unformat_error, i);
8180 if (!next_hop_set && !is_drop && !is_local &&
8181 !is_classify && !is_unreach && !is_prohibit &&
8182 MPLS_LABEL_INVALID == next_hop_via_label)
8185 ("next hop / local / drop / unreach / prohibit / classify not set");
8189 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
8191 errmsg ("next hop and next-hop via label set");
8194 if (address_set == 0)
8196 errmsg ("missing addresses");
8200 if (address_length_set == 0)
8202 errmsg ("missing address length");
8206 /* Generate a pile of unique, random routes */
8209 u32 this_random_address;
8210 random_hash = hash_create (count, sizeof (uword));
8212 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
8213 for (j = 0; j <= count; j++)
8217 this_random_address = random_u32 (&random_seed);
8218 this_random_address =
8219 clib_host_to_net_u32 (this_random_address);
8221 while (hash_get (random_hash, this_random_address));
8222 vec_add1 (random_vector, this_random_address);
8223 hash_set (random_hash, this_random_address, 1);
8225 hash_free (random_hash);
8226 v4_dst_address.as_u32 = random_vector[0];
8231 /* Turn on async mode */
8232 vam->async_mode = 1;
8233 vam->async_errors = 0;
8234 before = vat_time_now (vam);
8237 for (j = 0; j < count; j++)
8239 /* Construct the API message */
8240 M2 (IP_ADD_DEL_ROUTE, mp, sizeof (vl_api_fib_mpls_label_t) *
8241 vec_len (next_hop_out_label_stack));
8243 mp->next_hop_sw_if_index = ntohl (sw_if_index);
8244 mp->table_id = ntohl (vrf_id);
8246 mp->is_add = is_add;
8247 mp->is_drop = is_drop;
8248 mp->is_unreach = is_unreach;
8249 mp->is_prohibit = is_prohibit;
8250 mp->is_ipv6 = is_ipv6;
8251 mp->is_local = is_local;
8252 mp->is_classify = is_classify;
8253 mp->is_multipath = is_multipath;
8254 mp->is_resolve_host = resolve_host;
8255 mp->is_resolve_attached = resolve_attached;
8256 mp->next_hop_weight = next_hop_weight;
8257 mp->next_hop_preference = 0;
8258 mp->dst_address_length = dst_address_length;
8259 mp->next_hop_table_id = ntohl (next_hop_table_id);
8260 mp->classify_table_index = ntohl (classify_table_index);
8261 mp->next_hop_via_label = ntohl (next_hop_via_label);
8262 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
8263 if (0 != mp->next_hop_n_out_labels)
8265 memcpy (mp->next_hop_out_label_stack,
8266 next_hop_out_label_stack,
8267 (vec_len (next_hop_out_label_stack) *
8268 sizeof (vl_api_fib_mpls_label_t)));
8269 vec_free (next_hop_out_label_stack);
8274 clib_memcpy (mp->dst_address, &v6_dst_address,
8275 sizeof (v6_dst_address));
8277 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
8278 sizeof (v6_next_hop_address));
8279 increment_v6_address (&v6_dst_address);
8283 clib_memcpy (mp->dst_address, &v4_dst_address,
8284 sizeof (v4_dst_address));
8286 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
8287 sizeof (v4_next_hop_address));
8289 v4_dst_address.as_u32 = random_vector[j + 1];
8291 increment_v4_address (&v4_dst_address);
8295 /* If we receive SIGTERM, stop now... */
8300 /* When testing multiple add/del ops, use a control-ping to sync */
8303 vl_api_control_ping_t *mp_ping;
8307 /* Shut off async mode */
8308 vam->async_mode = 0;
8310 MPING (CONTROL_PING, mp_ping);
8313 timeout = vat_time_now (vam) + 1.0;
8314 while (vat_time_now (vam) < timeout)
8315 if (vam->result_ready == 1)
8320 if (vam->retval == -99)
8323 if (vam->async_errors > 0)
8325 errmsg ("%d asynchronous errors", vam->async_errors);
8328 vam->async_errors = 0;
8329 after = vat_time_now (vam);
8331 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8335 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8336 count, after - before, count / (after - before));
8342 /* Wait for a reply... */
8347 /* Return the good/bad news */
8348 return (vam->retval);
8352 api_ip_mroute_add_del (vat_main_t * vam)
8354 unformat_input_t *i = vam->input;
8355 vl_api_ip_mroute_add_del_t *mp;
8356 u32 sw_if_index = ~0, vrf_id = 0;
8361 u32 grp_address_length = 0;
8362 ip4_address_t v4_grp_address, v4_src_address;
8363 ip6_address_t v6_grp_address, v6_src_address;
8364 mfib_itf_flags_t iflags = 0;
8365 mfib_entry_flags_t eflags = 0;
8368 /* Parse args required to build the message */
8369 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8371 if (unformat (i, "sw_if_index %d", &sw_if_index))
8373 else if (unformat (i, "%U %U",
8374 unformat_ip4_address, &v4_src_address,
8375 unformat_ip4_address, &v4_grp_address))
8377 grp_address_length = 64;
8381 else if (unformat (i, "%U %U",
8382 unformat_ip6_address, &v6_src_address,
8383 unformat_ip6_address, &v6_grp_address))
8385 grp_address_length = 256;
8389 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
8391 clib_memset (&v4_src_address, 0, sizeof (v4_src_address));
8392 grp_address_length = 32;
8396 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
8398 clib_memset (&v6_src_address, 0, sizeof (v6_src_address));
8399 grp_address_length = 128;
8403 else if (unformat (i, "/%d", &grp_address_length))
8405 else if (unformat (i, "local"))
8409 else if (unformat (i, "del"))
8411 else if (unformat (i, "add"))
8413 else if (unformat (i, "vrf %d", &vrf_id))
8415 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
8417 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8421 clib_warning ("parse error '%U'", format_unformat_error, i);
8426 if (address_set == 0)
8428 errmsg ("missing addresses\n");
8432 /* Construct the API message */
8433 M (IP_MROUTE_ADD_DEL, mp);
8435 mp->next_hop_sw_if_index = ntohl (sw_if_index);
8436 mp->table_id = ntohl (vrf_id);
8438 mp->is_add = is_add;
8439 mp->is_ipv6 = is_ipv6;
8440 mp->is_local = is_local;
8441 mp->itf_flags = ntohl (iflags);
8442 mp->entry_flags = ntohl (eflags);
8443 mp->grp_address_length = grp_address_length;
8444 mp->grp_address_length = ntohs (mp->grp_address_length);
8448 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
8449 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
8453 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
8454 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
8460 /* Wait for a reply... */
8466 api_mpls_table_add_del (vat_main_t * vam)
8468 unformat_input_t *i = vam->input;
8469 vl_api_mpls_table_add_del_t *mp;
8474 /* Parse args required to build the message */
8475 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8477 if (unformat (i, "table %d", &table_id))
8479 else if (unformat (i, "del"))
8481 else if (unformat (i, "add"))
8485 clib_warning ("parse error '%U'", format_unformat_error, i);
8492 errmsg ("missing table-ID");
8496 /* Construct the API message */
8497 M (MPLS_TABLE_ADD_DEL, mp);
8499 mp->mt_table_id = ntohl (table_id);
8500 mp->mt_is_add = is_add;
8505 /* Wait for a reply... */
8512 api_mpls_route_add_del (vat_main_t * vam)
8514 unformat_input_t *i = vam->input;
8515 vl_api_mpls_route_add_del_t *mp;
8516 u32 sw_if_index = ~0, table_id = 0;
8518 u32 next_hop_weight = 1;
8519 u8 is_multipath = 0;
8520 u32 next_hop_table_id = 0;
8521 u8 next_hop_set = 0;
8522 ip4_address_t v4_next_hop_address = {
8525 ip6_address_t v6_next_hop_address = { {0} };
8529 u32 classify_table_index = ~0;
8531 u8 resolve_host = 0, resolve_attached = 0;
8532 u8 is_interface_rx = 0;
8533 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
8534 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8535 vl_api_fib_mpls_label_t *next_hop_out_label_stack = NULL;
8536 mpls_label_t local_label = MPLS_LABEL_INVALID;
8538 dpo_proto_t next_hop_proto = DPO_PROTO_MPLS;
8540 /* Parse args required to build the message */
8541 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8543 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8545 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8547 else if (unformat (i, "%d", &local_label))
8549 else if (unformat (i, "eos"))
8551 else if (unformat (i, "non-eos"))
8553 else if (unformat (i, "via %U", unformat_ip4_address,
8554 &v4_next_hop_address))
8557 next_hop_proto = DPO_PROTO_IP4;
8559 else if (unformat (i, "via %U", unformat_ip6_address,
8560 &v6_next_hop_address))
8563 next_hop_proto = DPO_PROTO_IP6;
8565 else if (unformat (i, "weight %d", &next_hop_weight))
8567 else if (unformat (i, "classify %d", &classify_table_index))
8571 else if (unformat (i, "del"))
8573 else if (unformat (i, "add"))
8575 else if (unformat (i, "resolve-via-host"))
8577 else if (unformat (i, "resolve-via-attached"))
8578 resolve_attached = 1;
8579 else if (unformat (i, "multipath"))
8581 else if (unformat (i, "count %d", &count))
8583 else if (unformat (i, "via lookup-in-ip4-table %d", &next_hop_table_id))
8586 next_hop_proto = DPO_PROTO_IP4;
8588 else if (unformat (i, "via lookup-in-ip6-table %d", &next_hop_table_id))
8591 next_hop_proto = DPO_PROTO_IP6;
8595 (i, "via l2-input-on %U", api_unformat_sw_if_index, vam,
8599 next_hop_proto = DPO_PROTO_ETHERNET;
8600 is_interface_rx = 1;
8602 else if (unformat (i, "via l2-input-on sw_if_index %d", &sw_if_index))
8605 next_hop_proto = DPO_PROTO_ETHERNET;
8606 is_interface_rx = 1;
8608 else if (unformat (i, "via next-hop-table %d", &next_hop_table_id))
8610 else if (unformat (i, "via via-label %d", &next_hop_via_label))
8612 else if (unformat (i, "out-label %d", &next_hop_out_label))
8614 vl_api_fib_mpls_label_t fib_label = {
8615 .label = ntohl (next_hop_out_label),
8619 vec_add1 (next_hop_out_label_stack, fib_label);
8623 clib_warning ("parse error '%U'", format_unformat_error, i);
8628 if (!next_hop_set && !is_classify)
8630 errmsg ("next hop / classify not set");
8634 if (MPLS_LABEL_INVALID == local_label)
8636 errmsg ("missing label");
8642 /* Turn on async mode */
8643 vam->async_mode = 1;
8644 vam->async_errors = 0;
8645 before = vat_time_now (vam);
8648 for (j = 0; j < count; j++)
8650 /* Construct the API message */
8651 M2 (MPLS_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_mpls_label_t) *
8652 vec_len (next_hop_out_label_stack));
8654 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
8655 mp->mr_table_id = ntohl (table_id);
8657 mp->mr_is_add = is_add;
8658 mp->mr_next_hop_proto = next_hop_proto;
8659 mp->mr_is_classify = is_classify;
8660 mp->mr_is_multipath = is_multipath;
8661 mp->mr_is_resolve_host = resolve_host;
8662 mp->mr_is_resolve_attached = resolve_attached;
8663 mp->mr_is_interface_rx = is_interface_rx;
8664 mp->mr_next_hop_weight = next_hop_weight;
8665 mp->mr_next_hop_preference = 0;
8666 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
8667 mp->mr_classify_table_index = ntohl (classify_table_index);
8668 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
8669 mp->mr_label = ntohl (local_label);
8670 mp->mr_eos = is_eos;
8672 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
8673 if (0 != mp->mr_next_hop_n_out_labels)
8675 memcpy (mp->mr_next_hop_out_label_stack,
8676 next_hop_out_label_stack,
8677 vec_len (next_hop_out_label_stack) *
8678 sizeof (vl_api_fib_mpls_label_t));
8679 vec_free (next_hop_out_label_stack);
8684 if (DPO_PROTO_IP4 == next_hop_proto)
8686 clib_memcpy (mp->mr_next_hop,
8687 &v4_next_hop_address,
8688 sizeof (v4_next_hop_address));
8690 else if (DPO_PROTO_IP6 == next_hop_proto)
8693 clib_memcpy (mp->mr_next_hop,
8694 &v6_next_hop_address,
8695 sizeof (v6_next_hop_address));
8702 /* If we receive SIGTERM, stop now... */
8707 /* When testing multiple add/del ops, use a control-ping to sync */
8710 vl_api_control_ping_t *mp_ping;
8714 /* Shut off async mode */
8715 vam->async_mode = 0;
8717 MPING (CONTROL_PING, mp_ping);
8720 timeout = vat_time_now (vam) + 1.0;
8721 while (vat_time_now (vam) < timeout)
8722 if (vam->result_ready == 1)
8727 if (vam->retval == -99)
8730 if (vam->async_errors > 0)
8732 errmsg ("%d asynchronous errors", vam->async_errors);
8735 vam->async_errors = 0;
8736 after = vat_time_now (vam);
8738 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8742 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8743 count, after - before, count / (after - before));
8749 /* Wait for a reply... */
8754 /* Return the good/bad news */
8755 return (vam->retval);
8759 api_mpls_ip_bind_unbind (vat_main_t * vam)
8761 unformat_input_t *i = vam->input;
8762 vl_api_mpls_ip_bind_unbind_t *mp;
8763 u32 ip_table_id = 0;
8766 ip4_address_t v4_address;
8767 ip6_address_t v6_address;
8770 mpls_label_t local_label = MPLS_LABEL_INVALID;
8773 /* Parse args required to build the message */
8774 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8776 if (unformat (i, "%U/%d", unformat_ip4_address,
8777 &v4_address, &address_length))
8782 else if (unformat (i, "%U/%d", unformat_ip6_address,
8783 &v6_address, &address_length))
8788 else if (unformat (i, "%d", &local_label))
8790 else if (unformat (i, "table-id %d", &ip_table_id))
8792 else if (unformat (i, "unbind"))
8794 else if (unformat (i, "bind"))
8798 clib_warning ("parse error '%U'", format_unformat_error, i);
8805 errmsg ("IP address not set");
8809 if (MPLS_LABEL_INVALID == local_label)
8811 errmsg ("missing label");
8815 /* Construct the API message */
8816 M (MPLS_IP_BIND_UNBIND, mp);
8818 mp->mb_is_bind = is_bind;
8819 mp->mb_is_ip4 = is_ip4;
8820 mp->mb_ip_table_id = ntohl (ip_table_id);
8821 mp->mb_mpls_table_id = 0;
8822 mp->mb_label = ntohl (local_label);
8823 mp->mb_address_length = address_length;
8826 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
8828 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
8833 /* Wait for a reply... */
8839 api_sr_mpls_policy_add (vat_main_t * vam)
8841 unformat_input_t *i = vam->input;
8842 vl_api_sr_mpls_policy_add_t *mp;
8848 u32 *segments = NULL;
8851 /* Parse args required to build the message */
8852 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8854 if (unformat (i, "bsid %d", &bsid))
8856 else if (unformat (i, "weight %d", &weight))
8858 else if (unformat (i, "spray"))
8860 else if (unformat (i, "next %d", &sid))
8863 vec_add1 (segments, htonl (sid));
8867 clib_warning ("parse error '%U'", format_unformat_error, i);
8874 errmsg ("bsid not set");
8878 if (n_segments == 0)
8880 errmsg ("no sid in segment stack");
8884 /* Construct the API message */
8885 M2 (SR_MPLS_POLICY_ADD, mp, sizeof (u32) * n_segments);
8887 mp->bsid = htonl (bsid);
8888 mp->weight = htonl (weight);
8890 mp->n_segments = n_segments;
8891 memcpy (mp->segments, segments, sizeof (u32) * n_segments);
8892 vec_free (segments);
8897 /* Wait for a reply... */
8903 api_sr_mpls_policy_del (vat_main_t * vam)
8905 unformat_input_t *i = vam->input;
8906 vl_api_sr_mpls_policy_del_t *mp;
8910 /* Parse args required to build the message */
8911 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8913 if (unformat (i, "bsid %d", &bsid))
8917 clib_warning ("parse error '%U'", format_unformat_error, i);
8924 errmsg ("bsid not set");
8928 /* Construct the API message */
8929 M (SR_MPLS_POLICY_DEL, mp);
8931 mp->bsid = htonl (bsid);
8936 /* Wait for a reply... */
8942 api_bier_table_add_del (vat_main_t * vam)
8944 unformat_input_t *i = vam->input;
8945 vl_api_bier_table_add_del_t *mp;
8947 u32 set = 0, sub_domain = 0, hdr_len = 3;
8948 mpls_label_t local_label = MPLS_LABEL_INVALID;
8951 /* Parse args required to build the message */
8952 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8954 if (unformat (i, "sub-domain %d", &sub_domain))
8956 else if (unformat (i, "set %d", &set))
8958 else if (unformat (i, "label %d", &local_label))
8960 else if (unformat (i, "hdr-len %d", &hdr_len))
8962 else if (unformat (i, "add"))
8964 else if (unformat (i, "del"))
8968 clib_warning ("parse error '%U'", format_unformat_error, i);
8973 if (MPLS_LABEL_INVALID == local_label)
8975 errmsg ("missing label\n");
8979 /* Construct the API message */
8980 M (BIER_TABLE_ADD_DEL, mp);
8982 mp->bt_is_add = is_add;
8983 mp->bt_label = ntohl (local_label);
8984 mp->bt_tbl_id.bt_set = set;
8985 mp->bt_tbl_id.bt_sub_domain = sub_domain;
8986 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
8991 /* Wait for a reply... */
8998 api_bier_route_add_del (vat_main_t * vam)
9000 unformat_input_t *i = vam->input;
9001 vl_api_bier_route_add_del_t *mp;
9003 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
9004 ip4_address_t v4_next_hop_address;
9005 ip6_address_t v6_next_hop_address;
9006 u8 next_hop_set = 0;
9007 u8 next_hop_proto_is_ip4 = 1;
9008 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
9011 /* Parse args required to build the message */
9012 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9014 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
9016 next_hop_proto_is_ip4 = 1;
9019 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
9021 next_hop_proto_is_ip4 = 0;
9024 if (unformat (i, "sub-domain %d", &sub_domain))
9026 else if (unformat (i, "set %d", &set))
9028 else if (unformat (i, "hdr-len %d", &hdr_len))
9030 else if (unformat (i, "bp %d", &bp))
9032 else if (unformat (i, "add"))
9034 else if (unformat (i, "del"))
9036 else if (unformat (i, "out-label %d", &next_hop_out_label))
9040 clib_warning ("parse error '%U'", format_unformat_error, i);
9045 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
9047 errmsg ("next hop / label set\n");
9052 errmsg ("bit=position not set\n");
9056 /* Construct the API message */
9057 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t));
9059 mp->br_is_add = is_add;
9060 mp->br_tbl_id.bt_set = set;
9061 mp->br_tbl_id.bt_sub_domain = sub_domain;
9062 mp->br_tbl_id.bt_hdr_len_id = hdr_len;
9063 mp->br_bp = ntohs (bp);
9065 mp->br_paths[0].n_labels = 1;
9066 mp->br_paths[0].label_stack[0].label = ntohl (next_hop_out_label);
9067 mp->br_paths[0].afi = (next_hop_proto_is_ip4 ? 0 : 1);
9069 if (next_hop_proto_is_ip4)
9071 clib_memcpy (mp->br_paths[0].next_hop,
9072 &v4_next_hop_address, sizeof (v4_next_hop_address));
9076 clib_memcpy (mp->br_paths[0].next_hop,
9077 &v6_next_hop_address, sizeof (v6_next_hop_address));
9083 /* Wait for a reply... */
9090 api_proxy_arp_add_del (vat_main_t * vam)
9092 unformat_input_t *i = vam->input;
9093 vl_api_proxy_arp_add_del_t *mp;
9096 vl_api_ip4_address_t lo, hi;
9100 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9102 if (unformat (i, "vrf %d", &vrf_id))
9104 else if (unformat (i, "%U - %U", unformat_vl_api_ip4_address, &lo,
9105 unformat_vl_api_ip4_address, &hi))
9107 else if (unformat (i, "del"))
9111 clib_warning ("parse error '%U'", format_unformat_error, i);
9118 errmsg ("address range not set");
9122 M (PROXY_ARP_ADD_DEL, mp);
9124 mp->proxy.table_id = ntohl (vrf_id);
9125 mp->is_add = is_add;
9126 clib_memcpy (mp->proxy.low, &lo, sizeof (lo));
9127 clib_memcpy (mp->proxy.hi, &hi, sizeof (hi));
9135 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
9137 unformat_input_t *i = vam->input;
9138 vl_api_proxy_arp_intfc_enable_disable_t *mp;
9141 u8 sw_if_index_set = 0;
9144 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9146 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9147 sw_if_index_set = 1;
9148 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9149 sw_if_index_set = 1;
9150 else if (unformat (i, "enable"))
9152 else if (unformat (i, "disable"))
9156 clib_warning ("parse error '%U'", format_unformat_error, i);
9161 if (sw_if_index_set == 0)
9163 errmsg ("missing interface name or sw_if_index");
9167 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
9169 mp->sw_if_index = ntohl (sw_if_index);
9170 mp->enable_disable = enable;
9178 api_mpls_tunnel_add_del (vat_main_t * vam)
9180 unformat_input_t *i = vam->input;
9181 vl_api_mpls_tunnel_add_del_t *mp;
9185 u32 sw_if_index = ~0;
9186 u32 next_hop_sw_if_index = ~0;
9187 u32 next_hop_proto_is_ip4 = 1;
9189 u32 next_hop_table_id = 0;
9190 ip4_address_t v4_next_hop_address = {
9193 ip6_address_t v6_next_hop_address = { {0} };
9194 vl_api_fib_mpls_label_t *next_hop_out_label_stack = NULL;
9195 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
9196 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
9199 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9201 if (unformat (i, "add"))
9205 (i, "del %U", api_unformat_sw_if_index, vam, &sw_if_index))
9207 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
9209 else if (unformat (i, "via %U",
9210 unformat_ip4_address, &v4_next_hop_address))
9212 next_hop_proto_is_ip4 = 1;
9214 else if (unformat (i, "via %U",
9215 unformat_ip6_address, &v6_next_hop_address))
9217 next_hop_proto_is_ip4 = 0;
9219 else if (unformat (i, "via-label %d", &next_hop_via_label))
9223 (i, "%U", api_unformat_sw_if_index, vam, &next_hop_sw_if_index))
9225 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
9227 else if (unformat (i, "l2-only"))
9229 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
9231 else if (unformat (i, "out-label %d", &next_hop_out_label))
9233 vl_api_fib_mpls_label_t fib_label = {
9234 .label = ntohl (next_hop_out_label),
9238 vec_add1 (next_hop_out_label_stack, fib_label);
9242 clib_warning ("parse error '%U'", format_unformat_error, i);
9247 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (vl_api_fib_mpls_label_t) *
9248 vec_len (next_hop_out_label_stack));
9250 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
9251 mp->mt_sw_if_index = ntohl (sw_if_index);
9252 mp->mt_is_add = is_add;
9253 mp->mt_l2_only = l2_only;
9254 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
9255 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
9256 mp->mt_next_hop_via_label = ntohl (next_hop_via_label);
9257 mp->mt_next_hop_weight = 1;
9258 mp->mt_next_hop_preference = 0;
9260 mp->mt_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
9262 if (0 != mp->mt_next_hop_n_out_labels)
9264 clib_memcpy (mp->mt_next_hop_out_label_stack,
9265 next_hop_out_label_stack,
9266 (vec_len (next_hop_out_label_stack) *
9267 sizeof (vl_api_fib_mpls_label_t)));
9268 vec_free (next_hop_out_label_stack);
9271 if (next_hop_proto_is_ip4)
9273 clib_memcpy (mp->mt_next_hop,
9274 &v4_next_hop_address, sizeof (v4_next_hop_address));
9278 clib_memcpy (mp->mt_next_hop,
9279 &v6_next_hop_address, sizeof (v6_next_hop_address));
9288 api_sw_interface_set_unnumbered (vat_main_t * vam)
9290 unformat_input_t *i = vam->input;
9291 vl_api_sw_interface_set_unnumbered_t *mp;
9293 u32 unnum_sw_index = ~0;
9295 u8 sw_if_index_set = 0;
9298 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9300 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9301 sw_if_index_set = 1;
9302 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9303 sw_if_index_set = 1;
9304 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
9306 else if (unformat (i, "del"))
9310 clib_warning ("parse error '%U'", format_unformat_error, i);
9315 if (sw_if_index_set == 0)
9317 errmsg ("missing interface name or sw_if_index");
9321 M (SW_INTERFACE_SET_UNNUMBERED, mp);
9323 mp->sw_if_index = ntohl (sw_if_index);
9324 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
9325 mp->is_add = is_add;
9333 api_ip_neighbor_add_del (vat_main_t * vam)
9335 vl_api_mac_address_t mac_address;
9336 unformat_input_t *i = vam->input;
9337 vl_api_ip_neighbor_add_del_t *mp;
9338 vl_api_address_t ip_address;
9340 u8 sw_if_index_set = 0;
9345 ip_neighbor_flags_t flags;
9347 flags = IP_NEIGHBOR_FLAG_NONE;
9348 clib_memset (&ip_address, 0, sizeof (ip_address));
9349 clib_memset (&mac_address, 0, sizeof (mac_address));
9350 /* Parse args required to build the message */
9351 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9353 if (unformat (i, "mac %U", unformat_vl_api_mac_address, &mac_address))
9357 else if (unformat (i, "del"))
9360 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9361 sw_if_index_set = 1;
9362 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9363 sw_if_index_set = 1;
9364 else if (unformat (i, "static"))
9365 flags |= IP_NEIGHBOR_FLAG_STATIC;
9366 else if (unformat (i, "no-fib-entry"))
9367 flags |= IP_NEIGHBOR_FLAG_NO_FIB_ENTRY;
9368 else if (unformat (i, "dst %U", unformat_vl_api_address, &ip_address))
9372 clib_warning ("parse error '%U'", format_unformat_error, i);
9377 if (sw_if_index_set == 0)
9379 errmsg ("missing interface name or sw_if_index");
9384 errmsg ("no address set");
9388 /* Construct the API message */
9389 M (IP_NEIGHBOR_ADD_DEL, mp);
9391 mp->neighbor.sw_if_index = ntohl (sw_if_index);
9392 mp->is_add = is_add;
9393 mp->neighbor.flags = htonl (flags);
9395 clib_memcpy (&mp->neighbor.mac_address, &mac_address,
9396 sizeof (mac_address));
9398 clib_memcpy (&mp->neighbor.ip_address, &ip_address, sizeof (ip_address));
9403 /* Wait for a reply, return good/bad news */
9409 api_create_vlan_subif (vat_main_t * vam)
9411 unformat_input_t *i = vam->input;
9412 vl_api_create_vlan_subif_t *mp;
9414 u8 sw_if_index_set = 0;
9419 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9421 if (unformat (i, "sw_if_index %d", &sw_if_index))
9422 sw_if_index_set = 1;
9424 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9425 sw_if_index_set = 1;
9426 else if (unformat (i, "vlan %d", &vlan_id))
9430 clib_warning ("parse error '%U'", format_unformat_error, i);
9435 if (sw_if_index_set == 0)
9437 errmsg ("missing interface name or sw_if_index");
9441 if (vlan_id_set == 0)
9443 errmsg ("missing vlan_id");
9446 M (CREATE_VLAN_SUBIF, mp);
9448 mp->sw_if_index = ntohl (sw_if_index);
9449 mp->vlan_id = ntohl (vlan_id);
9456 #define foreach_create_subif_bit \
9463 _(outer_vlan_id_any) \
9464 _(inner_vlan_id_any)
9467 api_create_subif (vat_main_t * vam)
9469 unformat_input_t *i = vam->input;
9470 vl_api_create_subif_t *mp;
9472 u8 sw_if_index_set = 0;
9479 u32 exact_match = 0;
9480 u32 default_sub = 0;
9481 u32 outer_vlan_id_any = 0;
9482 u32 inner_vlan_id_any = 0;
9484 u16 outer_vlan_id = 0;
9485 u16 inner_vlan_id = 0;
9488 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9490 if (unformat (i, "sw_if_index %d", &sw_if_index))
9491 sw_if_index_set = 1;
9493 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9494 sw_if_index_set = 1;
9495 else if (unformat (i, "sub_id %d", &sub_id))
9497 else if (unformat (i, "outer_vlan_id %d", &tmp))
9498 outer_vlan_id = tmp;
9499 else if (unformat (i, "inner_vlan_id %d", &tmp))
9500 inner_vlan_id = tmp;
9502 #define _(a) else if (unformat (i, #a)) a = 1 ;
9503 foreach_create_subif_bit
9507 clib_warning ("parse error '%U'", format_unformat_error, i);
9512 if (sw_if_index_set == 0)
9514 errmsg ("missing interface name or sw_if_index");
9518 if (sub_id_set == 0)
9520 errmsg ("missing sub_id");
9523 M (CREATE_SUBIF, mp);
9525 mp->sw_if_index = ntohl (sw_if_index);
9526 mp->sub_id = ntohl (sub_id);
9528 #define _(a) mp->a = a;
9529 foreach_create_subif_bit;
9532 mp->outer_vlan_id = ntohs (outer_vlan_id);
9533 mp->inner_vlan_id = ntohs (inner_vlan_id);
9541 api_oam_add_del (vat_main_t * vam)
9543 unformat_input_t *i = vam->input;
9544 vl_api_oam_add_del_t *mp;
9547 ip4_address_t src, dst;
9552 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9554 if (unformat (i, "vrf %d", &vrf_id))
9556 else if (unformat (i, "src %U", unformat_ip4_address, &src))
9558 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
9560 else if (unformat (i, "del"))
9564 clib_warning ("parse error '%U'", format_unformat_error, i);
9571 errmsg ("missing src addr");
9577 errmsg ("missing dst addr");
9581 M (OAM_ADD_DEL, mp);
9583 mp->vrf_id = ntohl (vrf_id);
9584 mp->is_add = is_add;
9585 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
9586 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
9594 api_reset_fib (vat_main_t * vam)
9596 unformat_input_t *i = vam->input;
9597 vl_api_reset_fib_t *mp;
9603 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9605 if (unformat (i, "vrf %d", &vrf_id))
9607 else if (unformat (i, "ipv6"))
9611 clib_warning ("parse error '%U'", format_unformat_error, i);
9616 if (vrf_id_set == 0)
9618 errmsg ("missing vrf id");
9624 mp->vrf_id = ntohl (vrf_id);
9625 mp->is_ipv6 = is_ipv6;
9633 api_dhcp_proxy_config (vat_main_t * vam)
9635 unformat_input_t *i = vam->input;
9636 vl_api_dhcp_proxy_config_t *mp;
9638 u32 server_vrf_id = 0;
9640 u8 v4_address_set = 0;
9641 u8 v6_address_set = 0;
9642 ip4_address_t v4address;
9643 ip6_address_t v6address;
9644 u8 v4_src_address_set = 0;
9645 u8 v6_src_address_set = 0;
9646 ip4_address_t v4srcaddress;
9647 ip6_address_t v6srcaddress;
9650 /* Parse args required to build the message */
9651 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9653 if (unformat (i, "del"))
9655 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
9657 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
9659 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
9661 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
9663 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
9664 v4_src_address_set = 1;
9665 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
9666 v6_src_address_set = 1;
9671 if (v4_address_set && v6_address_set)
9673 errmsg ("both v4 and v6 server addresses set");
9676 if (!v4_address_set && !v6_address_set)
9678 errmsg ("no server addresses set");
9682 if (v4_src_address_set && v6_src_address_set)
9684 errmsg ("both v4 and v6 src addresses set");
9687 if (!v4_src_address_set && !v6_src_address_set)
9689 errmsg ("no src addresses set");
9693 if (!(v4_src_address_set && v4_address_set) &&
9694 !(v6_src_address_set && v6_address_set))
9696 errmsg ("no matching server and src addresses set");
9700 /* Construct the API message */
9701 M (DHCP_PROXY_CONFIG, mp);
9703 mp->is_add = is_add;
9704 mp->rx_vrf_id = ntohl (rx_vrf_id);
9705 mp->server_vrf_id = ntohl (server_vrf_id);
9709 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
9710 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
9714 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
9715 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
9721 /* Wait for a reply, return good/bad news */
9726 #define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
9727 #define vl_api_dhcp_proxy_details_t_print vl_noop_handler
9730 vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
9732 vat_main_t *vam = &vat_main;
9733 u32 i, count = mp->count;
9734 vl_api_dhcp_server_t *s;
9738 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9739 "VSS ASCII VPN-ID '%s', VSS RFC2685 VPN-ID (oui:id) %d:%d",
9740 ntohl (mp->rx_vrf_id),
9741 format_ip6_address, mp->dhcp_src_address,
9742 mp->vss_type, mp->vss_vpn_ascii_id,
9743 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9746 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9747 "VSS ASCII VPN-ID '%s', VSS RFC2685 VPN-ID (oui:id) %d:%d",
9748 ntohl (mp->rx_vrf_id),
9749 format_ip4_address, mp->dhcp_src_address,
9750 mp->vss_type, mp->vss_vpn_ascii_id,
9751 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9753 for (i = 0; i < count; i++)
9755 s = &mp->servers[i];
9759 " Server Table-ID %d, Server Address %U",
9760 ntohl (s->server_vrf_id), format_ip6_address, s->dhcp_server);
9763 " Server Table-ID %d, Server Address %U",
9764 ntohl (s->server_vrf_id), format_ip4_address, s->dhcp_server);
9768 static void vl_api_dhcp_proxy_details_t_handler_json
9769 (vl_api_dhcp_proxy_details_t * mp)
9771 vat_main_t *vam = &vat_main;
9772 vat_json_node_t *node = NULL;
9773 u32 i, count = mp->count;
9775 struct in6_addr ip6;
9776 vl_api_dhcp_server_t *s;
9778 if (VAT_JSON_ARRAY != vam->json_tree.type)
9780 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9781 vat_json_init_array (&vam->json_tree);
9783 node = vat_json_array_add (&vam->json_tree);
9785 vat_json_init_object (node);
9786 vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
9787 vat_json_object_add_bytes (node, "vss-type", &mp->vss_type,
9788 sizeof (mp->vss_type));
9789 vat_json_object_add_string_copy (node, "vss-vpn-ascii-id",
9790 mp->vss_vpn_ascii_id);
9791 vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
9792 vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
9796 clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
9797 vat_json_object_add_ip6 (node, "src_address", ip6);
9801 clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
9802 vat_json_object_add_ip4 (node, "src_address", ip4);
9805 for (i = 0; i < count; i++)
9807 s = &mp->servers[i];
9809 vat_json_object_add_uint (node, "server-table-id",
9810 ntohl (s->server_vrf_id));
9814 clib_memcpy (&ip4, &s->dhcp_server, sizeof (ip4));
9815 vat_json_object_add_ip4 (node, "src_address", ip4);
9819 clib_memcpy (&ip6, &s->dhcp_server, sizeof (ip6));
9820 vat_json_object_add_ip6 (node, "server_address", ip6);
9826 api_dhcp_proxy_dump (vat_main_t * vam)
9828 unformat_input_t *i = vam->input;
9829 vl_api_control_ping_t *mp_ping;
9830 vl_api_dhcp_proxy_dump_t *mp;
9834 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9836 if (unformat (i, "ipv6"))
9840 clib_warning ("parse error '%U'", format_unformat_error, i);
9845 M (DHCP_PROXY_DUMP, mp);
9847 mp->is_ip6 = is_ipv6;
9850 /* Use a control ping for synchronization */
9851 MPING (CONTROL_PING, mp_ping);
9859 api_dhcp_proxy_set_vss (vat_main_t * vam)
9861 unformat_input_t *i = vam->input;
9862 vl_api_dhcp_proxy_set_vss_t *mp;
9866 u8 vss_type = VSS_TYPE_DEFAULT;
9867 u8 *vpn_ascii_id = 0;
9872 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9874 if (unformat (i, "tbl_id %d", &tbl_id))
9876 else if (unformat (i, "vpn_ascii_id %s", &vpn_ascii_id))
9877 vss_type = VSS_TYPE_ASCII;
9878 else if (unformat (i, "fib_id %d", &fib_id))
9879 vss_type = VSS_TYPE_VPN_ID;
9880 else if (unformat (i, "oui %d", &oui))
9881 vss_type = VSS_TYPE_VPN_ID;
9882 else if (unformat (i, "ipv6"))
9884 else if (unformat (i, "del"))
9892 errmsg ("missing tbl_id ");
9893 vec_free (vpn_ascii_id);
9897 if ((vpn_ascii_id) && (vec_len (vpn_ascii_id) > 128))
9899 errmsg ("vpn_ascii_id cannot be longer than 128 ");
9900 vec_free (vpn_ascii_id);
9904 M (DHCP_PROXY_SET_VSS, mp);
9905 mp->tbl_id = ntohl (tbl_id);
9906 mp->vss_type = vss_type;
9909 clib_memcpy (mp->vpn_ascii_id, vpn_ascii_id, vec_len (vpn_ascii_id));
9910 mp->vpn_ascii_id[vec_len (vpn_ascii_id)] = 0;
9912 mp->vpn_index = ntohl (fib_id);
9913 mp->oui = ntohl (oui);
9914 mp->is_ipv6 = is_ipv6;
9915 mp->is_add = is_add;
9920 vec_free (vpn_ascii_id);
9925 api_dhcp_client_config (vat_main_t * vam)
9927 unformat_input_t *i = vam->input;
9928 vl_api_dhcp_client_config_t *mp;
9930 u8 sw_if_index_set = 0;
9933 u8 disable_event = 0;
9936 /* Parse args required to build the message */
9937 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9939 if (unformat (i, "del"))
9942 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9943 sw_if_index_set = 1;
9944 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9945 sw_if_index_set = 1;
9946 else if (unformat (i, "hostname %s", &hostname))
9948 else if (unformat (i, "disable_event"))
9954 if (sw_if_index_set == 0)
9956 errmsg ("missing interface name or sw_if_index");
9960 if (vec_len (hostname) > 63)
9962 errmsg ("hostname too long");
9964 vec_add1 (hostname, 0);
9966 /* Construct the API message */
9967 M (DHCP_CLIENT_CONFIG, mp);
9969 mp->is_add = is_add;
9970 mp->client.sw_if_index = htonl (sw_if_index);
9971 clib_memcpy (mp->client.hostname, hostname, vec_len (hostname));
9972 vec_free (hostname);
9973 mp->client.want_dhcp_event = disable_event ? 0 : 1;
9974 mp->client.pid = htonl (getpid ());
9979 /* Wait for a reply, return good/bad news */
9985 api_set_ip_flow_hash (vat_main_t * vam)
9987 unformat_input_t *i = vam->input;
9988 vl_api_set_ip_flow_hash_t *mp;
10000 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10002 if (unformat (i, "vrf %d", &vrf_id))
10004 else if (unformat (i, "ipv6"))
10006 else if (unformat (i, "src"))
10008 else if (unformat (i, "dst"))
10010 else if (unformat (i, "sport"))
10012 else if (unformat (i, "dport"))
10014 else if (unformat (i, "proto"))
10016 else if (unformat (i, "reverse"))
10021 clib_warning ("parse error '%U'", format_unformat_error, i);
10026 if (vrf_id_set == 0)
10028 errmsg ("missing vrf id");
10032 M (SET_IP_FLOW_HASH, mp);
10038 mp->reverse = reverse;
10039 mp->vrf_id = ntohl (vrf_id);
10040 mp->is_ipv6 = is_ipv6;
10048 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
10050 unformat_input_t *i = vam->input;
10051 vl_api_sw_interface_ip6_enable_disable_t *mp;
10053 u8 sw_if_index_set = 0;
10057 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10059 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10060 sw_if_index_set = 1;
10061 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10062 sw_if_index_set = 1;
10063 else if (unformat (i, "enable"))
10065 else if (unformat (i, "disable"))
10069 clib_warning ("parse error '%U'", format_unformat_error, i);
10074 if (sw_if_index_set == 0)
10076 errmsg ("missing interface name or sw_if_index");
10080 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
10082 mp->sw_if_index = ntohl (sw_if_index);
10083 mp->enable = enable;
10091 api_ip6nd_proxy_add_del (vat_main_t * vam)
10093 unformat_input_t *i = vam->input;
10094 vl_api_ip6nd_proxy_add_del_t *mp;
10095 u32 sw_if_index = ~0;
10096 u8 v6_address_set = 0;
10097 vl_api_ip6_address_t v6address;
10101 /* Parse args required to build the message */
10102 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10104 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10106 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10108 else if (unformat (i, "%U", unformat_vl_api_ip6_address, &v6address))
10109 v6_address_set = 1;
10110 if (unformat (i, "del"))
10114 clib_warning ("parse error '%U'", format_unformat_error, i);
10119 if (sw_if_index == ~0)
10121 errmsg ("missing interface name or sw_if_index");
10124 if (!v6_address_set)
10126 errmsg ("no address set");
10130 /* Construct the API message */
10131 M (IP6ND_PROXY_ADD_DEL, mp);
10133 mp->is_del = is_del;
10134 mp->sw_if_index = ntohl (sw_if_index);
10135 clib_memcpy (mp->ip, v6address, sizeof (v6address));
10140 /* Wait for a reply, return good/bad news */
10146 api_ip6nd_proxy_dump (vat_main_t * vam)
10148 vl_api_ip6nd_proxy_dump_t *mp;
10149 vl_api_control_ping_t *mp_ping;
10152 M (IP6ND_PROXY_DUMP, mp);
10156 /* Use a control ping for synchronization */
10157 MPING (CONTROL_PING, mp_ping);
10164 static void vl_api_ip6nd_proxy_details_t_handler
10165 (vl_api_ip6nd_proxy_details_t * mp)
10167 vat_main_t *vam = &vat_main;
10169 print (vam->ofp, "host %U sw_if_index %d",
10170 format_vl_api_ip6_address, mp->ip, ntohl (mp->sw_if_index));
10173 static void vl_api_ip6nd_proxy_details_t_handler_json
10174 (vl_api_ip6nd_proxy_details_t * mp)
10176 vat_main_t *vam = &vat_main;
10177 struct in6_addr ip6;
10178 vat_json_node_t *node = NULL;
10180 if (VAT_JSON_ARRAY != vam->json_tree.type)
10182 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10183 vat_json_init_array (&vam->json_tree);
10185 node = vat_json_array_add (&vam->json_tree);
10187 vat_json_init_object (node);
10188 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10190 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
10191 vat_json_object_add_ip6 (node, "host", ip6);
10195 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
10197 unformat_input_t *i = vam->input;
10198 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
10200 u8 sw_if_index_set = 0;
10201 u32 address_length = 0;
10202 u8 v6_address_set = 0;
10203 vl_api_prefix_t pfx;
10204 u8 use_default = 0;
10205 u8 no_advertise = 0;
10207 u8 no_autoconfig = 0;
10210 u32 val_lifetime = 0;
10211 u32 pref_lifetime = 0;
10214 /* Parse args required to build the message */
10215 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10217 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10218 sw_if_index_set = 1;
10219 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10220 sw_if_index_set = 1;
10221 else if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
10222 v6_address_set = 1;
10223 else if (unformat (i, "val_life %d", &val_lifetime))
10225 else if (unformat (i, "pref_life %d", &pref_lifetime))
10227 else if (unformat (i, "def"))
10229 else if (unformat (i, "noadv"))
10231 else if (unformat (i, "offl"))
10233 else if (unformat (i, "noauto"))
10235 else if (unformat (i, "nolink"))
10237 else if (unformat (i, "isno"))
10241 clib_warning ("parse error '%U'", format_unformat_error, i);
10246 if (sw_if_index_set == 0)
10248 errmsg ("missing interface name or sw_if_index");
10251 if (!v6_address_set)
10253 errmsg ("no address set");
10257 /* Construct the API message */
10258 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
10260 mp->sw_if_index = ntohl (sw_if_index);
10261 clib_memcpy (&mp->prefix, &pfx, sizeof (pfx));
10262 mp->use_default = use_default;
10263 mp->no_advertise = no_advertise;
10264 mp->off_link = off_link;
10265 mp->no_autoconfig = no_autoconfig;
10266 mp->no_onlink = no_onlink;
10268 mp->val_lifetime = ntohl (val_lifetime);
10269 mp->pref_lifetime = ntohl (pref_lifetime);
10274 /* Wait for a reply, return good/bad news */
10280 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
10282 unformat_input_t *i = vam->input;
10283 vl_api_sw_interface_ip6nd_ra_config_t *mp;
10285 u8 sw_if_index_set = 0;
10290 u8 send_unicast = 0;
10293 u8 default_router = 0;
10294 u32 max_interval = 0;
10295 u32 min_interval = 0;
10297 u32 initial_count = 0;
10298 u32 initial_interval = 0;
10302 /* Parse args required to build the message */
10303 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10305 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10306 sw_if_index_set = 1;
10307 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10308 sw_if_index_set = 1;
10309 else if (unformat (i, "maxint %d", &max_interval))
10311 else if (unformat (i, "minint %d", &min_interval))
10313 else if (unformat (i, "life %d", &lifetime))
10315 else if (unformat (i, "count %d", &initial_count))
10317 else if (unformat (i, "interval %d", &initial_interval))
10319 else if (unformat (i, "suppress") || unformat (i, "surpress"))
10321 else if (unformat (i, "managed"))
10323 else if (unformat (i, "other"))
10325 else if (unformat (i, "ll"))
10327 else if (unformat (i, "send"))
10329 else if (unformat (i, "cease"))
10331 else if (unformat (i, "isno"))
10333 else if (unformat (i, "def"))
10334 default_router = 1;
10337 clib_warning ("parse error '%U'", format_unformat_error, i);
10342 if (sw_if_index_set == 0)
10344 errmsg ("missing interface name or sw_if_index");
10348 /* Construct the API message */
10349 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
10351 mp->sw_if_index = ntohl (sw_if_index);
10352 mp->max_interval = ntohl (max_interval);
10353 mp->min_interval = ntohl (min_interval);
10354 mp->lifetime = ntohl (lifetime);
10355 mp->initial_count = ntohl (initial_count);
10356 mp->initial_interval = ntohl (initial_interval);
10357 mp->suppress = suppress;
10358 mp->managed = managed;
10360 mp->ll_option = ll_option;
10361 mp->send_unicast = send_unicast;
10364 mp->default_router = default_router;
10369 /* Wait for a reply, return good/bad news */
10375 api_set_arp_neighbor_limit (vat_main_t * vam)
10377 unformat_input_t *i = vam->input;
10378 vl_api_set_arp_neighbor_limit_t *mp;
10384 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10386 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
10388 else if (unformat (i, "ipv6"))
10392 clib_warning ("parse error '%U'", format_unformat_error, i);
10397 if (limit_set == 0)
10399 errmsg ("missing limit value");
10403 M (SET_ARP_NEIGHBOR_LIMIT, mp);
10405 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
10406 mp->is_ipv6 = is_ipv6;
10414 api_l2_patch_add_del (vat_main_t * vam)
10416 unformat_input_t *i = vam->input;
10417 vl_api_l2_patch_add_del_t *mp;
10418 u32 rx_sw_if_index;
10419 u8 rx_sw_if_index_set = 0;
10420 u32 tx_sw_if_index;
10421 u8 tx_sw_if_index_set = 0;
10425 /* Parse args required to build the message */
10426 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10428 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
10429 rx_sw_if_index_set = 1;
10430 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
10431 tx_sw_if_index_set = 1;
10432 else if (unformat (i, "rx"))
10434 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10436 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10438 rx_sw_if_index_set = 1;
10443 else if (unformat (i, "tx"))
10445 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10447 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10449 tx_sw_if_index_set = 1;
10454 else if (unformat (i, "del"))
10460 if (rx_sw_if_index_set == 0)
10462 errmsg ("missing rx interface name or rx_sw_if_index");
10466 if (tx_sw_if_index_set == 0)
10468 errmsg ("missing tx interface name or tx_sw_if_index");
10472 M (L2_PATCH_ADD_DEL, mp);
10474 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
10475 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
10476 mp->is_add = is_add;
10484 u8 localsid_addr[16];
10493 api_sr_localsid_add_del (vat_main_t * vam)
10495 unformat_input_t *i = vam->input;
10496 vl_api_sr_localsid_add_del_t *mp;
10499 ip6_address_t localsid;
10503 u32 fib_table = ~(u32) 0;
10504 ip6_address_t nh_addr6;
10505 ip4_address_t nh_addr4;
10506 clib_memset (&nh_addr6, 0, sizeof (ip6_address_t));
10507 clib_memset (&nh_addr4, 0, sizeof (ip4_address_t));
10509 bool nexthop_set = 0;
10513 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10515 if (unformat (i, "del"))
10517 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
10518 else if (unformat (i, "next-hop %U", unformat_ip4_address, &nh_addr4))
10520 else if (unformat (i, "next-hop %U", unformat_ip6_address, &nh_addr6))
10522 else if (unformat (i, "behavior %u", &behavior));
10523 else if (unformat (i, "sw_if_index %u", &sw_if_index));
10524 else if (unformat (i, "fib-table %u", &fib_table));
10525 else if (unformat (i, "end.psp %u", &behavior));
10530 M (SR_LOCALSID_ADD_DEL, mp);
10532 clib_memcpy (mp->localsid.addr, &localsid, sizeof (mp->localsid));
10535 clib_memcpy (mp->nh_addr6, &nh_addr6, sizeof (mp->nh_addr6));
10536 clib_memcpy (mp->nh_addr4, &nh_addr4, sizeof (mp->nh_addr4));
10538 mp->behavior = behavior;
10539 mp->sw_if_index = ntohl (sw_if_index);
10540 mp->fib_table = ntohl (fib_table);
10541 mp->end_psp = end_psp;
10542 mp->is_del = is_del;
10550 api_ioam_enable (vat_main_t * vam)
10552 unformat_input_t *input = vam->input;
10553 vl_api_ioam_enable_t *mp;
10555 int has_trace_option = 0;
10556 int has_pot_option = 0;
10557 int has_seqno_option = 0;
10558 int has_analyse_option = 0;
10561 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10563 if (unformat (input, "trace"))
10564 has_trace_option = 1;
10565 else if (unformat (input, "pot"))
10566 has_pot_option = 1;
10567 else if (unformat (input, "seqno"))
10568 has_seqno_option = 1;
10569 else if (unformat (input, "analyse"))
10570 has_analyse_option = 1;
10574 M (IOAM_ENABLE, mp);
10575 mp->id = htons (id);
10576 mp->seqno = has_seqno_option;
10577 mp->analyse = has_analyse_option;
10578 mp->pot_enable = has_pot_option;
10579 mp->trace_enable = has_trace_option;
10588 api_ioam_disable (vat_main_t * vam)
10590 vl_api_ioam_disable_t *mp;
10593 M (IOAM_DISABLE, mp);
10599 #define foreach_tcp_proto_field \
10603 #define foreach_udp_proto_field \
10607 #define foreach_ip4_proto_field \
10619 u16 src_port, dst_port;
10622 #if VPP_API_TEST_BUILTIN == 0
10624 unformat_tcp_mask (unformat_input_t * input, va_list * args)
10626 u8 **maskp = va_arg (*args, u8 **);
10628 u8 found_something = 0;
10631 #define _(a) u8 a=0;
10632 foreach_tcp_proto_field;
10635 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10638 #define _(a) else if (unformat (input, #a)) a=1;
10639 foreach_tcp_proto_field
10645 #define _(a) found_something += a;
10646 foreach_tcp_proto_field;
10649 if (found_something == 0)
10652 vec_validate (mask, sizeof (*tcp) - 1);
10654 tcp = (tcp_header_t *) mask;
10656 #define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
10657 foreach_tcp_proto_field;
10665 unformat_udp_mask (unformat_input_t * input, va_list * args)
10667 u8 **maskp = va_arg (*args, u8 **);
10669 u8 found_something = 0;
10672 #define _(a) u8 a=0;
10673 foreach_udp_proto_field;
10676 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10679 #define _(a) else if (unformat (input, #a)) a=1;
10680 foreach_udp_proto_field
10686 #define _(a) found_something += a;
10687 foreach_udp_proto_field;
10690 if (found_something == 0)
10693 vec_validate (mask, sizeof (*udp) - 1);
10695 udp = (udp_header_t *) mask;
10697 #define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
10698 foreach_udp_proto_field;
10706 unformat_l4_mask (unformat_input_t * input, va_list * args)
10708 u8 **maskp = va_arg (*args, u8 **);
10709 u16 src_port = 0, dst_port = 0;
10710 tcpudp_header_t *tcpudp;
10712 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10714 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
10716 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
10718 else if (unformat (input, "src_port"))
10720 else if (unformat (input, "dst_port"))
10726 if (!src_port && !dst_port)
10730 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
10732 tcpudp = (tcpudp_header_t *) mask;
10733 tcpudp->src_port = src_port;
10734 tcpudp->dst_port = dst_port;
10742 unformat_ip4_mask (unformat_input_t * input, va_list * args)
10744 u8 **maskp = va_arg (*args, u8 **);
10746 u8 found_something = 0;
10749 #define _(a) u8 a=0;
10750 foreach_ip4_proto_field;
10756 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10758 if (unformat (input, "version"))
10760 else if (unformat (input, "hdr_length"))
10762 else if (unformat (input, "src"))
10764 else if (unformat (input, "dst"))
10766 else if (unformat (input, "proto"))
10769 #define _(a) else if (unformat (input, #a)) a=1;
10770 foreach_ip4_proto_field
10776 #define _(a) found_something += a;
10777 foreach_ip4_proto_field;
10780 if (found_something == 0)
10783 vec_validate (mask, sizeof (*ip) - 1);
10785 ip = (ip4_header_t *) mask;
10787 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
10788 foreach_ip4_proto_field;
10791 ip->ip_version_and_header_length = 0;
10794 ip->ip_version_and_header_length |= 0xF0;
10797 ip->ip_version_and_header_length |= 0x0F;
10803 #define foreach_ip6_proto_field \
10806 _(payload_length) \
10811 unformat_ip6_mask (unformat_input_t * input, va_list * args)
10813 u8 **maskp = va_arg (*args, u8 **);
10815 u8 found_something = 0;
10817 u32 ip_version_traffic_class_and_flow_label;
10819 #define _(a) u8 a=0;
10820 foreach_ip6_proto_field;
10823 u8 traffic_class = 0;
10826 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10828 if (unformat (input, "version"))
10830 else if (unformat (input, "traffic-class"))
10832 else if (unformat (input, "flow-label"))
10834 else if (unformat (input, "src"))
10836 else if (unformat (input, "dst"))
10838 else if (unformat (input, "proto"))
10841 #define _(a) else if (unformat (input, #a)) a=1;
10842 foreach_ip6_proto_field
10848 #define _(a) found_something += a;
10849 foreach_ip6_proto_field;
10852 if (found_something == 0)
10855 vec_validate (mask, sizeof (*ip) - 1);
10857 ip = (ip6_header_t *) mask;
10859 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
10860 foreach_ip6_proto_field;
10863 ip_version_traffic_class_and_flow_label = 0;
10866 ip_version_traffic_class_and_flow_label |= 0xF0000000;
10869 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
10872 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
10874 ip->ip_version_traffic_class_and_flow_label =
10875 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10882 unformat_l3_mask (unformat_input_t * input, va_list * args)
10884 u8 **maskp = va_arg (*args, u8 **);
10886 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10888 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
10890 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
10899 unformat_l2_mask (unformat_input_t * input, va_list * args)
10901 u8 **maskp = va_arg (*args, u8 **);
10908 u8 ignore_tag1 = 0;
10909 u8 ignore_tag2 = 0;
10916 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10918 if (unformat (input, "src"))
10920 else if (unformat (input, "dst"))
10922 else if (unformat (input, "proto"))
10924 else if (unformat (input, "tag1"))
10926 else if (unformat (input, "tag2"))
10928 else if (unformat (input, "ignore-tag1"))
10930 else if (unformat (input, "ignore-tag2"))
10932 else if (unformat (input, "cos1"))
10934 else if (unformat (input, "cos2"))
10936 else if (unformat (input, "dot1q"))
10938 else if (unformat (input, "dot1ad"))
10943 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
10944 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10947 if (tag1 || ignore_tag1 || cos1 || dot1q)
10949 if (tag2 || ignore_tag2 || cos2 || dot1ad)
10952 vec_validate (mask, len - 1);
10955 clib_memset (mask, 0xff, 6);
10958 clib_memset (mask + 6, 0xff, 6);
10960 if (tag2 || dot1ad)
10962 /* inner vlan tag */
10971 mask[21] = mask[20] = 0xff;
10992 mask[16] = mask[17] = 0xff;
11002 mask[12] = mask[13] = 0xff;
11009 unformat_classify_mask (unformat_input_t * input, va_list * args)
11011 u8 **maskp = va_arg (*args, u8 **);
11012 u32 *skipp = va_arg (*args, u32 *);
11013 u32 *matchp = va_arg (*args, u32 *);
11021 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11023 if (unformat (input, "hex %U", unformat_hex_string, &mask))
11025 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
11027 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
11029 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
11043 if (mask || l2 || l3 || l4)
11045 if (l2 || l3 || l4)
11047 /* "With a free Ethernet header in every package" */
11049 vec_validate (l2, 13);
11053 vec_append (mask, l3);
11058 vec_append (mask, l4);
11063 /* Scan forward looking for the first significant mask octet */
11064 for (i = 0; i < vec_len (mask); i++)
11068 /* compute (skip, match) params */
11069 *skipp = i / sizeof (u32x4);
11070 vec_delete (mask, *skipp * sizeof (u32x4), 0);
11072 /* Pad mask to an even multiple of the vector size */
11073 while (vec_len (mask) % sizeof (u32x4))
11074 vec_add1 (mask, 0);
11076 match = vec_len (mask) / sizeof (u32x4);
11078 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
11080 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
11081 if (*tmp || *(tmp + 1))
11086 clib_warning ("BUG: match 0");
11088 _vec_len (mask) = match * sizeof (u32x4);
11098 #endif /* VPP_API_TEST_BUILTIN */
11100 #define foreach_l2_next \
11102 _(ethernet, ETHERNET_INPUT) \
11103 _(ip4, IP4_INPUT) \
11107 unformat_l2_next_index (unformat_input_t * input, va_list * args)
11109 u32 *miss_next_indexp = va_arg (*args, u32 *);
11110 u32 next_index = 0;
11114 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
11118 if (unformat (input, "%d", &tmp))
11127 *miss_next_indexp = next_index;
11131 #define foreach_ip_next \
11134 _(rewrite, REWRITE)
11137 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
11139 u32 *miss_next_indexp = va_arg (*args, u32 *);
11140 u32 next_index = 0;
11144 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
11148 if (unformat (input, "%d", &tmp))
11157 *miss_next_indexp = next_index;
11161 #define foreach_acl_next \
11165 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
11167 u32 *miss_next_indexp = va_arg (*args, u32 *);
11168 u32 next_index = 0;
11172 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
11176 if (unformat (input, "permit"))
11181 else if (unformat (input, "%d", &tmp))
11190 *miss_next_indexp = next_index;
11195 unformat_policer_precolor (unformat_input_t * input, va_list * args)
11197 u32 *r = va_arg (*args, u32 *);
11199 if (unformat (input, "conform-color"))
11200 *r = POLICE_CONFORM;
11201 else if (unformat (input, "exceed-color"))
11202 *r = POLICE_EXCEED;
11210 api_classify_add_del_table (vat_main_t * vam)
11212 unformat_input_t *i = vam->input;
11213 vl_api_classify_add_del_table_t *mp;
11220 u32 table_index = ~0;
11221 u32 next_table_index = ~0;
11222 u32 miss_next_index = ~0;
11223 u32 memory_size = 32 << 20;
11225 u32 current_data_flag = 0;
11226 int current_data_offset = 0;
11229 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11231 if (unformat (i, "del"))
11233 else if (unformat (i, "del-chain"))
11238 else if (unformat (i, "buckets %d", &nbuckets))
11240 else if (unformat (i, "memory_size %d", &memory_size))
11242 else if (unformat (i, "skip %d", &skip))
11244 else if (unformat (i, "match %d", &match))
11246 else if (unformat (i, "table %d", &table_index))
11248 else if (unformat (i, "mask %U", unformat_classify_mask,
11249 &mask, &skip, &match))
11251 else if (unformat (i, "next-table %d", &next_table_index))
11253 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
11256 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
11259 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
11262 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
11264 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
11270 if (is_add && mask == 0)
11272 errmsg ("Mask required");
11276 if (is_add && skip == ~0)
11278 errmsg ("skip count required");
11282 if (is_add && match == ~0)
11284 errmsg ("match count required");
11288 if (!is_add && table_index == ~0)
11290 errmsg ("table index required for delete");
11294 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
11296 mp->is_add = is_add;
11297 mp->del_chain = del_chain;
11298 mp->table_index = ntohl (table_index);
11299 mp->nbuckets = ntohl (nbuckets);
11300 mp->memory_size = ntohl (memory_size);
11301 mp->skip_n_vectors = ntohl (skip);
11302 mp->match_n_vectors = ntohl (match);
11303 mp->next_table_index = ntohl (next_table_index);
11304 mp->miss_next_index = ntohl (miss_next_index);
11305 mp->current_data_flag = ntohl (current_data_flag);
11306 mp->current_data_offset = ntohl (current_data_offset);
11307 mp->mask_len = ntohl (vec_len (mask));
11308 clib_memcpy (mp->mask, mask, vec_len (mask));
11317 #if VPP_API_TEST_BUILTIN == 0
11319 unformat_l4_match (unformat_input_t * input, va_list * args)
11321 u8 **matchp = va_arg (*args, u8 **);
11323 u8 *proto_header = 0;
11329 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11331 if (unformat (input, "src_port %d", &src_port))
11333 else if (unformat (input, "dst_port %d", &dst_port))
11339 h.src_port = clib_host_to_net_u16 (src_port);
11340 h.dst_port = clib_host_to_net_u16 (dst_port);
11341 vec_validate (proto_header, sizeof (h) - 1);
11342 memcpy (proto_header, &h, sizeof (h));
11344 *matchp = proto_header;
11350 unformat_ip4_match (unformat_input_t * input, va_list * args)
11352 u8 **matchp = va_arg (*args, u8 **);
11357 int hdr_length = 0;
11358 u32 hdr_length_val;
11359 int src = 0, dst = 0;
11360 ip4_address_t src_val, dst_val;
11367 int fragment_id = 0;
11368 u32 fragment_id_val;
11374 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11376 if (unformat (input, "version %d", &version_val))
11378 else if (unformat (input, "hdr_length %d", &hdr_length_val))
11380 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
11382 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
11384 else if (unformat (input, "proto %d", &proto_val))
11386 else if (unformat (input, "tos %d", &tos_val))
11388 else if (unformat (input, "length %d", &length_val))
11390 else if (unformat (input, "fragment_id %d", &fragment_id_val))
11392 else if (unformat (input, "ttl %d", &ttl_val))
11394 else if (unformat (input, "checksum %d", &checksum_val))
11400 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
11401 + ttl + checksum == 0)
11405 * Aligned because we use the real comparison functions
11407 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11409 ip = (ip4_header_t *) match;
11411 /* These are realistically matched in practice */
11413 ip->src_address.as_u32 = src_val.as_u32;
11416 ip->dst_address.as_u32 = dst_val.as_u32;
11419 ip->protocol = proto_val;
11422 /* These are not, but they're included for completeness */
11424 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
11427 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
11433 ip->length = clib_host_to_net_u16 (length_val);
11439 ip->checksum = clib_host_to_net_u16 (checksum_val);
11446 unformat_ip6_match (unformat_input_t * input, va_list * args)
11448 u8 **matchp = va_arg (*args, u8 **);
11453 u8 traffic_class = 0;
11454 u32 traffic_class_val = 0;
11457 int src = 0, dst = 0;
11458 ip6_address_t src_val, dst_val;
11461 int payload_length = 0;
11462 u32 payload_length_val;
11465 u32 ip_version_traffic_class_and_flow_label;
11467 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11469 if (unformat (input, "version %d", &version_val))
11471 else if (unformat (input, "traffic_class %d", &traffic_class_val))
11473 else if (unformat (input, "flow_label %d", &flow_label_val))
11475 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
11477 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
11479 else if (unformat (input, "proto %d", &proto_val))
11481 else if (unformat (input, "payload_length %d", &payload_length_val))
11482 payload_length = 1;
11483 else if (unformat (input, "hop_limit %d", &hop_limit_val))
11489 if (version + traffic_class + flow_label + src + dst + proto +
11490 payload_length + hop_limit == 0)
11494 * Aligned because we use the real comparison functions
11496 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11498 ip = (ip6_header_t *) match;
11501 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
11504 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
11507 ip->protocol = proto_val;
11509 ip_version_traffic_class_and_flow_label = 0;
11512 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
11515 ip_version_traffic_class_and_flow_label |=
11516 (traffic_class_val & 0xFF) << 20;
11519 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
11521 ip->ip_version_traffic_class_and_flow_label =
11522 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
11524 if (payload_length)
11525 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
11528 ip->hop_limit = hop_limit_val;
11535 unformat_l3_match (unformat_input_t * input, va_list * args)
11537 u8 **matchp = va_arg (*args, u8 **);
11539 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11541 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
11543 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
11552 unformat_vlan_tag (unformat_input_t * input, va_list * args)
11554 u8 *tagp = va_arg (*args, u8 *);
11557 if (unformat (input, "%d", &tag))
11559 tagp[0] = (tag >> 8) & 0x0F;
11560 tagp[1] = tag & 0xFF;
11568 unformat_l2_match (unformat_input_t * input, va_list * args)
11570 u8 **matchp = va_arg (*args, u8 **);
11583 u8 ignore_tag1 = 0;
11584 u8 ignore_tag2 = 0;
11590 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11592 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
11595 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
11597 else if (unformat (input, "proto %U",
11598 unformat_ethernet_type_host_byte_order, &proto_val))
11600 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
11602 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
11604 else if (unformat (input, "ignore-tag1"))
11606 else if (unformat (input, "ignore-tag2"))
11608 else if (unformat (input, "cos1 %d", &cos1_val))
11610 else if (unformat (input, "cos2 %d", &cos2_val))
11615 if ((src + dst + proto + tag1 + tag2 +
11616 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
11619 if (tag1 || ignore_tag1 || cos1)
11621 if (tag2 || ignore_tag2 || cos2)
11624 vec_validate_aligned (match, len - 1, sizeof (u32x4));
11627 clib_memcpy (match, dst_val, 6);
11630 clib_memcpy (match + 6, src_val, 6);
11634 /* inner vlan tag */
11635 match[19] = tag2_val[1];
11636 match[18] = tag2_val[0];
11638 match[18] |= (cos2_val & 0x7) << 5;
11641 match[21] = proto_val & 0xff;
11642 match[20] = proto_val >> 8;
11646 match[15] = tag1_val[1];
11647 match[14] = tag1_val[0];
11650 match[14] |= (cos1_val & 0x7) << 5;
11656 match[15] = tag1_val[1];
11657 match[14] = tag1_val[0];
11660 match[17] = proto_val & 0xff;
11661 match[16] = proto_val >> 8;
11664 match[14] |= (cos1_val & 0x7) << 5;
11670 match[18] |= (cos2_val & 0x7) << 5;
11672 match[14] |= (cos1_val & 0x7) << 5;
11675 match[13] = proto_val & 0xff;
11676 match[12] = proto_val >> 8;
11684 unformat_qos_source (unformat_input_t * input, va_list * args)
11686 int *qs = va_arg (*args, int *);
11688 if (unformat (input, "ip"))
11689 *qs = QOS_SOURCE_IP;
11690 else if (unformat (input, "mpls"))
11691 *qs = QOS_SOURCE_MPLS;
11692 else if (unformat (input, "ext"))
11693 *qs = QOS_SOURCE_EXT;
11694 else if (unformat (input, "vlan"))
11695 *qs = QOS_SOURCE_VLAN;
11704 api_unformat_classify_match (unformat_input_t * input, va_list * args)
11706 u8 **matchp = va_arg (*args, u8 **);
11707 u32 skip_n_vectors = va_arg (*args, u32);
11708 u32 match_n_vectors = va_arg (*args, u32);
11715 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11717 if (unformat (input, "hex %U", unformat_hex_string, &match))
11719 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
11721 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
11723 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
11737 if (match || l2 || l3 || l4)
11739 if (l2 || l3 || l4)
11741 /* "Win a free Ethernet header in every packet" */
11743 vec_validate_aligned (l2, 13, sizeof (u32x4));
11747 vec_append_aligned (match, l3, sizeof (u32x4));
11752 vec_append_aligned (match, l4, sizeof (u32x4));
11757 /* Make sure the vector is big enough even if key is all 0's */
11758 vec_validate_aligned
11759 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
11762 /* Set size, include skipped vectors */
11763 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
11774 api_classify_add_del_session (vat_main_t * vam)
11776 unformat_input_t *i = vam->input;
11777 vl_api_classify_add_del_session_t *mp;
11779 u32 table_index = ~0;
11780 u32 hit_next_index = ~0;
11781 u32 opaque_index = ~0;
11784 u32 skip_n_vectors = 0;
11785 u32 match_n_vectors = 0;
11791 * Warning: you have to supply skip_n and match_n
11792 * because the API client cant simply look at the classify
11796 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11798 if (unformat (i, "del"))
11800 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
11803 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
11806 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
11809 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
11811 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
11813 else if (unformat (i, "opaque-index %d", &opaque_index))
11815 else if (unformat (i, "skip_n %d", &skip_n_vectors))
11817 else if (unformat (i, "match_n %d", &match_n_vectors))
11819 else if (unformat (i, "match %U", api_unformat_classify_match,
11820 &match, skip_n_vectors, match_n_vectors))
11822 else if (unformat (i, "advance %d", &advance))
11824 else if (unformat (i, "table-index %d", &table_index))
11826 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
11828 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
11830 else if (unformat (i, "action %d", &action))
11832 else if (unformat (i, "metadata %d", &metadata))
11838 if (table_index == ~0)
11840 errmsg ("Table index required");
11844 if (is_add && match == 0)
11846 errmsg ("Match value required");
11850 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
11852 mp->is_add = is_add;
11853 mp->table_index = ntohl (table_index);
11854 mp->hit_next_index = ntohl (hit_next_index);
11855 mp->opaque_index = ntohl (opaque_index);
11856 mp->advance = ntohl (advance);
11857 mp->action = action;
11858 mp->metadata = ntohl (metadata);
11859 mp->match_len = ntohl (vec_len (match));
11860 clib_memcpy (mp->match, match, vec_len (match));
11869 api_classify_set_interface_ip_table (vat_main_t * vam)
11871 unformat_input_t *i = vam->input;
11872 vl_api_classify_set_interface_ip_table_t *mp;
11874 int sw_if_index_set;
11875 u32 table_index = ~0;
11879 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11881 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11882 sw_if_index_set = 1;
11883 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11884 sw_if_index_set = 1;
11885 else if (unformat (i, "table %d", &table_index))
11889 clib_warning ("parse error '%U'", format_unformat_error, i);
11894 if (sw_if_index_set == 0)
11896 errmsg ("missing interface name or sw_if_index");
11901 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
11903 mp->sw_if_index = ntohl (sw_if_index);
11904 mp->table_index = ntohl (table_index);
11905 mp->is_ipv6 = is_ipv6;
11913 api_classify_set_interface_l2_tables (vat_main_t * vam)
11915 unformat_input_t *i = vam->input;
11916 vl_api_classify_set_interface_l2_tables_t *mp;
11918 int sw_if_index_set;
11919 u32 ip4_table_index = ~0;
11920 u32 ip6_table_index = ~0;
11921 u32 other_table_index = ~0;
11925 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11927 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11928 sw_if_index_set = 1;
11929 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11930 sw_if_index_set = 1;
11931 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11933 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11935 else if (unformat (i, "other-table %d", &other_table_index))
11937 else if (unformat (i, "is-input %d", &is_input))
11941 clib_warning ("parse error '%U'", format_unformat_error, i);
11946 if (sw_if_index_set == 0)
11948 errmsg ("missing interface name or sw_if_index");
11953 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
11955 mp->sw_if_index = ntohl (sw_if_index);
11956 mp->ip4_table_index = ntohl (ip4_table_index);
11957 mp->ip6_table_index = ntohl (ip6_table_index);
11958 mp->other_table_index = ntohl (other_table_index);
11959 mp->is_input = (u8) is_input;
11967 api_set_ipfix_exporter (vat_main_t * vam)
11969 unformat_input_t *i = vam->input;
11970 vl_api_set_ipfix_exporter_t *mp;
11971 ip4_address_t collector_address;
11972 u8 collector_address_set = 0;
11973 u32 collector_port = ~0;
11974 ip4_address_t src_address;
11975 u8 src_address_set = 0;
11978 u32 template_interval = ~0;
11979 u8 udp_checksum = 0;
11982 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11984 if (unformat (i, "collector_address %U", unformat_ip4_address,
11985 &collector_address))
11986 collector_address_set = 1;
11987 else if (unformat (i, "collector_port %d", &collector_port))
11989 else if (unformat (i, "src_address %U", unformat_ip4_address,
11991 src_address_set = 1;
11992 else if (unformat (i, "vrf_id %d", &vrf_id))
11994 else if (unformat (i, "path_mtu %d", &path_mtu))
11996 else if (unformat (i, "template_interval %d", &template_interval))
11998 else if (unformat (i, "udp_checksum"))
12004 if (collector_address_set == 0)
12006 errmsg ("collector_address required");
12010 if (src_address_set == 0)
12012 errmsg ("src_address required");
12016 M (SET_IPFIX_EXPORTER, mp);
12018 memcpy (mp->collector_address, collector_address.data,
12019 sizeof (collector_address.data));
12020 mp->collector_port = htons ((u16) collector_port);
12021 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
12022 mp->vrf_id = htonl (vrf_id);
12023 mp->path_mtu = htonl (path_mtu);
12024 mp->template_interval = htonl (template_interval);
12025 mp->udp_checksum = udp_checksum;
12033 api_set_ipfix_classify_stream (vat_main_t * vam)
12035 unformat_input_t *i = vam->input;
12036 vl_api_set_ipfix_classify_stream_t *mp;
12038 u32 src_port = UDP_DST_PORT_ipfix;
12041 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12043 if (unformat (i, "domain %d", &domain_id))
12045 else if (unformat (i, "src_port %d", &src_port))
12049 errmsg ("unknown input `%U'", format_unformat_error, i);
12054 M (SET_IPFIX_CLASSIFY_STREAM, mp);
12056 mp->domain_id = htonl (domain_id);
12057 mp->src_port = htons ((u16) src_port);
12065 api_ipfix_classify_table_add_del (vat_main_t * vam)
12067 unformat_input_t *i = vam->input;
12068 vl_api_ipfix_classify_table_add_del_t *mp;
12070 u32 classify_table_index = ~0;
12072 u8 transport_protocol = 255;
12075 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12077 if (unformat (i, "add"))
12079 else if (unformat (i, "del"))
12081 else if (unformat (i, "table %d", &classify_table_index))
12083 else if (unformat (i, "ip4"))
12085 else if (unformat (i, "ip6"))
12087 else if (unformat (i, "tcp"))
12088 transport_protocol = 6;
12089 else if (unformat (i, "udp"))
12090 transport_protocol = 17;
12093 errmsg ("unknown input `%U'", format_unformat_error, i);
12100 errmsg ("expecting: add|del");
12103 if (classify_table_index == ~0)
12105 errmsg ("classifier table not specified");
12108 if (ip_version == 0)
12110 errmsg ("IP version not specified");
12114 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
12116 mp->is_add = is_add;
12117 mp->table_id = htonl (classify_table_index);
12118 mp->ip_version = ip_version;
12119 mp->transport_protocol = transport_protocol;
12127 api_get_node_index (vat_main_t * vam)
12129 unformat_input_t *i = vam->input;
12130 vl_api_get_node_index_t *mp;
12134 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12136 if (unformat (i, "node %s", &name))
12143 errmsg ("node name required");
12146 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
12148 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12152 M (GET_NODE_INDEX, mp);
12153 clib_memcpy (mp->node_name, name, vec_len (name));
12162 api_get_next_index (vat_main_t * vam)
12164 unformat_input_t *i = vam->input;
12165 vl_api_get_next_index_t *mp;
12166 u8 *node_name = 0, *next_node_name = 0;
12169 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12171 if (unformat (i, "node-name %s", &node_name))
12173 else if (unformat (i, "next-node-name %s", &next_node_name))
12177 if (node_name == 0)
12179 errmsg ("node name required");
12182 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
12184 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12188 if (next_node_name == 0)
12190 errmsg ("next node name required");
12193 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
12195 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
12199 M (GET_NEXT_INDEX, mp);
12200 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
12201 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
12202 vec_free (node_name);
12203 vec_free (next_node_name);
12211 api_add_node_next (vat_main_t * vam)
12213 unformat_input_t *i = vam->input;
12214 vl_api_add_node_next_t *mp;
12219 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12221 if (unformat (i, "node %s", &name))
12223 else if (unformat (i, "next %s", &next))
12230 errmsg ("node name required");
12233 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
12235 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12240 errmsg ("next node required");
12243 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
12245 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
12249 M (ADD_NODE_NEXT, mp);
12250 clib_memcpy (mp->node_name, name, vec_len (name));
12251 clib_memcpy (mp->next_name, next, vec_len (next));
12261 api_l2tpv3_create_tunnel (vat_main_t * vam)
12263 unformat_input_t *i = vam->input;
12264 ip6_address_t client_address, our_address;
12265 int client_address_set = 0;
12266 int our_address_set = 0;
12267 u32 local_session_id = 0;
12268 u32 remote_session_id = 0;
12269 u64 local_cookie = 0;
12270 u64 remote_cookie = 0;
12271 u8 l2_sublayer_present = 0;
12272 vl_api_l2tpv3_create_tunnel_t *mp;
12275 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12277 if (unformat (i, "client_address %U", unformat_ip6_address,
12279 client_address_set = 1;
12280 else if (unformat (i, "our_address %U", unformat_ip6_address,
12282 our_address_set = 1;
12283 else if (unformat (i, "local_session_id %d", &local_session_id))
12285 else if (unformat (i, "remote_session_id %d", &remote_session_id))
12287 else if (unformat (i, "local_cookie %lld", &local_cookie))
12289 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
12291 else if (unformat (i, "l2-sublayer-present"))
12292 l2_sublayer_present = 1;
12297 if (client_address_set == 0)
12299 errmsg ("client_address required");
12303 if (our_address_set == 0)
12305 errmsg ("our_address required");
12309 M (L2TPV3_CREATE_TUNNEL, mp);
12311 clib_memcpy (mp->client_address, client_address.as_u8,
12312 sizeof (mp->client_address));
12314 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
12316 mp->local_session_id = ntohl (local_session_id);
12317 mp->remote_session_id = ntohl (remote_session_id);
12318 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
12319 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
12320 mp->l2_sublayer_present = l2_sublayer_present;
12329 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
12331 unformat_input_t *i = vam->input;
12333 u8 sw_if_index_set = 0;
12334 u64 new_local_cookie = 0;
12335 u64 new_remote_cookie = 0;
12336 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
12339 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12341 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12342 sw_if_index_set = 1;
12343 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12344 sw_if_index_set = 1;
12345 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
12347 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
12353 if (sw_if_index_set == 0)
12355 errmsg ("missing interface name or sw_if_index");
12359 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
12361 mp->sw_if_index = ntohl (sw_if_index);
12362 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
12363 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
12371 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
12373 unformat_input_t *i = vam->input;
12374 vl_api_l2tpv3_interface_enable_disable_t *mp;
12376 u8 sw_if_index_set = 0;
12377 u8 enable_disable = 1;
12380 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12382 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12383 sw_if_index_set = 1;
12384 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12385 sw_if_index_set = 1;
12386 else if (unformat (i, "enable"))
12387 enable_disable = 1;
12388 else if (unformat (i, "disable"))
12389 enable_disable = 0;
12394 if (sw_if_index_set == 0)
12396 errmsg ("missing interface name or sw_if_index");
12400 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
12402 mp->sw_if_index = ntohl (sw_if_index);
12403 mp->enable_disable = enable_disable;
12411 api_l2tpv3_set_lookup_key (vat_main_t * vam)
12413 unformat_input_t *i = vam->input;
12414 vl_api_l2tpv3_set_lookup_key_t *mp;
12418 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12420 if (unformat (i, "lookup_v6_src"))
12421 key = L2T_LOOKUP_SRC_ADDRESS;
12422 else if (unformat (i, "lookup_v6_dst"))
12423 key = L2T_LOOKUP_DST_ADDRESS;
12424 else if (unformat (i, "lookup_session_id"))
12425 key = L2T_LOOKUP_SESSION_ID;
12430 if (key == (u8) ~ 0)
12432 errmsg ("l2tp session lookup key unset");
12436 M (L2TPV3_SET_LOOKUP_KEY, mp);
12445 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
12446 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12448 vat_main_t *vam = &vat_main;
12450 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
12451 format_ip6_address, mp->our_address,
12452 format_ip6_address, mp->client_address,
12453 clib_net_to_host_u32 (mp->sw_if_index));
12456 " local cookies %016llx %016llx remote cookie %016llx",
12457 clib_net_to_host_u64 (mp->local_cookie[0]),
12458 clib_net_to_host_u64 (mp->local_cookie[1]),
12459 clib_net_to_host_u64 (mp->remote_cookie));
12461 print (vam->ofp, " local session-id %d remote session-id %d",
12462 clib_net_to_host_u32 (mp->local_session_id),
12463 clib_net_to_host_u32 (mp->remote_session_id));
12465 print (vam->ofp, " l2 specific sublayer %s\n",
12466 mp->l2_sublayer_present ? "preset" : "absent");
12470 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
12471 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12473 vat_main_t *vam = &vat_main;
12474 vat_json_node_t *node = NULL;
12475 struct in6_addr addr;
12477 if (VAT_JSON_ARRAY != vam->json_tree.type)
12479 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12480 vat_json_init_array (&vam->json_tree);
12482 node = vat_json_array_add (&vam->json_tree);
12484 vat_json_init_object (node);
12486 clib_memcpy (&addr, mp->our_address, sizeof (addr));
12487 vat_json_object_add_ip6 (node, "our_address", addr);
12488 clib_memcpy (&addr, mp->client_address, sizeof (addr));
12489 vat_json_object_add_ip6 (node, "client_address", addr);
12491 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
12492 vat_json_init_array (lc);
12493 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
12494 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
12495 vat_json_object_add_uint (node, "remote_cookie",
12496 clib_net_to_host_u64 (mp->remote_cookie));
12498 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
12499 vat_json_object_add_uint (node, "local_session_id",
12500 clib_net_to_host_u32 (mp->local_session_id));
12501 vat_json_object_add_uint (node, "remote_session_id",
12502 clib_net_to_host_u32 (mp->remote_session_id));
12503 vat_json_object_add_string_copy (node, "l2_sublayer",
12504 mp->l2_sublayer_present ? (u8 *) "present"
12505 : (u8 *) "absent");
12509 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
12511 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
12512 vl_api_control_ping_t *mp_ping;
12515 /* Get list of l2tpv3-tunnel interfaces */
12516 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
12519 /* Use a control ping for synchronization */
12520 MPING (CONTROL_PING, mp_ping);
12528 static void vl_api_sw_interface_tap_v2_details_t_handler
12529 (vl_api_sw_interface_tap_v2_details_t * mp)
12531 vat_main_t *vam = &vat_main;
12533 u8 *ip4 = format (0, "%U/%d", format_ip4_address, mp->host_ip4_addr,
12534 mp->host_ip4_prefix_len);
12535 u8 *ip6 = format (0, "%U/%d", format_ip6_address, mp->host_ip6_addr,
12536 mp->host_ip6_prefix_len);
12539 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s 0x%-08x",
12540 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
12541 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
12542 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
12543 mp->host_bridge, ip4, ip6, ntohl (mp->tap_flags));
12549 static void vl_api_sw_interface_tap_v2_details_t_handler_json
12550 (vl_api_sw_interface_tap_v2_details_t * mp)
12552 vat_main_t *vam = &vat_main;
12553 vat_json_node_t *node = NULL;
12555 if (VAT_JSON_ARRAY != vam->json_tree.type)
12557 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12558 vat_json_init_array (&vam->json_tree);
12560 node = vat_json_array_add (&vam->json_tree);
12562 vat_json_init_object (node);
12563 vat_json_object_add_uint (node, "id", ntohl (mp->id));
12564 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12565 vat_json_object_add_uint (node, "tap_flags", ntohl (mp->tap_flags));
12566 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
12567 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
12568 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
12569 vat_json_object_add_string_copy (node, "host_mac_addr",
12570 format (0, "%U", format_ethernet_address,
12571 &mp->host_mac_addr));
12572 vat_json_object_add_string_copy (node, "host_namespace",
12573 mp->host_namespace);
12574 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
12575 vat_json_object_add_string_copy (node, "host_ip4_addr",
12576 format (0, "%U/%d", format_ip4_address,
12578 mp->host_ip4_prefix_len));
12579 vat_json_object_add_string_copy (node, "host_ip6_addr",
12580 format (0, "%U/%d", format_ip6_address,
12582 mp->host_ip6_prefix_len));
12587 api_sw_interface_tap_v2_dump (vat_main_t * vam)
12589 vl_api_sw_interface_tap_v2_dump_t *mp;
12590 vl_api_control_ping_t *mp_ping;
12594 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
12595 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
12596 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
12599 /* Get list of tap interfaces */
12600 M (SW_INTERFACE_TAP_V2_DUMP, mp);
12603 /* Use a control ping for synchronization */
12604 MPING (CONTROL_PING, mp_ping);
12611 static void vl_api_sw_interface_virtio_pci_details_t_handler
12612 (vl_api_sw_interface_virtio_pci_details_t * mp)
12614 vat_main_t *vam = &vat_main;
12628 addr.as_u32 = ntohl (mp->pci_addr);
12629 u8 *pci_addr = format (0, "%04x:%02x:%02x.%x", addr.domain, addr.bus,
12630 addr.slot, addr.function);
12633 "\n%-12s %-12d %-12d %-12d %-17U 0x%-08llx",
12634 pci_addr, ntohl (mp->sw_if_index),
12635 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
12636 format_ethernet_address, mp->mac_addr,
12637 clib_net_to_host_u64 (mp->features));
12638 vec_free (pci_addr);
12641 static void vl_api_sw_interface_virtio_pci_details_t_handler_json
12642 (vl_api_sw_interface_virtio_pci_details_t * mp)
12644 vat_main_t *vam = &vat_main;
12645 vat_json_node_t *node = NULL;
12647 if (VAT_JSON_ARRAY != vam->json_tree.type)
12649 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12650 vat_json_init_array (&vam->json_tree);
12652 node = vat_json_array_add (&vam->json_tree);
12654 vat_json_init_object (node);
12655 vat_json_object_add_uint (node, "pci-addr", ntohl (mp->pci_addr));
12656 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12657 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
12658 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
12659 vat_json_object_add_uint (node, "features",
12660 clib_net_to_host_u64 (mp->features));
12661 vat_json_object_add_string_copy (node, "mac_addr",
12662 format (0, "%U", format_ethernet_address,
12667 api_sw_interface_virtio_pci_dump (vat_main_t * vam)
12669 vl_api_sw_interface_virtio_pci_dump_t *mp;
12670 vl_api_control_ping_t *mp_ping;
12674 "\n%-12s %-12s %-12s %-12s %-17s %-08s",
12675 "pci_addr", "sw_if_index", "rx_ring_sz", "tx_ring_sz",
12676 "mac_addr", "features");
12678 /* Get list of tap interfaces */
12679 M (SW_INTERFACE_VIRTIO_PCI_DUMP, mp);
12682 /* Use a control ping for synchronization */
12683 MPING (CONTROL_PING, mp_ping);
12691 api_vxlan_offload_rx (vat_main_t * vam)
12693 unformat_input_t *line_input = vam->input;
12694 vl_api_vxlan_offload_rx_t *mp;
12695 u32 hw_if_index = ~0, rx_if_index = ~0;
12699 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12701 if (unformat (line_input, "del"))
12703 else if (unformat (line_input, "hw %U", api_unformat_hw_if_index, vam,
12706 else if (unformat (line_input, "hw hw_if_index %u", &hw_if_index))
12708 else if (unformat (line_input, "rx %U", api_unformat_sw_if_index, vam,
12711 else if (unformat (line_input, "rx sw_if_index %u", &rx_if_index))
12715 errmsg ("parse error '%U'", format_unformat_error, line_input);
12720 if (hw_if_index == ~0)
12722 errmsg ("no hw interface");
12726 if (rx_if_index == ~0)
12728 errmsg ("no rx tunnel");
12732 M (VXLAN_OFFLOAD_RX, mp);
12734 mp->hw_if_index = ntohl (hw_if_index);
12735 mp->sw_if_index = ntohl (rx_if_index);
12736 mp->enable = is_add;
12743 static uword unformat_vxlan_decap_next
12744 (unformat_input_t * input, va_list * args)
12746 u32 *result = va_arg (*args, u32 *);
12749 if (unformat (input, "l2"))
12750 *result = VXLAN_INPUT_NEXT_L2_INPUT;
12751 else if (unformat (input, "%d", &tmp))
12759 api_vxlan_add_del_tunnel (vat_main_t * vam)
12761 unformat_input_t *line_input = vam->input;
12762 vl_api_vxlan_add_del_tunnel_t *mp;
12763 ip46_address_t src, dst;
12765 u8 ipv4_set = 0, ipv6_set = 0;
12770 u32 mcast_sw_if_index = ~0;
12771 u32 encap_vrf_id = 0;
12772 u32 decap_next_index = ~0;
12776 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12777 clib_memset (&src, 0, sizeof src);
12778 clib_memset (&dst, 0, sizeof dst);
12780 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12782 if (unformat (line_input, "del"))
12784 else if (unformat (line_input, "instance %d", &instance))
12787 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12793 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12799 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12805 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12810 else if (unformat (line_input, "group %U %U",
12811 unformat_ip4_address, &dst.ip4,
12812 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12814 grp_set = dst_set = 1;
12817 else if (unformat (line_input, "group %U",
12818 unformat_ip4_address, &dst.ip4))
12820 grp_set = dst_set = 1;
12823 else if (unformat (line_input, "group %U %U",
12824 unformat_ip6_address, &dst.ip6,
12825 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12827 grp_set = dst_set = 1;
12830 else if (unformat (line_input, "group %U",
12831 unformat_ip6_address, &dst.ip6))
12833 grp_set = dst_set = 1;
12837 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12839 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12841 else if (unformat (line_input, "decap-next %U",
12842 unformat_vxlan_decap_next, &decap_next_index))
12844 else if (unformat (line_input, "vni %d", &vni))
12848 errmsg ("parse error '%U'", format_unformat_error, line_input);
12855 errmsg ("tunnel src address not specified");
12860 errmsg ("tunnel dst address not specified");
12864 if (grp_set && !ip46_address_is_multicast (&dst))
12866 errmsg ("tunnel group address not multicast");
12869 if (grp_set && mcast_sw_if_index == ~0)
12871 errmsg ("tunnel nonexistent multicast device");
12874 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12876 errmsg ("tunnel dst address must be unicast");
12881 if (ipv4_set && ipv6_set)
12883 errmsg ("both IPv4 and IPv6 addresses specified");
12887 if ((vni == 0) || (vni >> 24))
12889 errmsg ("vni not specified or out of range");
12893 M (VXLAN_ADD_DEL_TUNNEL, mp);
12897 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
12898 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
12902 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
12903 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
12906 mp->instance = htonl (instance);
12907 mp->encap_vrf_id = ntohl (encap_vrf_id);
12908 mp->decap_next_index = ntohl (decap_next_index);
12909 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12910 mp->vni = ntohl (vni);
12911 mp->is_add = is_add;
12912 mp->is_ipv6 = ipv6_set;
12919 static void vl_api_vxlan_tunnel_details_t_handler
12920 (vl_api_vxlan_tunnel_details_t * mp)
12922 vat_main_t *vam = &vat_main;
12923 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12924 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12926 print (vam->ofp, "%11d%11d%24U%24U%14d%18d%13d%19d",
12927 ntohl (mp->sw_if_index),
12928 ntohl (mp->instance),
12929 format_ip46_address, &src, IP46_TYPE_ANY,
12930 format_ip46_address, &dst, IP46_TYPE_ANY,
12931 ntohl (mp->encap_vrf_id),
12932 ntohl (mp->decap_next_index), ntohl (mp->vni),
12933 ntohl (mp->mcast_sw_if_index));
12936 static void vl_api_vxlan_tunnel_details_t_handler_json
12937 (vl_api_vxlan_tunnel_details_t * mp)
12939 vat_main_t *vam = &vat_main;
12940 vat_json_node_t *node = NULL;
12942 if (VAT_JSON_ARRAY != vam->json_tree.type)
12944 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12945 vat_json_init_array (&vam->json_tree);
12947 node = vat_json_array_add (&vam->json_tree);
12949 vat_json_init_object (node);
12950 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12952 vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
12956 struct in6_addr ip6;
12958 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12959 vat_json_object_add_ip6 (node, "src_address", ip6);
12960 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12961 vat_json_object_add_ip6 (node, "dst_address", ip6);
12965 struct in_addr ip4;
12967 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12968 vat_json_object_add_ip4 (node, "src_address", ip4);
12969 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12970 vat_json_object_add_ip4 (node, "dst_address", ip4);
12972 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12973 vat_json_object_add_uint (node, "decap_next_index",
12974 ntohl (mp->decap_next_index));
12975 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12976 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12977 vat_json_object_add_uint (node, "mcast_sw_if_index",
12978 ntohl (mp->mcast_sw_if_index));
12982 api_vxlan_tunnel_dump (vat_main_t * vam)
12984 unformat_input_t *i = vam->input;
12985 vl_api_vxlan_tunnel_dump_t *mp;
12986 vl_api_control_ping_t *mp_ping;
12988 u8 sw_if_index_set = 0;
12991 /* Parse args required to build the message */
12992 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12994 if (unformat (i, "sw_if_index %d", &sw_if_index))
12995 sw_if_index_set = 1;
13000 if (sw_if_index_set == 0)
13005 if (!vam->json_output)
13007 print (vam->ofp, "%11s%11s%24s%24s%14s%18s%13s%19s",
13008 "sw_if_index", "instance", "src_address", "dst_address",
13009 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
13012 /* Get list of vxlan-tunnel interfaces */
13013 M (VXLAN_TUNNEL_DUMP, mp);
13015 mp->sw_if_index = htonl (sw_if_index);
13019 /* Use a control ping for synchronization */
13020 MPING (CONTROL_PING, mp_ping);
13027 static uword unformat_geneve_decap_next
13028 (unformat_input_t * input, va_list * args)
13030 u32 *result = va_arg (*args, u32 *);
13033 if (unformat (input, "l2"))
13034 *result = GENEVE_INPUT_NEXT_L2_INPUT;
13035 else if (unformat (input, "%d", &tmp))
13043 api_geneve_add_del_tunnel (vat_main_t * vam)
13045 unformat_input_t *line_input = vam->input;
13046 vl_api_geneve_add_del_tunnel_t *mp;
13047 ip46_address_t src, dst;
13049 u8 ipv4_set = 0, ipv6_set = 0;
13053 u32 mcast_sw_if_index = ~0;
13054 u32 encap_vrf_id = 0;
13055 u32 decap_next_index = ~0;
13059 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
13060 clib_memset (&src, 0, sizeof src);
13061 clib_memset (&dst, 0, sizeof dst);
13063 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13065 if (unformat (line_input, "del"))
13068 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
13074 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
13080 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
13086 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
13091 else if (unformat (line_input, "group %U %U",
13092 unformat_ip4_address, &dst.ip4,
13093 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13095 grp_set = dst_set = 1;
13098 else if (unformat (line_input, "group %U",
13099 unformat_ip4_address, &dst.ip4))
13101 grp_set = dst_set = 1;
13104 else if (unformat (line_input, "group %U %U",
13105 unformat_ip6_address, &dst.ip6,
13106 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13108 grp_set = dst_set = 1;
13111 else if (unformat (line_input, "group %U",
13112 unformat_ip6_address, &dst.ip6))
13114 grp_set = dst_set = 1;
13118 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13120 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13122 else if (unformat (line_input, "decap-next %U",
13123 unformat_geneve_decap_next, &decap_next_index))
13125 else if (unformat (line_input, "vni %d", &vni))
13129 errmsg ("parse error '%U'", format_unformat_error, line_input);
13136 errmsg ("tunnel src address not specified");
13141 errmsg ("tunnel dst address not specified");
13145 if (grp_set && !ip46_address_is_multicast (&dst))
13147 errmsg ("tunnel group address not multicast");
13150 if (grp_set && mcast_sw_if_index == ~0)
13152 errmsg ("tunnel nonexistent multicast device");
13155 if (grp_set == 0 && ip46_address_is_multicast (&dst))
13157 errmsg ("tunnel dst address must be unicast");
13162 if (ipv4_set && ipv6_set)
13164 errmsg ("both IPv4 and IPv6 addresses specified");
13168 if ((vni == 0) || (vni >> 24))
13170 errmsg ("vni not specified or out of range");
13174 M (GENEVE_ADD_DEL_TUNNEL, mp);
13178 clib_memcpy (mp->local_address, &src.ip6, sizeof (src.ip6));
13179 clib_memcpy (mp->remote_address, &dst.ip6, sizeof (dst.ip6));
13183 clib_memcpy (mp->local_address, &src.ip4, sizeof (src.ip4));
13184 clib_memcpy (mp->remote_address, &dst.ip4, sizeof (dst.ip4));
13186 mp->encap_vrf_id = ntohl (encap_vrf_id);
13187 mp->decap_next_index = ntohl (decap_next_index);
13188 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
13189 mp->vni = ntohl (vni);
13190 mp->is_add = is_add;
13191 mp->is_ipv6 = ipv6_set;
13198 static void vl_api_geneve_tunnel_details_t_handler
13199 (vl_api_geneve_tunnel_details_t * mp)
13201 vat_main_t *vam = &vat_main;
13202 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
13203 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
13205 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
13206 ntohl (mp->sw_if_index),
13207 format_ip46_address, &src, IP46_TYPE_ANY,
13208 format_ip46_address, &dst, IP46_TYPE_ANY,
13209 ntohl (mp->encap_vrf_id),
13210 ntohl (mp->decap_next_index), ntohl (mp->vni),
13211 ntohl (mp->mcast_sw_if_index));
13214 static void vl_api_geneve_tunnel_details_t_handler_json
13215 (vl_api_geneve_tunnel_details_t * mp)
13217 vat_main_t *vam = &vat_main;
13218 vat_json_node_t *node = NULL;
13220 if (VAT_JSON_ARRAY != vam->json_tree.type)
13222 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13223 vat_json_init_array (&vam->json_tree);
13225 node = vat_json_array_add (&vam->json_tree);
13227 vat_json_init_object (node);
13228 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13231 struct in6_addr ip6;
13233 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
13234 vat_json_object_add_ip6 (node, "src_address", ip6);
13235 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
13236 vat_json_object_add_ip6 (node, "dst_address", ip6);
13240 struct in_addr ip4;
13242 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
13243 vat_json_object_add_ip4 (node, "src_address", ip4);
13244 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
13245 vat_json_object_add_ip4 (node, "dst_address", ip4);
13247 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
13248 vat_json_object_add_uint (node, "decap_next_index",
13249 ntohl (mp->decap_next_index));
13250 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
13251 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
13252 vat_json_object_add_uint (node, "mcast_sw_if_index",
13253 ntohl (mp->mcast_sw_if_index));
13257 api_geneve_tunnel_dump (vat_main_t * vam)
13259 unformat_input_t *i = vam->input;
13260 vl_api_geneve_tunnel_dump_t *mp;
13261 vl_api_control_ping_t *mp_ping;
13263 u8 sw_if_index_set = 0;
13266 /* Parse args required to build the message */
13267 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13269 if (unformat (i, "sw_if_index %d", &sw_if_index))
13270 sw_if_index_set = 1;
13275 if (sw_if_index_set == 0)
13280 if (!vam->json_output)
13282 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
13283 "sw_if_index", "local_address", "remote_address",
13284 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
13287 /* Get list of geneve-tunnel interfaces */
13288 M (GENEVE_TUNNEL_DUMP, mp);
13290 mp->sw_if_index = htonl (sw_if_index);
13294 /* Use a control ping for synchronization */
13295 M (CONTROL_PING, mp_ping);
13303 api_gre_tunnel_add_del (vat_main_t * vam)
13305 unformat_input_t *line_input = vam->input;
13306 vl_api_address_t src = { }, dst =
13309 vl_api_gre_tunnel_add_del_t *mp;
13310 vl_api_gre_tunnel_type_t t_type;
13316 u32 outer_fib_id = 0;
13317 u32 session_id = 0;
13321 t_type = GRE_API_TUNNEL_TYPE_L3;
13323 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13325 if (unformat (line_input, "del"))
13327 else if (unformat (line_input, "instance %d", &instance))
13329 else if (unformat (line_input, "src %U", unformat_vl_api_address, &src))
13333 else if (unformat (line_input, "dst %U", unformat_vl_api_address, &dst))
13337 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
13339 else if (unformat (line_input, "teb"))
13340 t_type = GRE_API_TUNNEL_TYPE_TEB;
13341 else if (unformat (line_input, "erspan %d", &session_id))
13342 t_type = GRE_API_TUNNEL_TYPE_ERSPAN;
13345 errmsg ("parse error '%U'", format_unformat_error, line_input);
13352 errmsg ("tunnel src address not specified");
13357 errmsg ("tunnel dst address not specified");
13361 M (GRE_TUNNEL_ADD_DEL, mp);
13363 clib_memcpy (&mp->tunnel.src, &src, sizeof (mp->tunnel.src));
13364 clib_memcpy (&mp->tunnel.dst, &dst, sizeof (mp->tunnel.dst));
13366 mp->tunnel.instance = htonl (instance);
13367 mp->tunnel.outer_fib_id = htonl (outer_fib_id);
13368 mp->is_add = is_add;
13369 mp->tunnel.session_id = htons ((u16) session_id);
13370 mp->tunnel.type = htonl (t_type);
13377 static void vl_api_gre_tunnel_details_t_handler
13378 (vl_api_gre_tunnel_details_t * mp)
13380 vat_main_t *vam = &vat_main;
13382 print (vam->ofp, "%11d%11d%24U%24U%13d%14d%12d",
13383 ntohl (mp->tunnel.sw_if_index),
13384 ntohl (mp->tunnel.instance),
13385 format_vl_api_address, &mp->tunnel.src,
13386 format_vl_api_address, &mp->tunnel.dst,
13387 mp->tunnel.type, ntohl (mp->tunnel.outer_fib_id),
13388 ntohl (mp->tunnel.session_id));
13392 vat_json_object_add_address (vat_json_node_t * node,
13393 const char *str, const vl_api_address_t * addr)
13395 if (ADDRESS_IP6 == addr->af)
13397 struct in6_addr ip6;
13399 clib_memcpy (&ip6, &addr->un.ip6, sizeof (ip6));
13400 vat_json_object_add_ip6 (node, str, ip6);
13404 struct in_addr ip4;
13406 clib_memcpy (&ip4, &addr->un.ip4, sizeof (ip4));
13407 vat_json_object_add_ip4 (node, str, ip4);
13411 static void vl_api_gre_tunnel_details_t_handler_json
13412 (vl_api_gre_tunnel_details_t * mp)
13414 vat_main_t *vam = &vat_main;
13415 vat_json_node_t *node = NULL;
13416 struct in_addr ip4;
13417 struct in6_addr ip6;
13419 if (VAT_JSON_ARRAY != vam->json_tree.type)
13421 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13422 vat_json_init_array (&vam->json_tree);
13424 node = vat_json_array_add (&vam->json_tree);
13426 vat_json_init_object (node);
13427 vat_json_object_add_uint (node, "sw_if_index",
13428 ntohl (mp->tunnel.sw_if_index));
13429 vat_json_object_add_uint (node, "instance", ntohl (mp->tunnel.instance));
13431 vat_json_object_add_address (node, "src", &mp->tunnel.src);
13432 vat_json_object_add_address (node, "dst", &mp->tunnel.dst);
13433 vat_json_object_add_uint (node, "tunnel_type", mp->tunnel.type);
13434 vat_json_object_add_uint (node, "outer_fib_id",
13435 ntohl (mp->tunnel.outer_fib_id));
13436 vat_json_object_add_uint (node, "session_id", mp->tunnel.session_id);
13440 api_gre_tunnel_dump (vat_main_t * vam)
13442 unformat_input_t *i = vam->input;
13443 vl_api_gre_tunnel_dump_t *mp;
13444 vl_api_control_ping_t *mp_ping;
13446 u8 sw_if_index_set = 0;
13449 /* Parse args required to build the message */
13450 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13452 if (unformat (i, "sw_if_index %d", &sw_if_index))
13453 sw_if_index_set = 1;
13458 if (sw_if_index_set == 0)
13463 if (!vam->json_output)
13465 print (vam->ofp, "%11s%11s%24s%24s%13s%14s%12s",
13466 "sw_if_index", "instance", "src_address", "dst_address",
13467 "tunnel_type", "outer_fib_id", "session_id");
13470 /* Get list of gre-tunnel interfaces */
13471 M (GRE_TUNNEL_DUMP, mp);
13473 mp->sw_if_index = htonl (sw_if_index);
13477 /* Use a control ping for synchronization */
13478 MPING (CONTROL_PING, mp_ping);
13486 api_l2_fib_clear_table (vat_main_t * vam)
13488 // unformat_input_t * i = vam->input;
13489 vl_api_l2_fib_clear_table_t *mp;
13492 M (L2_FIB_CLEAR_TABLE, mp);
13500 api_l2_interface_efp_filter (vat_main_t * vam)
13502 unformat_input_t *i = vam->input;
13503 vl_api_l2_interface_efp_filter_t *mp;
13506 u8 sw_if_index_set = 0;
13509 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13511 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13512 sw_if_index_set = 1;
13513 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13514 sw_if_index_set = 1;
13515 else if (unformat (i, "enable"))
13517 else if (unformat (i, "disable"))
13521 clib_warning ("parse error '%U'", format_unformat_error, i);
13526 if (sw_if_index_set == 0)
13528 errmsg ("missing sw_if_index");
13532 M (L2_INTERFACE_EFP_FILTER, mp);
13534 mp->sw_if_index = ntohl (sw_if_index);
13535 mp->enable_disable = enable;
13542 #define foreach_vtr_op \
13543 _("disable", L2_VTR_DISABLED) \
13544 _("push-1", L2_VTR_PUSH_1) \
13545 _("push-2", L2_VTR_PUSH_2) \
13546 _("pop-1", L2_VTR_POP_1) \
13547 _("pop-2", L2_VTR_POP_2) \
13548 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
13549 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
13550 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
13551 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
13554 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
13556 unformat_input_t *i = vam->input;
13557 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
13559 u8 sw_if_index_set = 0;
13562 u32 push_dot1q = 1;
13567 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13569 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13570 sw_if_index_set = 1;
13571 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13572 sw_if_index_set = 1;
13573 else if (unformat (i, "vtr_op %d", &vtr_op))
13575 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
13578 else if (unformat (i, "push_dot1q %d", &push_dot1q))
13580 else if (unformat (i, "tag1 %d", &tag1))
13582 else if (unformat (i, "tag2 %d", &tag2))
13586 clib_warning ("parse error '%U'", format_unformat_error, i);
13591 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
13593 errmsg ("missing vtr operation or sw_if_index");
13597 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
13598 mp->sw_if_index = ntohl (sw_if_index);
13599 mp->vtr_op = ntohl (vtr_op);
13600 mp->push_dot1q = ntohl (push_dot1q);
13601 mp->tag1 = ntohl (tag1);
13602 mp->tag2 = ntohl (tag2);
13610 api_create_vhost_user_if (vat_main_t * vam)
13612 unformat_input_t *i = vam->input;
13613 vl_api_create_vhost_user_if_t *mp;
13616 u8 file_name_set = 0;
13617 u32 custom_dev_instance = ~0;
13619 u8 use_custom_mac = 0;
13620 u8 disable_mrg_rxbuf = 0;
13621 u8 disable_indirect_desc = 0;
13625 /* Shut up coverity */
13626 clib_memset (hwaddr, 0, sizeof (hwaddr));
13628 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13630 if (unformat (i, "socket %s", &file_name))
13634 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13636 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
13637 use_custom_mac = 1;
13638 else if (unformat (i, "server"))
13640 else if (unformat (i, "disable_mrg_rxbuf"))
13641 disable_mrg_rxbuf = 1;
13642 else if (unformat (i, "disable_indirect_desc"))
13643 disable_indirect_desc = 1;
13644 else if (unformat (i, "tag %s", &tag))
13650 if (file_name_set == 0)
13652 errmsg ("missing socket file name");
13656 if (vec_len (file_name) > 255)
13658 errmsg ("socket file name too long");
13661 vec_add1 (file_name, 0);
13663 M (CREATE_VHOST_USER_IF, mp);
13665 mp->is_server = is_server;
13666 mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
13667 mp->disable_indirect_desc = disable_indirect_desc;
13668 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13669 vec_free (file_name);
13670 if (custom_dev_instance != ~0)
13673 mp->custom_dev_instance = ntohl (custom_dev_instance);
13676 mp->use_custom_mac = use_custom_mac;
13677 clib_memcpy (mp->mac_address, hwaddr, 6);
13679 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
13688 api_modify_vhost_user_if (vat_main_t * vam)
13690 unformat_input_t *i = vam->input;
13691 vl_api_modify_vhost_user_if_t *mp;
13694 u8 file_name_set = 0;
13695 u32 custom_dev_instance = ~0;
13696 u8 sw_if_index_set = 0;
13697 u32 sw_if_index = (u32) ~ 0;
13700 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13702 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13703 sw_if_index_set = 1;
13704 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13705 sw_if_index_set = 1;
13706 else if (unformat (i, "socket %s", &file_name))
13710 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13712 else if (unformat (i, "server"))
13718 if (sw_if_index_set == 0)
13720 errmsg ("missing sw_if_index or interface name");
13724 if (file_name_set == 0)
13726 errmsg ("missing socket file name");
13730 if (vec_len (file_name) > 255)
13732 errmsg ("socket file name too long");
13735 vec_add1 (file_name, 0);
13737 M (MODIFY_VHOST_USER_IF, mp);
13739 mp->sw_if_index = ntohl (sw_if_index);
13740 mp->is_server = is_server;
13741 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13742 vec_free (file_name);
13743 if (custom_dev_instance != ~0)
13746 mp->custom_dev_instance = ntohl (custom_dev_instance);
13755 api_delete_vhost_user_if (vat_main_t * vam)
13757 unformat_input_t *i = vam->input;
13758 vl_api_delete_vhost_user_if_t *mp;
13759 u32 sw_if_index = ~0;
13760 u8 sw_if_index_set = 0;
13763 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13765 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13766 sw_if_index_set = 1;
13767 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13768 sw_if_index_set = 1;
13773 if (sw_if_index_set == 0)
13775 errmsg ("missing sw_if_index or interface name");
13780 M (DELETE_VHOST_USER_IF, mp);
13782 mp->sw_if_index = ntohl (sw_if_index);
13789 static void vl_api_sw_interface_vhost_user_details_t_handler
13790 (vl_api_sw_interface_vhost_user_details_t * mp)
13792 vat_main_t *vam = &vat_main;
13794 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
13795 (char *) mp->interface_name,
13796 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
13797 clib_net_to_host_u64 (mp->features), mp->is_server,
13798 ntohl (mp->num_regions), (char *) mp->sock_filename);
13799 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
13802 static void vl_api_sw_interface_vhost_user_details_t_handler_json
13803 (vl_api_sw_interface_vhost_user_details_t * mp)
13805 vat_main_t *vam = &vat_main;
13806 vat_json_node_t *node = NULL;
13808 if (VAT_JSON_ARRAY != vam->json_tree.type)
13810 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13811 vat_json_init_array (&vam->json_tree);
13813 node = vat_json_array_add (&vam->json_tree);
13815 vat_json_init_object (node);
13816 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13817 vat_json_object_add_string_copy (node, "interface_name",
13818 mp->interface_name);
13819 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
13820 ntohl (mp->virtio_net_hdr_sz));
13821 vat_json_object_add_uint (node, "features",
13822 clib_net_to_host_u64 (mp->features));
13823 vat_json_object_add_uint (node, "is_server", mp->is_server);
13824 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
13825 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
13826 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
13830 api_sw_interface_vhost_user_dump (vat_main_t * vam)
13832 vl_api_sw_interface_vhost_user_dump_t *mp;
13833 vl_api_control_ping_t *mp_ping;
13836 "Interface name idx hdr_sz features server regions filename");
13838 /* Get list of vhost-user interfaces */
13839 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
13842 /* Use a control ping for synchronization */
13843 MPING (CONTROL_PING, mp_ping);
13851 api_show_version (vat_main_t * vam)
13853 vl_api_show_version_t *mp;
13856 M (SHOW_VERSION, mp);
13865 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
13867 unformat_input_t *line_input = vam->input;
13868 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
13869 ip4_address_t local4, remote4;
13870 ip6_address_t local6, remote6;
13872 u8 ipv4_set = 0, ipv6_set = 0;
13876 u32 mcast_sw_if_index = ~0;
13877 u32 encap_vrf_id = 0;
13878 u32 decap_vrf_id = 0;
13884 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
13885 clib_memset (&local4, 0, sizeof local4);
13886 clib_memset (&remote4, 0, sizeof remote4);
13887 clib_memset (&local6, 0, sizeof local6);
13888 clib_memset (&remote6, 0, sizeof remote6);
13890 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13892 if (unformat (line_input, "del"))
13894 else if (unformat (line_input, "local %U",
13895 unformat_ip4_address, &local4))
13900 else if (unformat (line_input, "remote %U",
13901 unformat_ip4_address, &remote4))
13906 else if (unformat (line_input, "local %U",
13907 unformat_ip6_address, &local6))
13912 else if (unformat (line_input, "remote %U",
13913 unformat_ip6_address, &remote6))
13918 else if (unformat (line_input, "group %U %U",
13919 unformat_ip4_address, &remote4,
13920 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13922 grp_set = remote_set = 1;
13925 else if (unformat (line_input, "group %U",
13926 unformat_ip4_address, &remote4))
13928 grp_set = remote_set = 1;
13931 else if (unformat (line_input, "group %U %U",
13932 unformat_ip6_address, &remote6,
13933 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13935 grp_set = remote_set = 1;
13938 else if (unformat (line_input, "group %U",
13939 unformat_ip6_address, &remote6))
13941 grp_set = remote_set = 1;
13945 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13947 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13949 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
13951 else if (unformat (line_input, "vni %d", &vni))
13953 else if (unformat (line_input, "next-ip4"))
13955 else if (unformat (line_input, "next-ip6"))
13957 else if (unformat (line_input, "next-ethernet"))
13959 else if (unformat (line_input, "next-nsh"))
13963 errmsg ("parse error '%U'", format_unformat_error, line_input);
13968 if (local_set == 0)
13970 errmsg ("tunnel local address not specified");
13973 if (remote_set == 0)
13975 errmsg ("tunnel remote address not specified");
13978 if (grp_set && mcast_sw_if_index == ~0)
13980 errmsg ("tunnel nonexistent multicast device");
13983 if (ipv4_set && ipv6_set)
13985 errmsg ("both IPv4 and IPv6 addresses specified");
13991 errmsg ("vni not specified");
13995 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
14000 clib_memcpy (&mp->local, &local6, sizeof (local6));
14001 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
14005 clib_memcpy (&mp->local, &local4, sizeof (local4));
14006 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
14009 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
14010 mp->encap_vrf_id = ntohl (encap_vrf_id);
14011 mp->decap_vrf_id = ntohl (decap_vrf_id);
14012 mp->protocol = protocol;
14013 mp->vni = ntohl (vni);
14014 mp->is_add = is_add;
14015 mp->is_ipv6 = ipv6_set;
14022 static void vl_api_vxlan_gpe_tunnel_details_t_handler
14023 (vl_api_vxlan_gpe_tunnel_details_t * mp)
14025 vat_main_t *vam = &vat_main;
14026 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
14027 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
14029 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
14030 ntohl (mp->sw_if_index),
14031 format_ip46_address, &local, IP46_TYPE_ANY,
14032 format_ip46_address, &remote, IP46_TYPE_ANY,
14033 ntohl (mp->vni), mp->protocol,
14034 ntohl (mp->mcast_sw_if_index),
14035 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
14039 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
14040 (vl_api_vxlan_gpe_tunnel_details_t * mp)
14042 vat_main_t *vam = &vat_main;
14043 vat_json_node_t *node = NULL;
14044 struct in_addr ip4;
14045 struct in6_addr ip6;
14047 if (VAT_JSON_ARRAY != vam->json_tree.type)
14049 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14050 vat_json_init_array (&vam->json_tree);
14052 node = vat_json_array_add (&vam->json_tree);
14054 vat_json_init_object (node);
14055 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14058 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
14059 vat_json_object_add_ip6 (node, "local", ip6);
14060 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
14061 vat_json_object_add_ip6 (node, "remote", ip6);
14065 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
14066 vat_json_object_add_ip4 (node, "local", ip4);
14067 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
14068 vat_json_object_add_ip4 (node, "remote", ip4);
14070 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
14071 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
14072 vat_json_object_add_uint (node, "mcast_sw_if_index",
14073 ntohl (mp->mcast_sw_if_index));
14074 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
14075 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
14076 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
14080 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
14082 unformat_input_t *i = vam->input;
14083 vl_api_vxlan_gpe_tunnel_dump_t *mp;
14084 vl_api_control_ping_t *mp_ping;
14086 u8 sw_if_index_set = 0;
14089 /* Parse args required to build the message */
14090 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14092 if (unformat (i, "sw_if_index %d", &sw_if_index))
14093 sw_if_index_set = 1;
14098 if (sw_if_index_set == 0)
14103 if (!vam->json_output)
14105 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
14106 "sw_if_index", "local", "remote", "vni",
14107 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
14110 /* Get list of vxlan-tunnel interfaces */
14111 M (VXLAN_GPE_TUNNEL_DUMP, mp);
14113 mp->sw_if_index = htonl (sw_if_index);
14117 /* Use a control ping for synchronization */
14118 MPING (CONTROL_PING, mp_ping);
14125 static void vl_api_l2_fib_table_details_t_handler
14126 (vl_api_l2_fib_table_details_t * mp)
14128 vat_main_t *vam = &vat_main;
14130 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
14132 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
14133 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
14137 static void vl_api_l2_fib_table_details_t_handler_json
14138 (vl_api_l2_fib_table_details_t * mp)
14140 vat_main_t *vam = &vat_main;
14141 vat_json_node_t *node = NULL;
14143 if (VAT_JSON_ARRAY != vam->json_tree.type)
14145 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14146 vat_json_init_array (&vam->json_tree);
14148 node = vat_json_array_add (&vam->json_tree);
14150 vat_json_init_object (node);
14151 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
14152 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
14153 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14154 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
14155 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
14156 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
14160 api_l2_fib_table_dump (vat_main_t * vam)
14162 unformat_input_t *i = vam->input;
14163 vl_api_l2_fib_table_dump_t *mp;
14164 vl_api_control_ping_t *mp_ping;
14169 /* Parse args required to build the message */
14170 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14172 if (unformat (i, "bd_id %d", &bd_id))
14178 if (bd_id_set == 0)
14180 errmsg ("missing bridge domain");
14184 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
14186 /* Get list of l2 fib entries */
14187 M (L2_FIB_TABLE_DUMP, mp);
14189 mp->bd_id = ntohl (bd_id);
14192 /* Use a control ping for synchronization */
14193 MPING (CONTROL_PING, mp_ping);
14202 api_interface_name_renumber (vat_main_t * vam)
14204 unformat_input_t *line_input = vam->input;
14205 vl_api_interface_name_renumber_t *mp;
14206 u32 sw_if_index = ~0;
14207 u32 new_show_dev_instance = ~0;
14210 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14212 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
14215 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14217 else if (unformat (line_input, "new_show_dev_instance %d",
14218 &new_show_dev_instance))
14224 if (sw_if_index == ~0)
14226 errmsg ("missing interface name or sw_if_index");
14230 if (new_show_dev_instance == ~0)
14232 errmsg ("missing new_show_dev_instance");
14236 M (INTERFACE_NAME_RENUMBER, mp);
14238 mp->sw_if_index = ntohl (sw_if_index);
14239 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
14247 api_ip_probe_neighbor (vat_main_t * vam)
14249 unformat_input_t *i = vam->input;
14250 vl_api_ip_probe_neighbor_t *mp;
14251 vl_api_address_t dst_adr;
14257 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14259 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14261 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14263 else if (unformat (i, "address %U", unformat_vl_api_address, dst_adr))
14271 errmsg ("missing interface");
14277 errmsg ("missing addresses");
14281 M (IP_PROBE_NEIGHBOR, mp);
14283 mp->sw_if_index = ntohl (sw_if_index);
14284 clib_memcpy (&mp->dst, &dst_adr, sizeof (dst_adr));
14292 api_ip_scan_neighbor_enable_disable (vat_main_t * vam)
14294 unformat_input_t *i = vam->input;
14295 vl_api_ip_scan_neighbor_enable_disable_t *mp;
14296 u8 mode = IP_SCAN_V46_NEIGHBORS;
14297 u32 interval = 0, time = 0, update = 0, delay = 0, stale = 0;
14300 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14302 if (unformat (i, "ip4"))
14303 mode = IP_SCAN_V4_NEIGHBORS;
14304 else if (unformat (i, "ip6"))
14305 mode = IP_SCAN_V6_NEIGHBORS;
14306 if (unformat (i, "both"))
14307 mode = IP_SCAN_V46_NEIGHBORS;
14308 else if (unformat (i, "disable"))
14309 mode = IP_SCAN_DISABLED;
14310 else if (unformat (i, "interval %d", &interval))
14312 else if (unformat (i, "max-time %d", &time))
14314 else if (unformat (i, "max-update %d", &update))
14316 else if (unformat (i, "delay %d", &delay))
14318 else if (unformat (i, "stale %d", &stale))
14324 if (interval > 255)
14326 errmsg ("interval cannot exceed 255 minutes.");
14331 errmsg ("max-time cannot exceed 255 usec.");
14336 errmsg ("max-update cannot exceed 255.");
14341 errmsg ("delay cannot exceed 255 msec.");
14346 errmsg ("stale cannot exceed 255 minutes.");
14350 M (IP_SCAN_NEIGHBOR_ENABLE_DISABLE, mp);
14352 mp->scan_interval = interval;
14353 mp->max_proc_time = time;
14354 mp->max_update = update;
14355 mp->scan_int_delay = delay;
14356 mp->stale_threshold = stale;
14364 api_want_ip4_arp_events (vat_main_t * vam)
14366 unformat_input_t *line_input = vam->input;
14367 vl_api_want_ip4_arp_events_t *mp;
14368 ip4_address_t address;
14369 int address_set = 0;
14370 u32 enable_disable = 1;
14373 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14375 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
14377 else if (unformat (line_input, "del"))
14378 enable_disable = 0;
14383 if (address_set == 0)
14385 errmsg ("missing addresses");
14389 M (WANT_IP4_ARP_EVENTS, mp);
14390 mp->enable_disable = enable_disable;
14391 mp->pid = htonl (getpid ());
14392 clib_memcpy (mp->ip, &address, sizeof (address));
14400 api_want_ip6_nd_events (vat_main_t * vam)
14402 unformat_input_t *line_input = vam->input;
14403 vl_api_want_ip6_nd_events_t *mp;
14404 vl_api_ip6_address_t address;
14405 int address_set = 0;
14406 u32 enable_disable = 1;
14409 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14412 (line_input, "address %U", unformat_vl_api_ip6_address, &address))
14414 else if (unformat (line_input, "del"))
14415 enable_disable = 0;
14420 if (address_set == 0)
14422 errmsg ("missing addresses");
14426 M (WANT_IP6_ND_EVENTS, mp);
14427 mp->enable_disable = enable_disable;
14428 mp->pid = htonl (getpid ());
14429 clib_memcpy (&mp->ip, &address, sizeof (address));
14437 api_want_l2_macs_events (vat_main_t * vam)
14439 unformat_input_t *line_input = vam->input;
14440 vl_api_want_l2_macs_events_t *mp;
14441 u8 enable_disable = 1;
14442 u32 scan_delay = 0;
14443 u32 max_macs_in_event = 0;
14444 u32 learn_limit = 0;
14447 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14449 if (unformat (line_input, "learn-limit %d", &learn_limit))
14451 else if (unformat (line_input, "scan-delay %d", &scan_delay))
14453 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
14455 else if (unformat (line_input, "disable"))
14456 enable_disable = 0;
14461 M (WANT_L2_MACS_EVENTS, mp);
14462 mp->enable_disable = enable_disable;
14463 mp->pid = htonl (getpid ());
14464 mp->learn_limit = htonl (learn_limit);
14465 mp->scan_delay = (u8) scan_delay;
14466 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
14473 api_input_acl_set_interface (vat_main_t * vam)
14475 unformat_input_t *i = vam->input;
14476 vl_api_input_acl_set_interface_t *mp;
14478 int sw_if_index_set;
14479 u32 ip4_table_index = ~0;
14480 u32 ip6_table_index = ~0;
14481 u32 l2_table_index = ~0;
14485 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14487 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14488 sw_if_index_set = 1;
14489 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14490 sw_if_index_set = 1;
14491 else if (unformat (i, "del"))
14493 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14495 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14497 else if (unformat (i, "l2-table %d", &l2_table_index))
14501 clib_warning ("parse error '%U'", format_unformat_error, i);
14506 if (sw_if_index_set == 0)
14508 errmsg ("missing interface name or sw_if_index");
14512 M (INPUT_ACL_SET_INTERFACE, mp);
14514 mp->sw_if_index = ntohl (sw_if_index);
14515 mp->ip4_table_index = ntohl (ip4_table_index);
14516 mp->ip6_table_index = ntohl (ip6_table_index);
14517 mp->l2_table_index = ntohl (l2_table_index);
14518 mp->is_add = is_add;
14526 api_output_acl_set_interface (vat_main_t * vam)
14528 unformat_input_t *i = vam->input;
14529 vl_api_output_acl_set_interface_t *mp;
14531 int sw_if_index_set;
14532 u32 ip4_table_index = ~0;
14533 u32 ip6_table_index = ~0;
14534 u32 l2_table_index = ~0;
14538 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14540 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14541 sw_if_index_set = 1;
14542 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14543 sw_if_index_set = 1;
14544 else if (unformat (i, "del"))
14546 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14548 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14550 else if (unformat (i, "l2-table %d", &l2_table_index))
14554 clib_warning ("parse error '%U'", format_unformat_error, i);
14559 if (sw_if_index_set == 0)
14561 errmsg ("missing interface name or sw_if_index");
14565 M (OUTPUT_ACL_SET_INTERFACE, mp);
14567 mp->sw_if_index = ntohl (sw_if_index);
14568 mp->ip4_table_index = ntohl (ip4_table_index);
14569 mp->ip6_table_index = ntohl (ip6_table_index);
14570 mp->l2_table_index = ntohl (l2_table_index);
14571 mp->is_add = is_add;
14579 api_ip_address_dump (vat_main_t * vam)
14581 unformat_input_t *i = vam->input;
14582 vl_api_ip_address_dump_t *mp;
14583 vl_api_control_ping_t *mp_ping;
14584 u32 sw_if_index = ~0;
14585 u8 sw_if_index_set = 0;
14590 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14592 if (unformat (i, "sw_if_index %d", &sw_if_index))
14593 sw_if_index_set = 1;
14595 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14596 sw_if_index_set = 1;
14597 else if (unformat (i, "ipv4"))
14599 else if (unformat (i, "ipv6"))
14605 if (ipv4_set && ipv6_set)
14607 errmsg ("ipv4 and ipv6 flags cannot be both set");
14611 if ((!ipv4_set) && (!ipv6_set))
14613 errmsg ("no ipv4 nor ipv6 flag set");
14617 if (sw_if_index_set == 0)
14619 errmsg ("missing interface name or sw_if_index");
14623 vam->current_sw_if_index = sw_if_index;
14624 vam->is_ipv6 = ipv6_set;
14626 M (IP_ADDRESS_DUMP, mp);
14627 mp->sw_if_index = ntohl (sw_if_index);
14628 mp->is_ipv6 = ipv6_set;
14631 /* Use a control ping for synchronization */
14632 MPING (CONTROL_PING, mp_ping);
14640 api_ip_dump (vat_main_t * vam)
14642 vl_api_ip_dump_t *mp;
14643 vl_api_control_ping_t *mp_ping;
14644 unformat_input_t *in = vam->input;
14651 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
14653 if (unformat (in, "ipv4"))
14655 else if (unformat (in, "ipv6"))
14661 if (ipv4_set && ipv6_set)
14663 errmsg ("ipv4 and ipv6 flags cannot be both set");
14667 if ((!ipv4_set) && (!ipv6_set))
14669 errmsg ("no ipv4 nor ipv6 flag set");
14673 is_ipv6 = ipv6_set;
14674 vam->is_ipv6 = is_ipv6;
14676 /* free old data */
14677 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
14679 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
14681 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
14684 mp->is_ipv6 = ipv6_set;
14687 /* Use a control ping for synchronization */
14688 MPING (CONTROL_PING, mp_ping);
14696 api_ipsec_spd_add_del (vat_main_t * vam)
14698 unformat_input_t *i = vam->input;
14699 vl_api_ipsec_spd_add_del_t *mp;
14704 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14706 if (unformat (i, "spd_id %d", &spd_id))
14708 else if (unformat (i, "del"))
14712 clib_warning ("parse error '%U'", format_unformat_error, i);
14718 errmsg ("spd_id must be set");
14722 M (IPSEC_SPD_ADD_DEL, mp);
14724 mp->spd_id = ntohl (spd_id);
14725 mp->is_add = is_add;
14733 api_ipsec_interface_add_del_spd (vat_main_t * vam)
14735 unformat_input_t *i = vam->input;
14736 vl_api_ipsec_interface_add_del_spd_t *mp;
14738 u8 sw_if_index_set = 0;
14739 u32 spd_id = (u32) ~ 0;
14743 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14745 if (unformat (i, "del"))
14747 else if (unformat (i, "spd_id %d", &spd_id))
14750 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14751 sw_if_index_set = 1;
14752 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14753 sw_if_index_set = 1;
14756 clib_warning ("parse error '%U'", format_unformat_error, i);
14762 if (spd_id == (u32) ~ 0)
14764 errmsg ("spd_id must be set");
14768 if (sw_if_index_set == 0)
14770 errmsg ("missing interface name or sw_if_index");
14774 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
14776 mp->spd_id = ntohl (spd_id);
14777 mp->sw_if_index = ntohl (sw_if_index);
14778 mp->is_add = is_add;
14786 api_ipsec_spd_entry_add_del (vat_main_t * vam)
14788 unformat_input_t *i = vam->input;
14789 vl_api_ipsec_spd_entry_add_del_t *mp;
14790 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
14791 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
14793 u32 rport_start = 0, rport_stop = (u32) ~ 0;
14794 u32 lport_start = 0, lport_stop = (u32) ~ 0;
14795 vl_api_address_t laddr_start = { }, laddr_stop =
14804 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14806 if (unformat (i, "del"))
14808 if (unformat (i, "outbound"))
14810 if (unformat (i, "inbound"))
14812 else if (unformat (i, "spd_id %d", &spd_id))
14814 else if (unformat (i, "sa_id %d", &sa_id))
14816 else if (unformat (i, "priority %d", &priority))
14818 else if (unformat (i, "protocol %d", &protocol))
14820 else if (unformat (i, "lport_start %d", &lport_start))
14822 else if (unformat (i, "lport_stop %d", &lport_stop))
14824 else if (unformat (i, "rport_start %d", &rport_start))
14826 else if (unformat (i, "rport_stop %d", &rport_stop))
14828 else if (unformat (i, "laddr_start %U",
14829 unformat_vl_api_address, &laddr_start))
14831 else if (unformat (i, "laddr_stop %U", unformat_vl_api_address,
14834 else if (unformat (i, "raddr_start %U", unformat_vl_api_address,
14837 else if (unformat (i, "raddr_stop %U", unformat_vl_api_address,
14841 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
14843 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
14845 clib_warning ("unsupported action: 'resolve'");
14851 clib_warning ("parse error '%U'", format_unformat_error, i);
14857 M (IPSEC_SPD_ENTRY_ADD_DEL, mp);
14859 mp->is_add = is_add;
14861 mp->entry.spd_id = ntohl (spd_id);
14862 mp->entry.priority = ntohl (priority);
14863 mp->entry.is_outbound = is_outbound;
14865 clib_memcpy (&mp->entry.remote_address_start, &raddr_start,
14866 sizeof (vl_api_address_t));
14867 clib_memcpy (&mp->entry.remote_address_stop, &raddr_stop,
14868 sizeof (vl_api_address_t));
14869 clib_memcpy (&mp->entry.local_address_start, &laddr_start,
14870 sizeof (vl_api_address_t));
14871 clib_memcpy (&mp->entry.local_address_stop, &laddr_stop,
14872 sizeof (vl_api_address_t));
14874 mp->entry.protocol = (u8) protocol;
14875 mp->entry.local_port_start = ntohs ((u16) lport_start);
14876 mp->entry.local_port_stop = ntohs ((u16) lport_stop);
14877 mp->entry.remote_port_start = ntohs ((u16) rport_start);
14878 mp->entry.remote_port_stop = ntohs ((u16) rport_stop);
14879 mp->entry.policy = (u8) policy;
14880 mp->entry.sa_id = ntohl (sa_id);
14888 api_ipsec_sad_entry_add_del (vat_main_t * vam)
14890 unformat_input_t *i = vam->input;
14891 vl_api_ipsec_sad_entry_add_del_t *mp;
14892 u32 sad_id = 0, spi = 0;
14893 u8 *ck = 0, *ik = 0;
14896 vl_api_ipsec_crypto_alg_t crypto_alg = IPSEC_API_CRYPTO_ALG_NONE;
14897 vl_api_ipsec_integ_alg_t integ_alg = IPSEC_API_INTEG_ALG_NONE;
14898 vl_api_ipsec_sad_flags_t flags = IPSEC_API_SAD_FLAG_NONE;
14899 vl_api_ipsec_proto_t protocol = IPSEC_API_PROTO_AH;
14900 vl_api_address_t tun_src, tun_dst;
14903 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14905 if (unformat (i, "del"))
14907 else if (unformat (i, "sad_id %d", &sad_id))
14909 else if (unformat (i, "spi %d", &spi))
14911 else if (unformat (i, "esp"))
14912 protocol = IPSEC_API_PROTO_ESP;
14914 if (unformat (i, "tunnel_src %U", unformat_vl_api_address, &tun_src))
14916 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
14917 if (ADDRESS_IP6 == tun_src.af)
14918 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
14921 if (unformat (i, "tunnel_dst %U", unformat_vl_api_address, &tun_dst))
14923 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
14924 if (ADDRESS_IP6 == tun_src.af)
14925 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
14928 if (unformat (i, "crypto_alg %U",
14929 unformat_ipsec_api_crypto_alg, &crypto_alg))
14931 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14933 else if (unformat (i, "integ_alg %U",
14934 unformat_ipsec_api_integ_alg, &integ_alg))
14936 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14940 clib_warning ("parse error '%U'", format_unformat_error, i);
14946 M (IPSEC_SAD_ENTRY_ADD_DEL, mp);
14948 mp->is_add = is_add;
14949 mp->entry.sad_id = ntohl (sad_id);
14950 mp->entry.protocol = protocol;
14951 mp->entry.spi = ntohl (spi);
14952 mp->entry.flags = flags;
14954 mp->entry.crypto_algorithm = crypto_alg;
14955 mp->entry.integrity_algorithm = integ_alg;
14956 mp->entry.crypto_key.length = vec_len (ck);
14957 mp->entry.integrity_key.length = vec_len (ik);
14959 if (mp->entry.crypto_key.length > sizeof (mp->entry.crypto_key.data))
14960 mp->entry.crypto_key.length = sizeof (mp->entry.crypto_key.data);
14962 if (mp->entry.integrity_key.length > sizeof (mp->entry.integrity_key.data))
14963 mp->entry.integrity_key.length = sizeof (mp->entry.integrity_key.data);
14966 clib_memcpy (mp->entry.crypto_key.data, ck, mp->entry.crypto_key.length);
14968 clib_memcpy (mp->entry.integrity_key.data, ik,
14969 mp->entry.integrity_key.length);
14971 if (flags & IPSEC_API_SAD_FLAG_IS_TUNNEL)
14973 clib_memcpy (&mp->entry.tunnel_src, &tun_src,
14974 sizeof (mp->entry.tunnel_src));
14975 clib_memcpy (&mp->entry.tunnel_dst, &tun_dst,
14976 sizeof (mp->entry.tunnel_dst));
14985 api_ipsec_sa_set_key (vat_main_t * vam)
14987 unformat_input_t *i = vam->input;
14988 vl_api_ipsec_sa_set_key_t *mp;
14990 u8 *ck = 0, *ik = 0;
14993 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14995 if (unformat (i, "sa_id %d", &sa_id))
14997 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14999 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
15003 clib_warning ("parse error '%U'", format_unformat_error, i);
15008 M (IPSEC_SA_SET_KEY, mp);
15010 mp->sa_id = ntohl (sa_id);
15011 mp->crypto_key.length = vec_len (ck);
15012 mp->integrity_key.length = vec_len (ik);
15014 if (mp->crypto_key.length > sizeof (mp->crypto_key.data))
15015 mp->crypto_key.length = sizeof (mp->crypto_key.data);
15017 if (mp->integrity_key.length > sizeof (mp->integrity_key.data))
15018 mp->integrity_key.length = sizeof (mp->integrity_key.data);
15021 clib_memcpy (mp->crypto_key.data, ck, mp->crypto_key.length);
15023 clib_memcpy (mp->integrity_key.data, ik, mp->integrity_key.length);
15031 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
15033 unformat_input_t *i = vam->input;
15034 vl_api_ipsec_tunnel_if_add_del_t *mp;
15035 u32 local_spi = 0, remote_spi = 0;
15036 u32 crypto_alg = 0, integ_alg = 0;
15037 u8 *lck = NULL, *rck = NULL;
15038 u8 *lik = NULL, *rik = NULL;
15039 vl_api_address_t local_ip = { 0 };
15040 vl_api_address_t remote_ip = { 0 };
15044 u8 anti_replay = 0;
15050 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15052 if (unformat (i, "del"))
15054 else if (unformat (i, "esn"))
15056 else if (unformat (i, "anti-replay"))
15058 else if (unformat (i, "count %d", &count))
15060 else if (unformat (i, "local_spi %d", &local_spi))
15062 else if (unformat (i, "remote_spi %d", &remote_spi))
15065 if (unformat (i, "local_ip %U", unformat_vl_api_address, &local_ip))
15068 if (unformat (i, "remote_ip %U", unformat_vl_api_address, &remote_ip))
15070 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
15073 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
15075 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
15077 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
15081 (i, "crypto_alg %U", unformat_ipsec_api_crypto_alg, &crypto_alg))
15083 if (crypto_alg >= IPSEC_CRYPTO_N_ALG)
15085 errmsg ("unsupported crypto-alg: '%U'\n",
15086 format_ipsec_crypto_alg, crypto_alg);
15092 (i, "integ_alg %U", unformat_ipsec_api_integ_alg, &integ_alg))
15094 if (integ_alg >= IPSEC_INTEG_N_ALG)
15096 errmsg ("unsupported integ-alg: '%U'\n",
15097 format_ipsec_integ_alg, integ_alg);
15101 else if (unformat (i, "instance %u", &instance))
15105 errmsg ("parse error '%U'\n", format_unformat_error, i);
15112 /* Turn on async mode */
15113 vam->async_mode = 1;
15114 vam->async_errors = 0;
15115 before = vat_time_now (vam);
15118 for (jj = 0; jj < count; jj++)
15120 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
15122 mp->is_add = is_add;
15124 mp->anti_replay = anti_replay;
15127 increment_vl_address (&remote_ip);
15129 clib_memcpy (&mp->local_ip, &local_ip, sizeof (local_ip));
15130 clib_memcpy (&mp->remote_ip, &remote_ip, sizeof (remote_ip));
15132 mp->local_spi = htonl (local_spi + jj);
15133 mp->remote_spi = htonl (remote_spi + jj);
15134 mp->crypto_alg = (u8) crypto_alg;
15136 mp->local_crypto_key_len = 0;
15139 mp->local_crypto_key_len = vec_len (lck);
15140 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
15141 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
15142 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
15145 mp->remote_crypto_key_len = 0;
15148 mp->remote_crypto_key_len = vec_len (rck);
15149 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
15150 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
15151 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
15154 mp->integ_alg = (u8) integ_alg;
15156 mp->local_integ_key_len = 0;
15159 mp->local_integ_key_len = vec_len (lik);
15160 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
15161 mp->local_integ_key_len = sizeof (mp->local_integ_key);
15162 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
15165 mp->remote_integ_key_len = 0;
15168 mp->remote_integ_key_len = vec_len (rik);
15169 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
15170 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
15171 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
15176 mp->renumber = renumber;
15177 mp->show_instance = ntohl (instance);
15182 /* When testing multiple add/del ops, use a control-ping to sync */
15185 vl_api_control_ping_t *mp_ping;
15189 /* Shut off async mode */
15190 vam->async_mode = 0;
15192 MPING (CONTROL_PING, mp_ping);
15195 timeout = vat_time_now (vam) + 1.0;
15196 while (vat_time_now (vam) < timeout)
15197 if (vam->result_ready == 1)
15202 if (vam->retval == -99)
15203 errmsg ("timeout");
15205 if (vam->async_errors > 0)
15207 errmsg ("%d asynchronous errors", vam->async_errors);
15210 vam->async_errors = 0;
15211 after = vat_time_now (vam);
15213 /* slim chance, but we might have eaten SIGTERM on the first iteration */
15217 print (vam->ofp, "%d tunnels in %.6f secs, %.2f tunnels/sec",
15218 count, after - before, count / (after - before));
15222 /* Wait for a reply... */
15231 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
15233 vat_main_t *vam = &vat_main;
15235 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
15236 "crypto_key %U integ_alg %u integ_key %U flags %x "
15237 "tunnel_src_addr %U tunnel_dst_addr %U "
15238 "salt %u seq_outbound %lu last_seq_inbound %lu "
15239 "replay_window %lu\n",
15240 ntohl (mp->entry.sad_id),
15241 ntohl (mp->sw_if_index),
15242 ntohl (mp->entry.spi),
15243 ntohl (mp->entry.protocol),
15244 ntohl (mp->entry.crypto_algorithm),
15245 format_hex_bytes, mp->entry.crypto_key.data,
15246 mp->entry.crypto_key.length, ntohl (mp->entry.integrity_algorithm),
15247 format_hex_bytes, mp->entry.integrity_key.data,
15248 mp->entry.integrity_key.length, ntohl (mp->entry.flags),
15249 format_vl_api_address, &mp->entry.tunnel_src, format_vl_api_address,
15250 &mp->entry.tunnel_dst, ntohl (mp->salt),
15251 clib_net_to_host_u64 (mp->seq_outbound),
15252 clib_net_to_host_u64 (mp->last_seq_inbound),
15253 clib_net_to_host_u64 (mp->replay_window));
15256 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
15257 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
15259 static void vl_api_ipsec_sa_details_t_handler_json
15260 (vl_api_ipsec_sa_details_t * mp)
15262 vat_main_t *vam = &vat_main;
15263 vat_json_node_t *node = NULL;
15264 vl_api_ipsec_sad_flags_t flags;
15266 if (VAT_JSON_ARRAY != vam->json_tree.type)
15268 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15269 vat_json_init_array (&vam->json_tree);
15271 node = vat_json_array_add (&vam->json_tree);
15273 vat_json_init_object (node);
15274 vat_json_object_add_uint (node, "sa_id", ntohl (mp->entry.sad_id));
15275 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
15276 vat_json_object_add_uint (node, "spi", ntohl (mp->entry.spi));
15277 vat_json_object_add_uint (node, "proto", ntohl (mp->entry.protocol));
15278 vat_json_object_add_uint (node, "crypto_alg",
15279 ntohl (mp->entry.crypto_algorithm));
15280 vat_json_object_add_uint (node, "integ_alg",
15281 ntohl (mp->entry.integrity_algorithm));
15282 flags = ntohl (mp->entry.flags);
15283 vat_json_object_add_uint (node, "use_esn",
15284 ! !(flags & IPSEC_API_SAD_FLAG_USE_ESN));
15285 vat_json_object_add_uint (node, "use_anti_replay",
15286 ! !(flags & IPSEC_API_SAD_FLAG_USE_ANTI_REPLAY));
15287 vat_json_object_add_uint (node, "is_tunnel",
15288 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL));
15289 vat_json_object_add_uint (node, "is_tunnel_ip6",
15290 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL_V6));
15291 vat_json_object_add_uint (node, "udp_encap",
15292 ! !(flags & IPSEC_API_SAD_FLAG_UDP_ENCAP));
15293 vat_json_object_add_bytes (node, "crypto_key", mp->entry.crypto_key.data,
15294 mp->entry.crypto_key.length);
15295 vat_json_object_add_bytes (node, "integ_key", mp->entry.integrity_key.data,
15296 mp->entry.integrity_key.length);
15297 vat_json_object_add_address (node, "src", &mp->entry.tunnel_src);
15298 vat_json_object_add_address (node, "dst", &mp->entry.tunnel_dst);
15299 vat_json_object_add_uint (node, "replay_window",
15300 clib_net_to_host_u64 (mp->replay_window));
15304 api_ipsec_sa_dump (vat_main_t * vam)
15306 unformat_input_t *i = vam->input;
15307 vl_api_ipsec_sa_dump_t *mp;
15308 vl_api_control_ping_t *mp_ping;
15312 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15314 if (unformat (i, "sa_id %d", &sa_id))
15318 clib_warning ("parse error '%U'", format_unformat_error, i);
15323 M (IPSEC_SA_DUMP, mp);
15325 mp->sa_id = ntohl (sa_id);
15329 /* Use a control ping for synchronization */
15330 M (CONTROL_PING, mp_ping);
15338 api_ipsec_tunnel_if_set_key (vat_main_t * vam)
15340 unformat_input_t *i = vam->input;
15341 vl_api_ipsec_tunnel_if_set_key_t *mp;
15342 u32 sw_if_index = ~0;
15343 u8 key_type = IPSEC_IF_SET_KEY_TYPE_NONE;
15348 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15350 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15354 (i, "local crypto %U", unformat_ipsec_api_crypto_alg, &alg))
15355 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_CRYPTO;
15358 (i, "remote crypto %U", unformat_ipsec_api_crypto_alg, &alg))
15359 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_CRYPTO;
15362 (i, "local integ %U", unformat_ipsec_api_integ_alg, &alg))
15363 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_INTEG;
15366 (i, "remote integ %U", unformat_ipsec_api_integ_alg, &alg))
15367 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_INTEG;
15368 else if (unformat (i, "%U", unformat_hex_string, &key))
15372 clib_warning ("parse error '%U'", format_unformat_error, i);
15377 if (sw_if_index == ~0)
15379 errmsg ("interface must be specified");
15383 if (key_type == IPSEC_IF_SET_KEY_TYPE_NONE)
15385 errmsg ("key type must be specified");
15391 errmsg ("algorithm must be specified");
15395 if (vec_len (key) == 0)
15397 errmsg ("key must be specified");
15401 M (IPSEC_TUNNEL_IF_SET_KEY, mp);
15403 mp->sw_if_index = htonl (sw_if_index);
15405 mp->key_type = key_type;
15406 mp->key_len = vec_len (key);
15407 clib_memcpy (mp->key, key, vec_len (key));
15416 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
15418 unformat_input_t *i = vam->input;
15419 vl_api_ipsec_tunnel_if_set_sa_t *mp;
15420 u32 sw_if_index = ~0;
15422 u8 is_outbound = (u8) ~ 0;
15425 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15427 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15429 else if (unformat (i, "sa_id %d", &sa_id))
15431 else if (unformat (i, "outbound"))
15433 else if (unformat (i, "inbound"))
15437 clib_warning ("parse error '%U'", format_unformat_error, i);
15442 if (sw_if_index == ~0)
15444 errmsg ("interface must be specified");
15450 errmsg ("SA ID must be specified");
15454 M (IPSEC_TUNNEL_IF_SET_SA, mp);
15456 mp->sw_if_index = htonl (sw_if_index);
15457 mp->sa_id = htonl (sa_id);
15458 mp->is_outbound = is_outbound;
15467 api_get_first_msg_id (vat_main_t * vam)
15469 vl_api_get_first_msg_id_t *mp;
15470 unformat_input_t *i = vam->input;
15475 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15477 if (unformat (i, "client %s", &name))
15485 errmsg ("missing client name");
15488 vec_add1 (name, 0);
15490 if (vec_len (name) > 63)
15492 errmsg ("client name too long");
15496 M (GET_FIRST_MSG_ID, mp);
15497 clib_memcpy (mp->name, name, vec_len (name));
15504 api_cop_interface_enable_disable (vat_main_t * vam)
15506 unformat_input_t *line_input = vam->input;
15507 vl_api_cop_interface_enable_disable_t *mp;
15508 u32 sw_if_index = ~0;
15509 u8 enable_disable = 1;
15512 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15514 if (unformat (line_input, "disable"))
15515 enable_disable = 0;
15516 if (unformat (line_input, "enable"))
15517 enable_disable = 1;
15518 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
15519 vam, &sw_if_index))
15521 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
15527 if (sw_if_index == ~0)
15529 errmsg ("missing interface name or sw_if_index");
15533 /* Construct the API message */
15534 M (COP_INTERFACE_ENABLE_DISABLE, mp);
15535 mp->sw_if_index = ntohl (sw_if_index);
15536 mp->enable_disable = enable_disable;
15540 /* Wait for the reply */
15546 api_cop_whitelist_enable_disable (vat_main_t * vam)
15548 unformat_input_t *line_input = vam->input;
15549 vl_api_cop_whitelist_enable_disable_t *mp;
15550 u32 sw_if_index = ~0;
15551 u8 ip4 = 0, ip6 = 0, default_cop = 0;
15555 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15557 if (unformat (line_input, "ip4"))
15559 else if (unformat (line_input, "ip6"))
15561 else if (unformat (line_input, "default"))
15563 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
15564 vam, &sw_if_index))
15566 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
15568 else if (unformat (line_input, "fib-id %d", &fib_id))
15574 if (sw_if_index == ~0)
15576 errmsg ("missing interface name or sw_if_index");
15580 /* Construct the API message */
15581 M (COP_WHITELIST_ENABLE_DISABLE, mp);
15582 mp->sw_if_index = ntohl (sw_if_index);
15583 mp->fib_id = ntohl (fib_id);
15586 mp->default_cop = default_cop;
15590 /* Wait for the reply */
15596 api_get_node_graph (vat_main_t * vam)
15598 vl_api_get_node_graph_t *mp;
15601 M (GET_NODE_GRAPH, mp);
15605 /* Wait for the reply */
15611 /** Used for parsing LISP eids */
15612 typedef CLIB_PACKED(struct{
15613 u8 addr[16]; /**< eid address */
15614 u32 len; /**< prefix length if IP */
15615 u8 type; /**< type of eid */
15620 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
15622 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
15624 clib_memset (a, 0, sizeof (a[0]));
15626 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
15628 a->type = 0; /* ipv4 type */
15630 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
15632 a->type = 1; /* ipv6 type */
15634 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
15636 a->type = 2; /* mac type */
15638 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
15640 a->type = 3; /* NSH type */
15641 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
15642 nsh->spi = clib_host_to_net_u32 (nsh->spi);
15649 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
15658 lisp_eid_size_vat (u8 type)
15675 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
15677 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
15681 api_one_add_del_locator_set (vat_main_t * vam)
15683 unformat_input_t *input = vam->input;
15684 vl_api_one_add_del_locator_set_t *mp;
15686 u8 *locator_set_name = NULL;
15687 u8 locator_set_name_set = 0;
15688 vl_api_local_locator_t locator, *locators = 0;
15689 u32 sw_if_index, priority, weight;
15693 /* Parse args required to build the message */
15694 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15696 if (unformat (input, "del"))
15700 else if (unformat (input, "locator-set %s", &locator_set_name))
15702 locator_set_name_set = 1;
15704 else if (unformat (input, "sw_if_index %u p %u w %u",
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);
15714 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
15715 &sw_if_index, &priority, &weight))
15717 locator.sw_if_index = htonl (sw_if_index);
15718 locator.priority = priority;
15719 locator.weight = weight;
15720 vec_add1 (locators, locator);
15726 if (locator_set_name_set == 0)
15728 errmsg ("missing locator-set name");
15729 vec_free (locators);
15733 if (vec_len (locator_set_name) > 64)
15735 errmsg ("locator-set name too long");
15736 vec_free (locator_set_name);
15737 vec_free (locators);
15740 vec_add1 (locator_set_name, 0);
15742 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
15744 /* Construct the API message */
15745 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
15747 mp->is_add = is_add;
15748 clib_memcpy (mp->locator_set_name, locator_set_name,
15749 vec_len (locator_set_name));
15750 vec_free (locator_set_name);
15752 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
15754 clib_memcpy (mp->locators, locators, data_len);
15755 vec_free (locators);
15760 /* Wait for a reply... */
15765 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
15768 api_one_add_del_locator (vat_main_t * vam)
15770 unformat_input_t *input = vam->input;
15771 vl_api_one_add_del_locator_t *mp;
15772 u32 tmp_if_index = ~0;
15773 u32 sw_if_index = ~0;
15774 u8 sw_if_index_set = 0;
15775 u8 sw_if_index_if_name_set = 0;
15777 u8 priority_set = 0;
15781 u8 *locator_set_name = NULL;
15782 u8 locator_set_name_set = 0;
15785 /* Parse args required to build the message */
15786 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15788 if (unformat (input, "del"))
15792 else if (unformat (input, "locator-set %s", &locator_set_name))
15794 locator_set_name_set = 1;
15796 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
15799 sw_if_index_if_name_set = 1;
15800 sw_if_index = tmp_if_index;
15802 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
15804 sw_if_index_set = 1;
15805 sw_if_index = tmp_if_index;
15807 else if (unformat (input, "p %d", &priority))
15811 else if (unformat (input, "w %d", &weight))
15819 if (locator_set_name_set == 0)
15821 errmsg ("missing locator-set name");
15825 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
15827 errmsg ("missing sw_if_index");
15828 vec_free (locator_set_name);
15832 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
15834 errmsg ("cannot use both params interface name and sw_if_index");
15835 vec_free (locator_set_name);
15839 if (priority_set == 0)
15841 errmsg ("missing locator-set priority");
15842 vec_free (locator_set_name);
15846 if (weight_set == 0)
15848 errmsg ("missing locator-set weight");
15849 vec_free (locator_set_name);
15853 if (vec_len (locator_set_name) > 64)
15855 errmsg ("locator-set name too long");
15856 vec_free (locator_set_name);
15859 vec_add1 (locator_set_name, 0);
15861 /* Construct the API message */
15862 M (ONE_ADD_DEL_LOCATOR, mp);
15864 mp->is_add = is_add;
15865 mp->sw_if_index = ntohl (sw_if_index);
15866 mp->priority = priority;
15867 mp->weight = weight;
15868 clib_memcpy (mp->locator_set_name, locator_set_name,
15869 vec_len (locator_set_name));
15870 vec_free (locator_set_name);
15875 /* Wait for a reply... */
15880 #define api_lisp_add_del_locator api_one_add_del_locator
15883 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
15885 u32 *key_id = va_arg (*args, u32 *);
15888 if (unformat (input, "%s", &s))
15890 if (!strcmp ((char *) s, "sha1"))
15891 key_id[0] = HMAC_SHA_1_96;
15892 else if (!strcmp ((char *) s, "sha256"))
15893 key_id[0] = HMAC_SHA_256_128;
15896 clib_warning ("invalid key_id: '%s'", s);
15897 key_id[0] = HMAC_NO_KEY;
15908 api_one_add_del_local_eid (vat_main_t * vam)
15910 unformat_input_t *input = vam->input;
15911 vl_api_one_add_del_local_eid_t *mp;
15914 lisp_eid_vat_t _eid, *eid = &_eid;
15915 u8 *locator_set_name = 0;
15916 u8 locator_set_name_set = 0;
15922 /* Parse args required to build the message */
15923 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15925 if (unformat (input, "del"))
15929 else if (unformat (input, "vni %d", &vni))
15933 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
15937 else if (unformat (input, "locator-set %s", &locator_set_name))
15939 locator_set_name_set = 1;
15941 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
15943 else if (unformat (input, "secret-key %_%v%_", &key))
15949 if (locator_set_name_set == 0)
15951 errmsg ("missing locator-set name");
15957 errmsg ("EID address not set!");
15958 vec_free (locator_set_name);
15962 if (key && (0 == key_id))
15964 errmsg ("invalid key_id!");
15968 if (vec_len (key) > 64)
15970 errmsg ("key too long");
15975 if (vec_len (locator_set_name) > 64)
15977 errmsg ("locator-set name too long");
15978 vec_free (locator_set_name);
15981 vec_add1 (locator_set_name, 0);
15983 /* Construct the API message */
15984 M (ONE_ADD_DEL_LOCAL_EID, mp);
15986 mp->is_add = is_add;
15987 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
15988 mp->eid_type = eid->type;
15989 mp->prefix_len = eid->len;
15990 mp->vni = clib_host_to_net_u32 (vni);
15991 mp->key_id = clib_host_to_net_u16 (key_id);
15992 clib_memcpy (mp->locator_set_name, locator_set_name,
15993 vec_len (locator_set_name));
15994 clib_memcpy (mp->key, key, vec_len (key));
15996 vec_free (locator_set_name);
16002 /* Wait for a reply... */
16007 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
16010 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
16012 u32 dp_table = 0, vni = 0;;
16013 unformat_input_t *input = vam->input;
16014 vl_api_gpe_add_del_fwd_entry_t *mp;
16016 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
16017 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
16018 u8 rmt_eid_set = 0, lcl_eid_set = 0;
16019 u32 action = ~0, w;
16020 ip4_address_t rmt_rloc4, lcl_rloc4;
16021 ip6_address_t rmt_rloc6, lcl_rloc6;
16022 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
16025 clib_memset (&rloc, 0, sizeof (rloc));
16027 /* Parse args required to build the message */
16028 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16030 if (unformat (input, "del"))
16032 else if (unformat (input, "add"))
16034 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
16038 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
16042 else if (unformat (input, "vrf %d", &dp_table))
16044 else if (unformat (input, "bd %d", &dp_table))
16046 else if (unformat (input, "vni %d", &vni))
16048 else if (unformat (input, "w %d", &w))
16052 errmsg ("No RLOC configured for setting priority/weight!");
16055 curr_rloc->weight = w;
16057 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
16058 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
16062 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
16064 vec_add1 (lcl_locs, rloc);
16066 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
16067 vec_add1 (rmt_locs, rloc);
16068 /* weight saved in rmt loc */
16069 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
16071 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
16072 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
16075 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
16077 vec_add1 (lcl_locs, rloc);
16079 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
16080 vec_add1 (rmt_locs, rloc);
16081 /* weight saved in rmt loc */
16082 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
16084 else if (unformat (input, "action %d", &action))
16090 clib_warning ("parse error '%U'", format_unformat_error, input);
16097 errmsg ("remote eid addresses not set");
16101 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
16103 errmsg ("eid types don't match");
16107 if (0 == rmt_locs && (u32) ~ 0 == action)
16109 errmsg ("action not set for negative mapping");
16113 /* Construct the API message */
16114 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
16115 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
16117 mp->is_add = is_add;
16118 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
16119 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
16120 mp->eid_type = rmt_eid->type;
16121 mp->dp_table = clib_host_to_net_u32 (dp_table);
16122 mp->vni = clib_host_to_net_u32 (vni);
16123 mp->rmt_len = rmt_eid->len;
16124 mp->lcl_len = lcl_eid->len;
16125 mp->action = action;
16127 if (0 != rmt_locs && 0 != lcl_locs)
16129 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
16130 clib_memcpy (mp->locs, lcl_locs,
16131 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
16133 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
16134 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
16135 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
16137 vec_free (lcl_locs);
16138 vec_free (rmt_locs);
16143 /* Wait for a reply... */
16149 api_one_add_del_map_server (vat_main_t * vam)
16151 unformat_input_t *input = vam->input;
16152 vl_api_one_add_del_map_server_t *mp;
16156 ip4_address_t ipv4;
16157 ip6_address_t ipv6;
16160 /* Parse args required to build the message */
16161 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16163 if (unformat (input, "del"))
16167 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
16171 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
16179 if (ipv4_set && ipv6_set)
16181 errmsg ("both eid v4 and v6 addresses set");
16185 if (!ipv4_set && !ipv6_set)
16187 errmsg ("eid addresses not set");
16191 /* Construct the API message */
16192 M (ONE_ADD_DEL_MAP_SERVER, mp);
16194 mp->is_add = is_add;
16198 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
16203 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
16209 /* Wait for a reply... */
16214 #define api_lisp_add_del_map_server api_one_add_del_map_server
16217 api_one_add_del_map_resolver (vat_main_t * vam)
16219 unformat_input_t *input = vam->input;
16220 vl_api_one_add_del_map_resolver_t *mp;
16224 ip4_address_t ipv4;
16225 ip6_address_t ipv6;
16228 /* Parse args required to build the message */
16229 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16231 if (unformat (input, "del"))
16235 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
16239 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
16247 if (ipv4_set && ipv6_set)
16249 errmsg ("both eid v4 and v6 addresses set");
16253 if (!ipv4_set && !ipv6_set)
16255 errmsg ("eid addresses not set");
16259 /* Construct the API message */
16260 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
16262 mp->is_add = is_add;
16266 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
16271 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
16277 /* Wait for a reply... */
16282 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
16285 api_lisp_gpe_enable_disable (vat_main_t * vam)
16287 unformat_input_t *input = vam->input;
16288 vl_api_gpe_enable_disable_t *mp;
16293 /* Parse args required to build the message */
16294 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16296 if (unformat (input, "enable"))
16301 else if (unformat (input, "disable"))
16312 errmsg ("Value not set");
16316 /* Construct the API message */
16317 M (GPE_ENABLE_DISABLE, mp);
16324 /* Wait for a reply... */
16330 api_one_rloc_probe_enable_disable (vat_main_t * vam)
16332 unformat_input_t *input = vam->input;
16333 vl_api_one_rloc_probe_enable_disable_t *mp;
16338 /* Parse args required to build the message */
16339 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16341 if (unformat (input, "enable"))
16346 else if (unformat (input, "disable"))
16354 errmsg ("Value not set");
16358 /* Construct the API message */
16359 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
16361 mp->is_enabled = is_en;
16366 /* Wait for a reply... */
16371 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
16374 api_one_map_register_enable_disable (vat_main_t * vam)
16376 unformat_input_t *input = vam->input;
16377 vl_api_one_map_register_enable_disable_t *mp;
16382 /* Parse args required to build the message */
16383 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16385 if (unformat (input, "enable"))
16390 else if (unformat (input, "disable"))
16398 errmsg ("Value not set");
16402 /* Construct the API message */
16403 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
16405 mp->is_enabled = is_en;
16410 /* Wait for a reply... */
16415 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
16418 api_one_enable_disable (vat_main_t * vam)
16420 unformat_input_t *input = vam->input;
16421 vl_api_one_enable_disable_t *mp;
16426 /* Parse args required to build the message */
16427 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16429 if (unformat (input, "enable"))
16434 else if (unformat (input, "disable"))
16444 errmsg ("Value not set");
16448 /* Construct the API message */
16449 M (ONE_ENABLE_DISABLE, mp);
16456 /* Wait for a reply... */
16461 #define api_lisp_enable_disable api_one_enable_disable
16464 api_one_enable_disable_xtr_mode (vat_main_t * vam)
16466 unformat_input_t *input = vam->input;
16467 vl_api_one_enable_disable_xtr_mode_t *mp;
16472 /* Parse args required to build the message */
16473 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16475 if (unformat (input, "enable"))
16480 else if (unformat (input, "disable"))
16490 errmsg ("Value not set");
16494 /* Construct the API message */
16495 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
16502 /* Wait for a reply... */
16508 api_one_show_xtr_mode (vat_main_t * vam)
16510 vl_api_one_show_xtr_mode_t *mp;
16513 /* Construct the API message */
16514 M (ONE_SHOW_XTR_MODE, mp);
16519 /* Wait for a reply... */
16525 api_one_enable_disable_pitr_mode (vat_main_t * vam)
16527 unformat_input_t *input = vam->input;
16528 vl_api_one_enable_disable_pitr_mode_t *mp;
16533 /* Parse args required to build the message */
16534 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16536 if (unformat (input, "enable"))
16541 else if (unformat (input, "disable"))
16551 errmsg ("Value not set");
16555 /* Construct the API message */
16556 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
16563 /* Wait for a reply... */
16569 api_one_show_pitr_mode (vat_main_t * vam)
16571 vl_api_one_show_pitr_mode_t *mp;
16574 /* Construct the API message */
16575 M (ONE_SHOW_PITR_MODE, mp);
16580 /* Wait for a reply... */
16586 api_one_enable_disable_petr_mode (vat_main_t * vam)
16588 unformat_input_t *input = vam->input;
16589 vl_api_one_enable_disable_petr_mode_t *mp;
16594 /* Parse args required to build the message */
16595 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16597 if (unformat (input, "enable"))
16602 else if (unformat (input, "disable"))
16612 errmsg ("Value not set");
16616 /* Construct the API message */
16617 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
16624 /* Wait for a reply... */
16630 api_one_show_petr_mode (vat_main_t * vam)
16632 vl_api_one_show_petr_mode_t *mp;
16635 /* Construct the API message */
16636 M (ONE_SHOW_PETR_MODE, mp);
16641 /* Wait for a reply... */
16647 api_show_one_map_register_state (vat_main_t * vam)
16649 vl_api_show_one_map_register_state_t *mp;
16652 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
16657 /* wait for reply */
16662 #define api_show_lisp_map_register_state api_show_one_map_register_state
16665 api_show_one_rloc_probe_state (vat_main_t * vam)
16667 vl_api_show_one_rloc_probe_state_t *mp;
16670 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
16675 /* wait for reply */
16680 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
16683 api_one_add_del_ndp_entry (vat_main_t * vam)
16685 vl_api_one_add_del_ndp_entry_t *mp;
16686 unformat_input_t *input = vam->input;
16691 u8 mac[6] = { 0, };
16692 u8 ip6[16] = { 0, };
16696 /* Parse args required to build the message */
16697 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16699 if (unformat (input, "del"))
16701 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
16703 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
16705 else if (unformat (input, "bd %d", &bd))
16709 errmsg ("parse error '%U'", format_unformat_error, input);
16714 if (!bd_set || !ip_set || (!mac_set && is_add))
16716 errmsg ("Missing BD, IP or MAC!");
16720 M (ONE_ADD_DEL_NDP_ENTRY, mp);
16721 mp->is_add = is_add;
16722 clib_memcpy (mp->mac, mac, 6);
16723 mp->bd = clib_host_to_net_u32 (bd);
16724 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
16729 /* wait for reply */
16735 api_one_add_del_l2_arp_entry (vat_main_t * vam)
16737 vl_api_one_add_del_l2_arp_entry_t *mp;
16738 unformat_input_t *input = vam->input;
16743 u8 mac[6] = { 0, };
16744 u32 ip4 = 0, bd = ~0;
16747 /* Parse args required to build the message */
16748 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16750 if (unformat (input, "del"))
16752 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
16754 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
16756 else if (unformat (input, "bd %d", &bd))
16760 errmsg ("parse error '%U'", format_unformat_error, input);
16765 if (!bd_set || !ip_set || (!mac_set && is_add))
16767 errmsg ("Missing BD, IP or MAC!");
16771 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
16772 mp->is_add = is_add;
16773 clib_memcpy (mp->mac, mac, 6);
16774 mp->bd = clib_host_to_net_u32 (bd);
16780 /* wait for reply */
16786 api_one_ndp_bd_get (vat_main_t * vam)
16788 vl_api_one_ndp_bd_get_t *mp;
16791 M (ONE_NDP_BD_GET, mp);
16796 /* wait for reply */
16802 api_one_ndp_entries_get (vat_main_t * vam)
16804 vl_api_one_ndp_entries_get_t *mp;
16805 unformat_input_t *input = vam->input;
16810 /* Parse args required to build the message */
16811 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16813 if (unformat (input, "bd %d", &bd))
16817 errmsg ("parse error '%U'", format_unformat_error, input);
16824 errmsg ("Expected bridge domain!");
16828 M (ONE_NDP_ENTRIES_GET, mp);
16829 mp->bd = clib_host_to_net_u32 (bd);
16834 /* wait for reply */
16840 api_one_l2_arp_bd_get (vat_main_t * vam)
16842 vl_api_one_l2_arp_bd_get_t *mp;
16845 M (ONE_L2_ARP_BD_GET, mp);
16850 /* wait for reply */
16856 api_one_l2_arp_entries_get (vat_main_t * vam)
16858 vl_api_one_l2_arp_entries_get_t *mp;
16859 unformat_input_t *input = vam->input;
16864 /* Parse args required to build the message */
16865 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16867 if (unformat (input, "bd %d", &bd))
16871 errmsg ("parse error '%U'", format_unformat_error, input);
16878 errmsg ("Expected bridge domain!");
16882 M (ONE_L2_ARP_ENTRIES_GET, mp);
16883 mp->bd = clib_host_to_net_u32 (bd);
16888 /* wait for reply */
16894 api_one_stats_enable_disable (vat_main_t * vam)
16896 vl_api_one_stats_enable_disable_t *mp;
16897 unformat_input_t *input = vam->input;
16902 /* Parse args required to build the message */
16903 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16905 if (unformat (input, "enable"))
16910 else if (unformat (input, "disable"))
16920 errmsg ("Value not set");
16924 M (ONE_STATS_ENABLE_DISABLE, mp);
16930 /* wait for reply */
16936 api_show_one_stats_enable_disable (vat_main_t * vam)
16938 vl_api_show_one_stats_enable_disable_t *mp;
16941 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
16946 /* wait for reply */
16952 api_show_one_map_request_mode (vat_main_t * vam)
16954 vl_api_show_one_map_request_mode_t *mp;
16957 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
16962 /* wait for reply */
16967 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
16970 api_one_map_request_mode (vat_main_t * vam)
16972 unformat_input_t *input = vam->input;
16973 vl_api_one_map_request_mode_t *mp;
16977 /* Parse args required to build the message */
16978 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16980 if (unformat (input, "dst-only"))
16982 else if (unformat (input, "src-dst"))
16986 errmsg ("parse error '%U'", format_unformat_error, input);
16991 M (ONE_MAP_REQUEST_MODE, mp);
16998 /* wait for reply */
17003 #define api_lisp_map_request_mode api_one_map_request_mode
17006 * Enable/disable ONE proxy ITR.
17008 * @param vam vpp API test context
17009 * @return return code
17012 api_one_pitr_set_locator_set (vat_main_t * vam)
17014 u8 ls_name_set = 0;
17015 unformat_input_t *input = vam->input;
17016 vl_api_one_pitr_set_locator_set_t *mp;
17021 /* Parse args required to build the message */
17022 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17024 if (unformat (input, "del"))
17026 else if (unformat (input, "locator-set %s", &ls_name))
17030 errmsg ("parse error '%U'", format_unformat_error, input);
17037 errmsg ("locator-set name not set!");
17041 M (ONE_PITR_SET_LOCATOR_SET, mp);
17043 mp->is_add = is_add;
17044 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
17045 vec_free (ls_name);
17050 /* wait for reply */
17055 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
17058 api_one_nsh_set_locator_set (vat_main_t * vam)
17060 u8 ls_name_set = 0;
17061 unformat_input_t *input = vam->input;
17062 vl_api_one_nsh_set_locator_set_t *mp;
17067 /* Parse args required to build the message */
17068 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17070 if (unformat (input, "del"))
17072 else if (unformat (input, "ls %s", &ls_name))
17076 errmsg ("parse error '%U'", format_unformat_error, input);
17081 if (!ls_name_set && is_add)
17083 errmsg ("locator-set name not set!");
17087 M (ONE_NSH_SET_LOCATOR_SET, mp);
17089 mp->is_add = is_add;
17090 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
17091 vec_free (ls_name);
17096 /* wait for reply */
17102 api_show_one_pitr (vat_main_t * vam)
17104 vl_api_show_one_pitr_t *mp;
17107 if (!vam->json_output)
17109 print (vam->ofp, "%=20s", "lisp status:");
17112 M (SHOW_ONE_PITR, mp);
17116 /* Wait for a reply... */
17121 #define api_show_lisp_pitr api_show_one_pitr
17124 api_one_use_petr (vat_main_t * vam)
17126 unformat_input_t *input = vam->input;
17127 vl_api_one_use_petr_t *mp;
17132 clib_memset (&ip, 0, sizeof (ip));
17134 /* Parse args required to build the message */
17135 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17137 if (unformat (input, "disable"))
17140 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
17143 ip_addr_version (&ip) = IP4;
17146 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
17149 ip_addr_version (&ip) = IP6;
17153 errmsg ("parse error '%U'", format_unformat_error, input);
17158 M (ONE_USE_PETR, mp);
17160 mp->is_add = is_add;
17163 mp->is_ip4 = ip_addr_version (&ip) == IP4 ? 1 : 0;
17165 clib_memcpy (mp->address, &ip, 4);
17167 clib_memcpy (mp->address, &ip, 16);
17173 /* wait for reply */
17178 #define api_lisp_use_petr api_one_use_petr
17181 api_show_one_nsh_mapping (vat_main_t * vam)
17183 vl_api_show_one_use_petr_t *mp;
17186 if (!vam->json_output)
17188 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
17191 M (SHOW_ONE_NSH_MAPPING, mp);
17195 /* Wait for a reply... */
17201 api_show_one_use_petr (vat_main_t * vam)
17203 vl_api_show_one_use_petr_t *mp;
17206 if (!vam->json_output)
17208 print (vam->ofp, "%=20s", "Proxy-ETR status:");
17211 M (SHOW_ONE_USE_PETR, mp);
17215 /* Wait for a reply... */
17220 #define api_show_lisp_use_petr api_show_one_use_petr
17223 * Add/delete mapping between vni and vrf
17226 api_one_eid_table_add_del_map (vat_main_t * vam)
17228 unformat_input_t *input = vam->input;
17229 vl_api_one_eid_table_add_del_map_t *mp;
17230 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
17231 u32 vni, vrf, bd_index;
17234 /* Parse args required to build the message */
17235 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17237 if (unformat (input, "del"))
17239 else if (unformat (input, "vrf %d", &vrf))
17241 else if (unformat (input, "bd_index %d", &bd_index))
17243 else if (unformat (input, "vni %d", &vni))
17249 if (!vni_set || (!vrf_set && !bd_index_set))
17251 errmsg ("missing arguments!");
17255 if (vrf_set && bd_index_set)
17257 errmsg ("error: both vrf and bd entered!");
17261 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
17263 mp->is_add = is_add;
17264 mp->vni = htonl (vni);
17265 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
17266 mp->is_l2 = bd_index_set;
17271 /* wait for reply */
17276 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
17279 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
17281 u32 *action = va_arg (*args, u32 *);
17284 if (unformat (input, "%s", &s))
17286 if (!strcmp ((char *) s, "no-action"))
17288 else if (!strcmp ((char *) s, "natively-forward"))
17290 else if (!strcmp ((char *) s, "send-map-request"))
17292 else if (!strcmp ((char *) s, "drop"))
17296 clib_warning ("invalid action: '%s'", s);
17308 * Add/del remote mapping to/from ONE control plane
17310 * @param vam vpp API test context
17311 * @return return code
17314 api_one_add_del_remote_mapping (vat_main_t * vam)
17316 unformat_input_t *input = vam->input;
17317 vl_api_one_add_del_remote_mapping_t *mp;
17319 lisp_eid_vat_t _eid, *eid = &_eid;
17320 lisp_eid_vat_t _seid, *seid = &_seid;
17321 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
17322 u32 action = ~0, p, w, data_len;
17323 ip4_address_t rloc4;
17324 ip6_address_t rloc6;
17325 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
17328 clib_memset (&rloc, 0, sizeof (rloc));
17330 /* Parse args required to build the message */
17331 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17333 if (unformat (input, "del-all"))
17337 else if (unformat (input, "del"))
17341 else if (unformat (input, "add"))
17345 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
17349 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
17353 else if (unformat (input, "vni %d", &vni))
17357 else if (unformat (input, "p %d w %d", &p, &w))
17361 errmsg ("No RLOC configured for setting priority/weight!");
17364 curr_rloc->priority = p;
17365 curr_rloc->weight = w;
17367 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
17370 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
17371 vec_add1 (rlocs, rloc);
17372 curr_rloc = &rlocs[vec_len (rlocs) - 1];
17374 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
17377 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
17378 vec_add1 (rlocs, rloc);
17379 curr_rloc = &rlocs[vec_len (rlocs) - 1];
17381 else if (unformat (input, "action %U",
17382 unformat_negative_mapping_action, &action))
17388 clib_warning ("parse error '%U'", format_unformat_error, input);
17395 errmsg ("missing params!");
17399 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
17401 errmsg ("no action set for negative map-reply!");
17405 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
17407 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
17408 mp->is_add = is_add;
17409 mp->vni = htonl (vni);
17410 mp->action = (u8) action;
17411 mp->is_src_dst = seid_set;
17412 mp->eid_len = eid->len;
17413 mp->seid_len = seid->len;
17414 mp->del_all = del_all;
17415 mp->eid_type = eid->type;
17416 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
17417 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
17419 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
17420 clib_memcpy (mp->rlocs, rlocs, data_len);
17426 /* Wait for a reply... */
17431 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
17434 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
17435 * forwarding entries in data-plane accordingly.
17437 * @param vam vpp API test context
17438 * @return return code
17441 api_one_add_del_adjacency (vat_main_t * vam)
17443 unformat_input_t *input = vam->input;
17444 vl_api_one_add_del_adjacency_t *mp;
17446 ip4_address_t leid4, reid4;
17447 ip6_address_t leid6, reid6;
17448 u8 reid_mac[6] = { 0 };
17449 u8 leid_mac[6] = { 0 };
17450 u8 reid_type, leid_type;
17451 u32 leid_len = 0, reid_len = 0, len;
17455 leid_type = reid_type = (u8) ~ 0;
17457 /* Parse args required to build the message */
17458 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17460 if (unformat (input, "del"))
17464 else if (unformat (input, "add"))
17468 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
17471 reid_type = 0; /* ipv4 */
17474 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
17477 reid_type = 1; /* ipv6 */
17480 else if (unformat (input, "reid %U", unformat_ethernet_address,
17483 reid_type = 2; /* mac */
17485 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
17488 leid_type = 0; /* ipv4 */
17491 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
17494 leid_type = 1; /* ipv6 */
17497 else if (unformat (input, "leid %U", unformat_ethernet_address,
17500 leid_type = 2; /* mac */
17502 else if (unformat (input, "vni %d", &vni))
17508 errmsg ("parse error '%U'", format_unformat_error, input);
17513 if ((u8) ~ 0 == reid_type)
17515 errmsg ("missing params!");
17519 if (leid_type != reid_type)
17521 errmsg ("remote and local EIDs are of different types!");
17525 M (ONE_ADD_DEL_ADJACENCY, mp);
17526 mp->is_add = is_add;
17527 mp->vni = htonl (vni);
17528 mp->leid_len = leid_len;
17529 mp->reid_len = reid_len;
17530 mp->eid_type = reid_type;
17532 switch (mp->eid_type)
17535 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
17536 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
17539 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
17540 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
17543 clib_memcpy (mp->leid, leid_mac, 6);
17544 clib_memcpy (mp->reid, reid_mac, 6);
17547 errmsg ("unknown EID type %d!", mp->eid_type);
17554 /* Wait for a reply... */
17559 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
17562 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
17564 u32 *mode = va_arg (*args, u32 *);
17566 if (unformat (input, "lisp"))
17568 else if (unformat (input, "vxlan"))
17577 api_gpe_get_encap_mode (vat_main_t * vam)
17579 vl_api_gpe_get_encap_mode_t *mp;
17582 /* Construct the API message */
17583 M (GPE_GET_ENCAP_MODE, mp);
17588 /* Wait for a reply... */
17594 api_gpe_set_encap_mode (vat_main_t * vam)
17596 unformat_input_t *input = vam->input;
17597 vl_api_gpe_set_encap_mode_t *mp;
17601 /* Parse args required to build the message */
17602 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17604 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
17610 /* Construct the API message */
17611 M (GPE_SET_ENCAP_MODE, mp);
17618 /* Wait for a reply... */
17624 api_lisp_gpe_add_del_iface (vat_main_t * vam)
17626 unformat_input_t *input = vam->input;
17627 vl_api_gpe_add_del_iface_t *mp;
17628 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
17629 u32 dp_table = 0, vni = 0;
17632 /* Parse args required to build the message */
17633 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17635 if (unformat (input, "up"))
17640 else if (unformat (input, "down"))
17645 else if (unformat (input, "table_id %d", &dp_table))
17649 else if (unformat (input, "bd_id %d", &dp_table))
17654 else if (unformat (input, "vni %d", &vni))
17662 if (action_set == 0)
17664 errmsg ("Action not set");
17667 if (dp_table_set == 0 || vni_set == 0)
17669 errmsg ("vni and dp_table must be set");
17673 /* Construct the API message */
17674 M (GPE_ADD_DEL_IFACE, mp);
17676 mp->is_add = is_add;
17677 mp->dp_table = clib_host_to_net_u32 (dp_table);
17679 mp->vni = clib_host_to_net_u32 (vni);
17684 /* Wait for a reply... */
17690 api_one_map_register_fallback_threshold (vat_main_t * vam)
17692 unformat_input_t *input = vam->input;
17693 vl_api_one_map_register_fallback_threshold_t *mp;
17698 /* Parse args required to build the message */
17699 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17701 if (unformat (input, "%u", &value))
17705 clib_warning ("parse error '%U'", format_unformat_error, input);
17712 errmsg ("fallback threshold value is missing!");
17716 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
17717 mp->value = clib_host_to_net_u32 (value);
17722 /* Wait for a reply... */
17728 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
17730 vl_api_show_one_map_register_fallback_threshold_t *mp;
17733 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
17738 /* Wait for a reply... */
17744 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
17746 u32 *proto = va_arg (*args, u32 *);
17748 if (unformat (input, "udp"))
17750 else if (unformat (input, "api"))
17759 api_one_set_transport_protocol (vat_main_t * vam)
17761 unformat_input_t *input = vam->input;
17762 vl_api_one_set_transport_protocol_t *mp;
17767 /* Parse args required to build the message */
17768 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17770 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
17774 clib_warning ("parse error '%U'", format_unformat_error, input);
17781 errmsg ("Transport protocol missing!");
17785 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
17786 mp->protocol = (u8) protocol;
17791 /* Wait for a reply... */
17797 api_one_get_transport_protocol (vat_main_t * vam)
17799 vl_api_one_get_transport_protocol_t *mp;
17802 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
17807 /* Wait for a reply... */
17813 api_one_map_register_set_ttl (vat_main_t * vam)
17815 unformat_input_t *input = vam->input;
17816 vl_api_one_map_register_set_ttl_t *mp;
17821 /* Parse args required to build the message */
17822 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17824 if (unformat (input, "%u", &ttl))
17828 clib_warning ("parse error '%U'", format_unformat_error, input);
17835 errmsg ("TTL value missing!");
17839 M (ONE_MAP_REGISTER_SET_TTL, mp);
17840 mp->ttl = clib_host_to_net_u32 (ttl);
17845 /* Wait for a reply... */
17851 api_show_one_map_register_ttl (vat_main_t * vam)
17853 vl_api_show_one_map_register_ttl_t *mp;
17856 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
17861 /* Wait for a reply... */
17867 * Add/del map request itr rlocs from ONE control plane and updates
17869 * @param vam vpp API test context
17870 * @return return code
17873 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
17875 unformat_input_t *input = vam->input;
17876 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
17877 u8 *locator_set_name = 0;
17878 u8 locator_set_name_set = 0;
17882 /* Parse args required to build the message */
17883 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17885 if (unformat (input, "del"))
17889 else if (unformat (input, "%_%v%_", &locator_set_name))
17891 locator_set_name_set = 1;
17895 clib_warning ("parse error '%U'", format_unformat_error, input);
17900 if (is_add && !locator_set_name_set)
17902 errmsg ("itr-rloc is not set!");
17906 if (is_add && vec_len (locator_set_name) > 64)
17908 errmsg ("itr-rloc locator-set name too long");
17909 vec_free (locator_set_name);
17913 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
17914 mp->is_add = is_add;
17917 clib_memcpy (mp->locator_set_name, locator_set_name,
17918 vec_len (locator_set_name));
17922 clib_memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
17924 vec_free (locator_set_name);
17929 /* Wait for a reply... */
17934 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
17937 api_one_locator_dump (vat_main_t * vam)
17939 unformat_input_t *input = vam->input;
17940 vl_api_one_locator_dump_t *mp;
17941 vl_api_control_ping_t *mp_ping;
17942 u8 is_index_set = 0, is_name_set = 0;
17947 /* Parse args required to build the message */
17948 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17950 if (unformat (input, "ls_name %_%v%_", &ls_name))
17954 else if (unformat (input, "ls_index %d", &ls_index))
17960 errmsg ("parse error '%U'", format_unformat_error, input);
17965 if (!is_index_set && !is_name_set)
17967 errmsg ("error: expected one of index or name!");
17971 if (is_index_set && is_name_set)
17973 errmsg ("error: only one param expected!");
17977 if (vec_len (ls_name) > 62)
17979 errmsg ("error: locator set name too long!");
17983 if (!vam->json_output)
17985 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
17988 M (ONE_LOCATOR_DUMP, mp);
17989 mp->is_index_set = is_index_set;
17992 mp->ls_index = clib_host_to_net_u32 (ls_index);
17995 vec_add1 (ls_name, 0);
17996 strncpy ((char *) mp->ls_name, (char *) ls_name,
17997 sizeof (mp->ls_name) - 1);
18003 /* Use a control ping for synchronization */
18004 MPING (CONTROL_PING, mp_ping);
18007 /* Wait for a reply... */
18012 #define api_lisp_locator_dump api_one_locator_dump
18015 api_one_locator_set_dump (vat_main_t * vam)
18017 vl_api_one_locator_set_dump_t *mp;
18018 vl_api_control_ping_t *mp_ping;
18019 unformat_input_t *input = vam->input;
18023 /* Parse args required to build the message */
18024 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18026 if (unformat (input, "local"))
18030 else if (unformat (input, "remote"))
18036 errmsg ("parse error '%U'", format_unformat_error, input);
18041 if (!vam->json_output)
18043 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
18046 M (ONE_LOCATOR_SET_DUMP, mp);
18048 mp->filter = filter;
18053 /* Use a control ping for synchronization */
18054 MPING (CONTROL_PING, mp_ping);
18057 /* Wait for a reply... */
18062 #define api_lisp_locator_set_dump api_one_locator_set_dump
18065 api_one_eid_table_map_dump (vat_main_t * vam)
18069 unformat_input_t *input = vam->input;
18070 vl_api_one_eid_table_map_dump_t *mp;
18071 vl_api_control_ping_t *mp_ping;
18074 /* Parse args required to build the message */
18075 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18077 if (unformat (input, "l2"))
18082 else if (unformat (input, "l3"))
18089 errmsg ("parse error '%U'", format_unformat_error, input);
18096 errmsg ("expected one of 'l2' or 'l3' parameter!");
18100 if (!vam->json_output)
18102 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
18105 M (ONE_EID_TABLE_MAP_DUMP, mp);
18111 /* Use a control ping for synchronization */
18112 MPING (CONTROL_PING, mp_ping);
18115 /* Wait for a reply... */
18120 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
18123 api_one_eid_table_vni_dump (vat_main_t * vam)
18125 vl_api_one_eid_table_vni_dump_t *mp;
18126 vl_api_control_ping_t *mp_ping;
18129 if (!vam->json_output)
18131 print (vam->ofp, "VNI");
18134 M (ONE_EID_TABLE_VNI_DUMP, mp);
18139 /* Use a control ping for synchronization */
18140 MPING (CONTROL_PING, mp_ping);
18143 /* Wait for a reply... */
18148 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
18151 api_one_eid_table_dump (vat_main_t * vam)
18153 unformat_input_t *i = vam->input;
18154 vl_api_one_eid_table_dump_t *mp;
18155 vl_api_control_ping_t *mp_ping;
18156 struct in_addr ip4;
18157 struct in6_addr ip6;
18159 u8 eid_type = ~0, eid_set = 0;
18160 u32 prefix_length = ~0, t, vni = 0;
18163 lisp_nsh_api_t nsh;
18165 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18167 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
18173 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
18179 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
18184 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
18189 else if (unformat (i, "vni %d", &t))
18193 else if (unformat (i, "local"))
18197 else if (unformat (i, "remote"))
18203 errmsg ("parse error '%U'", format_unformat_error, i);
18208 if (!vam->json_output)
18210 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
18211 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
18214 M (ONE_EID_TABLE_DUMP, mp);
18216 mp->filter = filter;
18220 mp->vni = htonl (vni);
18221 mp->eid_type = eid_type;
18225 mp->prefix_length = prefix_length;
18226 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
18229 mp->prefix_length = prefix_length;
18230 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
18233 clib_memcpy (mp->eid, mac, sizeof (mac));
18236 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
18239 errmsg ("unknown EID type %d!", eid_type);
18247 /* Use a control ping for synchronization */
18248 MPING (CONTROL_PING, mp_ping);
18251 /* Wait for a reply... */
18256 #define api_lisp_eid_table_dump api_one_eid_table_dump
18259 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
18261 unformat_input_t *i = vam->input;
18262 vl_api_gpe_fwd_entries_get_t *mp;
18267 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18269 if (unformat (i, "vni %d", &vni))
18275 errmsg ("parse error '%U'", format_unformat_error, i);
18282 errmsg ("vni not set!");
18286 if (!vam->json_output)
18288 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
18292 M (GPE_FWD_ENTRIES_GET, mp);
18293 mp->vni = clib_host_to_net_u32 (vni);
18298 /* Wait for a reply... */
18303 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
18304 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
18305 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
18306 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
18307 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
18308 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
18309 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
18310 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
18313 api_one_adjacencies_get (vat_main_t * vam)
18315 unformat_input_t *i = vam->input;
18316 vl_api_one_adjacencies_get_t *mp;
18321 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18323 if (unformat (i, "vni %d", &vni))
18329 errmsg ("parse error '%U'", format_unformat_error, i);
18336 errmsg ("vni not set!");
18340 if (!vam->json_output)
18342 print (vam->ofp, "%s %40s", "leid", "reid");
18345 M (ONE_ADJACENCIES_GET, mp);
18346 mp->vni = clib_host_to_net_u32 (vni);
18351 /* Wait for a reply... */
18356 #define api_lisp_adjacencies_get api_one_adjacencies_get
18359 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
18361 unformat_input_t *i = vam->input;
18362 vl_api_gpe_native_fwd_rpaths_get_t *mp;
18364 u8 ip_family_set = 0, is_ip4 = 1;
18366 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18368 if (unformat (i, "ip4"))
18373 else if (unformat (i, "ip6"))
18380 errmsg ("parse error '%U'", format_unformat_error, i);
18385 if (!ip_family_set)
18387 errmsg ("ip family not set!");
18391 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
18392 mp->is_ip4 = is_ip4;
18397 /* Wait for a reply... */
18403 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
18405 vl_api_gpe_fwd_entry_vnis_get_t *mp;
18408 if (!vam->json_output)
18410 print (vam->ofp, "VNIs");
18413 M (GPE_FWD_ENTRY_VNIS_GET, mp);
18418 /* Wait for a reply... */
18424 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
18426 unformat_input_t *i = vam->input;
18427 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
18429 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
18430 struct in_addr ip4;
18431 struct in6_addr ip6;
18432 u32 table_id = 0, nh_sw_if_index = ~0;
18434 clib_memset (&ip4, 0, sizeof (ip4));
18435 clib_memset (&ip6, 0, sizeof (ip6));
18437 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18439 if (unformat (i, "del"))
18441 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
18442 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18447 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
18448 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18453 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
18457 nh_sw_if_index = ~0;
18459 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
18463 nh_sw_if_index = ~0;
18465 else if (unformat (i, "table %d", &table_id))
18469 errmsg ("parse error '%U'", format_unformat_error, i);
18476 errmsg ("nh addr not set!");
18480 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
18481 mp->is_add = is_add;
18482 mp->table_id = clib_host_to_net_u32 (table_id);
18483 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
18484 mp->is_ip4 = is_ip4;
18486 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
18488 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
18493 /* Wait for a reply... */
18499 api_one_map_server_dump (vat_main_t * vam)
18501 vl_api_one_map_server_dump_t *mp;
18502 vl_api_control_ping_t *mp_ping;
18505 if (!vam->json_output)
18507 print (vam->ofp, "%=20s", "Map server");
18510 M (ONE_MAP_SERVER_DUMP, mp);
18514 /* Use a control ping for synchronization */
18515 MPING (CONTROL_PING, mp_ping);
18518 /* Wait for a reply... */
18523 #define api_lisp_map_server_dump api_one_map_server_dump
18526 api_one_map_resolver_dump (vat_main_t * vam)
18528 vl_api_one_map_resolver_dump_t *mp;
18529 vl_api_control_ping_t *mp_ping;
18532 if (!vam->json_output)
18534 print (vam->ofp, "%=20s", "Map resolver");
18537 M (ONE_MAP_RESOLVER_DUMP, mp);
18541 /* Use a control ping for synchronization */
18542 MPING (CONTROL_PING, mp_ping);
18545 /* Wait for a reply... */
18550 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
18553 api_one_stats_flush (vat_main_t * vam)
18555 vl_api_one_stats_flush_t *mp;
18558 M (ONE_STATS_FLUSH, mp);
18565 api_one_stats_dump (vat_main_t * vam)
18567 vl_api_one_stats_dump_t *mp;
18568 vl_api_control_ping_t *mp_ping;
18571 M (ONE_STATS_DUMP, mp);
18575 /* Use a control ping for synchronization */
18576 MPING (CONTROL_PING, mp_ping);
18579 /* Wait for a reply... */
18585 api_show_one_status (vat_main_t * vam)
18587 vl_api_show_one_status_t *mp;
18590 if (!vam->json_output)
18592 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
18595 M (SHOW_ONE_STATUS, mp);
18598 /* Wait for a reply... */
18603 #define api_show_lisp_status api_show_one_status
18606 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
18608 vl_api_gpe_fwd_entry_path_dump_t *mp;
18609 vl_api_control_ping_t *mp_ping;
18610 unformat_input_t *i = vam->input;
18611 u32 fwd_entry_index = ~0;
18614 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18616 if (unformat (i, "index %d", &fwd_entry_index))
18622 if (~0 == fwd_entry_index)
18624 errmsg ("no index specified!");
18628 if (!vam->json_output)
18630 print (vam->ofp, "first line");
18633 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
18637 /* Use a control ping for synchronization */
18638 MPING (CONTROL_PING, mp_ping);
18641 /* Wait for a reply... */
18647 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
18649 vl_api_one_get_map_request_itr_rlocs_t *mp;
18652 if (!vam->json_output)
18654 print (vam->ofp, "%=20s", "itr-rlocs:");
18657 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
18660 /* Wait for a reply... */
18665 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
18668 api_af_packet_create (vat_main_t * vam)
18670 unformat_input_t *i = vam->input;
18671 vl_api_af_packet_create_t *mp;
18672 u8 *host_if_name = 0;
18674 u8 random_hw_addr = 1;
18677 clib_memset (hw_addr, 0, sizeof (hw_addr));
18679 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18681 if (unformat (i, "name %s", &host_if_name))
18682 vec_add1 (host_if_name, 0);
18683 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
18684 random_hw_addr = 0;
18689 if (!vec_len (host_if_name))
18691 errmsg ("host-interface name must be specified");
18695 if (vec_len (host_if_name) > 64)
18697 errmsg ("host-interface name too long");
18701 M (AF_PACKET_CREATE, mp);
18703 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
18704 clib_memcpy (mp->hw_addr, hw_addr, 6);
18705 mp->use_random_hw_addr = random_hw_addr;
18706 vec_free (host_if_name);
18714 fprintf (vam->ofp ? vam->ofp : stderr,
18715 " new sw_if_index = %d\n", vam->sw_if_index);
18722 api_af_packet_delete (vat_main_t * vam)
18724 unformat_input_t *i = vam->input;
18725 vl_api_af_packet_delete_t *mp;
18726 u8 *host_if_name = 0;
18729 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18731 if (unformat (i, "name %s", &host_if_name))
18732 vec_add1 (host_if_name, 0);
18737 if (!vec_len (host_if_name))
18739 errmsg ("host-interface name must be specified");
18743 if (vec_len (host_if_name) > 64)
18745 errmsg ("host-interface name too long");
18749 M (AF_PACKET_DELETE, mp);
18751 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
18752 vec_free (host_if_name);
18759 static void vl_api_af_packet_details_t_handler
18760 (vl_api_af_packet_details_t * mp)
18762 vat_main_t *vam = &vat_main;
18764 print (vam->ofp, "%-16s %d",
18765 mp->host_if_name, clib_net_to_host_u32 (mp->sw_if_index));
18768 static void vl_api_af_packet_details_t_handler_json
18769 (vl_api_af_packet_details_t * mp)
18771 vat_main_t *vam = &vat_main;
18772 vat_json_node_t *node = NULL;
18774 if (VAT_JSON_ARRAY != vam->json_tree.type)
18776 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18777 vat_json_init_array (&vam->json_tree);
18779 node = vat_json_array_add (&vam->json_tree);
18781 vat_json_init_object (node);
18782 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
18783 vat_json_object_add_string_copy (node, "dev_name", mp->host_if_name);
18787 api_af_packet_dump (vat_main_t * vam)
18789 vl_api_af_packet_dump_t *mp;
18790 vl_api_control_ping_t *mp_ping;
18793 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
18794 /* Get list of tap interfaces */
18795 M (AF_PACKET_DUMP, mp);
18798 /* Use a control ping for synchronization */
18799 MPING (CONTROL_PING, mp_ping);
18807 api_policer_add_del (vat_main_t * vam)
18809 unformat_input_t *i = vam->input;
18810 vl_api_policer_add_del_t *mp;
18820 u8 color_aware = 0;
18821 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
18824 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
18825 conform_action.dscp = 0;
18826 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
18827 exceed_action.dscp = 0;
18828 violate_action.action_type = SSE2_QOS_ACTION_DROP;
18829 violate_action.dscp = 0;
18831 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18833 if (unformat (i, "del"))
18835 else if (unformat (i, "name %s", &name))
18836 vec_add1 (name, 0);
18837 else if (unformat (i, "cir %u", &cir))
18839 else if (unformat (i, "eir %u", &eir))
18841 else if (unformat (i, "cb %u", &cb))
18843 else if (unformat (i, "eb %u", &eb))
18845 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
18848 else if (unformat (i, "round_type %U", unformat_policer_round_type,
18851 else if (unformat (i, "type %U", unformat_policer_type, &type))
18853 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
18856 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
18859 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
18862 else if (unformat (i, "color-aware"))
18868 if (!vec_len (name))
18870 errmsg ("policer name must be specified");
18874 if (vec_len (name) > 64)
18876 errmsg ("policer name too long");
18880 M (POLICER_ADD_DEL, mp);
18882 clib_memcpy (mp->name, name, vec_len (name));
18884 mp->is_add = is_add;
18885 mp->cir = ntohl (cir);
18886 mp->eir = ntohl (eir);
18887 mp->cb = clib_net_to_host_u64 (cb);
18888 mp->eb = clib_net_to_host_u64 (eb);
18889 mp->rate_type = rate_type;
18890 mp->round_type = round_type;
18892 mp->conform_action_type = conform_action.action_type;
18893 mp->conform_dscp = conform_action.dscp;
18894 mp->exceed_action_type = exceed_action.action_type;
18895 mp->exceed_dscp = exceed_action.dscp;
18896 mp->violate_action_type = violate_action.action_type;
18897 mp->violate_dscp = violate_action.dscp;
18898 mp->color_aware = color_aware;
18906 api_policer_dump (vat_main_t * vam)
18908 unformat_input_t *i = vam->input;
18909 vl_api_policer_dump_t *mp;
18910 vl_api_control_ping_t *mp_ping;
18911 u8 *match_name = 0;
18912 u8 match_name_valid = 0;
18915 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18917 if (unformat (i, "name %s", &match_name))
18919 vec_add1 (match_name, 0);
18920 match_name_valid = 1;
18926 M (POLICER_DUMP, mp);
18927 mp->match_name_valid = match_name_valid;
18928 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
18929 vec_free (match_name);
18933 /* Use a control ping for synchronization */
18934 MPING (CONTROL_PING, mp_ping);
18937 /* Wait for a reply... */
18943 api_policer_classify_set_interface (vat_main_t * vam)
18945 unformat_input_t *i = vam->input;
18946 vl_api_policer_classify_set_interface_t *mp;
18948 int sw_if_index_set;
18949 u32 ip4_table_index = ~0;
18950 u32 ip6_table_index = ~0;
18951 u32 l2_table_index = ~0;
18955 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18957 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18958 sw_if_index_set = 1;
18959 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18960 sw_if_index_set = 1;
18961 else if (unformat (i, "del"))
18963 else if (unformat (i, "ip4-table %d", &ip4_table_index))
18965 else if (unformat (i, "ip6-table %d", &ip6_table_index))
18967 else if (unformat (i, "l2-table %d", &l2_table_index))
18971 clib_warning ("parse error '%U'", format_unformat_error, i);
18976 if (sw_if_index_set == 0)
18978 errmsg ("missing interface name or sw_if_index");
18982 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
18984 mp->sw_if_index = ntohl (sw_if_index);
18985 mp->ip4_table_index = ntohl (ip4_table_index);
18986 mp->ip6_table_index = ntohl (ip6_table_index);
18987 mp->l2_table_index = ntohl (l2_table_index);
18988 mp->is_add = is_add;
18996 api_policer_classify_dump (vat_main_t * vam)
18998 unformat_input_t *i = vam->input;
18999 vl_api_policer_classify_dump_t *mp;
19000 vl_api_control_ping_t *mp_ping;
19001 u8 type = POLICER_CLASSIFY_N_TABLES;
19004 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
19008 errmsg ("classify table type must be specified");
19012 if (!vam->json_output)
19014 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
19017 M (POLICER_CLASSIFY_DUMP, mp);
19022 /* Use a control ping for synchronization */
19023 MPING (CONTROL_PING, mp_ping);
19026 /* Wait for a reply... */
19032 api_netmap_create (vat_main_t * vam)
19034 unformat_input_t *i = vam->input;
19035 vl_api_netmap_create_t *mp;
19038 u8 random_hw_addr = 1;
19043 clib_memset (hw_addr, 0, sizeof (hw_addr));
19045 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19047 if (unformat (i, "name %s", &if_name))
19048 vec_add1 (if_name, 0);
19049 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
19050 random_hw_addr = 0;
19051 else if (unformat (i, "pipe"))
19053 else if (unformat (i, "master"))
19055 else if (unformat (i, "slave"))
19061 if (!vec_len (if_name))
19063 errmsg ("interface name must be specified");
19067 if (vec_len (if_name) > 64)
19069 errmsg ("interface name too long");
19073 M (NETMAP_CREATE, mp);
19075 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
19076 clib_memcpy (mp->hw_addr, hw_addr, 6);
19077 mp->use_random_hw_addr = random_hw_addr;
19078 mp->is_pipe = is_pipe;
19079 mp->is_master = is_master;
19080 vec_free (if_name);
19088 api_netmap_delete (vat_main_t * vam)
19090 unformat_input_t *i = vam->input;
19091 vl_api_netmap_delete_t *mp;
19095 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19097 if (unformat (i, "name %s", &if_name))
19098 vec_add1 (if_name, 0);
19103 if (!vec_len (if_name))
19105 errmsg ("interface name must be specified");
19109 if (vec_len (if_name) > 64)
19111 errmsg ("interface name too long");
19115 M (NETMAP_DELETE, mp);
19117 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
19118 vec_free (if_name);
19126 vl_api_mpls_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
19128 if (fp->afi == IP46_TYPE_IP6)
19130 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19131 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19132 fp->weight, ntohl (fp->sw_if_index), fp->is_local,
19133 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19134 format_ip6_address, fp->next_hop);
19135 else if (fp->afi == IP46_TYPE_IP4)
19137 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19138 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19139 fp->weight, ntohl (fp->sw_if_index), fp->is_local,
19140 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19141 format_ip4_address, fp->next_hop);
19145 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
19146 vl_api_fib_path_t * fp)
19148 struct in_addr ip4;
19149 struct in6_addr ip6;
19151 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19152 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19153 vat_json_object_add_uint (node, "is_local", fp->is_local);
19154 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19155 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19156 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19157 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19158 if (fp->afi == IP46_TYPE_IP4)
19160 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19161 vat_json_object_add_ip4 (node, "next_hop", ip4);
19163 else if (fp->afi == IP46_TYPE_IP6)
19165 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19166 vat_json_object_add_ip6 (node, "next_hop", ip6);
19171 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
19173 vat_main_t *vam = &vat_main;
19174 int count = ntohl (mp->mt_count);
19175 vl_api_fib_path_t *fp;
19178 print (vam->ofp, "[%d]: sw_if_index %d via:",
19179 ntohl (mp->mt_tunnel_index), ntohl (mp->mt_sw_if_index));
19181 for (i = 0; i < count; i++)
19183 vl_api_mpls_fib_path_print (vam, fp);
19187 print (vam->ofp, "");
19190 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
19191 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
19194 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
19196 vat_main_t *vam = &vat_main;
19197 vat_json_node_t *node = NULL;
19198 int count = ntohl (mp->mt_count);
19199 vl_api_fib_path_t *fp;
19202 if (VAT_JSON_ARRAY != vam->json_tree.type)
19204 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19205 vat_json_init_array (&vam->json_tree);
19207 node = vat_json_array_add (&vam->json_tree);
19209 vat_json_init_object (node);
19210 vat_json_object_add_uint (node, "tunnel_index",
19211 ntohl (mp->mt_tunnel_index));
19212 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->mt_sw_if_index));
19214 vat_json_object_add_uint (node, "l2_only", mp->mt_l2_only);
19217 for (i = 0; i < count; i++)
19219 vl_api_mpls_fib_path_json_print (node, fp);
19225 api_mpls_tunnel_dump (vat_main_t * vam)
19227 vl_api_mpls_tunnel_dump_t *mp;
19228 vl_api_control_ping_t *mp_ping;
19229 u32 sw_if_index = ~0;
19232 /* Parse args required to build the message */
19233 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
19235 if (unformat (vam->input, "sw_if_index %d", &sw_if_index))
19239 print (vam->ofp, " sw_if_index %d", sw_if_index);
19241 M (MPLS_TUNNEL_DUMP, mp);
19242 mp->sw_if_index = htonl (sw_if_index);
19245 /* Use a control ping for synchronization */
19246 MPING (CONTROL_PING, mp_ping);
19253 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
19254 #define vl_api_mpls_fib_details_t_print vl_noop_handler
19258 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
19260 vat_main_t *vam = &vat_main;
19261 int count = ntohl (mp->count);
19262 vl_api_fib_path_t *fp;
19266 "table-id %d, label %u, ess_bit %u",
19267 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
19269 for (i = 0; i < count; i++)
19271 vl_api_mpls_fib_path_print (vam, fp);
19276 static void vl_api_mpls_fib_details_t_handler_json
19277 (vl_api_mpls_fib_details_t * mp)
19279 vat_main_t *vam = &vat_main;
19280 int count = ntohl (mp->count);
19281 vat_json_node_t *node = NULL;
19282 vl_api_fib_path_t *fp;
19285 if (VAT_JSON_ARRAY != vam->json_tree.type)
19287 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19288 vat_json_init_array (&vam->json_tree);
19290 node = vat_json_array_add (&vam->json_tree);
19292 vat_json_init_object (node);
19293 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19294 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
19295 vat_json_object_add_uint (node, "label", ntohl (mp->label));
19296 vat_json_object_add_uint (node, "path_count", count);
19298 for (i = 0; i < count; i++)
19300 vl_api_mpls_fib_path_json_print (node, fp);
19306 api_mpls_fib_dump (vat_main_t * vam)
19308 vl_api_mpls_fib_dump_t *mp;
19309 vl_api_control_ping_t *mp_ping;
19312 M (MPLS_FIB_DUMP, mp);
19315 /* Use a control ping for synchronization */
19316 MPING (CONTROL_PING, mp_ping);
19323 #define vl_api_ip_fib_details_t_endian vl_noop_handler
19324 #define vl_api_ip_fib_details_t_print vl_noop_handler
19327 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
19329 vat_main_t *vam = &vat_main;
19330 int count = ntohl (mp->count);
19331 vl_api_fib_path_t *fp;
19335 "table-id %d, prefix %U/%d stats-index %d",
19336 ntohl (mp->table_id), format_ip4_address, mp->address,
19337 mp->address_length, ntohl (mp->stats_index));
19339 for (i = 0; i < count; i++)
19341 if (fp->afi == IP46_TYPE_IP6)
19343 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19344 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U, "
19345 "next_hop_table %d",
19346 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19347 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19348 format_ip6_address, fp->next_hop, ntohl (fp->table_id));
19349 else if (fp->afi == IP46_TYPE_IP4)
19351 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19352 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U, "
19353 "next_hop_table %d",
19354 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19355 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19356 format_ip4_address, fp->next_hop, ntohl (fp->table_id));
19361 static void vl_api_ip_fib_details_t_handler_json
19362 (vl_api_ip_fib_details_t * mp)
19364 vat_main_t *vam = &vat_main;
19365 int count = ntohl (mp->count);
19366 vat_json_node_t *node = NULL;
19367 struct in_addr ip4;
19368 struct in6_addr ip6;
19369 vl_api_fib_path_t *fp;
19372 if (VAT_JSON_ARRAY != vam->json_tree.type)
19374 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19375 vat_json_init_array (&vam->json_tree);
19377 node = vat_json_array_add (&vam->json_tree);
19379 vat_json_init_object (node);
19380 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19381 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
19382 vat_json_object_add_ip4 (node, "prefix", ip4);
19383 vat_json_object_add_uint (node, "mask_length", mp->address_length);
19384 vat_json_object_add_uint (node, "path_count", count);
19386 for (i = 0; i < count; i++)
19388 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19389 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19390 vat_json_object_add_uint (node, "is_local", fp->is_local);
19391 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19392 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19393 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19394 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19395 if (fp->afi == IP46_TYPE_IP4)
19397 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19398 vat_json_object_add_ip4 (node, "next_hop", ip4);
19400 else if (fp->afi == IP46_TYPE_IP6)
19402 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19403 vat_json_object_add_ip6 (node, "next_hop", ip6);
19409 api_ip_fib_dump (vat_main_t * vam)
19411 vl_api_ip_fib_dump_t *mp;
19412 vl_api_control_ping_t *mp_ping;
19415 M (IP_FIB_DUMP, mp);
19418 /* Use a control ping for synchronization */
19419 MPING (CONTROL_PING, mp_ping);
19427 api_ip_mfib_dump (vat_main_t * vam)
19429 vl_api_ip_mfib_dump_t *mp;
19430 vl_api_control_ping_t *mp_ping;
19433 M (IP_MFIB_DUMP, mp);
19436 /* Use a control ping for synchronization */
19437 MPING (CONTROL_PING, mp_ping);
19444 static void vl_api_ip_neighbor_details_t_handler
19445 (vl_api_ip_neighbor_details_t * mp)
19447 vat_main_t *vam = &vat_main;
19449 print (vam->ofp, "%c %U %U",
19450 (ntohl (mp->neighbor.flags) & IP_NEIGHBOR_FLAG_STATIC) ? 'S' : 'D',
19451 format_vl_api_mac_address, &mp->neighbor.mac_address,
19452 format_vl_api_address, &mp->neighbor.ip_address);
19455 static void vl_api_ip_neighbor_details_t_handler_json
19456 (vl_api_ip_neighbor_details_t * mp)
19459 vat_main_t *vam = &vat_main;
19460 vat_json_node_t *node;
19462 if (VAT_JSON_ARRAY != vam->json_tree.type)
19464 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19465 vat_json_init_array (&vam->json_tree);
19467 node = vat_json_array_add (&vam->json_tree);
19469 vat_json_init_object (node);
19470 vat_json_object_add_string_copy
19472 ((ntohl (mp->neighbor.flags) & IP_NEIGHBOR_FLAG_STATIC) ?
19473 (u8 *) "static" : (u8 *) "dynamic"));
19475 vat_json_object_add_string_copy (node, "link_layer",
19476 format (0, "%U", format_vl_api_mac_address,
19477 &mp->neighbor.mac_address));
19478 vat_json_object_add_address (node, "ip", &mp->neighbor.ip_address);
19482 api_ip_neighbor_dump (vat_main_t * vam)
19484 unformat_input_t *i = vam->input;
19485 vl_api_ip_neighbor_dump_t *mp;
19486 vl_api_control_ping_t *mp_ping;
19488 u32 sw_if_index = ~0;
19491 /* Parse args required to build the message */
19492 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19494 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19496 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19498 else if (unformat (i, "ip6"))
19504 if (sw_if_index == ~0)
19506 errmsg ("missing interface name or sw_if_index");
19510 M (IP_NEIGHBOR_DUMP, mp);
19511 mp->is_ipv6 = (u8) is_ipv6;
19512 mp->sw_if_index = ntohl (sw_if_index);
19515 /* Use a control ping for synchronization */
19516 MPING (CONTROL_PING, mp_ping);
19523 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
19524 #define vl_api_ip6_fib_details_t_print vl_noop_handler
19527 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
19529 vat_main_t *vam = &vat_main;
19530 int count = ntohl (mp->count);
19531 vl_api_fib_path_t *fp;
19535 "table-id %d, prefix %U/%d stats-index %d",
19536 ntohl (mp->table_id), format_ip6_address, mp->address,
19537 mp->address_length, ntohl (mp->stats_index));
19539 for (i = 0; i < count; i++)
19541 if (fp->afi == IP46_TYPE_IP6)
19543 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19544 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19545 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19546 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19547 format_ip6_address, fp->next_hop);
19548 else if (fp->afi == IP46_TYPE_IP4)
19550 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19551 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19552 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19553 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19554 format_ip4_address, fp->next_hop);
19559 static void vl_api_ip6_fib_details_t_handler_json
19560 (vl_api_ip6_fib_details_t * mp)
19562 vat_main_t *vam = &vat_main;
19563 int count = ntohl (mp->count);
19564 vat_json_node_t *node = NULL;
19565 struct in_addr ip4;
19566 struct in6_addr ip6;
19567 vl_api_fib_path_t *fp;
19570 if (VAT_JSON_ARRAY != vam->json_tree.type)
19572 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19573 vat_json_init_array (&vam->json_tree);
19575 node = vat_json_array_add (&vam->json_tree);
19577 vat_json_init_object (node);
19578 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19579 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
19580 vat_json_object_add_ip6 (node, "prefix", ip6);
19581 vat_json_object_add_uint (node, "mask_length", mp->address_length);
19582 vat_json_object_add_uint (node, "path_count", count);
19584 for (i = 0; i < count; i++)
19586 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19587 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19588 vat_json_object_add_uint (node, "is_local", fp->is_local);
19589 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19590 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19591 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19592 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19593 if (fp->afi == IP46_TYPE_IP4)
19595 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19596 vat_json_object_add_ip4 (node, "next_hop", ip4);
19598 else if (fp->afi == IP46_TYPE_IP6)
19600 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19601 vat_json_object_add_ip6 (node, "next_hop", ip6);
19607 api_ip6_fib_dump (vat_main_t * vam)
19609 vl_api_ip6_fib_dump_t *mp;
19610 vl_api_control_ping_t *mp_ping;
19613 M (IP6_FIB_DUMP, mp);
19616 /* Use a control ping for synchronization */
19617 MPING (CONTROL_PING, mp_ping);
19625 api_ip6_mfib_dump (vat_main_t * vam)
19627 vl_api_ip6_mfib_dump_t *mp;
19628 vl_api_control_ping_t *mp_ping;
19631 M (IP6_MFIB_DUMP, mp);
19634 /* Use a control ping for synchronization */
19635 MPING (CONTROL_PING, mp_ping);
19643 api_classify_table_ids (vat_main_t * vam)
19645 vl_api_classify_table_ids_t *mp;
19648 /* Construct the API message */
19649 M (CLASSIFY_TABLE_IDS, mp);
19658 api_classify_table_by_interface (vat_main_t * vam)
19660 unformat_input_t *input = vam->input;
19661 vl_api_classify_table_by_interface_t *mp;
19663 u32 sw_if_index = ~0;
19665 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19667 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19669 else if (unformat (input, "sw_if_index %d", &sw_if_index))
19674 if (sw_if_index == ~0)
19676 errmsg ("missing interface name or sw_if_index");
19680 /* Construct the API message */
19681 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
19683 mp->sw_if_index = ntohl (sw_if_index);
19691 api_classify_table_info (vat_main_t * vam)
19693 unformat_input_t *input = vam->input;
19694 vl_api_classify_table_info_t *mp;
19698 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19700 if (unformat (input, "table_id %d", &table_id))
19705 if (table_id == ~0)
19707 errmsg ("missing table id");
19711 /* Construct the API message */
19712 M (CLASSIFY_TABLE_INFO, mp);
19714 mp->table_id = ntohl (table_id);
19722 api_classify_session_dump (vat_main_t * vam)
19724 unformat_input_t *input = vam->input;
19725 vl_api_classify_session_dump_t *mp;
19726 vl_api_control_ping_t *mp_ping;
19730 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19732 if (unformat (input, "table_id %d", &table_id))
19737 if (table_id == ~0)
19739 errmsg ("missing table id");
19743 /* Construct the API message */
19744 M (CLASSIFY_SESSION_DUMP, mp);
19746 mp->table_id = ntohl (table_id);
19749 /* Use a control ping for synchronization */
19750 MPING (CONTROL_PING, mp_ping);
19758 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
19760 vat_main_t *vam = &vat_main;
19762 print (vam->ofp, "collector_address %U, collector_port %d, "
19763 "src_address %U, vrf_id %d, path_mtu %u, "
19764 "template_interval %u, udp_checksum %d",
19765 format_ip4_address, mp->collector_address,
19766 ntohs (mp->collector_port),
19767 format_ip4_address, mp->src_address,
19768 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
19769 ntohl (mp->template_interval), mp->udp_checksum);
19772 vam->result_ready = 1;
19776 vl_api_ipfix_exporter_details_t_handler_json
19777 (vl_api_ipfix_exporter_details_t * mp)
19779 vat_main_t *vam = &vat_main;
19780 vat_json_node_t node;
19781 struct in_addr collector_address;
19782 struct in_addr src_address;
19784 vat_json_init_object (&node);
19785 clib_memcpy (&collector_address, &mp->collector_address,
19786 sizeof (collector_address));
19787 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
19788 vat_json_object_add_uint (&node, "collector_port",
19789 ntohs (mp->collector_port));
19790 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
19791 vat_json_object_add_ip4 (&node, "src_address", src_address);
19792 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
19793 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
19794 vat_json_object_add_uint (&node, "template_interval",
19795 ntohl (mp->template_interval));
19796 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
19798 vat_json_print (vam->ofp, &node);
19799 vat_json_free (&node);
19801 vam->result_ready = 1;
19805 api_ipfix_exporter_dump (vat_main_t * vam)
19807 vl_api_ipfix_exporter_dump_t *mp;
19810 /* Construct the API message */
19811 M (IPFIX_EXPORTER_DUMP, mp);
19820 api_ipfix_classify_stream_dump (vat_main_t * vam)
19822 vl_api_ipfix_classify_stream_dump_t *mp;
19825 /* Construct the API message */
19826 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
19837 vl_api_ipfix_classify_stream_details_t_handler
19838 (vl_api_ipfix_classify_stream_details_t * mp)
19840 vat_main_t *vam = &vat_main;
19841 print (vam->ofp, "domain_id %d, src_port %d",
19842 ntohl (mp->domain_id), ntohs (mp->src_port));
19844 vam->result_ready = 1;
19848 vl_api_ipfix_classify_stream_details_t_handler_json
19849 (vl_api_ipfix_classify_stream_details_t * mp)
19851 vat_main_t *vam = &vat_main;
19852 vat_json_node_t node;
19854 vat_json_init_object (&node);
19855 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
19856 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
19858 vat_json_print (vam->ofp, &node);
19859 vat_json_free (&node);
19861 vam->result_ready = 1;
19865 api_ipfix_classify_table_dump (vat_main_t * vam)
19867 vl_api_ipfix_classify_table_dump_t *mp;
19868 vl_api_control_ping_t *mp_ping;
19871 if (!vam->json_output)
19873 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
19874 "transport_protocol");
19877 /* Construct the API message */
19878 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
19883 /* Use a control ping for synchronization */
19884 MPING (CONTROL_PING, mp_ping);
19892 vl_api_ipfix_classify_table_details_t_handler
19893 (vl_api_ipfix_classify_table_details_t * mp)
19895 vat_main_t *vam = &vat_main;
19896 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
19897 mp->transport_protocol);
19901 vl_api_ipfix_classify_table_details_t_handler_json
19902 (vl_api_ipfix_classify_table_details_t * mp)
19904 vat_json_node_t *node = NULL;
19905 vat_main_t *vam = &vat_main;
19907 if (VAT_JSON_ARRAY != vam->json_tree.type)
19909 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19910 vat_json_init_array (&vam->json_tree);
19913 node = vat_json_array_add (&vam->json_tree);
19914 vat_json_init_object (node);
19916 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
19917 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
19918 vat_json_object_add_uint (node, "transport_protocol",
19919 mp->transport_protocol);
19923 api_sw_interface_span_enable_disable (vat_main_t * vam)
19925 unformat_input_t *i = vam->input;
19926 vl_api_sw_interface_span_enable_disable_t *mp;
19927 u32 src_sw_if_index = ~0;
19928 u32 dst_sw_if_index = ~0;
19933 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19936 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
19938 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
19942 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
19944 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
19946 else if (unformat (i, "disable"))
19948 else if (unformat (i, "rx"))
19950 else if (unformat (i, "tx"))
19952 else if (unformat (i, "both"))
19954 else if (unformat (i, "l2"))
19960 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
19962 mp->sw_if_index_from = htonl (src_sw_if_index);
19963 mp->sw_if_index_to = htonl (dst_sw_if_index);
19973 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
19976 vat_main_t *vam = &vat_main;
19977 u8 *sw_if_from_name = 0;
19978 u8 *sw_if_to_name = 0;
19979 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
19980 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
19981 char *states[] = { "none", "rx", "tx", "both" };
19985 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
19987 if ((u32) p->value[0] == sw_if_index_from)
19989 sw_if_from_name = (u8 *)(p->key);
19993 if ((u32) p->value[0] == sw_if_index_to)
19995 sw_if_to_name = (u8 *)(p->key);
19996 if (sw_if_from_name)
20001 print (vam->ofp, "%20s => %20s (%s) %s",
20002 sw_if_from_name, sw_if_to_name, states[mp->state],
20003 mp->is_l2 ? "l2" : "device");
20007 vl_api_sw_interface_span_details_t_handler_json
20008 (vl_api_sw_interface_span_details_t * mp)
20010 vat_main_t *vam = &vat_main;
20011 vat_json_node_t *node = NULL;
20012 u8 *sw_if_from_name = 0;
20013 u8 *sw_if_to_name = 0;
20014 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
20015 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
20019 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
20021 if ((u32) p->value[0] == sw_if_index_from)
20023 sw_if_from_name = (u8 *)(p->key);
20027 if ((u32) p->value[0] == sw_if_index_to)
20029 sw_if_to_name = (u8 *)(p->key);
20030 if (sw_if_from_name)
20036 if (VAT_JSON_ARRAY != vam->json_tree.type)
20038 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20039 vat_json_init_array (&vam->json_tree);
20041 node = vat_json_array_add (&vam->json_tree);
20043 vat_json_init_object (node);
20044 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
20045 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
20046 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
20047 if (0 != sw_if_to_name)
20049 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
20051 vat_json_object_add_uint (node, "state", mp->state);
20052 vat_json_object_add_uint (node, "is-l2", mp->is_l2);
20056 api_sw_interface_span_dump (vat_main_t * vam)
20058 unformat_input_t *input = vam->input;
20059 vl_api_sw_interface_span_dump_t *mp;
20060 vl_api_control_ping_t *mp_ping;
20064 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20066 if (unformat (input, "l2"))
20072 M (SW_INTERFACE_SPAN_DUMP, mp);
20076 /* Use a control ping for synchronization */
20077 MPING (CONTROL_PING, mp_ping);
20085 api_pg_create_interface (vat_main_t * vam)
20087 unformat_input_t *input = vam->input;
20088 vl_api_pg_create_interface_t *mp;
20092 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20094 if (unformat (input, "if_id %d", &if_id))
20101 errmsg ("missing pg interface index");
20105 /* Construct the API message */
20106 M (PG_CREATE_INTERFACE, mp);
20108 mp->interface_id = ntohl (if_id);
20116 api_pg_capture (vat_main_t * vam)
20118 unformat_input_t *input = vam->input;
20119 vl_api_pg_capture_t *mp;
20124 u8 pcap_file_set = 0;
20127 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20129 if (unformat (input, "if_id %d", &if_id))
20131 else if (unformat (input, "pcap %s", &pcap_file))
20133 else if (unformat (input, "count %d", &count))
20135 else if (unformat (input, "disable"))
20142 errmsg ("missing pg interface index");
20145 if (pcap_file_set > 0)
20147 if (vec_len (pcap_file) > 255)
20149 errmsg ("pcap file name is too long");
20154 u32 name_len = vec_len (pcap_file);
20155 /* Construct the API message */
20156 M (PG_CAPTURE, mp);
20158 mp->interface_id = ntohl (if_id);
20159 mp->is_enabled = enable;
20160 mp->count = ntohl (count);
20161 mp->pcap_name_length = ntohl (name_len);
20162 if (pcap_file_set != 0)
20164 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
20166 vec_free (pcap_file);
20174 api_pg_enable_disable (vat_main_t * vam)
20176 unformat_input_t *input = vam->input;
20177 vl_api_pg_enable_disable_t *mp;
20180 u8 stream_name_set = 0;
20181 u8 *stream_name = 0;
20183 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20185 if (unformat (input, "stream %s", &stream_name))
20186 stream_name_set = 1;
20187 else if (unformat (input, "disable"))
20193 if (stream_name_set > 0)
20195 if (vec_len (stream_name) > 255)
20197 errmsg ("stream name too long");
20202 u32 name_len = vec_len (stream_name);
20203 /* Construct the API message */
20204 M (PG_ENABLE_DISABLE, mp);
20206 mp->is_enabled = enable;
20207 if (stream_name_set != 0)
20209 mp->stream_name_length = ntohl (name_len);
20210 clib_memcpy (mp->stream_name, stream_name, name_len);
20212 vec_free (stream_name);
20220 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
20222 unformat_input_t *input = vam->input;
20223 vl_api_ip_source_and_port_range_check_add_del_t *mp;
20225 u16 *low_ports = 0;
20226 u16 *high_ports = 0;
20229 vl_api_prefix_t prefix;
20237 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20239 if (unformat (input, "%U", unformat_vl_api_prefix, &prefix))
20241 else if (unformat (input, "vrf %d", &vrf_id))
20243 else if (unformat (input, "del"))
20245 else if (unformat (input, "port %d", &tmp))
20247 if (tmp == 0 || tmp > 65535)
20249 errmsg ("port %d out of range", tmp);
20253 this_hi = this_low + 1;
20254 vec_add1 (low_ports, this_low);
20255 vec_add1 (high_ports, this_hi);
20257 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
20259 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
20261 errmsg ("incorrect range parameters");
20265 /* Note: in debug CLI +1 is added to high before
20266 passing to real fn that does "the work"
20267 (ip_source_and_port_range_check_add_del).
20268 This fn is a wrapper around the binary API fn a
20269 control plane will call, which expects this increment
20270 to have occurred. Hence letting the binary API control
20271 plane fn do the increment for consistency between VAT
20272 and other control planes.
20275 vec_add1 (low_ports, this_low);
20276 vec_add1 (high_ports, this_hi);
20282 if (prefix_set == 0)
20284 errmsg ("<address>/<mask> not specified");
20290 errmsg ("VRF ID required, not specified");
20297 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
20301 if (vec_len (low_ports) == 0)
20303 errmsg ("At least one port or port range required");
20307 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
20309 mp->is_add = is_add;
20311 clib_memcpy (&mp->prefix, &prefix, sizeof (prefix));
20313 mp->number_of_ranges = vec_len (low_ports);
20315 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
20316 vec_free (low_ports);
20318 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
20319 vec_free (high_ports);
20321 mp->vrf_id = ntohl (vrf_id);
20329 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
20331 unformat_input_t *input = vam->input;
20332 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
20333 u32 sw_if_index = ~0;
20335 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
20336 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
20340 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20342 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20344 else if (unformat (input, "sw_if_index %d", &sw_if_index))
20346 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
20348 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
20350 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
20352 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
20354 else if (unformat (input, "del"))
20360 if (sw_if_index == ~0)
20362 errmsg ("Interface required but not specified");
20368 errmsg ("VRF ID required but not specified");
20372 if (tcp_out_vrf_id == 0
20373 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
20376 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
20380 /* Construct the API message */
20381 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
20383 mp->sw_if_index = ntohl (sw_if_index);
20384 mp->is_add = is_add;
20385 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
20386 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
20387 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
20388 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
20393 /* Wait for a reply... */
20399 api_ipsec_gre_tunnel_add_del (vat_main_t * vam)
20401 unformat_input_t *i = vam->input;
20402 vl_api_ipsec_gre_tunnel_add_del_t *mp;
20403 u32 local_sa_id = 0;
20404 u32 remote_sa_id = 0;
20405 vl_api_ip4_address_t src_address;
20406 vl_api_ip4_address_t dst_address;
20410 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20412 if (unformat (i, "local_sa %d", &local_sa_id))
20414 else if (unformat (i, "remote_sa %d", &remote_sa_id))
20417 if (unformat (i, "src %U", unformat_vl_api_ip4_address, &src_address))
20420 if (unformat (i, "dst %U", unformat_vl_api_ip4_address, &dst_address))
20422 else if (unformat (i, "del"))
20426 clib_warning ("parse error '%U'", format_unformat_error, i);
20431 M (IPSEC_GRE_TUNNEL_ADD_DEL, mp);
20433 mp->tunnel.local_sa_id = ntohl (local_sa_id);
20434 mp->tunnel.remote_sa_id = ntohl (remote_sa_id);
20435 clib_memcpy (mp->tunnel.src, &src_address, sizeof (src_address));
20436 clib_memcpy (mp->tunnel.dst, &dst_address, sizeof (dst_address));
20437 mp->is_add = is_add;
20445 api_set_punt (vat_main_t * vam)
20447 unformat_input_t *i = vam->input;
20448 vl_api_set_punt_t *mp;
20455 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20457 if (unformat (i, "ip %d", &ipv))
20459 else if (unformat (i, "protocol %d", &protocol))
20461 else if (unformat (i, "port %d", &port))
20463 else if (unformat (i, "del"))
20467 clib_warning ("parse error '%U'", format_unformat_error, i);
20474 mp->is_add = (u8) is_add;
20475 mp->punt.ipv = (u8) ipv;
20476 mp->punt.l4_protocol = (u8) protocol;
20477 mp->punt.l4_port = htons ((u16) port);
20484 static void vl_api_ipsec_gre_tunnel_details_t_handler
20485 (vl_api_ipsec_gre_tunnel_details_t * mp)
20487 vat_main_t *vam = &vat_main;
20489 print (vam->ofp, "%11d%15U%15U%14d%14d",
20490 ntohl (mp->tunnel.sw_if_index),
20491 format_vl_api_ip4_address, mp->tunnel.src,
20492 format_vl_api_ip4_address, mp->tunnel.dst,
20493 ntohl (mp->tunnel.local_sa_id), ntohl (mp->tunnel.remote_sa_id));
20497 vat_json_object_add_vl_api_ip4 (vat_json_node_t * node,
20499 const vl_api_ip4_address_t addr)
20501 struct in_addr ip4;
20503 clib_memcpy (&ip4, addr, sizeof (ip4));
20504 vat_json_object_add_ip4 (node, name, ip4);
20507 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
20508 (vl_api_ipsec_gre_tunnel_details_t * mp)
20510 vat_main_t *vam = &vat_main;
20511 vat_json_node_t *node = NULL;
20512 struct in_addr ip4;
20514 if (VAT_JSON_ARRAY != vam->json_tree.type)
20516 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20517 vat_json_init_array (&vam->json_tree);
20519 node = vat_json_array_add (&vam->json_tree);
20521 vat_json_init_object (node);
20522 vat_json_object_add_uint (node, "sw_if_index",
20523 ntohl (mp->tunnel.sw_if_index));
20524 vat_json_object_add_vl_api_ip4 (node, "src", mp->tunnel.src);
20525 vat_json_object_add_vl_api_ip4 (node, "src", mp->tunnel.dst);
20526 vat_json_object_add_uint (node, "local_sa_id",
20527 ntohl (mp->tunnel.local_sa_id));
20528 vat_json_object_add_uint (node, "remote_sa_id",
20529 ntohl (mp->tunnel.remote_sa_id));
20533 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
20535 unformat_input_t *i = vam->input;
20536 vl_api_ipsec_gre_tunnel_dump_t *mp;
20537 vl_api_control_ping_t *mp_ping;
20539 u8 sw_if_index_set = 0;
20542 /* Parse args required to build the message */
20543 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20545 if (unformat (i, "sw_if_index %d", &sw_if_index))
20546 sw_if_index_set = 1;
20551 if (sw_if_index_set == 0)
20556 if (!vam->json_output)
20558 print (vam->ofp, "%11s%15s%15s%14s%14s",
20559 "sw_if_index", "src_address", "dst_address",
20560 "local_sa_id", "remote_sa_id");
20563 /* Get list of gre-tunnel interfaces */
20564 M (IPSEC_GRE_TUNNEL_DUMP, mp);
20566 mp->sw_if_index = htonl (sw_if_index);
20570 /* Use a control ping for synchronization */
20571 MPING (CONTROL_PING, mp_ping);
20579 api_delete_subif (vat_main_t * vam)
20581 unformat_input_t *i = vam->input;
20582 vl_api_delete_subif_t *mp;
20583 u32 sw_if_index = ~0;
20586 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20588 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20590 if (unformat (i, "sw_if_index %d", &sw_if_index))
20596 if (sw_if_index == ~0)
20598 errmsg ("missing sw_if_index");
20602 /* Construct the API message */
20603 M (DELETE_SUBIF, mp);
20604 mp->sw_if_index = ntohl (sw_if_index);
20611 #define foreach_pbb_vtr_op \
20612 _("disable", L2_VTR_DISABLED) \
20613 _("pop", L2_VTR_POP_2) \
20614 _("push", L2_VTR_PUSH_2)
20617 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
20619 unformat_input_t *i = vam->input;
20620 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
20621 u32 sw_if_index = ~0, vtr_op = ~0;
20622 u16 outer_tag = ~0;
20623 u8 dmac[6], smac[6];
20624 u8 dmac_set = 0, smac_set = 0;
20630 /* Shut up coverity */
20631 clib_memset (dmac, 0, sizeof (dmac));
20632 clib_memset (smac, 0, sizeof (smac));
20634 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20636 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20638 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20640 else if (unformat (i, "vtr_op %d", &vtr_op))
20642 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
20645 else if (unformat (i, "translate_pbb_stag"))
20647 if (unformat (i, "%d", &tmp))
20649 vtr_op = L2_VTR_TRANSLATE_2_1;
20655 ("translate_pbb_stag operation requires outer tag definition");
20659 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
20661 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
20663 else if (unformat (i, "sid %d", &sid))
20665 else if (unformat (i, "vlanid %d", &tmp))
20669 clib_warning ("parse error '%U'", format_unformat_error, i);
20674 if ((sw_if_index == ~0) || (vtr_op == ~0))
20676 errmsg ("missing sw_if_index or vtr operation");
20679 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
20680 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
20683 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
20687 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
20688 mp->sw_if_index = ntohl (sw_if_index);
20689 mp->vtr_op = ntohl (vtr_op);
20690 mp->outer_tag = ntohs (outer_tag);
20691 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
20692 clib_memcpy (mp->b_smac, smac, sizeof (smac));
20693 mp->b_vlanid = ntohs (vlanid);
20694 mp->i_sid = ntohl (sid);
20702 api_flow_classify_set_interface (vat_main_t * vam)
20704 unformat_input_t *i = vam->input;
20705 vl_api_flow_classify_set_interface_t *mp;
20707 int sw_if_index_set;
20708 u32 ip4_table_index = ~0;
20709 u32 ip6_table_index = ~0;
20713 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20715 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20716 sw_if_index_set = 1;
20717 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20718 sw_if_index_set = 1;
20719 else if (unformat (i, "del"))
20721 else if (unformat (i, "ip4-table %d", &ip4_table_index))
20723 else if (unformat (i, "ip6-table %d", &ip6_table_index))
20727 clib_warning ("parse error '%U'", format_unformat_error, i);
20732 if (sw_if_index_set == 0)
20734 errmsg ("missing interface name or sw_if_index");
20738 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
20740 mp->sw_if_index = ntohl (sw_if_index);
20741 mp->ip4_table_index = ntohl (ip4_table_index);
20742 mp->ip6_table_index = ntohl (ip6_table_index);
20743 mp->is_add = is_add;
20751 api_flow_classify_dump (vat_main_t * vam)
20753 unformat_input_t *i = vam->input;
20754 vl_api_flow_classify_dump_t *mp;
20755 vl_api_control_ping_t *mp_ping;
20756 u8 type = FLOW_CLASSIFY_N_TABLES;
20759 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
20763 errmsg ("classify table type must be specified");
20767 if (!vam->json_output)
20769 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
20772 M (FLOW_CLASSIFY_DUMP, mp);
20777 /* Use a control ping for synchronization */
20778 MPING (CONTROL_PING, mp_ping);
20781 /* Wait for a reply... */
20787 api_feature_enable_disable (vat_main_t * vam)
20789 unformat_input_t *i = vam->input;
20790 vl_api_feature_enable_disable_t *mp;
20792 u8 *feature_name = 0;
20793 u32 sw_if_index = ~0;
20797 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20799 if (unformat (i, "arc_name %s", &arc_name))
20801 else if (unformat (i, "feature_name %s", &feature_name))
20804 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20806 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20808 else if (unformat (i, "disable"))
20816 errmsg ("missing arc name");
20819 if (vec_len (arc_name) > 63)
20821 errmsg ("arc name too long");
20824 if (feature_name == 0)
20826 errmsg ("missing feature name");
20829 if (vec_len (feature_name) > 63)
20831 errmsg ("feature name too long");
20834 if (sw_if_index == ~0)
20836 errmsg ("missing interface name or sw_if_index");
20840 /* Construct the API message */
20841 M (FEATURE_ENABLE_DISABLE, mp);
20842 mp->sw_if_index = ntohl (sw_if_index);
20843 mp->enable = enable;
20844 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
20845 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
20846 vec_free (arc_name);
20847 vec_free (feature_name);
20855 api_sw_interface_tag_add_del (vat_main_t * vam)
20857 unformat_input_t *i = vam->input;
20858 vl_api_sw_interface_tag_add_del_t *mp;
20859 u32 sw_if_index = ~0;
20864 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20866 if (unformat (i, "tag %s", &tag))
20868 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20870 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20872 else if (unformat (i, "del"))
20878 if (sw_if_index == ~0)
20880 errmsg ("missing interface name or sw_if_index");
20884 if (enable && (tag == 0))
20886 errmsg ("no tag specified");
20890 /* Construct the API message */
20891 M (SW_INTERFACE_TAG_ADD_DEL, mp);
20892 mp->sw_if_index = ntohl (sw_if_index);
20893 mp->is_add = enable;
20895 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
20903 static void vl_api_l2_xconnect_details_t_handler
20904 (vl_api_l2_xconnect_details_t * mp)
20906 vat_main_t *vam = &vat_main;
20908 print (vam->ofp, "%15d%15d",
20909 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
20912 static void vl_api_l2_xconnect_details_t_handler_json
20913 (vl_api_l2_xconnect_details_t * mp)
20915 vat_main_t *vam = &vat_main;
20916 vat_json_node_t *node = NULL;
20918 if (VAT_JSON_ARRAY != vam->json_tree.type)
20920 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20921 vat_json_init_array (&vam->json_tree);
20923 node = vat_json_array_add (&vam->json_tree);
20925 vat_json_init_object (node);
20926 vat_json_object_add_uint (node, "rx_sw_if_index",
20927 ntohl (mp->rx_sw_if_index));
20928 vat_json_object_add_uint (node, "tx_sw_if_index",
20929 ntohl (mp->tx_sw_if_index));
20933 api_l2_xconnect_dump (vat_main_t * vam)
20935 vl_api_l2_xconnect_dump_t *mp;
20936 vl_api_control_ping_t *mp_ping;
20939 if (!vam->json_output)
20941 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
20944 M (L2_XCONNECT_DUMP, mp);
20948 /* Use a control ping for synchronization */
20949 MPING (CONTROL_PING, mp_ping);
20957 api_hw_interface_set_mtu (vat_main_t * vam)
20959 unformat_input_t *i = vam->input;
20960 vl_api_hw_interface_set_mtu_t *mp;
20961 u32 sw_if_index = ~0;
20965 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20967 if (unformat (i, "mtu %d", &mtu))
20969 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20971 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20977 if (sw_if_index == ~0)
20979 errmsg ("missing interface name or sw_if_index");
20985 errmsg ("no mtu specified");
20989 /* Construct the API message */
20990 M (HW_INTERFACE_SET_MTU, mp);
20991 mp->sw_if_index = ntohl (sw_if_index);
20992 mp->mtu = ntohs ((u16) mtu);
21000 api_p2p_ethernet_add (vat_main_t * vam)
21002 unformat_input_t *i = vam->input;
21003 vl_api_p2p_ethernet_add_t *mp;
21004 u32 parent_if_index = ~0;
21010 clib_memset (remote_mac, 0, sizeof (remote_mac));
21011 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21013 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
21015 else if (unformat (i, "sw_if_index %d", &parent_if_index))
21019 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
21021 else if (unformat (i, "sub_id %d", &sub_id))
21025 clib_warning ("parse error '%U'", format_unformat_error, i);
21030 if (parent_if_index == ~0)
21032 errmsg ("missing interface name or sw_if_index");
21037 errmsg ("missing remote mac address");
21042 errmsg ("missing sub-interface id");
21046 M (P2P_ETHERNET_ADD, mp);
21047 mp->parent_if_index = ntohl (parent_if_index);
21048 mp->subif_id = ntohl (sub_id);
21049 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
21057 api_p2p_ethernet_del (vat_main_t * vam)
21059 unformat_input_t *i = vam->input;
21060 vl_api_p2p_ethernet_del_t *mp;
21061 u32 parent_if_index = ~0;
21066 clib_memset (remote_mac, 0, sizeof (remote_mac));
21067 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21069 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
21071 else if (unformat (i, "sw_if_index %d", &parent_if_index))
21075 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
21079 clib_warning ("parse error '%U'", format_unformat_error, i);
21084 if (parent_if_index == ~0)
21086 errmsg ("missing interface name or sw_if_index");
21091 errmsg ("missing remote mac address");
21095 M (P2P_ETHERNET_DEL, mp);
21096 mp->parent_if_index = ntohl (parent_if_index);
21097 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
21105 api_lldp_config (vat_main_t * vam)
21107 unformat_input_t *i = vam->input;
21108 vl_api_lldp_config_t *mp;
21110 int tx_interval = 0;
21111 u8 *sys_name = NULL;
21114 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21116 if (unformat (i, "system-name %s", &sys_name))
21118 else if (unformat (i, "tx-hold %d", &tx_hold))
21120 else if (unformat (i, "tx-interval %d", &tx_interval))
21124 clib_warning ("parse error '%U'", format_unformat_error, i);
21129 vec_add1 (sys_name, 0);
21131 M (LLDP_CONFIG, mp);
21132 mp->tx_hold = htonl (tx_hold);
21133 mp->tx_interval = htonl (tx_interval);
21134 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
21135 vec_free (sys_name);
21143 api_sw_interface_set_lldp (vat_main_t * vam)
21145 unformat_input_t *i = vam->input;
21146 vl_api_sw_interface_set_lldp_t *mp;
21147 u32 sw_if_index = ~0;
21149 u8 *port_desc = NULL, *mgmt_oid = NULL;
21150 ip4_address_t ip4_addr;
21151 ip6_address_t ip6_addr;
21154 clib_memset (&ip4_addr, 0, sizeof (ip4_addr));
21155 clib_memset (&ip6_addr, 0, sizeof (ip6_addr));
21157 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21159 if (unformat (i, "disable"))
21162 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21164 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21166 else if (unformat (i, "port-desc %s", &port_desc))
21168 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
21170 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
21172 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
21178 if (sw_if_index == ~0)
21180 errmsg ("missing interface name or sw_if_index");
21184 /* Construct the API message */
21185 vec_add1 (port_desc, 0);
21186 vec_add1 (mgmt_oid, 0);
21187 M (SW_INTERFACE_SET_LLDP, mp);
21188 mp->sw_if_index = ntohl (sw_if_index);
21189 mp->enable = enable;
21190 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
21191 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
21192 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
21193 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
21194 vec_free (port_desc);
21195 vec_free (mgmt_oid);
21203 api_tcp_configure_src_addresses (vat_main_t * vam)
21205 vl_api_tcp_configure_src_addresses_t *mp;
21206 unformat_input_t *i = vam->input;
21207 ip4_address_t v4first, v4last;
21208 ip6_address_t v6first, v6last;
21213 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21215 if (unformat (i, "%U - %U",
21216 unformat_ip4_address, &v4first,
21217 unformat_ip4_address, &v4last))
21221 errmsg ("one range per message (range already set)");
21226 else if (unformat (i, "%U - %U",
21227 unformat_ip6_address, &v6first,
21228 unformat_ip6_address, &v6last))
21232 errmsg ("one range per message (range already set)");
21237 else if (unformat (i, "vrf %d", &vrf_id))
21243 if (range_set == 0)
21245 errmsg ("address range not set");
21249 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
21250 mp->vrf_id = ntohl (vrf_id);
21252 if (range_set == 2)
21255 clib_memcpy (mp->first_address, &v6first, sizeof (v6first));
21256 clib_memcpy (mp->last_address, &v6last, sizeof (v6last));
21261 clib_memcpy (mp->first_address, &v4first, sizeof (v4first));
21262 clib_memcpy (mp->last_address, &v4last, sizeof (v4last));
21269 static void vl_api_app_namespace_add_del_reply_t_handler
21270 (vl_api_app_namespace_add_del_reply_t * mp)
21272 vat_main_t *vam = &vat_main;
21273 i32 retval = ntohl (mp->retval);
21274 if (vam->async_mode)
21276 vam->async_errors += (retval < 0);
21280 vam->retval = retval;
21282 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
21283 vam->result_ready = 1;
21287 static void vl_api_app_namespace_add_del_reply_t_handler_json
21288 (vl_api_app_namespace_add_del_reply_t * mp)
21290 vat_main_t *vam = &vat_main;
21291 vat_json_node_t node;
21293 vat_json_init_object (&node);
21294 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
21295 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
21297 vat_json_print (vam->ofp, &node);
21298 vat_json_free (&node);
21300 vam->retval = ntohl (mp->retval);
21301 vam->result_ready = 1;
21305 api_app_namespace_add_del (vat_main_t * vam)
21307 vl_api_app_namespace_add_del_t *mp;
21308 unformat_input_t *i = vam->input;
21309 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
21310 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
21314 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21316 if (unformat (i, "id %_%v%_", &ns_id))
21318 else if (unformat (i, "secret %lu", &secret))
21320 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21321 sw_if_index_set = 1;
21322 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
21324 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
21329 if (!ns_id || !secret_set || !sw_if_index_set)
21331 errmsg ("namespace id, secret and sw_if_index must be set");
21334 if (vec_len (ns_id) > 64)
21336 errmsg ("namespace id too long");
21339 M (APP_NAMESPACE_ADD_DEL, mp);
21341 clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
21342 mp->namespace_id_len = vec_len (ns_id);
21343 mp->secret = clib_host_to_net_u64 (secret);
21344 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
21345 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
21346 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
21354 api_sock_init_shm (vat_main_t * vam)
21356 #if VPP_API_TEST_BUILTIN == 0
21357 unformat_input_t *i = vam->input;
21358 vl_api_shm_elem_config_t *config = 0;
21359 u64 size = 64 << 20;
21362 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21364 if (unformat (i, "size %U", unformat_memory_size, &size))
21371 * Canned custom ring allocator config.
21372 * Should probably parse all of this
21374 vec_validate (config, 6);
21375 config[0].type = VL_API_VLIB_RING;
21376 config[0].size = 256;
21377 config[0].count = 32;
21379 config[1].type = VL_API_VLIB_RING;
21380 config[1].size = 1024;
21381 config[1].count = 16;
21383 config[2].type = VL_API_VLIB_RING;
21384 config[2].size = 4096;
21385 config[2].count = 2;
21387 config[3].type = VL_API_CLIENT_RING;
21388 config[3].size = 256;
21389 config[3].count = 32;
21391 config[4].type = VL_API_CLIENT_RING;
21392 config[4].size = 1024;
21393 config[4].count = 16;
21395 config[5].type = VL_API_CLIENT_RING;
21396 config[5].size = 4096;
21397 config[5].count = 2;
21399 config[6].type = VL_API_QUEUE;
21400 config[6].count = 128;
21401 config[6].size = sizeof (uword);
21403 rv = vl_socket_client_init_shm (config, 1 /* want_pthread */ );
21405 vam->client_index_invalid = 1;
21413 api_dns_enable_disable (vat_main_t * vam)
21415 unformat_input_t *line_input = vam->input;
21416 vl_api_dns_enable_disable_t *mp;
21417 u8 enable_disable = 1;
21420 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21422 if (unformat (line_input, "disable"))
21423 enable_disable = 0;
21424 if (unformat (line_input, "enable"))
21425 enable_disable = 1;
21430 /* Construct the API message */
21431 M (DNS_ENABLE_DISABLE, mp);
21432 mp->enable = enable_disable;
21436 /* Wait for the reply */
21442 api_dns_resolve_name (vat_main_t * vam)
21444 unformat_input_t *line_input = vam->input;
21445 vl_api_dns_resolve_name_t *mp;
21449 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21451 if (unformat (line_input, "%s", &name))
21457 if (vec_len (name) > 127)
21459 errmsg ("name too long");
21463 /* Construct the API message */
21464 M (DNS_RESOLVE_NAME, mp);
21465 memcpy (mp->name, name, vec_len (name));
21470 /* Wait for the reply */
21476 api_dns_resolve_ip (vat_main_t * vam)
21478 unformat_input_t *line_input = vam->input;
21479 vl_api_dns_resolve_ip_t *mp;
21481 ip4_address_t addr4;
21482 ip6_address_t addr6;
21485 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21487 if (unformat (line_input, "%U", unformat_ip6_address, &addr6))
21489 else if (unformat (line_input, "%U", unformat_ip4_address, &addr4))
21497 errmsg ("missing address");
21501 /* Construct the API message */
21502 M (DNS_RESOLVE_IP, mp);
21503 mp->is_ip6 = is_ip6;
21505 memcpy (mp->address, &addr6, sizeof (addr6));
21507 memcpy (mp->address, &addr4, sizeof (addr4));
21511 /* Wait for the reply */
21517 api_dns_name_server_add_del (vat_main_t * vam)
21519 unformat_input_t *i = vam->input;
21520 vl_api_dns_name_server_add_del_t *mp;
21522 ip6_address_t ip6_server;
21523 ip4_address_t ip4_server;
21528 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21530 if (unformat (i, "%U", unformat_ip6_address, &ip6_server))
21532 else if (unformat (i, "%U", unformat_ip4_address, &ip4_server))
21534 else if (unformat (i, "del"))
21538 clib_warning ("parse error '%U'", format_unformat_error, i);
21543 if (ip4_set && ip6_set)
21545 errmsg ("Only one server address allowed per message");
21548 if ((ip4_set + ip6_set) == 0)
21550 errmsg ("Server address required");
21554 /* Construct the API message */
21555 M (DNS_NAME_SERVER_ADD_DEL, mp);
21559 memcpy (mp->server_address, &ip6_server, sizeof (ip6_address_t));
21564 memcpy (mp->server_address, &ip4_server, sizeof (ip4_address_t));
21568 mp->is_add = is_add;
21573 /* Wait for a reply, return good/bad news */
21579 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
21581 vat_main_t *vam = &vat_main;
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_ip4_address, &mp->lcl_ip, mp->lcl_plen,
21589 clib_net_to_host_u16 (mp->lcl_port), format_ip4_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 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
21597 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
21598 mp->scope, format_ip6_address, &mp->lcl_ip, mp->lcl_plen,
21599 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
21600 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
21601 clib_net_to_host_u32 (mp->action_index), mp->tag);
21606 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
21609 vat_main_t *vam = &vat_main;
21610 vat_json_node_t *node = NULL;
21611 struct in6_addr ip6;
21612 struct in_addr ip4;
21614 if (VAT_JSON_ARRAY != vam->json_tree.type)
21616 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
21617 vat_json_init_array (&vam->json_tree);
21619 node = vat_json_array_add (&vam->json_tree);
21620 vat_json_init_object (node);
21622 vat_json_object_add_uint (node, "is_ip4", mp->is_ip4 ? 1 : 0);
21623 vat_json_object_add_uint (node, "appns_index",
21624 clib_net_to_host_u32 (mp->appns_index));
21625 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
21626 vat_json_object_add_uint (node, "scope", mp->scope);
21627 vat_json_object_add_uint (node, "action_index",
21628 clib_net_to_host_u32 (mp->action_index));
21629 vat_json_object_add_uint (node, "lcl_port",
21630 clib_net_to_host_u16 (mp->lcl_port));
21631 vat_json_object_add_uint (node, "rmt_port",
21632 clib_net_to_host_u16 (mp->rmt_port));
21633 vat_json_object_add_uint (node, "lcl_plen", mp->lcl_plen);
21634 vat_json_object_add_uint (node, "rmt_plen", mp->rmt_plen);
21635 vat_json_object_add_string_copy (node, "tag", mp->tag);
21638 clib_memcpy (&ip4, mp->lcl_ip, sizeof (ip4));
21639 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
21640 clib_memcpy (&ip4, mp->rmt_ip, sizeof (ip4));
21641 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
21645 clib_memcpy (&ip6, mp->lcl_ip, sizeof (ip6));
21646 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
21647 clib_memcpy (&ip6, mp->rmt_ip, sizeof (ip6));
21648 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
21653 api_session_rule_add_del (vat_main_t * vam)
21655 vl_api_session_rule_add_del_t *mp;
21656 unformat_input_t *i = vam->input;
21657 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
21658 u32 appns_index = 0, scope = 0;
21659 ip4_address_t lcl_ip4, rmt_ip4;
21660 ip6_address_t lcl_ip6, rmt_ip6;
21661 u8 is_ip4 = 1, conn_set = 0;
21662 u8 is_add = 1, *tag = 0;
21665 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21667 if (unformat (i, "del"))
21669 else if (unformat (i, "add"))
21671 else if (unformat (i, "proto tcp"))
21673 else if (unformat (i, "proto udp"))
21675 else if (unformat (i, "appns %d", &appns_index))
21677 else if (unformat (i, "scope %d", &scope))
21679 else if (unformat (i, "tag %_%v%_", &tag))
21683 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
21684 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
21692 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
21693 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
21699 else if (unformat (i, "action %d", &action))
21704 if (proto == ~0 || !conn_set || action == ~0)
21706 errmsg ("transport proto, connection and action must be set");
21712 errmsg ("scope should be 0-3");
21716 M (SESSION_RULE_ADD_DEL, mp);
21718 mp->is_ip4 = is_ip4;
21719 mp->transport_proto = proto;
21720 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
21721 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
21722 mp->lcl_plen = lcl_plen;
21723 mp->rmt_plen = rmt_plen;
21724 mp->action_index = clib_host_to_net_u32 (action);
21725 mp->appns_index = clib_host_to_net_u32 (appns_index);
21727 mp->is_add = is_add;
21730 clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
21731 clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
21735 clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
21736 clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
21740 clib_memcpy (mp->tag, tag, vec_len (tag));
21750 api_session_rules_dump (vat_main_t * vam)
21752 vl_api_session_rules_dump_t *mp;
21753 vl_api_control_ping_t *mp_ping;
21756 if (!vam->json_output)
21758 print (vam->ofp, "%=20s", "Session Rules");
21761 M (SESSION_RULES_DUMP, mp);
21765 /* Use a control ping for synchronization */
21766 MPING (CONTROL_PING, mp_ping);
21769 /* Wait for a reply... */
21775 api_ip_container_proxy_add_del (vat_main_t * vam)
21777 vl_api_ip_container_proxy_add_del_t *mp;
21778 unformat_input_t *i = vam->input;
21779 u32 sw_if_index = ~0;
21780 vl_api_prefix_t pfx = { };
21784 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21786 if (unformat (i, "del"))
21788 else if (unformat (i, "add"))
21790 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
21792 else if (unformat (i, "sw_if_index %u", &sw_if_index))
21797 if (sw_if_index == ~0 || pfx.address_length == 0)
21799 errmsg ("address and sw_if_index must be set");
21803 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
21805 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
21806 mp->is_add = is_add;
21807 clib_memcpy (&mp->pfx, &pfx, sizeof (pfx));
21815 api_qos_record_enable_disable (vat_main_t * vam)
21817 unformat_input_t *i = vam->input;
21818 vl_api_qos_record_enable_disable_t *mp;
21819 u32 sw_if_index, qs = 0xff;
21820 u8 sw_if_index_set = 0;
21824 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21826 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21827 sw_if_index_set = 1;
21828 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21829 sw_if_index_set = 1;
21830 else if (unformat (i, "%U", unformat_qos_source, &qs))
21832 else if (unformat (i, "disable"))
21836 clib_warning ("parse error '%U'", format_unformat_error, i);
21841 if (sw_if_index_set == 0)
21843 errmsg ("missing interface name or sw_if_index");
21848 errmsg ("input location must be specified");
21852 M (QOS_RECORD_ENABLE_DISABLE, mp);
21854 mp->sw_if_index = ntohl (sw_if_index);
21855 mp->input_source = qs;
21856 mp->enable = enable;
21865 q_or_quit (vat_main_t * vam)
21867 #if VPP_API_TEST_BUILTIN == 0
21868 longjmp (vam->jump_buf, 1);
21870 return 0; /* not so much */
21874 q (vat_main_t * vam)
21876 return q_or_quit (vam);
21880 quit (vat_main_t * vam)
21882 return q_or_quit (vam);
21886 comment (vat_main_t * vam)
21892 statseg (vat_main_t * vam)
21894 ssvm_private_t *ssvmp = &vam->stat_segment;
21895 ssvm_shared_header_t *shared_header = ssvmp->sh;
21896 vlib_counter_t **counters;
21897 u64 thread0_index1_packets;
21898 u64 thread0_index1_bytes;
21899 f64 vector_rate, input_rate;
21902 uword *counter_vector_by_name;
21903 if (vam->stat_segment_lockp == 0)
21905 errmsg ("Stat segment not mapped...");
21909 /* look up "/if/rx for sw_if_index 1 as a test */
21911 clib_spinlock_lock (vam->stat_segment_lockp);
21913 counter_vector_by_name = (uword *) shared_header->opaque[1];
21915 p = hash_get_mem (counter_vector_by_name, "/if/rx");
21918 clib_spinlock_unlock (vam->stat_segment_lockp);
21919 errmsg ("/if/tx not found?");
21923 /* Fish per-thread vector of combined counters from shared memory */
21924 counters = (vlib_counter_t **) p[0];
21926 if (vec_len (counters[0]) < 2)
21928 clib_spinlock_unlock (vam->stat_segment_lockp);
21929 errmsg ("/if/tx vector length %d", vec_len (counters[0]));
21933 /* Read thread 0 sw_if_index 1 counter */
21934 thread0_index1_packets = counters[0][1].packets;
21935 thread0_index1_bytes = counters[0][1].bytes;
21937 p = hash_get_mem (counter_vector_by_name, "vector_rate");
21940 clib_spinlock_unlock (vam->stat_segment_lockp);
21941 errmsg ("vector_rate not found?");
21945 vector_rate = *(f64 *) (p[0]);
21946 p = hash_get_mem (counter_vector_by_name, "input_rate");
21949 clib_spinlock_unlock (vam->stat_segment_lockp);
21950 errmsg ("input_rate not found?");
21953 input_rate = *(f64 *) (p[0]);
21955 clib_spinlock_unlock (vam->stat_segment_lockp);
21957 print (vam->ofp, "vector_rate %.2f input_rate %.2f",
21958 vector_rate, input_rate);
21959 print (vam->ofp, "thread 0 sw_if_index 1 rx pkts %lld, bytes %lld",
21960 thread0_index1_packets, thread0_index1_bytes);
21966 cmd_cmp (void *a1, void *a2)
21971 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
21975 help (vat_main_t * vam)
21980 unformat_input_t *i = vam->input;
21983 if (unformat (i, "%s", &name))
21987 vec_add1 (name, 0);
21989 hs = hash_get_mem (vam->help_by_name, name);
21991 print (vam->ofp, "usage: %s %s", name, hs[0]);
21993 print (vam->ofp, "No such msg / command '%s'", name);
21998 print (vam->ofp, "Help is available for the following:");
22001 hash_foreach_pair (p, vam->function_by_name,
22003 vec_add1 (cmds, (u8 *)(p->key));
22007 vec_sort_with_function (cmds, cmd_cmp);
22009 for (j = 0; j < vec_len (cmds); j++)
22010 print (vam->ofp, "%s", cmds[j]);
22017 set (vat_main_t * vam)
22019 u8 *name = 0, *value = 0;
22020 unformat_input_t *i = vam->input;
22022 if (unformat (i, "%s", &name))
22024 /* The input buffer is a vector, not a string. */
22025 value = vec_dup (i->buffer);
22026 vec_delete (value, i->index, 0);
22027 /* Almost certainly has a trailing newline */
22028 if (value[vec_len (value) - 1] == '\n')
22029 value[vec_len (value) - 1] = 0;
22030 /* Make sure it's a proper string, one way or the other */
22031 vec_add1 (value, 0);
22032 (void) clib_macro_set_value (&vam->macro_main,
22033 (char *) name, (char *) value);
22036 errmsg ("usage: set <name> <value>");
22044 unset (vat_main_t * vam)
22048 if (unformat (vam->input, "%s", &name))
22049 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
22050 errmsg ("unset: %s wasn't set", name);
22063 macro_sort_cmp (void *a1, void *a2)
22065 macro_sort_t *s1 = a1;
22066 macro_sort_t *s2 = a2;
22068 return strcmp ((char *) (s1->name), (char *) (s2->name));
22072 dump_macro_table (vat_main_t * vam)
22074 macro_sort_t *sort_me = 0, *sm;
22079 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
22081 vec_add2 (sort_me, sm, 1);
22082 sm->name = (u8 *)(p->key);
22083 sm->value = (u8 *) (p->value[0]);
22087 vec_sort_with_function (sort_me, macro_sort_cmp);
22089 if (vec_len (sort_me))
22090 print (vam->ofp, "%-15s%s", "Name", "Value");
22092 print (vam->ofp, "The macro table is empty...");
22094 for (i = 0; i < vec_len (sort_me); i++)
22095 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
22100 dump_node_table (vat_main_t * vam)
22103 vlib_node_t *node, *next_node;
22105 if (vec_len (vam->graph_nodes) == 0)
22107 print (vam->ofp, "Node table empty, issue get_node_graph...");
22111 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
22113 node = vam->graph_nodes[0][i];
22114 print (vam->ofp, "[%d] %s", i, node->name);
22115 for (j = 0; j < vec_len (node->next_nodes); j++)
22117 if (node->next_nodes[j] != ~0)
22119 next_node = vam->graph_nodes[0][node->next_nodes[j]];
22120 print (vam->ofp, " [%d] %s", j, next_node->name);
22128 value_sort_cmp (void *a1, void *a2)
22130 name_sort_t *n1 = a1;
22131 name_sort_t *n2 = a2;
22133 if (n1->value < n2->value)
22135 if (n1->value > n2->value)
22142 dump_msg_api_table (vat_main_t * vam)
22144 api_main_t *am = &api_main;
22145 name_sort_t *nses = 0, *ns;
22150 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
22152 vec_add2 (nses, ns, 1);
22153 ns->name = (u8 *)(hp->key);
22154 ns->value = (u32) hp->value[0];
22158 vec_sort_with_function (nses, value_sort_cmp);
22160 for (i = 0; i < vec_len (nses); i++)
22161 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
22167 get_msg_id (vat_main_t * vam)
22172 if (unformat (vam->input, "%s", &name_and_crc))
22174 message_index = vl_msg_api_get_msg_index (name_and_crc);
22175 if (message_index == ~0)
22177 print (vam->ofp, " '%s' not found", name_and_crc);
22180 print (vam->ofp, " '%s' has message index %d",
22181 name_and_crc, message_index);
22184 errmsg ("name_and_crc required...");
22189 search_node_table (vat_main_t * vam)
22191 unformat_input_t *line_input = vam->input;
22194 vlib_node_t *node, *next_node;
22197 if (vam->graph_node_index_by_name == 0)
22199 print (vam->ofp, "Node table empty, issue get_node_graph...");
22203 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
22205 if (unformat (line_input, "%s", &node_to_find))
22207 vec_add1 (node_to_find, 0);
22208 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
22211 print (vam->ofp, "%s not found...", node_to_find);
22214 node = vam->graph_nodes[0][p[0]];
22215 print (vam->ofp, "[%d] %s", p[0], node->name);
22216 for (j = 0; j < vec_len (node->next_nodes); j++)
22218 if (node->next_nodes[j] != ~0)
22220 next_node = vam->graph_nodes[0][node->next_nodes[j]];
22221 print (vam->ofp, " [%d] %s", j, next_node->name);
22228 clib_warning ("parse error '%U'", format_unformat_error,
22234 vec_free (node_to_find);
22243 script (vat_main_t * vam)
22245 #if (VPP_API_TEST_BUILTIN==0)
22247 char *save_current_file;
22248 unformat_input_t save_input;
22249 jmp_buf save_jump_buf;
22250 u32 save_line_number;
22252 FILE *new_fp, *save_ifp;
22254 if (unformat (vam->input, "%s", &s))
22256 new_fp = fopen ((char *) s, "r");
22259 errmsg ("Couldn't open script file %s", s);
22266 errmsg ("Missing script name");
22270 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
22271 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
22272 save_ifp = vam->ifp;
22273 save_line_number = vam->input_line_number;
22274 save_current_file = (char *) vam->current_file;
22276 vam->input_line_number = 0;
22278 vam->current_file = s;
22281 clib_memcpy (&vam->input, &save_input, sizeof (save_input));
22282 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
22283 vam->ifp = save_ifp;
22284 vam->input_line_number = save_line_number;
22285 vam->current_file = (u8 *) save_current_file;
22290 clib_warning ("use the exec command...");
22296 echo (vat_main_t * vam)
22298 print (vam->ofp, "%v", vam->input->buffer);
22302 /* List of API message constructors, CLI names map to api_xxx */
22303 #define foreach_vpe_api_msg \
22304 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
22305 _(sw_interface_dump,"") \
22306 _(sw_interface_set_flags, \
22307 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
22308 _(sw_interface_add_del_address, \
22309 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
22310 _(sw_interface_set_rx_mode, \
22311 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
22312 _(sw_interface_set_rx_placement, \
22313 "<intfc> | sw_if_index <id> [queue <id>] [worker <id> | main]") \
22314 _(sw_interface_rx_placement_dump, \
22315 "[<intfc> | sw_if_index <id>]") \
22316 _(sw_interface_set_table, \
22317 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
22318 _(sw_interface_set_mpls_enable, \
22319 "<intfc> | sw_if_index [disable | dis]") \
22320 _(sw_interface_set_vpath, \
22321 "<intfc> | sw_if_index <id> enable | disable") \
22322 _(sw_interface_set_vxlan_bypass, \
22323 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
22324 _(sw_interface_set_geneve_bypass, \
22325 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
22326 _(sw_interface_set_l2_xconnect, \
22327 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
22328 "enable | disable") \
22329 _(sw_interface_set_l2_bridge, \
22330 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
22331 "[shg <split-horizon-group>] [bvi]\n" \
22332 "enable | disable") \
22333 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
22334 _(bridge_domain_add_del, \
22335 "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") \
22336 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
22338 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
22339 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
22340 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
22342 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
22344 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
22346 "id <num> [hw-addr <mac-addr>] [host-ns <name>] [rx-ring-size <num> [tx-ring-size <num>]") \
22348 "<vpp-if-name> | sw_if_index <id>") \
22349 _(sw_interface_tap_v2_dump, "") \
22350 _(virtio_pci_create, \
22351 "pci-addr <pci-address> [use_random_mac | hw-addr <mac-addr>] [tx-ring-size <num> [rx-ring-size <num>] [features <hex-value>]") \
22352 _(virtio_pci_delete, \
22353 "<vpp-if-name> | sw_if_index <id>") \
22354 _(sw_interface_virtio_pci_dump, "") \
22356 "[hw-addr <mac-addr>] {round-robin | active-backup | " \
22357 "broadcast | {lacp | xor} [load-balance { l2 | l23 | l34 }]} " \
22360 "<vpp-if-name> | sw_if_index <id>") \
22362 "sw_if_index <n> bond <sw_if_index> [is_passive] [is_long_timeout]") \
22363 _(bond_detach_slave, \
22364 "sw_if_index <n>") \
22365 _(sw_interface_bond_dump, "") \
22366 _(sw_interface_slave_dump, \
22367 "<vpp-if-name> | sw_if_index <id>") \
22368 _(ip_table_add_del, \
22369 "table <n> [ipv6] [add | del]\n") \
22370 _(ip_add_del_route, \
22371 "<addr>/<mask> via <<addr>|<intfc>|sw_if_index <id>|via-label <n>>\n" \
22372 "[table-id <n>] [<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n"\
22373 "[weight <n>] [drop] [local] [classify <n>] [out-label <n>]\n" \
22374 "[multipath] [count <n>] [del]") \
22375 _(ip_mroute_add_del, \
22376 "<src> <grp>/<mask> [table-id <n>]\n" \
22377 "[<intfc> | sw_if_index <id>] [local] [del]") \
22378 _(mpls_table_add_del, \
22379 "table <n> [add | del]\n") \
22380 _(mpls_route_add_del, \
22381 "<label> <eos> via <addr | next-hop-table <n> | via-label <n> |\n" \
22382 "lookup-ip4-table <n> | lookup-in-ip6-table <n> |\n" \
22383 "l2-input-on <intfc> | l2-input-on sw_if_index <id>>\n" \
22384 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>] [weight <n>]\n" \
22385 "[drop] [local] [classify <n>] [out-label <n>] [multipath]\n" \
22386 "[count <n>] [del]") \
22387 _(mpls_ip_bind_unbind, \
22388 "<label> <addr/len>") \
22389 _(mpls_tunnel_add_del, \
22390 "[add | del <intfc | sw_if_index <id>>] via <addr | via-label <n>>\n" \
22391 "[<intfc> | sw_if_index <id> | next-hop-table <id>]\n" \
22392 "[l2-only] [out-label <n>]") \
22393 _(sr_mpls_policy_add, \
22394 "bsid <id> [weight <n>] [spray] next <sid> [next <sid>]") \
22395 _(sr_mpls_policy_del, \
22397 _(bier_table_add_del, \
22398 "<label> <sub-domain> <set> <bsl> [del]") \
22399 _(bier_route_add_del, \
22400 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
22401 "[<intfc> | sw_if_index <id>]" \
22402 "[weight <n>] [del] [multipath]") \
22403 _(proxy_arp_add_del, \
22404 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
22405 _(proxy_arp_intfc_enable_disable, \
22406 "<intfc> | sw_if_index <id> enable | disable") \
22407 _(sw_interface_set_unnumbered, \
22408 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
22409 _(ip_neighbor_add_del, \
22410 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
22411 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
22412 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
22413 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
22414 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
22415 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
22416 "[outer_vlan_id_any][inner_vlan_id_any]") \
22417 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
22418 _(reset_fib, "vrf <n> [ipv6]") \
22419 _(dhcp_proxy_config, \
22420 "svr <v46-address> src <v46-address>\n" \
22421 "rx_vrf_id <nn> server_vrf_id <nn> [del]") \
22422 _(dhcp_proxy_set_vss, \
22423 "tbl_id <n> [fib_id <n> oui <n> | vpn_ascii_id <text>] [ipv6] [del]") \
22424 _(dhcp_proxy_dump, "ip6") \
22425 _(dhcp_client_config, \
22426 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
22427 _(set_ip_flow_hash, \
22428 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
22429 _(sw_interface_ip6_enable_disable, \
22430 "<intfc> | sw_if_index <id> enable | disable") \
22431 _(ip6nd_proxy_add_del, \
22432 "<intfc> | sw_if_index <id> <ip6-address>") \
22433 _(ip6nd_proxy_dump, "") \
22434 _(sw_interface_ip6nd_ra_prefix, \
22435 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
22436 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
22437 "[nolink] [isno]") \
22438 _(sw_interface_ip6nd_ra_config, \
22439 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
22440 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
22441 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
22442 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
22443 _(l2_patch_add_del, \
22444 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
22445 "enable | disable") \
22446 _(sr_localsid_add_del, \
22447 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
22448 "fib-table <num> (end.psp) sw_if_index <num>") \
22449 _(classify_add_del_table, \
22450 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
22451 " [del] [del-chain] mask <mask-value>\n" \
22452 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
22453 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
22454 _(classify_add_del_session, \
22455 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
22456 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
22457 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
22458 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
22459 _(classify_set_interface_ip_table, \
22460 "<intfc> | sw_if_index <nn> table <nn>") \
22461 _(classify_set_interface_l2_tables, \
22462 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22463 " [other-table <nn>]") \
22464 _(get_node_index, "node <node-name") \
22465 _(add_node_next, "node <node-name> next <next-node-name>") \
22466 _(l2tpv3_create_tunnel, \
22467 "client_address <ip6-addr> our_address <ip6-addr>\n" \
22468 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
22469 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
22470 _(l2tpv3_set_tunnel_cookies, \
22471 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
22472 "[new_remote_cookie <nn>]\n") \
22473 _(l2tpv3_interface_enable_disable, \
22474 "<intfc> | sw_if_index <nn> enable | disable") \
22475 _(l2tpv3_set_lookup_key, \
22476 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
22477 _(sw_if_l2tpv3_tunnel_dump, "") \
22478 _(vxlan_offload_rx, \
22479 "hw { <interface name> | hw_if_index <nn>} " \
22480 "rx { <vxlan tunnel name> | sw_if_index <nn> } [del]") \
22481 _(vxlan_add_del_tunnel, \
22482 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
22483 "{ <intfc> | mcast_sw_if_index <nn> } [instance <id>]}\n" \
22484 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
22485 _(geneve_add_del_tunnel, \
22486 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
22487 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22488 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
22489 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22490 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22491 _(gre_tunnel_add_del, \
22492 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [instance <n>]\n" \
22493 "[teb | erspan <session-id>] [del]") \
22494 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22495 _(l2_fib_clear_table, "") \
22496 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
22497 _(l2_interface_vlan_tag_rewrite, \
22498 "<intfc> | sw_if_index <nn> \n" \
22499 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
22500 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
22501 _(create_vhost_user_if, \
22502 "socket <filename> [server] [renumber <dev_instance>] " \
22503 "[disable_mrg_rxbuf] [disable_indirect_desc] " \
22504 "[mac <mac_address>]") \
22505 _(modify_vhost_user_if, \
22506 "<intfc> | sw_if_index <nn> socket <filename>\n" \
22507 "[server] [renumber <dev_instance>]") \
22508 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
22509 _(sw_interface_vhost_user_dump, "") \
22510 _(show_version, "") \
22511 _(show_threads, "") \
22512 _(vxlan_gpe_add_del_tunnel, \
22513 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
22514 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22515 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
22516 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
22517 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22518 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
22519 _(interface_name_renumber, \
22520 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
22521 _(input_acl_set_interface, \
22522 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22523 " [l2-table <nn>] [del]") \
22524 _(ip_probe_neighbor, "(<intc> | sw_if_index <nn>) address <ip4|ip6-addr>") \
22525 _(ip_scan_neighbor_enable_disable, "[ip4|ip6|both|disable] [interval <n-min>]\n" \
22526 " [max-time <n-usec>] [max-update <n>] [delay <n-msec>] [stale <n-min>]") \
22527 _(want_ip4_arp_events, "address <ip4-address> [del]") \
22528 _(want_ip6_nd_events, "address <ip6-address> [del]") \
22529 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
22530 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
22531 _(ip_dump, "ipv4 | ipv6") \
22532 _(ipsec_spd_add_del, "spd_id <n> [del]") \
22533 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
22535 _(ipsec_sad_entry_add_del, "sad_id <n> spi <n> crypto_alg <alg>\n" \
22536 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
22537 " integ_alg <alg> integ_key <hex>") \
22538 _(ipsec_spd_entry_add_del, "spd_id <n> priority <n> action <action>\n" \
22539 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
22540 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
22541 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
22542 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
22543 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
22544 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
22545 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
22546 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n" \
22547 " [instance <n>]") \
22548 _(ipsec_sa_dump, "[sa_id <n>]") \
22549 _(ipsec_tunnel_if_set_key, "<intfc> <local|remote> <crypto|integ>\n" \
22550 " <alg> <hex>\n") \
22551 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
22552 _(delete_loopback,"sw_if_index <nn>") \
22553 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
22554 _(bd_ip_mac_flush, "bd_id <bridge-domain-id>") \
22555 _(bd_ip_mac_dump, "[bd_id] <bridge-domain-id>") \
22556 _(want_interface_events, "enable|disable") \
22557 _(get_first_msg_id, "client <name>") \
22558 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
22559 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
22560 "fib-id <nn> [ip4][ip6][default]") \
22561 _(get_node_graph, " ") \
22562 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
22563 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
22564 _(ioam_disable, "") \
22565 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
22566 " sw_if_index <sw_if_index> p <priority> " \
22567 "w <weight>] [del]") \
22568 _(one_add_del_locator, "locator-set <locator_name> " \
22569 "iface <intf> | sw_if_index <sw_if_index> " \
22570 "p <priority> w <weight> [del]") \
22571 _(one_add_del_local_eid,"vni <vni> eid " \
22572 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22573 "locator-set <locator_name> [del]" \
22574 "[key-id sha1|sha256 secret-key <secret-key>]")\
22575 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
22576 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
22577 _(one_enable_disable, "enable|disable") \
22578 _(one_map_register_enable_disable, "enable|disable") \
22579 _(one_map_register_fallback_threshold, "<value>") \
22580 _(one_rloc_probe_enable_disable, "enable|disable") \
22581 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22583 "rloc <locator> p <prio> " \
22584 "w <weight> [rloc <loc> ... ] " \
22585 "action <action> [del-all]") \
22586 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22588 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22589 _(one_use_petr, "ip-address> | disable") \
22590 _(one_map_request_mode, "src-dst|dst-only") \
22591 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22592 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22593 _(one_locator_set_dump, "[local | remote]") \
22594 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
22595 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22596 "[local] | [remote]") \
22597 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
22598 _(one_ndp_bd_get, "") \
22599 _(one_ndp_entries_get, "bd <bridge-domain>") \
22600 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
22601 _(one_l2_arp_bd_get, "") \
22602 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
22603 _(one_stats_enable_disable, "enable|disable") \
22604 _(show_one_stats_enable_disable, "") \
22605 _(one_eid_table_vni_dump, "") \
22606 _(one_eid_table_map_dump, "l2|l3") \
22607 _(one_map_resolver_dump, "") \
22608 _(one_map_server_dump, "") \
22609 _(one_adjacencies_get, "vni <vni>") \
22610 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
22611 _(show_one_rloc_probe_state, "") \
22612 _(show_one_map_register_state, "") \
22613 _(show_one_status, "") \
22614 _(one_stats_dump, "") \
22615 _(one_stats_flush, "") \
22616 _(one_get_map_request_itr_rlocs, "") \
22617 _(one_map_register_set_ttl, "<ttl>") \
22618 _(one_set_transport_protocol, "udp|api") \
22619 _(one_get_transport_protocol, "") \
22620 _(one_enable_disable_xtr_mode, "enable|disable") \
22621 _(one_show_xtr_mode, "") \
22622 _(one_enable_disable_pitr_mode, "enable|disable") \
22623 _(one_show_pitr_mode, "") \
22624 _(one_enable_disable_petr_mode, "enable|disable") \
22625 _(one_show_petr_mode, "") \
22626 _(show_one_nsh_mapping, "") \
22627 _(show_one_pitr, "") \
22628 _(show_one_use_petr, "") \
22629 _(show_one_map_request_mode, "") \
22630 _(show_one_map_register_ttl, "") \
22631 _(show_one_map_register_fallback_threshold, "") \
22632 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
22633 " sw_if_index <sw_if_index> p <priority> " \
22634 "w <weight>] [del]") \
22635 _(lisp_add_del_locator, "locator-set <locator_name> " \
22636 "iface <intf> | sw_if_index <sw_if_index> " \
22637 "p <priority> w <weight> [del]") \
22638 _(lisp_add_del_local_eid,"vni <vni> eid " \
22639 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22640 "locator-set <locator_name> [del]" \
22641 "[key-id sha1|sha256 secret-key <secret-key>]") \
22642 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
22643 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
22644 _(lisp_enable_disable, "enable|disable") \
22645 _(lisp_map_register_enable_disable, "enable|disable") \
22646 _(lisp_rloc_probe_enable_disable, "enable|disable") \
22647 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22649 "rloc <locator> p <prio> " \
22650 "w <weight> [rloc <loc> ... ] " \
22651 "action <action> [del-all]") \
22652 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22654 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22655 _(lisp_use_petr, "<ip-address> | disable") \
22656 _(lisp_map_request_mode, "src-dst|dst-only") \
22657 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22658 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22659 _(lisp_locator_set_dump, "[local | remote]") \
22660 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
22661 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22662 "[local] | [remote]") \
22663 _(lisp_eid_table_vni_dump, "") \
22664 _(lisp_eid_table_map_dump, "l2|l3") \
22665 _(lisp_map_resolver_dump, "") \
22666 _(lisp_map_server_dump, "") \
22667 _(lisp_adjacencies_get, "vni <vni>") \
22668 _(gpe_fwd_entry_vnis_get, "") \
22669 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
22670 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
22671 "[table <table-id>]") \
22672 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
22673 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
22674 _(gpe_set_encap_mode, "lisp|vxlan") \
22675 _(gpe_get_encap_mode, "") \
22676 _(lisp_gpe_add_del_iface, "up|down") \
22677 _(lisp_gpe_enable_disable, "enable|disable") \
22678 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
22679 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
22680 _(show_lisp_rloc_probe_state, "") \
22681 _(show_lisp_map_register_state, "") \
22682 _(show_lisp_status, "") \
22683 _(lisp_get_map_request_itr_rlocs, "") \
22684 _(show_lisp_pitr, "") \
22685 _(show_lisp_use_petr, "") \
22686 _(show_lisp_map_request_mode, "") \
22687 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
22688 _(af_packet_delete, "name <host interface name>") \
22689 _(af_packet_dump, "") \
22690 _(policer_add_del, "name <policer name> <params> [del]") \
22691 _(policer_dump, "[name <policer name>]") \
22692 _(policer_classify_set_interface, \
22693 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22694 " [l2-table <nn>] [del]") \
22695 _(policer_classify_dump, "type [ip4|ip6|l2]") \
22696 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
22697 "[master|slave]") \
22698 _(netmap_delete, "name <interface name>") \
22699 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
22700 _(mpls_fib_dump, "") \
22701 _(classify_table_ids, "") \
22702 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
22703 _(classify_table_info, "table_id <nn>") \
22704 _(classify_session_dump, "table_id <nn>") \
22705 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
22706 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
22707 "[template_interval <nn>] [udp_checksum]") \
22708 _(ipfix_exporter_dump, "") \
22709 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
22710 _(ipfix_classify_stream_dump, "") \
22711 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
22712 _(ipfix_classify_table_dump, "") \
22713 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
22714 _(sw_interface_span_dump, "[l2]") \
22715 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
22716 _(pg_create_interface, "if_id <nn>") \
22717 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
22718 _(pg_enable_disable, "[stream <id>] disable") \
22719 _(ip_source_and_port_range_check_add_del, \
22720 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
22721 _(ip_source_and_port_range_check_interface_add_del, \
22722 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
22723 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
22724 _(ipsec_gre_tunnel_add_del, \
22725 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
22726 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
22727 _(delete_subif,"<intfc> | sw_if_index <nn>") \
22728 _(l2_interface_pbb_tag_rewrite, \
22729 "<intfc> | sw_if_index <nn> \n" \
22730 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
22731 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
22732 _(set_punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
22733 _(flow_classify_set_interface, \
22734 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
22735 _(flow_classify_dump, "type [ip4|ip6]") \
22736 _(ip_fib_dump, "") \
22737 _(ip_mfib_dump, "") \
22738 _(ip6_fib_dump, "") \
22739 _(ip6_mfib_dump, "") \
22740 _(feature_enable_disable, "arc_name <arc_name> " \
22741 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
22742 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
22744 _(l2_xconnect_dump, "") \
22745 _(hw_interface_set_mtu, "<intfc> | hw_if_index <nn> mtu <nn>") \
22746 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
22747 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
22748 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
22749 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
22750 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
22751 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
22752 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
22753 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
22754 _(sock_init_shm, "size <nnn>") \
22755 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
22756 _(dns_enable_disable, "[enable][disable]") \
22757 _(dns_name_server_add_del, "<ip-address> [del]") \
22758 _(dns_resolve_name, "<hostname>") \
22759 _(dns_resolve_ip, "<ip4|ip6>") \
22760 _(dns_name_server_add_del, "<ip-address> [del]") \
22761 _(dns_resolve_name, "<hostname>") \
22762 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
22763 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
22764 _(session_rules_dump, "") \
22765 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
22766 _(output_acl_set_interface, \
22767 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22768 " [l2-table <nn>] [del]") \
22769 _(qos_record_enable_disable, "<record-source> <intfc> | sw_if_index <id> [disable]")
22771 /* List of command functions, CLI names map directly to functions */
22772 #define foreach_cli_function \
22773 _(comment, "usage: comment <ignore-rest-of-line>") \
22774 _(dump_interface_table, "usage: dump_interface_table") \
22775 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
22776 _(dump_ipv4_table, "usage: dump_ipv4_table") \
22777 _(dump_ipv6_table, "usage: dump_ipv6_table") \
22778 _(dump_macro_table, "usage: dump_macro_table ") \
22779 _(dump_node_table, "usage: dump_node_table") \
22780 _(dump_msg_api_table, "usage: dump_msg_api_table") \
22781 _(get_msg_id, "usage: get_msg_id name_and_crc") \
22782 _(echo, "usage: echo <message>") \
22783 _(exec, "usage: exec <vpe-debug-CLI-command>") \
22784 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
22785 _(help, "usage: help") \
22786 _(q, "usage: quit") \
22787 _(quit, "usage: quit") \
22788 _(search_node_table, "usage: search_node_table <name>...") \
22789 _(set, "usage: set <variable-name> <value>") \
22790 _(script, "usage: script <file-name>") \
22791 _(statseg, "usage: statseg"); \
22792 _(unset, "usage: unset <variable-name>")
22795 static void vl_api_##n##_t_handler_uni \
22796 (vl_api_##n##_t * mp) \
22798 vat_main_t * vam = &vat_main; \
22799 if (vam->json_output) { \
22800 vl_api_##n##_t_handler_json(mp); \
22802 vl_api_##n##_t_handler(mp); \
22805 foreach_vpe_api_reply_msg;
22806 #if VPP_API_TEST_BUILTIN == 0
22807 foreach_standalone_reply_msg;
22812 vat_api_hookup (vat_main_t * vam)
22815 vl_msg_api_set_handlers(VL_API_##N, #n, \
22816 vl_api_##n##_t_handler_uni, \
22818 vl_api_##n##_t_endian, \
22819 vl_api_##n##_t_print, \
22820 sizeof(vl_api_##n##_t), 1);
22821 foreach_vpe_api_reply_msg;
22822 #if VPP_API_TEST_BUILTIN == 0
22823 foreach_standalone_reply_msg;
22827 #if (VPP_API_TEST_BUILTIN==0)
22828 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
22830 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
22832 vam->function_by_name = hash_create_string (0, sizeof (uword));
22834 vam->help_by_name = hash_create_string (0, sizeof (uword));
22837 /* API messages we can send */
22838 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
22839 foreach_vpe_api_msg;
22843 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
22844 foreach_vpe_api_msg;
22847 /* CLI functions */
22848 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
22849 foreach_cli_function;
22853 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
22854 foreach_cli_function;
22858 #if VPP_API_TEST_BUILTIN
22859 static clib_error_t *
22860 vat_api_hookup_shim (vlib_main_t * vm)
22862 vat_api_hookup (&vat_main);
22866 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
22870 * fd.io coding-style-patch-verification: ON
22873 * eval: (c-set-style "gnu")