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 _(reset_fib_reply) \
5174 _(dhcp_proxy_config_reply) \
5175 _(dhcp_proxy_set_vss_reply) \
5176 _(dhcp_client_config_reply) \
5177 _(set_ip_flow_hash_reply) \
5178 _(sw_interface_ip6_enable_disable_reply) \
5179 _(ip6nd_proxy_add_del_reply) \
5180 _(sw_interface_ip6nd_ra_prefix_reply) \
5181 _(sw_interface_ip6nd_ra_config_reply) \
5182 _(set_arp_neighbor_limit_reply) \
5183 _(l2_patch_add_del_reply) \
5184 _(sr_mpls_policy_add_reply) \
5185 _(sr_mpls_policy_mod_reply) \
5186 _(sr_mpls_policy_del_reply) \
5187 _(sr_policy_add_reply) \
5188 _(sr_policy_mod_reply) \
5189 _(sr_policy_del_reply) \
5190 _(sr_localsid_add_del_reply) \
5191 _(sr_steering_add_del_reply) \
5192 _(classify_add_del_session_reply) \
5193 _(classify_set_interface_ip_table_reply) \
5194 _(classify_set_interface_l2_tables_reply) \
5195 _(l2tpv3_set_tunnel_cookies_reply) \
5196 _(l2tpv3_interface_enable_disable_reply) \
5197 _(l2tpv3_set_lookup_key_reply) \
5198 _(l2_fib_clear_table_reply) \
5199 _(l2_interface_efp_filter_reply) \
5200 _(l2_interface_vlan_tag_rewrite_reply) \
5201 _(modify_vhost_user_if_reply) \
5202 _(delete_vhost_user_if_reply) \
5203 _(ip_probe_neighbor_reply) \
5204 _(ip_scan_neighbor_enable_disable_reply) \
5205 _(want_ip4_arp_events_reply) \
5206 _(want_ip6_nd_events_reply) \
5207 _(want_l2_macs_events_reply) \
5208 _(input_acl_set_interface_reply) \
5209 _(ipsec_spd_add_del_reply) \
5210 _(ipsec_interface_add_del_spd_reply) \
5211 _(ipsec_spd_entry_add_del_reply) \
5212 _(ipsec_sad_entry_add_del_reply) \
5213 _(ipsec_sa_set_key_reply) \
5214 _(ipsec_tunnel_if_add_del_reply) \
5215 _(ipsec_tunnel_if_set_key_reply) \
5216 _(ipsec_tunnel_if_set_sa_reply) \
5217 _(delete_loopback_reply) \
5218 _(bd_ip_mac_add_del_reply) \
5219 _(bd_ip_mac_flush_reply) \
5220 _(want_interface_events_reply) \
5221 _(cop_interface_enable_disable_reply) \
5222 _(cop_whitelist_enable_disable_reply) \
5223 _(sw_interface_clear_stats_reply) \
5224 _(ioam_enable_reply) \
5225 _(ioam_disable_reply) \
5226 _(one_add_del_locator_reply) \
5227 _(one_add_del_local_eid_reply) \
5228 _(one_add_del_remote_mapping_reply) \
5229 _(one_add_del_adjacency_reply) \
5230 _(one_add_del_map_resolver_reply) \
5231 _(one_add_del_map_server_reply) \
5232 _(one_enable_disable_reply) \
5233 _(one_rloc_probe_enable_disable_reply) \
5234 _(one_map_register_enable_disable_reply) \
5235 _(one_map_register_set_ttl_reply) \
5236 _(one_set_transport_protocol_reply) \
5237 _(one_map_register_fallback_threshold_reply) \
5238 _(one_pitr_set_locator_set_reply) \
5239 _(one_map_request_mode_reply) \
5240 _(one_add_del_map_request_itr_rlocs_reply) \
5241 _(one_eid_table_add_del_map_reply) \
5242 _(one_use_petr_reply) \
5243 _(one_stats_enable_disable_reply) \
5244 _(one_add_del_l2_arp_entry_reply) \
5245 _(one_add_del_ndp_entry_reply) \
5246 _(one_stats_flush_reply) \
5247 _(one_enable_disable_xtr_mode_reply) \
5248 _(one_enable_disable_pitr_mode_reply) \
5249 _(one_enable_disable_petr_mode_reply) \
5250 _(gpe_enable_disable_reply) \
5251 _(gpe_set_encap_mode_reply) \
5252 _(gpe_add_del_iface_reply) \
5253 _(gpe_add_del_native_fwd_rpath_reply) \
5254 _(af_packet_delete_reply) \
5255 _(policer_classify_set_interface_reply) \
5256 _(netmap_create_reply) \
5257 _(netmap_delete_reply) \
5258 _(set_ipfix_exporter_reply) \
5259 _(set_ipfix_classify_stream_reply) \
5260 _(ipfix_classify_table_add_del_reply) \
5261 _(flow_classify_set_interface_reply) \
5262 _(sw_interface_span_enable_disable_reply) \
5263 _(pg_capture_reply) \
5264 _(pg_enable_disable_reply) \
5265 _(ip_source_and_port_range_check_add_del_reply) \
5266 _(ip_source_and_port_range_check_interface_add_del_reply)\
5267 _(delete_subif_reply) \
5268 _(l2_interface_pbb_tag_rewrite_reply) \
5270 _(feature_enable_disable_reply) \
5271 _(sw_interface_tag_add_del_reply) \
5272 _(hw_interface_set_mtu_reply) \
5273 _(p2p_ethernet_add_reply) \
5274 _(p2p_ethernet_del_reply) \
5275 _(lldp_config_reply) \
5276 _(sw_interface_set_lldp_reply) \
5277 _(tcp_configure_src_addresses_reply) \
5278 _(dns_enable_disable_reply) \
5279 _(dns_name_server_add_del_reply) \
5280 _(session_rule_add_del_reply) \
5281 _(ip_container_proxy_add_del_reply) \
5282 _(output_acl_set_interface_reply) \
5283 _(qos_record_enable_disable_reply)
5286 static void vl_api_##n##_t_handler \
5287 (vl_api_##n##_t * mp) \
5289 vat_main_t * vam = &vat_main; \
5290 i32 retval = ntohl(mp->retval); \
5291 if (vam->async_mode) { \
5292 vam->async_errors += (retval < 0); \
5294 vam->retval = retval; \
5295 vam->result_ready = 1; \
5298 foreach_standard_reply_retval_handler;
5302 static void vl_api_##n##_t_handler_json \
5303 (vl_api_##n##_t * mp) \
5305 vat_main_t * vam = &vat_main; \
5306 vat_json_node_t node; \
5307 vat_json_init_object(&node); \
5308 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
5309 vat_json_print(vam->ofp, &node); \
5310 vam->retval = ntohl(mp->retval); \
5311 vam->result_ready = 1; \
5313 foreach_standard_reply_retval_handler;
5317 * Table of message reply handlers, must include boilerplate handlers
5321 #define foreach_vpe_api_reply_msg \
5322 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
5323 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
5324 _(SW_INTERFACE_DETAILS, sw_interface_details) \
5325 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
5326 _(CONTROL_PING_REPLY, control_ping_reply) \
5327 _(CLI_REPLY, cli_reply) \
5328 _(CLI_INBAND_REPLY, cli_inband_reply) \
5329 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
5330 sw_interface_add_del_address_reply) \
5331 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
5332 _(SW_INTERFACE_SET_RX_PLACEMENT_REPLY, sw_interface_set_rx_placement_reply) \
5333 _(SW_INTERFACE_RX_PLACEMENT_DETAILS, sw_interface_rx_placement_details) \
5334 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
5335 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
5336 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
5337 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
5338 _(SW_INTERFACE_SET_GENEVE_BYPASS_REPLY, sw_interface_set_geneve_bypass_reply) \
5339 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
5340 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
5341 sw_interface_set_l2_xconnect_reply) \
5342 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
5343 sw_interface_set_l2_bridge_reply) \
5344 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
5345 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
5346 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
5347 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
5348 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
5349 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
5350 _(L2_FLAGS_REPLY, l2_flags_reply) \
5351 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
5352 _(TAP_CREATE_V2_REPLY, tap_create_v2_reply) \
5353 _(TAP_DELETE_V2_REPLY, tap_delete_v2_reply) \
5354 _(SW_INTERFACE_TAP_V2_DETAILS, sw_interface_tap_v2_details) \
5355 _(VIRTIO_PCI_CREATE_REPLY, virtio_pci_create_reply) \
5356 _(VIRTIO_PCI_DELETE_REPLY, virtio_pci_delete_reply) \
5357 _(SW_INTERFACE_VIRTIO_PCI_DETAILS, sw_interface_virtio_pci_details) \
5358 _(BOND_CREATE_REPLY, bond_create_reply) \
5359 _(BOND_DELETE_REPLY, bond_delete_reply) \
5360 _(BOND_ENSLAVE_REPLY, bond_enslave_reply) \
5361 _(BOND_DETACH_SLAVE_REPLY, bond_detach_slave_reply) \
5362 _(SW_INTERFACE_BOND_DETAILS, sw_interface_bond_details) \
5363 _(SW_INTERFACE_SLAVE_DETAILS, sw_interface_slave_details) \
5364 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
5365 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
5366 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
5367 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
5368 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
5369 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
5370 _(BIER_ROUTE_ADD_DEL_REPLY, bier_route_add_del_reply) \
5371 _(BIER_TABLE_ADD_DEL_REPLY, bier_table_add_del_reply) \
5372 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
5373 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
5374 proxy_arp_intfc_enable_disable_reply) \
5375 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
5376 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
5377 sw_interface_set_unnumbered_reply) \
5378 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
5379 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
5380 _(CREATE_SUBIF_REPLY, create_subif_reply) \
5381 _(RESET_FIB_REPLY, reset_fib_reply) \
5382 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
5383 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
5384 _(DHCP_PROXY_DETAILS, dhcp_proxy_details) \
5385 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
5386 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
5387 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
5388 sw_interface_ip6_enable_disable_reply) \
5389 _(IP6ND_PROXY_ADD_DEL_REPLY, ip6nd_proxy_add_del_reply) \
5390 _(IP6ND_PROXY_DETAILS, ip6nd_proxy_details) \
5391 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
5392 sw_interface_ip6nd_ra_prefix_reply) \
5393 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
5394 sw_interface_ip6nd_ra_config_reply) \
5395 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
5396 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
5397 _(SR_MPLS_POLICY_ADD_REPLY, sr_mpls_policy_add_reply) \
5398 _(SR_MPLS_POLICY_MOD_REPLY, sr_mpls_policy_mod_reply) \
5399 _(SR_MPLS_POLICY_DEL_REPLY, sr_mpls_policy_del_reply) \
5400 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
5401 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
5402 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
5403 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
5404 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
5405 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
5406 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
5407 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
5408 classify_set_interface_ip_table_reply) \
5409 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
5410 classify_set_interface_l2_tables_reply) \
5411 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
5412 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
5413 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
5414 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
5415 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
5416 l2tpv3_interface_enable_disable_reply) \
5417 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
5418 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
5419 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
5420 _(VXLAN_OFFLOAD_RX_REPLY, vxlan_offload_rx_reply) \
5421 _(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
5422 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
5423 _(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
5424 _(GRE_TUNNEL_ADD_DEL_REPLY, gre_tunnel_add_del_reply) \
5425 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
5426 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
5427 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
5428 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
5429 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
5430 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
5431 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
5432 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
5433 _(SHOW_VERSION_REPLY, show_version_reply) \
5434 _(SHOW_THREADS_REPLY, show_threads_reply) \
5435 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
5436 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
5437 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
5438 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
5439 _(IP_PROBE_NEIGHBOR_REPLY, ip_probe_neighbor_reply) \
5440 _(IP_SCAN_NEIGHBOR_ENABLE_DISABLE_REPLY, ip_scan_neighbor_enable_disable_reply) \
5441 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
5442 _(IP4_ARP_EVENT, ip4_arp_event) \
5443 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
5444 _(IP6_ND_EVENT, ip6_nd_event) \
5445 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
5446 _(L2_MACS_EVENT, l2_macs_event) \
5447 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
5448 _(IP_ADDRESS_DETAILS, ip_address_details) \
5449 _(IP_DETAILS, ip_details) \
5450 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
5451 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
5452 _(IPSEC_SPD_ENTRY_ADD_DEL_REPLY, ipsec_spd_entry_add_del_reply) \
5453 _(IPSEC_SAD_ENTRY_ADD_DEL_REPLY, ipsec_sad_entry_add_del_reply) \
5454 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
5455 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
5456 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
5457 _(IPSEC_TUNNEL_IF_SET_KEY_REPLY, ipsec_tunnel_if_set_key_reply) \
5458 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
5459 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
5460 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
5461 _(BD_IP_MAC_FLUSH_REPLY, bd_ip_mac_flush_reply) \
5462 _(BD_IP_MAC_DETAILS, bd_ip_mac_details) \
5463 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
5464 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
5465 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
5466 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
5467 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
5468 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
5469 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
5470 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
5471 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
5472 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
5473 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
5474 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
5475 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
5476 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
5477 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
5478 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
5479 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
5480 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
5481 one_map_register_enable_disable_reply) \
5482 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
5483 _(ONE_SET_TRANSPORT_PROTOCOL_REPLY, one_set_transport_protocol_reply) \
5484 _(ONE_GET_TRANSPORT_PROTOCOL_REPLY, one_get_transport_protocol_reply) \
5485 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5486 one_map_register_fallback_threshold_reply) \
5487 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
5488 one_rloc_probe_enable_disable_reply) \
5489 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
5490 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
5491 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
5492 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
5493 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
5494 _(ONE_LOCATOR_DETAILS, one_locator_details) \
5495 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
5496 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
5497 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
5498 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
5499 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
5500 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
5501 _(ONE_STATS_DETAILS, one_stats_details) \
5502 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
5503 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
5504 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
5505 show_one_stats_enable_disable_reply) \
5506 _(ONE_ADD_DEL_NDP_ENTRY_REPLY, one_add_del_ndp_entry_reply) \
5507 _(ONE_NDP_BD_GET_REPLY, one_ndp_bd_get_reply) \
5508 _(ONE_NDP_ENTRIES_GET_REPLY, one_ndp_entries_get_reply) \
5509 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
5510 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
5511 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
5512 _(ONE_ENABLE_DISABLE_XTR_MODE_REPLY, one_enable_disable_xtr_mode_reply) \
5513 _(ONE_ENABLE_DISABLE_PITR_MODE_REPLY, \
5514 one_enable_disable_pitr_mode_reply) \
5515 _(ONE_ENABLE_DISABLE_PETR_MODE_REPLY, \
5516 one_enable_disable_petr_mode_reply) \
5517 _(ONE_SHOW_XTR_MODE_REPLY, one_show_xtr_mode_reply) \
5518 _(ONE_SHOW_PITR_MODE_REPLY, one_show_pitr_mode_reply) \
5519 _(ONE_SHOW_PETR_MODE_REPLY, one_show_petr_mode_reply) \
5520 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
5521 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
5522 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
5523 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
5524 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
5525 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
5526 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
5527 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
5528 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
5529 gpe_add_del_native_fwd_rpath_reply) \
5530 _(GPE_FWD_ENTRY_PATH_DETAILS, \
5531 gpe_fwd_entry_path_details) \
5532 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
5533 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
5534 one_add_del_map_request_itr_rlocs_reply) \
5535 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
5536 one_get_map_request_itr_rlocs_reply) \
5537 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
5538 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
5539 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
5540 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
5541 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
5542 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
5543 show_one_map_register_state_reply) \
5544 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
5545 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5546 show_one_map_register_fallback_threshold_reply) \
5547 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
5548 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
5549 _(AF_PACKET_DETAILS, af_packet_details) \
5550 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
5551 _(POLICER_DETAILS, policer_details) \
5552 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
5553 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
5554 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
5555 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
5556 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
5557 _(MPLS_FIB_DETAILS, mpls_fib_details) \
5558 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
5559 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
5560 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
5561 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
5562 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
5563 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
5564 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
5565 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5566 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5567 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5568 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5569 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5570 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5571 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5572 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5573 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5574 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5575 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5576 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5577 ip_source_and_port_range_check_add_del_reply) \
5578 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5579 ip_source_and_port_range_check_interface_add_del_reply) \
5580 _(IPSEC_GRE_TUNNEL_ADD_DEL_REPLY, ipsec_gre_tunnel_add_del_reply) \
5581 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
5582 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5583 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5584 _(SET_PUNT_REPLY, set_punt_reply) \
5585 _(IP_FIB_DETAILS, ip_fib_details) \
5586 _(IP6_FIB_DETAILS, ip6_fib_details) \
5587 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5588 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5589 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5590 _(HW_INTERFACE_SET_MTU_REPLY, hw_interface_set_mtu_reply) \
5591 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
5592 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5593 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5594 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5595 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5596 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply) \
5597 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
5598 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
5599 _(DNS_ENABLE_DISABLE_REPLY, dns_enable_disable_reply) \
5600 _(DNS_NAME_SERVER_ADD_DEL_REPLY, dns_name_server_add_del_reply) \
5601 _(DNS_RESOLVE_NAME_REPLY, dns_resolve_name_reply) \
5602 _(DNS_RESOLVE_IP_REPLY, dns_resolve_ip_reply) \
5603 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
5604 _(SESSION_RULES_DETAILS, session_rules_details) \
5605 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
5606 _(OUTPUT_ACL_SET_INTERFACE_REPLY, output_acl_set_interface_reply) \
5607 _(QOS_RECORD_ENABLE_DISABLE_REPLY, qos_record_enable_disable_reply)
5609 #define foreach_standalone_reply_msg \
5610 _(SW_INTERFACE_EVENT, sw_interface_event)
5618 #define STR_VTR_OP_CASE(op) \
5619 case L2_VTR_ ## op: \
5623 str_vtr_op (u32 vtr_op)
5627 STR_VTR_OP_CASE (DISABLED);
5628 STR_VTR_OP_CASE (PUSH_1);
5629 STR_VTR_OP_CASE (PUSH_2);
5630 STR_VTR_OP_CASE (POP_1);
5631 STR_VTR_OP_CASE (POP_2);
5632 STR_VTR_OP_CASE (TRANSLATE_1_1);
5633 STR_VTR_OP_CASE (TRANSLATE_1_2);
5634 STR_VTR_OP_CASE (TRANSLATE_2_1);
5635 STR_VTR_OP_CASE (TRANSLATE_2_2);
5642 dump_sub_interface_table (vat_main_t * vam)
5644 const sw_interface_subif_t *sub = NULL;
5646 if (vam->json_output)
5649 ("JSON output supported only for VPE API calls and dump_stats_table");
5654 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5655 "Interface", "sw_if_index",
5656 "sub id", "dot1ad", "tags", "outer id",
5657 "inner id", "exact", "default", "outer any", "inner any");
5659 vec_foreach (sub, vam->sw_if_subif_table)
5662 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5663 sub->interface_name,
5665 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5666 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5667 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5668 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5669 if (sub->vtr_op != L2_VTR_DISABLED)
5672 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
5673 "tag1: %d tag2: %d ]",
5674 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
5675 sub->vtr_tag1, sub->vtr_tag2);
5683 name_sort_cmp (void *a1, void *a2)
5685 name_sort_t *n1 = a1;
5686 name_sort_t *n2 = a2;
5688 return strcmp ((char *) n1->name, (char *) n2->name);
5692 dump_interface_table (vat_main_t * vam)
5695 name_sort_t *nses = 0, *ns;
5697 if (vam->json_output)
5700 ("JSON output supported only for VPE API calls and dump_stats_table");
5705 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5707 vec_add2 (nses, ns, 1);
5708 ns->name = (u8 *)(p->key);
5709 ns->value = (u32) p->value[0];
5713 vec_sort_with_function (nses, name_sort_cmp);
5715 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
5716 vec_foreach (ns, nses)
5718 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
5725 dump_ip_table (vat_main_t * vam, int is_ipv6)
5727 const ip_details_t *det = NULL;
5728 const ip_address_details_t *address = NULL;
5731 print (vam->ofp, "%-12s", "sw_if_index");
5733 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
5740 print (vam->ofp, "%-12d", i);
5741 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
5746 vec_foreach (address, det->addr)
5750 is_ipv6 ? format_ip6_address : format_ip4_address,
5751 address->ip, address->prefix_length);
5759 dump_ipv4_table (vat_main_t * vam)
5761 if (vam->json_output)
5764 ("JSON output supported only for VPE API calls and dump_stats_table");
5768 return dump_ip_table (vam, 0);
5772 dump_ipv6_table (vat_main_t * vam)
5774 if (vam->json_output)
5777 ("JSON output supported only for VPE API calls and dump_stats_table");
5781 return dump_ip_table (vam, 1);
5785 * Pass CLI buffers directly in the CLI_INBAND API message,
5786 * instead of an additional shared memory area.
5789 exec_inband (vat_main_t * vam)
5791 vl_api_cli_inband_t *mp;
5792 unformat_input_t *i = vam->input;
5795 if (vec_len (i->buffer) == 0)
5798 if (vam->exec_mode == 0 && unformat (i, "mode"))
5803 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
5810 * In order for the CLI command to work, it
5811 * must be a vector ending in \n, not a C-string ending
5814 u32 len = vec_len (vam->input->buffer);
5815 M2 (CLI_INBAND, mp, len);
5816 vl_api_to_api_string (len - 1, (const char *) vam->input->buffer, &mp->cmd);
5820 /* json responses may or may not include a useful reply... */
5821 if (vec_len (vam->cmd_reply))
5822 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
5827 exec (vat_main_t * vam)
5829 return exec_inband (vam);
5833 api_create_loopback (vat_main_t * vam)
5835 unformat_input_t *i = vam->input;
5836 vl_api_create_loopback_t *mp;
5837 vl_api_create_loopback_instance_t *mp_lbi;
5840 u8 is_specified = 0;
5841 u32 user_instance = 0;
5844 clib_memset (mac_address, 0, sizeof (mac_address));
5846 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5848 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5850 if (unformat (i, "instance %d", &user_instance))
5858 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
5859 mp_lbi->is_specified = is_specified;
5861 mp_lbi->user_instance = htonl (user_instance);
5863 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
5868 /* Construct the API message */
5869 M (CREATE_LOOPBACK, mp);
5871 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
5880 api_delete_loopback (vat_main_t * vam)
5882 unformat_input_t *i = vam->input;
5883 vl_api_delete_loopback_t *mp;
5884 u32 sw_if_index = ~0;
5887 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5889 if (unformat (i, "sw_if_index %d", &sw_if_index))
5895 if (sw_if_index == ~0)
5897 errmsg ("missing sw_if_index");
5901 /* Construct the API message */
5902 M (DELETE_LOOPBACK, mp);
5903 mp->sw_if_index = ntohl (sw_if_index);
5911 api_want_interface_events (vat_main_t * vam)
5913 unformat_input_t *i = vam->input;
5914 vl_api_want_interface_events_t *mp;
5918 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5920 if (unformat (i, "enable"))
5922 else if (unformat (i, "disable"))
5930 errmsg ("missing enable|disable");
5934 M (WANT_INTERFACE_EVENTS, mp);
5935 mp->enable_disable = enable;
5937 vam->interface_event_display = enable;
5945 /* Note: non-static, called once to set up the initial intfc table */
5947 api_sw_interface_dump (vat_main_t * vam)
5949 vl_api_sw_interface_dump_t *mp;
5950 vl_api_control_ping_t *mp_ping;
5952 name_sort_t *nses = 0, *ns;
5953 sw_interface_subif_t *sub = NULL;
5956 /* Toss the old name table */
5958 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5960 vec_add2 (nses, ns, 1);
5961 ns->name = (u8 *)(p->key);
5962 ns->value = (u32) p->value[0];
5966 hash_free (vam->sw_if_index_by_interface_name);
5968 vec_foreach (ns, nses) vec_free (ns->name);
5972 vec_foreach (sub, vam->sw_if_subif_table)
5974 vec_free (sub->interface_name);
5976 vec_free (vam->sw_if_subif_table);
5978 /* recreate the interface name hash table */
5979 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
5982 * Ask for all interface names. Otherwise, the epic catalog of
5983 * name filters becomes ridiculously long, and vat ends up needing
5984 * to be taught about new interface types.
5986 M (SW_INTERFACE_DUMP, mp);
5989 /* Use a control ping for synchronization */
5990 MPING (CONTROL_PING, mp_ping);
5998 api_sw_interface_set_flags (vat_main_t * vam)
6000 unformat_input_t *i = vam->input;
6001 vl_api_sw_interface_set_flags_t *mp;
6003 u8 sw_if_index_set = 0;
6007 /* Parse args required to build the message */
6008 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6010 if (unformat (i, "admin-up"))
6012 else if (unformat (i, "admin-down"))
6015 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6016 sw_if_index_set = 1;
6017 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6018 sw_if_index_set = 1;
6023 if (sw_if_index_set == 0)
6025 errmsg ("missing interface name or sw_if_index");
6029 /* Construct the API message */
6030 M (SW_INTERFACE_SET_FLAGS, mp);
6031 mp->sw_if_index = ntohl (sw_if_index);
6032 mp->admin_up_down = admin_up;
6037 /* Wait for a reply, return the good/bad news... */
6043 api_sw_interface_set_rx_mode (vat_main_t * vam)
6045 unformat_input_t *i = vam->input;
6046 vl_api_sw_interface_set_rx_mode_t *mp;
6048 u8 sw_if_index_set = 0;
6050 u8 queue_id_valid = 0;
6052 vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN;
6054 /* Parse args required to build the message */
6055 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6057 if (unformat (i, "queue %d", &queue_id))
6059 else if (unformat (i, "polling"))
6060 mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
6061 else if (unformat (i, "interrupt"))
6062 mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT;
6063 else if (unformat (i, "adaptive"))
6064 mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE;
6066 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6067 sw_if_index_set = 1;
6068 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6069 sw_if_index_set = 1;
6074 if (sw_if_index_set == 0)
6076 errmsg ("missing interface name or sw_if_index");
6079 if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
6081 errmsg ("missing rx-mode");
6085 /* Construct the API message */
6086 M (SW_INTERFACE_SET_RX_MODE, mp);
6087 mp->sw_if_index = ntohl (sw_if_index);
6089 mp->queue_id_valid = queue_id_valid;
6090 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
6095 /* Wait for a reply, return the good/bad news... */
6101 api_sw_interface_set_rx_placement (vat_main_t * vam)
6103 unformat_input_t *i = vam->input;
6104 vl_api_sw_interface_set_rx_placement_t *mp;
6106 u8 sw_if_index_set = 0;
6109 u32 queue_id, thread_index;
6111 /* Parse args required to build the message */
6112 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6114 if (unformat (i, "queue %d", &queue_id))
6116 else if (unformat (i, "main"))
6118 else if (unformat (i, "worker %d", &thread_index))
6121 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6122 sw_if_index_set = 1;
6123 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6124 sw_if_index_set = 1;
6129 if (sw_if_index_set == 0)
6131 errmsg ("missing interface name or sw_if_index");
6137 /* Construct the API message */
6138 M (SW_INTERFACE_SET_RX_PLACEMENT, mp);
6139 mp->sw_if_index = ntohl (sw_if_index);
6140 mp->worker_id = ntohl (thread_index);
6141 mp->queue_id = ntohl (queue_id);
6142 mp->is_main = is_main;
6146 /* Wait for a reply, return the good/bad news... */
6151 static void vl_api_sw_interface_rx_placement_details_t_handler
6152 (vl_api_sw_interface_rx_placement_details_t * mp)
6154 vat_main_t *vam = &vat_main;
6155 u32 worker_id = ntohl (mp->worker_id);
6158 "\n%-11d %-11s %-6d %-5d %-9s",
6159 ntohl (mp->sw_if_index), (worker_id == 0) ? "main" : "worker",
6160 worker_id, ntohl (mp->queue_id),
6162 1) ? "polling" : ((mp->mode == 2) ? "interrupt" : "adaptive"));
6165 static void vl_api_sw_interface_rx_placement_details_t_handler_json
6166 (vl_api_sw_interface_rx_placement_details_t * mp)
6168 vat_main_t *vam = &vat_main;
6169 vat_json_node_t *node = NULL;
6171 if (VAT_JSON_ARRAY != vam->json_tree.type)
6173 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
6174 vat_json_init_array (&vam->json_tree);
6176 node = vat_json_array_add (&vam->json_tree);
6178 vat_json_init_object (node);
6179 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
6180 vat_json_object_add_uint (node, "worker_id", ntohl (mp->worker_id));
6181 vat_json_object_add_uint (node, "queue_id", ntohl (mp->queue_id));
6182 vat_json_object_add_uint (node, "mode", mp->mode);
6186 api_sw_interface_rx_placement_dump (vat_main_t * vam)
6188 unformat_input_t *i = vam->input;
6189 vl_api_sw_interface_rx_placement_dump_t *mp;
6190 vl_api_control_ping_t *mp_ping;
6193 u8 sw_if_index_set = 0;
6195 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6197 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6199 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6206 "\n%-11s %-11s %-6s %-5s %-4s",
6207 "sw_if_index", "main/worker", "thread", "queue", "mode");
6209 /* Dump Interface rx placement */
6210 M (SW_INTERFACE_RX_PLACEMENT_DUMP, mp);
6212 if (sw_if_index_set)
6213 mp->sw_if_index = htonl (sw_if_index);
6215 mp->sw_if_index = ~0;
6219 /* Use a control ping for synchronization */
6220 MPING (CONTROL_PING, mp_ping);
6228 api_sw_interface_clear_stats (vat_main_t * vam)
6230 unformat_input_t *i = vam->input;
6231 vl_api_sw_interface_clear_stats_t *mp;
6233 u8 sw_if_index_set = 0;
6236 /* Parse args required to build the message */
6237 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6239 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6240 sw_if_index_set = 1;
6241 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6242 sw_if_index_set = 1;
6247 /* Construct the API message */
6248 M (SW_INTERFACE_CLEAR_STATS, mp);
6250 if (sw_if_index_set == 1)
6251 mp->sw_if_index = ntohl (sw_if_index);
6253 mp->sw_if_index = ~0;
6258 /* Wait for a reply, return the good/bad news... */
6264 api_sw_interface_add_del_address (vat_main_t * vam)
6266 unformat_input_t *i = vam->input;
6267 vl_api_sw_interface_add_del_address_t *mp;
6269 u8 sw_if_index_set = 0;
6270 u8 is_add = 1, del_all = 0;
6271 u32 address_length = 0;
6272 u8 v4_address_set = 0;
6273 u8 v6_address_set = 0;
6274 ip4_address_t v4address;
6275 ip6_address_t v6address;
6278 /* Parse args required to build the message */
6279 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6281 if (unformat (i, "del-all"))
6283 else if (unformat (i, "del"))
6286 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6287 sw_if_index_set = 1;
6288 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6289 sw_if_index_set = 1;
6290 else if (unformat (i, "%U/%d",
6291 unformat_ip4_address, &v4address, &address_length))
6293 else if (unformat (i, "%U/%d",
6294 unformat_ip6_address, &v6address, &address_length))
6300 if (sw_if_index_set == 0)
6302 errmsg ("missing interface name or sw_if_index");
6305 if (v4_address_set && v6_address_set)
6307 errmsg ("both v4 and v6 addresses set");
6310 if (!v4_address_set && !v6_address_set && !del_all)
6312 errmsg ("no addresses set");
6316 /* Construct the API message */
6317 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
6319 mp->sw_if_index = ntohl (sw_if_index);
6320 mp->is_add = is_add;
6321 mp->del_all = del_all;
6325 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6329 clib_memcpy (mp->address, &v4address, sizeof (v4address));
6331 mp->address_length = address_length;
6336 /* Wait for a reply, return good/bad news */
6342 api_sw_interface_set_mpls_enable (vat_main_t * vam)
6344 unformat_input_t *i = vam->input;
6345 vl_api_sw_interface_set_mpls_enable_t *mp;
6347 u8 sw_if_index_set = 0;
6351 /* Parse args required to build the message */
6352 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6354 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6355 sw_if_index_set = 1;
6356 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6357 sw_if_index_set = 1;
6358 else if (unformat (i, "disable"))
6360 else if (unformat (i, "dis"))
6366 if (sw_if_index_set == 0)
6368 errmsg ("missing interface name or sw_if_index");
6372 /* Construct the API message */
6373 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
6375 mp->sw_if_index = ntohl (sw_if_index);
6376 mp->enable = enable;
6381 /* Wait for a reply... */
6387 api_sw_interface_set_table (vat_main_t * vam)
6389 unformat_input_t *i = vam->input;
6390 vl_api_sw_interface_set_table_t *mp;
6391 u32 sw_if_index, vrf_id = 0;
6392 u8 sw_if_index_set = 0;
6396 /* Parse args required to build the message */
6397 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6399 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6400 sw_if_index_set = 1;
6401 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6402 sw_if_index_set = 1;
6403 else if (unformat (i, "vrf %d", &vrf_id))
6405 else if (unformat (i, "ipv6"))
6411 if (sw_if_index_set == 0)
6413 errmsg ("missing interface name or sw_if_index");
6417 /* Construct the API message */
6418 M (SW_INTERFACE_SET_TABLE, mp);
6420 mp->sw_if_index = ntohl (sw_if_index);
6421 mp->is_ipv6 = is_ipv6;
6422 mp->vrf_id = ntohl (vrf_id);
6427 /* Wait for a reply... */
6432 static void vl_api_sw_interface_get_table_reply_t_handler
6433 (vl_api_sw_interface_get_table_reply_t * mp)
6435 vat_main_t *vam = &vat_main;
6437 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6439 vam->retval = ntohl (mp->retval);
6440 vam->result_ready = 1;
6444 static void vl_api_sw_interface_get_table_reply_t_handler_json
6445 (vl_api_sw_interface_get_table_reply_t * mp)
6447 vat_main_t *vam = &vat_main;
6448 vat_json_node_t node;
6450 vat_json_init_object (&node);
6451 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6452 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6454 vat_json_print (vam->ofp, &node);
6455 vat_json_free (&node);
6457 vam->retval = ntohl (mp->retval);
6458 vam->result_ready = 1;
6462 api_sw_interface_get_table (vat_main_t * vam)
6464 unformat_input_t *i = vam->input;
6465 vl_api_sw_interface_get_table_t *mp;
6467 u8 sw_if_index_set = 0;
6471 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6473 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6474 sw_if_index_set = 1;
6475 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6476 sw_if_index_set = 1;
6477 else if (unformat (i, "ipv6"))
6483 if (sw_if_index_set == 0)
6485 errmsg ("missing interface name or sw_if_index");
6489 M (SW_INTERFACE_GET_TABLE, mp);
6490 mp->sw_if_index = htonl (sw_if_index);
6491 mp->is_ipv6 = is_ipv6;
6499 api_sw_interface_set_vpath (vat_main_t * vam)
6501 unformat_input_t *i = vam->input;
6502 vl_api_sw_interface_set_vpath_t *mp;
6503 u32 sw_if_index = 0;
6504 u8 sw_if_index_set = 0;
6508 /* Parse args required to build the message */
6509 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6511 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6512 sw_if_index_set = 1;
6513 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6514 sw_if_index_set = 1;
6515 else if (unformat (i, "enable"))
6517 else if (unformat (i, "disable"))
6523 if (sw_if_index_set == 0)
6525 errmsg ("missing interface name or sw_if_index");
6529 /* Construct the API message */
6530 M (SW_INTERFACE_SET_VPATH, mp);
6532 mp->sw_if_index = ntohl (sw_if_index);
6533 mp->enable = is_enable;
6538 /* Wait for a reply... */
6544 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
6546 unformat_input_t *i = vam->input;
6547 vl_api_sw_interface_set_vxlan_bypass_t *mp;
6548 u32 sw_if_index = 0;
6549 u8 sw_if_index_set = 0;
6554 /* Parse args required to build the message */
6555 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6557 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6558 sw_if_index_set = 1;
6559 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6560 sw_if_index_set = 1;
6561 else if (unformat (i, "enable"))
6563 else if (unformat (i, "disable"))
6565 else if (unformat (i, "ip4"))
6567 else if (unformat (i, "ip6"))
6573 if (sw_if_index_set == 0)
6575 errmsg ("missing interface name or sw_if_index");
6579 /* Construct the API message */
6580 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
6582 mp->sw_if_index = ntohl (sw_if_index);
6583 mp->enable = is_enable;
6584 mp->is_ipv6 = is_ipv6;
6589 /* Wait for a reply... */
6595 api_sw_interface_set_geneve_bypass (vat_main_t * vam)
6597 unformat_input_t *i = vam->input;
6598 vl_api_sw_interface_set_geneve_bypass_t *mp;
6599 u32 sw_if_index = 0;
6600 u8 sw_if_index_set = 0;
6605 /* Parse args required to build the message */
6606 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6608 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6609 sw_if_index_set = 1;
6610 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6611 sw_if_index_set = 1;
6612 else if (unformat (i, "enable"))
6614 else if (unformat (i, "disable"))
6616 else if (unformat (i, "ip4"))
6618 else if (unformat (i, "ip6"))
6624 if (sw_if_index_set == 0)
6626 errmsg ("missing interface name or sw_if_index");
6630 /* Construct the API message */
6631 M (SW_INTERFACE_SET_GENEVE_BYPASS, mp);
6633 mp->sw_if_index = ntohl (sw_if_index);
6634 mp->enable = is_enable;
6635 mp->is_ipv6 = is_ipv6;
6640 /* Wait for a reply... */
6646 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
6648 unformat_input_t *i = vam->input;
6649 vl_api_sw_interface_set_l2_xconnect_t *mp;
6651 u8 rx_sw_if_index_set = 0;
6653 u8 tx_sw_if_index_set = 0;
6657 /* Parse args required to build the message */
6658 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6660 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6661 rx_sw_if_index_set = 1;
6662 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6663 tx_sw_if_index_set = 1;
6664 else if (unformat (i, "rx"))
6666 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6668 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6670 rx_sw_if_index_set = 1;
6675 else if (unformat (i, "tx"))
6677 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6679 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6681 tx_sw_if_index_set = 1;
6686 else if (unformat (i, "enable"))
6688 else if (unformat (i, "disable"))
6694 if (rx_sw_if_index_set == 0)
6696 errmsg ("missing rx interface name or rx_sw_if_index");
6700 if (enable && (tx_sw_if_index_set == 0))
6702 errmsg ("missing tx interface name or tx_sw_if_index");
6706 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
6708 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6709 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6710 mp->enable = enable;
6718 api_sw_interface_set_l2_bridge (vat_main_t * vam)
6720 unformat_input_t *i = vam->input;
6721 vl_api_sw_interface_set_l2_bridge_t *mp;
6722 vl_api_l2_port_type_t port_type;
6724 u8 rx_sw_if_index_set = 0;
6731 port_type = L2_API_PORT_TYPE_NORMAL;
6733 /* Parse args required to build the message */
6734 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6736 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
6737 rx_sw_if_index_set = 1;
6738 else if (unformat (i, "bd_id %d", &bd_id))
6742 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
6743 rx_sw_if_index_set = 1;
6744 else if (unformat (i, "shg %d", &shg))
6746 else if (unformat (i, "bvi"))
6747 port_type = L2_API_PORT_TYPE_BVI;
6748 else if (unformat (i, "uu-fwd"))
6749 port_type = L2_API_PORT_TYPE_UU_FWD;
6750 else if (unformat (i, "enable"))
6752 else if (unformat (i, "disable"))
6758 if (rx_sw_if_index_set == 0)
6760 errmsg ("missing rx interface name or sw_if_index");
6764 if (enable && (bd_id_set == 0))
6766 errmsg ("missing bridge domain");
6770 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
6772 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6773 mp->bd_id = ntohl (bd_id);
6775 mp->port_type = ntohl (port_type);
6776 mp->enable = enable;
6784 api_bridge_domain_dump (vat_main_t * vam)
6786 unformat_input_t *i = vam->input;
6787 vl_api_bridge_domain_dump_t *mp;
6788 vl_api_control_ping_t *mp_ping;
6792 /* Parse args required to build the message */
6793 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6795 if (unformat (i, "bd_id %d", &bd_id))
6801 M (BRIDGE_DOMAIN_DUMP, mp);
6802 mp->bd_id = ntohl (bd_id);
6805 /* Use a control ping for synchronization */
6806 MPING (CONTROL_PING, mp_ping);
6814 api_bridge_domain_add_del (vat_main_t * vam)
6816 unformat_input_t *i = vam->input;
6817 vl_api_bridge_domain_add_del_t *mp;
6820 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
6825 /* Parse args required to build the message */
6826 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6828 if (unformat (i, "bd_id %d", &bd_id))
6830 else if (unformat (i, "flood %d", &flood))
6832 else if (unformat (i, "uu-flood %d", &uu_flood))
6834 else if (unformat (i, "forward %d", &forward))
6836 else if (unformat (i, "learn %d", &learn))
6838 else if (unformat (i, "arp-term %d", &arp_term))
6840 else if (unformat (i, "mac-age %d", &mac_age))
6842 else if (unformat (i, "bd-tag %s", &bd_tag))
6844 else if (unformat (i, "del"))
6847 flood = uu_flood = forward = learn = 0;
6855 errmsg ("missing bridge domain");
6862 errmsg ("mac age must be less than 256 ");
6867 if ((bd_tag) && (vec_len (bd_tag) > 63))
6869 errmsg ("bd-tag cannot be longer than 63");
6874 M (BRIDGE_DOMAIN_ADD_DEL, mp);
6876 mp->bd_id = ntohl (bd_id);
6878 mp->uu_flood = uu_flood;
6879 mp->forward = forward;
6881 mp->arp_term = arp_term;
6882 mp->is_add = is_add;
6883 mp->mac_age = (u8) mac_age;
6886 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
6887 mp->bd_tag[vec_len (bd_tag)] = 0;
6898 api_l2fib_flush_bd (vat_main_t * vam)
6900 unformat_input_t *i = vam->input;
6901 vl_api_l2fib_flush_bd_t *mp;
6905 /* Parse args required to build the message */
6906 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6908 if (unformat (i, "bd_id %d", &bd_id));
6915 errmsg ("missing bridge domain");
6919 M (L2FIB_FLUSH_BD, mp);
6921 mp->bd_id = htonl (bd_id);
6929 api_l2fib_flush_int (vat_main_t * vam)
6931 unformat_input_t *i = vam->input;
6932 vl_api_l2fib_flush_int_t *mp;
6933 u32 sw_if_index = ~0;
6936 /* Parse args required to build the message */
6937 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6939 if (unformat (i, "sw_if_index %d", &sw_if_index));
6941 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
6946 if (sw_if_index == ~0)
6948 errmsg ("missing interface name or sw_if_index");
6952 M (L2FIB_FLUSH_INT, mp);
6954 mp->sw_if_index = ntohl (sw_if_index);
6962 api_l2fib_add_del (vat_main_t * vam)
6964 unformat_input_t *i = vam->input;
6965 vl_api_l2fib_add_del_t *mp;
6971 u32 sw_if_index = 0;
6972 u8 sw_if_index_set = 0;
6981 /* Parse args required to build the message */
6982 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6984 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
6986 else if (unformat (i, "bd_id %d", &bd_id))
6988 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6989 sw_if_index_set = 1;
6990 else if (unformat (i, "sw_if"))
6992 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6995 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6996 sw_if_index_set = 1;
7001 else if (unformat (i, "static"))
7003 else if (unformat (i, "filter"))
7008 else if (unformat (i, "bvi"))
7013 else if (unformat (i, "del"))
7015 else if (unformat (i, "count %d", &count))
7023 errmsg ("missing mac address");
7029 errmsg ("missing bridge domain");
7033 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
7035 errmsg ("missing interface name or sw_if_index");
7041 /* Turn on async mode */
7042 vam->async_mode = 1;
7043 vam->async_errors = 0;
7044 before = vat_time_now (vam);
7047 for (j = 0; j < count; j++)
7049 M (L2FIB_ADD_DEL, mp);
7051 clib_memcpy (mp->mac, mac, 6);
7052 mp->bd_id = ntohl (bd_id);
7053 mp->is_add = is_add;
7054 mp->sw_if_index = ntohl (sw_if_index);
7058 mp->static_mac = static_mac;
7059 mp->filter_mac = filter_mac;
7060 mp->bvi_mac = bvi_mac;
7062 increment_mac_address (mac);
7069 vl_api_control_ping_t *mp_ping;
7072 /* Shut off async mode */
7073 vam->async_mode = 0;
7075 MPING (CONTROL_PING, mp_ping);
7078 timeout = vat_time_now (vam) + 1.0;
7079 while (vat_time_now (vam) < timeout)
7080 if (vam->result_ready == 1)
7085 if (vam->retval == -99)
7088 if (vam->async_errors > 0)
7090 errmsg ("%d asynchronous errors", vam->async_errors);
7093 vam->async_errors = 0;
7094 after = vat_time_now (vam);
7096 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
7097 count, after - before, count / (after - before));
7103 /* Wait for a reply... */
7107 /* Return the good/bad news */
7108 return (vam->retval);
7112 api_bridge_domain_set_mac_age (vat_main_t * vam)
7114 unformat_input_t *i = vam->input;
7115 vl_api_bridge_domain_set_mac_age_t *mp;
7120 /* Parse args required to build the message */
7121 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7123 if (unformat (i, "bd_id %d", &bd_id));
7124 else if (unformat (i, "mac-age %d", &mac_age));
7131 errmsg ("missing bridge domain");
7137 errmsg ("mac age must be less than 256 ");
7141 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
7143 mp->bd_id = htonl (bd_id);
7144 mp->mac_age = (u8) mac_age;
7152 api_l2_flags (vat_main_t * vam)
7154 unformat_input_t *i = vam->input;
7155 vl_api_l2_flags_t *mp;
7158 u8 sw_if_index_set = 0;
7162 /* Parse args required to build the message */
7163 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7165 if (unformat (i, "sw_if_index %d", &sw_if_index))
7166 sw_if_index_set = 1;
7167 else if (unformat (i, "sw_if"))
7169 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7172 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7173 sw_if_index_set = 1;
7178 else if (unformat (i, "learn"))
7180 else if (unformat (i, "forward"))
7182 else if (unformat (i, "flood"))
7184 else if (unformat (i, "uu-flood"))
7185 flags |= L2_UU_FLOOD;
7186 else if (unformat (i, "arp-term"))
7187 flags |= L2_ARP_TERM;
7188 else if (unformat (i, "off"))
7190 else if (unformat (i, "disable"))
7196 if (sw_if_index_set == 0)
7198 errmsg ("missing interface name or sw_if_index");
7204 mp->sw_if_index = ntohl (sw_if_index);
7205 mp->feature_bitmap = ntohl (flags);
7206 mp->is_set = is_set;
7214 api_bridge_flags (vat_main_t * vam)
7216 unformat_input_t *i = vam->input;
7217 vl_api_bridge_flags_t *mp;
7221 bd_flags_t flags = 0;
7224 /* Parse args required to build the message */
7225 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7227 if (unformat (i, "bd_id %d", &bd_id))
7229 else if (unformat (i, "learn"))
7230 flags |= BRIDGE_API_FLAG_LEARN;
7231 else if (unformat (i, "forward"))
7232 flags |= BRIDGE_API_FLAG_FWD;
7233 else if (unformat (i, "flood"))
7234 flags |= BRIDGE_API_FLAG_FLOOD;
7235 else if (unformat (i, "uu-flood"))
7236 flags |= BRIDGE_API_FLAG_UU_FLOOD;
7237 else if (unformat (i, "arp-term"))
7238 flags |= BRIDGE_API_FLAG_ARP_TERM;
7239 else if (unformat (i, "off"))
7241 else if (unformat (i, "disable"))
7249 errmsg ("missing bridge domain");
7253 M (BRIDGE_FLAGS, mp);
7255 mp->bd_id = ntohl (bd_id);
7256 mp->flags = ntohl (flags);
7257 mp->is_set = is_set;
7265 api_bd_ip_mac_add_del (vat_main_t * vam)
7267 vl_api_address_t ip = VL_API_ZERO_ADDRESS;
7268 vl_api_mac_address_t mac = { 0 };
7269 unformat_input_t *i = vam->input;
7270 vl_api_bd_ip_mac_add_del_t *mp;
7282 /* Parse args required to build the message */
7283 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7285 if (unformat (i, "bd_id %d", &bd_id))
7289 else if (unformat (i, "%U", unformat_vl_api_address, &ip))
7293 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
7297 else if (unformat (i, "del"))
7305 errmsg ("missing bridge domain");
7308 else if (ip_set == 0)
7310 errmsg ("missing IP address");
7313 else if (mac_set == 0)
7315 errmsg ("missing MAC address");
7319 M (BD_IP_MAC_ADD_DEL, mp);
7321 mp->bd_id = ntohl (bd_id);
7322 mp->is_add = is_add;
7324 clib_memcpy (&mp->ip, &ip, sizeof (ip));
7325 clib_memcpy (&mp->mac, &mac, sizeof (mac));
7333 api_bd_ip_mac_flush (vat_main_t * vam)
7335 unformat_input_t *i = vam->input;
7336 vl_api_bd_ip_mac_flush_t *mp;
7341 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7343 if (unformat (i, "bd_id %d", &bd_id))
7353 errmsg ("missing bridge domain");
7357 M (BD_IP_MAC_FLUSH, mp);
7359 mp->bd_id = ntohl (bd_id);
7366 static void vl_api_bd_ip_mac_details_t_handler
7367 (vl_api_bd_ip_mac_details_t * mp)
7369 vat_main_t *vam = &vat_main;
7374 format (0, "%U", format_ip4_address, (ip4_address_t *) mp->ip_address);
7377 format (0, "%U", format_ip6_address, (ip6_address_t *) mp->ip_address);
7380 "\n%-5d %-7s %-20U %-30s",
7381 ntohl (mp->bd_id), mp->is_ipv6 ? "ip6" : "ip4",
7382 format_ethernet_address, mp->mac_address, ip);
7387 static void vl_api_bd_ip_mac_details_t_handler_json
7388 (vl_api_bd_ip_mac_details_t * mp)
7390 vat_main_t *vam = &vat_main;
7391 vat_json_node_t *node = NULL;
7393 if (VAT_JSON_ARRAY != vam->json_tree.type)
7395 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7396 vat_json_init_array (&vam->json_tree);
7398 node = vat_json_array_add (&vam->json_tree);
7400 vat_json_init_object (node);
7401 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
7402 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6);
7403 vat_json_object_add_string_copy (node, "mac_address",
7404 format (0, "%U", format_ethernet_address,
7410 format (0, "%U", format_ip4_address, (ip4_address_t *) mp->ip_address);
7413 format (0, "%U", format_ip6_address, (ip6_address_t *) mp->ip_address);
7414 vat_json_object_add_string_copy (node, "ip_address", ip);
7419 api_bd_ip_mac_dump (vat_main_t * vam)
7421 unformat_input_t *i = vam->input;
7422 vl_api_bd_ip_mac_dump_t *mp;
7423 vl_api_control_ping_t *mp_ping;
7428 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7430 if (unformat (i, "bd_id %d", &bd_id))
7439 "\n%-5s %-7s %-20s %-30s",
7440 "bd_id", "is_ipv6", "mac_address", "ip_address");
7442 /* Dump Bridge Domain Ip to Mac entries */
7443 M (BD_IP_MAC_DUMP, mp);
7446 mp->bd_id = htonl (bd_id);
7452 /* Use a control ping for synchronization */
7453 MPING (CONTROL_PING, mp_ping);
7461 api_tap_create_v2 (vat_main_t * vam)
7463 unformat_input_t *i = vam->input;
7464 vl_api_tap_create_v2_t *mp;
7468 u8 *host_if_name = 0;
7470 u8 host_mac_addr[6];
7471 u8 host_mac_addr_set = 0;
7472 u8 *host_bridge = 0;
7473 ip4_address_t host_ip4_addr;
7474 ip4_address_t host_ip4_gw;
7475 u8 host_ip4_gw_set = 0;
7476 u32 host_ip4_prefix_len = 0;
7477 ip6_address_t host_ip6_addr;
7478 ip6_address_t host_ip6_gw;
7479 u8 host_ip6_gw_set = 0;
7480 u32 host_ip6_prefix_len = 0;
7482 u32 rx_ring_sz = 0, tx_ring_sz = 0;
7484 clib_memset (mac_address, 0, sizeof (mac_address));
7486 /* Parse args required to build the message */
7487 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7489 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7493 else if (unformat (i, "id %u", &id))
7495 else if (unformat (i, "host-if-name %s", &host_if_name))
7497 else if (unformat (i, "host-ns %s", &host_ns))
7499 else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
7501 host_mac_addr_set = 1;
7502 else if (unformat (i, "host-bridge %s", &host_bridge))
7504 else if (unformat (i, "host-ip4-addr %U/%d", unformat_ip4_address,
7505 &host_ip4_addr, &host_ip4_prefix_len))
7507 else if (unformat (i, "host-ip6-addr %U/%d", unformat_ip6_address,
7508 &host_ip6_addr, &host_ip6_prefix_len))
7510 else if (unformat (i, "host-ip4-gw %U", unformat_ip4_address,
7512 host_ip4_gw_set = 1;
7513 else if (unformat (i, "host-ip6-gw %U", unformat_ip6_address,
7515 host_ip6_gw_set = 1;
7516 else if (unformat (i, "rx-ring-size %d", &rx_ring_sz))
7518 else if (unformat (i, "tx-ring-size %d", &tx_ring_sz))
7524 if (vec_len (host_if_name) > 63)
7526 errmsg ("tap name too long. ");
7529 if (vec_len (host_ns) > 63)
7531 errmsg ("host name space too long. ");
7534 if (vec_len (host_bridge) > 63)
7536 errmsg ("host bridge name too long. ");
7539 if (host_ip4_prefix_len > 32)
7541 errmsg ("host ip4 prefix length not valid. ");
7544 if (host_ip6_prefix_len > 128)
7546 errmsg ("host ip6 prefix length not valid. ");
7549 if (!is_pow2 (rx_ring_sz))
7551 errmsg ("rx ring size must be power of 2. ");
7554 if (rx_ring_sz > 32768)
7556 errmsg ("rx ring size must be 32768 or lower. ");
7559 if (!is_pow2 (tx_ring_sz))
7561 errmsg ("tx ring size must be power of 2. ");
7564 if (tx_ring_sz > 32768)
7566 errmsg ("tx ring size must be 32768 or lower. ");
7570 /* Construct the API message */
7571 M (TAP_CREATE_V2, mp);
7573 mp->use_random_mac = random_mac;
7575 mp->id = ntohl (id);
7576 mp->host_namespace_set = host_ns != 0;
7577 mp->host_bridge_set = host_bridge != 0;
7578 mp->host_ip4_addr_set = host_ip4_prefix_len != 0;
7579 mp->host_ip6_addr_set = host_ip6_prefix_len != 0;
7580 mp->rx_ring_sz = ntohs (rx_ring_sz);
7581 mp->tx_ring_sz = ntohs (tx_ring_sz);
7583 if (random_mac == 0)
7584 clib_memcpy (mp->mac_address, mac_address, 6);
7585 if (host_mac_addr_set)
7586 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
7588 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
7590 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
7592 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
7593 if (host_ip4_prefix_len)
7594 clib_memcpy (mp->host_ip4_addr, &host_ip4_addr, 4);
7595 if (host_ip6_prefix_len)
7596 clib_memcpy (mp->host_ip6_addr, &host_ip6_addr, 16);
7597 if (host_ip4_gw_set)
7598 clib_memcpy (mp->host_ip4_gw, &host_ip4_gw, 4);
7599 if (host_ip6_gw_set)
7600 clib_memcpy (mp->host_ip6_gw, &host_ip6_gw, 16);
7603 vec_free (host_if_name);
7604 vec_free (host_bridge);
7609 /* Wait for a reply... */
7615 api_tap_delete_v2 (vat_main_t * vam)
7617 unformat_input_t *i = vam->input;
7618 vl_api_tap_delete_v2_t *mp;
7619 u32 sw_if_index = ~0;
7620 u8 sw_if_index_set = 0;
7623 /* Parse args required to build the message */
7624 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7626 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7627 sw_if_index_set = 1;
7628 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7629 sw_if_index_set = 1;
7634 if (sw_if_index_set == 0)
7636 errmsg ("missing vpp interface name. ");
7640 /* Construct the API message */
7641 M (TAP_DELETE_V2, mp);
7643 mp->sw_if_index = ntohl (sw_if_index);
7648 /* Wait for a reply... */
7654 unformat_pci_addr (unformat_input_t * input, va_list * args)
7663 addr = va_arg (*args, struct pci_addr_t *);
7666 if (!unformat (input, "%x:%x:%x.%x", &x[0], &x[1], &x[2], &x[3]))
7669 addr->domain = x[0];
7672 addr->function = x[3];
7678 api_virtio_pci_create (vat_main_t * vam)
7680 unformat_input_t *i = vam->input;
7681 vl_api_virtio_pci_create_t *mp;
7686 u64 features = (u64) ~ (0ULL);
7689 clib_memset (mac_address, 0, sizeof (mac_address));
7691 /* Parse args required to build the message */
7692 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7694 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7698 else if (unformat (i, "pci-addr %U", unformat_pci_addr, &pci_addr))
7700 else if (unformat (i, "features 0x%llx", &features))
7702 else if (unformat (i, "gso-enabled"))
7710 errmsg ("pci address must be non zero. ");
7714 /* Construct the API message */
7715 M (VIRTIO_PCI_CREATE, mp);
7717 mp->use_random_mac = random_mac;
7719 mp->pci_addr = htonl (pci_addr);
7720 mp->features = clib_host_to_net_u64 (features);
7722 if (random_mac == 0)
7723 clib_memcpy (mp->mac_address, mac_address, 6);
7728 /* Wait for a reply... */
7734 api_virtio_pci_delete (vat_main_t * vam)
7736 unformat_input_t *i = vam->input;
7737 vl_api_virtio_pci_delete_t *mp;
7738 u32 sw_if_index = ~0;
7739 u8 sw_if_index_set = 0;
7742 /* Parse args required to build the message */
7743 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7745 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7746 sw_if_index_set = 1;
7747 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7748 sw_if_index_set = 1;
7753 if (sw_if_index_set == 0)
7755 errmsg ("missing vpp interface name. ");
7759 /* Construct the API message */
7760 M (VIRTIO_PCI_DELETE, mp);
7762 mp->sw_if_index = htonl (sw_if_index);
7767 /* Wait for a reply... */
7773 api_bond_create (vat_main_t * vam)
7775 unformat_input_t *i = vam->input;
7776 vl_api_bond_create_t *mp;
7785 clib_memset (mac_address, 0, sizeof (mac_address));
7788 /* Parse args required to build the message */
7789 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7791 if (unformat (i, "mode %U", unformat_bond_mode, &mode))
7793 else if (((mode == BOND_MODE_LACP) || (mode == BOND_MODE_XOR))
7794 && unformat (i, "lb %U", unformat_bond_load_balance, &lb))
7796 else if (unformat (i, "hw-addr %U", unformat_ethernet_address,
7799 else if (unformat (i, "id %u", &id))
7805 if (mode_is_set == 0)
7807 errmsg ("Missing bond mode. ");
7811 /* Construct the API message */
7812 M (BOND_CREATE, mp);
7814 mp->use_custom_mac = custom_mac;
7818 mp->id = htonl (id);
7821 clib_memcpy (mp->mac_address, mac_address, 6);
7826 /* Wait for a reply... */
7832 api_bond_delete (vat_main_t * vam)
7834 unformat_input_t *i = vam->input;
7835 vl_api_bond_delete_t *mp;
7836 u32 sw_if_index = ~0;
7837 u8 sw_if_index_set = 0;
7840 /* Parse args required to build the message */
7841 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7843 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7844 sw_if_index_set = 1;
7845 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7846 sw_if_index_set = 1;
7851 if (sw_if_index_set == 0)
7853 errmsg ("missing vpp interface name. ");
7857 /* Construct the API message */
7858 M (BOND_DELETE, mp);
7860 mp->sw_if_index = ntohl (sw_if_index);
7865 /* Wait for a reply... */
7871 api_bond_enslave (vat_main_t * vam)
7873 unformat_input_t *i = vam->input;
7874 vl_api_bond_enslave_t *mp;
7875 u32 bond_sw_if_index;
7879 u32 bond_sw_if_index_is_set = 0;
7881 u8 sw_if_index_is_set = 0;
7883 /* Parse args required to build the message */
7884 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7886 if (unformat (i, "sw_if_index %d", &sw_if_index))
7887 sw_if_index_is_set = 1;
7888 else if (unformat (i, "bond %u", &bond_sw_if_index))
7889 bond_sw_if_index_is_set = 1;
7890 else if (unformat (i, "passive %d", &is_passive))
7892 else if (unformat (i, "long-timeout %d", &is_long_timeout))
7898 if (bond_sw_if_index_is_set == 0)
7900 errmsg ("Missing bond sw_if_index. ");
7903 if (sw_if_index_is_set == 0)
7905 errmsg ("Missing slave sw_if_index. ");
7909 /* Construct the API message */
7910 M (BOND_ENSLAVE, mp);
7912 mp->bond_sw_if_index = ntohl (bond_sw_if_index);
7913 mp->sw_if_index = ntohl (sw_if_index);
7914 mp->is_long_timeout = is_long_timeout;
7915 mp->is_passive = is_passive;
7920 /* Wait for a reply... */
7926 api_bond_detach_slave (vat_main_t * vam)
7928 unformat_input_t *i = vam->input;
7929 vl_api_bond_detach_slave_t *mp;
7930 u32 sw_if_index = ~0;
7931 u8 sw_if_index_set = 0;
7934 /* Parse args required to build the message */
7935 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7937 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7938 sw_if_index_set = 1;
7939 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7940 sw_if_index_set = 1;
7945 if (sw_if_index_set == 0)
7947 errmsg ("missing vpp interface name. ");
7951 /* Construct the API message */
7952 M (BOND_DETACH_SLAVE, mp);
7954 mp->sw_if_index = ntohl (sw_if_index);
7959 /* Wait for a reply... */
7965 api_ip_table_add_del (vat_main_t * vam)
7967 unformat_input_t *i = vam->input;
7968 vl_api_ip_table_add_del_t *mp;
7974 /* Parse args required to build the message */
7975 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7977 if (unformat (i, "ipv6"))
7979 else if (unformat (i, "del"))
7981 else if (unformat (i, "add"))
7983 else if (unformat (i, "table %d", &table_id))
7987 clib_warning ("parse error '%U'", format_unformat_error, i);
7994 errmsg ("missing table-ID");
7998 /* Construct the API message */
7999 M (IP_TABLE_ADD_DEL, mp);
8001 mp->table_id = ntohl (table_id);
8002 mp->is_ipv6 = is_ipv6;
8003 mp->is_add = is_add;
8008 /* Wait for a reply... */
8015 api_ip_add_del_route (vat_main_t * vam)
8017 unformat_input_t *i = vam->input;
8018 vl_api_ip_add_del_route_t *mp;
8019 u32 sw_if_index = ~0, vrf_id = 0;
8021 u8 is_local = 0, is_drop = 0;
8022 u8 is_unreach = 0, is_prohibit = 0;
8024 u32 next_hop_weight = 1;
8025 u8 is_multipath = 0;
8027 u8 address_length_set = 0;
8028 u32 next_hop_table_id = 0;
8029 u32 resolve_attempts = 0;
8030 u32 dst_address_length = 0;
8031 u8 next_hop_set = 0;
8032 ip4_address_t v4_dst_address, v4_next_hop_address;
8033 ip6_address_t v6_dst_address, v6_next_hop_address;
8037 u32 random_add_del = 0;
8038 u32 *random_vector = 0;
8040 u32 random_seed = 0xdeaddabe;
8041 u32 classify_table_index = ~0;
8043 u8 resolve_host = 0, resolve_attached = 0;
8044 vl_api_fib_mpls_label_t *next_hop_out_label_stack = NULL;
8045 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8046 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
8048 clib_memset (&v4_next_hop_address, 0, sizeof (ip4_address_t));
8049 clib_memset (&v6_next_hop_address, 0, sizeof (ip6_address_t));
8050 /* Parse args required to build the message */
8051 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8053 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8055 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8057 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
8062 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
8067 else if (unformat (i, "/%d", &dst_address_length))
8069 address_length_set = 1;
8072 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
8073 &v4_next_hop_address))
8077 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
8078 &v6_next_hop_address))
8084 (i, "via %U", api_unformat_sw_if_index, vam, &sw_if_index))
8088 else if (unformat (i, "via sw_if_index %d", &sw_if_index))
8092 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
8094 else if (unformat (i, "weight %d", &next_hop_weight))
8096 else if (unformat (i, "drop"))
8100 else if (unformat (i, "null-send-unreach"))
8104 else if (unformat (i, "null-send-prohibit"))
8108 else if (unformat (i, "local"))
8112 else if (unformat (i, "classify %d", &classify_table_index))
8116 else if (unformat (i, "del"))
8118 else if (unformat (i, "add"))
8120 else if (unformat (i, "resolve-via-host"))
8122 else if (unformat (i, "resolve-via-attached"))
8123 resolve_attached = 1;
8124 else if (unformat (i, "multipath"))
8126 else if (unformat (i, "vrf %d", &vrf_id))
8128 else if (unformat (i, "count %d", &count))
8130 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
8132 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
8134 else if (unformat (i, "out-label %d", &next_hop_out_label))
8136 vl_api_fib_mpls_label_t fib_label = {
8137 .label = ntohl (next_hop_out_label),
8141 vec_add1 (next_hop_out_label_stack, fib_label);
8143 else if (unformat (i, "via via-label %d", &next_hop_via_label))
8145 else if (unformat (i, "random"))
8147 else if (unformat (i, "seed %d", &random_seed))
8151 clib_warning ("parse error '%U'", format_unformat_error, i);
8156 if (!next_hop_set && !is_drop && !is_local &&
8157 !is_classify && !is_unreach && !is_prohibit &&
8158 MPLS_LABEL_INVALID == next_hop_via_label)
8161 ("next hop / local / drop / unreach / prohibit / classify not set");
8165 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
8167 errmsg ("next hop and next-hop via label set");
8170 if (address_set == 0)
8172 errmsg ("missing addresses");
8176 if (address_length_set == 0)
8178 errmsg ("missing address length");
8182 /* Generate a pile of unique, random routes */
8185 u32 this_random_address;
8186 random_hash = hash_create (count, sizeof (uword));
8188 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
8189 for (j = 0; j <= count; j++)
8193 this_random_address = random_u32 (&random_seed);
8194 this_random_address =
8195 clib_host_to_net_u32 (this_random_address);
8197 while (hash_get (random_hash, this_random_address));
8198 vec_add1 (random_vector, this_random_address);
8199 hash_set (random_hash, this_random_address, 1);
8201 hash_free (random_hash);
8202 v4_dst_address.as_u32 = random_vector[0];
8207 /* Turn on async mode */
8208 vam->async_mode = 1;
8209 vam->async_errors = 0;
8210 before = vat_time_now (vam);
8213 for (j = 0; j < count; j++)
8215 /* Construct the API message */
8216 M2 (IP_ADD_DEL_ROUTE, mp, sizeof (vl_api_fib_mpls_label_t) *
8217 vec_len (next_hop_out_label_stack));
8219 mp->next_hop_sw_if_index = ntohl (sw_if_index);
8220 mp->table_id = ntohl (vrf_id);
8222 mp->is_add = is_add;
8223 mp->is_drop = is_drop;
8224 mp->is_unreach = is_unreach;
8225 mp->is_prohibit = is_prohibit;
8226 mp->is_ipv6 = is_ipv6;
8227 mp->is_local = is_local;
8228 mp->is_classify = is_classify;
8229 mp->is_multipath = is_multipath;
8230 mp->is_resolve_host = resolve_host;
8231 mp->is_resolve_attached = resolve_attached;
8232 mp->next_hop_weight = next_hop_weight;
8233 mp->next_hop_preference = 0;
8234 mp->dst_address_length = dst_address_length;
8235 mp->next_hop_table_id = ntohl (next_hop_table_id);
8236 mp->classify_table_index = ntohl (classify_table_index);
8237 mp->next_hop_via_label = ntohl (next_hop_via_label);
8238 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
8239 if (0 != mp->next_hop_n_out_labels)
8241 memcpy (mp->next_hop_out_label_stack,
8242 next_hop_out_label_stack,
8243 (vec_len (next_hop_out_label_stack) *
8244 sizeof (vl_api_fib_mpls_label_t)));
8245 vec_free (next_hop_out_label_stack);
8250 clib_memcpy (mp->dst_address, &v6_dst_address,
8251 sizeof (v6_dst_address));
8253 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
8254 sizeof (v6_next_hop_address));
8255 increment_v6_address (&v6_dst_address);
8259 clib_memcpy (mp->dst_address, &v4_dst_address,
8260 sizeof (v4_dst_address));
8262 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
8263 sizeof (v4_next_hop_address));
8265 v4_dst_address.as_u32 = random_vector[j + 1];
8267 increment_v4_address (&v4_dst_address);
8271 /* If we receive SIGTERM, stop now... */
8276 /* When testing multiple add/del ops, use a control-ping to sync */
8279 vl_api_control_ping_t *mp_ping;
8283 /* Shut off async mode */
8284 vam->async_mode = 0;
8286 MPING (CONTROL_PING, mp_ping);
8289 timeout = vat_time_now (vam) + 1.0;
8290 while (vat_time_now (vam) < timeout)
8291 if (vam->result_ready == 1)
8296 if (vam->retval == -99)
8299 if (vam->async_errors > 0)
8301 errmsg ("%d asynchronous errors", vam->async_errors);
8304 vam->async_errors = 0;
8305 after = vat_time_now (vam);
8307 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8311 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8312 count, after - before, count / (after - before));
8318 /* Wait for a reply... */
8323 /* Return the good/bad news */
8324 return (vam->retval);
8328 api_ip_mroute_add_del (vat_main_t * vam)
8330 unformat_input_t *i = vam->input;
8331 vl_api_ip_mroute_add_del_t *mp;
8332 u32 sw_if_index = ~0, vrf_id = 0;
8337 u32 grp_address_length = 0;
8338 ip4_address_t v4_grp_address, v4_src_address;
8339 ip6_address_t v6_grp_address, v6_src_address;
8340 mfib_itf_flags_t iflags = 0;
8341 mfib_entry_flags_t eflags = 0;
8344 /* Parse args required to build the message */
8345 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8347 if (unformat (i, "sw_if_index %d", &sw_if_index))
8349 else if (unformat (i, "%U %U",
8350 unformat_ip4_address, &v4_src_address,
8351 unformat_ip4_address, &v4_grp_address))
8353 grp_address_length = 64;
8357 else if (unformat (i, "%U %U",
8358 unformat_ip6_address, &v6_src_address,
8359 unformat_ip6_address, &v6_grp_address))
8361 grp_address_length = 256;
8365 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
8367 clib_memset (&v4_src_address, 0, sizeof (v4_src_address));
8368 grp_address_length = 32;
8372 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
8374 clib_memset (&v6_src_address, 0, sizeof (v6_src_address));
8375 grp_address_length = 128;
8379 else if (unformat (i, "/%d", &grp_address_length))
8381 else if (unformat (i, "local"))
8385 else if (unformat (i, "del"))
8387 else if (unformat (i, "add"))
8389 else if (unformat (i, "vrf %d", &vrf_id))
8391 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
8393 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8397 clib_warning ("parse error '%U'", format_unformat_error, i);
8402 if (address_set == 0)
8404 errmsg ("missing addresses\n");
8408 /* Construct the API message */
8409 M (IP_MROUTE_ADD_DEL, mp);
8411 mp->next_hop_sw_if_index = ntohl (sw_if_index);
8412 mp->table_id = ntohl (vrf_id);
8414 mp->is_add = is_add;
8415 mp->is_ipv6 = is_ipv6;
8416 mp->is_local = is_local;
8417 mp->itf_flags = ntohl (iflags);
8418 mp->entry_flags = ntohl (eflags);
8419 mp->grp_address_length = grp_address_length;
8420 mp->grp_address_length = ntohs (mp->grp_address_length);
8424 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
8425 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
8429 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
8430 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
8436 /* Wait for a reply... */
8442 api_mpls_table_add_del (vat_main_t * vam)
8444 unformat_input_t *i = vam->input;
8445 vl_api_mpls_table_add_del_t *mp;
8450 /* Parse args required to build the message */
8451 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8453 if (unformat (i, "table %d", &table_id))
8455 else if (unformat (i, "del"))
8457 else if (unformat (i, "add"))
8461 clib_warning ("parse error '%U'", format_unformat_error, i);
8468 errmsg ("missing table-ID");
8472 /* Construct the API message */
8473 M (MPLS_TABLE_ADD_DEL, mp);
8475 mp->mt_table_id = ntohl (table_id);
8476 mp->mt_is_add = is_add;
8481 /* Wait for a reply... */
8488 api_mpls_route_add_del (vat_main_t * vam)
8490 unformat_input_t *i = vam->input;
8491 vl_api_mpls_route_add_del_t *mp;
8492 u32 sw_if_index = ~0, table_id = 0;
8494 u32 next_hop_weight = 1;
8495 u8 is_multipath = 0;
8496 u32 next_hop_table_id = 0;
8497 u8 next_hop_set = 0;
8498 ip4_address_t v4_next_hop_address = {
8501 ip6_address_t v6_next_hop_address = { {0} };
8505 u32 classify_table_index = ~0;
8507 u8 resolve_host = 0, resolve_attached = 0;
8508 u8 is_interface_rx = 0;
8509 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
8510 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8511 vl_api_fib_mpls_label_t *next_hop_out_label_stack = NULL;
8512 mpls_label_t local_label = MPLS_LABEL_INVALID;
8514 dpo_proto_t next_hop_proto = DPO_PROTO_MPLS;
8516 /* Parse args required to build the message */
8517 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8519 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8521 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8523 else if (unformat (i, "%d", &local_label))
8525 else if (unformat (i, "eos"))
8527 else if (unformat (i, "non-eos"))
8529 else if (unformat (i, "via %U", unformat_ip4_address,
8530 &v4_next_hop_address))
8533 next_hop_proto = DPO_PROTO_IP4;
8535 else if (unformat (i, "via %U", unformat_ip6_address,
8536 &v6_next_hop_address))
8539 next_hop_proto = DPO_PROTO_IP6;
8541 else if (unformat (i, "weight %d", &next_hop_weight))
8543 else if (unformat (i, "classify %d", &classify_table_index))
8547 else if (unformat (i, "del"))
8549 else if (unformat (i, "add"))
8551 else if (unformat (i, "resolve-via-host"))
8553 else if (unformat (i, "resolve-via-attached"))
8554 resolve_attached = 1;
8555 else if (unformat (i, "multipath"))
8557 else if (unformat (i, "count %d", &count))
8559 else if (unformat (i, "via lookup-in-ip4-table %d", &next_hop_table_id))
8562 next_hop_proto = DPO_PROTO_IP4;
8564 else if (unformat (i, "via lookup-in-ip6-table %d", &next_hop_table_id))
8567 next_hop_proto = DPO_PROTO_IP6;
8571 (i, "via l2-input-on %U", api_unformat_sw_if_index, vam,
8575 next_hop_proto = DPO_PROTO_ETHERNET;
8576 is_interface_rx = 1;
8578 else if (unformat (i, "via l2-input-on sw_if_index %d", &sw_if_index))
8581 next_hop_proto = DPO_PROTO_ETHERNET;
8582 is_interface_rx = 1;
8584 else if (unformat (i, "via next-hop-table %d", &next_hop_table_id))
8586 else if (unformat (i, "via via-label %d", &next_hop_via_label))
8588 else if (unformat (i, "out-label %d", &next_hop_out_label))
8590 vl_api_fib_mpls_label_t fib_label = {
8591 .label = ntohl (next_hop_out_label),
8595 vec_add1 (next_hop_out_label_stack, fib_label);
8599 clib_warning ("parse error '%U'", format_unformat_error, i);
8604 if (!next_hop_set && !is_classify)
8606 errmsg ("next hop / classify not set");
8610 if (MPLS_LABEL_INVALID == local_label)
8612 errmsg ("missing label");
8618 /* Turn on async mode */
8619 vam->async_mode = 1;
8620 vam->async_errors = 0;
8621 before = vat_time_now (vam);
8624 for (j = 0; j < count; j++)
8626 /* Construct the API message */
8627 M2 (MPLS_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_mpls_label_t) *
8628 vec_len (next_hop_out_label_stack));
8630 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
8631 mp->mr_table_id = ntohl (table_id);
8633 mp->mr_is_add = is_add;
8634 mp->mr_next_hop_proto = next_hop_proto;
8635 mp->mr_is_classify = is_classify;
8636 mp->mr_is_multipath = is_multipath;
8637 mp->mr_is_resolve_host = resolve_host;
8638 mp->mr_is_resolve_attached = resolve_attached;
8639 mp->mr_is_interface_rx = is_interface_rx;
8640 mp->mr_next_hop_weight = next_hop_weight;
8641 mp->mr_next_hop_preference = 0;
8642 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
8643 mp->mr_classify_table_index = ntohl (classify_table_index);
8644 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
8645 mp->mr_label = ntohl (local_label);
8646 mp->mr_eos = is_eos;
8648 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
8649 if (0 != mp->mr_next_hop_n_out_labels)
8651 memcpy (mp->mr_next_hop_out_label_stack,
8652 next_hop_out_label_stack,
8653 vec_len (next_hop_out_label_stack) *
8654 sizeof (vl_api_fib_mpls_label_t));
8655 vec_free (next_hop_out_label_stack);
8660 if (DPO_PROTO_IP4 == next_hop_proto)
8662 clib_memcpy (mp->mr_next_hop,
8663 &v4_next_hop_address,
8664 sizeof (v4_next_hop_address));
8666 else if (DPO_PROTO_IP6 == next_hop_proto)
8669 clib_memcpy (mp->mr_next_hop,
8670 &v6_next_hop_address,
8671 sizeof (v6_next_hop_address));
8678 /* If we receive SIGTERM, stop now... */
8683 /* When testing multiple add/del ops, use a control-ping to sync */
8686 vl_api_control_ping_t *mp_ping;
8690 /* Shut off async mode */
8691 vam->async_mode = 0;
8693 MPING (CONTROL_PING, mp_ping);
8696 timeout = vat_time_now (vam) + 1.0;
8697 while (vat_time_now (vam) < timeout)
8698 if (vam->result_ready == 1)
8703 if (vam->retval == -99)
8706 if (vam->async_errors > 0)
8708 errmsg ("%d asynchronous errors", vam->async_errors);
8711 vam->async_errors = 0;
8712 after = vat_time_now (vam);
8714 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8718 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8719 count, after - before, count / (after - before));
8725 /* Wait for a reply... */
8730 /* Return the good/bad news */
8731 return (vam->retval);
8735 api_mpls_ip_bind_unbind (vat_main_t * vam)
8737 unformat_input_t *i = vam->input;
8738 vl_api_mpls_ip_bind_unbind_t *mp;
8739 u32 ip_table_id = 0;
8742 ip4_address_t v4_address;
8743 ip6_address_t v6_address;
8746 mpls_label_t local_label = MPLS_LABEL_INVALID;
8749 /* Parse args required to build the message */
8750 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8752 if (unformat (i, "%U/%d", unformat_ip4_address,
8753 &v4_address, &address_length))
8758 else if (unformat (i, "%U/%d", unformat_ip6_address,
8759 &v6_address, &address_length))
8764 else if (unformat (i, "%d", &local_label))
8766 else if (unformat (i, "table-id %d", &ip_table_id))
8768 else if (unformat (i, "unbind"))
8770 else if (unformat (i, "bind"))
8774 clib_warning ("parse error '%U'", format_unformat_error, i);
8781 errmsg ("IP address not set");
8785 if (MPLS_LABEL_INVALID == local_label)
8787 errmsg ("missing label");
8791 /* Construct the API message */
8792 M (MPLS_IP_BIND_UNBIND, mp);
8794 mp->mb_is_bind = is_bind;
8795 mp->mb_is_ip4 = is_ip4;
8796 mp->mb_ip_table_id = ntohl (ip_table_id);
8797 mp->mb_mpls_table_id = 0;
8798 mp->mb_label = ntohl (local_label);
8799 mp->mb_address_length = address_length;
8802 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
8804 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
8809 /* Wait for a reply... */
8815 api_sr_mpls_policy_add (vat_main_t * vam)
8817 unformat_input_t *i = vam->input;
8818 vl_api_sr_mpls_policy_add_t *mp;
8824 u32 *segments = NULL;
8827 /* Parse args required to build the message */
8828 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8830 if (unformat (i, "bsid %d", &bsid))
8832 else if (unformat (i, "weight %d", &weight))
8834 else if (unformat (i, "spray"))
8836 else if (unformat (i, "next %d", &sid))
8839 vec_add1 (segments, htonl (sid));
8843 clib_warning ("parse error '%U'", format_unformat_error, i);
8850 errmsg ("bsid not set");
8854 if (n_segments == 0)
8856 errmsg ("no sid in segment stack");
8860 /* Construct the API message */
8861 M2 (SR_MPLS_POLICY_ADD, mp, sizeof (u32) * n_segments);
8863 mp->bsid = htonl (bsid);
8864 mp->weight = htonl (weight);
8866 mp->n_segments = n_segments;
8867 memcpy (mp->segments, segments, sizeof (u32) * n_segments);
8868 vec_free (segments);
8873 /* Wait for a reply... */
8879 api_sr_mpls_policy_del (vat_main_t * vam)
8881 unformat_input_t *i = vam->input;
8882 vl_api_sr_mpls_policy_del_t *mp;
8886 /* Parse args required to build the message */
8887 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8889 if (unformat (i, "bsid %d", &bsid))
8893 clib_warning ("parse error '%U'", format_unformat_error, i);
8900 errmsg ("bsid not set");
8904 /* Construct the API message */
8905 M (SR_MPLS_POLICY_DEL, mp);
8907 mp->bsid = htonl (bsid);
8912 /* Wait for a reply... */
8918 api_bier_table_add_del (vat_main_t * vam)
8920 unformat_input_t *i = vam->input;
8921 vl_api_bier_table_add_del_t *mp;
8923 u32 set = 0, sub_domain = 0, hdr_len = 3;
8924 mpls_label_t local_label = MPLS_LABEL_INVALID;
8927 /* Parse args required to build the message */
8928 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8930 if (unformat (i, "sub-domain %d", &sub_domain))
8932 else if (unformat (i, "set %d", &set))
8934 else if (unformat (i, "label %d", &local_label))
8936 else if (unformat (i, "hdr-len %d", &hdr_len))
8938 else if (unformat (i, "add"))
8940 else if (unformat (i, "del"))
8944 clib_warning ("parse error '%U'", format_unformat_error, i);
8949 if (MPLS_LABEL_INVALID == local_label)
8951 errmsg ("missing label\n");
8955 /* Construct the API message */
8956 M (BIER_TABLE_ADD_DEL, mp);
8958 mp->bt_is_add = is_add;
8959 mp->bt_label = ntohl (local_label);
8960 mp->bt_tbl_id.bt_set = set;
8961 mp->bt_tbl_id.bt_sub_domain = sub_domain;
8962 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
8967 /* Wait for a reply... */
8974 api_bier_route_add_del (vat_main_t * vam)
8976 unformat_input_t *i = vam->input;
8977 vl_api_bier_route_add_del_t *mp;
8979 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
8980 ip4_address_t v4_next_hop_address;
8981 ip6_address_t v6_next_hop_address;
8982 u8 next_hop_set = 0;
8983 u8 next_hop_proto_is_ip4 = 1;
8984 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8987 /* Parse args required to build the message */
8988 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8990 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
8992 next_hop_proto_is_ip4 = 1;
8995 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
8997 next_hop_proto_is_ip4 = 0;
9000 if (unformat (i, "sub-domain %d", &sub_domain))
9002 else if (unformat (i, "set %d", &set))
9004 else if (unformat (i, "hdr-len %d", &hdr_len))
9006 else if (unformat (i, "bp %d", &bp))
9008 else if (unformat (i, "add"))
9010 else if (unformat (i, "del"))
9012 else if (unformat (i, "out-label %d", &next_hop_out_label))
9016 clib_warning ("parse error '%U'", format_unformat_error, i);
9021 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
9023 errmsg ("next hop / label set\n");
9028 errmsg ("bit=position not set\n");
9032 /* Construct the API message */
9033 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t));
9035 mp->br_is_add = is_add;
9036 mp->br_tbl_id.bt_set = set;
9037 mp->br_tbl_id.bt_sub_domain = sub_domain;
9038 mp->br_tbl_id.bt_hdr_len_id = hdr_len;
9039 mp->br_bp = ntohs (bp);
9041 mp->br_paths[0].n_labels = 1;
9042 mp->br_paths[0].label_stack[0].label = ntohl (next_hop_out_label);
9043 mp->br_paths[0].afi = (next_hop_proto_is_ip4 ? 0 : 1);
9045 if (next_hop_proto_is_ip4)
9047 clib_memcpy (mp->br_paths[0].next_hop,
9048 &v4_next_hop_address, sizeof (v4_next_hop_address));
9052 clib_memcpy (mp->br_paths[0].next_hop,
9053 &v6_next_hop_address, sizeof (v6_next_hop_address));
9059 /* Wait for a reply... */
9066 api_proxy_arp_add_del (vat_main_t * vam)
9068 unformat_input_t *i = vam->input;
9069 vl_api_proxy_arp_add_del_t *mp;
9072 vl_api_ip4_address_t lo, hi;
9076 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9078 if (unformat (i, "vrf %d", &vrf_id))
9080 else if (unformat (i, "%U - %U", unformat_vl_api_ip4_address, &lo,
9081 unformat_vl_api_ip4_address, &hi))
9083 else if (unformat (i, "del"))
9087 clib_warning ("parse error '%U'", format_unformat_error, i);
9094 errmsg ("address range not set");
9098 M (PROXY_ARP_ADD_DEL, mp);
9100 mp->proxy.table_id = ntohl (vrf_id);
9101 mp->is_add = is_add;
9102 clib_memcpy (mp->proxy.low, &lo, sizeof (lo));
9103 clib_memcpy (mp->proxy.hi, &hi, sizeof (hi));
9111 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
9113 unformat_input_t *i = vam->input;
9114 vl_api_proxy_arp_intfc_enable_disable_t *mp;
9117 u8 sw_if_index_set = 0;
9120 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9122 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9123 sw_if_index_set = 1;
9124 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9125 sw_if_index_set = 1;
9126 else if (unformat (i, "enable"))
9128 else if (unformat (i, "disable"))
9132 clib_warning ("parse error '%U'", format_unformat_error, i);
9137 if (sw_if_index_set == 0)
9139 errmsg ("missing interface name or sw_if_index");
9143 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
9145 mp->sw_if_index = ntohl (sw_if_index);
9146 mp->enable_disable = enable;
9154 api_mpls_tunnel_add_del (vat_main_t * vam)
9156 unformat_input_t *i = vam->input;
9157 vl_api_mpls_tunnel_add_del_t *mp;
9161 u32 sw_if_index = ~0;
9162 u32 next_hop_sw_if_index = ~0;
9163 u32 next_hop_proto_is_ip4 = 1;
9165 u32 next_hop_table_id = 0;
9166 ip4_address_t v4_next_hop_address = {
9169 ip6_address_t v6_next_hop_address = { {0} };
9170 vl_api_fib_mpls_label_t *next_hop_out_label_stack = NULL;
9171 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
9172 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
9175 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9177 if (unformat (i, "add"))
9181 (i, "del %U", api_unformat_sw_if_index, vam, &sw_if_index))
9183 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
9185 else if (unformat (i, "via %U",
9186 unformat_ip4_address, &v4_next_hop_address))
9188 next_hop_proto_is_ip4 = 1;
9190 else if (unformat (i, "via %U",
9191 unformat_ip6_address, &v6_next_hop_address))
9193 next_hop_proto_is_ip4 = 0;
9195 else if (unformat (i, "via-label %d", &next_hop_via_label))
9199 (i, "%U", api_unformat_sw_if_index, vam, &next_hop_sw_if_index))
9201 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
9203 else if (unformat (i, "l2-only"))
9205 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
9207 else if (unformat (i, "out-label %d", &next_hop_out_label))
9209 vl_api_fib_mpls_label_t fib_label = {
9210 .label = ntohl (next_hop_out_label),
9214 vec_add1 (next_hop_out_label_stack, fib_label);
9218 clib_warning ("parse error '%U'", format_unformat_error, i);
9223 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (vl_api_fib_mpls_label_t) *
9224 vec_len (next_hop_out_label_stack));
9226 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
9227 mp->mt_sw_if_index = ntohl (sw_if_index);
9228 mp->mt_is_add = is_add;
9229 mp->mt_l2_only = l2_only;
9230 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
9231 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
9232 mp->mt_next_hop_via_label = ntohl (next_hop_via_label);
9233 mp->mt_next_hop_weight = 1;
9234 mp->mt_next_hop_preference = 0;
9236 mp->mt_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
9238 if (0 != mp->mt_next_hop_n_out_labels)
9240 clib_memcpy (mp->mt_next_hop_out_label_stack,
9241 next_hop_out_label_stack,
9242 (vec_len (next_hop_out_label_stack) *
9243 sizeof (vl_api_fib_mpls_label_t)));
9244 vec_free (next_hop_out_label_stack);
9247 if (next_hop_proto_is_ip4)
9249 clib_memcpy (mp->mt_next_hop,
9250 &v4_next_hop_address, sizeof (v4_next_hop_address));
9254 clib_memcpy (mp->mt_next_hop,
9255 &v6_next_hop_address, sizeof (v6_next_hop_address));
9264 api_sw_interface_set_unnumbered (vat_main_t * vam)
9266 unformat_input_t *i = vam->input;
9267 vl_api_sw_interface_set_unnumbered_t *mp;
9269 u32 unnum_sw_index = ~0;
9271 u8 sw_if_index_set = 0;
9274 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9276 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9277 sw_if_index_set = 1;
9278 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9279 sw_if_index_set = 1;
9280 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
9282 else if (unformat (i, "del"))
9286 clib_warning ("parse error '%U'", format_unformat_error, i);
9291 if (sw_if_index_set == 0)
9293 errmsg ("missing interface name or sw_if_index");
9297 M (SW_INTERFACE_SET_UNNUMBERED, mp);
9299 mp->sw_if_index = ntohl (sw_if_index);
9300 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
9301 mp->is_add = is_add;
9309 api_ip_neighbor_add_del (vat_main_t * vam)
9311 vl_api_mac_address_t mac_address;
9312 unformat_input_t *i = vam->input;
9313 vl_api_ip_neighbor_add_del_t *mp;
9314 vl_api_address_t ip_address;
9316 u8 sw_if_index_set = 0;
9321 ip_neighbor_flags_t flags;
9323 flags = IP_NEIGHBOR_FLAG_NONE;
9324 clib_memset (&ip_address, 0, sizeof (ip_address));
9325 clib_memset (&mac_address, 0, sizeof (mac_address));
9326 /* Parse args required to build the message */
9327 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9329 if (unformat (i, "mac %U", unformat_vl_api_mac_address, &mac_address))
9333 else if (unformat (i, "del"))
9336 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9337 sw_if_index_set = 1;
9338 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9339 sw_if_index_set = 1;
9340 else if (unformat (i, "static"))
9341 flags |= IP_NEIGHBOR_FLAG_STATIC;
9342 else if (unformat (i, "no-fib-entry"))
9343 flags |= IP_NEIGHBOR_FLAG_NO_FIB_ENTRY;
9344 else if (unformat (i, "dst %U", unformat_vl_api_address, &ip_address))
9348 clib_warning ("parse error '%U'", format_unformat_error, i);
9353 if (sw_if_index_set == 0)
9355 errmsg ("missing interface name or sw_if_index");
9360 errmsg ("no address set");
9364 /* Construct the API message */
9365 M (IP_NEIGHBOR_ADD_DEL, mp);
9367 mp->neighbor.sw_if_index = ntohl (sw_if_index);
9368 mp->is_add = is_add;
9369 mp->neighbor.flags = htonl (flags);
9371 clib_memcpy (&mp->neighbor.mac_address, &mac_address,
9372 sizeof (mac_address));
9374 clib_memcpy (&mp->neighbor.ip_address, &ip_address, sizeof (ip_address));
9379 /* Wait for a reply, return good/bad news */
9385 api_create_vlan_subif (vat_main_t * vam)
9387 unformat_input_t *i = vam->input;
9388 vl_api_create_vlan_subif_t *mp;
9390 u8 sw_if_index_set = 0;
9395 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9397 if (unformat (i, "sw_if_index %d", &sw_if_index))
9398 sw_if_index_set = 1;
9400 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9401 sw_if_index_set = 1;
9402 else if (unformat (i, "vlan %d", &vlan_id))
9406 clib_warning ("parse error '%U'", format_unformat_error, i);
9411 if (sw_if_index_set == 0)
9413 errmsg ("missing interface name or sw_if_index");
9417 if (vlan_id_set == 0)
9419 errmsg ("missing vlan_id");
9422 M (CREATE_VLAN_SUBIF, mp);
9424 mp->sw_if_index = ntohl (sw_if_index);
9425 mp->vlan_id = ntohl (vlan_id);
9432 #define foreach_create_subif_bit \
9439 _(outer_vlan_id_any) \
9440 _(inner_vlan_id_any)
9443 api_create_subif (vat_main_t * vam)
9445 unformat_input_t *i = vam->input;
9446 vl_api_create_subif_t *mp;
9448 u8 sw_if_index_set = 0;
9455 u32 exact_match = 0;
9456 u32 default_sub = 0;
9457 u32 outer_vlan_id_any = 0;
9458 u32 inner_vlan_id_any = 0;
9460 u16 outer_vlan_id = 0;
9461 u16 inner_vlan_id = 0;
9464 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9466 if (unformat (i, "sw_if_index %d", &sw_if_index))
9467 sw_if_index_set = 1;
9469 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9470 sw_if_index_set = 1;
9471 else if (unformat (i, "sub_id %d", &sub_id))
9473 else if (unformat (i, "outer_vlan_id %d", &tmp))
9474 outer_vlan_id = tmp;
9475 else if (unformat (i, "inner_vlan_id %d", &tmp))
9476 inner_vlan_id = tmp;
9478 #define _(a) else if (unformat (i, #a)) a = 1 ;
9479 foreach_create_subif_bit
9483 clib_warning ("parse error '%U'", format_unformat_error, i);
9488 if (sw_if_index_set == 0)
9490 errmsg ("missing interface name or sw_if_index");
9494 if (sub_id_set == 0)
9496 errmsg ("missing sub_id");
9499 M (CREATE_SUBIF, mp);
9501 mp->sw_if_index = ntohl (sw_if_index);
9502 mp->sub_id = ntohl (sub_id);
9504 #define _(a) mp->a = a;
9505 foreach_create_subif_bit;
9508 mp->outer_vlan_id = ntohs (outer_vlan_id);
9509 mp->inner_vlan_id = ntohs (inner_vlan_id);
9517 api_reset_fib (vat_main_t * vam)
9519 unformat_input_t *i = vam->input;
9520 vl_api_reset_fib_t *mp;
9526 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9528 if (unformat (i, "vrf %d", &vrf_id))
9530 else if (unformat (i, "ipv6"))
9534 clib_warning ("parse error '%U'", format_unformat_error, i);
9539 if (vrf_id_set == 0)
9541 errmsg ("missing vrf id");
9547 mp->vrf_id = ntohl (vrf_id);
9548 mp->is_ipv6 = is_ipv6;
9556 api_dhcp_proxy_config (vat_main_t * vam)
9558 unformat_input_t *i = vam->input;
9559 vl_api_dhcp_proxy_config_t *mp;
9561 u32 server_vrf_id = 0;
9563 u8 v4_address_set = 0;
9564 u8 v6_address_set = 0;
9565 ip4_address_t v4address;
9566 ip6_address_t v6address;
9567 u8 v4_src_address_set = 0;
9568 u8 v6_src_address_set = 0;
9569 ip4_address_t v4srcaddress;
9570 ip6_address_t v6srcaddress;
9573 /* Parse args required to build the message */
9574 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9576 if (unformat (i, "del"))
9578 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
9580 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
9582 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
9584 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
9586 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
9587 v4_src_address_set = 1;
9588 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
9589 v6_src_address_set = 1;
9594 if (v4_address_set && v6_address_set)
9596 errmsg ("both v4 and v6 server addresses set");
9599 if (!v4_address_set && !v6_address_set)
9601 errmsg ("no server addresses set");
9605 if (v4_src_address_set && v6_src_address_set)
9607 errmsg ("both v4 and v6 src addresses set");
9610 if (!v4_src_address_set && !v6_src_address_set)
9612 errmsg ("no src addresses set");
9616 if (!(v4_src_address_set && v4_address_set) &&
9617 !(v6_src_address_set && v6_address_set))
9619 errmsg ("no matching server and src addresses set");
9623 /* Construct the API message */
9624 M (DHCP_PROXY_CONFIG, mp);
9626 mp->is_add = is_add;
9627 mp->rx_vrf_id = ntohl (rx_vrf_id);
9628 mp->server_vrf_id = ntohl (server_vrf_id);
9632 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
9633 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
9637 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
9638 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
9644 /* Wait for a reply, return good/bad news */
9649 #define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
9650 #define vl_api_dhcp_proxy_details_t_print vl_noop_handler
9653 vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
9655 vat_main_t *vam = &vat_main;
9656 u32 i, count = mp->count;
9657 vl_api_dhcp_server_t *s;
9661 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9662 "VSS ASCII VPN-ID '%s', VSS RFC2685 VPN-ID (oui:id) %d:%d",
9663 ntohl (mp->rx_vrf_id),
9664 format_ip6_address, mp->dhcp_src_address,
9665 mp->vss_type, mp->vss_vpn_ascii_id,
9666 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9669 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9670 "VSS ASCII VPN-ID '%s', VSS RFC2685 VPN-ID (oui:id) %d:%d",
9671 ntohl (mp->rx_vrf_id),
9672 format_ip4_address, mp->dhcp_src_address,
9673 mp->vss_type, mp->vss_vpn_ascii_id,
9674 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9676 for (i = 0; i < count; i++)
9678 s = &mp->servers[i];
9682 " Server Table-ID %d, Server Address %U",
9683 ntohl (s->server_vrf_id), format_ip6_address, s->dhcp_server);
9686 " Server Table-ID %d, Server Address %U",
9687 ntohl (s->server_vrf_id), format_ip4_address, s->dhcp_server);
9691 static void vl_api_dhcp_proxy_details_t_handler_json
9692 (vl_api_dhcp_proxy_details_t * mp)
9694 vat_main_t *vam = &vat_main;
9695 vat_json_node_t *node = NULL;
9696 u32 i, count = mp->count;
9698 struct in6_addr ip6;
9699 vl_api_dhcp_server_t *s;
9701 if (VAT_JSON_ARRAY != vam->json_tree.type)
9703 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9704 vat_json_init_array (&vam->json_tree);
9706 node = vat_json_array_add (&vam->json_tree);
9708 vat_json_init_object (node);
9709 vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
9710 vat_json_object_add_bytes (node, "vss-type", &mp->vss_type,
9711 sizeof (mp->vss_type));
9712 vat_json_object_add_string_copy (node, "vss-vpn-ascii-id",
9713 mp->vss_vpn_ascii_id);
9714 vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
9715 vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
9719 clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
9720 vat_json_object_add_ip6 (node, "src_address", ip6);
9724 clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
9725 vat_json_object_add_ip4 (node, "src_address", ip4);
9728 for (i = 0; i < count; i++)
9730 s = &mp->servers[i];
9732 vat_json_object_add_uint (node, "server-table-id",
9733 ntohl (s->server_vrf_id));
9737 clib_memcpy (&ip4, &s->dhcp_server, sizeof (ip4));
9738 vat_json_object_add_ip4 (node, "src_address", ip4);
9742 clib_memcpy (&ip6, &s->dhcp_server, sizeof (ip6));
9743 vat_json_object_add_ip6 (node, "server_address", ip6);
9749 api_dhcp_proxy_dump (vat_main_t * vam)
9751 unformat_input_t *i = vam->input;
9752 vl_api_control_ping_t *mp_ping;
9753 vl_api_dhcp_proxy_dump_t *mp;
9757 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9759 if (unformat (i, "ipv6"))
9763 clib_warning ("parse error '%U'", format_unformat_error, i);
9768 M (DHCP_PROXY_DUMP, mp);
9770 mp->is_ip6 = is_ipv6;
9773 /* Use a control ping for synchronization */
9774 MPING (CONTROL_PING, mp_ping);
9782 api_dhcp_proxy_set_vss (vat_main_t * vam)
9784 unformat_input_t *i = vam->input;
9785 vl_api_dhcp_proxy_set_vss_t *mp;
9789 u8 vss_type = VSS_TYPE_DEFAULT;
9790 u8 *vpn_ascii_id = 0;
9795 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9797 if (unformat (i, "tbl_id %d", &tbl_id))
9799 else if (unformat (i, "vpn_ascii_id %s", &vpn_ascii_id))
9800 vss_type = VSS_TYPE_ASCII;
9801 else if (unformat (i, "fib_id %d", &fib_id))
9802 vss_type = VSS_TYPE_VPN_ID;
9803 else if (unformat (i, "oui %d", &oui))
9804 vss_type = VSS_TYPE_VPN_ID;
9805 else if (unformat (i, "ipv6"))
9807 else if (unformat (i, "del"))
9815 errmsg ("missing tbl_id ");
9816 vec_free (vpn_ascii_id);
9820 if ((vpn_ascii_id) && (vec_len (vpn_ascii_id) > 128))
9822 errmsg ("vpn_ascii_id cannot be longer than 128 ");
9823 vec_free (vpn_ascii_id);
9827 M (DHCP_PROXY_SET_VSS, mp);
9828 mp->tbl_id = ntohl (tbl_id);
9829 mp->vss_type = vss_type;
9832 clib_memcpy (mp->vpn_ascii_id, vpn_ascii_id, vec_len (vpn_ascii_id));
9833 mp->vpn_ascii_id[vec_len (vpn_ascii_id)] = 0;
9835 mp->vpn_index = ntohl (fib_id);
9836 mp->oui = ntohl (oui);
9837 mp->is_ipv6 = is_ipv6;
9838 mp->is_add = is_add;
9843 vec_free (vpn_ascii_id);
9848 api_dhcp_client_config (vat_main_t * vam)
9850 unformat_input_t *i = vam->input;
9851 vl_api_dhcp_client_config_t *mp;
9853 u8 sw_if_index_set = 0;
9856 u8 disable_event = 0;
9859 /* Parse args required to build the message */
9860 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9862 if (unformat (i, "del"))
9865 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9866 sw_if_index_set = 1;
9867 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9868 sw_if_index_set = 1;
9869 else if (unformat (i, "hostname %s", &hostname))
9871 else if (unformat (i, "disable_event"))
9877 if (sw_if_index_set == 0)
9879 errmsg ("missing interface name or sw_if_index");
9883 if (vec_len (hostname) > 63)
9885 errmsg ("hostname too long");
9887 vec_add1 (hostname, 0);
9889 /* Construct the API message */
9890 M (DHCP_CLIENT_CONFIG, mp);
9892 mp->is_add = is_add;
9893 mp->client.sw_if_index = htonl (sw_if_index);
9894 clib_memcpy (mp->client.hostname, hostname, vec_len (hostname));
9895 vec_free (hostname);
9896 mp->client.want_dhcp_event = disable_event ? 0 : 1;
9897 mp->client.pid = htonl (getpid ());
9902 /* Wait for a reply, return good/bad news */
9908 api_set_ip_flow_hash (vat_main_t * vam)
9910 unformat_input_t *i = vam->input;
9911 vl_api_set_ip_flow_hash_t *mp;
9923 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9925 if (unformat (i, "vrf %d", &vrf_id))
9927 else if (unformat (i, "ipv6"))
9929 else if (unformat (i, "src"))
9931 else if (unformat (i, "dst"))
9933 else if (unformat (i, "sport"))
9935 else if (unformat (i, "dport"))
9937 else if (unformat (i, "proto"))
9939 else if (unformat (i, "reverse"))
9944 clib_warning ("parse error '%U'", format_unformat_error, i);
9949 if (vrf_id_set == 0)
9951 errmsg ("missing vrf id");
9955 M (SET_IP_FLOW_HASH, mp);
9961 mp->reverse = reverse;
9962 mp->vrf_id = ntohl (vrf_id);
9963 mp->is_ipv6 = is_ipv6;
9971 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
9973 unformat_input_t *i = vam->input;
9974 vl_api_sw_interface_ip6_enable_disable_t *mp;
9976 u8 sw_if_index_set = 0;
9980 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9982 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9983 sw_if_index_set = 1;
9984 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9985 sw_if_index_set = 1;
9986 else if (unformat (i, "enable"))
9988 else if (unformat (i, "disable"))
9992 clib_warning ("parse error '%U'", format_unformat_error, i);
9997 if (sw_if_index_set == 0)
9999 errmsg ("missing interface name or sw_if_index");
10003 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
10005 mp->sw_if_index = ntohl (sw_if_index);
10006 mp->enable = enable;
10014 api_ip6nd_proxy_add_del (vat_main_t * vam)
10016 unformat_input_t *i = vam->input;
10017 vl_api_ip6nd_proxy_add_del_t *mp;
10018 u32 sw_if_index = ~0;
10019 u8 v6_address_set = 0;
10020 vl_api_ip6_address_t v6address;
10024 /* Parse args required to build the message */
10025 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10027 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10029 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10031 else if (unformat (i, "%U", unformat_vl_api_ip6_address, &v6address))
10032 v6_address_set = 1;
10033 if (unformat (i, "del"))
10037 clib_warning ("parse error '%U'", format_unformat_error, i);
10042 if (sw_if_index == ~0)
10044 errmsg ("missing interface name or sw_if_index");
10047 if (!v6_address_set)
10049 errmsg ("no address set");
10053 /* Construct the API message */
10054 M (IP6ND_PROXY_ADD_DEL, mp);
10056 mp->is_del = is_del;
10057 mp->sw_if_index = ntohl (sw_if_index);
10058 clib_memcpy (mp->ip, v6address, sizeof (v6address));
10063 /* Wait for a reply, return good/bad news */
10069 api_ip6nd_proxy_dump (vat_main_t * vam)
10071 vl_api_ip6nd_proxy_dump_t *mp;
10072 vl_api_control_ping_t *mp_ping;
10075 M (IP6ND_PROXY_DUMP, mp);
10079 /* Use a control ping for synchronization */
10080 MPING (CONTROL_PING, mp_ping);
10087 static void vl_api_ip6nd_proxy_details_t_handler
10088 (vl_api_ip6nd_proxy_details_t * mp)
10090 vat_main_t *vam = &vat_main;
10092 print (vam->ofp, "host %U sw_if_index %d",
10093 format_vl_api_ip6_address, mp->ip, ntohl (mp->sw_if_index));
10096 static void vl_api_ip6nd_proxy_details_t_handler_json
10097 (vl_api_ip6nd_proxy_details_t * mp)
10099 vat_main_t *vam = &vat_main;
10100 struct in6_addr ip6;
10101 vat_json_node_t *node = NULL;
10103 if (VAT_JSON_ARRAY != vam->json_tree.type)
10105 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10106 vat_json_init_array (&vam->json_tree);
10108 node = vat_json_array_add (&vam->json_tree);
10110 vat_json_init_object (node);
10111 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10113 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
10114 vat_json_object_add_ip6 (node, "host", ip6);
10118 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
10120 unformat_input_t *i = vam->input;
10121 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
10123 u8 sw_if_index_set = 0;
10124 u32 address_length = 0;
10125 u8 v6_address_set = 0;
10126 vl_api_prefix_t pfx;
10127 u8 use_default = 0;
10128 u8 no_advertise = 0;
10130 u8 no_autoconfig = 0;
10133 u32 val_lifetime = 0;
10134 u32 pref_lifetime = 0;
10137 /* Parse args required to build the message */
10138 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10140 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10141 sw_if_index_set = 1;
10142 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10143 sw_if_index_set = 1;
10144 else if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
10145 v6_address_set = 1;
10146 else if (unformat (i, "val_life %d", &val_lifetime))
10148 else if (unformat (i, "pref_life %d", &pref_lifetime))
10150 else if (unformat (i, "def"))
10152 else if (unformat (i, "noadv"))
10154 else if (unformat (i, "offl"))
10156 else if (unformat (i, "noauto"))
10158 else if (unformat (i, "nolink"))
10160 else if (unformat (i, "isno"))
10164 clib_warning ("parse error '%U'", format_unformat_error, i);
10169 if (sw_if_index_set == 0)
10171 errmsg ("missing interface name or sw_if_index");
10174 if (!v6_address_set)
10176 errmsg ("no address set");
10180 /* Construct the API message */
10181 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
10183 mp->sw_if_index = ntohl (sw_if_index);
10184 clib_memcpy (&mp->prefix, &pfx, sizeof (pfx));
10185 mp->use_default = use_default;
10186 mp->no_advertise = no_advertise;
10187 mp->off_link = off_link;
10188 mp->no_autoconfig = no_autoconfig;
10189 mp->no_onlink = no_onlink;
10191 mp->val_lifetime = ntohl (val_lifetime);
10192 mp->pref_lifetime = ntohl (pref_lifetime);
10197 /* Wait for a reply, return good/bad news */
10203 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
10205 unformat_input_t *i = vam->input;
10206 vl_api_sw_interface_ip6nd_ra_config_t *mp;
10208 u8 sw_if_index_set = 0;
10213 u8 send_unicast = 0;
10216 u8 default_router = 0;
10217 u32 max_interval = 0;
10218 u32 min_interval = 0;
10220 u32 initial_count = 0;
10221 u32 initial_interval = 0;
10225 /* Parse args required to build the message */
10226 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10228 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10229 sw_if_index_set = 1;
10230 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10231 sw_if_index_set = 1;
10232 else if (unformat (i, "maxint %d", &max_interval))
10234 else if (unformat (i, "minint %d", &min_interval))
10236 else if (unformat (i, "life %d", &lifetime))
10238 else if (unformat (i, "count %d", &initial_count))
10240 else if (unformat (i, "interval %d", &initial_interval))
10242 else if (unformat (i, "suppress") || unformat (i, "surpress"))
10244 else if (unformat (i, "managed"))
10246 else if (unformat (i, "other"))
10248 else if (unformat (i, "ll"))
10250 else if (unformat (i, "send"))
10252 else if (unformat (i, "cease"))
10254 else if (unformat (i, "isno"))
10256 else if (unformat (i, "def"))
10257 default_router = 1;
10260 clib_warning ("parse error '%U'", format_unformat_error, i);
10265 if (sw_if_index_set == 0)
10267 errmsg ("missing interface name or sw_if_index");
10271 /* Construct the API message */
10272 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
10274 mp->sw_if_index = ntohl (sw_if_index);
10275 mp->max_interval = ntohl (max_interval);
10276 mp->min_interval = ntohl (min_interval);
10277 mp->lifetime = ntohl (lifetime);
10278 mp->initial_count = ntohl (initial_count);
10279 mp->initial_interval = ntohl (initial_interval);
10280 mp->suppress = suppress;
10281 mp->managed = managed;
10283 mp->ll_option = ll_option;
10284 mp->send_unicast = send_unicast;
10287 mp->default_router = default_router;
10292 /* Wait for a reply, return good/bad news */
10298 api_set_arp_neighbor_limit (vat_main_t * vam)
10300 unformat_input_t *i = vam->input;
10301 vl_api_set_arp_neighbor_limit_t *mp;
10307 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10309 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
10311 else if (unformat (i, "ipv6"))
10315 clib_warning ("parse error '%U'", format_unformat_error, i);
10320 if (limit_set == 0)
10322 errmsg ("missing limit value");
10326 M (SET_ARP_NEIGHBOR_LIMIT, mp);
10328 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
10329 mp->is_ipv6 = is_ipv6;
10337 api_l2_patch_add_del (vat_main_t * vam)
10339 unformat_input_t *i = vam->input;
10340 vl_api_l2_patch_add_del_t *mp;
10341 u32 rx_sw_if_index;
10342 u8 rx_sw_if_index_set = 0;
10343 u32 tx_sw_if_index;
10344 u8 tx_sw_if_index_set = 0;
10348 /* Parse args required to build the message */
10349 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10351 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
10352 rx_sw_if_index_set = 1;
10353 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
10354 tx_sw_if_index_set = 1;
10355 else if (unformat (i, "rx"))
10357 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10359 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10361 rx_sw_if_index_set = 1;
10366 else if (unformat (i, "tx"))
10368 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10370 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10372 tx_sw_if_index_set = 1;
10377 else if (unformat (i, "del"))
10383 if (rx_sw_if_index_set == 0)
10385 errmsg ("missing rx interface name or rx_sw_if_index");
10389 if (tx_sw_if_index_set == 0)
10391 errmsg ("missing tx interface name or tx_sw_if_index");
10395 M (L2_PATCH_ADD_DEL, mp);
10397 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
10398 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
10399 mp->is_add = is_add;
10407 u8 localsid_addr[16];
10416 api_sr_localsid_add_del (vat_main_t * vam)
10418 unformat_input_t *i = vam->input;
10419 vl_api_sr_localsid_add_del_t *mp;
10422 ip6_address_t localsid;
10426 u32 fib_table = ~(u32) 0;
10427 ip6_address_t nh_addr6;
10428 ip4_address_t nh_addr4;
10429 clib_memset (&nh_addr6, 0, sizeof (ip6_address_t));
10430 clib_memset (&nh_addr4, 0, sizeof (ip4_address_t));
10432 bool nexthop_set = 0;
10436 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10438 if (unformat (i, "del"))
10440 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
10441 else if (unformat (i, "next-hop %U", unformat_ip4_address, &nh_addr4))
10443 else if (unformat (i, "next-hop %U", unformat_ip6_address, &nh_addr6))
10445 else if (unformat (i, "behavior %u", &behavior));
10446 else if (unformat (i, "sw_if_index %u", &sw_if_index));
10447 else if (unformat (i, "fib-table %u", &fib_table));
10448 else if (unformat (i, "end.psp %u", &behavior));
10453 M (SR_LOCALSID_ADD_DEL, mp);
10455 clib_memcpy (mp->localsid.addr, &localsid, sizeof (mp->localsid));
10458 clib_memcpy (mp->nh_addr6, &nh_addr6, sizeof (mp->nh_addr6));
10459 clib_memcpy (mp->nh_addr4, &nh_addr4, sizeof (mp->nh_addr4));
10461 mp->behavior = behavior;
10462 mp->sw_if_index = ntohl (sw_if_index);
10463 mp->fib_table = ntohl (fib_table);
10464 mp->end_psp = end_psp;
10465 mp->is_del = is_del;
10473 api_ioam_enable (vat_main_t * vam)
10475 unformat_input_t *input = vam->input;
10476 vl_api_ioam_enable_t *mp;
10478 int has_trace_option = 0;
10479 int has_pot_option = 0;
10480 int has_seqno_option = 0;
10481 int has_analyse_option = 0;
10484 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10486 if (unformat (input, "trace"))
10487 has_trace_option = 1;
10488 else if (unformat (input, "pot"))
10489 has_pot_option = 1;
10490 else if (unformat (input, "seqno"))
10491 has_seqno_option = 1;
10492 else if (unformat (input, "analyse"))
10493 has_analyse_option = 1;
10497 M (IOAM_ENABLE, mp);
10498 mp->id = htons (id);
10499 mp->seqno = has_seqno_option;
10500 mp->analyse = has_analyse_option;
10501 mp->pot_enable = has_pot_option;
10502 mp->trace_enable = has_trace_option;
10511 api_ioam_disable (vat_main_t * vam)
10513 vl_api_ioam_disable_t *mp;
10516 M (IOAM_DISABLE, mp);
10522 #define foreach_tcp_proto_field \
10526 #define foreach_udp_proto_field \
10530 #define foreach_ip4_proto_field \
10542 u16 src_port, dst_port;
10545 #if VPP_API_TEST_BUILTIN == 0
10547 unformat_tcp_mask (unformat_input_t * input, va_list * args)
10549 u8 **maskp = va_arg (*args, u8 **);
10551 u8 found_something = 0;
10554 #define _(a) u8 a=0;
10555 foreach_tcp_proto_field;
10558 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10561 #define _(a) else if (unformat (input, #a)) a=1;
10562 foreach_tcp_proto_field
10568 #define _(a) found_something += a;
10569 foreach_tcp_proto_field;
10572 if (found_something == 0)
10575 vec_validate (mask, sizeof (*tcp) - 1);
10577 tcp = (tcp_header_t *) mask;
10579 #define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
10580 foreach_tcp_proto_field;
10588 unformat_udp_mask (unformat_input_t * input, va_list * args)
10590 u8 **maskp = va_arg (*args, u8 **);
10592 u8 found_something = 0;
10595 #define _(a) u8 a=0;
10596 foreach_udp_proto_field;
10599 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10602 #define _(a) else if (unformat (input, #a)) a=1;
10603 foreach_udp_proto_field
10609 #define _(a) found_something += a;
10610 foreach_udp_proto_field;
10613 if (found_something == 0)
10616 vec_validate (mask, sizeof (*udp) - 1);
10618 udp = (udp_header_t *) mask;
10620 #define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
10621 foreach_udp_proto_field;
10629 unformat_l4_mask (unformat_input_t * input, va_list * args)
10631 u8 **maskp = va_arg (*args, u8 **);
10632 u16 src_port = 0, dst_port = 0;
10633 tcpudp_header_t *tcpudp;
10635 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10637 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
10639 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
10641 else if (unformat (input, "src_port"))
10643 else if (unformat (input, "dst_port"))
10649 if (!src_port && !dst_port)
10653 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
10655 tcpudp = (tcpudp_header_t *) mask;
10656 tcpudp->src_port = src_port;
10657 tcpudp->dst_port = dst_port;
10665 unformat_ip4_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_ip4_proto_field;
10679 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10681 if (unformat (input, "version"))
10683 else if (unformat (input, "hdr_length"))
10685 else if (unformat (input, "src"))
10687 else if (unformat (input, "dst"))
10689 else if (unformat (input, "proto"))
10692 #define _(a) else if (unformat (input, #a)) a=1;
10693 foreach_ip4_proto_field
10699 #define _(a) found_something += a;
10700 foreach_ip4_proto_field;
10703 if (found_something == 0)
10706 vec_validate (mask, sizeof (*ip) - 1);
10708 ip = (ip4_header_t *) mask;
10710 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
10711 foreach_ip4_proto_field;
10714 ip->ip_version_and_header_length = 0;
10717 ip->ip_version_and_header_length |= 0xF0;
10720 ip->ip_version_and_header_length |= 0x0F;
10726 #define foreach_ip6_proto_field \
10729 _(payload_length) \
10734 unformat_ip6_mask (unformat_input_t * input, va_list * args)
10736 u8 **maskp = va_arg (*args, u8 **);
10738 u8 found_something = 0;
10740 u32 ip_version_traffic_class_and_flow_label;
10742 #define _(a) u8 a=0;
10743 foreach_ip6_proto_field;
10746 u8 traffic_class = 0;
10749 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10751 if (unformat (input, "version"))
10753 else if (unformat (input, "traffic-class"))
10755 else if (unformat (input, "flow-label"))
10757 else if (unformat (input, "src"))
10759 else if (unformat (input, "dst"))
10761 else if (unformat (input, "proto"))
10764 #define _(a) else if (unformat (input, #a)) a=1;
10765 foreach_ip6_proto_field
10771 #define _(a) found_something += a;
10772 foreach_ip6_proto_field;
10775 if (found_something == 0)
10778 vec_validate (mask, sizeof (*ip) - 1);
10780 ip = (ip6_header_t *) mask;
10782 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
10783 foreach_ip6_proto_field;
10786 ip_version_traffic_class_and_flow_label = 0;
10789 ip_version_traffic_class_and_flow_label |= 0xF0000000;
10792 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
10795 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
10797 ip->ip_version_traffic_class_and_flow_label =
10798 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10805 unformat_l3_mask (unformat_input_t * input, va_list * args)
10807 u8 **maskp = va_arg (*args, u8 **);
10809 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10811 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
10813 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
10822 unformat_l2_mask (unformat_input_t * input, va_list * args)
10824 u8 **maskp = va_arg (*args, u8 **);
10831 u8 ignore_tag1 = 0;
10832 u8 ignore_tag2 = 0;
10839 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10841 if (unformat (input, "src"))
10843 else if (unformat (input, "dst"))
10845 else if (unformat (input, "proto"))
10847 else if (unformat (input, "tag1"))
10849 else if (unformat (input, "tag2"))
10851 else if (unformat (input, "ignore-tag1"))
10853 else if (unformat (input, "ignore-tag2"))
10855 else if (unformat (input, "cos1"))
10857 else if (unformat (input, "cos2"))
10859 else if (unformat (input, "dot1q"))
10861 else if (unformat (input, "dot1ad"))
10866 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
10867 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10870 if (tag1 || ignore_tag1 || cos1 || dot1q)
10872 if (tag2 || ignore_tag2 || cos2 || dot1ad)
10875 vec_validate (mask, len - 1);
10878 clib_memset (mask, 0xff, 6);
10881 clib_memset (mask + 6, 0xff, 6);
10883 if (tag2 || dot1ad)
10885 /* inner vlan tag */
10894 mask[21] = mask[20] = 0xff;
10915 mask[16] = mask[17] = 0xff;
10925 mask[12] = mask[13] = 0xff;
10932 unformat_classify_mask (unformat_input_t * input, va_list * args)
10934 u8 **maskp = va_arg (*args, u8 **);
10935 u32 *skipp = va_arg (*args, u32 *);
10936 u32 *matchp = va_arg (*args, u32 *);
10944 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10946 if (unformat (input, "hex %U", unformat_hex_string, &mask))
10948 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
10950 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
10952 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
10966 if (mask || l2 || l3 || l4)
10968 if (l2 || l3 || l4)
10970 /* "With a free Ethernet header in every package" */
10972 vec_validate (l2, 13);
10976 vec_append (mask, l3);
10981 vec_append (mask, l4);
10986 /* Scan forward looking for the first significant mask octet */
10987 for (i = 0; i < vec_len (mask); i++)
10991 /* compute (skip, match) params */
10992 *skipp = i / sizeof (u32x4);
10993 vec_delete (mask, *skipp * sizeof (u32x4), 0);
10995 /* Pad mask to an even multiple of the vector size */
10996 while (vec_len (mask) % sizeof (u32x4))
10997 vec_add1 (mask, 0);
10999 match = vec_len (mask) / sizeof (u32x4);
11001 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
11003 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
11004 if (*tmp || *(tmp + 1))
11009 clib_warning ("BUG: match 0");
11011 _vec_len (mask) = match * sizeof (u32x4);
11021 #endif /* VPP_API_TEST_BUILTIN */
11023 #define foreach_l2_next \
11025 _(ethernet, ETHERNET_INPUT) \
11026 _(ip4, IP4_INPUT) \
11030 unformat_l2_next_index (unformat_input_t * input, va_list * args)
11032 u32 *miss_next_indexp = va_arg (*args, u32 *);
11033 u32 next_index = 0;
11037 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
11041 if (unformat (input, "%d", &tmp))
11050 *miss_next_indexp = next_index;
11054 #define foreach_ip_next \
11057 _(rewrite, REWRITE)
11060 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
11062 u32 *miss_next_indexp = va_arg (*args, u32 *);
11063 u32 next_index = 0;
11067 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
11071 if (unformat (input, "%d", &tmp))
11080 *miss_next_indexp = next_index;
11084 #define foreach_acl_next \
11088 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
11090 u32 *miss_next_indexp = va_arg (*args, u32 *);
11091 u32 next_index = 0;
11095 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
11099 if (unformat (input, "permit"))
11104 else if (unformat (input, "%d", &tmp))
11113 *miss_next_indexp = next_index;
11118 unformat_policer_precolor (unformat_input_t * input, va_list * args)
11120 u32 *r = va_arg (*args, u32 *);
11122 if (unformat (input, "conform-color"))
11123 *r = POLICE_CONFORM;
11124 else if (unformat (input, "exceed-color"))
11125 *r = POLICE_EXCEED;
11133 api_classify_add_del_table (vat_main_t * vam)
11135 unformat_input_t *i = vam->input;
11136 vl_api_classify_add_del_table_t *mp;
11143 u32 table_index = ~0;
11144 u32 next_table_index = ~0;
11145 u32 miss_next_index = ~0;
11146 u32 memory_size = 32 << 20;
11148 u32 current_data_flag = 0;
11149 int current_data_offset = 0;
11152 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11154 if (unformat (i, "del"))
11156 else if (unformat (i, "del-chain"))
11161 else if (unformat (i, "buckets %d", &nbuckets))
11163 else if (unformat (i, "memory_size %d", &memory_size))
11165 else if (unformat (i, "skip %d", &skip))
11167 else if (unformat (i, "match %d", &match))
11169 else if (unformat (i, "table %d", &table_index))
11171 else if (unformat (i, "mask %U", unformat_classify_mask,
11172 &mask, &skip, &match))
11174 else if (unformat (i, "next-table %d", &next_table_index))
11176 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
11179 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
11182 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
11185 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
11187 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
11193 if (is_add && mask == 0)
11195 errmsg ("Mask required");
11199 if (is_add && skip == ~0)
11201 errmsg ("skip count required");
11205 if (is_add && match == ~0)
11207 errmsg ("match count required");
11211 if (!is_add && table_index == ~0)
11213 errmsg ("table index required for delete");
11217 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
11219 mp->is_add = is_add;
11220 mp->del_chain = del_chain;
11221 mp->table_index = ntohl (table_index);
11222 mp->nbuckets = ntohl (nbuckets);
11223 mp->memory_size = ntohl (memory_size);
11224 mp->skip_n_vectors = ntohl (skip);
11225 mp->match_n_vectors = ntohl (match);
11226 mp->next_table_index = ntohl (next_table_index);
11227 mp->miss_next_index = ntohl (miss_next_index);
11228 mp->current_data_flag = ntohl (current_data_flag);
11229 mp->current_data_offset = ntohl (current_data_offset);
11230 mp->mask_len = ntohl (vec_len (mask));
11231 clib_memcpy (mp->mask, mask, vec_len (mask));
11240 #if VPP_API_TEST_BUILTIN == 0
11242 unformat_l4_match (unformat_input_t * input, va_list * args)
11244 u8 **matchp = va_arg (*args, u8 **);
11246 u8 *proto_header = 0;
11252 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11254 if (unformat (input, "src_port %d", &src_port))
11256 else if (unformat (input, "dst_port %d", &dst_port))
11262 h.src_port = clib_host_to_net_u16 (src_port);
11263 h.dst_port = clib_host_to_net_u16 (dst_port);
11264 vec_validate (proto_header, sizeof (h) - 1);
11265 memcpy (proto_header, &h, sizeof (h));
11267 *matchp = proto_header;
11273 unformat_ip4_match (unformat_input_t * input, va_list * args)
11275 u8 **matchp = va_arg (*args, u8 **);
11280 int hdr_length = 0;
11281 u32 hdr_length_val;
11282 int src = 0, dst = 0;
11283 ip4_address_t src_val, dst_val;
11290 int fragment_id = 0;
11291 u32 fragment_id_val;
11297 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11299 if (unformat (input, "version %d", &version_val))
11301 else if (unformat (input, "hdr_length %d", &hdr_length_val))
11303 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
11305 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
11307 else if (unformat (input, "proto %d", &proto_val))
11309 else if (unformat (input, "tos %d", &tos_val))
11311 else if (unformat (input, "length %d", &length_val))
11313 else if (unformat (input, "fragment_id %d", &fragment_id_val))
11315 else if (unformat (input, "ttl %d", &ttl_val))
11317 else if (unformat (input, "checksum %d", &checksum_val))
11323 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
11324 + ttl + checksum == 0)
11328 * Aligned because we use the real comparison functions
11330 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11332 ip = (ip4_header_t *) match;
11334 /* These are realistically matched in practice */
11336 ip->src_address.as_u32 = src_val.as_u32;
11339 ip->dst_address.as_u32 = dst_val.as_u32;
11342 ip->protocol = proto_val;
11345 /* These are not, but they're included for completeness */
11347 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
11350 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
11356 ip->length = clib_host_to_net_u16 (length_val);
11362 ip->checksum = clib_host_to_net_u16 (checksum_val);
11369 unformat_ip6_match (unformat_input_t * input, va_list * args)
11371 u8 **matchp = va_arg (*args, u8 **);
11376 u8 traffic_class = 0;
11377 u32 traffic_class_val = 0;
11380 int src = 0, dst = 0;
11381 ip6_address_t src_val, dst_val;
11384 int payload_length = 0;
11385 u32 payload_length_val;
11388 u32 ip_version_traffic_class_and_flow_label;
11390 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11392 if (unformat (input, "version %d", &version_val))
11394 else if (unformat (input, "traffic_class %d", &traffic_class_val))
11396 else if (unformat (input, "flow_label %d", &flow_label_val))
11398 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
11400 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
11402 else if (unformat (input, "proto %d", &proto_val))
11404 else if (unformat (input, "payload_length %d", &payload_length_val))
11405 payload_length = 1;
11406 else if (unformat (input, "hop_limit %d", &hop_limit_val))
11412 if (version + traffic_class + flow_label + src + dst + proto +
11413 payload_length + hop_limit == 0)
11417 * Aligned because we use the real comparison functions
11419 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11421 ip = (ip6_header_t *) match;
11424 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
11427 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
11430 ip->protocol = proto_val;
11432 ip_version_traffic_class_and_flow_label = 0;
11435 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
11438 ip_version_traffic_class_and_flow_label |=
11439 (traffic_class_val & 0xFF) << 20;
11442 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
11444 ip->ip_version_traffic_class_and_flow_label =
11445 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
11447 if (payload_length)
11448 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
11451 ip->hop_limit = hop_limit_val;
11458 unformat_l3_match (unformat_input_t * input, va_list * args)
11460 u8 **matchp = va_arg (*args, u8 **);
11462 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11464 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
11466 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
11475 unformat_vlan_tag (unformat_input_t * input, va_list * args)
11477 u8 *tagp = va_arg (*args, u8 *);
11480 if (unformat (input, "%d", &tag))
11482 tagp[0] = (tag >> 8) & 0x0F;
11483 tagp[1] = tag & 0xFF;
11491 unformat_l2_match (unformat_input_t * input, va_list * args)
11493 u8 **matchp = va_arg (*args, u8 **);
11506 u8 ignore_tag1 = 0;
11507 u8 ignore_tag2 = 0;
11513 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11515 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
11518 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
11520 else if (unformat (input, "proto %U",
11521 unformat_ethernet_type_host_byte_order, &proto_val))
11523 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
11525 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
11527 else if (unformat (input, "ignore-tag1"))
11529 else if (unformat (input, "ignore-tag2"))
11531 else if (unformat (input, "cos1 %d", &cos1_val))
11533 else if (unformat (input, "cos2 %d", &cos2_val))
11538 if ((src + dst + proto + tag1 + tag2 +
11539 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
11542 if (tag1 || ignore_tag1 || cos1)
11544 if (tag2 || ignore_tag2 || cos2)
11547 vec_validate_aligned (match, len - 1, sizeof (u32x4));
11550 clib_memcpy (match, dst_val, 6);
11553 clib_memcpy (match + 6, src_val, 6);
11557 /* inner vlan tag */
11558 match[19] = tag2_val[1];
11559 match[18] = tag2_val[0];
11561 match[18] |= (cos2_val & 0x7) << 5;
11564 match[21] = proto_val & 0xff;
11565 match[20] = proto_val >> 8;
11569 match[15] = tag1_val[1];
11570 match[14] = tag1_val[0];
11573 match[14] |= (cos1_val & 0x7) << 5;
11579 match[15] = tag1_val[1];
11580 match[14] = tag1_val[0];
11583 match[17] = proto_val & 0xff;
11584 match[16] = proto_val >> 8;
11587 match[14] |= (cos1_val & 0x7) << 5;
11593 match[18] |= (cos2_val & 0x7) << 5;
11595 match[14] |= (cos1_val & 0x7) << 5;
11598 match[13] = proto_val & 0xff;
11599 match[12] = proto_val >> 8;
11607 unformat_qos_source (unformat_input_t * input, va_list * args)
11609 int *qs = va_arg (*args, int *);
11611 if (unformat (input, "ip"))
11612 *qs = QOS_SOURCE_IP;
11613 else if (unformat (input, "mpls"))
11614 *qs = QOS_SOURCE_MPLS;
11615 else if (unformat (input, "ext"))
11616 *qs = QOS_SOURCE_EXT;
11617 else if (unformat (input, "vlan"))
11618 *qs = QOS_SOURCE_VLAN;
11627 api_unformat_classify_match (unformat_input_t * input, va_list * args)
11629 u8 **matchp = va_arg (*args, u8 **);
11630 u32 skip_n_vectors = va_arg (*args, u32);
11631 u32 match_n_vectors = va_arg (*args, u32);
11638 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11640 if (unformat (input, "hex %U", unformat_hex_string, &match))
11642 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
11644 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
11646 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
11660 if (match || l2 || l3 || l4)
11662 if (l2 || l3 || l4)
11664 /* "Win a free Ethernet header in every packet" */
11666 vec_validate_aligned (l2, 13, sizeof (u32x4));
11670 vec_append_aligned (match, l3, sizeof (u32x4));
11675 vec_append_aligned (match, l4, sizeof (u32x4));
11680 /* Make sure the vector is big enough even if key is all 0's */
11681 vec_validate_aligned
11682 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
11685 /* Set size, include skipped vectors */
11686 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
11697 api_classify_add_del_session (vat_main_t * vam)
11699 unformat_input_t *i = vam->input;
11700 vl_api_classify_add_del_session_t *mp;
11702 u32 table_index = ~0;
11703 u32 hit_next_index = ~0;
11704 u32 opaque_index = ~0;
11707 u32 skip_n_vectors = 0;
11708 u32 match_n_vectors = 0;
11714 * Warning: you have to supply skip_n and match_n
11715 * because the API client cant simply look at the classify
11719 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11721 if (unformat (i, "del"))
11723 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
11726 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
11729 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
11732 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
11734 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
11736 else if (unformat (i, "opaque-index %d", &opaque_index))
11738 else if (unformat (i, "skip_n %d", &skip_n_vectors))
11740 else if (unformat (i, "match_n %d", &match_n_vectors))
11742 else if (unformat (i, "match %U", api_unformat_classify_match,
11743 &match, skip_n_vectors, match_n_vectors))
11745 else if (unformat (i, "advance %d", &advance))
11747 else if (unformat (i, "table-index %d", &table_index))
11749 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
11751 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
11753 else if (unformat (i, "action %d", &action))
11755 else if (unformat (i, "metadata %d", &metadata))
11761 if (table_index == ~0)
11763 errmsg ("Table index required");
11767 if (is_add && match == 0)
11769 errmsg ("Match value required");
11773 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
11775 mp->is_add = is_add;
11776 mp->table_index = ntohl (table_index);
11777 mp->hit_next_index = ntohl (hit_next_index);
11778 mp->opaque_index = ntohl (opaque_index);
11779 mp->advance = ntohl (advance);
11780 mp->action = action;
11781 mp->metadata = ntohl (metadata);
11782 mp->match_len = ntohl (vec_len (match));
11783 clib_memcpy (mp->match, match, vec_len (match));
11792 api_classify_set_interface_ip_table (vat_main_t * vam)
11794 unformat_input_t *i = vam->input;
11795 vl_api_classify_set_interface_ip_table_t *mp;
11797 int sw_if_index_set;
11798 u32 table_index = ~0;
11802 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11804 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11805 sw_if_index_set = 1;
11806 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11807 sw_if_index_set = 1;
11808 else if (unformat (i, "table %d", &table_index))
11812 clib_warning ("parse error '%U'", format_unformat_error, i);
11817 if (sw_if_index_set == 0)
11819 errmsg ("missing interface name or sw_if_index");
11824 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
11826 mp->sw_if_index = ntohl (sw_if_index);
11827 mp->table_index = ntohl (table_index);
11828 mp->is_ipv6 = is_ipv6;
11836 api_classify_set_interface_l2_tables (vat_main_t * vam)
11838 unformat_input_t *i = vam->input;
11839 vl_api_classify_set_interface_l2_tables_t *mp;
11841 int sw_if_index_set;
11842 u32 ip4_table_index = ~0;
11843 u32 ip6_table_index = ~0;
11844 u32 other_table_index = ~0;
11848 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11850 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11851 sw_if_index_set = 1;
11852 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11853 sw_if_index_set = 1;
11854 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11856 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11858 else if (unformat (i, "other-table %d", &other_table_index))
11860 else if (unformat (i, "is-input %d", &is_input))
11864 clib_warning ("parse error '%U'", format_unformat_error, i);
11869 if (sw_if_index_set == 0)
11871 errmsg ("missing interface name or sw_if_index");
11876 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
11878 mp->sw_if_index = ntohl (sw_if_index);
11879 mp->ip4_table_index = ntohl (ip4_table_index);
11880 mp->ip6_table_index = ntohl (ip6_table_index);
11881 mp->other_table_index = ntohl (other_table_index);
11882 mp->is_input = (u8) is_input;
11890 api_set_ipfix_exporter (vat_main_t * vam)
11892 unformat_input_t *i = vam->input;
11893 vl_api_set_ipfix_exporter_t *mp;
11894 ip4_address_t collector_address;
11895 u8 collector_address_set = 0;
11896 u32 collector_port = ~0;
11897 ip4_address_t src_address;
11898 u8 src_address_set = 0;
11901 u32 template_interval = ~0;
11902 u8 udp_checksum = 0;
11905 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11907 if (unformat (i, "collector_address %U", unformat_ip4_address,
11908 &collector_address))
11909 collector_address_set = 1;
11910 else if (unformat (i, "collector_port %d", &collector_port))
11912 else if (unformat (i, "src_address %U", unformat_ip4_address,
11914 src_address_set = 1;
11915 else if (unformat (i, "vrf_id %d", &vrf_id))
11917 else if (unformat (i, "path_mtu %d", &path_mtu))
11919 else if (unformat (i, "template_interval %d", &template_interval))
11921 else if (unformat (i, "udp_checksum"))
11927 if (collector_address_set == 0)
11929 errmsg ("collector_address required");
11933 if (src_address_set == 0)
11935 errmsg ("src_address required");
11939 M (SET_IPFIX_EXPORTER, mp);
11941 memcpy (mp->collector_address, collector_address.data,
11942 sizeof (collector_address.data));
11943 mp->collector_port = htons ((u16) collector_port);
11944 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
11945 mp->vrf_id = htonl (vrf_id);
11946 mp->path_mtu = htonl (path_mtu);
11947 mp->template_interval = htonl (template_interval);
11948 mp->udp_checksum = udp_checksum;
11956 api_set_ipfix_classify_stream (vat_main_t * vam)
11958 unformat_input_t *i = vam->input;
11959 vl_api_set_ipfix_classify_stream_t *mp;
11961 u32 src_port = UDP_DST_PORT_ipfix;
11964 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11966 if (unformat (i, "domain %d", &domain_id))
11968 else if (unformat (i, "src_port %d", &src_port))
11972 errmsg ("unknown input `%U'", format_unformat_error, i);
11977 M (SET_IPFIX_CLASSIFY_STREAM, mp);
11979 mp->domain_id = htonl (domain_id);
11980 mp->src_port = htons ((u16) src_port);
11988 api_ipfix_classify_table_add_del (vat_main_t * vam)
11990 unformat_input_t *i = vam->input;
11991 vl_api_ipfix_classify_table_add_del_t *mp;
11993 u32 classify_table_index = ~0;
11995 u8 transport_protocol = 255;
11998 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12000 if (unformat (i, "add"))
12002 else if (unformat (i, "del"))
12004 else if (unformat (i, "table %d", &classify_table_index))
12006 else if (unformat (i, "ip4"))
12008 else if (unformat (i, "ip6"))
12010 else if (unformat (i, "tcp"))
12011 transport_protocol = 6;
12012 else if (unformat (i, "udp"))
12013 transport_protocol = 17;
12016 errmsg ("unknown input `%U'", format_unformat_error, i);
12023 errmsg ("expecting: add|del");
12026 if (classify_table_index == ~0)
12028 errmsg ("classifier table not specified");
12031 if (ip_version == 0)
12033 errmsg ("IP version not specified");
12037 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
12039 mp->is_add = is_add;
12040 mp->table_id = htonl (classify_table_index);
12041 mp->ip_version = ip_version;
12042 mp->transport_protocol = transport_protocol;
12050 api_get_node_index (vat_main_t * vam)
12052 unformat_input_t *i = vam->input;
12053 vl_api_get_node_index_t *mp;
12057 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12059 if (unformat (i, "node %s", &name))
12066 errmsg ("node name required");
12069 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
12071 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12075 M (GET_NODE_INDEX, mp);
12076 clib_memcpy (mp->node_name, name, vec_len (name));
12085 api_get_next_index (vat_main_t * vam)
12087 unformat_input_t *i = vam->input;
12088 vl_api_get_next_index_t *mp;
12089 u8 *node_name = 0, *next_node_name = 0;
12092 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12094 if (unformat (i, "node-name %s", &node_name))
12096 else if (unformat (i, "next-node-name %s", &next_node_name))
12100 if (node_name == 0)
12102 errmsg ("node name required");
12105 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
12107 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12111 if (next_node_name == 0)
12113 errmsg ("next node name required");
12116 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
12118 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
12122 M (GET_NEXT_INDEX, mp);
12123 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
12124 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
12125 vec_free (node_name);
12126 vec_free (next_node_name);
12134 api_add_node_next (vat_main_t * vam)
12136 unformat_input_t *i = vam->input;
12137 vl_api_add_node_next_t *mp;
12142 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12144 if (unformat (i, "node %s", &name))
12146 else if (unformat (i, "next %s", &next))
12153 errmsg ("node name required");
12156 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
12158 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12163 errmsg ("next node required");
12166 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
12168 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
12172 M (ADD_NODE_NEXT, mp);
12173 clib_memcpy (mp->node_name, name, vec_len (name));
12174 clib_memcpy (mp->next_name, next, vec_len (next));
12184 api_l2tpv3_create_tunnel (vat_main_t * vam)
12186 unformat_input_t *i = vam->input;
12187 ip6_address_t client_address, our_address;
12188 int client_address_set = 0;
12189 int our_address_set = 0;
12190 u32 local_session_id = 0;
12191 u32 remote_session_id = 0;
12192 u64 local_cookie = 0;
12193 u64 remote_cookie = 0;
12194 u8 l2_sublayer_present = 0;
12195 vl_api_l2tpv3_create_tunnel_t *mp;
12198 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12200 if (unformat (i, "client_address %U", unformat_ip6_address,
12202 client_address_set = 1;
12203 else if (unformat (i, "our_address %U", unformat_ip6_address,
12205 our_address_set = 1;
12206 else if (unformat (i, "local_session_id %d", &local_session_id))
12208 else if (unformat (i, "remote_session_id %d", &remote_session_id))
12210 else if (unformat (i, "local_cookie %lld", &local_cookie))
12212 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
12214 else if (unformat (i, "l2-sublayer-present"))
12215 l2_sublayer_present = 1;
12220 if (client_address_set == 0)
12222 errmsg ("client_address required");
12226 if (our_address_set == 0)
12228 errmsg ("our_address required");
12232 M (L2TPV3_CREATE_TUNNEL, mp);
12234 clib_memcpy (mp->client_address, client_address.as_u8,
12235 sizeof (mp->client_address));
12237 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
12239 mp->local_session_id = ntohl (local_session_id);
12240 mp->remote_session_id = ntohl (remote_session_id);
12241 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
12242 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
12243 mp->l2_sublayer_present = l2_sublayer_present;
12252 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
12254 unformat_input_t *i = vam->input;
12256 u8 sw_if_index_set = 0;
12257 u64 new_local_cookie = 0;
12258 u64 new_remote_cookie = 0;
12259 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
12262 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12264 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12265 sw_if_index_set = 1;
12266 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12267 sw_if_index_set = 1;
12268 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
12270 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
12276 if (sw_if_index_set == 0)
12278 errmsg ("missing interface name or sw_if_index");
12282 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
12284 mp->sw_if_index = ntohl (sw_if_index);
12285 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
12286 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
12294 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
12296 unformat_input_t *i = vam->input;
12297 vl_api_l2tpv3_interface_enable_disable_t *mp;
12299 u8 sw_if_index_set = 0;
12300 u8 enable_disable = 1;
12303 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12305 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12306 sw_if_index_set = 1;
12307 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12308 sw_if_index_set = 1;
12309 else if (unformat (i, "enable"))
12310 enable_disable = 1;
12311 else if (unformat (i, "disable"))
12312 enable_disable = 0;
12317 if (sw_if_index_set == 0)
12319 errmsg ("missing interface name or sw_if_index");
12323 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
12325 mp->sw_if_index = ntohl (sw_if_index);
12326 mp->enable_disable = enable_disable;
12334 api_l2tpv3_set_lookup_key (vat_main_t * vam)
12336 unformat_input_t *i = vam->input;
12337 vl_api_l2tpv3_set_lookup_key_t *mp;
12341 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12343 if (unformat (i, "lookup_v6_src"))
12344 key = L2T_LOOKUP_SRC_ADDRESS;
12345 else if (unformat (i, "lookup_v6_dst"))
12346 key = L2T_LOOKUP_DST_ADDRESS;
12347 else if (unformat (i, "lookup_session_id"))
12348 key = L2T_LOOKUP_SESSION_ID;
12353 if (key == (u8) ~ 0)
12355 errmsg ("l2tp session lookup key unset");
12359 M (L2TPV3_SET_LOOKUP_KEY, mp);
12368 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
12369 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12371 vat_main_t *vam = &vat_main;
12373 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
12374 format_ip6_address, mp->our_address,
12375 format_ip6_address, mp->client_address,
12376 clib_net_to_host_u32 (mp->sw_if_index));
12379 " local cookies %016llx %016llx remote cookie %016llx",
12380 clib_net_to_host_u64 (mp->local_cookie[0]),
12381 clib_net_to_host_u64 (mp->local_cookie[1]),
12382 clib_net_to_host_u64 (mp->remote_cookie));
12384 print (vam->ofp, " local session-id %d remote session-id %d",
12385 clib_net_to_host_u32 (mp->local_session_id),
12386 clib_net_to_host_u32 (mp->remote_session_id));
12388 print (vam->ofp, " l2 specific sublayer %s\n",
12389 mp->l2_sublayer_present ? "preset" : "absent");
12393 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
12394 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12396 vat_main_t *vam = &vat_main;
12397 vat_json_node_t *node = NULL;
12398 struct in6_addr addr;
12400 if (VAT_JSON_ARRAY != vam->json_tree.type)
12402 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12403 vat_json_init_array (&vam->json_tree);
12405 node = vat_json_array_add (&vam->json_tree);
12407 vat_json_init_object (node);
12409 clib_memcpy (&addr, mp->our_address, sizeof (addr));
12410 vat_json_object_add_ip6 (node, "our_address", addr);
12411 clib_memcpy (&addr, mp->client_address, sizeof (addr));
12412 vat_json_object_add_ip6 (node, "client_address", addr);
12414 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
12415 vat_json_init_array (lc);
12416 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
12417 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
12418 vat_json_object_add_uint (node, "remote_cookie",
12419 clib_net_to_host_u64 (mp->remote_cookie));
12421 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
12422 vat_json_object_add_uint (node, "local_session_id",
12423 clib_net_to_host_u32 (mp->local_session_id));
12424 vat_json_object_add_uint (node, "remote_session_id",
12425 clib_net_to_host_u32 (mp->remote_session_id));
12426 vat_json_object_add_string_copy (node, "l2_sublayer",
12427 mp->l2_sublayer_present ? (u8 *) "present"
12428 : (u8 *) "absent");
12432 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
12434 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
12435 vl_api_control_ping_t *mp_ping;
12438 /* Get list of l2tpv3-tunnel interfaces */
12439 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
12442 /* Use a control ping for synchronization */
12443 MPING (CONTROL_PING, mp_ping);
12451 static void vl_api_sw_interface_tap_v2_details_t_handler
12452 (vl_api_sw_interface_tap_v2_details_t * mp)
12454 vat_main_t *vam = &vat_main;
12456 u8 *ip4 = format (0, "%U/%d", format_ip4_address, mp->host_ip4_addr,
12457 mp->host_ip4_prefix_len);
12458 u8 *ip6 = format (0, "%U/%d", format_ip6_address, mp->host_ip6_addr,
12459 mp->host_ip6_prefix_len);
12462 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s 0x%-08x",
12463 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
12464 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
12465 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
12466 mp->host_bridge, ip4, ip6, ntohl (mp->tap_flags));
12472 static void vl_api_sw_interface_tap_v2_details_t_handler_json
12473 (vl_api_sw_interface_tap_v2_details_t * mp)
12475 vat_main_t *vam = &vat_main;
12476 vat_json_node_t *node = NULL;
12478 if (VAT_JSON_ARRAY != vam->json_tree.type)
12480 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12481 vat_json_init_array (&vam->json_tree);
12483 node = vat_json_array_add (&vam->json_tree);
12485 vat_json_init_object (node);
12486 vat_json_object_add_uint (node, "id", ntohl (mp->id));
12487 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12488 vat_json_object_add_uint (node, "tap_flags", ntohl (mp->tap_flags));
12489 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
12490 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
12491 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
12492 vat_json_object_add_string_copy (node, "host_mac_addr",
12493 format (0, "%U", format_ethernet_address,
12494 &mp->host_mac_addr));
12495 vat_json_object_add_string_copy (node, "host_namespace",
12496 mp->host_namespace);
12497 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
12498 vat_json_object_add_string_copy (node, "host_ip4_addr",
12499 format (0, "%U/%d", format_ip4_address,
12501 mp->host_ip4_prefix_len));
12502 vat_json_object_add_string_copy (node, "host_ip6_addr",
12503 format (0, "%U/%d", format_ip6_address,
12505 mp->host_ip6_prefix_len));
12510 api_sw_interface_tap_v2_dump (vat_main_t * vam)
12512 vl_api_sw_interface_tap_v2_dump_t *mp;
12513 vl_api_control_ping_t *mp_ping;
12517 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
12518 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
12519 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
12522 /* Get list of tap interfaces */
12523 M (SW_INTERFACE_TAP_V2_DUMP, mp);
12526 /* Use a control ping for synchronization */
12527 MPING (CONTROL_PING, mp_ping);
12534 static void vl_api_sw_interface_virtio_pci_details_t_handler
12535 (vl_api_sw_interface_virtio_pci_details_t * mp)
12537 vat_main_t *vam = &vat_main;
12551 addr.as_u32 = ntohl (mp->pci_addr);
12552 u8 *pci_addr = format (0, "%04x:%02x:%02x.%x", addr.domain, addr.bus,
12553 addr.slot, addr.function);
12556 "\n%-12s %-12d %-12d %-12d %-17U 0x%-08llx",
12557 pci_addr, ntohl (mp->sw_if_index),
12558 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
12559 format_ethernet_address, mp->mac_addr,
12560 clib_net_to_host_u64 (mp->features));
12561 vec_free (pci_addr);
12564 static void vl_api_sw_interface_virtio_pci_details_t_handler_json
12565 (vl_api_sw_interface_virtio_pci_details_t * mp)
12567 vat_main_t *vam = &vat_main;
12568 vat_json_node_t *node = NULL;
12570 if (VAT_JSON_ARRAY != vam->json_tree.type)
12572 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12573 vat_json_init_array (&vam->json_tree);
12575 node = vat_json_array_add (&vam->json_tree);
12577 vat_json_init_object (node);
12578 vat_json_object_add_uint (node, "pci-addr", ntohl (mp->pci_addr));
12579 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12580 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
12581 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
12582 vat_json_object_add_uint (node, "features",
12583 clib_net_to_host_u64 (mp->features));
12584 vat_json_object_add_string_copy (node, "mac_addr",
12585 format (0, "%U", format_ethernet_address,
12590 api_sw_interface_virtio_pci_dump (vat_main_t * vam)
12592 vl_api_sw_interface_virtio_pci_dump_t *mp;
12593 vl_api_control_ping_t *mp_ping;
12597 "\n%-12s %-12s %-12s %-12s %-17s %-08s",
12598 "pci_addr", "sw_if_index", "rx_ring_sz", "tx_ring_sz",
12599 "mac_addr", "features");
12601 /* Get list of tap interfaces */
12602 M (SW_INTERFACE_VIRTIO_PCI_DUMP, mp);
12605 /* Use a control ping for synchronization */
12606 MPING (CONTROL_PING, mp_ping);
12614 api_vxlan_offload_rx (vat_main_t * vam)
12616 unformat_input_t *line_input = vam->input;
12617 vl_api_vxlan_offload_rx_t *mp;
12618 u32 hw_if_index = ~0, rx_if_index = ~0;
12622 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12624 if (unformat (line_input, "del"))
12626 else if (unformat (line_input, "hw %U", api_unformat_hw_if_index, vam,
12629 else if (unformat (line_input, "hw hw_if_index %u", &hw_if_index))
12631 else if (unformat (line_input, "rx %U", api_unformat_sw_if_index, vam,
12634 else if (unformat (line_input, "rx sw_if_index %u", &rx_if_index))
12638 errmsg ("parse error '%U'", format_unformat_error, line_input);
12643 if (hw_if_index == ~0)
12645 errmsg ("no hw interface");
12649 if (rx_if_index == ~0)
12651 errmsg ("no rx tunnel");
12655 M (VXLAN_OFFLOAD_RX, mp);
12657 mp->hw_if_index = ntohl (hw_if_index);
12658 mp->sw_if_index = ntohl (rx_if_index);
12659 mp->enable = is_add;
12666 static uword unformat_vxlan_decap_next
12667 (unformat_input_t * input, va_list * args)
12669 u32 *result = va_arg (*args, u32 *);
12672 if (unformat (input, "l2"))
12673 *result = VXLAN_INPUT_NEXT_L2_INPUT;
12674 else if (unformat (input, "%d", &tmp))
12682 api_vxlan_add_del_tunnel (vat_main_t * vam)
12684 unformat_input_t *line_input = vam->input;
12685 vl_api_vxlan_add_del_tunnel_t *mp;
12686 ip46_address_t src, dst;
12688 u8 ipv4_set = 0, ipv6_set = 0;
12693 u32 mcast_sw_if_index = ~0;
12694 u32 encap_vrf_id = 0;
12695 u32 decap_next_index = ~0;
12699 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12700 clib_memset (&src, 0, sizeof src);
12701 clib_memset (&dst, 0, sizeof dst);
12703 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12705 if (unformat (line_input, "del"))
12707 else if (unformat (line_input, "instance %d", &instance))
12710 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12716 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12722 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12728 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12733 else if (unformat (line_input, "group %U %U",
12734 unformat_ip4_address, &dst.ip4,
12735 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12737 grp_set = dst_set = 1;
12740 else if (unformat (line_input, "group %U",
12741 unformat_ip4_address, &dst.ip4))
12743 grp_set = dst_set = 1;
12746 else if (unformat (line_input, "group %U %U",
12747 unformat_ip6_address, &dst.ip6,
12748 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12750 grp_set = dst_set = 1;
12753 else if (unformat (line_input, "group %U",
12754 unformat_ip6_address, &dst.ip6))
12756 grp_set = dst_set = 1;
12760 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12762 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12764 else if (unformat (line_input, "decap-next %U",
12765 unformat_vxlan_decap_next, &decap_next_index))
12767 else if (unformat (line_input, "vni %d", &vni))
12771 errmsg ("parse error '%U'", format_unformat_error, line_input);
12778 errmsg ("tunnel src address not specified");
12783 errmsg ("tunnel dst address not specified");
12787 if (grp_set && !ip46_address_is_multicast (&dst))
12789 errmsg ("tunnel group address not multicast");
12792 if (grp_set && mcast_sw_if_index == ~0)
12794 errmsg ("tunnel nonexistent multicast device");
12797 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12799 errmsg ("tunnel dst address must be unicast");
12804 if (ipv4_set && ipv6_set)
12806 errmsg ("both IPv4 and IPv6 addresses specified");
12810 if ((vni == 0) || (vni >> 24))
12812 errmsg ("vni not specified or out of range");
12816 M (VXLAN_ADD_DEL_TUNNEL, mp);
12820 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
12821 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
12825 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
12826 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
12829 mp->instance = htonl (instance);
12830 mp->encap_vrf_id = ntohl (encap_vrf_id);
12831 mp->decap_next_index = ntohl (decap_next_index);
12832 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12833 mp->vni = ntohl (vni);
12834 mp->is_add = is_add;
12835 mp->is_ipv6 = ipv6_set;
12842 static void vl_api_vxlan_tunnel_details_t_handler
12843 (vl_api_vxlan_tunnel_details_t * mp)
12845 vat_main_t *vam = &vat_main;
12846 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12847 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12849 print (vam->ofp, "%11d%11d%24U%24U%14d%18d%13d%19d",
12850 ntohl (mp->sw_if_index),
12851 ntohl (mp->instance),
12852 format_ip46_address, &src, IP46_TYPE_ANY,
12853 format_ip46_address, &dst, IP46_TYPE_ANY,
12854 ntohl (mp->encap_vrf_id),
12855 ntohl (mp->decap_next_index), ntohl (mp->vni),
12856 ntohl (mp->mcast_sw_if_index));
12859 static void vl_api_vxlan_tunnel_details_t_handler_json
12860 (vl_api_vxlan_tunnel_details_t * mp)
12862 vat_main_t *vam = &vat_main;
12863 vat_json_node_t *node = NULL;
12865 if (VAT_JSON_ARRAY != vam->json_tree.type)
12867 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12868 vat_json_init_array (&vam->json_tree);
12870 node = vat_json_array_add (&vam->json_tree);
12872 vat_json_init_object (node);
12873 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12875 vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
12879 struct in6_addr ip6;
12881 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12882 vat_json_object_add_ip6 (node, "src_address", ip6);
12883 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12884 vat_json_object_add_ip6 (node, "dst_address", ip6);
12888 struct in_addr ip4;
12890 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12891 vat_json_object_add_ip4 (node, "src_address", ip4);
12892 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12893 vat_json_object_add_ip4 (node, "dst_address", ip4);
12895 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12896 vat_json_object_add_uint (node, "decap_next_index",
12897 ntohl (mp->decap_next_index));
12898 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12899 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12900 vat_json_object_add_uint (node, "mcast_sw_if_index",
12901 ntohl (mp->mcast_sw_if_index));
12905 api_vxlan_tunnel_dump (vat_main_t * vam)
12907 unformat_input_t *i = vam->input;
12908 vl_api_vxlan_tunnel_dump_t *mp;
12909 vl_api_control_ping_t *mp_ping;
12911 u8 sw_if_index_set = 0;
12914 /* Parse args required to build the message */
12915 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12917 if (unformat (i, "sw_if_index %d", &sw_if_index))
12918 sw_if_index_set = 1;
12923 if (sw_if_index_set == 0)
12928 if (!vam->json_output)
12930 print (vam->ofp, "%11s%11s%24s%24s%14s%18s%13s%19s",
12931 "sw_if_index", "instance", "src_address", "dst_address",
12932 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12935 /* Get list of vxlan-tunnel interfaces */
12936 M (VXLAN_TUNNEL_DUMP, mp);
12938 mp->sw_if_index = htonl (sw_if_index);
12942 /* Use a control ping for synchronization */
12943 MPING (CONTROL_PING, mp_ping);
12950 static uword unformat_geneve_decap_next
12951 (unformat_input_t * input, va_list * args)
12953 u32 *result = va_arg (*args, u32 *);
12956 if (unformat (input, "l2"))
12957 *result = GENEVE_INPUT_NEXT_L2_INPUT;
12958 else if (unformat (input, "%d", &tmp))
12966 api_geneve_add_del_tunnel (vat_main_t * vam)
12968 unformat_input_t *line_input = vam->input;
12969 vl_api_geneve_add_del_tunnel_t *mp;
12970 ip46_address_t src, dst;
12972 u8 ipv4_set = 0, ipv6_set = 0;
12976 u32 mcast_sw_if_index = ~0;
12977 u32 encap_vrf_id = 0;
12978 u32 decap_next_index = ~0;
12982 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12983 clib_memset (&src, 0, sizeof src);
12984 clib_memset (&dst, 0, sizeof dst);
12986 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12988 if (unformat (line_input, "del"))
12991 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12997 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
13003 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
13009 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
13014 else if (unformat (line_input, "group %U %U",
13015 unformat_ip4_address, &dst.ip4,
13016 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13018 grp_set = dst_set = 1;
13021 else if (unformat (line_input, "group %U",
13022 unformat_ip4_address, &dst.ip4))
13024 grp_set = dst_set = 1;
13027 else if (unformat (line_input, "group %U %U",
13028 unformat_ip6_address, &dst.ip6,
13029 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13031 grp_set = dst_set = 1;
13034 else if (unformat (line_input, "group %U",
13035 unformat_ip6_address, &dst.ip6))
13037 grp_set = dst_set = 1;
13041 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13043 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13045 else if (unformat (line_input, "decap-next %U",
13046 unformat_geneve_decap_next, &decap_next_index))
13048 else if (unformat (line_input, "vni %d", &vni))
13052 errmsg ("parse error '%U'", format_unformat_error, line_input);
13059 errmsg ("tunnel src address not specified");
13064 errmsg ("tunnel dst address not specified");
13068 if (grp_set && !ip46_address_is_multicast (&dst))
13070 errmsg ("tunnel group address not multicast");
13073 if (grp_set && mcast_sw_if_index == ~0)
13075 errmsg ("tunnel nonexistent multicast device");
13078 if (grp_set == 0 && ip46_address_is_multicast (&dst))
13080 errmsg ("tunnel dst address must be unicast");
13085 if (ipv4_set && ipv6_set)
13087 errmsg ("both IPv4 and IPv6 addresses specified");
13091 if ((vni == 0) || (vni >> 24))
13093 errmsg ("vni not specified or out of range");
13097 M (GENEVE_ADD_DEL_TUNNEL, mp);
13101 clib_memcpy (mp->local_address, &src.ip6, sizeof (src.ip6));
13102 clib_memcpy (mp->remote_address, &dst.ip6, sizeof (dst.ip6));
13106 clib_memcpy (mp->local_address, &src.ip4, sizeof (src.ip4));
13107 clib_memcpy (mp->remote_address, &dst.ip4, sizeof (dst.ip4));
13109 mp->encap_vrf_id = ntohl (encap_vrf_id);
13110 mp->decap_next_index = ntohl (decap_next_index);
13111 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
13112 mp->vni = ntohl (vni);
13113 mp->is_add = is_add;
13114 mp->is_ipv6 = ipv6_set;
13121 static void vl_api_geneve_tunnel_details_t_handler
13122 (vl_api_geneve_tunnel_details_t * mp)
13124 vat_main_t *vam = &vat_main;
13125 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
13126 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
13128 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
13129 ntohl (mp->sw_if_index),
13130 format_ip46_address, &src, IP46_TYPE_ANY,
13131 format_ip46_address, &dst, IP46_TYPE_ANY,
13132 ntohl (mp->encap_vrf_id),
13133 ntohl (mp->decap_next_index), ntohl (mp->vni),
13134 ntohl (mp->mcast_sw_if_index));
13137 static void vl_api_geneve_tunnel_details_t_handler_json
13138 (vl_api_geneve_tunnel_details_t * mp)
13140 vat_main_t *vam = &vat_main;
13141 vat_json_node_t *node = NULL;
13143 if (VAT_JSON_ARRAY != vam->json_tree.type)
13145 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13146 vat_json_init_array (&vam->json_tree);
13148 node = vat_json_array_add (&vam->json_tree);
13150 vat_json_init_object (node);
13151 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13154 struct in6_addr ip6;
13156 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
13157 vat_json_object_add_ip6 (node, "src_address", ip6);
13158 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
13159 vat_json_object_add_ip6 (node, "dst_address", ip6);
13163 struct in_addr ip4;
13165 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
13166 vat_json_object_add_ip4 (node, "src_address", ip4);
13167 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
13168 vat_json_object_add_ip4 (node, "dst_address", ip4);
13170 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
13171 vat_json_object_add_uint (node, "decap_next_index",
13172 ntohl (mp->decap_next_index));
13173 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
13174 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
13175 vat_json_object_add_uint (node, "mcast_sw_if_index",
13176 ntohl (mp->mcast_sw_if_index));
13180 api_geneve_tunnel_dump (vat_main_t * vam)
13182 unformat_input_t *i = vam->input;
13183 vl_api_geneve_tunnel_dump_t *mp;
13184 vl_api_control_ping_t *mp_ping;
13186 u8 sw_if_index_set = 0;
13189 /* Parse args required to build the message */
13190 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13192 if (unformat (i, "sw_if_index %d", &sw_if_index))
13193 sw_if_index_set = 1;
13198 if (sw_if_index_set == 0)
13203 if (!vam->json_output)
13205 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
13206 "sw_if_index", "local_address", "remote_address",
13207 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
13210 /* Get list of geneve-tunnel interfaces */
13211 M (GENEVE_TUNNEL_DUMP, mp);
13213 mp->sw_if_index = htonl (sw_if_index);
13217 /* Use a control ping for synchronization */
13218 M (CONTROL_PING, mp_ping);
13226 api_gre_tunnel_add_del (vat_main_t * vam)
13228 unformat_input_t *line_input = vam->input;
13229 vl_api_address_t src = { }, dst =
13232 vl_api_gre_tunnel_add_del_t *mp;
13233 vl_api_gre_tunnel_type_t t_type;
13239 u32 outer_fib_id = 0;
13240 u32 session_id = 0;
13244 t_type = GRE_API_TUNNEL_TYPE_L3;
13246 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13248 if (unformat (line_input, "del"))
13250 else if (unformat (line_input, "instance %d", &instance))
13252 else if (unformat (line_input, "src %U", unformat_vl_api_address, &src))
13256 else if (unformat (line_input, "dst %U", unformat_vl_api_address, &dst))
13260 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
13262 else if (unformat (line_input, "teb"))
13263 t_type = GRE_API_TUNNEL_TYPE_TEB;
13264 else if (unformat (line_input, "erspan %d", &session_id))
13265 t_type = GRE_API_TUNNEL_TYPE_ERSPAN;
13268 errmsg ("parse error '%U'", format_unformat_error, line_input);
13275 errmsg ("tunnel src address not specified");
13280 errmsg ("tunnel dst address not specified");
13284 M (GRE_TUNNEL_ADD_DEL, mp);
13286 clib_memcpy (&mp->tunnel.src, &src, sizeof (mp->tunnel.src));
13287 clib_memcpy (&mp->tunnel.dst, &dst, sizeof (mp->tunnel.dst));
13289 mp->tunnel.instance = htonl (instance);
13290 mp->tunnel.outer_fib_id = htonl (outer_fib_id);
13291 mp->is_add = is_add;
13292 mp->tunnel.session_id = htons ((u16) session_id);
13293 mp->tunnel.type = htonl (t_type);
13300 static void vl_api_gre_tunnel_details_t_handler
13301 (vl_api_gre_tunnel_details_t * mp)
13303 vat_main_t *vam = &vat_main;
13305 print (vam->ofp, "%11d%11d%24U%24U%13d%14d%12d",
13306 ntohl (mp->tunnel.sw_if_index),
13307 ntohl (mp->tunnel.instance),
13308 format_vl_api_address, &mp->tunnel.src,
13309 format_vl_api_address, &mp->tunnel.dst,
13310 mp->tunnel.type, ntohl (mp->tunnel.outer_fib_id),
13311 ntohl (mp->tunnel.session_id));
13315 vat_json_object_add_address (vat_json_node_t * node,
13316 const char *str, const vl_api_address_t * addr)
13318 if (ADDRESS_IP6 == addr->af)
13320 struct in6_addr ip6;
13322 clib_memcpy (&ip6, &addr->un.ip6, sizeof (ip6));
13323 vat_json_object_add_ip6 (node, str, ip6);
13327 struct in_addr ip4;
13329 clib_memcpy (&ip4, &addr->un.ip4, sizeof (ip4));
13330 vat_json_object_add_ip4 (node, str, ip4);
13334 static void vl_api_gre_tunnel_details_t_handler_json
13335 (vl_api_gre_tunnel_details_t * mp)
13337 vat_main_t *vam = &vat_main;
13338 vat_json_node_t *node = NULL;
13339 struct in_addr ip4;
13340 struct in6_addr ip6;
13342 if (VAT_JSON_ARRAY != vam->json_tree.type)
13344 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13345 vat_json_init_array (&vam->json_tree);
13347 node = vat_json_array_add (&vam->json_tree);
13349 vat_json_init_object (node);
13350 vat_json_object_add_uint (node, "sw_if_index",
13351 ntohl (mp->tunnel.sw_if_index));
13352 vat_json_object_add_uint (node, "instance", ntohl (mp->tunnel.instance));
13354 vat_json_object_add_address (node, "src", &mp->tunnel.src);
13355 vat_json_object_add_address (node, "dst", &mp->tunnel.dst);
13356 vat_json_object_add_uint (node, "tunnel_type", mp->tunnel.type);
13357 vat_json_object_add_uint (node, "outer_fib_id",
13358 ntohl (mp->tunnel.outer_fib_id));
13359 vat_json_object_add_uint (node, "session_id", mp->tunnel.session_id);
13363 api_gre_tunnel_dump (vat_main_t * vam)
13365 unformat_input_t *i = vam->input;
13366 vl_api_gre_tunnel_dump_t *mp;
13367 vl_api_control_ping_t *mp_ping;
13369 u8 sw_if_index_set = 0;
13372 /* Parse args required to build the message */
13373 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13375 if (unformat (i, "sw_if_index %d", &sw_if_index))
13376 sw_if_index_set = 1;
13381 if (sw_if_index_set == 0)
13386 if (!vam->json_output)
13388 print (vam->ofp, "%11s%11s%24s%24s%13s%14s%12s",
13389 "sw_if_index", "instance", "src_address", "dst_address",
13390 "tunnel_type", "outer_fib_id", "session_id");
13393 /* Get list of gre-tunnel interfaces */
13394 M (GRE_TUNNEL_DUMP, mp);
13396 mp->sw_if_index = htonl (sw_if_index);
13400 /* Use a control ping for synchronization */
13401 MPING (CONTROL_PING, mp_ping);
13409 api_l2_fib_clear_table (vat_main_t * vam)
13411 // unformat_input_t * i = vam->input;
13412 vl_api_l2_fib_clear_table_t *mp;
13415 M (L2_FIB_CLEAR_TABLE, mp);
13423 api_l2_interface_efp_filter (vat_main_t * vam)
13425 unformat_input_t *i = vam->input;
13426 vl_api_l2_interface_efp_filter_t *mp;
13429 u8 sw_if_index_set = 0;
13432 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13434 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13435 sw_if_index_set = 1;
13436 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13437 sw_if_index_set = 1;
13438 else if (unformat (i, "enable"))
13440 else if (unformat (i, "disable"))
13444 clib_warning ("parse error '%U'", format_unformat_error, i);
13449 if (sw_if_index_set == 0)
13451 errmsg ("missing sw_if_index");
13455 M (L2_INTERFACE_EFP_FILTER, mp);
13457 mp->sw_if_index = ntohl (sw_if_index);
13458 mp->enable_disable = enable;
13465 #define foreach_vtr_op \
13466 _("disable", L2_VTR_DISABLED) \
13467 _("push-1", L2_VTR_PUSH_1) \
13468 _("push-2", L2_VTR_PUSH_2) \
13469 _("pop-1", L2_VTR_POP_1) \
13470 _("pop-2", L2_VTR_POP_2) \
13471 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
13472 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
13473 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
13474 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
13477 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
13479 unformat_input_t *i = vam->input;
13480 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
13482 u8 sw_if_index_set = 0;
13485 u32 push_dot1q = 1;
13490 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13492 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13493 sw_if_index_set = 1;
13494 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13495 sw_if_index_set = 1;
13496 else if (unformat (i, "vtr_op %d", &vtr_op))
13498 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
13501 else if (unformat (i, "push_dot1q %d", &push_dot1q))
13503 else if (unformat (i, "tag1 %d", &tag1))
13505 else if (unformat (i, "tag2 %d", &tag2))
13509 clib_warning ("parse error '%U'", format_unformat_error, i);
13514 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
13516 errmsg ("missing vtr operation or sw_if_index");
13520 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
13521 mp->sw_if_index = ntohl (sw_if_index);
13522 mp->vtr_op = ntohl (vtr_op);
13523 mp->push_dot1q = ntohl (push_dot1q);
13524 mp->tag1 = ntohl (tag1);
13525 mp->tag2 = ntohl (tag2);
13533 api_create_vhost_user_if (vat_main_t * vam)
13535 unformat_input_t *i = vam->input;
13536 vl_api_create_vhost_user_if_t *mp;
13539 u8 file_name_set = 0;
13540 u32 custom_dev_instance = ~0;
13542 u8 use_custom_mac = 0;
13543 u8 disable_mrg_rxbuf = 0;
13544 u8 disable_indirect_desc = 0;
13548 /* Shut up coverity */
13549 clib_memset (hwaddr, 0, sizeof (hwaddr));
13551 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13553 if (unformat (i, "socket %s", &file_name))
13557 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13559 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
13560 use_custom_mac = 1;
13561 else if (unformat (i, "server"))
13563 else if (unformat (i, "disable_mrg_rxbuf"))
13564 disable_mrg_rxbuf = 1;
13565 else if (unformat (i, "disable_indirect_desc"))
13566 disable_indirect_desc = 1;
13567 else if (unformat (i, "tag %s", &tag))
13573 if (file_name_set == 0)
13575 errmsg ("missing socket file name");
13579 if (vec_len (file_name) > 255)
13581 errmsg ("socket file name too long");
13584 vec_add1 (file_name, 0);
13586 M (CREATE_VHOST_USER_IF, mp);
13588 mp->is_server = is_server;
13589 mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
13590 mp->disable_indirect_desc = disable_indirect_desc;
13591 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13592 vec_free (file_name);
13593 if (custom_dev_instance != ~0)
13596 mp->custom_dev_instance = ntohl (custom_dev_instance);
13599 mp->use_custom_mac = use_custom_mac;
13600 clib_memcpy (mp->mac_address, hwaddr, 6);
13602 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
13611 api_modify_vhost_user_if (vat_main_t * vam)
13613 unformat_input_t *i = vam->input;
13614 vl_api_modify_vhost_user_if_t *mp;
13617 u8 file_name_set = 0;
13618 u32 custom_dev_instance = ~0;
13619 u8 sw_if_index_set = 0;
13620 u32 sw_if_index = (u32) ~ 0;
13623 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13625 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13626 sw_if_index_set = 1;
13627 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13628 sw_if_index_set = 1;
13629 else if (unformat (i, "socket %s", &file_name))
13633 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13635 else if (unformat (i, "server"))
13641 if (sw_if_index_set == 0)
13643 errmsg ("missing sw_if_index or interface name");
13647 if (file_name_set == 0)
13649 errmsg ("missing socket file name");
13653 if (vec_len (file_name) > 255)
13655 errmsg ("socket file name too long");
13658 vec_add1 (file_name, 0);
13660 M (MODIFY_VHOST_USER_IF, mp);
13662 mp->sw_if_index = ntohl (sw_if_index);
13663 mp->is_server = is_server;
13664 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13665 vec_free (file_name);
13666 if (custom_dev_instance != ~0)
13669 mp->custom_dev_instance = ntohl (custom_dev_instance);
13678 api_delete_vhost_user_if (vat_main_t * vam)
13680 unformat_input_t *i = vam->input;
13681 vl_api_delete_vhost_user_if_t *mp;
13682 u32 sw_if_index = ~0;
13683 u8 sw_if_index_set = 0;
13686 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13688 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13689 sw_if_index_set = 1;
13690 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13691 sw_if_index_set = 1;
13696 if (sw_if_index_set == 0)
13698 errmsg ("missing sw_if_index or interface name");
13703 M (DELETE_VHOST_USER_IF, mp);
13705 mp->sw_if_index = ntohl (sw_if_index);
13712 static void vl_api_sw_interface_vhost_user_details_t_handler
13713 (vl_api_sw_interface_vhost_user_details_t * mp)
13715 vat_main_t *vam = &vat_main;
13717 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
13718 (char *) mp->interface_name,
13719 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
13720 clib_net_to_host_u64 (mp->features), mp->is_server,
13721 ntohl (mp->num_regions), (char *) mp->sock_filename);
13722 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
13725 static void vl_api_sw_interface_vhost_user_details_t_handler_json
13726 (vl_api_sw_interface_vhost_user_details_t * mp)
13728 vat_main_t *vam = &vat_main;
13729 vat_json_node_t *node = NULL;
13731 if (VAT_JSON_ARRAY != vam->json_tree.type)
13733 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13734 vat_json_init_array (&vam->json_tree);
13736 node = vat_json_array_add (&vam->json_tree);
13738 vat_json_init_object (node);
13739 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13740 vat_json_object_add_string_copy (node, "interface_name",
13741 mp->interface_name);
13742 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
13743 ntohl (mp->virtio_net_hdr_sz));
13744 vat_json_object_add_uint (node, "features",
13745 clib_net_to_host_u64 (mp->features));
13746 vat_json_object_add_uint (node, "is_server", mp->is_server);
13747 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
13748 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
13749 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
13753 api_sw_interface_vhost_user_dump (vat_main_t * vam)
13755 vl_api_sw_interface_vhost_user_dump_t *mp;
13756 vl_api_control_ping_t *mp_ping;
13759 "Interface name idx hdr_sz features server regions filename");
13761 /* Get list of vhost-user interfaces */
13762 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
13765 /* Use a control ping for synchronization */
13766 MPING (CONTROL_PING, mp_ping);
13774 api_show_version (vat_main_t * vam)
13776 vl_api_show_version_t *mp;
13779 M (SHOW_VERSION, mp);
13788 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
13790 unformat_input_t *line_input = vam->input;
13791 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
13792 ip4_address_t local4, remote4;
13793 ip6_address_t local6, remote6;
13795 u8 ipv4_set = 0, ipv6_set = 0;
13799 u32 mcast_sw_if_index = ~0;
13800 u32 encap_vrf_id = 0;
13801 u32 decap_vrf_id = 0;
13807 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
13808 clib_memset (&local4, 0, sizeof local4);
13809 clib_memset (&remote4, 0, sizeof remote4);
13810 clib_memset (&local6, 0, sizeof local6);
13811 clib_memset (&remote6, 0, sizeof remote6);
13813 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13815 if (unformat (line_input, "del"))
13817 else if (unformat (line_input, "local %U",
13818 unformat_ip4_address, &local4))
13823 else if (unformat (line_input, "remote %U",
13824 unformat_ip4_address, &remote4))
13829 else if (unformat (line_input, "local %U",
13830 unformat_ip6_address, &local6))
13835 else if (unformat (line_input, "remote %U",
13836 unformat_ip6_address, &remote6))
13841 else if (unformat (line_input, "group %U %U",
13842 unformat_ip4_address, &remote4,
13843 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13845 grp_set = remote_set = 1;
13848 else if (unformat (line_input, "group %U",
13849 unformat_ip4_address, &remote4))
13851 grp_set = remote_set = 1;
13854 else if (unformat (line_input, "group %U %U",
13855 unformat_ip6_address, &remote6,
13856 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13858 grp_set = remote_set = 1;
13861 else if (unformat (line_input, "group %U",
13862 unformat_ip6_address, &remote6))
13864 grp_set = remote_set = 1;
13868 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13870 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13872 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
13874 else if (unformat (line_input, "vni %d", &vni))
13876 else if (unformat (line_input, "next-ip4"))
13878 else if (unformat (line_input, "next-ip6"))
13880 else if (unformat (line_input, "next-ethernet"))
13882 else if (unformat (line_input, "next-nsh"))
13886 errmsg ("parse error '%U'", format_unformat_error, line_input);
13891 if (local_set == 0)
13893 errmsg ("tunnel local address not specified");
13896 if (remote_set == 0)
13898 errmsg ("tunnel remote address not specified");
13901 if (grp_set && mcast_sw_if_index == ~0)
13903 errmsg ("tunnel nonexistent multicast device");
13906 if (ipv4_set && ipv6_set)
13908 errmsg ("both IPv4 and IPv6 addresses specified");
13914 errmsg ("vni not specified");
13918 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
13923 clib_memcpy (&mp->local, &local6, sizeof (local6));
13924 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
13928 clib_memcpy (&mp->local, &local4, sizeof (local4));
13929 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
13932 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
13933 mp->encap_vrf_id = ntohl (encap_vrf_id);
13934 mp->decap_vrf_id = ntohl (decap_vrf_id);
13935 mp->protocol = protocol;
13936 mp->vni = ntohl (vni);
13937 mp->is_add = is_add;
13938 mp->is_ipv6 = ipv6_set;
13945 static void vl_api_vxlan_gpe_tunnel_details_t_handler
13946 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13948 vat_main_t *vam = &vat_main;
13949 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
13950 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
13952 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
13953 ntohl (mp->sw_if_index),
13954 format_ip46_address, &local, IP46_TYPE_ANY,
13955 format_ip46_address, &remote, IP46_TYPE_ANY,
13956 ntohl (mp->vni), mp->protocol,
13957 ntohl (mp->mcast_sw_if_index),
13958 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
13962 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
13963 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13965 vat_main_t *vam = &vat_main;
13966 vat_json_node_t *node = NULL;
13967 struct in_addr ip4;
13968 struct in6_addr ip6;
13970 if (VAT_JSON_ARRAY != vam->json_tree.type)
13972 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13973 vat_json_init_array (&vam->json_tree);
13975 node = vat_json_array_add (&vam->json_tree);
13977 vat_json_init_object (node);
13978 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13981 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
13982 vat_json_object_add_ip6 (node, "local", ip6);
13983 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
13984 vat_json_object_add_ip6 (node, "remote", ip6);
13988 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
13989 vat_json_object_add_ip4 (node, "local", ip4);
13990 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
13991 vat_json_object_add_ip4 (node, "remote", ip4);
13993 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
13994 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
13995 vat_json_object_add_uint (node, "mcast_sw_if_index",
13996 ntohl (mp->mcast_sw_if_index));
13997 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
13998 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
13999 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
14003 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
14005 unformat_input_t *i = vam->input;
14006 vl_api_vxlan_gpe_tunnel_dump_t *mp;
14007 vl_api_control_ping_t *mp_ping;
14009 u8 sw_if_index_set = 0;
14012 /* Parse args required to build the message */
14013 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14015 if (unformat (i, "sw_if_index %d", &sw_if_index))
14016 sw_if_index_set = 1;
14021 if (sw_if_index_set == 0)
14026 if (!vam->json_output)
14028 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
14029 "sw_if_index", "local", "remote", "vni",
14030 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
14033 /* Get list of vxlan-tunnel interfaces */
14034 M (VXLAN_GPE_TUNNEL_DUMP, mp);
14036 mp->sw_if_index = htonl (sw_if_index);
14040 /* Use a control ping for synchronization */
14041 MPING (CONTROL_PING, mp_ping);
14048 static void vl_api_l2_fib_table_details_t_handler
14049 (vl_api_l2_fib_table_details_t * mp)
14051 vat_main_t *vam = &vat_main;
14053 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
14055 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
14056 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
14060 static void vl_api_l2_fib_table_details_t_handler_json
14061 (vl_api_l2_fib_table_details_t * mp)
14063 vat_main_t *vam = &vat_main;
14064 vat_json_node_t *node = NULL;
14066 if (VAT_JSON_ARRAY != vam->json_tree.type)
14068 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14069 vat_json_init_array (&vam->json_tree);
14071 node = vat_json_array_add (&vam->json_tree);
14073 vat_json_init_object (node);
14074 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
14075 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
14076 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14077 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
14078 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
14079 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
14083 api_l2_fib_table_dump (vat_main_t * vam)
14085 unformat_input_t *i = vam->input;
14086 vl_api_l2_fib_table_dump_t *mp;
14087 vl_api_control_ping_t *mp_ping;
14092 /* Parse args required to build the message */
14093 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14095 if (unformat (i, "bd_id %d", &bd_id))
14101 if (bd_id_set == 0)
14103 errmsg ("missing bridge domain");
14107 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
14109 /* Get list of l2 fib entries */
14110 M (L2_FIB_TABLE_DUMP, mp);
14112 mp->bd_id = ntohl (bd_id);
14115 /* Use a control ping for synchronization */
14116 MPING (CONTROL_PING, mp_ping);
14125 api_interface_name_renumber (vat_main_t * vam)
14127 unformat_input_t *line_input = vam->input;
14128 vl_api_interface_name_renumber_t *mp;
14129 u32 sw_if_index = ~0;
14130 u32 new_show_dev_instance = ~0;
14133 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14135 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
14138 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14140 else if (unformat (line_input, "new_show_dev_instance %d",
14141 &new_show_dev_instance))
14147 if (sw_if_index == ~0)
14149 errmsg ("missing interface name or sw_if_index");
14153 if (new_show_dev_instance == ~0)
14155 errmsg ("missing new_show_dev_instance");
14159 M (INTERFACE_NAME_RENUMBER, mp);
14161 mp->sw_if_index = ntohl (sw_if_index);
14162 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
14170 api_ip_probe_neighbor (vat_main_t * vam)
14172 unformat_input_t *i = vam->input;
14173 vl_api_ip_probe_neighbor_t *mp;
14174 vl_api_address_t dst_adr;
14180 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14182 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14184 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14186 else if (unformat (i, "address %U", unformat_vl_api_address, dst_adr))
14194 errmsg ("missing interface");
14200 errmsg ("missing addresses");
14204 M (IP_PROBE_NEIGHBOR, mp);
14206 mp->sw_if_index = ntohl (sw_if_index);
14207 clib_memcpy (&mp->dst, &dst_adr, sizeof (dst_adr));
14215 api_ip_scan_neighbor_enable_disable (vat_main_t * vam)
14217 unformat_input_t *i = vam->input;
14218 vl_api_ip_scan_neighbor_enable_disable_t *mp;
14219 u8 mode = IP_SCAN_V46_NEIGHBORS;
14220 u32 interval = 0, time = 0, update = 0, delay = 0, stale = 0;
14223 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14225 if (unformat (i, "ip4"))
14226 mode = IP_SCAN_V4_NEIGHBORS;
14227 else if (unformat (i, "ip6"))
14228 mode = IP_SCAN_V6_NEIGHBORS;
14229 if (unformat (i, "both"))
14230 mode = IP_SCAN_V46_NEIGHBORS;
14231 else if (unformat (i, "disable"))
14232 mode = IP_SCAN_DISABLED;
14233 else if (unformat (i, "interval %d", &interval))
14235 else if (unformat (i, "max-time %d", &time))
14237 else if (unformat (i, "max-update %d", &update))
14239 else if (unformat (i, "delay %d", &delay))
14241 else if (unformat (i, "stale %d", &stale))
14247 if (interval > 255)
14249 errmsg ("interval cannot exceed 255 minutes.");
14254 errmsg ("max-time cannot exceed 255 usec.");
14259 errmsg ("max-update cannot exceed 255.");
14264 errmsg ("delay cannot exceed 255 msec.");
14269 errmsg ("stale cannot exceed 255 minutes.");
14273 M (IP_SCAN_NEIGHBOR_ENABLE_DISABLE, mp);
14275 mp->scan_interval = interval;
14276 mp->max_proc_time = time;
14277 mp->max_update = update;
14278 mp->scan_int_delay = delay;
14279 mp->stale_threshold = stale;
14287 api_want_ip4_arp_events (vat_main_t * vam)
14289 unformat_input_t *line_input = vam->input;
14290 vl_api_want_ip4_arp_events_t *mp;
14291 ip4_address_t address;
14292 int address_set = 0;
14293 u32 enable_disable = 1;
14296 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14298 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
14300 else if (unformat (line_input, "del"))
14301 enable_disable = 0;
14306 if (address_set == 0)
14308 errmsg ("missing addresses");
14312 M (WANT_IP4_ARP_EVENTS, mp);
14313 mp->enable_disable = enable_disable;
14314 mp->pid = htonl (getpid ());
14315 clib_memcpy (mp->ip, &address, sizeof (address));
14323 api_want_ip6_nd_events (vat_main_t * vam)
14325 unformat_input_t *line_input = vam->input;
14326 vl_api_want_ip6_nd_events_t *mp;
14327 vl_api_ip6_address_t address;
14328 int address_set = 0;
14329 u32 enable_disable = 1;
14332 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14335 (line_input, "address %U", unformat_vl_api_ip6_address, &address))
14337 else if (unformat (line_input, "del"))
14338 enable_disable = 0;
14343 if (address_set == 0)
14345 errmsg ("missing addresses");
14349 M (WANT_IP6_ND_EVENTS, mp);
14350 mp->enable_disable = enable_disable;
14351 mp->pid = htonl (getpid ());
14352 clib_memcpy (&mp->ip, &address, sizeof (address));
14360 api_want_l2_macs_events (vat_main_t * vam)
14362 unformat_input_t *line_input = vam->input;
14363 vl_api_want_l2_macs_events_t *mp;
14364 u8 enable_disable = 1;
14365 u32 scan_delay = 0;
14366 u32 max_macs_in_event = 0;
14367 u32 learn_limit = 0;
14370 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14372 if (unformat (line_input, "learn-limit %d", &learn_limit))
14374 else if (unformat (line_input, "scan-delay %d", &scan_delay))
14376 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
14378 else if (unformat (line_input, "disable"))
14379 enable_disable = 0;
14384 M (WANT_L2_MACS_EVENTS, mp);
14385 mp->enable_disable = enable_disable;
14386 mp->pid = htonl (getpid ());
14387 mp->learn_limit = htonl (learn_limit);
14388 mp->scan_delay = (u8) scan_delay;
14389 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
14396 api_input_acl_set_interface (vat_main_t * vam)
14398 unformat_input_t *i = vam->input;
14399 vl_api_input_acl_set_interface_t *mp;
14401 int sw_if_index_set;
14402 u32 ip4_table_index = ~0;
14403 u32 ip6_table_index = ~0;
14404 u32 l2_table_index = ~0;
14408 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14410 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14411 sw_if_index_set = 1;
14412 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14413 sw_if_index_set = 1;
14414 else if (unformat (i, "del"))
14416 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14418 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14420 else if (unformat (i, "l2-table %d", &l2_table_index))
14424 clib_warning ("parse error '%U'", format_unformat_error, i);
14429 if (sw_if_index_set == 0)
14431 errmsg ("missing interface name or sw_if_index");
14435 M (INPUT_ACL_SET_INTERFACE, mp);
14437 mp->sw_if_index = ntohl (sw_if_index);
14438 mp->ip4_table_index = ntohl (ip4_table_index);
14439 mp->ip6_table_index = ntohl (ip6_table_index);
14440 mp->l2_table_index = ntohl (l2_table_index);
14441 mp->is_add = is_add;
14449 api_output_acl_set_interface (vat_main_t * vam)
14451 unformat_input_t *i = vam->input;
14452 vl_api_output_acl_set_interface_t *mp;
14454 int sw_if_index_set;
14455 u32 ip4_table_index = ~0;
14456 u32 ip6_table_index = ~0;
14457 u32 l2_table_index = ~0;
14461 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14463 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14464 sw_if_index_set = 1;
14465 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14466 sw_if_index_set = 1;
14467 else if (unformat (i, "del"))
14469 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14471 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14473 else if (unformat (i, "l2-table %d", &l2_table_index))
14477 clib_warning ("parse error '%U'", format_unformat_error, i);
14482 if (sw_if_index_set == 0)
14484 errmsg ("missing interface name or sw_if_index");
14488 M (OUTPUT_ACL_SET_INTERFACE, mp);
14490 mp->sw_if_index = ntohl (sw_if_index);
14491 mp->ip4_table_index = ntohl (ip4_table_index);
14492 mp->ip6_table_index = ntohl (ip6_table_index);
14493 mp->l2_table_index = ntohl (l2_table_index);
14494 mp->is_add = is_add;
14502 api_ip_address_dump (vat_main_t * vam)
14504 unformat_input_t *i = vam->input;
14505 vl_api_ip_address_dump_t *mp;
14506 vl_api_control_ping_t *mp_ping;
14507 u32 sw_if_index = ~0;
14508 u8 sw_if_index_set = 0;
14513 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14515 if (unformat (i, "sw_if_index %d", &sw_if_index))
14516 sw_if_index_set = 1;
14518 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14519 sw_if_index_set = 1;
14520 else if (unformat (i, "ipv4"))
14522 else if (unformat (i, "ipv6"))
14528 if (ipv4_set && ipv6_set)
14530 errmsg ("ipv4 and ipv6 flags cannot be both set");
14534 if ((!ipv4_set) && (!ipv6_set))
14536 errmsg ("no ipv4 nor ipv6 flag set");
14540 if (sw_if_index_set == 0)
14542 errmsg ("missing interface name or sw_if_index");
14546 vam->current_sw_if_index = sw_if_index;
14547 vam->is_ipv6 = ipv6_set;
14549 M (IP_ADDRESS_DUMP, mp);
14550 mp->sw_if_index = ntohl (sw_if_index);
14551 mp->is_ipv6 = ipv6_set;
14554 /* Use a control ping for synchronization */
14555 MPING (CONTROL_PING, mp_ping);
14563 api_ip_dump (vat_main_t * vam)
14565 vl_api_ip_dump_t *mp;
14566 vl_api_control_ping_t *mp_ping;
14567 unformat_input_t *in = vam->input;
14574 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
14576 if (unformat (in, "ipv4"))
14578 else if (unformat (in, "ipv6"))
14584 if (ipv4_set && ipv6_set)
14586 errmsg ("ipv4 and ipv6 flags cannot be both set");
14590 if ((!ipv4_set) && (!ipv6_set))
14592 errmsg ("no ipv4 nor ipv6 flag set");
14596 is_ipv6 = ipv6_set;
14597 vam->is_ipv6 = is_ipv6;
14599 /* free old data */
14600 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
14602 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
14604 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
14607 mp->is_ipv6 = ipv6_set;
14610 /* Use a control ping for synchronization */
14611 MPING (CONTROL_PING, mp_ping);
14619 api_ipsec_spd_add_del (vat_main_t * vam)
14621 unformat_input_t *i = vam->input;
14622 vl_api_ipsec_spd_add_del_t *mp;
14627 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14629 if (unformat (i, "spd_id %d", &spd_id))
14631 else if (unformat (i, "del"))
14635 clib_warning ("parse error '%U'", format_unformat_error, i);
14641 errmsg ("spd_id must be set");
14645 M (IPSEC_SPD_ADD_DEL, mp);
14647 mp->spd_id = ntohl (spd_id);
14648 mp->is_add = is_add;
14656 api_ipsec_interface_add_del_spd (vat_main_t * vam)
14658 unformat_input_t *i = vam->input;
14659 vl_api_ipsec_interface_add_del_spd_t *mp;
14661 u8 sw_if_index_set = 0;
14662 u32 spd_id = (u32) ~ 0;
14666 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14668 if (unformat (i, "del"))
14670 else if (unformat (i, "spd_id %d", &spd_id))
14673 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14674 sw_if_index_set = 1;
14675 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14676 sw_if_index_set = 1;
14679 clib_warning ("parse error '%U'", format_unformat_error, i);
14685 if (spd_id == (u32) ~ 0)
14687 errmsg ("spd_id must be set");
14691 if (sw_if_index_set == 0)
14693 errmsg ("missing interface name or sw_if_index");
14697 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
14699 mp->spd_id = ntohl (spd_id);
14700 mp->sw_if_index = ntohl (sw_if_index);
14701 mp->is_add = is_add;
14709 api_ipsec_spd_entry_add_del (vat_main_t * vam)
14711 unformat_input_t *i = vam->input;
14712 vl_api_ipsec_spd_entry_add_del_t *mp;
14713 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
14714 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
14716 u32 rport_start = 0, rport_stop = (u32) ~ 0;
14717 u32 lport_start = 0, lport_stop = (u32) ~ 0;
14718 vl_api_address_t laddr_start = { }, laddr_stop =
14727 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14729 if (unformat (i, "del"))
14731 if (unformat (i, "outbound"))
14733 if (unformat (i, "inbound"))
14735 else if (unformat (i, "spd_id %d", &spd_id))
14737 else if (unformat (i, "sa_id %d", &sa_id))
14739 else if (unformat (i, "priority %d", &priority))
14741 else if (unformat (i, "protocol %d", &protocol))
14743 else if (unformat (i, "lport_start %d", &lport_start))
14745 else if (unformat (i, "lport_stop %d", &lport_stop))
14747 else if (unformat (i, "rport_start %d", &rport_start))
14749 else if (unformat (i, "rport_stop %d", &rport_stop))
14751 else if (unformat (i, "laddr_start %U",
14752 unformat_vl_api_address, &laddr_start))
14754 else if (unformat (i, "laddr_stop %U", unformat_vl_api_address,
14757 else if (unformat (i, "raddr_start %U", unformat_vl_api_address,
14760 else if (unformat (i, "raddr_stop %U", unformat_vl_api_address,
14764 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
14766 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
14768 clib_warning ("unsupported action: 'resolve'");
14774 clib_warning ("parse error '%U'", format_unformat_error, i);
14780 M (IPSEC_SPD_ENTRY_ADD_DEL, mp);
14782 mp->is_add = is_add;
14784 mp->entry.spd_id = ntohl (spd_id);
14785 mp->entry.priority = ntohl (priority);
14786 mp->entry.is_outbound = is_outbound;
14788 clib_memcpy (&mp->entry.remote_address_start, &raddr_start,
14789 sizeof (vl_api_address_t));
14790 clib_memcpy (&mp->entry.remote_address_stop, &raddr_stop,
14791 sizeof (vl_api_address_t));
14792 clib_memcpy (&mp->entry.local_address_start, &laddr_start,
14793 sizeof (vl_api_address_t));
14794 clib_memcpy (&mp->entry.local_address_stop, &laddr_stop,
14795 sizeof (vl_api_address_t));
14797 mp->entry.protocol = (u8) protocol;
14798 mp->entry.local_port_start = ntohs ((u16) lport_start);
14799 mp->entry.local_port_stop = ntohs ((u16) lport_stop);
14800 mp->entry.remote_port_start = ntohs ((u16) rport_start);
14801 mp->entry.remote_port_stop = ntohs ((u16) rport_stop);
14802 mp->entry.policy = (u8) policy;
14803 mp->entry.sa_id = ntohl (sa_id);
14811 api_ipsec_sad_entry_add_del (vat_main_t * vam)
14813 unformat_input_t *i = vam->input;
14814 vl_api_ipsec_sad_entry_add_del_t *mp;
14815 u32 sad_id = 0, spi = 0;
14816 u8 *ck = 0, *ik = 0;
14819 vl_api_ipsec_crypto_alg_t crypto_alg = IPSEC_API_CRYPTO_ALG_NONE;
14820 vl_api_ipsec_integ_alg_t integ_alg = IPSEC_API_INTEG_ALG_NONE;
14821 vl_api_ipsec_sad_flags_t flags = IPSEC_API_SAD_FLAG_NONE;
14822 vl_api_ipsec_proto_t protocol = IPSEC_API_PROTO_AH;
14823 vl_api_address_t tun_src, tun_dst;
14826 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14828 if (unformat (i, "del"))
14830 else if (unformat (i, "sad_id %d", &sad_id))
14832 else if (unformat (i, "spi %d", &spi))
14834 else if (unformat (i, "esp"))
14835 protocol = IPSEC_API_PROTO_ESP;
14837 if (unformat (i, "tunnel_src %U", unformat_vl_api_address, &tun_src))
14839 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
14840 if (ADDRESS_IP6 == tun_src.af)
14841 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
14844 if (unformat (i, "tunnel_dst %U", unformat_vl_api_address, &tun_dst))
14846 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
14847 if (ADDRESS_IP6 == tun_src.af)
14848 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
14851 if (unformat (i, "crypto_alg %U",
14852 unformat_ipsec_api_crypto_alg, &crypto_alg))
14854 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14856 else if (unformat (i, "integ_alg %U",
14857 unformat_ipsec_api_integ_alg, &integ_alg))
14859 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14863 clib_warning ("parse error '%U'", format_unformat_error, i);
14869 M (IPSEC_SAD_ENTRY_ADD_DEL, mp);
14871 mp->is_add = is_add;
14872 mp->entry.sad_id = ntohl (sad_id);
14873 mp->entry.protocol = protocol;
14874 mp->entry.spi = ntohl (spi);
14875 mp->entry.flags = flags;
14877 mp->entry.crypto_algorithm = crypto_alg;
14878 mp->entry.integrity_algorithm = integ_alg;
14879 mp->entry.crypto_key.length = vec_len (ck);
14880 mp->entry.integrity_key.length = vec_len (ik);
14882 if (mp->entry.crypto_key.length > sizeof (mp->entry.crypto_key.data))
14883 mp->entry.crypto_key.length = sizeof (mp->entry.crypto_key.data);
14885 if (mp->entry.integrity_key.length > sizeof (mp->entry.integrity_key.data))
14886 mp->entry.integrity_key.length = sizeof (mp->entry.integrity_key.data);
14889 clib_memcpy (mp->entry.crypto_key.data, ck, mp->entry.crypto_key.length);
14891 clib_memcpy (mp->entry.integrity_key.data, ik,
14892 mp->entry.integrity_key.length);
14894 if (flags & IPSEC_API_SAD_FLAG_IS_TUNNEL)
14896 clib_memcpy (&mp->entry.tunnel_src, &tun_src,
14897 sizeof (mp->entry.tunnel_src));
14898 clib_memcpy (&mp->entry.tunnel_dst, &tun_dst,
14899 sizeof (mp->entry.tunnel_dst));
14908 api_ipsec_sa_set_key (vat_main_t * vam)
14910 unformat_input_t *i = vam->input;
14911 vl_api_ipsec_sa_set_key_t *mp;
14913 u8 *ck = 0, *ik = 0;
14916 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14918 if (unformat (i, "sa_id %d", &sa_id))
14920 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14922 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14926 clib_warning ("parse error '%U'", format_unformat_error, i);
14931 M (IPSEC_SA_SET_KEY, mp);
14933 mp->sa_id = ntohl (sa_id);
14934 mp->crypto_key.length = vec_len (ck);
14935 mp->integrity_key.length = vec_len (ik);
14937 if (mp->crypto_key.length > sizeof (mp->crypto_key.data))
14938 mp->crypto_key.length = sizeof (mp->crypto_key.data);
14940 if (mp->integrity_key.length > sizeof (mp->integrity_key.data))
14941 mp->integrity_key.length = sizeof (mp->integrity_key.data);
14944 clib_memcpy (mp->crypto_key.data, ck, mp->crypto_key.length);
14946 clib_memcpy (mp->integrity_key.data, ik, mp->integrity_key.length);
14954 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
14956 unformat_input_t *i = vam->input;
14957 vl_api_ipsec_tunnel_if_add_del_t *mp;
14958 u32 local_spi = 0, remote_spi = 0;
14959 u32 crypto_alg = 0, integ_alg = 0;
14960 u8 *lck = NULL, *rck = NULL;
14961 u8 *lik = NULL, *rik = NULL;
14962 vl_api_address_t local_ip = { 0 };
14963 vl_api_address_t remote_ip = { 0 };
14967 u8 anti_replay = 0;
14973 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14975 if (unformat (i, "del"))
14977 else if (unformat (i, "esn"))
14979 else if (unformat (i, "anti-replay"))
14981 else if (unformat (i, "count %d", &count))
14983 else if (unformat (i, "local_spi %d", &local_spi))
14985 else if (unformat (i, "remote_spi %d", &remote_spi))
14988 if (unformat (i, "local_ip %U", unformat_vl_api_address, &local_ip))
14991 if (unformat (i, "remote_ip %U", unformat_vl_api_address, &remote_ip))
14993 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
14996 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
14998 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
15000 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
15004 (i, "crypto_alg %U", unformat_ipsec_api_crypto_alg, &crypto_alg))
15006 if (crypto_alg >= IPSEC_CRYPTO_N_ALG)
15008 errmsg ("unsupported crypto-alg: '%U'\n",
15009 format_ipsec_crypto_alg, crypto_alg);
15015 (i, "integ_alg %U", unformat_ipsec_api_integ_alg, &integ_alg))
15017 if (integ_alg >= IPSEC_INTEG_N_ALG)
15019 errmsg ("unsupported integ-alg: '%U'\n",
15020 format_ipsec_integ_alg, integ_alg);
15024 else if (unformat (i, "instance %u", &instance))
15028 errmsg ("parse error '%U'\n", format_unformat_error, i);
15035 /* Turn on async mode */
15036 vam->async_mode = 1;
15037 vam->async_errors = 0;
15038 before = vat_time_now (vam);
15041 for (jj = 0; jj < count; jj++)
15043 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
15045 mp->is_add = is_add;
15047 mp->anti_replay = anti_replay;
15050 increment_vl_address (&remote_ip);
15052 clib_memcpy (&mp->local_ip, &local_ip, sizeof (local_ip));
15053 clib_memcpy (&mp->remote_ip, &remote_ip, sizeof (remote_ip));
15055 mp->local_spi = htonl (local_spi + jj);
15056 mp->remote_spi = htonl (remote_spi + jj);
15057 mp->crypto_alg = (u8) crypto_alg;
15059 mp->local_crypto_key_len = 0;
15062 mp->local_crypto_key_len = vec_len (lck);
15063 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
15064 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
15065 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
15068 mp->remote_crypto_key_len = 0;
15071 mp->remote_crypto_key_len = vec_len (rck);
15072 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
15073 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
15074 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
15077 mp->integ_alg = (u8) integ_alg;
15079 mp->local_integ_key_len = 0;
15082 mp->local_integ_key_len = vec_len (lik);
15083 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
15084 mp->local_integ_key_len = sizeof (mp->local_integ_key);
15085 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
15088 mp->remote_integ_key_len = 0;
15091 mp->remote_integ_key_len = vec_len (rik);
15092 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
15093 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
15094 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
15099 mp->renumber = renumber;
15100 mp->show_instance = ntohl (instance);
15105 /* When testing multiple add/del ops, use a control-ping to sync */
15108 vl_api_control_ping_t *mp_ping;
15112 /* Shut off async mode */
15113 vam->async_mode = 0;
15115 MPING (CONTROL_PING, mp_ping);
15118 timeout = vat_time_now (vam) + 1.0;
15119 while (vat_time_now (vam) < timeout)
15120 if (vam->result_ready == 1)
15125 if (vam->retval == -99)
15126 errmsg ("timeout");
15128 if (vam->async_errors > 0)
15130 errmsg ("%d asynchronous errors", vam->async_errors);
15133 vam->async_errors = 0;
15134 after = vat_time_now (vam);
15136 /* slim chance, but we might have eaten SIGTERM on the first iteration */
15140 print (vam->ofp, "%d tunnels in %.6f secs, %.2f tunnels/sec",
15141 count, after - before, count / (after - before));
15145 /* Wait for a reply... */
15154 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
15156 vat_main_t *vam = &vat_main;
15158 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
15159 "crypto_key %U integ_alg %u integ_key %U flags %x "
15160 "tunnel_src_addr %U tunnel_dst_addr %U "
15161 "salt %u seq_outbound %lu last_seq_inbound %lu "
15162 "replay_window %lu\n",
15163 ntohl (mp->entry.sad_id),
15164 ntohl (mp->sw_if_index),
15165 ntohl (mp->entry.spi),
15166 ntohl (mp->entry.protocol),
15167 ntohl (mp->entry.crypto_algorithm),
15168 format_hex_bytes, mp->entry.crypto_key.data,
15169 mp->entry.crypto_key.length, ntohl (mp->entry.integrity_algorithm),
15170 format_hex_bytes, mp->entry.integrity_key.data,
15171 mp->entry.integrity_key.length, ntohl (mp->entry.flags),
15172 format_vl_api_address, &mp->entry.tunnel_src, format_vl_api_address,
15173 &mp->entry.tunnel_dst, ntohl (mp->salt),
15174 clib_net_to_host_u64 (mp->seq_outbound),
15175 clib_net_to_host_u64 (mp->last_seq_inbound),
15176 clib_net_to_host_u64 (mp->replay_window));
15179 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
15180 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
15182 static void vl_api_ipsec_sa_details_t_handler_json
15183 (vl_api_ipsec_sa_details_t * mp)
15185 vat_main_t *vam = &vat_main;
15186 vat_json_node_t *node = NULL;
15187 vl_api_ipsec_sad_flags_t flags;
15189 if (VAT_JSON_ARRAY != vam->json_tree.type)
15191 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15192 vat_json_init_array (&vam->json_tree);
15194 node = vat_json_array_add (&vam->json_tree);
15196 vat_json_init_object (node);
15197 vat_json_object_add_uint (node, "sa_id", ntohl (mp->entry.sad_id));
15198 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
15199 vat_json_object_add_uint (node, "spi", ntohl (mp->entry.spi));
15200 vat_json_object_add_uint (node, "proto", ntohl (mp->entry.protocol));
15201 vat_json_object_add_uint (node, "crypto_alg",
15202 ntohl (mp->entry.crypto_algorithm));
15203 vat_json_object_add_uint (node, "integ_alg",
15204 ntohl (mp->entry.integrity_algorithm));
15205 flags = ntohl (mp->entry.flags);
15206 vat_json_object_add_uint (node, "use_esn",
15207 ! !(flags & IPSEC_API_SAD_FLAG_USE_ESN));
15208 vat_json_object_add_uint (node, "use_anti_replay",
15209 ! !(flags & IPSEC_API_SAD_FLAG_USE_ANTI_REPLAY));
15210 vat_json_object_add_uint (node, "is_tunnel",
15211 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL));
15212 vat_json_object_add_uint (node, "is_tunnel_ip6",
15213 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL_V6));
15214 vat_json_object_add_uint (node, "udp_encap",
15215 ! !(flags & IPSEC_API_SAD_FLAG_UDP_ENCAP));
15216 vat_json_object_add_bytes (node, "crypto_key", mp->entry.crypto_key.data,
15217 mp->entry.crypto_key.length);
15218 vat_json_object_add_bytes (node, "integ_key", mp->entry.integrity_key.data,
15219 mp->entry.integrity_key.length);
15220 vat_json_object_add_address (node, "src", &mp->entry.tunnel_src);
15221 vat_json_object_add_address (node, "dst", &mp->entry.tunnel_dst);
15222 vat_json_object_add_uint (node, "replay_window",
15223 clib_net_to_host_u64 (mp->replay_window));
15227 api_ipsec_sa_dump (vat_main_t * vam)
15229 unformat_input_t *i = vam->input;
15230 vl_api_ipsec_sa_dump_t *mp;
15231 vl_api_control_ping_t *mp_ping;
15235 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15237 if (unformat (i, "sa_id %d", &sa_id))
15241 clib_warning ("parse error '%U'", format_unformat_error, i);
15246 M (IPSEC_SA_DUMP, mp);
15248 mp->sa_id = ntohl (sa_id);
15252 /* Use a control ping for synchronization */
15253 M (CONTROL_PING, mp_ping);
15261 api_ipsec_tunnel_if_set_key (vat_main_t * vam)
15263 unformat_input_t *i = vam->input;
15264 vl_api_ipsec_tunnel_if_set_key_t *mp;
15265 u32 sw_if_index = ~0;
15266 u8 key_type = IPSEC_IF_SET_KEY_TYPE_NONE;
15271 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15273 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15277 (i, "local crypto %U", unformat_ipsec_api_crypto_alg, &alg))
15278 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_CRYPTO;
15281 (i, "remote crypto %U", unformat_ipsec_api_crypto_alg, &alg))
15282 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_CRYPTO;
15285 (i, "local integ %U", unformat_ipsec_api_integ_alg, &alg))
15286 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_INTEG;
15289 (i, "remote integ %U", unformat_ipsec_api_integ_alg, &alg))
15290 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_INTEG;
15291 else if (unformat (i, "%U", unformat_hex_string, &key))
15295 clib_warning ("parse error '%U'", format_unformat_error, i);
15300 if (sw_if_index == ~0)
15302 errmsg ("interface must be specified");
15306 if (key_type == IPSEC_IF_SET_KEY_TYPE_NONE)
15308 errmsg ("key type must be specified");
15314 errmsg ("algorithm must be specified");
15318 if (vec_len (key) == 0)
15320 errmsg ("key must be specified");
15324 M (IPSEC_TUNNEL_IF_SET_KEY, mp);
15326 mp->sw_if_index = htonl (sw_if_index);
15328 mp->key_type = key_type;
15329 mp->key_len = vec_len (key);
15330 clib_memcpy (mp->key, key, vec_len (key));
15339 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
15341 unformat_input_t *i = vam->input;
15342 vl_api_ipsec_tunnel_if_set_sa_t *mp;
15343 u32 sw_if_index = ~0;
15345 u8 is_outbound = (u8) ~ 0;
15348 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15350 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15352 else if (unformat (i, "sa_id %d", &sa_id))
15354 else if (unformat (i, "outbound"))
15356 else if (unformat (i, "inbound"))
15360 clib_warning ("parse error '%U'", format_unformat_error, i);
15365 if (sw_if_index == ~0)
15367 errmsg ("interface must be specified");
15373 errmsg ("SA ID must be specified");
15377 M (IPSEC_TUNNEL_IF_SET_SA, mp);
15379 mp->sw_if_index = htonl (sw_if_index);
15380 mp->sa_id = htonl (sa_id);
15381 mp->is_outbound = is_outbound;
15390 api_get_first_msg_id (vat_main_t * vam)
15392 vl_api_get_first_msg_id_t *mp;
15393 unformat_input_t *i = vam->input;
15398 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15400 if (unformat (i, "client %s", &name))
15408 errmsg ("missing client name");
15411 vec_add1 (name, 0);
15413 if (vec_len (name) > 63)
15415 errmsg ("client name too long");
15419 M (GET_FIRST_MSG_ID, mp);
15420 clib_memcpy (mp->name, name, vec_len (name));
15427 api_cop_interface_enable_disable (vat_main_t * vam)
15429 unformat_input_t *line_input = vam->input;
15430 vl_api_cop_interface_enable_disable_t *mp;
15431 u32 sw_if_index = ~0;
15432 u8 enable_disable = 1;
15435 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15437 if (unformat (line_input, "disable"))
15438 enable_disable = 0;
15439 if (unformat (line_input, "enable"))
15440 enable_disable = 1;
15441 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
15442 vam, &sw_if_index))
15444 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
15450 if (sw_if_index == ~0)
15452 errmsg ("missing interface name or sw_if_index");
15456 /* Construct the API message */
15457 M (COP_INTERFACE_ENABLE_DISABLE, mp);
15458 mp->sw_if_index = ntohl (sw_if_index);
15459 mp->enable_disable = enable_disable;
15463 /* Wait for the reply */
15469 api_cop_whitelist_enable_disable (vat_main_t * vam)
15471 unformat_input_t *line_input = vam->input;
15472 vl_api_cop_whitelist_enable_disable_t *mp;
15473 u32 sw_if_index = ~0;
15474 u8 ip4 = 0, ip6 = 0, default_cop = 0;
15478 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15480 if (unformat (line_input, "ip4"))
15482 else if (unformat (line_input, "ip6"))
15484 else if (unformat (line_input, "default"))
15486 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
15487 vam, &sw_if_index))
15489 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
15491 else if (unformat (line_input, "fib-id %d", &fib_id))
15497 if (sw_if_index == ~0)
15499 errmsg ("missing interface name or sw_if_index");
15503 /* Construct the API message */
15504 M (COP_WHITELIST_ENABLE_DISABLE, mp);
15505 mp->sw_if_index = ntohl (sw_if_index);
15506 mp->fib_id = ntohl (fib_id);
15509 mp->default_cop = default_cop;
15513 /* Wait for the reply */
15519 api_get_node_graph (vat_main_t * vam)
15521 vl_api_get_node_graph_t *mp;
15524 M (GET_NODE_GRAPH, mp);
15528 /* Wait for the reply */
15534 /** Used for parsing LISP eids */
15535 typedef CLIB_PACKED(struct{
15536 u8 addr[16]; /**< eid address */
15537 u32 len; /**< prefix length if IP */
15538 u8 type; /**< type of eid */
15543 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
15545 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
15547 clib_memset (a, 0, sizeof (a[0]));
15549 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
15551 a->type = 0; /* ipv4 type */
15553 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
15555 a->type = 1; /* ipv6 type */
15557 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
15559 a->type = 2; /* mac type */
15561 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
15563 a->type = 3; /* NSH type */
15564 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
15565 nsh->spi = clib_host_to_net_u32 (nsh->spi);
15572 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
15581 lisp_eid_size_vat (u8 type)
15598 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
15600 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
15604 api_one_add_del_locator_set (vat_main_t * vam)
15606 unformat_input_t *input = vam->input;
15607 vl_api_one_add_del_locator_set_t *mp;
15609 u8 *locator_set_name = NULL;
15610 u8 locator_set_name_set = 0;
15611 vl_api_local_locator_t locator, *locators = 0;
15612 u32 sw_if_index, priority, weight;
15616 /* Parse args required to build the message */
15617 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15619 if (unformat (input, "del"))
15623 else if (unformat (input, "locator-set %s", &locator_set_name))
15625 locator_set_name_set = 1;
15627 else if (unformat (input, "sw_if_index %u p %u w %u",
15628 &sw_if_index, &priority, &weight))
15630 locator.sw_if_index = htonl (sw_if_index);
15631 locator.priority = priority;
15632 locator.weight = weight;
15633 vec_add1 (locators, locator);
15637 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
15638 &sw_if_index, &priority, &weight))
15640 locator.sw_if_index = htonl (sw_if_index);
15641 locator.priority = priority;
15642 locator.weight = weight;
15643 vec_add1 (locators, locator);
15649 if (locator_set_name_set == 0)
15651 errmsg ("missing locator-set name");
15652 vec_free (locators);
15656 if (vec_len (locator_set_name) > 64)
15658 errmsg ("locator-set name too long");
15659 vec_free (locator_set_name);
15660 vec_free (locators);
15663 vec_add1 (locator_set_name, 0);
15665 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
15667 /* Construct the API message */
15668 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
15670 mp->is_add = is_add;
15671 clib_memcpy (mp->locator_set_name, locator_set_name,
15672 vec_len (locator_set_name));
15673 vec_free (locator_set_name);
15675 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
15677 clib_memcpy (mp->locators, locators, data_len);
15678 vec_free (locators);
15683 /* Wait for a reply... */
15688 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
15691 api_one_add_del_locator (vat_main_t * vam)
15693 unformat_input_t *input = vam->input;
15694 vl_api_one_add_del_locator_t *mp;
15695 u32 tmp_if_index = ~0;
15696 u32 sw_if_index = ~0;
15697 u8 sw_if_index_set = 0;
15698 u8 sw_if_index_if_name_set = 0;
15700 u8 priority_set = 0;
15704 u8 *locator_set_name = NULL;
15705 u8 locator_set_name_set = 0;
15708 /* Parse args required to build the message */
15709 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15711 if (unformat (input, "del"))
15715 else if (unformat (input, "locator-set %s", &locator_set_name))
15717 locator_set_name_set = 1;
15719 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
15722 sw_if_index_if_name_set = 1;
15723 sw_if_index = tmp_if_index;
15725 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
15727 sw_if_index_set = 1;
15728 sw_if_index = tmp_if_index;
15730 else if (unformat (input, "p %d", &priority))
15734 else if (unformat (input, "w %d", &weight))
15742 if (locator_set_name_set == 0)
15744 errmsg ("missing locator-set name");
15748 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
15750 errmsg ("missing sw_if_index");
15751 vec_free (locator_set_name);
15755 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
15757 errmsg ("cannot use both params interface name and sw_if_index");
15758 vec_free (locator_set_name);
15762 if (priority_set == 0)
15764 errmsg ("missing locator-set priority");
15765 vec_free (locator_set_name);
15769 if (weight_set == 0)
15771 errmsg ("missing locator-set weight");
15772 vec_free (locator_set_name);
15776 if (vec_len (locator_set_name) > 64)
15778 errmsg ("locator-set name too long");
15779 vec_free (locator_set_name);
15782 vec_add1 (locator_set_name, 0);
15784 /* Construct the API message */
15785 M (ONE_ADD_DEL_LOCATOR, mp);
15787 mp->is_add = is_add;
15788 mp->sw_if_index = ntohl (sw_if_index);
15789 mp->priority = priority;
15790 mp->weight = weight;
15791 clib_memcpy (mp->locator_set_name, locator_set_name,
15792 vec_len (locator_set_name));
15793 vec_free (locator_set_name);
15798 /* Wait for a reply... */
15803 #define api_lisp_add_del_locator api_one_add_del_locator
15806 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
15808 u32 *key_id = va_arg (*args, u32 *);
15811 if (unformat (input, "%s", &s))
15813 if (!strcmp ((char *) s, "sha1"))
15814 key_id[0] = HMAC_SHA_1_96;
15815 else if (!strcmp ((char *) s, "sha256"))
15816 key_id[0] = HMAC_SHA_256_128;
15819 clib_warning ("invalid key_id: '%s'", s);
15820 key_id[0] = HMAC_NO_KEY;
15831 api_one_add_del_local_eid (vat_main_t * vam)
15833 unformat_input_t *input = vam->input;
15834 vl_api_one_add_del_local_eid_t *mp;
15837 lisp_eid_vat_t _eid, *eid = &_eid;
15838 u8 *locator_set_name = 0;
15839 u8 locator_set_name_set = 0;
15845 /* Parse args required to build the message */
15846 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15848 if (unformat (input, "del"))
15852 else if (unformat (input, "vni %d", &vni))
15856 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
15860 else if (unformat (input, "locator-set %s", &locator_set_name))
15862 locator_set_name_set = 1;
15864 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
15866 else if (unformat (input, "secret-key %_%v%_", &key))
15872 if (locator_set_name_set == 0)
15874 errmsg ("missing locator-set name");
15880 errmsg ("EID address not set!");
15881 vec_free (locator_set_name);
15885 if (key && (0 == key_id))
15887 errmsg ("invalid key_id!");
15891 if (vec_len (key) > 64)
15893 errmsg ("key too long");
15898 if (vec_len (locator_set_name) > 64)
15900 errmsg ("locator-set name too long");
15901 vec_free (locator_set_name);
15904 vec_add1 (locator_set_name, 0);
15906 /* Construct the API message */
15907 M (ONE_ADD_DEL_LOCAL_EID, mp);
15909 mp->is_add = is_add;
15910 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
15911 mp->eid_type = eid->type;
15912 mp->prefix_len = eid->len;
15913 mp->vni = clib_host_to_net_u32 (vni);
15914 mp->key_id = clib_host_to_net_u16 (key_id);
15915 clib_memcpy (mp->locator_set_name, locator_set_name,
15916 vec_len (locator_set_name));
15917 clib_memcpy (mp->key, key, vec_len (key));
15919 vec_free (locator_set_name);
15925 /* Wait for a reply... */
15930 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
15933 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
15935 u32 dp_table = 0, vni = 0;;
15936 unformat_input_t *input = vam->input;
15937 vl_api_gpe_add_del_fwd_entry_t *mp;
15939 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
15940 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
15941 u8 rmt_eid_set = 0, lcl_eid_set = 0;
15942 u32 action = ~0, w;
15943 ip4_address_t rmt_rloc4, lcl_rloc4;
15944 ip6_address_t rmt_rloc6, lcl_rloc6;
15945 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
15948 clib_memset (&rloc, 0, sizeof (rloc));
15950 /* Parse args required to build the message */
15951 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15953 if (unformat (input, "del"))
15955 else if (unformat (input, "add"))
15957 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
15961 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
15965 else if (unformat (input, "vrf %d", &dp_table))
15967 else if (unformat (input, "bd %d", &dp_table))
15969 else if (unformat (input, "vni %d", &vni))
15971 else if (unformat (input, "w %d", &w))
15975 errmsg ("No RLOC configured for setting priority/weight!");
15978 curr_rloc->weight = w;
15980 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
15981 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
15985 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
15987 vec_add1 (lcl_locs, rloc);
15989 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
15990 vec_add1 (rmt_locs, rloc);
15991 /* weight saved in rmt loc */
15992 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
15994 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
15995 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
15998 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
16000 vec_add1 (lcl_locs, rloc);
16002 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
16003 vec_add1 (rmt_locs, rloc);
16004 /* weight saved in rmt loc */
16005 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
16007 else if (unformat (input, "action %d", &action))
16013 clib_warning ("parse error '%U'", format_unformat_error, input);
16020 errmsg ("remote eid addresses not set");
16024 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
16026 errmsg ("eid types don't match");
16030 if (0 == rmt_locs && (u32) ~ 0 == action)
16032 errmsg ("action not set for negative mapping");
16036 /* Construct the API message */
16037 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
16038 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
16040 mp->is_add = is_add;
16041 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
16042 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
16043 mp->eid_type = rmt_eid->type;
16044 mp->dp_table = clib_host_to_net_u32 (dp_table);
16045 mp->vni = clib_host_to_net_u32 (vni);
16046 mp->rmt_len = rmt_eid->len;
16047 mp->lcl_len = lcl_eid->len;
16048 mp->action = action;
16050 if (0 != rmt_locs && 0 != lcl_locs)
16052 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
16053 clib_memcpy (mp->locs, lcl_locs,
16054 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
16056 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
16057 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
16058 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
16060 vec_free (lcl_locs);
16061 vec_free (rmt_locs);
16066 /* Wait for a reply... */
16072 api_one_add_del_map_server (vat_main_t * vam)
16074 unformat_input_t *input = vam->input;
16075 vl_api_one_add_del_map_server_t *mp;
16079 ip4_address_t ipv4;
16080 ip6_address_t ipv6;
16083 /* Parse args required to build the message */
16084 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16086 if (unformat (input, "del"))
16090 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
16094 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
16102 if (ipv4_set && ipv6_set)
16104 errmsg ("both eid v4 and v6 addresses set");
16108 if (!ipv4_set && !ipv6_set)
16110 errmsg ("eid addresses not set");
16114 /* Construct the API message */
16115 M (ONE_ADD_DEL_MAP_SERVER, mp);
16117 mp->is_add = is_add;
16121 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
16126 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
16132 /* Wait for a reply... */
16137 #define api_lisp_add_del_map_server api_one_add_del_map_server
16140 api_one_add_del_map_resolver (vat_main_t * vam)
16142 unformat_input_t *input = vam->input;
16143 vl_api_one_add_del_map_resolver_t *mp;
16147 ip4_address_t ipv4;
16148 ip6_address_t ipv6;
16151 /* Parse args required to build the message */
16152 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16154 if (unformat (input, "del"))
16158 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
16162 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
16170 if (ipv4_set && ipv6_set)
16172 errmsg ("both eid v4 and v6 addresses set");
16176 if (!ipv4_set && !ipv6_set)
16178 errmsg ("eid addresses not set");
16182 /* Construct the API message */
16183 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
16185 mp->is_add = is_add;
16189 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
16194 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
16200 /* Wait for a reply... */
16205 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
16208 api_lisp_gpe_enable_disable (vat_main_t * vam)
16210 unformat_input_t *input = vam->input;
16211 vl_api_gpe_enable_disable_t *mp;
16216 /* Parse args required to build the message */
16217 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16219 if (unformat (input, "enable"))
16224 else if (unformat (input, "disable"))
16235 errmsg ("Value not set");
16239 /* Construct the API message */
16240 M (GPE_ENABLE_DISABLE, mp);
16247 /* Wait for a reply... */
16253 api_one_rloc_probe_enable_disable (vat_main_t * vam)
16255 unformat_input_t *input = vam->input;
16256 vl_api_one_rloc_probe_enable_disable_t *mp;
16261 /* Parse args required to build the message */
16262 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16264 if (unformat (input, "enable"))
16269 else if (unformat (input, "disable"))
16277 errmsg ("Value not set");
16281 /* Construct the API message */
16282 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
16284 mp->is_enabled = is_en;
16289 /* Wait for a reply... */
16294 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
16297 api_one_map_register_enable_disable (vat_main_t * vam)
16299 unformat_input_t *input = vam->input;
16300 vl_api_one_map_register_enable_disable_t *mp;
16305 /* Parse args required to build the message */
16306 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16308 if (unformat (input, "enable"))
16313 else if (unformat (input, "disable"))
16321 errmsg ("Value not set");
16325 /* Construct the API message */
16326 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
16328 mp->is_enabled = is_en;
16333 /* Wait for a reply... */
16338 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
16341 api_one_enable_disable (vat_main_t * vam)
16343 unformat_input_t *input = vam->input;
16344 vl_api_one_enable_disable_t *mp;
16349 /* Parse args required to build the message */
16350 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16352 if (unformat (input, "enable"))
16357 else if (unformat (input, "disable"))
16367 errmsg ("Value not set");
16371 /* Construct the API message */
16372 M (ONE_ENABLE_DISABLE, mp);
16379 /* Wait for a reply... */
16384 #define api_lisp_enable_disable api_one_enable_disable
16387 api_one_enable_disable_xtr_mode (vat_main_t * vam)
16389 unformat_input_t *input = vam->input;
16390 vl_api_one_enable_disable_xtr_mode_t *mp;
16395 /* Parse args required to build the message */
16396 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16398 if (unformat (input, "enable"))
16403 else if (unformat (input, "disable"))
16413 errmsg ("Value not set");
16417 /* Construct the API message */
16418 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
16425 /* Wait for a reply... */
16431 api_one_show_xtr_mode (vat_main_t * vam)
16433 vl_api_one_show_xtr_mode_t *mp;
16436 /* Construct the API message */
16437 M (ONE_SHOW_XTR_MODE, mp);
16442 /* Wait for a reply... */
16448 api_one_enable_disable_pitr_mode (vat_main_t * vam)
16450 unformat_input_t *input = vam->input;
16451 vl_api_one_enable_disable_pitr_mode_t *mp;
16456 /* Parse args required to build the message */
16457 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16459 if (unformat (input, "enable"))
16464 else if (unformat (input, "disable"))
16474 errmsg ("Value not set");
16478 /* Construct the API message */
16479 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
16486 /* Wait for a reply... */
16492 api_one_show_pitr_mode (vat_main_t * vam)
16494 vl_api_one_show_pitr_mode_t *mp;
16497 /* Construct the API message */
16498 M (ONE_SHOW_PITR_MODE, mp);
16503 /* Wait for a reply... */
16509 api_one_enable_disable_petr_mode (vat_main_t * vam)
16511 unformat_input_t *input = vam->input;
16512 vl_api_one_enable_disable_petr_mode_t *mp;
16517 /* Parse args required to build the message */
16518 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16520 if (unformat (input, "enable"))
16525 else if (unformat (input, "disable"))
16535 errmsg ("Value not set");
16539 /* Construct the API message */
16540 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
16547 /* Wait for a reply... */
16553 api_one_show_petr_mode (vat_main_t * vam)
16555 vl_api_one_show_petr_mode_t *mp;
16558 /* Construct the API message */
16559 M (ONE_SHOW_PETR_MODE, mp);
16564 /* Wait for a reply... */
16570 api_show_one_map_register_state (vat_main_t * vam)
16572 vl_api_show_one_map_register_state_t *mp;
16575 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
16580 /* wait for reply */
16585 #define api_show_lisp_map_register_state api_show_one_map_register_state
16588 api_show_one_rloc_probe_state (vat_main_t * vam)
16590 vl_api_show_one_rloc_probe_state_t *mp;
16593 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
16598 /* wait for reply */
16603 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
16606 api_one_add_del_ndp_entry (vat_main_t * vam)
16608 vl_api_one_add_del_ndp_entry_t *mp;
16609 unformat_input_t *input = vam->input;
16614 u8 mac[6] = { 0, };
16615 u8 ip6[16] = { 0, };
16619 /* Parse args required to build the message */
16620 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16622 if (unformat (input, "del"))
16624 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
16626 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
16628 else if (unformat (input, "bd %d", &bd))
16632 errmsg ("parse error '%U'", format_unformat_error, input);
16637 if (!bd_set || !ip_set || (!mac_set && is_add))
16639 errmsg ("Missing BD, IP or MAC!");
16643 M (ONE_ADD_DEL_NDP_ENTRY, mp);
16644 mp->is_add = is_add;
16645 clib_memcpy (mp->mac, mac, 6);
16646 mp->bd = clib_host_to_net_u32 (bd);
16647 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
16652 /* wait for reply */
16658 api_one_add_del_l2_arp_entry (vat_main_t * vam)
16660 vl_api_one_add_del_l2_arp_entry_t *mp;
16661 unformat_input_t *input = vam->input;
16666 u8 mac[6] = { 0, };
16667 u32 ip4 = 0, bd = ~0;
16670 /* Parse args required to build the message */
16671 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16673 if (unformat (input, "del"))
16675 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
16677 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
16679 else if (unformat (input, "bd %d", &bd))
16683 errmsg ("parse error '%U'", format_unformat_error, input);
16688 if (!bd_set || !ip_set || (!mac_set && is_add))
16690 errmsg ("Missing BD, IP or MAC!");
16694 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
16695 mp->is_add = is_add;
16696 clib_memcpy (mp->mac, mac, 6);
16697 mp->bd = clib_host_to_net_u32 (bd);
16703 /* wait for reply */
16709 api_one_ndp_bd_get (vat_main_t * vam)
16711 vl_api_one_ndp_bd_get_t *mp;
16714 M (ONE_NDP_BD_GET, mp);
16719 /* wait for reply */
16725 api_one_ndp_entries_get (vat_main_t * vam)
16727 vl_api_one_ndp_entries_get_t *mp;
16728 unformat_input_t *input = vam->input;
16733 /* Parse args required to build the message */
16734 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16736 if (unformat (input, "bd %d", &bd))
16740 errmsg ("parse error '%U'", format_unformat_error, input);
16747 errmsg ("Expected bridge domain!");
16751 M (ONE_NDP_ENTRIES_GET, mp);
16752 mp->bd = clib_host_to_net_u32 (bd);
16757 /* wait for reply */
16763 api_one_l2_arp_bd_get (vat_main_t * vam)
16765 vl_api_one_l2_arp_bd_get_t *mp;
16768 M (ONE_L2_ARP_BD_GET, mp);
16773 /* wait for reply */
16779 api_one_l2_arp_entries_get (vat_main_t * vam)
16781 vl_api_one_l2_arp_entries_get_t *mp;
16782 unformat_input_t *input = vam->input;
16787 /* Parse args required to build the message */
16788 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16790 if (unformat (input, "bd %d", &bd))
16794 errmsg ("parse error '%U'", format_unformat_error, input);
16801 errmsg ("Expected bridge domain!");
16805 M (ONE_L2_ARP_ENTRIES_GET, mp);
16806 mp->bd = clib_host_to_net_u32 (bd);
16811 /* wait for reply */
16817 api_one_stats_enable_disable (vat_main_t * vam)
16819 vl_api_one_stats_enable_disable_t *mp;
16820 unformat_input_t *input = vam->input;
16825 /* Parse args required to build the message */
16826 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16828 if (unformat (input, "enable"))
16833 else if (unformat (input, "disable"))
16843 errmsg ("Value not set");
16847 M (ONE_STATS_ENABLE_DISABLE, mp);
16853 /* wait for reply */
16859 api_show_one_stats_enable_disable (vat_main_t * vam)
16861 vl_api_show_one_stats_enable_disable_t *mp;
16864 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
16869 /* wait for reply */
16875 api_show_one_map_request_mode (vat_main_t * vam)
16877 vl_api_show_one_map_request_mode_t *mp;
16880 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
16885 /* wait for reply */
16890 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
16893 api_one_map_request_mode (vat_main_t * vam)
16895 unformat_input_t *input = vam->input;
16896 vl_api_one_map_request_mode_t *mp;
16900 /* Parse args required to build the message */
16901 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16903 if (unformat (input, "dst-only"))
16905 else if (unformat (input, "src-dst"))
16909 errmsg ("parse error '%U'", format_unformat_error, input);
16914 M (ONE_MAP_REQUEST_MODE, mp);
16921 /* wait for reply */
16926 #define api_lisp_map_request_mode api_one_map_request_mode
16929 * Enable/disable ONE proxy ITR.
16931 * @param vam vpp API test context
16932 * @return return code
16935 api_one_pitr_set_locator_set (vat_main_t * vam)
16937 u8 ls_name_set = 0;
16938 unformat_input_t *input = vam->input;
16939 vl_api_one_pitr_set_locator_set_t *mp;
16944 /* Parse args required to build the message */
16945 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16947 if (unformat (input, "del"))
16949 else if (unformat (input, "locator-set %s", &ls_name))
16953 errmsg ("parse error '%U'", format_unformat_error, input);
16960 errmsg ("locator-set name not set!");
16964 M (ONE_PITR_SET_LOCATOR_SET, mp);
16966 mp->is_add = is_add;
16967 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
16968 vec_free (ls_name);
16973 /* wait for reply */
16978 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
16981 api_one_nsh_set_locator_set (vat_main_t * vam)
16983 u8 ls_name_set = 0;
16984 unformat_input_t *input = vam->input;
16985 vl_api_one_nsh_set_locator_set_t *mp;
16990 /* Parse args required to build the message */
16991 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16993 if (unformat (input, "del"))
16995 else if (unformat (input, "ls %s", &ls_name))
16999 errmsg ("parse error '%U'", format_unformat_error, input);
17004 if (!ls_name_set && is_add)
17006 errmsg ("locator-set name not set!");
17010 M (ONE_NSH_SET_LOCATOR_SET, mp);
17012 mp->is_add = is_add;
17013 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
17014 vec_free (ls_name);
17019 /* wait for reply */
17025 api_show_one_pitr (vat_main_t * vam)
17027 vl_api_show_one_pitr_t *mp;
17030 if (!vam->json_output)
17032 print (vam->ofp, "%=20s", "lisp status:");
17035 M (SHOW_ONE_PITR, mp);
17039 /* Wait for a reply... */
17044 #define api_show_lisp_pitr api_show_one_pitr
17047 api_one_use_petr (vat_main_t * vam)
17049 unformat_input_t *input = vam->input;
17050 vl_api_one_use_petr_t *mp;
17055 clib_memset (&ip, 0, sizeof (ip));
17057 /* Parse args required to build the message */
17058 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17060 if (unformat (input, "disable"))
17063 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
17066 ip_addr_version (&ip) = IP4;
17069 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
17072 ip_addr_version (&ip) = IP6;
17076 errmsg ("parse error '%U'", format_unformat_error, input);
17081 M (ONE_USE_PETR, mp);
17083 mp->is_add = is_add;
17086 mp->is_ip4 = ip_addr_version (&ip) == IP4 ? 1 : 0;
17088 clib_memcpy (mp->address, &ip, 4);
17090 clib_memcpy (mp->address, &ip, 16);
17096 /* wait for reply */
17101 #define api_lisp_use_petr api_one_use_petr
17104 api_show_one_nsh_mapping (vat_main_t * vam)
17106 vl_api_show_one_use_petr_t *mp;
17109 if (!vam->json_output)
17111 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
17114 M (SHOW_ONE_NSH_MAPPING, mp);
17118 /* Wait for a reply... */
17124 api_show_one_use_petr (vat_main_t * vam)
17126 vl_api_show_one_use_petr_t *mp;
17129 if (!vam->json_output)
17131 print (vam->ofp, "%=20s", "Proxy-ETR status:");
17134 M (SHOW_ONE_USE_PETR, mp);
17138 /* Wait for a reply... */
17143 #define api_show_lisp_use_petr api_show_one_use_petr
17146 * Add/delete mapping between vni and vrf
17149 api_one_eid_table_add_del_map (vat_main_t * vam)
17151 unformat_input_t *input = vam->input;
17152 vl_api_one_eid_table_add_del_map_t *mp;
17153 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
17154 u32 vni, vrf, bd_index;
17157 /* Parse args required to build the message */
17158 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17160 if (unformat (input, "del"))
17162 else if (unformat (input, "vrf %d", &vrf))
17164 else if (unformat (input, "bd_index %d", &bd_index))
17166 else if (unformat (input, "vni %d", &vni))
17172 if (!vni_set || (!vrf_set && !bd_index_set))
17174 errmsg ("missing arguments!");
17178 if (vrf_set && bd_index_set)
17180 errmsg ("error: both vrf and bd entered!");
17184 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
17186 mp->is_add = is_add;
17187 mp->vni = htonl (vni);
17188 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
17189 mp->is_l2 = bd_index_set;
17194 /* wait for reply */
17199 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
17202 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
17204 u32 *action = va_arg (*args, u32 *);
17207 if (unformat (input, "%s", &s))
17209 if (!strcmp ((char *) s, "no-action"))
17211 else if (!strcmp ((char *) s, "natively-forward"))
17213 else if (!strcmp ((char *) s, "send-map-request"))
17215 else if (!strcmp ((char *) s, "drop"))
17219 clib_warning ("invalid action: '%s'", s);
17231 * Add/del remote mapping to/from ONE control plane
17233 * @param vam vpp API test context
17234 * @return return code
17237 api_one_add_del_remote_mapping (vat_main_t * vam)
17239 unformat_input_t *input = vam->input;
17240 vl_api_one_add_del_remote_mapping_t *mp;
17242 lisp_eid_vat_t _eid, *eid = &_eid;
17243 lisp_eid_vat_t _seid, *seid = &_seid;
17244 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
17245 u32 action = ~0, p, w, data_len;
17246 ip4_address_t rloc4;
17247 ip6_address_t rloc6;
17248 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
17251 clib_memset (&rloc, 0, sizeof (rloc));
17253 /* Parse args required to build the message */
17254 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17256 if (unformat (input, "del-all"))
17260 else if (unformat (input, "del"))
17264 else if (unformat (input, "add"))
17268 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
17272 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
17276 else if (unformat (input, "vni %d", &vni))
17280 else if (unformat (input, "p %d w %d", &p, &w))
17284 errmsg ("No RLOC configured for setting priority/weight!");
17287 curr_rloc->priority = p;
17288 curr_rloc->weight = w;
17290 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
17293 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
17294 vec_add1 (rlocs, rloc);
17295 curr_rloc = &rlocs[vec_len (rlocs) - 1];
17297 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
17300 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
17301 vec_add1 (rlocs, rloc);
17302 curr_rloc = &rlocs[vec_len (rlocs) - 1];
17304 else if (unformat (input, "action %U",
17305 unformat_negative_mapping_action, &action))
17311 clib_warning ("parse error '%U'", format_unformat_error, input);
17318 errmsg ("missing params!");
17322 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
17324 errmsg ("no action set for negative map-reply!");
17328 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
17330 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
17331 mp->is_add = is_add;
17332 mp->vni = htonl (vni);
17333 mp->action = (u8) action;
17334 mp->is_src_dst = seid_set;
17335 mp->eid_len = eid->len;
17336 mp->seid_len = seid->len;
17337 mp->del_all = del_all;
17338 mp->eid_type = eid->type;
17339 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
17340 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
17342 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
17343 clib_memcpy (mp->rlocs, rlocs, data_len);
17349 /* Wait for a reply... */
17354 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
17357 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
17358 * forwarding entries in data-plane accordingly.
17360 * @param vam vpp API test context
17361 * @return return code
17364 api_one_add_del_adjacency (vat_main_t * vam)
17366 unformat_input_t *input = vam->input;
17367 vl_api_one_add_del_adjacency_t *mp;
17369 ip4_address_t leid4, reid4;
17370 ip6_address_t leid6, reid6;
17371 u8 reid_mac[6] = { 0 };
17372 u8 leid_mac[6] = { 0 };
17373 u8 reid_type, leid_type;
17374 u32 leid_len = 0, reid_len = 0, len;
17378 leid_type = reid_type = (u8) ~ 0;
17380 /* Parse args required to build the message */
17381 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17383 if (unformat (input, "del"))
17387 else if (unformat (input, "add"))
17391 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
17394 reid_type = 0; /* ipv4 */
17397 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
17400 reid_type = 1; /* ipv6 */
17403 else if (unformat (input, "reid %U", unformat_ethernet_address,
17406 reid_type = 2; /* mac */
17408 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
17411 leid_type = 0; /* ipv4 */
17414 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
17417 leid_type = 1; /* ipv6 */
17420 else if (unformat (input, "leid %U", unformat_ethernet_address,
17423 leid_type = 2; /* mac */
17425 else if (unformat (input, "vni %d", &vni))
17431 errmsg ("parse error '%U'", format_unformat_error, input);
17436 if ((u8) ~ 0 == reid_type)
17438 errmsg ("missing params!");
17442 if (leid_type != reid_type)
17444 errmsg ("remote and local EIDs are of different types!");
17448 M (ONE_ADD_DEL_ADJACENCY, mp);
17449 mp->is_add = is_add;
17450 mp->vni = htonl (vni);
17451 mp->leid_len = leid_len;
17452 mp->reid_len = reid_len;
17453 mp->eid_type = reid_type;
17455 switch (mp->eid_type)
17458 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
17459 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
17462 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
17463 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
17466 clib_memcpy (mp->leid, leid_mac, 6);
17467 clib_memcpy (mp->reid, reid_mac, 6);
17470 errmsg ("unknown EID type %d!", mp->eid_type);
17477 /* Wait for a reply... */
17482 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
17485 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
17487 u32 *mode = va_arg (*args, u32 *);
17489 if (unformat (input, "lisp"))
17491 else if (unformat (input, "vxlan"))
17500 api_gpe_get_encap_mode (vat_main_t * vam)
17502 vl_api_gpe_get_encap_mode_t *mp;
17505 /* Construct the API message */
17506 M (GPE_GET_ENCAP_MODE, mp);
17511 /* Wait for a reply... */
17517 api_gpe_set_encap_mode (vat_main_t * vam)
17519 unformat_input_t *input = vam->input;
17520 vl_api_gpe_set_encap_mode_t *mp;
17524 /* Parse args required to build the message */
17525 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17527 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
17533 /* Construct the API message */
17534 M (GPE_SET_ENCAP_MODE, mp);
17541 /* Wait for a reply... */
17547 api_lisp_gpe_add_del_iface (vat_main_t * vam)
17549 unformat_input_t *input = vam->input;
17550 vl_api_gpe_add_del_iface_t *mp;
17551 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
17552 u32 dp_table = 0, vni = 0;
17555 /* Parse args required to build the message */
17556 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17558 if (unformat (input, "up"))
17563 else if (unformat (input, "down"))
17568 else if (unformat (input, "table_id %d", &dp_table))
17572 else if (unformat (input, "bd_id %d", &dp_table))
17577 else if (unformat (input, "vni %d", &vni))
17585 if (action_set == 0)
17587 errmsg ("Action not set");
17590 if (dp_table_set == 0 || vni_set == 0)
17592 errmsg ("vni and dp_table must be set");
17596 /* Construct the API message */
17597 M (GPE_ADD_DEL_IFACE, mp);
17599 mp->is_add = is_add;
17600 mp->dp_table = clib_host_to_net_u32 (dp_table);
17602 mp->vni = clib_host_to_net_u32 (vni);
17607 /* Wait for a reply... */
17613 api_one_map_register_fallback_threshold (vat_main_t * vam)
17615 unformat_input_t *input = vam->input;
17616 vl_api_one_map_register_fallback_threshold_t *mp;
17621 /* Parse args required to build the message */
17622 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17624 if (unformat (input, "%u", &value))
17628 clib_warning ("parse error '%U'", format_unformat_error, input);
17635 errmsg ("fallback threshold value is missing!");
17639 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
17640 mp->value = clib_host_to_net_u32 (value);
17645 /* Wait for a reply... */
17651 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
17653 vl_api_show_one_map_register_fallback_threshold_t *mp;
17656 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
17661 /* Wait for a reply... */
17667 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
17669 u32 *proto = va_arg (*args, u32 *);
17671 if (unformat (input, "udp"))
17673 else if (unformat (input, "api"))
17682 api_one_set_transport_protocol (vat_main_t * vam)
17684 unformat_input_t *input = vam->input;
17685 vl_api_one_set_transport_protocol_t *mp;
17690 /* Parse args required to build the message */
17691 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17693 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
17697 clib_warning ("parse error '%U'", format_unformat_error, input);
17704 errmsg ("Transport protocol missing!");
17708 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
17709 mp->protocol = (u8) protocol;
17714 /* Wait for a reply... */
17720 api_one_get_transport_protocol (vat_main_t * vam)
17722 vl_api_one_get_transport_protocol_t *mp;
17725 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
17730 /* Wait for a reply... */
17736 api_one_map_register_set_ttl (vat_main_t * vam)
17738 unformat_input_t *input = vam->input;
17739 vl_api_one_map_register_set_ttl_t *mp;
17744 /* Parse args required to build the message */
17745 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17747 if (unformat (input, "%u", &ttl))
17751 clib_warning ("parse error '%U'", format_unformat_error, input);
17758 errmsg ("TTL value missing!");
17762 M (ONE_MAP_REGISTER_SET_TTL, mp);
17763 mp->ttl = clib_host_to_net_u32 (ttl);
17768 /* Wait for a reply... */
17774 api_show_one_map_register_ttl (vat_main_t * vam)
17776 vl_api_show_one_map_register_ttl_t *mp;
17779 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
17784 /* Wait for a reply... */
17790 * Add/del map request itr rlocs from ONE control plane and updates
17792 * @param vam vpp API test context
17793 * @return return code
17796 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
17798 unformat_input_t *input = vam->input;
17799 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
17800 u8 *locator_set_name = 0;
17801 u8 locator_set_name_set = 0;
17805 /* Parse args required to build the message */
17806 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17808 if (unformat (input, "del"))
17812 else if (unformat (input, "%_%v%_", &locator_set_name))
17814 locator_set_name_set = 1;
17818 clib_warning ("parse error '%U'", format_unformat_error, input);
17823 if (is_add && !locator_set_name_set)
17825 errmsg ("itr-rloc is not set!");
17829 if (is_add && vec_len (locator_set_name) > 64)
17831 errmsg ("itr-rloc locator-set name too long");
17832 vec_free (locator_set_name);
17836 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
17837 mp->is_add = is_add;
17840 clib_memcpy (mp->locator_set_name, locator_set_name,
17841 vec_len (locator_set_name));
17845 clib_memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
17847 vec_free (locator_set_name);
17852 /* Wait for a reply... */
17857 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
17860 api_one_locator_dump (vat_main_t * vam)
17862 unformat_input_t *input = vam->input;
17863 vl_api_one_locator_dump_t *mp;
17864 vl_api_control_ping_t *mp_ping;
17865 u8 is_index_set = 0, is_name_set = 0;
17870 /* Parse args required to build the message */
17871 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17873 if (unformat (input, "ls_name %_%v%_", &ls_name))
17877 else if (unformat (input, "ls_index %d", &ls_index))
17883 errmsg ("parse error '%U'", format_unformat_error, input);
17888 if (!is_index_set && !is_name_set)
17890 errmsg ("error: expected one of index or name!");
17894 if (is_index_set && is_name_set)
17896 errmsg ("error: only one param expected!");
17900 if (vec_len (ls_name) > 62)
17902 errmsg ("error: locator set name too long!");
17906 if (!vam->json_output)
17908 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
17911 M (ONE_LOCATOR_DUMP, mp);
17912 mp->is_index_set = is_index_set;
17915 mp->ls_index = clib_host_to_net_u32 (ls_index);
17918 vec_add1 (ls_name, 0);
17919 strncpy ((char *) mp->ls_name, (char *) ls_name,
17920 sizeof (mp->ls_name) - 1);
17926 /* Use a control ping for synchronization */
17927 MPING (CONTROL_PING, mp_ping);
17930 /* Wait for a reply... */
17935 #define api_lisp_locator_dump api_one_locator_dump
17938 api_one_locator_set_dump (vat_main_t * vam)
17940 vl_api_one_locator_set_dump_t *mp;
17941 vl_api_control_ping_t *mp_ping;
17942 unformat_input_t *input = vam->input;
17946 /* Parse args required to build the message */
17947 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17949 if (unformat (input, "local"))
17953 else if (unformat (input, "remote"))
17959 errmsg ("parse error '%U'", format_unformat_error, input);
17964 if (!vam->json_output)
17966 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
17969 M (ONE_LOCATOR_SET_DUMP, mp);
17971 mp->filter = filter;
17976 /* Use a control ping for synchronization */
17977 MPING (CONTROL_PING, mp_ping);
17980 /* Wait for a reply... */
17985 #define api_lisp_locator_set_dump api_one_locator_set_dump
17988 api_one_eid_table_map_dump (vat_main_t * vam)
17992 unformat_input_t *input = vam->input;
17993 vl_api_one_eid_table_map_dump_t *mp;
17994 vl_api_control_ping_t *mp_ping;
17997 /* Parse args required to build the message */
17998 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18000 if (unformat (input, "l2"))
18005 else if (unformat (input, "l3"))
18012 errmsg ("parse error '%U'", format_unformat_error, input);
18019 errmsg ("expected one of 'l2' or 'l3' parameter!");
18023 if (!vam->json_output)
18025 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
18028 M (ONE_EID_TABLE_MAP_DUMP, mp);
18034 /* Use a control ping for synchronization */
18035 MPING (CONTROL_PING, mp_ping);
18038 /* Wait for a reply... */
18043 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
18046 api_one_eid_table_vni_dump (vat_main_t * vam)
18048 vl_api_one_eid_table_vni_dump_t *mp;
18049 vl_api_control_ping_t *mp_ping;
18052 if (!vam->json_output)
18054 print (vam->ofp, "VNI");
18057 M (ONE_EID_TABLE_VNI_DUMP, mp);
18062 /* Use a control ping for synchronization */
18063 MPING (CONTROL_PING, mp_ping);
18066 /* Wait for a reply... */
18071 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
18074 api_one_eid_table_dump (vat_main_t * vam)
18076 unformat_input_t *i = vam->input;
18077 vl_api_one_eid_table_dump_t *mp;
18078 vl_api_control_ping_t *mp_ping;
18079 struct in_addr ip4;
18080 struct in6_addr ip6;
18082 u8 eid_type = ~0, eid_set = 0;
18083 u32 prefix_length = ~0, t, vni = 0;
18086 lisp_nsh_api_t nsh;
18088 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18090 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
18096 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
18102 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
18107 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
18112 else if (unformat (i, "vni %d", &t))
18116 else if (unformat (i, "local"))
18120 else if (unformat (i, "remote"))
18126 errmsg ("parse error '%U'", format_unformat_error, i);
18131 if (!vam->json_output)
18133 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
18134 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
18137 M (ONE_EID_TABLE_DUMP, mp);
18139 mp->filter = filter;
18143 mp->vni = htonl (vni);
18144 mp->eid_type = eid_type;
18148 mp->prefix_length = prefix_length;
18149 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
18152 mp->prefix_length = prefix_length;
18153 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
18156 clib_memcpy (mp->eid, mac, sizeof (mac));
18159 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
18162 errmsg ("unknown EID type %d!", eid_type);
18170 /* Use a control ping for synchronization */
18171 MPING (CONTROL_PING, mp_ping);
18174 /* Wait for a reply... */
18179 #define api_lisp_eid_table_dump api_one_eid_table_dump
18182 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
18184 unformat_input_t *i = vam->input;
18185 vl_api_gpe_fwd_entries_get_t *mp;
18190 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18192 if (unformat (i, "vni %d", &vni))
18198 errmsg ("parse error '%U'", format_unformat_error, i);
18205 errmsg ("vni not set!");
18209 if (!vam->json_output)
18211 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
18215 M (GPE_FWD_ENTRIES_GET, mp);
18216 mp->vni = clib_host_to_net_u32 (vni);
18221 /* Wait for a reply... */
18226 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
18227 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
18228 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
18229 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
18230 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
18231 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
18232 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
18233 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
18236 api_one_adjacencies_get (vat_main_t * vam)
18238 unformat_input_t *i = vam->input;
18239 vl_api_one_adjacencies_get_t *mp;
18244 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18246 if (unformat (i, "vni %d", &vni))
18252 errmsg ("parse error '%U'", format_unformat_error, i);
18259 errmsg ("vni not set!");
18263 if (!vam->json_output)
18265 print (vam->ofp, "%s %40s", "leid", "reid");
18268 M (ONE_ADJACENCIES_GET, mp);
18269 mp->vni = clib_host_to_net_u32 (vni);
18274 /* Wait for a reply... */
18279 #define api_lisp_adjacencies_get api_one_adjacencies_get
18282 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
18284 unformat_input_t *i = vam->input;
18285 vl_api_gpe_native_fwd_rpaths_get_t *mp;
18287 u8 ip_family_set = 0, is_ip4 = 1;
18289 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18291 if (unformat (i, "ip4"))
18296 else if (unformat (i, "ip6"))
18303 errmsg ("parse error '%U'", format_unformat_error, i);
18308 if (!ip_family_set)
18310 errmsg ("ip family not set!");
18314 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
18315 mp->is_ip4 = is_ip4;
18320 /* Wait for a reply... */
18326 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
18328 vl_api_gpe_fwd_entry_vnis_get_t *mp;
18331 if (!vam->json_output)
18333 print (vam->ofp, "VNIs");
18336 M (GPE_FWD_ENTRY_VNIS_GET, mp);
18341 /* Wait for a reply... */
18347 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
18349 unformat_input_t *i = vam->input;
18350 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
18352 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
18353 struct in_addr ip4;
18354 struct in6_addr ip6;
18355 u32 table_id = 0, nh_sw_if_index = ~0;
18357 clib_memset (&ip4, 0, sizeof (ip4));
18358 clib_memset (&ip6, 0, sizeof (ip6));
18360 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18362 if (unformat (i, "del"))
18364 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
18365 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18370 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
18371 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18376 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
18380 nh_sw_if_index = ~0;
18382 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
18386 nh_sw_if_index = ~0;
18388 else if (unformat (i, "table %d", &table_id))
18392 errmsg ("parse error '%U'", format_unformat_error, i);
18399 errmsg ("nh addr not set!");
18403 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
18404 mp->is_add = is_add;
18405 mp->table_id = clib_host_to_net_u32 (table_id);
18406 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
18407 mp->is_ip4 = is_ip4;
18409 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
18411 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
18416 /* Wait for a reply... */
18422 api_one_map_server_dump (vat_main_t * vam)
18424 vl_api_one_map_server_dump_t *mp;
18425 vl_api_control_ping_t *mp_ping;
18428 if (!vam->json_output)
18430 print (vam->ofp, "%=20s", "Map server");
18433 M (ONE_MAP_SERVER_DUMP, mp);
18437 /* Use a control ping for synchronization */
18438 MPING (CONTROL_PING, mp_ping);
18441 /* Wait for a reply... */
18446 #define api_lisp_map_server_dump api_one_map_server_dump
18449 api_one_map_resolver_dump (vat_main_t * vam)
18451 vl_api_one_map_resolver_dump_t *mp;
18452 vl_api_control_ping_t *mp_ping;
18455 if (!vam->json_output)
18457 print (vam->ofp, "%=20s", "Map resolver");
18460 M (ONE_MAP_RESOLVER_DUMP, mp);
18464 /* Use a control ping for synchronization */
18465 MPING (CONTROL_PING, mp_ping);
18468 /* Wait for a reply... */
18473 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
18476 api_one_stats_flush (vat_main_t * vam)
18478 vl_api_one_stats_flush_t *mp;
18481 M (ONE_STATS_FLUSH, mp);
18488 api_one_stats_dump (vat_main_t * vam)
18490 vl_api_one_stats_dump_t *mp;
18491 vl_api_control_ping_t *mp_ping;
18494 M (ONE_STATS_DUMP, mp);
18498 /* Use a control ping for synchronization */
18499 MPING (CONTROL_PING, mp_ping);
18502 /* Wait for a reply... */
18508 api_show_one_status (vat_main_t * vam)
18510 vl_api_show_one_status_t *mp;
18513 if (!vam->json_output)
18515 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
18518 M (SHOW_ONE_STATUS, mp);
18521 /* Wait for a reply... */
18526 #define api_show_lisp_status api_show_one_status
18529 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
18531 vl_api_gpe_fwd_entry_path_dump_t *mp;
18532 vl_api_control_ping_t *mp_ping;
18533 unformat_input_t *i = vam->input;
18534 u32 fwd_entry_index = ~0;
18537 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18539 if (unformat (i, "index %d", &fwd_entry_index))
18545 if (~0 == fwd_entry_index)
18547 errmsg ("no index specified!");
18551 if (!vam->json_output)
18553 print (vam->ofp, "first line");
18556 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
18560 /* Use a control ping for synchronization */
18561 MPING (CONTROL_PING, mp_ping);
18564 /* Wait for a reply... */
18570 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
18572 vl_api_one_get_map_request_itr_rlocs_t *mp;
18575 if (!vam->json_output)
18577 print (vam->ofp, "%=20s", "itr-rlocs:");
18580 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
18583 /* Wait for a reply... */
18588 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
18591 api_af_packet_create (vat_main_t * vam)
18593 unformat_input_t *i = vam->input;
18594 vl_api_af_packet_create_t *mp;
18595 u8 *host_if_name = 0;
18597 u8 random_hw_addr = 1;
18600 clib_memset (hw_addr, 0, sizeof (hw_addr));
18602 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18604 if (unformat (i, "name %s", &host_if_name))
18605 vec_add1 (host_if_name, 0);
18606 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
18607 random_hw_addr = 0;
18612 if (!vec_len (host_if_name))
18614 errmsg ("host-interface name must be specified");
18618 if (vec_len (host_if_name) > 64)
18620 errmsg ("host-interface name too long");
18624 M (AF_PACKET_CREATE, mp);
18626 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
18627 clib_memcpy (mp->hw_addr, hw_addr, 6);
18628 mp->use_random_hw_addr = random_hw_addr;
18629 vec_free (host_if_name);
18637 fprintf (vam->ofp ? vam->ofp : stderr,
18638 " new sw_if_index = %d\n", vam->sw_if_index);
18645 api_af_packet_delete (vat_main_t * vam)
18647 unformat_input_t *i = vam->input;
18648 vl_api_af_packet_delete_t *mp;
18649 u8 *host_if_name = 0;
18652 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18654 if (unformat (i, "name %s", &host_if_name))
18655 vec_add1 (host_if_name, 0);
18660 if (!vec_len (host_if_name))
18662 errmsg ("host-interface name must be specified");
18666 if (vec_len (host_if_name) > 64)
18668 errmsg ("host-interface name too long");
18672 M (AF_PACKET_DELETE, mp);
18674 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
18675 vec_free (host_if_name);
18682 static void vl_api_af_packet_details_t_handler
18683 (vl_api_af_packet_details_t * mp)
18685 vat_main_t *vam = &vat_main;
18687 print (vam->ofp, "%-16s %d",
18688 mp->host_if_name, clib_net_to_host_u32 (mp->sw_if_index));
18691 static void vl_api_af_packet_details_t_handler_json
18692 (vl_api_af_packet_details_t * mp)
18694 vat_main_t *vam = &vat_main;
18695 vat_json_node_t *node = NULL;
18697 if (VAT_JSON_ARRAY != vam->json_tree.type)
18699 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18700 vat_json_init_array (&vam->json_tree);
18702 node = vat_json_array_add (&vam->json_tree);
18704 vat_json_init_object (node);
18705 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
18706 vat_json_object_add_string_copy (node, "dev_name", mp->host_if_name);
18710 api_af_packet_dump (vat_main_t * vam)
18712 vl_api_af_packet_dump_t *mp;
18713 vl_api_control_ping_t *mp_ping;
18716 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
18717 /* Get list of tap interfaces */
18718 M (AF_PACKET_DUMP, mp);
18721 /* Use a control ping for synchronization */
18722 MPING (CONTROL_PING, mp_ping);
18730 api_policer_add_del (vat_main_t * vam)
18732 unformat_input_t *i = vam->input;
18733 vl_api_policer_add_del_t *mp;
18743 u8 color_aware = 0;
18744 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
18747 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
18748 conform_action.dscp = 0;
18749 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
18750 exceed_action.dscp = 0;
18751 violate_action.action_type = SSE2_QOS_ACTION_DROP;
18752 violate_action.dscp = 0;
18754 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18756 if (unformat (i, "del"))
18758 else if (unformat (i, "name %s", &name))
18759 vec_add1 (name, 0);
18760 else if (unformat (i, "cir %u", &cir))
18762 else if (unformat (i, "eir %u", &eir))
18764 else if (unformat (i, "cb %u", &cb))
18766 else if (unformat (i, "eb %u", &eb))
18768 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
18771 else if (unformat (i, "round_type %U", unformat_policer_round_type,
18774 else if (unformat (i, "type %U", unformat_policer_type, &type))
18776 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
18779 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
18782 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
18785 else if (unformat (i, "color-aware"))
18791 if (!vec_len (name))
18793 errmsg ("policer name must be specified");
18797 if (vec_len (name) > 64)
18799 errmsg ("policer name too long");
18803 M (POLICER_ADD_DEL, mp);
18805 clib_memcpy (mp->name, name, vec_len (name));
18807 mp->is_add = is_add;
18808 mp->cir = ntohl (cir);
18809 mp->eir = ntohl (eir);
18810 mp->cb = clib_net_to_host_u64 (cb);
18811 mp->eb = clib_net_to_host_u64 (eb);
18812 mp->rate_type = rate_type;
18813 mp->round_type = round_type;
18815 mp->conform_action_type = conform_action.action_type;
18816 mp->conform_dscp = conform_action.dscp;
18817 mp->exceed_action_type = exceed_action.action_type;
18818 mp->exceed_dscp = exceed_action.dscp;
18819 mp->violate_action_type = violate_action.action_type;
18820 mp->violate_dscp = violate_action.dscp;
18821 mp->color_aware = color_aware;
18829 api_policer_dump (vat_main_t * vam)
18831 unformat_input_t *i = vam->input;
18832 vl_api_policer_dump_t *mp;
18833 vl_api_control_ping_t *mp_ping;
18834 u8 *match_name = 0;
18835 u8 match_name_valid = 0;
18838 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18840 if (unformat (i, "name %s", &match_name))
18842 vec_add1 (match_name, 0);
18843 match_name_valid = 1;
18849 M (POLICER_DUMP, mp);
18850 mp->match_name_valid = match_name_valid;
18851 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
18852 vec_free (match_name);
18856 /* Use a control ping for synchronization */
18857 MPING (CONTROL_PING, mp_ping);
18860 /* Wait for a reply... */
18866 api_policer_classify_set_interface (vat_main_t * vam)
18868 unformat_input_t *i = vam->input;
18869 vl_api_policer_classify_set_interface_t *mp;
18871 int sw_if_index_set;
18872 u32 ip4_table_index = ~0;
18873 u32 ip6_table_index = ~0;
18874 u32 l2_table_index = ~0;
18878 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18880 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18881 sw_if_index_set = 1;
18882 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18883 sw_if_index_set = 1;
18884 else if (unformat (i, "del"))
18886 else if (unformat (i, "ip4-table %d", &ip4_table_index))
18888 else if (unformat (i, "ip6-table %d", &ip6_table_index))
18890 else if (unformat (i, "l2-table %d", &l2_table_index))
18894 clib_warning ("parse error '%U'", format_unformat_error, i);
18899 if (sw_if_index_set == 0)
18901 errmsg ("missing interface name or sw_if_index");
18905 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
18907 mp->sw_if_index = ntohl (sw_if_index);
18908 mp->ip4_table_index = ntohl (ip4_table_index);
18909 mp->ip6_table_index = ntohl (ip6_table_index);
18910 mp->l2_table_index = ntohl (l2_table_index);
18911 mp->is_add = is_add;
18919 api_policer_classify_dump (vat_main_t * vam)
18921 unformat_input_t *i = vam->input;
18922 vl_api_policer_classify_dump_t *mp;
18923 vl_api_control_ping_t *mp_ping;
18924 u8 type = POLICER_CLASSIFY_N_TABLES;
18927 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
18931 errmsg ("classify table type must be specified");
18935 if (!vam->json_output)
18937 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
18940 M (POLICER_CLASSIFY_DUMP, mp);
18945 /* Use a control ping for synchronization */
18946 MPING (CONTROL_PING, mp_ping);
18949 /* Wait for a reply... */
18955 api_netmap_create (vat_main_t * vam)
18957 unformat_input_t *i = vam->input;
18958 vl_api_netmap_create_t *mp;
18961 u8 random_hw_addr = 1;
18966 clib_memset (hw_addr, 0, sizeof (hw_addr));
18968 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18970 if (unformat (i, "name %s", &if_name))
18971 vec_add1 (if_name, 0);
18972 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
18973 random_hw_addr = 0;
18974 else if (unformat (i, "pipe"))
18976 else if (unformat (i, "master"))
18978 else if (unformat (i, "slave"))
18984 if (!vec_len (if_name))
18986 errmsg ("interface name must be specified");
18990 if (vec_len (if_name) > 64)
18992 errmsg ("interface name too long");
18996 M (NETMAP_CREATE, mp);
18998 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
18999 clib_memcpy (mp->hw_addr, hw_addr, 6);
19000 mp->use_random_hw_addr = random_hw_addr;
19001 mp->is_pipe = is_pipe;
19002 mp->is_master = is_master;
19003 vec_free (if_name);
19011 api_netmap_delete (vat_main_t * vam)
19013 unformat_input_t *i = vam->input;
19014 vl_api_netmap_delete_t *mp;
19018 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19020 if (unformat (i, "name %s", &if_name))
19021 vec_add1 (if_name, 0);
19026 if (!vec_len (if_name))
19028 errmsg ("interface name must be specified");
19032 if (vec_len (if_name) > 64)
19034 errmsg ("interface name too long");
19038 M (NETMAP_DELETE, mp);
19040 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
19041 vec_free (if_name);
19049 vl_api_mpls_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
19051 if (fp->afi == IP46_TYPE_IP6)
19053 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19054 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19055 fp->weight, ntohl (fp->sw_if_index), fp->is_local,
19056 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19057 format_ip6_address, fp->next_hop);
19058 else if (fp->afi == IP46_TYPE_IP4)
19060 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19061 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19062 fp->weight, ntohl (fp->sw_if_index), fp->is_local,
19063 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19064 format_ip4_address, fp->next_hop);
19068 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
19069 vl_api_fib_path_t * fp)
19071 struct in_addr ip4;
19072 struct in6_addr ip6;
19074 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19075 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19076 vat_json_object_add_uint (node, "is_local", fp->is_local);
19077 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19078 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19079 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19080 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19081 if (fp->afi == IP46_TYPE_IP4)
19083 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19084 vat_json_object_add_ip4 (node, "next_hop", ip4);
19086 else if (fp->afi == IP46_TYPE_IP6)
19088 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19089 vat_json_object_add_ip6 (node, "next_hop", ip6);
19094 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
19096 vat_main_t *vam = &vat_main;
19097 int count = ntohl (mp->mt_count);
19098 vl_api_fib_path_t *fp;
19101 print (vam->ofp, "[%d]: sw_if_index %d via:",
19102 ntohl (mp->mt_tunnel_index), ntohl (mp->mt_sw_if_index));
19104 for (i = 0; i < count; i++)
19106 vl_api_mpls_fib_path_print (vam, fp);
19110 print (vam->ofp, "");
19113 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
19114 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
19117 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
19119 vat_main_t *vam = &vat_main;
19120 vat_json_node_t *node = NULL;
19121 int count = ntohl (mp->mt_count);
19122 vl_api_fib_path_t *fp;
19125 if (VAT_JSON_ARRAY != vam->json_tree.type)
19127 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19128 vat_json_init_array (&vam->json_tree);
19130 node = vat_json_array_add (&vam->json_tree);
19132 vat_json_init_object (node);
19133 vat_json_object_add_uint (node, "tunnel_index",
19134 ntohl (mp->mt_tunnel_index));
19135 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->mt_sw_if_index));
19137 vat_json_object_add_uint (node, "l2_only", mp->mt_l2_only);
19140 for (i = 0; i < count; i++)
19142 vl_api_mpls_fib_path_json_print (node, fp);
19148 api_mpls_tunnel_dump (vat_main_t * vam)
19150 vl_api_mpls_tunnel_dump_t *mp;
19151 vl_api_control_ping_t *mp_ping;
19152 u32 sw_if_index = ~0;
19155 /* Parse args required to build the message */
19156 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
19158 if (unformat (vam->input, "sw_if_index %d", &sw_if_index))
19162 print (vam->ofp, " sw_if_index %d", sw_if_index);
19164 M (MPLS_TUNNEL_DUMP, mp);
19165 mp->sw_if_index = htonl (sw_if_index);
19168 /* Use a control ping for synchronization */
19169 MPING (CONTROL_PING, mp_ping);
19176 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
19177 #define vl_api_mpls_fib_details_t_print vl_noop_handler
19181 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
19183 vat_main_t *vam = &vat_main;
19184 int count = ntohl (mp->count);
19185 vl_api_fib_path_t *fp;
19189 "table-id %d, label %u, ess_bit %u",
19190 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
19192 for (i = 0; i < count; i++)
19194 vl_api_mpls_fib_path_print (vam, fp);
19199 static void vl_api_mpls_fib_details_t_handler_json
19200 (vl_api_mpls_fib_details_t * mp)
19202 vat_main_t *vam = &vat_main;
19203 int count = ntohl (mp->count);
19204 vat_json_node_t *node = NULL;
19205 vl_api_fib_path_t *fp;
19208 if (VAT_JSON_ARRAY != vam->json_tree.type)
19210 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19211 vat_json_init_array (&vam->json_tree);
19213 node = vat_json_array_add (&vam->json_tree);
19215 vat_json_init_object (node);
19216 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19217 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
19218 vat_json_object_add_uint (node, "label", ntohl (mp->label));
19219 vat_json_object_add_uint (node, "path_count", count);
19221 for (i = 0; i < count; i++)
19223 vl_api_mpls_fib_path_json_print (node, fp);
19229 api_mpls_fib_dump (vat_main_t * vam)
19231 vl_api_mpls_fib_dump_t *mp;
19232 vl_api_control_ping_t *mp_ping;
19235 M (MPLS_FIB_DUMP, mp);
19238 /* Use a control ping for synchronization */
19239 MPING (CONTROL_PING, mp_ping);
19246 #define vl_api_ip_fib_details_t_endian vl_noop_handler
19247 #define vl_api_ip_fib_details_t_print vl_noop_handler
19250 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
19252 vat_main_t *vam = &vat_main;
19253 int count = ntohl (mp->count);
19254 vl_api_fib_path_t *fp;
19258 "table-id %d, prefix %U/%d stats-index %d",
19259 ntohl (mp->table_id), format_ip4_address, mp->address,
19260 mp->address_length, ntohl (mp->stats_index));
19262 for (i = 0; i < count; i++)
19264 if (fp->afi == IP46_TYPE_IP6)
19266 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19267 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U, "
19268 "next_hop_table %d",
19269 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19270 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19271 format_ip6_address, fp->next_hop, ntohl (fp->table_id));
19272 else if (fp->afi == IP46_TYPE_IP4)
19274 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19275 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U, "
19276 "next_hop_table %d",
19277 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19278 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19279 format_ip4_address, fp->next_hop, ntohl (fp->table_id));
19284 static void vl_api_ip_fib_details_t_handler_json
19285 (vl_api_ip_fib_details_t * mp)
19287 vat_main_t *vam = &vat_main;
19288 int count = ntohl (mp->count);
19289 vat_json_node_t *node = NULL;
19290 struct in_addr ip4;
19291 struct in6_addr ip6;
19292 vl_api_fib_path_t *fp;
19295 if (VAT_JSON_ARRAY != vam->json_tree.type)
19297 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19298 vat_json_init_array (&vam->json_tree);
19300 node = vat_json_array_add (&vam->json_tree);
19302 vat_json_init_object (node);
19303 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19304 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
19305 vat_json_object_add_ip4 (node, "prefix", ip4);
19306 vat_json_object_add_uint (node, "mask_length", mp->address_length);
19307 vat_json_object_add_uint (node, "path_count", count);
19309 for (i = 0; i < count; i++)
19311 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19312 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19313 vat_json_object_add_uint (node, "is_local", fp->is_local);
19314 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19315 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19316 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19317 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19318 if (fp->afi == IP46_TYPE_IP4)
19320 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19321 vat_json_object_add_ip4 (node, "next_hop", ip4);
19323 else if (fp->afi == IP46_TYPE_IP6)
19325 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19326 vat_json_object_add_ip6 (node, "next_hop", ip6);
19332 api_ip_fib_dump (vat_main_t * vam)
19334 vl_api_ip_fib_dump_t *mp;
19335 vl_api_control_ping_t *mp_ping;
19338 M (IP_FIB_DUMP, mp);
19341 /* Use a control ping for synchronization */
19342 MPING (CONTROL_PING, mp_ping);
19350 api_ip_mfib_dump (vat_main_t * vam)
19352 vl_api_ip_mfib_dump_t *mp;
19353 vl_api_control_ping_t *mp_ping;
19356 M (IP_MFIB_DUMP, mp);
19359 /* Use a control ping for synchronization */
19360 MPING (CONTROL_PING, mp_ping);
19367 static void vl_api_ip_neighbor_details_t_handler
19368 (vl_api_ip_neighbor_details_t * mp)
19370 vat_main_t *vam = &vat_main;
19372 print (vam->ofp, "%c %U %U",
19373 (ntohl (mp->neighbor.flags) & IP_NEIGHBOR_FLAG_STATIC) ? 'S' : 'D',
19374 format_vl_api_mac_address, &mp->neighbor.mac_address,
19375 format_vl_api_address, &mp->neighbor.ip_address);
19378 static void vl_api_ip_neighbor_details_t_handler_json
19379 (vl_api_ip_neighbor_details_t * mp)
19382 vat_main_t *vam = &vat_main;
19383 vat_json_node_t *node;
19385 if (VAT_JSON_ARRAY != vam->json_tree.type)
19387 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19388 vat_json_init_array (&vam->json_tree);
19390 node = vat_json_array_add (&vam->json_tree);
19392 vat_json_init_object (node);
19393 vat_json_object_add_string_copy
19395 ((ntohl (mp->neighbor.flags) & IP_NEIGHBOR_FLAG_STATIC) ?
19396 (u8 *) "static" : (u8 *) "dynamic"));
19398 vat_json_object_add_string_copy (node, "link_layer",
19399 format (0, "%U", format_vl_api_mac_address,
19400 &mp->neighbor.mac_address));
19401 vat_json_object_add_address (node, "ip", &mp->neighbor.ip_address);
19405 api_ip_neighbor_dump (vat_main_t * vam)
19407 unformat_input_t *i = vam->input;
19408 vl_api_ip_neighbor_dump_t *mp;
19409 vl_api_control_ping_t *mp_ping;
19411 u32 sw_if_index = ~0;
19414 /* Parse args required to build the message */
19415 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19417 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19419 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19421 else if (unformat (i, "ip6"))
19427 if (sw_if_index == ~0)
19429 errmsg ("missing interface name or sw_if_index");
19433 M (IP_NEIGHBOR_DUMP, mp);
19434 mp->is_ipv6 = (u8) is_ipv6;
19435 mp->sw_if_index = ntohl (sw_if_index);
19438 /* Use a control ping for synchronization */
19439 MPING (CONTROL_PING, mp_ping);
19446 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
19447 #define vl_api_ip6_fib_details_t_print vl_noop_handler
19450 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
19452 vat_main_t *vam = &vat_main;
19453 int count = ntohl (mp->count);
19454 vl_api_fib_path_t *fp;
19458 "table-id %d, prefix %U/%d stats-index %d",
19459 ntohl (mp->table_id), format_ip6_address, mp->address,
19460 mp->address_length, ntohl (mp->stats_index));
19462 for (i = 0; i < count; i++)
19464 if (fp->afi == IP46_TYPE_IP6)
19466 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19467 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19468 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19469 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19470 format_ip6_address, fp->next_hop);
19471 else if (fp->afi == IP46_TYPE_IP4)
19473 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19474 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19475 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19476 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19477 format_ip4_address, fp->next_hop);
19482 static void vl_api_ip6_fib_details_t_handler_json
19483 (vl_api_ip6_fib_details_t * mp)
19485 vat_main_t *vam = &vat_main;
19486 int count = ntohl (mp->count);
19487 vat_json_node_t *node = NULL;
19488 struct in_addr ip4;
19489 struct in6_addr ip6;
19490 vl_api_fib_path_t *fp;
19493 if (VAT_JSON_ARRAY != vam->json_tree.type)
19495 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19496 vat_json_init_array (&vam->json_tree);
19498 node = vat_json_array_add (&vam->json_tree);
19500 vat_json_init_object (node);
19501 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19502 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
19503 vat_json_object_add_ip6 (node, "prefix", ip6);
19504 vat_json_object_add_uint (node, "mask_length", mp->address_length);
19505 vat_json_object_add_uint (node, "path_count", count);
19507 for (i = 0; i < count; i++)
19509 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19510 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19511 vat_json_object_add_uint (node, "is_local", fp->is_local);
19512 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19513 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19514 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19515 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19516 if (fp->afi == IP46_TYPE_IP4)
19518 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19519 vat_json_object_add_ip4 (node, "next_hop", ip4);
19521 else if (fp->afi == IP46_TYPE_IP6)
19523 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19524 vat_json_object_add_ip6 (node, "next_hop", ip6);
19530 api_ip6_fib_dump (vat_main_t * vam)
19532 vl_api_ip6_fib_dump_t *mp;
19533 vl_api_control_ping_t *mp_ping;
19536 M (IP6_FIB_DUMP, mp);
19539 /* Use a control ping for synchronization */
19540 MPING (CONTROL_PING, mp_ping);
19548 api_ip6_mfib_dump (vat_main_t * vam)
19550 vl_api_ip6_mfib_dump_t *mp;
19551 vl_api_control_ping_t *mp_ping;
19554 M (IP6_MFIB_DUMP, mp);
19557 /* Use a control ping for synchronization */
19558 MPING (CONTROL_PING, mp_ping);
19566 api_classify_table_ids (vat_main_t * vam)
19568 vl_api_classify_table_ids_t *mp;
19571 /* Construct the API message */
19572 M (CLASSIFY_TABLE_IDS, mp);
19581 api_classify_table_by_interface (vat_main_t * vam)
19583 unformat_input_t *input = vam->input;
19584 vl_api_classify_table_by_interface_t *mp;
19586 u32 sw_if_index = ~0;
19588 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19590 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19592 else if (unformat (input, "sw_if_index %d", &sw_if_index))
19597 if (sw_if_index == ~0)
19599 errmsg ("missing interface name or sw_if_index");
19603 /* Construct the API message */
19604 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
19606 mp->sw_if_index = ntohl (sw_if_index);
19614 api_classify_table_info (vat_main_t * vam)
19616 unformat_input_t *input = vam->input;
19617 vl_api_classify_table_info_t *mp;
19621 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19623 if (unformat (input, "table_id %d", &table_id))
19628 if (table_id == ~0)
19630 errmsg ("missing table id");
19634 /* Construct the API message */
19635 M (CLASSIFY_TABLE_INFO, mp);
19637 mp->table_id = ntohl (table_id);
19645 api_classify_session_dump (vat_main_t * vam)
19647 unformat_input_t *input = vam->input;
19648 vl_api_classify_session_dump_t *mp;
19649 vl_api_control_ping_t *mp_ping;
19653 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19655 if (unformat (input, "table_id %d", &table_id))
19660 if (table_id == ~0)
19662 errmsg ("missing table id");
19666 /* Construct the API message */
19667 M (CLASSIFY_SESSION_DUMP, mp);
19669 mp->table_id = ntohl (table_id);
19672 /* Use a control ping for synchronization */
19673 MPING (CONTROL_PING, mp_ping);
19681 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
19683 vat_main_t *vam = &vat_main;
19685 print (vam->ofp, "collector_address %U, collector_port %d, "
19686 "src_address %U, vrf_id %d, path_mtu %u, "
19687 "template_interval %u, udp_checksum %d",
19688 format_ip4_address, mp->collector_address,
19689 ntohs (mp->collector_port),
19690 format_ip4_address, mp->src_address,
19691 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
19692 ntohl (mp->template_interval), mp->udp_checksum);
19695 vam->result_ready = 1;
19699 vl_api_ipfix_exporter_details_t_handler_json
19700 (vl_api_ipfix_exporter_details_t * mp)
19702 vat_main_t *vam = &vat_main;
19703 vat_json_node_t node;
19704 struct in_addr collector_address;
19705 struct in_addr src_address;
19707 vat_json_init_object (&node);
19708 clib_memcpy (&collector_address, &mp->collector_address,
19709 sizeof (collector_address));
19710 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
19711 vat_json_object_add_uint (&node, "collector_port",
19712 ntohs (mp->collector_port));
19713 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
19714 vat_json_object_add_ip4 (&node, "src_address", src_address);
19715 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
19716 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
19717 vat_json_object_add_uint (&node, "template_interval",
19718 ntohl (mp->template_interval));
19719 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
19721 vat_json_print (vam->ofp, &node);
19722 vat_json_free (&node);
19724 vam->result_ready = 1;
19728 api_ipfix_exporter_dump (vat_main_t * vam)
19730 vl_api_ipfix_exporter_dump_t *mp;
19733 /* Construct the API message */
19734 M (IPFIX_EXPORTER_DUMP, mp);
19743 api_ipfix_classify_stream_dump (vat_main_t * vam)
19745 vl_api_ipfix_classify_stream_dump_t *mp;
19748 /* Construct the API message */
19749 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
19760 vl_api_ipfix_classify_stream_details_t_handler
19761 (vl_api_ipfix_classify_stream_details_t * mp)
19763 vat_main_t *vam = &vat_main;
19764 print (vam->ofp, "domain_id %d, src_port %d",
19765 ntohl (mp->domain_id), ntohs (mp->src_port));
19767 vam->result_ready = 1;
19771 vl_api_ipfix_classify_stream_details_t_handler_json
19772 (vl_api_ipfix_classify_stream_details_t * mp)
19774 vat_main_t *vam = &vat_main;
19775 vat_json_node_t node;
19777 vat_json_init_object (&node);
19778 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
19779 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
19781 vat_json_print (vam->ofp, &node);
19782 vat_json_free (&node);
19784 vam->result_ready = 1;
19788 api_ipfix_classify_table_dump (vat_main_t * vam)
19790 vl_api_ipfix_classify_table_dump_t *mp;
19791 vl_api_control_ping_t *mp_ping;
19794 if (!vam->json_output)
19796 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
19797 "transport_protocol");
19800 /* Construct the API message */
19801 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
19806 /* Use a control ping for synchronization */
19807 MPING (CONTROL_PING, mp_ping);
19815 vl_api_ipfix_classify_table_details_t_handler
19816 (vl_api_ipfix_classify_table_details_t * mp)
19818 vat_main_t *vam = &vat_main;
19819 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
19820 mp->transport_protocol);
19824 vl_api_ipfix_classify_table_details_t_handler_json
19825 (vl_api_ipfix_classify_table_details_t * mp)
19827 vat_json_node_t *node = NULL;
19828 vat_main_t *vam = &vat_main;
19830 if (VAT_JSON_ARRAY != vam->json_tree.type)
19832 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19833 vat_json_init_array (&vam->json_tree);
19836 node = vat_json_array_add (&vam->json_tree);
19837 vat_json_init_object (node);
19839 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
19840 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
19841 vat_json_object_add_uint (node, "transport_protocol",
19842 mp->transport_protocol);
19846 api_sw_interface_span_enable_disable (vat_main_t * vam)
19848 unformat_input_t *i = vam->input;
19849 vl_api_sw_interface_span_enable_disable_t *mp;
19850 u32 src_sw_if_index = ~0;
19851 u32 dst_sw_if_index = ~0;
19856 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19859 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
19861 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
19865 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
19867 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
19869 else if (unformat (i, "disable"))
19871 else if (unformat (i, "rx"))
19873 else if (unformat (i, "tx"))
19875 else if (unformat (i, "both"))
19877 else if (unformat (i, "l2"))
19883 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
19885 mp->sw_if_index_from = htonl (src_sw_if_index);
19886 mp->sw_if_index_to = htonl (dst_sw_if_index);
19896 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
19899 vat_main_t *vam = &vat_main;
19900 u8 *sw_if_from_name = 0;
19901 u8 *sw_if_to_name = 0;
19902 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
19903 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
19904 char *states[] = { "none", "rx", "tx", "both" };
19908 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
19910 if ((u32) p->value[0] == sw_if_index_from)
19912 sw_if_from_name = (u8 *)(p->key);
19916 if ((u32) p->value[0] == sw_if_index_to)
19918 sw_if_to_name = (u8 *)(p->key);
19919 if (sw_if_from_name)
19924 print (vam->ofp, "%20s => %20s (%s) %s",
19925 sw_if_from_name, sw_if_to_name, states[mp->state],
19926 mp->is_l2 ? "l2" : "device");
19930 vl_api_sw_interface_span_details_t_handler_json
19931 (vl_api_sw_interface_span_details_t * mp)
19933 vat_main_t *vam = &vat_main;
19934 vat_json_node_t *node = NULL;
19935 u8 *sw_if_from_name = 0;
19936 u8 *sw_if_to_name = 0;
19937 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
19938 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
19942 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
19944 if ((u32) p->value[0] == sw_if_index_from)
19946 sw_if_from_name = (u8 *)(p->key);
19950 if ((u32) p->value[0] == sw_if_index_to)
19952 sw_if_to_name = (u8 *)(p->key);
19953 if (sw_if_from_name)
19959 if (VAT_JSON_ARRAY != vam->json_tree.type)
19961 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19962 vat_json_init_array (&vam->json_tree);
19964 node = vat_json_array_add (&vam->json_tree);
19966 vat_json_init_object (node);
19967 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
19968 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
19969 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
19970 if (0 != sw_if_to_name)
19972 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
19974 vat_json_object_add_uint (node, "state", mp->state);
19975 vat_json_object_add_uint (node, "is-l2", mp->is_l2);
19979 api_sw_interface_span_dump (vat_main_t * vam)
19981 unformat_input_t *input = vam->input;
19982 vl_api_sw_interface_span_dump_t *mp;
19983 vl_api_control_ping_t *mp_ping;
19987 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19989 if (unformat (input, "l2"))
19995 M (SW_INTERFACE_SPAN_DUMP, mp);
19999 /* Use a control ping for synchronization */
20000 MPING (CONTROL_PING, mp_ping);
20008 api_pg_create_interface (vat_main_t * vam)
20010 unformat_input_t *input = vam->input;
20011 vl_api_pg_create_interface_t *mp;
20015 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20017 if (unformat (input, "if_id %d", &if_id))
20024 errmsg ("missing pg interface index");
20028 /* Construct the API message */
20029 M (PG_CREATE_INTERFACE, mp);
20031 mp->interface_id = ntohl (if_id);
20039 api_pg_capture (vat_main_t * vam)
20041 unformat_input_t *input = vam->input;
20042 vl_api_pg_capture_t *mp;
20047 u8 pcap_file_set = 0;
20050 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20052 if (unformat (input, "if_id %d", &if_id))
20054 else if (unformat (input, "pcap %s", &pcap_file))
20056 else if (unformat (input, "count %d", &count))
20058 else if (unformat (input, "disable"))
20065 errmsg ("missing pg interface index");
20068 if (pcap_file_set > 0)
20070 if (vec_len (pcap_file) > 255)
20072 errmsg ("pcap file name is too long");
20077 u32 name_len = vec_len (pcap_file);
20078 /* Construct the API message */
20079 M (PG_CAPTURE, mp);
20081 mp->interface_id = ntohl (if_id);
20082 mp->is_enabled = enable;
20083 mp->count = ntohl (count);
20084 mp->pcap_name_length = ntohl (name_len);
20085 if (pcap_file_set != 0)
20087 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
20089 vec_free (pcap_file);
20097 api_pg_enable_disable (vat_main_t * vam)
20099 unformat_input_t *input = vam->input;
20100 vl_api_pg_enable_disable_t *mp;
20103 u8 stream_name_set = 0;
20104 u8 *stream_name = 0;
20106 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20108 if (unformat (input, "stream %s", &stream_name))
20109 stream_name_set = 1;
20110 else if (unformat (input, "disable"))
20116 if (stream_name_set > 0)
20118 if (vec_len (stream_name) > 255)
20120 errmsg ("stream name too long");
20125 u32 name_len = vec_len (stream_name);
20126 /* Construct the API message */
20127 M (PG_ENABLE_DISABLE, mp);
20129 mp->is_enabled = enable;
20130 if (stream_name_set != 0)
20132 mp->stream_name_length = ntohl (name_len);
20133 clib_memcpy (mp->stream_name, stream_name, name_len);
20135 vec_free (stream_name);
20143 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
20145 unformat_input_t *input = vam->input;
20146 vl_api_ip_source_and_port_range_check_add_del_t *mp;
20148 u16 *low_ports = 0;
20149 u16 *high_ports = 0;
20152 vl_api_prefix_t prefix;
20160 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20162 if (unformat (input, "%U", unformat_vl_api_prefix, &prefix))
20164 else if (unformat (input, "vrf %d", &vrf_id))
20166 else if (unformat (input, "del"))
20168 else if (unformat (input, "port %d", &tmp))
20170 if (tmp == 0 || tmp > 65535)
20172 errmsg ("port %d out of range", tmp);
20176 this_hi = this_low + 1;
20177 vec_add1 (low_ports, this_low);
20178 vec_add1 (high_ports, this_hi);
20180 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
20182 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
20184 errmsg ("incorrect range parameters");
20188 /* Note: in debug CLI +1 is added to high before
20189 passing to real fn that does "the work"
20190 (ip_source_and_port_range_check_add_del).
20191 This fn is a wrapper around the binary API fn a
20192 control plane will call, which expects this increment
20193 to have occurred. Hence letting the binary API control
20194 plane fn do the increment for consistency between VAT
20195 and other control planes.
20198 vec_add1 (low_ports, this_low);
20199 vec_add1 (high_ports, this_hi);
20205 if (prefix_set == 0)
20207 errmsg ("<address>/<mask> not specified");
20213 errmsg ("VRF ID required, not specified");
20220 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
20224 if (vec_len (low_ports) == 0)
20226 errmsg ("At least one port or port range required");
20230 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
20232 mp->is_add = is_add;
20234 clib_memcpy (&mp->prefix, &prefix, sizeof (prefix));
20236 mp->number_of_ranges = vec_len (low_ports);
20238 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
20239 vec_free (low_ports);
20241 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
20242 vec_free (high_ports);
20244 mp->vrf_id = ntohl (vrf_id);
20252 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
20254 unformat_input_t *input = vam->input;
20255 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
20256 u32 sw_if_index = ~0;
20258 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
20259 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
20263 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20265 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20267 else if (unformat (input, "sw_if_index %d", &sw_if_index))
20269 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
20271 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
20273 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
20275 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
20277 else if (unformat (input, "del"))
20283 if (sw_if_index == ~0)
20285 errmsg ("Interface required but not specified");
20291 errmsg ("VRF ID required but not specified");
20295 if (tcp_out_vrf_id == 0
20296 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
20299 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
20303 /* Construct the API message */
20304 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
20306 mp->sw_if_index = ntohl (sw_if_index);
20307 mp->is_add = is_add;
20308 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
20309 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
20310 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
20311 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
20316 /* Wait for a reply... */
20322 api_ipsec_gre_tunnel_add_del (vat_main_t * vam)
20324 unformat_input_t *i = vam->input;
20325 vl_api_ipsec_gre_tunnel_add_del_t *mp;
20326 u32 local_sa_id = 0;
20327 u32 remote_sa_id = 0;
20328 vl_api_ip4_address_t src_address;
20329 vl_api_ip4_address_t dst_address;
20333 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20335 if (unformat (i, "local_sa %d", &local_sa_id))
20337 else if (unformat (i, "remote_sa %d", &remote_sa_id))
20340 if (unformat (i, "src %U", unformat_vl_api_ip4_address, &src_address))
20343 if (unformat (i, "dst %U", unformat_vl_api_ip4_address, &dst_address))
20345 else if (unformat (i, "del"))
20349 clib_warning ("parse error '%U'", format_unformat_error, i);
20354 M (IPSEC_GRE_TUNNEL_ADD_DEL, mp);
20356 mp->tunnel.local_sa_id = ntohl (local_sa_id);
20357 mp->tunnel.remote_sa_id = ntohl (remote_sa_id);
20358 clib_memcpy (mp->tunnel.src, &src_address, sizeof (src_address));
20359 clib_memcpy (mp->tunnel.dst, &dst_address, sizeof (dst_address));
20360 mp->is_add = is_add;
20368 api_set_punt (vat_main_t * vam)
20370 unformat_input_t *i = vam->input;
20371 vl_api_address_family_t af;
20372 vl_api_set_punt_t *mp;
20380 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20382 if (unformat (i, "%U", unformat_vl_api_address_family, &af))
20384 else if (unformat (i, "protocol %d", &protocol))
20386 else if (unformat (i, "port %d", &port))
20388 else if (unformat (i, "del"))
20392 clib_warning ("parse error '%U'", format_unformat_error, i);
20399 mp->is_add = (u8) is_add;
20400 mp->punt.type = PUNT_API_TYPE_L4;
20401 mp->punt.punt.l4.af = af;
20402 mp->punt.punt.l4.protocol = (u8) protocol;
20403 mp->punt.punt.l4.port = htons ((u16) port);
20410 static void vl_api_ipsec_gre_tunnel_details_t_handler
20411 (vl_api_ipsec_gre_tunnel_details_t * mp)
20413 vat_main_t *vam = &vat_main;
20415 print (vam->ofp, "%11d%15U%15U%14d%14d",
20416 ntohl (mp->tunnel.sw_if_index),
20417 format_vl_api_ip4_address, mp->tunnel.src,
20418 format_vl_api_ip4_address, mp->tunnel.dst,
20419 ntohl (mp->tunnel.local_sa_id), ntohl (mp->tunnel.remote_sa_id));
20423 vat_json_object_add_vl_api_ip4 (vat_json_node_t * node,
20425 const vl_api_ip4_address_t addr)
20427 struct in_addr ip4;
20429 clib_memcpy (&ip4, addr, sizeof (ip4));
20430 vat_json_object_add_ip4 (node, name, ip4);
20433 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
20434 (vl_api_ipsec_gre_tunnel_details_t * mp)
20436 vat_main_t *vam = &vat_main;
20437 vat_json_node_t *node = NULL;
20438 struct in_addr ip4;
20440 if (VAT_JSON_ARRAY != vam->json_tree.type)
20442 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20443 vat_json_init_array (&vam->json_tree);
20445 node = vat_json_array_add (&vam->json_tree);
20447 vat_json_init_object (node);
20448 vat_json_object_add_uint (node, "sw_if_index",
20449 ntohl (mp->tunnel.sw_if_index));
20450 vat_json_object_add_vl_api_ip4 (node, "src", mp->tunnel.src);
20451 vat_json_object_add_vl_api_ip4 (node, "src", mp->tunnel.dst);
20452 vat_json_object_add_uint (node, "local_sa_id",
20453 ntohl (mp->tunnel.local_sa_id));
20454 vat_json_object_add_uint (node, "remote_sa_id",
20455 ntohl (mp->tunnel.remote_sa_id));
20459 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
20461 unformat_input_t *i = vam->input;
20462 vl_api_ipsec_gre_tunnel_dump_t *mp;
20463 vl_api_control_ping_t *mp_ping;
20465 u8 sw_if_index_set = 0;
20468 /* Parse args required to build the message */
20469 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20471 if (unformat (i, "sw_if_index %d", &sw_if_index))
20472 sw_if_index_set = 1;
20477 if (sw_if_index_set == 0)
20482 if (!vam->json_output)
20484 print (vam->ofp, "%11s%15s%15s%14s%14s",
20485 "sw_if_index", "src_address", "dst_address",
20486 "local_sa_id", "remote_sa_id");
20489 /* Get list of gre-tunnel interfaces */
20490 M (IPSEC_GRE_TUNNEL_DUMP, mp);
20492 mp->sw_if_index = htonl (sw_if_index);
20496 /* Use a control ping for synchronization */
20497 MPING (CONTROL_PING, mp_ping);
20505 api_delete_subif (vat_main_t * vam)
20507 unformat_input_t *i = vam->input;
20508 vl_api_delete_subif_t *mp;
20509 u32 sw_if_index = ~0;
20512 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20514 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20516 if (unformat (i, "sw_if_index %d", &sw_if_index))
20522 if (sw_if_index == ~0)
20524 errmsg ("missing sw_if_index");
20528 /* Construct the API message */
20529 M (DELETE_SUBIF, mp);
20530 mp->sw_if_index = ntohl (sw_if_index);
20537 #define foreach_pbb_vtr_op \
20538 _("disable", L2_VTR_DISABLED) \
20539 _("pop", L2_VTR_POP_2) \
20540 _("push", L2_VTR_PUSH_2)
20543 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
20545 unformat_input_t *i = vam->input;
20546 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
20547 u32 sw_if_index = ~0, vtr_op = ~0;
20548 u16 outer_tag = ~0;
20549 u8 dmac[6], smac[6];
20550 u8 dmac_set = 0, smac_set = 0;
20556 /* Shut up coverity */
20557 clib_memset (dmac, 0, sizeof (dmac));
20558 clib_memset (smac, 0, sizeof (smac));
20560 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20562 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20564 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20566 else if (unformat (i, "vtr_op %d", &vtr_op))
20568 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
20571 else if (unformat (i, "translate_pbb_stag"))
20573 if (unformat (i, "%d", &tmp))
20575 vtr_op = L2_VTR_TRANSLATE_2_1;
20581 ("translate_pbb_stag operation requires outer tag definition");
20585 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
20587 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
20589 else if (unformat (i, "sid %d", &sid))
20591 else if (unformat (i, "vlanid %d", &tmp))
20595 clib_warning ("parse error '%U'", format_unformat_error, i);
20600 if ((sw_if_index == ~0) || (vtr_op == ~0))
20602 errmsg ("missing sw_if_index or vtr operation");
20605 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
20606 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
20609 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
20613 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
20614 mp->sw_if_index = ntohl (sw_if_index);
20615 mp->vtr_op = ntohl (vtr_op);
20616 mp->outer_tag = ntohs (outer_tag);
20617 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
20618 clib_memcpy (mp->b_smac, smac, sizeof (smac));
20619 mp->b_vlanid = ntohs (vlanid);
20620 mp->i_sid = ntohl (sid);
20628 api_flow_classify_set_interface (vat_main_t * vam)
20630 unformat_input_t *i = vam->input;
20631 vl_api_flow_classify_set_interface_t *mp;
20633 int sw_if_index_set;
20634 u32 ip4_table_index = ~0;
20635 u32 ip6_table_index = ~0;
20639 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20641 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20642 sw_if_index_set = 1;
20643 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20644 sw_if_index_set = 1;
20645 else if (unformat (i, "del"))
20647 else if (unformat (i, "ip4-table %d", &ip4_table_index))
20649 else if (unformat (i, "ip6-table %d", &ip6_table_index))
20653 clib_warning ("parse error '%U'", format_unformat_error, i);
20658 if (sw_if_index_set == 0)
20660 errmsg ("missing interface name or sw_if_index");
20664 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
20666 mp->sw_if_index = ntohl (sw_if_index);
20667 mp->ip4_table_index = ntohl (ip4_table_index);
20668 mp->ip6_table_index = ntohl (ip6_table_index);
20669 mp->is_add = is_add;
20677 api_flow_classify_dump (vat_main_t * vam)
20679 unformat_input_t *i = vam->input;
20680 vl_api_flow_classify_dump_t *mp;
20681 vl_api_control_ping_t *mp_ping;
20682 u8 type = FLOW_CLASSIFY_N_TABLES;
20685 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
20689 errmsg ("classify table type must be specified");
20693 if (!vam->json_output)
20695 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
20698 M (FLOW_CLASSIFY_DUMP, mp);
20703 /* Use a control ping for synchronization */
20704 MPING (CONTROL_PING, mp_ping);
20707 /* Wait for a reply... */
20713 api_feature_enable_disable (vat_main_t * vam)
20715 unformat_input_t *i = vam->input;
20716 vl_api_feature_enable_disable_t *mp;
20718 u8 *feature_name = 0;
20719 u32 sw_if_index = ~0;
20723 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20725 if (unformat (i, "arc_name %s", &arc_name))
20727 else if (unformat (i, "feature_name %s", &feature_name))
20730 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20732 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20734 else if (unformat (i, "disable"))
20742 errmsg ("missing arc name");
20745 if (vec_len (arc_name) > 63)
20747 errmsg ("arc name too long");
20750 if (feature_name == 0)
20752 errmsg ("missing feature name");
20755 if (vec_len (feature_name) > 63)
20757 errmsg ("feature name too long");
20760 if (sw_if_index == ~0)
20762 errmsg ("missing interface name or sw_if_index");
20766 /* Construct the API message */
20767 M (FEATURE_ENABLE_DISABLE, mp);
20768 mp->sw_if_index = ntohl (sw_if_index);
20769 mp->enable = enable;
20770 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
20771 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
20772 vec_free (arc_name);
20773 vec_free (feature_name);
20781 api_sw_interface_tag_add_del (vat_main_t * vam)
20783 unformat_input_t *i = vam->input;
20784 vl_api_sw_interface_tag_add_del_t *mp;
20785 u32 sw_if_index = ~0;
20790 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20792 if (unformat (i, "tag %s", &tag))
20794 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20796 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20798 else if (unformat (i, "del"))
20804 if (sw_if_index == ~0)
20806 errmsg ("missing interface name or sw_if_index");
20810 if (enable && (tag == 0))
20812 errmsg ("no tag specified");
20816 /* Construct the API message */
20817 M (SW_INTERFACE_TAG_ADD_DEL, mp);
20818 mp->sw_if_index = ntohl (sw_if_index);
20819 mp->is_add = enable;
20821 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
20829 static void vl_api_l2_xconnect_details_t_handler
20830 (vl_api_l2_xconnect_details_t * mp)
20832 vat_main_t *vam = &vat_main;
20834 print (vam->ofp, "%15d%15d",
20835 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
20838 static void vl_api_l2_xconnect_details_t_handler_json
20839 (vl_api_l2_xconnect_details_t * mp)
20841 vat_main_t *vam = &vat_main;
20842 vat_json_node_t *node = NULL;
20844 if (VAT_JSON_ARRAY != vam->json_tree.type)
20846 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20847 vat_json_init_array (&vam->json_tree);
20849 node = vat_json_array_add (&vam->json_tree);
20851 vat_json_init_object (node);
20852 vat_json_object_add_uint (node, "rx_sw_if_index",
20853 ntohl (mp->rx_sw_if_index));
20854 vat_json_object_add_uint (node, "tx_sw_if_index",
20855 ntohl (mp->tx_sw_if_index));
20859 api_l2_xconnect_dump (vat_main_t * vam)
20861 vl_api_l2_xconnect_dump_t *mp;
20862 vl_api_control_ping_t *mp_ping;
20865 if (!vam->json_output)
20867 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
20870 M (L2_XCONNECT_DUMP, mp);
20874 /* Use a control ping for synchronization */
20875 MPING (CONTROL_PING, mp_ping);
20883 api_hw_interface_set_mtu (vat_main_t * vam)
20885 unformat_input_t *i = vam->input;
20886 vl_api_hw_interface_set_mtu_t *mp;
20887 u32 sw_if_index = ~0;
20891 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20893 if (unformat (i, "mtu %d", &mtu))
20895 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20897 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20903 if (sw_if_index == ~0)
20905 errmsg ("missing interface name or sw_if_index");
20911 errmsg ("no mtu specified");
20915 /* Construct the API message */
20916 M (HW_INTERFACE_SET_MTU, mp);
20917 mp->sw_if_index = ntohl (sw_if_index);
20918 mp->mtu = ntohs ((u16) mtu);
20926 api_p2p_ethernet_add (vat_main_t * vam)
20928 unformat_input_t *i = vam->input;
20929 vl_api_p2p_ethernet_add_t *mp;
20930 u32 parent_if_index = ~0;
20936 clib_memset (remote_mac, 0, sizeof (remote_mac));
20937 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20939 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
20941 else if (unformat (i, "sw_if_index %d", &parent_if_index))
20945 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
20947 else if (unformat (i, "sub_id %d", &sub_id))
20951 clib_warning ("parse error '%U'", format_unformat_error, i);
20956 if (parent_if_index == ~0)
20958 errmsg ("missing interface name or sw_if_index");
20963 errmsg ("missing remote mac address");
20968 errmsg ("missing sub-interface id");
20972 M (P2P_ETHERNET_ADD, mp);
20973 mp->parent_if_index = ntohl (parent_if_index);
20974 mp->subif_id = ntohl (sub_id);
20975 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
20983 api_p2p_ethernet_del (vat_main_t * vam)
20985 unformat_input_t *i = vam->input;
20986 vl_api_p2p_ethernet_del_t *mp;
20987 u32 parent_if_index = ~0;
20992 clib_memset (remote_mac, 0, sizeof (remote_mac));
20993 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20995 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
20997 else if (unformat (i, "sw_if_index %d", &parent_if_index))
21001 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
21005 clib_warning ("parse error '%U'", format_unformat_error, i);
21010 if (parent_if_index == ~0)
21012 errmsg ("missing interface name or sw_if_index");
21017 errmsg ("missing remote mac address");
21021 M (P2P_ETHERNET_DEL, mp);
21022 mp->parent_if_index = ntohl (parent_if_index);
21023 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
21031 api_lldp_config (vat_main_t * vam)
21033 unformat_input_t *i = vam->input;
21034 vl_api_lldp_config_t *mp;
21036 int tx_interval = 0;
21037 u8 *sys_name = NULL;
21040 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21042 if (unformat (i, "system-name %s", &sys_name))
21044 else if (unformat (i, "tx-hold %d", &tx_hold))
21046 else if (unformat (i, "tx-interval %d", &tx_interval))
21050 clib_warning ("parse error '%U'", format_unformat_error, i);
21055 vec_add1 (sys_name, 0);
21057 M (LLDP_CONFIG, mp);
21058 mp->tx_hold = htonl (tx_hold);
21059 mp->tx_interval = htonl (tx_interval);
21060 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
21061 vec_free (sys_name);
21069 api_sw_interface_set_lldp (vat_main_t * vam)
21071 unformat_input_t *i = vam->input;
21072 vl_api_sw_interface_set_lldp_t *mp;
21073 u32 sw_if_index = ~0;
21075 u8 *port_desc = NULL, *mgmt_oid = NULL;
21076 ip4_address_t ip4_addr;
21077 ip6_address_t ip6_addr;
21080 clib_memset (&ip4_addr, 0, sizeof (ip4_addr));
21081 clib_memset (&ip6_addr, 0, sizeof (ip6_addr));
21083 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21085 if (unformat (i, "disable"))
21088 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21090 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21092 else if (unformat (i, "port-desc %s", &port_desc))
21094 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
21096 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
21098 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
21104 if (sw_if_index == ~0)
21106 errmsg ("missing interface name or sw_if_index");
21110 /* Construct the API message */
21111 vec_add1 (port_desc, 0);
21112 vec_add1 (mgmt_oid, 0);
21113 M (SW_INTERFACE_SET_LLDP, mp);
21114 mp->sw_if_index = ntohl (sw_if_index);
21115 mp->enable = enable;
21116 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
21117 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
21118 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
21119 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
21120 vec_free (port_desc);
21121 vec_free (mgmt_oid);
21129 api_tcp_configure_src_addresses (vat_main_t * vam)
21131 vl_api_tcp_configure_src_addresses_t *mp;
21132 unformat_input_t *i = vam->input;
21133 ip4_address_t v4first, v4last;
21134 ip6_address_t v6first, v6last;
21139 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21141 if (unformat (i, "%U - %U",
21142 unformat_ip4_address, &v4first,
21143 unformat_ip4_address, &v4last))
21147 errmsg ("one range per message (range already set)");
21152 else if (unformat (i, "%U - %U",
21153 unformat_ip6_address, &v6first,
21154 unformat_ip6_address, &v6last))
21158 errmsg ("one range per message (range already set)");
21163 else if (unformat (i, "vrf %d", &vrf_id))
21169 if (range_set == 0)
21171 errmsg ("address range not set");
21175 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
21176 mp->vrf_id = ntohl (vrf_id);
21178 if (range_set == 2)
21181 clib_memcpy (mp->first_address, &v6first, sizeof (v6first));
21182 clib_memcpy (mp->last_address, &v6last, sizeof (v6last));
21187 clib_memcpy (mp->first_address, &v4first, sizeof (v4first));
21188 clib_memcpy (mp->last_address, &v4last, sizeof (v4last));
21195 static void vl_api_app_namespace_add_del_reply_t_handler
21196 (vl_api_app_namespace_add_del_reply_t * mp)
21198 vat_main_t *vam = &vat_main;
21199 i32 retval = ntohl (mp->retval);
21200 if (vam->async_mode)
21202 vam->async_errors += (retval < 0);
21206 vam->retval = retval;
21208 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
21209 vam->result_ready = 1;
21213 static void vl_api_app_namespace_add_del_reply_t_handler_json
21214 (vl_api_app_namespace_add_del_reply_t * mp)
21216 vat_main_t *vam = &vat_main;
21217 vat_json_node_t node;
21219 vat_json_init_object (&node);
21220 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
21221 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
21223 vat_json_print (vam->ofp, &node);
21224 vat_json_free (&node);
21226 vam->retval = ntohl (mp->retval);
21227 vam->result_ready = 1;
21231 api_app_namespace_add_del (vat_main_t * vam)
21233 vl_api_app_namespace_add_del_t *mp;
21234 unformat_input_t *i = vam->input;
21235 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
21236 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
21240 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21242 if (unformat (i, "id %_%v%_", &ns_id))
21244 else if (unformat (i, "secret %lu", &secret))
21246 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21247 sw_if_index_set = 1;
21248 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
21250 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
21255 if (!ns_id || !secret_set || !sw_if_index_set)
21257 errmsg ("namespace id, secret and sw_if_index must be set");
21260 if (vec_len (ns_id) > 64)
21262 errmsg ("namespace id too long");
21265 M (APP_NAMESPACE_ADD_DEL, mp);
21267 clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
21268 mp->namespace_id_len = vec_len (ns_id);
21269 mp->secret = clib_host_to_net_u64 (secret);
21270 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
21271 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
21272 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
21280 api_sock_init_shm (vat_main_t * vam)
21282 #if VPP_API_TEST_BUILTIN == 0
21283 unformat_input_t *i = vam->input;
21284 vl_api_shm_elem_config_t *config = 0;
21285 u64 size = 64 << 20;
21288 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21290 if (unformat (i, "size %U", unformat_memory_size, &size))
21297 * Canned custom ring allocator config.
21298 * Should probably parse all of this
21300 vec_validate (config, 6);
21301 config[0].type = VL_API_VLIB_RING;
21302 config[0].size = 256;
21303 config[0].count = 32;
21305 config[1].type = VL_API_VLIB_RING;
21306 config[1].size = 1024;
21307 config[1].count = 16;
21309 config[2].type = VL_API_VLIB_RING;
21310 config[2].size = 4096;
21311 config[2].count = 2;
21313 config[3].type = VL_API_CLIENT_RING;
21314 config[3].size = 256;
21315 config[3].count = 32;
21317 config[4].type = VL_API_CLIENT_RING;
21318 config[4].size = 1024;
21319 config[4].count = 16;
21321 config[5].type = VL_API_CLIENT_RING;
21322 config[5].size = 4096;
21323 config[5].count = 2;
21325 config[6].type = VL_API_QUEUE;
21326 config[6].count = 128;
21327 config[6].size = sizeof (uword);
21329 rv = vl_socket_client_init_shm (config, 1 /* want_pthread */ );
21331 vam->client_index_invalid = 1;
21339 api_dns_enable_disable (vat_main_t * vam)
21341 unformat_input_t *line_input = vam->input;
21342 vl_api_dns_enable_disable_t *mp;
21343 u8 enable_disable = 1;
21346 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21348 if (unformat (line_input, "disable"))
21349 enable_disable = 0;
21350 if (unformat (line_input, "enable"))
21351 enable_disable = 1;
21356 /* Construct the API message */
21357 M (DNS_ENABLE_DISABLE, mp);
21358 mp->enable = enable_disable;
21362 /* Wait for the reply */
21368 api_dns_resolve_name (vat_main_t * vam)
21370 unformat_input_t *line_input = vam->input;
21371 vl_api_dns_resolve_name_t *mp;
21375 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21377 if (unformat (line_input, "%s", &name))
21383 if (vec_len (name) > 127)
21385 errmsg ("name too long");
21389 /* Construct the API message */
21390 M (DNS_RESOLVE_NAME, mp);
21391 memcpy (mp->name, name, vec_len (name));
21396 /* Wait for the reply */
21402 api_dns_resolve_ip (vat_main_t * vam)
21404 unformat_input_t *line_input = vam->input;
21405 vl_api_dns_resolve_ip_t *mp;
21407 ip4_address_t addr4;
21408 ip6_address_t addr6;
21411 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21413 if (unformat (line_input, "%U", unformat_ip6_address, &addr6))
21415 else if (unformat (line_input, "%U", unformat_ip4_address, &addr4))
21423 errmsg ("missing address");
21427 /* Construct the API message */
21428 M (DNS_RESOLVE_IP, mp);
21429 mp->is_ip6 = is_ip6;
21431 memcpy (mp->address, &addr6, sizeof (addr6));
21433 memcpy (mp->address, &addr4, sizeof (addr4));
21437 /* Wait for the reply */
21443 api_dns_name_server_add_del (vat_main_t * vam)
21445 unformat_input_t *i = vam->input;
21446 vl_api_dns_name_server_add_del_t *mp;
21448 ip6_address_t ip6_server;
21449 ip4_address_t ip4_server;
21454 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21456 if (unformat (i, "%U", unformat_ip6_address, &ip6_server))
21458 else if (unformat (i, "%U", unformat_ip4_address, &ip4_server))
21460 else if (unformat (i, "del"))
21464 clib_warning ("parse error '%U'", format_unformat_error, i);
21469 if (ip4_set && ip6_set)
21471 errmsg ("Only one server address allowed per message");
21474 if ((ip4_set + ip6_set) == 0)
21476 errmsg ("Server address required");
21480 /* Construct the API message */
21481 M (DNS_NAME_SERVER_ADD_DEL, mp);
21485 memcpy (mp->server_address, &ip6_server, sizeof (ip6_address_t));
21490 memcpy (mp->server_address, &ip4_server, sizeof (ip4_address_t));
21494 mp->is_add = is_add;
21499 /* Wait for a reply, return good/bad news */
21505 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
21507 vat_main_t *vam = &vat_main;
21512 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
21513 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
21514 mp->scope, format_ip4_address, &mp->lcl_ip, mp->lcl_plen,
21515 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
21516 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
21517 clib_net_to_host_u32 (mp->action_index), mp->tag);
21522 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
21523 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
21524 mp->scope, format_ip6_address, &mp->lcl_ip, mp->lcl_plen,
21525 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
21526 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
21527 clib_net_to_host_u32 (mp->action_index), mp->tag);
21532 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
21535 vat_main_t *vam = &vat_main;
21536 vat_json_node_t *node = NULL;
21537 struct in6_addr ip6;
21538 struct in_addr ip4;
21540 if (VAT_JSON_ARRAY != vam->json_tree.type)
21542 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
21543 vat_json_init_array (&vam->json_tree);
21545 node = vat_json_array_add (&vam->json_tree);
21546 vat_json_init_object (node);
21548 vat_json_object_add_uint (node, "is_ip4", mp->is_ip4 ? 1 : 0);
21549 vat_json_object_add_uint (node, "appns_index",
21550 clib_net_to_host_u32 (mp->appns_index));
21551 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
21552 vat_json_object_add_uint (node, "scope", mp->scope);
21553 vat_json_object_add_uint (node, "action_index",
21554 clib_net_to_host_u32 (mp->action_index));
21555 vat_json_object_add_uint (node, "lcl_port",
21556 clib_net_to_host_u16 (mp->lcl_port));
21557 vat_json_object_add_uint (node, "rmt_port",
21558 clib_net_to_host_u16 (mp->rmt_port));
21559 vat_json_object_add_uint (node, "lcl_plen", mp->lcl_plen);
21560 vat_json_object_add_uint (node, "rmt_plen", mp->rmt_plen);
21561 vat_json_object_add_string_copy (node, "tag", mp->tag);
21564 clib_memcpy (&ip4, mp->lcl_ip, sizeof (ip4));
21565 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
21566 clib_memcpy (&ip4, mp->rmt_ip, sizeof (ip4));
21567 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
21571 clib_memcpy (&ip6, mp->lcl_ip, sizeof (ip6));
21572 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
21573 clib_memcpy (&ip6, mp->rmt_ip, sizeof (ip6));
21574 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
21579 api_session_rule_add_del (vat_main_t * vam)
21581 vl_api_session_rule_add_del_t *mp;
21582 unformat_input_t *i = vam->input;
21583 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
21584 u32 appns_index = 0, scope = 0;
21585 ip4_address_t lcl_ip4, rmt_ip4;
21586 ip6_address_t lcl_ip6, rmt_ip6;
21587 u8 is_ip4 = 1, conn_set = 0;
21588 u8 is_add = 1, *tag = 0;
21591 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21593 if (unformat (i, "del"))
21595 else if (unformat (i, "add"))
21597 else if (unformat (i, "proto tcp"))
21599 else if (unformat (i, "proto udp"))
21601 else if (unformat (i, "appns %d", &appns_index))
21603 else if (unformat (i, "scope %d", &scope))
21605 else if (unformat (i, "tag %_%v%_", &tag))
21609 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
21610 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
21618 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
21619 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
21625 else if (unformat (i, "action %d", &action))
21630 if (proto == ~0 || !conn_set || action == ~0)
21632 errmsg ("transport proto, connection and action must be set");
21638 errmsg ("scope should be 0-3");
21642 M (SESSION_RULE_ADD_DEL, mp);
21644 mp->is_ip4 = is_ip4;
21645 mp->transport_proto = proto;
21646 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
21647 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
21648 mp->lcl_plen = lcl_plen;
21649 mp->rmt_plen = rmt_plen;
21650 mp->action_index = clib_host_to_net_u32 (action);
21651 mp->appns_index = clib_host_to_net_u32 (appns_index);
21653 mp->is_add = is_add;
21656 clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
21657 clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
21661 clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
21662 clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
21666 clib_memcpy (mp->tag, tag, vec_len (tag));
21676 api_session_rules_dump (vat_main_t * vam)
21678 vl_api_session_rules_dump_t *mp;
21679 vl_api_control_ping_t *mp_ping;
21682 if (!vam->json_output)
21684 print (vam->ofp, "%=20s", "Session Rules");
21687 M (SESSION_RULES_DUMP, mp);
21691 /* Use a control ping for synchronization */
21692 MPING (CONTROL_PING, mp_ping);
21695 /* Wait for a reply... */
21701 api_ip_container_proxy_add_del (vat_main_t * vam)
21703 vl_api_ip_container_proxy_add_del_t *mp;
21704 unformat_input_t *i = vam->input;
21705 u32 sw_if_index = ~0;
21706 vl_api_prefix_t pfx = { };
21710 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21712 if (unformat (i, "del"))
21714 else if (unformat (i, "add"))
21716 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
21718 else if (unformat (i, "sw_if_index %u", &sw_if_index))
21723 if (sw_if_index == ~0 || pfx.address_length == 0)
21725 errmsg ("address and sw_if_index must be set");
21729 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
21731 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
21732 mp->is_add = is_add;
21733 clib_memcpy (&mp->pfx, &pfx, sizeof (pfx));
21741 api_qos_record_enable_disable (vat_main_t * vam)
21743 unformat_input_t *i = vam->input;
21744 vl_api_qos_record_enable_disable_t *mp;
21745 u32 sw_if_index, qs = 0xff;
21746 u8 sw_if_index_set = 0;
21750 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21752 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21753 sw_if_index_set = 1;
21754 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21755 sw_if_index_set = 1;
21756 else if (unformat (i, "%U", unformat_qos_source, &qs))
21758 else if (unformat (i, "disable"))
21762 clib_warning ("parse error '%U'", format_unformat_error, i);
21767 if (sw_if_index_set == 0)
21769 errmsg ("missing interface name or sw_if_index");
21774 errmsg ("input location must be specified");
21778 M (QOS_RECORD_ENABLE_DISABLE, mp);
21780 mp->sw_if_index = ntohl (sw_if_index);
21781 mp->input_source = qs;
21782 mp->enable = enable;
21791 q_or_quit (vat_main_t * vam)
21793 #if VPP_API_TEST_BUILTIN == 0
21794 longjmp (vam->jump_buf, 1);
21796 return 0; /* not so much */
21800 q (vat_main_t * vam)
21802 return q_or_quit (vam);
21806 quit (vat_main_t * vam)
21808 return q_or_quit (vam);
21812 comment (vat_main_t * vam)
21818 statseg (vat_main_t * vam)
21820 ssvm_private_t *ssvmp = &vam->stat_segment;
21821 ssvm_shared_header_t *shared_header = ssvmp->sh;
21822 vlib_counter_t **counters;
21823 u64 thread0_index1_packets;
21824 u64 thread0_index1_bytes;
21825 f64 vector_rate, input_rate;
21828 uword *counter_vector_by_name;
21829 if (vam->stat_segment_lockp == 0)
21831 errmsg ("Stat segment not mapped...");
21835 /* look up "/if/rx for sw_if_index 1 as a test */
21837 clib_spinlock_lock (vam->stat_segment_lockp);
21839 counter_vector_by_name = (uword *) shared_header->opaque[1];
21841 p = hash_get_mem (counter_vector_by_name, "/if/rx");
21844 clib_spinlock_unlock (vam->stat_segment_lockp);
21845 errmsg ("/if/tx not found?");
21849 /* Fish per-thread vector of combined counters from shared memory */
21850 counters = (vlib_counter_t **) p[0];
21852 if (vec_len (counters[0]) < 2)
21854 clib_spinlock_unlock (vam->stat_segment_lockp);
21855 errmsg ("/if/tx vector length %d", vec_len (counters[0]));
21859 /* Read thread 0 sw_if_index 1 counter */
21860 thread0_index1_packets = counters[0][1].packets;
21861 thread0_index1_bytes = counters[0][1].bytes;
21863 p = hash_get_mem (counter_vector_by_name, "vector_rate");
21866 clib_spinlock_unlock (vam->stat_segment_lockp);
21867 errmsg ("vector_rate not found?");
21871 vector_rate = *(f64 *) (p[0]);
21872 p = hash_get_mem (counter_vector_by_name, "input_rate");
21875 clib_spinlock_unlock (vam->stat_segment_lockp);
21876 errmsg ("input_rate not found?");
21879 input_rate = *(f64 *) (p[0]);
21881 clib_spinlock_unlock (vam->stat_segment_lockp);
21883 print (vam->ofp, "vector_rate %.2f input_rate %.2f",
21884 vector_rate, input_rate);
21885 print (vam->ofp, "thread 0 sw_if_index 1 rx pkts %lld, bytes %lld",
21886 thread0_index1_packets, thread0_index1_bytes);
21892 cmd_cmp (void *a1, void *a2)
21897 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
21901 help (vat_main_t * vam)
21906 unformat_input_t *i = vam->input;
21909 if (unformat (i, "%s", &name))
21913 vec_add1 (name, 0);
21915 hs = hash_get_mem (vam->help_by_name, name);
21917 print (vam->ofp, "usage: %s %s", name, hs[0]);
21919 print (vam->ofp, "No such msg / command '%s'", name);
21924 print (vam->ofp, "Help is available for the following:");
21927 hash_foreach_pair (p, vam->function_by_name,
21929 vec_add1 (cmds, (u8 *)(p->key));
21933 vec_sort_with_function (cmds, cmd_cmp);
21935 for (j = 0; j < vec_len (cmds); j++)
21936 print (vam->ofp, "%s", cmds[j]);
21943 set (vat_main_t * vam)
21945 u8 *name = 0, *value = 0;
21946 unformat_input_t *i = vam->input;
21948 if (unformat (i, "%s", &name))
21950 /* The input buffer is a vector, not a string. */
21951 value = vec_dup (i->buffer);
21952 vec_delete (value, i->index, 0);
21953 /* Almost certainly has a trailing newline */
21954 if (value[vec_len (value) - 1] == '\n')
21955 value[vec_len (value) - 1] = 0;
21956 /* Make sure it's a proper string, one way or the other */
21957 vec_add1 (value, 0);
21958 (void) clib_macro_set_value (&vam->macro_main,
21959 (char *) name, (char *) value);
21962 errmsg ("usage: set <name> <value>");
21970 unset (vat_main_t * vam)
21974 if (unformat (vam->input, "%s", &name))
21975 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
21976 errmsg ("unset: %s wasn't set", name);
21989 macro_sort_cmp (void *a1, void *a2)
21991 macro_sort_t *s1 = a1;
21992 macro_sort_t *s2 = a2;
21994 return strcmp ((char *) (s1->name), (char *) (s2->name));
21998 dump_macro_table (vat_main_t * vam)
22000 macro_sort_t *sort_me = 0, *sm;
22005 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
22007 vec_add2 (sort_me, sm, 1);
22008 sm->name = (u8 *)(p->key);
22009 sm->value = (u8 *) (p->value[0]);
22013 vec_sort_with_function (sort_me, macro_sort_cmp);
22015 if (vec_len (sort_me))
22016 print (vam->ofp, "%-15s%s", "Name", "Value");
22018 print (vam->ofp, "The macro table is empty...");
22020 for (i = 0; i < vec_len (sort_me); i++)
22021 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
22026 dump_node_table (vat_main_t * vam)
22029 vlib_node_t *node, *next_node;
22031 if (vec_len (vam->graph_nodes) == 0)
22033 print (vam->ofp, "Node table empty, issue get_node_graph...");
22037 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
22039 node = vam->graph_nodes[0][i];
22040 print (vam->ofp, "[%d] %s", i, node->name);
22041 for (j = 0; j < vec_len (node->next_nodes); j++)
22043 if (node->next_nodes[j] != ~0)
22045 next_node = vam->graph_nodes[0][node->next_nodes[j]];
22046 print (vam->ofp, " [%d] %s", j, next_node->name);
22054 value_sort_cmp (void *a1, void *a2)
22056 name_sort_t *n1 = a1;
22057 name_sort_t *n2 = a2;
22059 if (n1->value < n2->value)
22061 if (n1->value > n2->value)
22068 dump_msg_api_table (vat_main_t * vam)
22070 api_main_t *am = &api_main;
22071 name_sort_t *nses = 0, *ns;
22076 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
22078 vec_add2 (nses, ns, 1);
22079 ns->name = (u8 *)(hp->key);
22080 ns->value = (u32) hp->value[0];
22084 vec_sort_with_function (nses, value_sort_cmp);
22086 for (i = 0; i < vec_len (nses); i++)
22087 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
22093 get_msg_id (vat_main_t * vam)
22098 if (unformat (vam->input, "%s", &name_and_crc))
22100 message_index = vl_msg_api_get_msg_index (name_and_crc);
22101 if (message_index == ~0)
22103 print (vam->ofp, " '%s' not found", name_and_crc);
22106 print (vam->ofp, " '%s' has message index %d",
22107 name_and_crc, message_index);
22110 errmsg ("name_and_crc required...");
22115 search_node_table (vat_main_t * vam)
22117 unformat_input_t *line_input = vam->input;
22120 vlib_node_t *node, *next_node;
22123 if (vam->graph_node_index_by_name == 0)
22125 print (vam->ofp, "Node table empty, issue get_node_graph...");
22129 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
22131 if (unformat (line_input, "%s", &node_to_find))
22133 vec_add1 (node_to_find, 0);
22134 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
22137 print (vam->ofp, "%s not found...", node_to_find);
22140 node = vam->graph_nodes[0][p[0]];
22141 print (vam->ofp, "[%d] %s", p[0], node->name);
22142 for (j = 0; j < vec_len (node->next_nodes); j++)
22144 if (node->next_nodes[j] != ~0)
22146 next_node = vam->graph_nodes[0][node->next_nodes[j]];
22147 print (vam->ofp, " [%d] %s", j, next_node->name);
22154 clib_warning ("parse error '%U'", format_unformat_error,
22160 vec_free (node_to_find);
22169 script (vat_main_t * vam)
22171 #if (VPP_API_TEST_BUILTIN==0)
22173 char *save_current_file;
22174 unformat_input_t save_input;
22175 jmp_buf save_jump_buf;
22176 u32 save_line_number;
22178 FILE *new_fp, *save_ifp;
22180 if (unformat (vam->input, "%s", &s))
22182 new_fp = fopen ((char *) s, "r");
22185 errmsg ("Couldn't open script file %s", s);
22192 errmsg ("Missing script name");
22196 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
22197 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
22198 save_ifp = vam->ifp;
22199 save_line_number = vam->input_line_number;
22200 save_current_file = (char *) vam->current_file;
22202 vam->input_line_number = 0;
22204 vam->current_file = s;
22207 clib_memcpy (&vam->input, &save_input, sizeof (save_input));
22208 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
22209 vam->ifp = save_ifp;
22210 vam->input_line_number = save_line_number;
22211 vam->current_file = (u8 *) save_current_file;
22216 clib_warning ("use the exec command...");
22222 echo (vat_main_t * vam)
22224 print (vam->ofp, "%v", vam->input->buffer);
22228 /* List of API message constructors, CLI names map to api_xxx */
22229 #define foreach_vpe_api_msg \
22230 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
22231 _(sw_interface_dump,"") \
22232 _(sw_interface_set_flags, \
22233 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
22234 _(sw_interface_add_del_address, \
22235 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
22236 _(sw_interface_set_rx_mode, \
22237 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
22238 _(sw_interface_set_rx_placement, \
22239 "<intfc> | sw_if_index <id> [queue <id>] [worker <id> | main]") \
22240 _(sw_interface_rx_placement_dump, \
22241 "[<intfc> | sw_if_index <id>]") \
22242 _(sw_interface_set_table, \
22243 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
22244 _(sw_interface_set_mpls_enable, \
22245 "<intfc> | sw_if_index [disable | dis]") \
22246 _(sw_interface_set_vpath, \
22247 "<intfc> | sw_if_index <id> enable | disable") \
22248 _(sw_interface_set_vxlan_bypass, \
22249 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
22250 _(sw_interface_set_geneve_bypass, \
22251 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
22252 _(sw_interface_set_l2_xconnect, \
22253 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
22254 "enable | disable") \
22255 _(sw_interface_set_l2_bridge, \
22256 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
22257 "[shg <split-horizon-group>] [bvi]\n" \
22258 "enable | disable") \
22259 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
22260 _(bridge_domain_add_del, \
22261 "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") \
22262 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
22264 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
22265 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
22266 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
22268 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
22270 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
22272 "id <num> [hw-addr <mac-addr>] [host-ns <name>] [rx-ring-size <num> [tx-ring-size <num>]") \
22274 "<vpp-if-name> | sw_if_index <id>") \
22275 _(sw_interface_tap_v2_dump, "") \
22276 _(virtio_pci_create, \
22277 "pci-addr <pci-address> [use_random_mac | hw-addr <mac-addr>] [features <hex-value>] [gso-enabled]") \
22278 _(virtio_pci_delete, \
22279 "<vpp-if-name> | sw_if_index <id>") \
22280 _(sw_interface_virtio_pci_dump, "") \
22282 "[hw-addr <mac-addr>] {round-robin | active-backup | " \
22283 "broadcast | {lacp | xor} [load-balance { l2 | l23 | l34 }]} " \
22286 "<vpp-if-name> | sw_if_index <id>") \
22288 "sw_if_index <n> bond <sw_if_index> [is_passive] [is_long_timeout]") \
22289 _(bond_detach_slave, \
22290 "sw_if_index <n>") \
22291 _(sw_interface_bond_dump, "") \
22292 _(sw_interface_slave_dump, \
22293 "<vpp-if-name> | sw_if_index <id>") \
22294 _(ip_table_add_del, \
22295 "table <n> [ipv6] [add | del]\n") \
22296 _(ip_add_del_route, \
22297 "<addr>/<mask> via <<addr>|<intfc>|sw_if_index <id>|via-label <n>>\n" \
22298 "[table-id <n>] [<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n"\
22299 "[weight <n>] [drop] [local] [classify <n>] [out-label <n>]\n" \
22300 "[multipath] [count <n>] [del]") \
22301 _(ip_mroute_add_del, \
22302 "<src> <grp>/<mask> [table-id <n>]\n" \
22303 "[<intfc> | sw_if_index <id>] [local] [del]") \
22304 _(mpls_table_add_del, \
22305 "table <n> [add | del]\n") \
22306 _(mpls_route_add_del, \
22307 "<label> <eos> via <addr | next-hop-table <n> | via-label <n> |\n" \
22308 "lookup-ip4-table <n> | lookup-in-ip6-table <n> |\n" \
22309 "l2-input-on <intfc> | l2-input-on sw_if_index <id>>\n" \
22310 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>] [weight <n>]\n" \
22311 "[drop] [local] [classify <n>] [out-label <n>] [multipath]\n" \
22312 "[count <n>] [del]") \
22313 _(mpls_ip_bind_unbind, \
22314 "<label> <addr/len>") \
22315 _(mpls_tunnel_add_del, \
22316 "[add | del <intfc | sw_if_index <id>>] via <addr | via-label <n>>\n" \
22317 "[<intfc> | sw_if_index <id> | next-hop-table <id>]\n" \
22318 "[l2-only] [out-label <n>]") \
22319 _(sr_mpls_policy_add, \
22320 "bsid <id> [weight <n>] [spray] next <sid> [next <sid>]") \
22321 _(sr_mpls_policy_del, \
22323 _(bier_table_add_del, \
22324 "<label> <sub-domain> <set> <bsl> [del]") \
22325 _(bier_route_add_del, \
22326 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
22327 "[<intfc> | sw_if_index <id>]" \
22328 "[weight <n>] [del] [multipath]") \
22329 _(proxy_arp_add_del, \
22330 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
22331 _(proxy_arp_intfc_enable_disable, \
22332 "<intfc> | sw_if_index <id> enable | disable") \
22333 _(sw_interface_set_unnumbered, \
22334 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
22335 _(ip_neighbor_add_del, \
22336 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
22337 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
22338 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
22339 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
22340 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
22341 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
22342 "[outer_vlan_id_any][inner_vlan_id_any]") \
22343 _(reset_fib, "vrf <n> [ipv6]") \
22344 _(dhcp_proxy_config, \
22345 "svr <v46-address> src <v46-address>\n" \
22346 "rx_vrf_id <nn> server_vrf_id <nn> [del]") \
22347 _(dhcp_proxy_set_vss, \
22348 "tbl_id <n> [fib_id <n> oui <n> | vpn_ascii_id <text>] [ipv6] [del]") \
22349 _(dhcp_proxy_dump, "ip6") \
22350 _(dhcp_client_config, \
22351 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
22352 _(set_ip_flow_hash, \
22353 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
22354 _(sw_interface_ip6_enable_disable, \
22355 "<intfc> | sw_if_index <id> enable | disable") \
22356 _(ip6nd_proxy_add_del, \
22357 "<intfc> | sw_if_index <id> <ip6-address>") \
22358 _(ip6nd_proxy_dump, "") \
22359 _(sw_interface_ip6nd_ra_prefix, \
22360 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
22361 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
22362 "[nolink] [isno]") \
22363 _(sw_interface_ip6nd_ra_config, \
22364 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
22365 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
22366 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
22367 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
22368 _(l2_patch_add_del, \
22369 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
22370 "enable | disable") \
22371 _(sr_localsid_add_del, \
22372 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
22373 "fib-table <num> (end.psp) sw_if_index <num>") \
22374 _(classify_add_del_table, \
22375 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
22376 " [del] [del-chain] mask <mask-value>\n" \
22377 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
22378 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
22379 _(classify_add_del_session, \
22380 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
22381 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
22382 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
22383 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
22384 _(classify_set_interface_ip_table, \
22385 "<intfc> | sw_if_index <nn> table <nn>") \
22386 _(classify_set_interface_l2_tables, \
22387 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22388 " [other-table <nn>]") \
22389 _(get_node_index, "node <node-name") \
22390 _(add_node_next, "node <node-name> next <next-node-name>") \
22391 _(l2tpv3_create_tunnel, \
22392 "client_address <ip6-addr> our_address <ip6-addr>\n" \
22393 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
22394 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
22395 _(l2tpv3_set_tunnel_cookies, \
22396 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
22397 "[new_remote_cookie <nn>]\n") \
22398 _(l2tpv3_interface_enable_disable, \
22399 "<intfc> | sw_if_index <nn> enable | disable") \
22400 _(l2tpv3_set_lookup_key, \
22401 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
22402 _(sw_if_l2tpv3_tunnel_dump, "") \
22403 _(vxlan_offload_rx, \
22404 "hw { <interface name> | hw_if_index <nn>} " \
22405 "rx { <vxlan tunnel name> | sw_if_index <nn> } [del]") \
22406 _(vxlan_add_del_tunnel, \
22407 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
22408 "{ <intfc> | mcast_sw_if_index <nn> } [instance <id>]}\n" \
22409 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
22410 _(geneve_add_del_tunnel, \
22411 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
22412 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22413 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
22414 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22415 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22416 _(gre_tunnel_add_del, \
22417 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [instance <n>]\n" \
22418 "[teb | erspan <session-id>] [del]") \
22419 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22420 _(l2_fib_clear_table, "") \
22421 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
22422 _(l2_interface_vlan_tag_rewrite, \
22423 "<intfc> | sw_if_index <nn> \n" \
22424 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
22425 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
22426 _(create_vhost_user_if, \
22427 "socket <filename> [server] [renumber <dev_instance>] " \
22428 "[disable_mrg_rxbuf] [disable_indirect_desc] " \
22429 "[mac <mac_address>]") \
22430 _(modify_vhost_user_if, \
22431 "<intfc> | sw_if_index <nn> socket <filename>\n" \
22432 "[server] [renumber <dev_instance>]") \
22433 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
22434 _(sw_interface_vhost_user_dump, "") \
22435 _(show_version, "") \
22436 _(show_threads, "") \
22437 _(vxlan_gpe_add_del_tunnel, \
22438 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
22439 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22440 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
22441 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
22442 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22443 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
22444 _(interface_name_renumber, \
22445 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
22446 _(input_acl_set_interface, \
22447 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22448 " [l2-table <nn>] [del]") \
22449 _(ip_probe_neighbor, "(<intc> | sw_if_index <nn>) address <ip4|ip6-addr>") \
22450 _(ip_scan_neighbor_enable_disable, "[ip4|ip6|both|disable] [interval <n-min>]\n" \
22451 " [max-time <n-usec>] [max-update <n>] [delay <n-msec>] [stale <n-min>]") \
22452 _(want_ip4_arp_events, "address <ip4-address> [del]") \
22453 _(want_ip6_nd_events, "address <ip6-address> [del]") \
22454 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
22455 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
22456 _(ip_dump, "ipv4 | ipv6") \
22457 _(ipsec_spd_add_del, "spd_id <n> [del]") \
22458 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
22460 _(ipsec_sad_entry_add_del, "sad_id <n> spi <n> crypto_alg <alg>\n" \
22461 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
22462 " integ_alg <alg> integ_key <hex>") \
22463 _(ipsec_spd_entry_add_del, "spd_id <n> priority <n> action <action>\n" \
22464 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
22465 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
22466 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
22467 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
22468 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
22469 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
22470 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
22471 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n" \
22472 " [instance <n>]") \
22473 _(ipsec_sa_dump, "[sa_id <n>]") \
22474 _(ipsec_tunnel_if_set_key, "<intfc> <local|remote> <crypto|integ>\n" \
22475 " <alg> <hex>\n") \
22476 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
22477 _(delete_loopback,"sw_if_index <nn>") \
22478 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
22479 _(bd_ip_mac_flush, "bd_id <bridge-domain-id>") \
22480 _(bd_ip_mac_dump, "[bd_id] <bridge-domain-id>") \
22481 _(want_interface_events, "enable|disable") \
22482 _(get_first_msg_id, "client <name>") \
22483 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
22484 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
22485 "fib-id <nn> [ip4][ip6][default]") \
22486 _(get_node_graph, " ") \
22487 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
22488 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
22489 _(ioam_disable, "") \
22490 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
22491 " sw_if_index <sw_if_index> p <priority> " \
22492 "w <weight>] [del]") \
22493 _(one_add_del_locator, "locator-set <locator_name> " \
22494 "iface <intf> | sw_if_index <sw_if_index> " \
22495 "p <priority> w <weight> [del]") \
22496 _(one_add_del_local_eid,"vni <vni> eid " \
22497 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22498 "locator-set <locator_name> [del]" \
22499 "[key-id sha1|sha256 secret-key <secret-key>]")\
22500 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
22501 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
22502 _(one_enable_disable, "enable|disable") \
22503 _(one_map_register_enable_disable, "enable|disable") \
22504 _(one_map_register_fallback_threshold, "<value>") \
22505 _(one_rloc_probe_enable_disable, "enable|disable") \
22506 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22508 "rloc <locator> p <prio> " \
22509 "w <weight> [rloc <loc> ... ] " \
22510 "action <action> [del-all]") \
22511 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22513 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22514 _(one_use_petr, "ip-address> | disable") \
22515 _(one_map_request_mode, "src-dst|dst-only") \
22516 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22517 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22518 _(one_locator_set_dump, "[local | remote]") \
22519 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
22520 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22521 "[local] | [remote]") \
22522 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
22523 _(one_ndp_bd_get, "") \
22524 _(one_ndp_entries_get, "bd <bridge-domain>") \
22525 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
22526 _(one_l2_arp_bd_get, "") \
22527 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
22528 _(one_stats_enable_disable, "enable|disable") \
22529 _(show_one_stats_enable_disable, "") \
22530 _(one_eid_table_vni_dump, "") \
22531 _(one_eid_table_map_dump, "l2|l3") \
22532 _(one_map_resolver_dump, "") \
22533 _(one_map_server_dump, "") \
22534 _(one_adjacencies_get, "vni <vni>") \
22535 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
22536 _(show_one_rloc_probe_state, "") \
22537 _(show_one_map_register_state, "") \
22538 _(show_one_status, "") \
22539 _(one_stats_dump, "") \
22540 _(one_stats_flush, "") \
22541 _(one_get_map_request_itr_rlocs, "") \
22542 _(one_map_register_set_ttl, "<ttl>") \
22543 _(one_set_transport_protocol, "udp|api") \
22544 _(one_get_transport_protocol, "") \
22545 _(one_enable_disable_xtr_mode, "enable|disable") \
22546 _(one_show_xtr_mode, "") \
22547 _(one_enable_disable_pitr_mode, "enable|disable") \
22548 _(one_show_pitr_mode, "") \
22549 _(one_enable_disable_petr_mode, "enable|disable") \
22550 _(one_show_petr_mode, "") \
22551 _(show_one_nsh_mapping, "") \
22552 _(show_one_pitr, "") \
22553 _(show_one_use_petr, "") \
22554 _(show_one_map_request_mode, "") \
22555 _(show_one_map_register_ttl, "") \
22556 _(show_one_map_register_fallback_threshold, "") \
22557 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
22558 " sw_if_index <sw_if_index> p <priority> " \
22559 "w <weight>] [del]") \
22560 _(lisp_add_del_locator, "locator-set <locator_name> " \
22561 "iface <intf> | sw_if_index <sw_if_index> " \
22562 "p <priority> w <weight> [del]") \
22563 _(lisp_add_del_local_eid,"vni <vni> eid " \
22564 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22565 "locator-set <locator_name> [del]" \
22566 "[key-id sha1|sha256 secret-key <secret-key>]") \
22567 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
22568 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
22569 _(lisp_enable_disable, "enable|disable") \
22570 _(lisp_map_register_enable_disable, "enable|disable") \
22571 _(lisp_rloc_probe_enable_disable, "enable|disable") \
22572 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22574 "rloc <locator> p <prio> " \
22575 "w <weight> [rloc <loc> ... ] " \
22576 "action <action> [del-all]") \
22577 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22579 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22580 _(lisp_use_petr, "<ip-address> | disable") \
22581 _(lisp_map_request_mode, "src-dst|dst-only") \
22582 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22583 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22584 _(lisp_locator_set_dump, "[local | remote]") \
22585 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
22586 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22587 "[local] | [remote]") \
22588 _(lisp_eid_table_vni_dump, "") \
22589 _(lisp_eid_table_map_dump, "l2|l3") \
22590 _(lisp_map_resolver_dump, "") \
22591 _(lisp_map_server_dump, "") \
22592 _(lisp_adjacencies_get, "vni <vni>") \
22593 _(gpe_fwd_entry_vnis_get, "") \
22594 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
22595 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
22596 "[table <table-id>]") \
22597 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
22598 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
22599 _(gpe_set_encap_mode, "lisp|vxlan") \
22600 _(gpe_get_encap_mode, "") \
22601 _(lisp_gpe_add_del_iface, "up|down") \
22602 _(lisp_gpe_enable_disable, "enable|disable") \
22603 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
22604 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
22605 _(show_lisp_rloc_probe_state, "") \
22606 _(show_lisp_map_register_state, "") \
22607 _(show_lisp_status, "") \
22608 _(lisp_get_map_request_itr_rlocs, "") \
22609 _(show_lisp_pitr, "") \
22610 _(show_lisp_use_petr, "") \
22611 _(show_lisp_map_request_mode, "") \
22612 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
22613 _(af_packet_delete, "name <host interface name>") \
22614 _(af_packet_dump, "") \
22615 _(policer_add_del, "name <policer name> <params> [del]") \
22616 _(policer_dump, "[name <policer name>]") \
22617 _(policer_classify_set_interface, \
22618 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22619 " [l2-table <nn>] [del]") \
22620 _(policer_classify_dump, "type [ip4|ip6|l2]") \
22621 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
22622 "[master|slave]") \
22623 _(netmap_delete, "name <interface name>") \
22624 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
22625 _(mpls_fib_dump, "") \
22626 _(classify_table_ids, "") \
22627 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
22628 _(classify_table_info, "table_id <nn>") \
22629 _(classify_session_dump, "table_id <nn>") \
22630 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
22631 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
22632 "[template_interval <nn>] [udp_checksum]") \
22633 _(ipfix_exporter_dump, "") \
22634 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
22635 _(ipfix_classify_stream_dump, "") \
22636 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
22637 _(ipfix_classify_table_dump, "") \
22638 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
22639 _(sw_interface_span_dump, "[l2]") \
22640 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
22641 _(pg_create_interface, "if_id <nn>") \
22642 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
22643 _(pg_enable_disable, "[stream <id>] disable") \
22644 _(ip_source_and_port_range_check_add_del, \
22645 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
22646 _(ip_source_and_port_range_check_interface_add_del, \
22647 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
22648 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
22649 _(ipsec_gre_tunnel_add_del, \
22650 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
22651 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
22652 _(delete_subif,"<intfc> | sw_if_index <nn>") \
22653 _(l2_interface_pbb_tag_rewrite, \
22654 "<intfc> | sw_if_index <nn> \n" \
22655 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
22656 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
22657 _(set_punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
22658 _(flow_classify_set_interface, \
22659 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
22660 _(flow_classify_dump, "type [ip4|ip6]") \
22661 _(ip_fib_dump, "") \
22662 _(ip_mfib_dump, "") \
22663 _(ip6_fib_dump, "") \
22664 _(ip6_mfib_dump, "") \
22665 _(feature_enable_disable, "arc_name <arc_name> " \
22666 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
22667 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
22669 _(l2_xconnect_dump, "") \
22670 _(hw_interface_set_mtu, "<intfc> | hw_if_index <nn> mtu <nn>") \
22671 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
22672 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
22673 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
22674 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
22675 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
22676 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
22677 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
22678 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
22679 _(sock_init_shm, "size <nnn>") \
22680 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
22681 _(dns_enable_disable, "[enable][disable]") \
22682 _(dns_name_server_add_del, "<ip-address> [del]") \
22683 _(dns_resolve_name, "<hostname>") \
22684 _(dns_resolve_ip, "<ip4|ip6>") \
22685 _(dns_name_server_add_del, "<ip-address> [del]") \
22686 _(dns_resolve_name, "<hostname>") \
22687 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
22688 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
22689 _(session_rules_dump, "") \
22690 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
22691 _(output_acl_set_interface, \
22692 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22693 " [l2-table <nn>] [del]") \
22694 _(qos_record_enable_disable, "<record-source> <intfc> | sw_if_index <id> [disable]")
22696 /* List of command functions, CLI names map directly to functions */
22697 #define foreach_cli_function \
22698 _(comment, "usage: comment <ignore-rest-of-line>") \
22699 _(dump_interface_table, "usage: dump_interface_table") \
22700 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
22701 _(dump_ipv4_table, "usage: dump_ipv4_table") \
22702 _(dump_ipv6_table, "usage: dump_ipv6_table") \
22703 _(dump_macro_table, "usage: dump_macro_table ") \
22704 _(dump_node_table, "usage: dump_node_table") \
22705 _(dump_msg_api_table, "usage: dump_msg_api_table") \
22706 _(get_msg_id, "usage: get_msg_id name_and_crc") \
22707 _(echo, "usage: echo <message>") \
22708 _(exec, "usage: exec <vpe-debug-CLI-command>") \
22709 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
22710 _(help, "usage: help") \
22711 _(q, "usage: quit") \
22712 _(quit, "usage: quit") \
22713 _(search_node_table, "usage: search_node_table <name>...") \
22714 _(set, "usage: set <variable-name> <value>") \
22715 _(script, "usage: script <file-name>") \
22716 _(statseg, "usage: statseg"); \
22717 _(unset, "usage: unset <variable-name>")
22720 static void vl_api_##n##_t_handler_uni \
22721 (vl_api_##n##_t * mp) \
22723 vat_main_t * vam = &vat_main; \
22724 if (vam->json_output) { \
22725 vl_api_##n##_t_handler_json(mp); \
22727 vl_api_##n##_t_handler(mp); \
22730 foreach_vpe_api_reply_msg;
22731 #if VPP_API_TEST_BUILTIN == 0
22732 foreach_standalone_reply_msg;
22737 vat_api_hookup (vat_main_t * vam)
22740 vl_msg_api_set_handlers(VL_API_##N, #n, \
22741 vl_api_##n##_t_handler_uni, \
22743 vl_api_##n##_t_endian, \
22744 vl_api_##n##_t_print, \
22745 sizeof(vl_api_##n##_t), 1);
22746 foreach_vpe_api_reply_msg;
22747 #if VPP_API_TEST_BUILTIN == 0
22748 foreach_standalone_reply_msg;
22752 #if (VPP_API_TEST_BUILTIN==0)
22753 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
22755 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
22757 vam->function_by_name = hash_create_string (0, sizeof (uword));
22759 vam->help_by_name = hash_create_string (0, sizeof (uword));
22762 /* API messages we can send */
22763 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
22764 foreach_vpe_api_msg;
22768 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
22769 foreach_vpe_api_msg;
22772 /* CLI functions */
22773 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
22774 foreach_cli_function;
22778 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
22779 foreach_cli_function;
22783 #if VPP_API_TEST_BUILTIN
22784 static clib_error_t *
22785 vat_api_hookup_shim (vlib_main_t * vm)
22787 vat_api_hookup (&vat_main);
22791 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
22795 * fd.io coding-style-patch-verification: ON
22798 * eval: (c-set-style "gnu")