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 #if VPP_API_TEST_BUILTIN == 0
77 #define vl_print(handle, ...)
79 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
82 #include <vpp/api/vpe_all_api_h.h>
85 #define __plugin_msg_base 0
86 #include <vlibapi/vat_helper_macros.h>
88 void vl_api_set_elog_main (elog_main_t * m);
89 int vl_api_set_elog_trace_api_messages (int enable);
91 #if VPP_API_TEST_BUILTIN == 0
101 vat_socket_connect (vat_main_t * vam)
104 vam->socket_client_main = &socket_client_main;
105 if ((rv = vl_socket_client_connect ((char *) vam->socket_name,
107 0 /* default socket rx, tx buffer */ )))
109 /* vpp expects the client index in network order */
110 vam->my_client_index = htonl (socket_client_main.client_index);
113 #else /* vpp built-in case, we don't do sockets... */
115 vat_socket_connect (vat_main_t * vam)
121 vl_socket_client_read (int wait)
127 vl_socket_client_write ()
133 vl_socket_client_msg_alloc (int nbytes)
141 vat_time_now (vat_main_t * vam)
143 #if VPP_API_TEST_BUILTIN
144 return vlib_time_now (vam->vlib_main);
146 return clib_time_now (&vam->clib_time);
151 errmsg (char *fmt, ...)
153 vat_main_t *vam = &vat_main;
158 s = va_format (0, fmt, &va);
163 #if VPP_API_TEST_BUILTIN
164 vlib_cli_output (vam->vlib_main, (char *) s);
167 if (vam->ifp != stdin)
168 fformat (vam->ofp, "%s(%d): \n", vam->current_file,
169 vam->input_line_number);
171 fformat (vam->ofp, "%s\n", (char *) s);
179 #if VPP_API_TEST_BUILTIN == 0
181 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
183 vat_main_t *vam = va_arg (*args, vat_main_t *);
184 u32 *result = va_arg (*args, u32 *);
188 if (!unformat (input, "%s", &if_name))
191 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
199 api_unformat_hw_if_index (unformat_input_t * input, va_list * args)
204 /* Parse an IP4 address %d.%d.%d.%d. */
206 unformat_ip4_address (unformat_input_t * input, va_list * args)
208 u8 *result = va_arg (*args, u8 *);
211 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
214 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
226 unformat_ethernet_address (unformat_input_t * input, va_list * args)
228 u8 *result = va_arg (*args, u8 *);
231 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
232 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
236 for (i = 0; i < 6; i++)
237 if (a[i] >= (1 << 8))
240 for (i = 0; i < 6; i++)
246 /* Returns ethernet type as an int in host byte order. */
248 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
251 u16 *result = va_arg (*args, u16 *);
255 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
257 if (type >= (1 << 16))
265 /* Parse an IP6 address. */
267 unformat_ip6_address (unformat_input_t * input, va_list * args)
269 ip6_address_t *result = va_arg (*args, ip6_address_t *);
271 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
272 uword c, n_colon, double_colon_index;
274 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
275 double_colon_index = ARRAY_LEN (hex_quads);
276 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
279 if (c >= '0' && c <= '9')
281 else if (c >= 'a' && c <= 'f')
282 hex_digit = c + 10 - 'a';
283 else if (c >= 'A' && c <= 'F')
284 hex_digit = c + 10 - 'A';
285 else if (c == ':' && n_colon < 2)
289 unformat_put_input (input);
293 /* Too many hex quads. */
294 if (n_hex_quads >= ARRAY_LEN (hex_quads))
299 hex_quad = (hex_quad << 4) | hex_digit;
301 /* Hex quad must fit in 16 bits. */
302 if (n_hex_digits >= 4)
309 /* Save position of :: */
312 /* More than one :: ? */
313 if (double_colon_index < ARRAY_LEN (hex_quads))
315 double_colon_index = n_hex_quads;
318 if (n_colon > 0 && n_hex_digits > 0)
320 hex_quads[n_hex_quads++] = hex_quad;
326 if (n_hex_digits > 0)
327 hex_quads[n_hex_quads++] = hex_quad;
332 /* Expand :: to appropriate number of zero hex quads. */
333 if (double_colon_index < ARRAY_LEN (hex_quads))
335 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
337 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
338 hex_quads[n_zero + i] = hex_quads[i];
340 for (i = 0; i < n_zero; i++)
341 hex_quads[double_colon_index + i] = 0;
343 n_hex_quads = ARRAY_LEN (hex_quads);
346 /* Too few hex quads given. */
347 if (n_hex_quads < ARRAY_LEN (hex_quads))
350 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
351 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
358 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
360 u32 *r = va_arg (*args, u32 *);
363 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
364 foreach_ipsec_policy_action
372 format_ipsec_crypto_alg (u8 * s, va_list * args)
374 u32 i = va_arg (*args, u32);
379 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
380 foreach_ipsec_crypto_alg
383 return format (s, "unknown");
385 return format (s, "%s", t);
389 format_ipsec_integ_alg (u8 * s, va_list * args)
391 u32 i = va_arg (*args, u32);
396 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
397 foreach_ipsec_integ_alg
400 return format (s, "unknown");
402 return format (s, "%s", t);
405 #else /* VPP_API_TEST_BUILTIN == 1 */
407 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
409 vat_main_t *vam __clib_unused = va_arg (*args, vat_main_t *);
410 vnet_main_t *vnm = vnet_get_main ();
411 u32 *result = va_arg (*args, u32 *);
413 return unformat (input, "%U", unformat_vnet_sw_interface, vnm, result);
417 api_unformat_hw_if_index (unformat_input_t * input, va_list * args)
419 vat_main_t *vam __clib_unused = va_arg (*args, vat_main_t *);
420 vnet_main_t *vnm = vnet_get_main ();
421 u32 *result = va_arg (*args, u32 *);
423 return unformat (input, "%U", unformat_vnet_hw_interface, vnm, result);
426 #endif /* VPP_API_TEST_BUILTIN */
429 unformat_ipsec_api_crypto_alg (unformat_input_t * input, va_list * args)
431 u32 *r = va_arg (*args, u32 *);
434 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_API_CRYPTO_ALG_##f;
435 foreach_ipsec_crypto_alg
443 unformat_ipsec_api_integ_alg (unformat_input_t * input, va_list * args)
445 u32 *r = va_arg (*args, u32 *);
448 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_API_INTEG_ALG_##f;
449 foreach_ipsec_integ_alg
457 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
459 u8 *r = va_arg (*args, u8 *);
461 if (unformat (input, "kbps"))
462 *r = SSE2_QOS_RATE_KBPS;
463 else if (unformat (input, "pps"))
464 *r = SSE2_QOS_RATE_PPS;
471 unformat_policer_round_type (unformat_input_t * input, va_list * args)
473 u8 *r = va_arg (*args, u8 *);
475 if (unformat (input, "closest"))
476 *r = SSE2_QOS_ROUND_TO_CLOSEST;
477 else if (unformat (input, "up"))
478 *r = SSE2_QOS_ROUND_TO_UP;
479 else if (unformat (input, "down"))
480 *r = SSE2_QOS_ROUND_TO_DOWN;
487 unformat_policer_type (unformat_input_t * input, va_list * args)
489 u8 *r = va_arg (*args, u8 *);
491 if (unformat (input, "1r2c"))
492 *r = SSE2_QOS_POLICER_TYPE_1R2C;
493 else if (unformat (input, "1r3c"))
494 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
495 else if (unformat (input, "2r3c-2698"))
496 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
497 else if (unformat (input, "2r3c-4115"))
498 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
499 else if (unformat (input, "2r3c-mef5cf1"))
500 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
507 unformat_dscp (unformat_input_t * input, va_list * va)
509 u8 *r = va_arg (*va, u8 *);
512 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
521 unformat_policer_action_type (unformat_input_t * input, va_list * va)
523 sse2_qos_pol_action_params_st *a
524 = va_arg (*va, sse2_qos_pol_action_params_st *);
526 if (unformat (input, "drop"))
527 a->action_type = SSE2_QOS_ACTION_DROP;
528 else if (unformat (input, "transmit"))
529 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
530 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
531 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
538 unformat_policer_classify_table_type (unformat_input_t * input, va_list * va)
540 u32 *r = va_arg (*va, u32 *);
543 if (unformat (input, "ip4"))
544 tid = POLICER_CLASSIFY_TABLE_IP4;
545 else if (unformat (input, "ip6"))
546 tid = POLICER_CLASSIFY_TABLE_IP6;
547 else if (unformat (input, "l2"))
548 tid = POLICER_CLASSIFY_TABLE_L2;
557 unformat_flow_classify_table_type (unformat_input_t * input, va_list * va)
559 u32 *r = va_arg (*va, u32 *);
562 if (unformat (input, "ip4"))
563 tid = FLOW_CLASSIFY_TABLE_IP4;
564 else if (unformat (input, "ip6"))
565 tid = FLOW_CLASSIFY_TABLE_IP6;
573 #if (VPP_API_TEST_BUILTIN==0)
575 static const char *mfib_flag_names[] = MFIB_ENTRY_NAMES_SHORT;
576 static const char *mfib_flag_long_names[] = MFIB_ENTRY_NAMES_LONG;
577 static const char *mfib_itf_flag_long_names[] = MFIB_ITF_NAMES_LONG;
578 static const char *mfib_itf_flag_names[] = MFIB_ITF_NAMES_SHORT;
581 unformat_mfib_itf_flags (unformat_input_t * input, va_list * args)
583 mfib_itf_flags_t old, *iflags = va_arg (*args, mfib_itf_flags_t *);
584 mfib_itf_attribute_t attr;
587 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
589 if (unformat (input, mfib_itf_flag_long_names[attr]))
590 *iflags |= (1 << attr);
592 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
594 if (unformat (input, mfib_itf_flag_names[attr]))
595 *iflags |= (1 << attr);
598 return (old == *iflags ? 0 : 1);
602 unformat_mfib_entry_flags (unformat_input_t * input, va_list * args)
604 mfib_entry_flags_t old, *eflags = va_arg (*args, mfib_entry_flags_t *);
605 mfib_entry_attribute_t attr;
608 FOR_EACH_MFIB_ATTRIBUTE (attr)
610 if (unformat (input, mfib_flag_long_names[attr]))
611 *eflags |= (1 << attr);
613 FOR_EACH_MFIB_ATTRIBUTE (attr)
615 if (unformat (input, mfib_flag_names[attr]))
616 *eflags |= (1 << attr);
619 return (old == *eflags ? 0 : 1);
623 format_ip4_address (u8 * s, va_list * args)
625 u8 *a = va_arg (*args, u8 *);
626 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
630 format_ip6_address (u8 * s, va_list * args)
632 ip6_address_t *a = va_arg (*args, ip6_address_t *);
633 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
635 i_max_n_zero = ARRAY_LEN (a->as_u16);
637 i_first_zero = i_max_n_zero;
639 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
641 u32 is_zero = a->as_u16[i] == 0;
642 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
648 if ((!is_zero && n_zeros > max_n_zeros)
649 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
651 i_max_n_zero = i_first_zero;
652 max_n_zeros = n_zeros;
653 i_first_zero = ARRAY_LEN (a->as_u16);
658 last_double_colon = 0;
659 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
661 if (i == i_max_n_zero && max_n_zeros > 1)
663 s = format (s, "::");
664 i += max_n_zeros - 1;
665 last_double_colon = 1;
669 s = format (s, "%s%x",
670 (last_double_colon || i == 0) ? "" : ":",
671 clib_net_to_host_u16 (a->as_u16[i]));
672 last_double_colon = 0;
679 /* Format an IP46 address. */
681 format_ip46_address (u8 * s, va_list * args)
683 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
684 ip46_type_t type = va_arg (*args, ip46_type_t);
690 is_ip4 = ip46_address_is_ip4 (ip46);
701 format (s, "%U", format_ip4_address, &ip46->ip4) :
702 format (s, "%U", format_ip6_address, &ip46->ip6);
706 format_ethernet_address (u8 * s, va_list * args)
708 u8 *a = va_arg (*args, u8 *);
710 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
711 a[0], a[1], a[2], a[3], a[4], a[5]);
716 increment_v4_address (vl_api_ip4_address_t * i)
718 ip4_address_t *a = (ip4_address_t *) i;
721 v = ntohl (a->as_u32) + 1;
722 a->as_u32 = ntohl (v);
726 increment_v6_address (vl_api_ip6_address_t * i)
728 ip6_address_t *a = (ip6_address_t *) i;
731 v0 = clib_net_to_host_u64 (a->as_u64[0]);
732 v1 = clib_net_to_host_u64 (a->as_u64[1]);
737 a->as_u64[0] = clib_net_to_host_u64 (v0);
738 a->as_u64[1] = clib_net_to_host_u64 (v1);
742 increment_address (vl_api_address_t * a)
744 if (clib_net_to_host_u32 (a->af) == ADDRESS_IP4)
745 increment_v4_address (&a->un.ip4);
746 else if (clib_net_to_host_u32 (a->af) == ADDRESS_IP6)
747 increment_v6_address (&a->un.ip6);
751 set_ip4_address (vl_api_address_t * a, u32 v)
753 if (a->af == ADDRESS_IP4)
755 ip4_address_t *i = (ip4_address_t *) & a->un.ip4;
761 increment_mac_address (u8 * mac)
763 u64 tmp = *((u64 *) mac);
764 tmp = clib_net_to_host_u64 (tmp);
765 tmp += 1 << 16; /* skip unused (least significant) octets */
766 tmp = clib_host_to_net_u64 (tmp);
768 clib_memcpy (mac, &tmp, 6);
772 vat_json_object_add_address (vat_json_node_t * node,
773 const char *str, const vl_api_address_t * addr)
775 if (ADDRESS_IP6 == addr->af)
779 clib_memcpy (&ip6, &addr->un.ip6, sizeof (ip6));
780 vat_json_object_add_ip6 (node, str, ip6);
786 clib_memcpy (&ip4, &addr->un.ip4, sizeof (ip4));
787 vat_json_object_add_ip4 (node, str, ip4);
792 vat_json_object_add_prefix (vat_json_node_t * node,
793 const vl_api_prefix_t * prefix)
795 vat_json_object_add_uint (node, "len", prefix->len);
796 vat_json_object_add_address (node, "address", &prefix->address);
799 static void vl_api_create_loopback_reply_t_handler
800 (vl_api_create_loopback_reply_t * mp)
802 vat_main_t *vam = &vat_main;
803 i32 retval = ntohl (mp->retval);
805 vam->retval = retval;
806 vam->regenerate_interface_table = 1;
807 vam->sw_if_index = ntohl (mp->sw_if_index);
808 vam->result_ready = 1;
811 static void vl_api_create_loopback_reply_t_handler_json
812 (vl_api_create_loopback_reply_t * mp)
814 vat_main_t *vam = &vat_main;
815 vat_json_node_t node;
817 vat_json_init_object (&node);
818 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
819 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
821 vat_json_print (vam->ofp, &node);
822 vat_json_free (&node);
823 vam->retval = ntohl (mp->retval);
824 vam->result_ready = 1;
827 static void vl_api_create_loopback_instance_reply_t_handler
828 (vl_api_create_loopback_instance_reply_t * mp)
830 vat_main_t *vam = &vat_main;
831 i32 retval = ntohl (mp->retval);
833 vam->retval = retval;
834 vam->regenerate_interface_table = 1;
835 vam->sw_if_index = ntohl (mp->sw_if_index);
836 vam->result_ready = 1;
839 static void vl_api_create_loopback_instance_reply_t_handler_json
840 (vl_api_create_loopback_instance_reply_t * mp)
842 vat_main_t *vam = &vat_main;
843 vat_json_node_t node;
845 vat_json_init_object (&node);
846 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
847 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
849 vat_json_print (vam->ofp, &node);
850 vat_json_free (&node);
851 vam->retval = ntohl (mp->retval);
852 vam->result_ready = 1;
855 static void vl_api_af_packet_create_reply_t_handler
856 (vl_api_af_packet_create_reply_t * mp)
858 vat_main_t *vam = &vat_main;
859 i32 retval = ntohl (mp->retval);
861 vam->retval = retval;
862 vam->regenerate_interface_table = 1;
863 vam->sw_if_index = ntohl (mp->sw_if_index);
864 vam->result_ready = 1;
867 static void vl_api_af_packet_create_reply_t_handler_json
868 (vl_api_af_packet_create_reply_t * mp)
870 vat_main_t *vam = &vat_main;
871 vat_json_node_t node;
873 vat_json_init_object (&node);
874 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
875 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
877 vat_json_print (vam->ofp, &node);
878 vat_json_free (&node);
880 vam->retval = ntohl (mp->retval);
881 vam->result_ready = 1;
884 static void vl_api_create_vlan_subif_reply_t_handler
885 (vl_api_create_vlan_subif_reply_t * mp)
887 vat_main_t *vam = &vat_main;
888 i32 retval = ntohl (mp->retval);
890 vam->retval = retval;
891 vam->regenerate_interface_table = 1;
892 vam->sw_if_index = ntohl (mp->sw_if_index);
893 vam->result_ready = 1;
896 static void vl_api_create_vlan_subif_reply_t_handler_json
897 (vl_api_create_vlan_subif_reply_t * mp)
899 vat_main_t *vam = &vat_main;
900 vat_json_node_t node;
902 vat_json_init_object (&node);
903 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
904 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
906 vat_json_print (vam->ofp, &node);
907 vat_json_free (&node);
909 vam->retval = ntohl (mp->retval);
910 vam->result_ready = 1;
913 static void vl_api_create_subif_reply_t_handler
914 (vl_api_create_subif_reply_t * mp)
916 vat_main_t *vam = &vat_main;
917 i32 retval = ntohl (mp->retval);
919 vam->retval = retval;
920 vam->regenerate_interface_table = 1;
921 vam->sw_if_index = ntohl (mp->sw_if_index);
922 vam->result_ready = 1;
925 static void vl_api_create_subif_reply_t_handler_json
926 (vl_api_create_subif_reply_t * mp)
928 vat_main_t *vam = &vat_main;
929 vat_json_node_t node;
931 vat_json_init_object (&node);
932 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
933 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
935 vat_json_print (vam->ofp, &node);
936 vat_json_free (&node);
938 vam->retval = ntohl (mp->retval);
939 vam->result_ready = 1;
942 static void vl_api_interface_name_renumber_reply_t_handler
943 (vl_api_interface_name_renumber_reply_t * mp)
945 vat_main_t *vam = &vat_main;
946 i32 retval = ntohl (mp->retval);
948 vam->retval = retval;
949 vam->regenerate_interface_table = 1;
950 vam->result_ready = 1;
953 static void vl_api_interface_name_renumber_reply_t_handler_json
954 (vl_api_interface_name_renumber_reply_t * mp)
956 vat_main_t *vam = &vat_main;
957 vat_json_node_t node;
959 vat_json_init_object (&node);
960 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
962 vat_json_print (vam->ofp, &node);
963 vat_json_free (&node);
965 vam->retval = ntohl (mp->retval);
966 vam->result_ready = 1;
970 * Special-case: build the interface table, maintain
971 * the next loopback sw_if_index vbl.
973 static void vl_api_sw_interface_details_t_handler
974 (vl_api_sw_interface_details_t * mp)
976 vat_main_t *vam = &vat_main;
977 u8 *s = format (0, "%s%c", mp->interface_name, 0);
979 hash_set_mem (vam->sw_if_index_by_interface_name, s,
980 ntohl (mp->sw_if_index));
982 /* In sub interface case, fill the sub interface table entry */
983 if (mp->sw_if_index != mp->sup_sw_if_index)
985 sw_interface_subif_t *sub = NULL;
987 vec_add2 (vam->sw_if_subif_table, sub, 1);
989 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
990 strncpy ((char *) sub->interface_name, (char *) s,
991 vec_len (sub->interface_name));
992 sub->sw_if_index = ntohl (mp->sw_if_index);
993 sub->sub_id = ntohl (mp->sub_id);
995 sub->raw_flags = ntohl (mp->sub_if_flags & SUB_IF_API_FLAG_MASK_VNET);
997 sub->sub_number_of_tags = mp->sub_number_of_tags;
998 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
999 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
1001 /* vlan tag rewrite */
1002 sub->vtr_op = ntohl (mp->vtr_op);
1003 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
1004 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
1005 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
1009 static void vl_api_sw_interface_details_t_handler_json
1010 (vl_api_sw_interface_details_t * mp)
1012 vat_main_t *vam = &vat_main;
1013 vat_json_node_t *node = NULL;
1015 if (VAT_JSON_ARRAY != vam->json_tree.type)
1017 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1018 vat_json_init_array (&vam->json_tree);
1020 node = vat_json_array_add (&vam->json_tree);
1022 vat_json_init_object (node);
1023 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
1024 vat_json_object_add_uint (node, "sup_sw_if_index",
1025 ntohl (mp->sup_sw_if_index));
1026 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
1027 sizeof (mp->l2_address));
1028 vat_json_object_add_string_copy (node, "interface_name",
1029 mp->interface_name);
1030 vat_json_object_add_uint (node, "flags", mp->flags);
1031 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
1032 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
1033 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
1034 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
1035 vat_json_object_add_uint (node, "sub_number_of_tags",
1036 mp->sub_number_of_tags);
1037 vat_json_object_add_uint (node, "sub_outer_vlan_id",
1038 ntohs (mp->sub_outer_vlan_id));
1039 vat_json_object_add_uint (node, "sub_inner_vlan_id",
1040 ntohs (mp->sub_inner_vlan_id));
1041 vat_json_object_add_uint (node, "sub_if_flags", ntohl (mp->sub_if_flags));
1042 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
1043 vat_json_object_add_uint (node, "vtr_push_dot1q",
1044 ntohl (mp->vtr_push_dot1q));
1045 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
1046 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
1047 if (ntohl (mp->sub_if_flags) & SUB_IF_API_FLAG_DOT1AH)
1049 vat_json_object_add_string_copy (node, "pbb_vtr_dmac",
1051 format_ethernet_address,
1053 vat_json_object_add_string_copy (node, "pbb_vtr_smac",
1055 format_ethernet_address,
1057 vat_json_object_add_uint (node, "pbb_vtr_b_vlanid", mp->b_vlanid);
1058 vat_json_object_add_uint (node, "pbb_vtr_i_sid", mp->i_sid);
1062 #if VPP_API_TEST_BUILTIN == 0
1063 static void vl_api_sw_interface_event_t_handler
1064 (vl_api_sw_interface_event_t * mp)
1066 vat_main_t *vam = &vat_main;
1067 if (vam->interface_event_display)
1068 errmsg ("interface flags: sw_if_index %d %s %s",
1069 ntohl (mp->sw_if_index),
1070 ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_ADMIN_UP) ?
1071 "admin-up" : "admin-down",
1072 ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_LINK_UP) ?
1073 "link-up" : "link-down");
1077 __clib_unused static void
1078 vl_api_sw_interface_event_t_handler_json (vl_api_sw_interface_event_t * mp)
1080 /* JSON output not supported */
1084 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
1086 vat_main_t *vam = &vat_main;
1087 i32 retval = ntohl (mp->retval);
1089 vam->retval = retval;
1090 vam->shmem_result = uword_to_pointer (mp->reply_in_shmem, u8 *);
1091 vam->result_ready = 1;
1095 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
1097 vat_main_t *vam = &vat_main;
1098 vat_json_node_t node;
1099 api_main_t *am = &api_main;
1103 vat_json_init_object (&node);
1104 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1105 vat_json_object_add_uint (&node, "reply_in_shmem",
1106 ntohl (mp->reply_in_shmem));
1107 /* Toss the shared-memory original... */
1108 pthread_mutex_lock (&am->vlib_rp->mutex);
1109 oldheap = svm_push_data_heap (am->vlib_rp);
1111 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
1114 svm_pop_heap (oldheap);
1115 pthread_mutex_unlock (&am->vlib_rp->mutex);
1117 vat_json_print (vam->ofp, &node);
1118 vat_json_free (&node);
1120 vam->retval = ntohl (mp->retval);
1121 vam->result_ready = 1;
1125 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
1127 vat_main_t *vam = &vat_main;
1128 i32 retval = ntohl (mp->retval);
1129 u32 length = vl_api_string_len (&mp->reply);
1131 vec_reset_length (vam->cmd_reply);
1133 vam->retval = retval;
1136 vec_validate (vam->cmd_reply, length);
1137 clib_memcpy ((char *) (vam->cmd_reply),
1138 vl_api_from_api_string (&mp->reply), length);
1139 vam->cmd_reply[length] = 0;
1141 vam->result_ready = 1;
1145 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
1147 vat_main_t *vam = &vat_main;
1148 vat_json_node_t node;
1150 vec_reset_length (vam->cmd_reply);
1152 vat_json_init_object (&node);
1153 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1154 vat_json_object_add_string_copy (&node, "reply",
1155 vl_api_from_api_string (&mp->reply));
1157 vat_json_print (vam->ofp, &node);
1158 vat_json_free (&node);
1160 vam->retval = ntohl (mp->retval);
1161 vam->result_ready = 1;
1164 static void vl_api_classify_add_del_table_reply_t_handler
1165 (vl_api_classify_add_del_table_reply_t * mp)
1167 vat_main_t *vam = &vat_main;
1168 i32 retval = ntohl (mp->retval);
1169 if (vam->async_mode)
1171 vam->async_errors += (retval < 0);
1175 vam->retval = retval;
1177 ((mp->new_table_index != 0xFFFFFFFF) ||
1178 (mp->skip_n_vectors != 0xFFFFFFFF) ||
1179 (mp->match_n_vectors != 0xFFFFFFFF)))
1181 * Note: this is just barely thread-safe, depends on
1182 * the main thread spinning waiting for an answer...
1184 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d",
1185 ntohl (mp->new_table_index),
1186 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
1187 vam->result_ready = 1;
1191 static void vl_api_classify_add_del_table_reply_t_handler_json
1192 (vl_api_classify_add_del_table_reply_t * mp)
1194 vat_main_t *vam = &vat_main;
1195 vat_json_node_t node;
1197 vat_json_init_object (&node);
1198 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1199 vat_json_object_add_uint (&node, "new_table_index",
1200 ntohl (mp->new_table_index));
1201 vat_json_object_add_uint (&node, "skip_n_vectors",
1202 ntohl (mp->skip_n_vectors));
1203 vat_json_object_add_uint (&node, "match_n_vectors",
1204 ntohl (mp->match_n_vectors));
1206 vat_json_print (vam->ofp, &node);
1207 vat_json_free (&node);
1209 vam->retval = ntohl (mp->retval);
1210 vam->result_ready = 1;
1213 static void vl_api_get_node_index_reply_t_handler
1214 (vl_api_get_node_index_reply_t * mp)
1216 vat_main_t *vam = &vat_main;
1217 i32 retval = ntohl (mp->retval);
1218 if (vam->async_mode)
1220 vam->async_errors += (retval < 0);
1224 vam->retval = retval;
1226 errmsg ("node index %d", ntohl (mp->node_index));
1227 vam->result_ready = 1;
1231 static void vl_api_get_node_index_reply_t_handler_json
1232 (vl_api_get_node_index_reply_t * mp)
1234 vat_main_t *vam = &vat_main;
1235 vat_json_node_t node;
1237 vat_json_init_object (&node);
1238 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1239 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1241 vat_json_print (vam->ofp, &node);
1242 vat_json_free (&node);
1244 vam->retval = ntohl (mp->retval);
1245 vam->result_ready = 1;
1248 static void vl_api_get_next_index_reply_t_handler
1249 (vl_api_get_next_index_reply_t * mp)
1251 vat_main_t *vam = &vat_main;
1252 i32 retval = ntohl (mp->retval);
1253 if (vam->async_mode)
1255 vam->async_errors += (retval < 0);
1259 vam->retval = retval;
1261 errmsg ("next node index %d", ntohl (mp->next_index));
1262 vam->result_ready = 1;
1266 static void vl_api_get_next_index_reply_t_handler_json
1267 (vl_api_get_next_index_reply_t * mp)
1269 vat_main_t *vam = &vat_main;
1270 vat_json_node_t node;
1272 vat_json_init_object (&node);
1273 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1274 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1276 vat_json_print (vam->ofp, &node);
1277 vat_json_free (&node);
1279 vam->retval = ntohl (mp->retval);
1280 vam->result_ready = 1;
1283 static void vl_api_add_node_next_reply_t_handler
1284 (vl_api_add_node_next_reply_t * mp)
1286 vat_main_t *vam = &vat_main;
1287 i32 retval = ntohl (mp->retval);
1288 if (vam->async_mode)
1290 vam->async_errors += (retval < 0);
1294 vam->retval = retval;
1296 errmsg ("next index %d", ntohl (mp->next_index));
1297 vam->result_ready = 1;
1301 static void vl_api_add_node_next_reply_t_handler_json
1302 (vl_api_add_node_next_reply_t * mp)
1304 vat_main_t *vam = &vat_main;
1305 vat_json_node_t node;
1307 vat_json_init_object (&node);
1308 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1309 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1311 vat_json_print (vam->ofp, &node);
1312 vat_json_free (&node);
1314 vam->retval = ntohl (mp->retval);
1315 vam->result_ready = 1;
1318 static void vl_api_show_version_reply_t_handler
1319 (vl_api_show_version_reply_t * mp)
1321 vat_main_t *vam = &vat_main;
1322 i32 retval = ntohl (mp->retval);
1326 errmsg (" program: %s", mp->program);
1327 errmsg (" version: %s", mp->version);
1328 errmsg (" build date: %s", mp->build_date);
1329 errmsg ("build directory: %s", mp->build_directory);
1331 vam->retval = retval;
1332 vam->result_ready = 1;
1335 static void vl_api_show_version_reply_t_handler_json
1336 (vl_api_show_version_reply_t * mp)
1338 vat_main_t *vam = &vat_main;
1339 vat_json_node_t node;
1341 vat_json_init_object (&node);
1342 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1343 vat_json_object_add_string_copy (&node, "program", mp->program);
1344 vat_json_object_add_string_copy (&node, "version", mp->version);
1345 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1346 vat_json_object_add_string_copy (&node, "build_directory",
1347 mp->build_directory);
1349 vat_json_print (vam->ofp, &node);
1350 vat_json_free (&node);
1352 vam->retval = ntohl (mp->retval);
1353 vam->result_ready = 1;
1356 static void vl_api_show_threads_reply_t_handler
1357 (vl_api_show_threads_reply_t * mp)
1359 vat_main_t *vam = &vat_main;
1360 i32 retval = ntohl (mp->retval);
1364 count = ntohl (mp->count);
1366 for (i = 0; i < count; i++)
1368 "\n%-2d %-11s %-11s %-5d %-6d %-4d %-6d",
1369 ntohl (mp->thread_data[i].id), mp->thread_data[i].name,
1370 mp->thread_data[i].type, ntohl (mp->thread_data[i].pid),
1371 ntohl (mp->thread_data[i].cpu_id), ntohl (mp->thread_data[i].core),
1372 ntohl (mp->thread_data[i].cpu_socket));
1374 vam->retval = retval;
1375 vam->result_ready = 1;
1378 static void vl_api_show_threads_reply_t_handler_json
1379 (vl_api_show_threads_reply_t * mp)
1381 vat_main_t *vam = &vat_main;
1382 vat_json_node_t node;
1383 vl_api_thread_data_t *td;
1384 i32 retval = ntohl (mp->retval);
1388 count = ntohl (mp->count);
1390 vat_json_init_object (&node);
1391 vat_json_object_add_int (&node, "retval", retval);
1392 vat_json_object_add_uint (&node, "count", count);
1394 for (i = 0; i < count; i++)
1396 td = &mp->thread_data[i];
1397 vat_json_object_add_uint (&node, "id", ntohl (td->id));
1398 vat_json_object_add_string_copy (&node, "name", td->name);
1399 vat_json_object_add_string_copy (&node, "type", td->type);
1400 vat_json_object_add_uint (&node, "pid", ntohl (td->pid));
1401 vat_json_object_add_int (&node, "cpu_id", ntohl (td->cpu_id));
1402 vat_json_object_add_int (&node, "core", ntohl (td->id));
1403 vat_json_object_add_int (&node, "cpu_socket", ntohl (td->cpu_socket));
1406 vat_json_print (vam->ofp, &node);
1407 vat_json_free (&node);
1409 vam->retval = retval;
1410 vam->result_ready = 1;
1414 api_show_threads (vat_main_t * vam)
1416 vl_api_show_threads_t *mp;
1420 "\n%-2s %-11s %-11s %-5s %-6s %-4s %-6s",
1421 "ID", "Name", "Type", "LWP", "cpu_id", "Core", "Socket");
1423 M (SHOW_THREADS, mp);
1431 vl_api_ip4_arp_event_t_handler (vl_api_ip4_arp_event_t * mp)
1433 u32 sw_if_index = ntohl (mp->sw_if_index);
1434 errmsg ("arp %s event: pid %d address %U new mac %U sw_if_index %d\n",
1435 mp->mac_ip ? "mac/ip binding" : "address resolution",
1436 ntohl (mp->pid), format_ip4_address, mp->ip,
1437 format_vl_api_mac_address, &mp->mac, sw_if_index);
1441 vl_api_ip4_arp_event_t_handler_json (vl_api_ip4_arp_event_t * mp)
1443 /* JSON output not supported */
1447 vl_api_ip6_nd_event_t_handler (vl_api_ip6_nd_event_t * mp)
1449 u32 sw_if_index = ntohl (mp->sw_if_index);
1450 errmsg ("ip6 nd %s event: pid %d address %U new mac %U sw_if_index %d\n",
1451 mp->mac_ip ? "mac/ip binding" : "address resolution",
1452 ntohl (mp->pid), format_vl_api_ip6_address, mp->ip,
1453 format_vl_api_mac_address, mp->mac, sw_if_index);
1457 vl_api_ip6_nd_event_t_handler_json (vl_api_ip6_nd_event_t * mp)
1459 /* JSON output not supported */
1463 vl_api_l2_macs_event_t_handler (vl_api_l2_macs_event_t * mp)
1465 u32 n_macs = ntohl (mp->n_macs);
1466 errmsg ("L2MAC event received with pid %d cl-idx %d for %d macs: \n",
1467 ntohl (mp->pid), mp->client_index, n_macs);
1469 for (i = 0; i < n_macs; i++)
1471 vl_api_mac_entry_t *mac = &mp->mac[i];
1472 errmsg (" [%d] sw_if_index %d mac_addr %U action %d \n",
1473 i + 1, ntohl (mac->sw_if_index),
1474 format_ethernet_address, mac->mac_addr, mac->action);
1481 vl_api_l2_macs_event_t_handler_json (vl_api_l2_macs_event_t * mp)
1483 /* JSON output not supported */
1486 #define vl_api_bridge_domain_details_t_endian vl_noop_handler
1487 #define vl_api_bridge_domain_details_t_print vl_noop_handler
1490 * Special-case: build the bridge domain table, maintain
1491 * the next bd id vbl.
1493 static void vl_api_bridge_domain_details_t_handler
1494 (vl_api_bridge_domain_details_t * mp)
1496 vat_main_t *vam = &vat_main;
1497 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1500 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-6s %-3s",
1501 " ID", "LRN", "FWD", "FLD", "BVI", "UU-FWD", "#IF");
1503 print (vam->ofp, "%3d %3d %3d %3d %3d %6d %3d",
1504 ntohl (mp->bd_id), mp->learn, mp->forward,
1505 mp->flood, ntohl (mp->bvi_sw_if_index),
1506 ntohl (mp->uu_fwd_sw_if_index), n_sw_ifs);
1510 vl_api_bridge_domain_sw_if_t *sw_ifs;
1511 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG",
1514 sw_ifs = mp->sw_if_details;
1515 for (i = 0; i < n_sw_ifs; i++)
1521 sw_if_index = ntohl (sw_ifs->sw_if_index);
1524 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1526 if ((u32) p->value[0] == sw_if_index)
1528 sw_if_name = (u8 *)(p->key);
1533 print (vam->ofp, "%7d %3d %s", sw_if_index,
1534 sw_ifs->shg, sw_if_name ? (char *) sw_if_name :
1535 "sw_if_index not found!");
1542 static void vl_api_bridge_domain_details_t_handler_json
1543 (vl_api_bridge_domain_details_t * mp)
1545 vat_main_t *vam = &vat_main;
1546 vat_json_node_t *node, *array = NULL;
1547 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1549 if (VAT_JSON_ARRAY != vam->json_tree.type)
1551 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1552 vat_json_init_array (&vam->json_tree);
1554 node = vat_json_array_add (&vam->json_tree);
1556 vat_json_init_object (node);
1557 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1558 vat_json_object_add_uint (node, "flood", mp->flood);
1559 vat_json_object_add_uint (node, "forward", mp->forward);
1560 vat_json_object_add_uint (node, "learn", mp->learn);
1561 vat_json_object_add_uint (node, "bvi_sw_if_index",
1562 ntohl (mp->bvi_sw_if_index));
1563 vat_json_object_add_uint (node, "n_sw_ifs", n_sw_ifs);
1564 array = vat_json_object_add (node, "sw_if");
1565 vat_json_init_array (array);
1571 vl_api_bridge_domain_sw_if_t *sw_ifs;
1574 sw_ifs = mp->sw_if_details;
1575 for (i = 0; i < n_sw_ifs; i++)
1577 node = vat_json_array_add (array);
1578 vat_json_init_object (node);
1579 vat_json_object_add_uint (node, "sw_if_index",
1580 ntohl (sw_ifs->sw_if_index));
1581 vat_json_object_add_uint (node, "shg", sw_ifs->shg);
1587 static void vl_api_control_ping_reply_t_handler
1588 (vl_api_control_ping_reply_t * mp)
1590 vat_main_t *vam = &vat_main;
1591 i32 retval = ntohl (mp->retval);
1592 if (vam->async_mode)
1594 vam->async_errors += (retval < 0);
1598 vam->retval = retval;
1599 vam->result_ready = 1;
1601 if (vam->socket_client_main)
1602 vam->socket_client_main->control_pings_outstanding--;
1605 static void vl_api_control_ping_reply_t_handler_json
1606 (vl_api_control_ping_reply_t * mp)
1608 vat_main_t *vam = &vat_main;
1609 i32 retval = ntohl (mp->retval);
1611 if (VAT_JSON_NONE != vam->json_tree.type)
1613 vat_json_print (vam->ofp, &vam->json_tree);
1614 vat_json_free (&vam->json_tree);
1615 vam->json_tree.type = VAT_JSON_NONE;
1620 vat_json_init_array (&vam->json_tree);
1621 vat_json_print (vam->ofp, &vam->json_tree);
1622 vam->json_tree.type = VAT_JSON_NONE;
1625 vam->retval = retval;
1626 vam->result_ready = 1;
1630 vl_api_bridge_domain_set_mac_age_reply_t_handler
1631 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1633 vat_main_t *vam = &vat_main;
1634 i32 retval = ntohl (mp->retval);
1635 if (vam->async_mode)
1637 vam->async_errors += (retval < 0);
1641 vam->retval = retval;
1642 vam->result_ready = 1;
1646 static void vl_api_bridge_domain_set_mac_age_reply_t_handler_json
1647 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1649 vat_main_t *vam = &vat_main;
1650 vat_json_node_t node;
1652 vat_json_init_object (&node);
1653 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1655 vat_json_print (vam->ofp, &node);
1656 vat_json_free (&node);
1658 vam->retval = ntohl (mp->retval);
1659 vam->result_ready = 1;
1663 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1665 vat_main_t *vam = &vat_main;
1666 i32 retval = ntohl (mp->retval);
1667 if (vam->async_mode)
1669 vam->async_errors += (retval < 0);
1673 vam->retval = retval;
1674 vam->result_ready = 1;
1678 static void vl_api_l2_flags_reply_t_handler_json
1679 (vl_api_l2_flags_reply_t * mp)
1681 vat_main_t *vam = &vat_main;
1682 vat_json_node_t node;
1684 vat_json_init_object (&node);
1685 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1686 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1687 ntohl (mp->resulting_feature_bitmap));
1689 vat_json_print (vam->ofp, &node);
1690 vat_json_free (&node);
1692 vam->retval = ntohl (mp->retval);
1693 vam->result_ready = 1;
1696 static void vl_api_bridge_flags_reply_t_handler
1697 (vl_api_bridge_flags_reply_t * mp)
1699 vat_main_t *vam = &vat_main;
1700 i32 retval = ntohl (mp->retval);
1701 if (vam->async_mode)
1703 vam->async_errors += (retval < 0);
1707 vam->retval = retval;
1708 vam->result_ready = 1;
1712 static void vl_api_bridge_flags_reply_t_handler_json
1713 (vl_api_bridge_flags_reply_t * mp)
1715 vat_main_t *vam = &vat_main;
1716 vat_json_node_t node;
1718 vat_json_init_object (&node);
1719 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1720 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1721 ntohl (mp->resulting_feature_bitmap));
1723 vat_json_print (vam->ofp, &node);
1724 vat_json_free (&node);
1726 vam->retval = ntohl (mp->retval);
1727 vam->result_ready = 1;
1731 vl_api_tap_create_v2_reply_t_handler (vl_api_tap_create_v2_reply_t * mp)
1733 vat_main_t *vam = &vat_main;
1734 i32 retval = ntohl (mp->retval);
1735 if (vam->async_mode)
1737 vam->async_errors += (retval < 0);
1741 vam->retval = retval;
1742 vam->sw_if_index = ntohl (mp->sw_if_index);
1743 vam->result_ready = 1;
1748 static void vl_api_tap_create_v2_reply_t_handler_json
1749 (vl_api_tap_create_v2_reply_t * mp)
1751 vat_main_t *vam = &vat_main;
1752 vat_json_node_t node;
1754 vat_json_init_object (&node);
1755 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1756 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1758 vat_json_print (vam->ofp, &node);
1759 vat_json_free (&node);
1761 vam->retval = ntohl (mp->retval);
1762 vam->result_ready = 1;
1767 vl_api_tap_delete_v2_reply_t_handler (vl_api_tap_delete_v2_reply_t * mp)
1769 vat_main_t *vam = &vat_main;
1770 i32 retval = ntohl (mp->retval);
1771 if (vam->async_mode)
1773 vam->async_errors += (retval < 0);
1777 vam->retval = retval;
1778 vam->result_ready = 1;
1782 static void vl_api_tap_delete_v2_reply_t_handler_json
1783 (vl_api_tap_delete_v2_reply_t * mp)
1785 vat_main_t *vam = &vat_main;
1786 vat_json_node_t node;
1788 vat_json_init_object (&node);
1789 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1791 vat_json_print (vam->ofp, &node);
1792 vat_json_free (&node);
1794 vam->retval = ntohl (mp->retval);
1795 vam->result_ready = 1;
1799 vl_api_virtio_pci_create_reply_t_handler (vl_api_virtio_pci_create_reply_t *
1802 vat_main_t *vam = &vat_main;
1803 i32 retval = ntohl (mp->retval);
1804 if (vam->async_mode)
1806 vam->async_errors += (retval < 0);
1810 vam->retval = retval;
1811 vam->sw_if_index = ntohl (mp->sw_if_index);
1812 vam->result_ready = 1;
1816 static void vl_api_virtio_pci_create_reply_t_handler_json
1817 (vl_api_virtio_pci_create_reply_t * mp)
1819 vat_main_t *vam = &vat_main;
1820 vat_json_node_t node;
1822 vat_json_init_object (&node);
1823 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1824 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1826 vat_json_print (vam->ofp, &node);
1827 vat_json_free (&node);
1829 vam->retval = ntohl (mp->retval);
1830 vam->result_ready = 1;
1835 vl_api_virtio_pci_delete_reply_t_handler (vl_api_virtio_pci_delete_reply_t *
1838 vat_main_t *vam = &vat_main;
1839 i32 retval = ntohl (mp->retval);
1840 if (vam->async_mode)
1842 vam->async_errors += (retval < 0);
1846 vam->retval = retval;
1847 vam->result_ready = 1;
1851 static void vl_api_virtio_pci_delete_reply_t_handler_json
1852 (vl_api_virtio_pci_delete_reply_t * mp)
1854 vat_main_t *vam = &vat_main;
1855 vat_json_node_t node;
1857 vat_json_init_object (&node);
1858 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1860 vat_json_print (vam->ofp, &node);
1861 vat_json_free (&node);
1863 vam->retval = ntohl (mp->retval);
1864 vam->result_ready = 1;
1868 vl_api_bond_create_reply_t_handler (vl_api_bond_create_reply_t * mp)
1870 vat_main_t *vam = &vat_main;
1871 i32 retval = ntohl (mp->retval);
1873 if (vam->async_mode)
1875 vam->async_errors += (retval < 0);
1879 vam->retval = retval;
1880 vam->sw_if_index = ntohl (mp->sw_if_index);
1881 vam->result_ready = 1;
1885 static void vl_api_bond_create_reply_t_handler_json
1886 (vl_api_bond_create_reply_t * mp)
1888 vat_main_t *vam = &vat_main;
1889 vat_json_node_t node;
1891 vat_json_init_object (&node);
1892 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1893 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1895 vat_json_print (vam->ofp, &node);
1896 vat_json_free (&node);
1898 vam->retval = ntohl (mp->retval);
1899 vam->result_ready = 1;
1903 vl_api_bond_delete_reply_t_handler (vl_api_bond_delete_reply_t * mp)
1905 vat_main_t *vam = &vat_main;
1906 i32 retval = ntohl (mp->retval);
1908 if (vam->async_mode)
1910 vam->async_errors += (retval < 0);
1914 vam->retval = retval;
1915 vam->result_ready = 1;
1919 static void vl_api_bond_delete_reply_t_handler_json
1920 (vl_api_bond_delete_reply_t * mp)
1922 vat_main_t *vam = &vat_main;
1923 vat_json_node_t node;
1925 vat_json_init_object (&node);
1926 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1928 vat_json_print (vam->ofp, &node);
1929 vat_json_free (&node);
1931 vam->retval = ntohl (mp->retval);
1932 vam->result_ready = 1;
1936 vl_api_bond_enslave_reply_t_handler (vl_api_bond_enslave_reply_t * mp)
1938 vat_main_t *vam = &vat_main;
1939 i32 retval = ntohl (mp->retval);
1941 if (vam->async_mode)
1943 vam->async_errors += (retval < 0);
1947 vam->retval = retval;
1948 vam->result_ready = 1;
1952 static void vl_api_bond_enslave_reply_t_handler_json
1953 (vl_api_bond_enslave_reply_t * mp)
1955 vat_main_t *vam = &vat_main;
1956 vat_json_node_t node;
1958 vat_json_init_object (&node);
1959 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1961 vat_json_print (vam->ofp, &node);
1962 vat_json_free (&node);
1964 vam->retval = ntohl (mp->retval);
1965 vam->result_ready = 1;
1969 vl_api_bond_detach_slave_reply_t_handler (vl_api_bond_detach_slave_reply_t *
1972 vat_main_t *vam = &vat_main;
1973 i32 retval = ntohl (mp->retval);
1975 if (vam->async_mode)
1977 vam->async_errors += (retval < 0);
1981 vam->retval = retval;
1982 vam->result_ready = 1;
1986 static void vl_api_bond_detach_slave_reply_t_handler_json
1987 (vl_api_bond_detach_slave_reply_t * mp)
1989 vat_main_t *vam = &vat_main;
1990 vat_json_node_t node;
1992 vat_json_init_object (&node);
1993 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1995 vat_json_print (vam->ofp, &node);
1996 vat_json_free (&node);
1998 vam->retval = ntohl (mp->retval);
1999 vam->result_ready = 1;
2002 static void vl_api_sw_interface_bond_details_t_handler
2003 (vl_api_sw_interface_bond_details_t * mp)
2005 vat_main_t *vam = &vat_main;
2008 "%-16s %-12d %-12U %-13U %-14u %-14u",
2009 mp->interface_name, ntohl (mp->sw_if_index),
2010 format_bond_mode, mp->mode, format_bond_load_balance, mp->lb,
2011 ntohl (mp->active_slaves), ntohl (mp->slaves));
2014 static void vl_api_sw_interface_bond_details_t_handler_json
2015 (vl_api_sw_interface_bond_details_t * mp)
2017 vat_main_t *vam = &vat_main;
2018 vat_json_node_t *node = NULL;
2020 if (VAT_JSON_ARRAY != vam->json_tree.type)
2022 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2023 vat_json_init_array (&vam->json_tree);
2025 node = vat_json_array_add (&vam->json_tree);
2027 vat_json_init_object (node);
2028 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2029 vat_json_object_add_string_copy (node, "interface_name",
2030 mp->interface_name);
2031 vat_json_object_add_uint (node, "mode", mp->mode);
2032 vat_json_object_add_uint (node, "load_balance", mp->lb);
2033 vat_json_object_add_uint (node, "active_slaves", ntohl (mp->active_slaves));
2034 vat_json_object_add_uint (node, "slaves", ntohl (mp->slaves));
2038 api_sw_interface_bond_dump (vat_main_t * vam)
2040 vl_api_sw_interface_bond_dump_t *mp;
2041 vl_api_control_ping_t *mp_ping;
2045 "\n%-16s %-12s %-12s %-13s %-14s %-14s",
2046 "interface name", "sw_if_index", "mode", "load balance",
2047 "active slaves", "slaves");
2049 /* Get list of bond interfaces */
2050 M (SW_INTERFACE_BOND_DUMP, mp);
2053 /* Use a control ping for synchronization */
2054 MPING (CONTROL_PING, mp_ping);
2061 static void vl_api_sw_interface_slave_details_t_handler
2062 (vl_api_sw_interface_slave_details_t * mp)
2064 vat_main_t *vam = &vat_main;
2067 "%-25s %-12d %-12d %d", mp->interface_name,
2068 ntohl (mp->sw_if_index), mp->is_passive, mp->is_long_timeout);
2071 static void vl_api_sw_interface_slave_details_t_handler_json
2072 (vl_api_sw_interface_slave_details_t * mp)
2074 vat_main_t *vam = &vat_main;
2075 vat_json_node_t *node = NULL;
2077 if (VAT_JSON_ARRAY != vam->json_tree.type)
2079 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2080 vat_json_init_array (&vam->json_tree);
2082 node = vat_json_array_add (&vam->json_tree);
2084 vat_json_init_object (node);
2085 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2086 vat_json_object_add_string_copy (node, "interface_name",
2087 mp->interface_name);
2088 vat_json_object_add_uint (node, "passive", mp->is_passive);
2089 vat_json_object_add_uint (node, "long_timeout", mp->is_long_timeout);
2093 api_sw_interface_slave_dump (vat_main_t * vam)
2095 unformat_input_t *i = vam->input;
2096 vl_api_sw_interface_slave_dump_t *mp;
2097 vl_api_control_ping_t *mp_ping;
2098 u32 sw_if_index = ~0;
2099 u8 sw_if_index_set = 0;
2102 /* Parse args required to build the message */
2103 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2105 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2106 sw_if_index_set = 1;
2107 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2108 sw_if_index_set = 1;
2113 if (sw_if_index_set == 0)
2115 errmsg ("missing vpp interface name. ");
2120 "\n%-25s %-12s %-12s %s",
2121 "slave interface name", "sw_if_index", "passive", "long_timeout");
2123 /* Get list of bond interfaces */
2124 M (SW_INTERFACE_SLAVE_DUMP, mp);
2125 mp->sw_if_index = ntohl (sw_if_index);
2128 /* Use a control ping for synchronization */
2129 MPING (CONTROL_PING, mp_ping);
2136 static void vl_api_mpls_tunnel_add_del_reply_t_handler
2137 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2139 vat_main_t *vam = &vat_main;
2140 i32 retval = ntohl (mp->retval);
2141 if (vam->async_mode)
2143 vam->async_errors += (retval < 0);
2147 vam->retval = retval;
2148 vam->sw_if_index = ntohl (mp->sw_if_index);
2149 vam->result_ready = 1;
2151 vam->regenerate_interface_table = 1;
2154 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
2155 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2157 vat_main_t *vam = &vat_main;
2158 vat_json_node_t node;
2160 vat_json_init_object (&node);
2161 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2162 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
2163 ntohl (mp->sw_if_index));
2165 vat_json_print (vam->ofp, &node);
2166 vat_json_free (&node);
2168 vam->retval = ntohl (mp->retval);
2169 vam->result_ready = 1;
2172 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
2173 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2175 vat_main_t *vam = &vat_main;
2176 i32 retval = ntohl (mp->retval);
2177 if (vam->async_mode)
2179 vam->async_errors += (retval < 0);
2183 vam->retval = retval;
2184 vam->sw_if_index = ntohl (mp->sw_if_index);
2185 vam->result_ready = 1;
2189 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
2190 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2192 vat_main_t *vam = &vat_main;
2193 vat_json_node_t node;
2195 vat_json_init_object (&node);
2196 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2197 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2199 vat_json_print (vam->ofp, &node);
2200 vat_json_free (&node);
2202 vam->retval = ntohl (mp->retval);
2203 vam->result_ready = 1;
2206 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler
2207 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2209 vat_main_t *vam = &vat_main;
2210 i32 retval = ntohl (mp->retval);
2211 if (vam->async_mode)
2213 vam->async_errors += (retval < 0);
2217 vam->retval = retval;
2218 vam->result_ready = 1;
2222 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler_json
2223 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2225 vat_main_t *vam = &vat_main;
2226 vat_json_node_t node;
2228 vat_json_init_object (&node);
2229 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2230 vat_json_object_add_uint (&node, "fwd_entry_index",
2231 clib_net_to_host_u32 (mp->fwd_entry_index));
2233 vat_json_print (vam->ofp, &node);
2234 vat_json_free (&node);
2236 vam->retval = ntohl (mp->retval);
2237 vam->result_ready = 1;
2241 format_lisp_transport_protocol (u8 * s, va_list * args)
2243 u32 proto = va_arg (*args, u32);
2248 return format (s, "udp");
2250 return format (s, "api");
2257 static void vl_api_one_get_transport_protocol_reply_t_handler
2258 (vl_api_one_get_transport_protocol_reply_t * mp)
2260 vat_main_t *vam = &vat_main;
2261 i32 retval = ntohl (mp->retval);
2262 if (vam->async_mode)
2264 vam->async_errors += (retval < 0);
2268 u32 proto = mp->protocol;
2269 print (vam->ofp, "Transport protocol: %U",
2270 format_lisp_transport_protocol, proto);
2271 vam->retval = retval;
2272 vam->result_ready = 1;
2276 static void vl_api_one_get_transport_protocol_reply_t_handler_json
2277 (vl_api_one_get_transport_protocol_reply_t * mp)
2279 vat_main_t *vam = &vat_main;
2280 vat_json_node_t node;
2283 s = format (0, "%U", format_lisp_transport_protocol, mp->protocol);
2286 vat_json_init_object (&node);
2287 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2288 vat_json_object_add_string_copy (&node, "transport-protocol", s);
2291 vat_json_print (vam->ofp, &node);
2292 vat_json_free (&node);
2294 vam->retval = ntohl (mp->retval);
2295 vam->result_ready = 1;
2298 static void vl_api_one_add_del_locator_set_reply_t_handler
2299 (vl_api_one_add_del_locator_set_reply_t * mp)
2301 vat_main_t *vam = &vat_main;
2302 i32 retval = ntohl (mp->retval);
2303 if (vam->async_mode)
2305 vam->async_errors += (retval < 0);
2309 vam->retval = retval;
2310 vam->result_ready = 1;
2314 static void vl_api_one_add_del_locator_set_reply_t_handler_json
2315 (vl_api_one_add_del_locator_set_reply_t * mp)
2317 vat_main_t *vam = &vat_main;
2318 vat_json_node_t node;
2320 vat_json_init_object (&node);
2321 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2322 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
2324 vat_json_print (vam->ofp, &node);
2325 vat_json_free (&node);
2327 vam->retval = ntohl (mp->retval);
2328 vam->result_ready = 1;
2331 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
2332 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2334 vat_main_t *vam = &vat_main;
2335 i32 retval = ntohl (mp->retval);
2336 if (vam->async_mode)
2338 vam->async_errors += (retval < 0);
2342 vam->retval = retval;
2343 vam->sw_if_index = ntohl (mp->sw_if_index);
2344 vam->result_ready = 1;
2346 vam->regenerate_interface_table = 1;
2349 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
2350 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2352 vat_main_t *vam = &vat_main;
2353 vat_json_node_t node;
2355 vat_json_init_object (&node);
2356 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2357 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2359 vat_json_print (vam->ofp, &node);
2360 vat_json_free (&node);
2362 vam->retval = ntohl (mp->retval);
2363 vam->result_ready = 1;
2366 static void vl_api_vxlan_offload_rx_reply_t_handler
2367 (vl_api_vxlan_offload_rx_reply_t * mp)
2369 vat_main_t *vam = &vat_main;
2370 i32 retval = ntohl (mp->retval);
2371 if (vam->async_mode)
2373 vam->async_errors += (retval < 0);
2377 vam->retval = retval;
2378 vam->result_ready = 1;
2382 static void vl_api_vxlan_offload_rx_reply_t_handler_json
2383 (vl_api_vxlan_offload_rx_reply_t * mp)
2385 vat_main_t *vam = &vat_main;
2386 vat_json_node_t node;
2388 vat_json_init_object (&node);
2389 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2391 vat_json_print (vam->ofp, &node);
2392 vat_json_free (&node);
2394 vam->retval = ntohl (mp->retval);
2395 vam->result_ready = 1;
2398 static void vl_api_geneve_add_del_tunnel_reply_t_handler
2399 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2401 vat_main_t *vam = &vat_main;
2402 i32 retval = ntohl (mp->retval);
2403 if (vam->async_mode)
2405 vam->async_errors += (retval < 0);
2409 vam->retval = retval;
2410 vam->sw_if_index = ntohl (mp->sw_if_index);
2411 vam->result_ready = 1;
2415 static void vl_api_geneve_add_del_tunnel_reply_t_handler_json
2416 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2418 vat_main_t *vam = &vat_main;
2419 vat_json_node_t node;
2421 vat_json_init_object (&node);
2422 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2423 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2425 vat_json_print (vam->ofp, &node);
2426 vat_json_free (&node);
2428 vam->retval = ntohl (mp->retval);
2429 vam->result_ready = 1;
2432 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler
2433 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2435 vat_main_t *vam = &vat_main;
2436 i32 retval = ntohl (mp->retval);
2437 if (vam->async_mode)
2439 vam->async_errors += (retval < 0);
2443 vam->retval = retval;
2444 vam->sw_if_index = ntohl (mp->sw_if_index);
2445 vam->result_ready = 1;
2447 vam->regenerate_interface_table = 1;
2450 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler_json
2451 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2453 vat_main_t *vam = &vat_main;
2454 vat_json_node_t node;
2456 vat_json_init_object (&node);
2457 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2458 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2460 vat_json_print (vam->ofp, &node);
2461 vat_json_free (&node);
2463 vam->retval = ntohl (mp->retval);
2464 vam->result_ready = 1;
2467 static void vl_api_gre_tunnel_add_del_reply_t_handler
2468 (vl_api_gre_tunnel_add_del_reply_t * mp)
2470 vat_main_t *vam = &vat_main;
2471 i32 retval = ntohl (mp->retval);
2472 if (vam->async_mode)
2474 vam->async_errors += (retval < 0);
2478 vam->retval = retval;
2479 vam->sw_if_index = ntohl (mp->sw_if_index);
2480 vam->result_ready = 1;
2484 static void vl_api_gre_tunnel_add_del_reply_t_handler_json
2485 (vl_api_gre_tunnel_add_del_reply_t * mp)
2487 vat_main_t *vam = &vat_main;
2488 vat_json_node_t node;
2490 vat_json_init_object (&node);
2491 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2492 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2494 vat_json_print (vam->ofp, &node);
2495 vat_json_free (&node);
2497 vam->retval = ntohl (mp->retval);
2498 vam->result_ready = 1;
2501 static void vl_api_create_vhost_user_if_reply_t_handler
2502 (vl_api_create_vhost_user_if_reply_t * mp)
2504 vat_main_t *vam = &vat_main;
2505 i32 retval = ntohl (mp->retval);
2506 if (vam->async_mode)
2508 vam->async_errors += (retval < 0);
2512 vam->retval = retval;
2513 vam->sw_if_index = ntohl (mp->sw_if_index);
2514 vam->result_ready = 1;
2516 vam->regenerate_interface_table = 1;
2519 static void vl_api_create_vhost_user_if_reply_t_handler_json
2520 (vl_api_create_vhost_user_if_reply_t * mp)
2522 vat_main_t *vam = &vat_main;
2523 vat_json_node_t node;
2525 vat_json_init_object (&node);
2526 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2527 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2529 vat_json_print (vam->ofp, &node);
2530 vat_json_free (&node);
2532 vam->retval = ntohl (mp->retval);
2533 vam->result_ready = 1;
2536 static void vl_api_ip_address_details_t_handler
2537 (vl_api_ip_address_details_t * mp)
2539 vat_main_t *vam = &vat_main;
2540 static ip_address_details_t empty_ip_address_details = { {0} };
2541 ip_address_details_t *address = NULL;
2542 ip_details_t *current_ip_details = NULL;
2543 ip_details_t *details = NULL;
2545 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
2547 if (!details || vam->current_sw_if_index >= vec_len (details)
2548 || !details[vam->current_sw_if_index].present)
2550 errmsg ("ip address details arrived but not stored");
2551 errmsg ("ip_dump should be called first");
2555 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
2557 #define addresses (current_ip_details->addr)
2559 vec_validate_init_empty (addresses, vec_len (addresses),
2560 empty_ip_address_details);
2562 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
2564 clib_memcpy (&address->ip, &mp->prefix.address.un, sizeof (address->ip));
2565 address->prefix_length = mp->prefix.len;
2569 static void vl_api_ip_address_details_t_handler_json
2570 (vl_api_ip_address_details_t * mp)
2572 vat_main_t *vam = &vat_main;
2573 vat_json_node_t *node = NULL;
2575 if (VAT_JSON_ARRAY != vam->json_tree.type)
2577 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2578 vat_json_init_array (&vam->json_tree);
2580 node = vat_json_array_add (&vam->json_tree);
2582 vat_json_init_object (node);
2583 vat_json_object_add_prefix (node, &mp->prefix);
2587 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
2589 vat_main_t *vam = &vat_main;
2590 static ip_details_t empty_ip_details = { 0 };
2591 ip_details_t *ip = NULL;
2592 u32 sw_if_index = ~0;
2594 sw_if_index = ntohl (mp->sw_if_index);
2596 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2597 sw_if_index, empty_ip_details);
2599 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2606 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
2608 vat_main_t *vam = &vat_main;
2610 if (VAT_JSON_ARRAY != vam->json_tree.type)
2612 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2613 vat_json_init_array (&vam->json_tree);
2615 vat_json_array_add_uint (&vam->json_tree,
2616 clib_net_to_host_u32 (mp->sw_if_index));
2620 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
2624 s = format (0, "DHCP compl event: pid %d %s hostname %s host_addr %U "
2625 "host_mac %U router_addr %U",
2626 ntohl (mp->pid), mp->lease.is_ipv6 ? "ipv6" : "ipv4",
2628 format_ip4_address, mp->lease.host_address,
2629 format_ethernet_address, mp->lease.host_mac,
2630 format_ip4_address, mp->lease.router_address);
2632 for (i = 0; i < mp->lease.count; i++)
2634 format (s, " domain_server_addr %U", format_ip4_address,
2635 mp->lease.domain_server[i].address);
2637 errmsg ((char *) s);
2641 static void vl_api_dhcp_compl_event_t_handler_json
2642 (vl_api_dhcp_compl_event_t * mp)
2644 /* JSON output not supported */
2647 static void vl_api_get_first_msg_id_reply_t_handler
2648 (vl_api_get_first_msg_id_reply_t * mp)
2650 vat_main_t *vam = &vat_main;
2651 i32 retval = ntohl (mp->retval);
2653 if (vam->async_mode)
2655 vam->async_errors += (retval < 0);
2659 vam->retval = retval;
2660 vam->result_ready = 1;
2664 errmsg ("first message id %d", ntohs (mp->first_msg_id));
2668 static void vl_api_get_first_msg_id_reply_t_handler_json
2669 (vl_api_get_first_msg_id_reply_t * mp)
2671 vat_main_t *vam = &vat_main;
2672 vat_json_node_t node;
2674 vat_json_init_object (&node);
2675 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2676 vat_json_object_add_uint (&node, "first_msg_id",
2677 (uint) ntohs (mp->first_msg_id));
2679 vat_json_print (vam->ofp, &node);
2680 vat_json_free (&node);
2682 vam->retval = ntohl (mp->retval);
2683 vam->result_ready = 1;
2686 static void vl_api_get_node_graph_reply_t_handler
2687 (vl_api_get_node_graph_reply_t * mp)
2689 vat_main_t *vam = &vat_main;
2690 api_main_t *am = &api_main;
2691 i32 retval = ntohl (mp->retval);
2692 u8 *pvt_copy, *reply;
2697 if (vam->async_mode)
2699 vam->async_errors += (retval < 0);
2703 vam->retval = retval;
2704 vam->result_ready = 1;
2707 /* "Should never happen..." */
2711 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2712 pvt_copy = vec_dup (reply);
2714 /* Toss the shared-memory original... */
2715 pthread_mutex_lock (&am->vlib_rp->mutex);
2716 oldheap = svm_push_data_heap (am->vlib_rp);
2720 svm_pop_heap (oldheap);
2721 pthread_mutex_unlock (&am->vlib_rp->mutex);
2723 if (vam->graph_nodes)
2725 hash_free (vam->graph_node_index_by_name);
2727 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2729 node = vam->graph_nodes[0][i];
2730 vec_free (node->name);
2731 vec_free (node->next_nodes);
2734 vec_free (vam->graph_nodes[0]);
2735 vec_free (vam->graph_nodes);
2738 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2739 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2740 vec_free (pvt_copy);
2742 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2744 node = vam->graph_nodes[0][i];
2745 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2749 static void vl_api_get_node_graph_reply_t_handler_json
2750 (vl_api_get_node_graph_reply_t * mp)
2752 vat_main_t *vam = &vat_main;
2753 api_main_t *am = &api_main;
2755 vat_json_node_t node;
2758 /* $$$$ make this real? */
2759 vat_json_init_object (&node);
2760 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2761 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2763 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2765 /* Toss the shared-memory original... */
2766 pthread_mutex_lock (&am->vlib_rp->mutex);
2767 oldheap = svm_push_data_heap (am->vlib_rp);
2771 svm_pop_heap (oldheap);
2772 pthread_mutex_unlock (&am->vlib_rp->mutex);
2774 vat_json_print (vam->ofp, &node);
2775 vat_json_free (&node);
2777 vam->retval = ntohl (mp->retval);
2778 vam->result_ready = 1;
2782 vl_api_one_locator_details_t_handler (vl_api_one_locator_details_t * mp)
2784 vat_main_t *vam = &vat_main;
2789 s = format (s, "%=16d%=16d%=16d",
2790 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2794 s = format (s, "%=16U%=16d%=16d",
2795 mp->is_ipv6 ? format_ip6_address :
2797 mp->ip_address, mp->priority, mp->weight);
2800 print (vam->ofp, "%v", s);
2805 vl_api_one_locator_details_t_handler_json (vl_api_one_locator_details_t * mp)
2807 vat_main_t *vam = &vat_main;
2808 vat_json_node_t *node = NULL;
2809 struct in6_addr ip6;
2812 if (VAT_JSON_ARRAY != vam->json_tree.type)
2814 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2815 vat_json_init_array (&vam->json_tree);
2817 node = vat_json_array_add (&vam->json_tree);
2818 vat_json_init_object (node);
2820 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2821 vat_json_object_add_uint (node, "priority", mp->priority);
2822 vat_json_object_add_uint (node, "weight", mp->weight);
2825 vat_json_object_add_uint (node, "sw_if_index",
2826 clib_net_to_host_u32 (mp->sw_if_index));
2831 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2832 vat_json_object_add_ip6 (node, "address", ip6);
2836 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2837 vat_json_object_add_ip4 (node, "address", ip4);
2843 vl_api_one_locator_set_details_t_handler (vl_api_one_locator_set_details_t *
2846 vat_main_t *vam = &vat_main;
2849 ls_name = format (0, "%s", mp->ls_name);
2851 print (vam->ofp, "%=10d%=15v", clib_net_to_host_u32 (mp->ls_index),
2857 vl_api_one_locator_set_details_t_handler_json
2858 (vl_api_one_locator_set_details_t * mp)
2860 vat_main_t *vam = &vat_main;
2861 vat_json_node_t *node = 0;
2864 ls_name = format (0, "%s", mp->ls_name);
2865 vec_add1 (ls_name, 0);
2867 if (VAT_JSON_ARRAY != vam->json_tree.type)
2869 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2870 vat_json_init_array (&vam->json_tree);
2872 node = vat_json_array_add (&vam->json_tree);
2874 vat_json_init_object (node);
2875 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2876 vat_json_object_add_uint (node, "ls_index",
2877 clib_net_to_host_u32 (mp->ls_index));
2885 } __attribute__ ((__packed__)) lisp_nsh_api_t;
2888 unformat_nsh_address (unformat_input_t * input, va_list * args)
2890 lisp_nsh_api_t *nsh = va_arg (*args, lisp_nsh_api_t *);
2891 return unformat (input, "SPI:%d SI:%d", &nsh->spi, &nsh->si);
2895 format_nsh_address_vat (u8 * s, va_list * args)
2897 nsh_t *a = va_arg (*args, nsh_t *);
2898 return format (s, "SPI:%d SI:%d", clib_net_to_host_u32 (a->spi), a->si);
2902 format_lisp_flat_eid (u8 * s, va_list * args)
2904 u32 type = va_arg (*args, u32);
2905 u8 *eid = va_arg (*args, u8 *);
2906 u32 eid_len = va_arg (*args, u32);
2911 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
2913 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
2915 return format (s, "%U", format_ethernet_address, eid);
2917 return format (s, "%U", format_nsh_address_vat, eid);
2923 format_lisp_eid_vat (u8 * s, va_list * args)
2925 u32 type = va_arg (*args, u32);
2926 u8 *eid = va_arg (*args, u8 *);
2927 u32 eid_len = va_arg (*args, u32);
2928 u8 *seid = va_arg (*args, u8 *);
2929 u32 seid_len = va_arg (*args, u32);
2930 u32 is_src_dst = va_arg (*args, u32);
2933 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
2935 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
2941 vl_api_one_eid_table_details_t_handler (vl_api_one_eid_table_details_t * mp)
2943 vat_main_t *vam = &vat_main;
2944 u8 *s = 0, *eid = 0;
2946 if (~0 == mp->locator_set_index)
2947 s = format (0, "action: %d", mp->action);
2949 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
2951 eid = format (0, "%U", format_lisp_eid_vat,
2955 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2958 print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
2959 clib_net_to_host_u32 (mp->vni),
2961 mp->is_local ? "local" : "remote",
2962 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
2963 clib_net_to_host_u16 (mp->key_id), mp->key);
2970 vl_api_one_eid_table_details_t_handler_json (vl_api_one_eid_table_details_t
2973 vat_main_t *vam = &vat_main;
2974 vat_json_node_t *node = 0;
2977 if (VAT_JSON_ARRAY != vam->json_tree.type)
2979 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2980 vat_json_init_array (&vam->json_tree);
2982 node = vat_json_array_add (&vam->json_tree);
2984 vat_json_init_object (node);
2985 if (~0 == mp->locator_set_index)
2986 vat_json_object_add_uint (node, "action", mp->action);
2988 vat_json_object_add_uint (node, "locator_set_index",
2989 clib_net_to_host_u32 (mp->locator_set_index));
2991 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
2992 if (mp->eid_type == 3)
2994 vat_json_node_t *nsh_json = vat_json_object_add (node, "eid");
2995 vat_json_init_object (nsh_json);
2996 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) mp->eid;
2997 vat_json_object_add_uint (nsh_json, "spi",
2998 clib_net_to_host_u32 (nsh->spi));
2999 vat_json_object_add_uint (nsh_json, "si", nsh->si);
3003 eid = format (0, "%U", format_lisp_eid_vat,
3007 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
3009 vat_json_object_add_string_copy (node, "eid", eid);
3012 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3013 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
3014 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
3018 vat_json_object_add_uint (node, "key_id",
3019 clib_net_to_host_u16 (mp->key_id));
3020 vat_json_object_add_string_copy (node, "key", mp->key);
3025 vl_api_one_stats_details_t_handler (vl_api_one_stats_details_t * mp)
3027 vat_main_t *vam = &vat_main;
3028 u8 *seid = 0, *deid = 0;
3029 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3031 deid = format (0, "%U", format_lisp_eid_vat,
3032 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3034 seid = format (0, "%U", format_lisp_eid_vat,
3035 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3041 format_ip_address_fcn = format_ip4_address;
3043 format_ip_address_fcn = format_ip6_address;
3046 print (vam->ofp, "([%d] %s %s) (%U %U) %u %u",
3047 clib_net_to_host_u32 (mp->vni),
3049 format_ip_address_fcn, mp->lloc,
3050 format_ip_address_fcn, mp->rloc,
3051 clib_net_to_host_u32 (mp->pkt_count),
3052 clib_net_to_host_u32 (mp->bytes));
3059 vl_api_one_stats_details_t_handler_json (vl_api_one_stats_details_t * mp)
3061 struct in6_addr ip6;
3063 vat_main_t *vam = &vat_main;
3064 vat_json_node_t *node = 0;
3065 u8 *deid = 0, *seid = 0;
3067 if (VAT_JSON_ARRAY != vam->json_tree.type)
3069 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3070 vat_json_init_array (&vam->json_tree);
3072 node = vat_json_array_add (&vam->json_tree);
3074 vat_json_init_object (node);
3075 deid = format (0, "%U", format_lisp_eid_vat,
3076 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3078 seid = format (0, "%U", format_lisp_eid_vat,
3079 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3084 vat_json_object_add_string_copy (node, "seid", seid);
3085 vat_json_object_add_string_copy (node, "deid", deid);
3086 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3090 clib_memcpy (&ip4, mp->lloc, sizeof (ip4));
3091 vat_json_object_add_ip4 (node, "lloc", ip4);
3092 clib_memcpy (&ip4, mp->rloc, sizeof (ip4));
3093 vat_json_object_add_ip4 (node, "rloc", ip4);
3097 clib_memcpy (&ip6, mp->lloc, sizeof (ip6));
3098 vat_json_object_add_ip6 (node, "lloc", ip6);
3099 clib_memcpy (&ip6, mp->rloc, sizeof (ip6));
3100 vat_json_object_add_ip6 (node, "rloc", ip6);
3102 vat_json_object_add_uint (node, "pkt_count",
3103 clib_net_to_host_u32 (mp->pkt_count));
3104 vat_json_object_add_uint (node, "bytes", clib_net_to_host_u32 (mp->bytes));
3111 vl_api_one_eid_table_map_details_t_handler
3112 (vl_api_one_eid_table_map_details_t * mp)
3114 vat_main_t *vam = &vat_main;
3116 u8 *line = format (0, "%=10d%=10d",
3117 clib_net_to_host_u32 (mp->vni),
3118 clib_net_to_host_u32 (mp->dp_table));
3119 print (vam->ofp, "%v", line);
3124 vl_api_one_eid_table_map_details_t_handler_json
3125 (vl_api_one_eid_table_map_details_t * mp)
3127 vat_main_t *vam = &vat_main;
3128 vat_json_node_t *node = NULL;
3130 if (VAT_JSON_ARRAY != vam->json_tree.type)
3132 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3133 vat_json_init_array (&vam->json_tree);
3135 node = vat_json_array_add (&vam->json_tree);
3136 vat_json_init_object (node);
3137 vat_json_object_add_uint (node, "dp_table",
3138 clib_net_to_host_u32 (mp->dp_table));
3139 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3143 vl_api_one_eid_table_vni_details_t_handler
3144 (vl_api_one_eid_table_vni_details_t * mp)
3146 vat_main_t *vam = &vat_main;
3148 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
3149 print (vam->ofp, "%v", line);
3154 vl_api_one_eid_table_vni_details_t_handler_json
3155 (vl_api_one_eid_table_vni_details_t * mp)
3157 vat_main_t *vam = &vat_main;
3158 vat_json_node_t *node = NULL;
3160 if (VAT_JSON_ARRAY != vam->json_tree.type)
3162 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3163 vat_json_init_array (&vam->json_tree);
3165 node = vat_json_array_add (&vam->json_tree);
3166 vat_json_init_object (node);
3167 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3171 vl_api_show_one_map_register_fallback_threshold_reply_t_handler
3172 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3174 vat_main_t *vam = &vat_main;
3175 int retval = clib_net_to_host_u32 (mp->retval);
3177 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3178 print (vam->ofp, "fallback threshold value: %d", mp->value);
3180 vam->retval = retval;
3181 vam->result_ready = 1;
3185 vl_api_show_one_map_register_fallback_threshold_reply_t_handler_json
3186 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3188 vat_main_t *vam = &vat_main;
3189 vat_json_node_t _node, *node = &_node;
3190 int retval = clib_net_to_host_u32 (mp->retval);
3192 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3193 vat_json_init_object (node);
3194 vat_json_object_add_uint (node, "value", mp->value);
3196 vat_json_print (vam->ofp, node);
3197 vat_json_free (node);
3199 vam->retval = retval;
3200 vam->result_ready = 1;
3204 vl_api_show_one_map_register_state_reply_t_handler
3205 (vl_api_show_one_map_register_state_reply_t * mp)
3207 vat_main_t *vam = &vat_main;
3208 int retval = clib_net_to_host_u32 (mp->retval);
3210 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3212 vam->retval = retval;
3213 vam->result_ready = 1;
3217 vl_api_show_one_map_register_state_reply_t_handler_json
3218 (vl_api_show_one_map_register_state_reply_t * mp)
3220 vat_main_t *vam = &vat_main;
3221 vat_json_node_t _node, *node = &_node;
3222 int retval = clib_net_to_host_u32 (mp->retval);
3224 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3226 vat_json_init_object (node);
3227 vat_json_object_add_string_copy (node, "state", s);
3229 vat_json_print (vam->ofp, node);
3230 vat_json_free (node);
3232 vam->retval = retval;
3233 vam->result_ready = 1;
3238 vl_api_show_one_rloc_probe_state_reply_t_handler
3239 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3241 vat_main_t *vam = &vat_main;
3242 int retval = clib_net_to_host_u32 (mp->retval);
3247 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3249 vam->retval = retval;
3250 vam->result_ready = 1;
3254 vl_api_show_one_rloc_probe_state_reply_t_handler_json
3255 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3257 vat_main_t *vam = &vat_main;
3258 vat_json_node_t _node, *node = &_node;
3259 int retval = clib_net_to_host_u32 (mp->retval);
3261 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3262 vat_json_init_object (node);
3263 vat_json_object_add_string_copy (node, "state", s);
3265 vat_json_print (vam->ofp, node);
3266 vat_json_free (node);
3268 vam->retval = retval;
3269 vam->result_ready = 1;
3274 vl_api_show_one_stats_enable_disable_reply_t_handler
3275 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3277 vat_main_t *vam = &vat_main;
3278 int retval = clib_net_to_host_u32 (mp->retval);
3283 print (vam->ofp, "%s", mp->is_en ? "enabled" : "disabled");
3285 vam->retval = retval;
3286 vam->result_ready = 1;
3290 vl_api_show_one_stats_enable_disable_reply_t_handler_json
3291 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3293 vat_main_t *vam = &vat_main;
3294 vat_json_node_t _node, *node = &_node;
3295 int retval = clib_net_to_host_u32 (mp->retval);
3297 u8 *s = format (0, "%s", mp->is_en ? "enabled" : "disabled");
3298 vat_json_init_object (node);
3299 vat_json_object_add_string_copy (node, "state", s);
3301 vat_json_print (vam->ofp, node);
3302 vat_json_free (node);
3304 vam->retval = retval;
3305 vam->result_ready = 1;
3310 api_gpe_fwd_entry_net_to_host (vl_api_gpe_fwd_entry_t * e)
3312 e->dp_table = clib_net_to_host_u32 (e->dp_table);
3313 e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
3314 e->vni = clib_net_to_host_u32 (e->vni);
3318 gpe_fwd_entries_get_reply_t_net_to_host
3319 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3323 mp->count = clib_net_to_host_u32 (mp->count);
3324 for (i = 0; i < mp->count; i++)
3326 api_gpe_fwd_entry_net_to_host (&mp->entries[i]);
3331 format_gpe_encap_mode (u8 * s, va_list * args)
3333 u32 mode = va_arg (*args, u32);
3338 return format (s, "lisp");
3340 return format (s, "vxlan");
3346 vl_api_gpe_get_encap_mode_reply_t_handler
3347 (vl_api_gpe_get_encap_mode_reply_t * mp)
3349 vat_main_t *vam = &vat_main;
3351 print (vam->ofp, "gpe mode: %U", format_gpe_encap_mode, mp->encap_mode);
3352 vam->retval = ntohl (mp->retval);
3353 vam->result_ready = 1;
3357 vl_api_gpe_get_encap_mode_reply_t_handler_json
3358 (vl_api_gpe_get_encap_mode_reply_t * mp)
3360 vat_main_t *vam = &vat_main;
3361 vat_json_node_t node;
3363 u8 *encap_mode = format (0, "%U", format_gpe_encap_mode, mp->encap_mode);
3364 vec_add1 (encap_mode, 0);
3366 vat_json_init_object (&node);
3367 vat_json_object_add_string_copy (&node, "gpe_mode", encap_mode);
3369 vec_free (encap_mode);
3370 vat_json_print (vam->ofp, &node);
3371 vat_json_free (&node);
3373 vam->retval = ntohl (mp->retval);
3374 vam->result_ready = 1;
3378 vl_api_gpe_fwd_entry_path_details_t_handler
3379 (vl_api_gpe_fwd_entry_path_details_t * mp)
3381 vat_main_t *vam = &vat_main;
3382 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3384 if (mp->lcl_loc.is_ip4)
3385 format_ip_address_fcn = format_ip4_address;
3387 format_ip_address_fcn = format_ip6_address;
3389 print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
3390 format_ip_address_fcn, &mp->lcl_loc,
3391 format_ip_address_fcn, &mp->rmt_loc);
3395 lisp_fill_locator_node (vat_json_node_t * n, vl_api_gpe_locator_t * loc)
3397 struct in6_addr ip6;
3402 clib_memcpy (&ip4, loc->addr, sizeof (ip4));
3403 vat_json_object_add_ip4 (n, "address", ip4);
3407 clib_memcpy (&ip6, loc->addr, sizeof (ip6));
3408 vat_json_object_add_ip6 (n, "address", ip6);
3410 vat_json_object_add_uint (n, "weight", loc->weight);
3414 vl_api_gpe_fwd_entry_path_details_t_handler_json
3415 (vl_api_gpe_fwd_entry_path_details_t * mp)
3417 vat_main_t *vam = &vat_main;
3418 vat_json_node_t *node = NULL;
3419 vat_json_node_t *loc_node;
3421 if (VAT_JSON_ARRAY != vam->json_tree.type)
3423 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3424 vat_json_init_array (&vam->json_tree);
3426 node = vat_json_array_add (&vam->json_tree);
3427 vat_json_init_object (node);
3429 loc_node = vat_json_object_add (node, "local_locator");
3430 vat_json_init_object (loc_node);
3431 lisp_fill_locator_node (loc_node, &mp->lcl_loc);
3433 loc_node = vat_json_object_add (node, "remote_locator");
3434 vat_json_init_object (loc_node);
3435 lisp_fill_locator_node (loc_node, &mp->rmt_loc);
3439 vl_api_gpe_fwd_entries_get_reply_t_handler
3440 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3442 vat_main_t *vam = &vat_main;
3444 int retval = clib_net_to_host_u32 (mp->retval);
3445 vl_api_gpe_fwd_entry_t *e;
3450 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3452 for (i = 0; i < mp->count; i++)
3454 e = &mp->entries[i];
3455 print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
3456 format_lisp_flat_eid, e->eid_type, e->leid, e->leid_prefix_len,
3457 format_lisp_flat_eid, e->eid_type, e->reid, e->reid_prefix_len);
3461 vam->retval = retval;
3462 vam->result_ready = 1;
3466 vl_api_gpe_fwd_entries_get_reply_t_handler_json
3467 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3470 vat_main_t *vam = &vat_main;
3471 vat_json_node_t *e = 0, root;
3473 int retval = clib_net_to_host_u32 (mp->retval);
3474 vl_api_gpe_fwd_entry_t *fwd;
3479 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3480 vat_json_init_array (&root);
3482 for (i = 0; i < mp->count; i++)
3484 e = vat_json_array_add (&root);
3485 fwd = &mp->entries[i];
3487 vat_json_init_object (e);
3488 vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
3489 vat_json_object_add_int (e, "dp_table", fwd->dp_table);
3490 vat_json_object_add_int (e, "vni", fwd->vni);
3491 vat_json_object_add_int (e, "action", fwd->action);
3493 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->leid,
3494 fwd->leid_prefix_len);
3496 vat_json_object_add_string_copy (e, "leid", s);
3499 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->reid,
3500 fwd->reid_prefix_len);
3502 vat_json_object_add_string_copy (e, "reid", s);
3506 vat_json_print (vam->ofp, &root);
3507 vat_json_free (&root);
3510 vam->retval = retval;
3511 vam->result_ready = 1;
3515 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler
3516 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3518 vat_main_t *vam = &vat_main;
3520 int retval = clib_net_to_host_u32 (mp->retval);
3521 vl_api_gpe_native_fwd_rpath_t *r;
3526 n = clib_net_to_host_u32 (mp->count);
3528 for (i = 0; i < n; i++)
3530 r = &mp->entries[i];
3531 print (vam->ofp, "fib_index: %d sw_if_index %d nh %U",
3532 clib_net_to_host_u32 (r->fib_index),
3533 clib_net_to_host_u32 (r->nh_sw_if_index),
3534 r->is_ip4 ? format_ip4_address : format_ip6_address, r->nh_addr);
3538 vam->retval = retval;
3539 vam->result_ready = 1;
3543 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler_json
3544 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3546 vat_main_t *vam = &vat_main;
3547 vat_json_node_t root, *e;
3549 int retval = clib_net_to_host_u32 (mp->retval);
3550 vl_api_gpe_native_fwd_rpath_t *r;
3556 n = clib_net_to_host_u32 (mp->count);
3557 vat_json_init_array (&root);
3559 for (i = 0; i < n; i++)
3561 e = vat_json_array_add (&root);
3562 vat_json_init_object (e);
3563 r = &mp->entries[i];
3565 format (0, "%U", r->is_ip4 ? format_ip4_address : format_ip6_address,
3568 vat_json_object_add_string_copy (e, "ip4", s);
3571 vat_json_object_add_uint (e, "fib_index",
3572 clib_net_to_host_u32 (r->fib_index));
3573 vat_json_object_add_uint (e, "nh_sw_if_index",
3574 clib_net_to_host_u32 (r->nh_sw_if_index));
3577 vat_json_print (vam->ofp, &root);
3578 vat_json_free (&root);
3581 vam->retval = retval;
3582 vam->result_ready = 1;
3586 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler
3587 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3589 vat_main_t *vam = &vat_main;
3591 int retval = clib_net_to_host_u32 (mp->retval);
3596 n = clib_net_to_host_u32 (mp->count);
3598 for (i = 0; i < n; i++)
3599 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->vnis[i]));
3602 vam->retval = retval;
3603 vam->result_ready = 1;
3607 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler_json
3608 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3610 vat_main_t *vam = &vat_main;
3611 vat_json_node_t root;
3613 int retval = clib_net_to_host_u32 (mp->retval);
3618 n = clib_net_to_host_u32 (mp->count);
3619 vat_json_init_array (&root);
3621 for (i = 0; i < n; i++)
3622 vat_json_array_add_uint (&root, clib_net_to_host_u32 (mp->vnis[i]));
3624 vat_json_print (vam->ofp, &root);
3625 vat_json_free (&root);
3628 vam->retval = retval;
3629 vam->result_ready = 1;
3633 vl_api_one_ndp_entries_get_reply_t_handler
3634 (vl_api_one_ndp_entries_get_reply_t * mp)
3636 vat_main_t *vam = &vat_main;
3638 int retval = clib_net_to_host_u32 (mp->retval);
3643 n = clib_net_to_host_u32 (mp->count);
3645 for (i = 0; i < n; i++)
3646 print (vam->ofp, "%U -> %U", format_ip6_address, &mp->entries[i].ip6,
3647 format_ethernet_address, mp->entries[i].mac);
3650 vam->retval = retval;
3651 vam->result_ready = 1;
3655 vl_api_one_ndp_entries_get_reply_t_handler_json
3656 (vl_api_one_ndp_entries_get_reply_t * mp)
3659 vat_main_t *vam = &vat_main;
3660 vat_json_node_t *e = 0, root;
3662 int retval = clib_net_to_host_u32 (mp->retval);
3663 vl_api_one_ndp_entry_t *arp_entry;
3668 n = clib_net_to_host_u32 (mp->count);
3669 vat_json_init_array (&root);
3671 for (i = 0; i < n; i++)
3673 e = vat_json_array_add (&root);
3674 arp_entry = &mp->entries[i];
3676 vat_json_init_object (e);
3677 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3680 vat_json_object_add_string_copy (e, "mac", s);
3683 s = format (0, "%U", format_ip6_address, &arp_entry->ip6);
3685 vat_json_object_add_string_copy (e, "ip6", s);
3689 vat_json_print (vam->ofp, &root);
3690 vat_json_free (&root);
3693 vam->retval = retval;
3694 vam->result_ready = 1;
3698 vl_api_one_l2_arp_entries_get_reply_t_handler
3699 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3701 vat_main_t *vam = &vat_main;
3703 int retval = clib_net_to_host_u32 (mp->retval);
3708 n = clib_net_to_host_u32 (mp->count);
3710 for (i = 0; i < n; i++)
3711 print (vam->ofp, "%U -> %U", format_ip4_address, &mp->entries[i].ip4,
3712 format_ethernet_address, mp->entries[i].mac);
3715 vam->retval = retval;
3716 vam->result_ready = 1;
3720 vl_api_one_l2_arp_entries_get_reply_t_handler_json
3721 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3724 vat_main_t *vam = &vat_main;
3725 vat_json_node_t *e = 0, root;
3727 int retval = clib_net_to_host_u32 (mp->retval);
3728 vl_api_one_l2_arp_entry_t *arp_entry;
3733 n = clib_net_to_host_u32 (mp->count);
3734 vat_json_init_array (&root);
3736 for (i = 0; i < n; i++)
3738 e = vat_json_array_add (&root);
3739 arp_entry = &mp->entries[i];
3741 vat_json_init_object (e);
3742 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3745 vat_json_object_add_string_copy (e, "mac", s);
3748 s = format (0, "%U", format_ip4_address, &arp_entry->ip4);
3750 vat_json_object_add_string_copy (e, "ip4", s);
3754 vat_json_print (vam->ofp, &root);
3755 vat_json_free (&root);
3758 vam->retval = retval;
3759 vam->result_ready = 1;
3763 vl_api_one_ndp_bd_get_reply_t_handler (vl_api_one_ndp_bd_get_reply_t * mp)
3765 vat_main_t *vam = &vat_main;
3767 int retval = clib_net_to_host_u32 (mp->retval);
3772 n = clib_net_to_host_u32 (mp->count);
3774 for (i = 0; i < n; i++)
3776 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3780 vam->retval = retval;
3781 vam->result_ready = 1;
3785 vl_api_one_ndp_bd_get_reply_t_handler_json
3786 (vl_api_one_ndp_bd_get_reply_t * mp)
3788 vat_main_t *vam = &vat_main;
3789 vat_json_node_t root;
3791 int retval = clib_net_to_host_u32 (mp->retval);
3796 n = clib_net_to_host_u32 (mp->count);
3797 vat_json_init_array (&root);
3799 for (i = 0; i < n; i++)
3801 vat_json_array_add_uint (&root,
3802 clib_net_to_host_u32 (mp->bridge_domains[i]));
3805 vat_json_print (vam->ofp, &root);
3806 vat_json_free (&root);
3809 vam->retval = retval;
3810 vam->result_ready = 1;
3814 vl_api_one_l2_arp_bd_get_reply_t_handler
3815 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3817 vat_main_t *vam = &vat_main;
3819 int retval = clib_net_to_host_u32 (mp->retval);
3824 n = clib_net_to_host_u32 (mp->count);
3826 for (i = 0; i < n; i++)
3828 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3832 vam->retval = retval;
3833 vam->result_ready = 1;
3837 vl_api_one_l2_arp_bd_get_reply_t_handler_json
3838 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3840 vat_main_t *vam = &vat_main;
3841 vat_json_node_t root;
3843 int retval = clib_net_to_host_u32 (mp->retval);
3848 n = clib_net_to_host_u32 (mp->count);
3849 vat_json_init_array (&root);
3851 for (i = 0; i < n; i++)
3853 vat_json_array_add_uint (&root,
3854 clib_net_to_host_u32 (mp->bridge_domains[i]));
3857 vat_json_print (vam->ofp, &root);
3858 vat_json_free (&root);
3861 vam->retval = retval;
3862 vam->result_ready = 1;
3866 vl_api_one_adjacencies_get_reply_t_handler
3867 (vl_api_one_adjacencies_get_reply_t * mp)
3869 vat_main_t *vam = &vat_main;
3871 int retval = clib_net_to_host_u32 (mp->retval);
3872 vl_api_one_adjacency_t *a;
3877 n = clib_net_to_host_u32 (mp->count);
3879 for (i = 0; i < n; i++)
3881 a = &mp->adjacencies[i];
3882 print (vam->ofp, "%U %40U",
3883 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
3884 format_lisp_flat_eid, a->eid_type, a->reid, a->reid_prefix_len);
3888 vam->retval = retval;
3889 vam->result_ready = 1;
3893 vl_api_one_adjacencies_get_reply_t_handler_json
3894 (vl_api_one_adjacencies_get_reply_t * mp)
3897 vat_main_t *vam = &vat_main;
3898 vat_json_node_t *e = 0, root;
3900 int retval = clib_net_to_host_u32 (mp->retval);
3901 vl_api_one_adjacency_t *a;
3906 n = clib_net_to_host_u32 (mp->count);
3907 vat_json_init_array (&root);
3909 for (i = 0; i < n; i++)
3911 e = vat_json_array_add (&root);
3912 a = &mp->adjacencies[i];
3914 vat_json_init_object (e);
3915 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
3916 a->leid_prefix_len);
3918 vat_json_object_add_string_copy (e, "leid", s);
3921 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
3922 a->reid_prefix_len);
3924 vat_json_object_add_string_copy (e, "reid", s);
3928 vat_json_print (vam->ofp, &root);
3929 vat_json_free (&root);
3932 vam->retval = retval;
3933 vam->result_ready = 1;
3937 vl_api_one_map_server_details_t_handler (vl_api_one_map_server_details_t * mp)
3939 vat_main_t *vam = &vat_main;
3941 print (vam->ofp, "%=20U",
3942 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
3947 vl_api_one_map_server_details_t_handler_json
3948 (vl_api_one_map_server_details_t * mp)
3950 vat_main_t *vam = &vat_main;
3951 vat_json_node_t *node = NULL;
3952 struct in6_addr ip6;
3955 if (VAT_JSON_ARRAY != vam->json_tree.type)
3957 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3958 vat_json_init_array (&vam->json_tree);
3960 node = vat_json_array_add (&vam->json_tree);
3962 vat_json_init_object (node);
3965 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
3966 vat_json_object_add_ip6 (node, "map-server", ip6);
3970 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
3971 vat_json_object_add_ip4 (node, "map-server", ip4);
3976 vl_api_one_map_resolver_details_t_handler (vl_api_one_map_resolver_details_t
3979 vat_main_t *vam = &vat_main;
3981 print (vam->ofp, "%=20U",
3982 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
3987 vl_api_one_map_resolver_details_t_handler_json
3988 (vl_api_one_map_resolver_details_t * mp)
3990 vat_main_t *vam = &vat_main;
3991 vat_json_node_t *node = NULL;
3992 struct in6_addr ip6;
3995 if (VAT_JSON_ARRAY != vam->json_tree.type)
3997 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3998 vat_json_init_array (&vam->json_tree);
4000 node = vat_json_array_add (&vam->json_tree);
4002 vat_json_init_object (node);
4005 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
4006 vat_json_object_add_ip6 (node, "map resolver", ip6);
4010 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
4011 vat_json_object_add_ip4 (node, "map resolver", ip4);
4016 vl_api_show_one_status_reply_t_handler (vl_api_show_one_status_reply_t * mp)
4018 vat_main_t *vam = &vat_main;
4019 i32 retval = ntohl (mp->retval);
4023 print (vam->ofp, "feature: %s\ngpe: %s",
4024 mp->feature_status ? "enabled" : "disabled",
4025 mp->gpe_status ? "enabled" : "disabled");
4028 vam->retval = retval;
4029 vam->result_ready = 1;
4033 vl_api_show_one_status_reply_t_handler_json
4034 (vl_api_show_one_status_reply_t * mp)
4036 vat_main_t *vam = &vat_main;
4037 vat_json_node_t node;
4038 u8 *gpe_status = NULL;
4039 u8 *feature_status = NULL;
4041 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
4042 feature_status = format (0, "%s",
4043 mp->feature_status ? "enabled" : "disabled");
4044 vec_add1 (gpe_status, 0);
4045 vec_add1 (feature_status, 0);
4047 vat_json_init_object (&node);
4048 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
4049 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
4051 vec_free (gpe_status);
4052 vec_free (feature_status);
4054 vat_json_print (vam->ofp, &node);
4055 vat_json_free (&node);
4057 vam->retval = ntohl (mp->retval);
4058 vam->result_ready = 1;
4062 vl_api_one_get_map_request_itr_rlocs_reply_t_handler
4063 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4065 vat_main_t *vam = &vat_main;
4066 i32 retval = ntohl (mp->retval);
4070 print (vam->ofp, "%=20s", mp->locator_set_name);
4073 vam->retval = retval;
4074 vam->result_ready = 1;
4078 vl_api_one_get_map_request_itr_rlocs_reply_t_handler_json
4079 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4081 vat_main_t *vam = &vat_main;
4082 vat_json_node_t *node = NULL;
4084 if (VAT_JSON_ARRAY != vam->json_tree.type)
4086 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4087 vat_json_init_array (&vam->json_tree);
4089 node = vat_json_array_add (&vam->json_tree);
4091 vat_json_init_object (node);
4092 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
4094 vat_json_print (vam->ofp, node);
4095 vat_json_free (node);
4097 vam->retval = ntohl (mp->retval);
4098 vam->result_ready = 1;
4102 format_lisp_map_request_mode (u8 * s, va_list * args)
4104 u32 mode = va_arg (*args, u32);
4109 return format (0, "dst-only");
4111 return format (0, "src-dst");
4117 vl_api_show_one_map_request_mode_reply_t_handler
4118 (vl_api_show_one_map_request_mode_reply_t * mp)
4120 vat_main_t *vam = &vat_main;
4121 i32 retval = ntohl (mp->retval);
4125 u32 mode = mp->mode;
4126 print (vam->ofp, "map_request_mode: %U",
4127 format_lisp_map_request_mode, mode);
4130 vam->retval = retval;
4131 vam->result_ready = 1;
4135 vl_api_show_one_map_request_mode_reply_t_handler_json
4136 (vl_api_show_one_map_request_mode_reply_t * mp)
4138 vat_main_t *vam = &vat_main;
4139 vat_json_node_t node;
4144 s = format (0, "%U", format_lisp_map_request_mode, mode);
4147 vat_json_init_object (&node);
4148 vat_json_object_add_string_copy (&node, "map_request_mode", s);
4149 vat_json_print (vam->ofp, &node);
4150 vat_json_free (&node);
4153 vam->retval = ntohl (mp->retval);
4154 vam->result_ready = 1;
4158 vl_api_one_show_xtr_mode_reply_t_handler
4159 (vl_api_one_show_xtr_mode_reply_t * mp)
4161 vat_main_t *vam = &vat_main;
4162 i32 retval = ntohl (mp->retval);
4166 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4169 vam->retval = retval;
4170 vam->result_ready = 1;
4174 vl_api_one_show_xtr_mode_reply_t_handler_json
4175 (vl_api_one_show_xtr_mode_reply_t * mp)
4177 vat_main_t *vam = &vat_main;
4178 vat_json_node_t node;
4181 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4182 vec_add1 (status, 0);
4184 vat_json_init_object (&node);
4185 vat_json_object_add_string_copy (&node, "status", status);
4189 vat_json_print (vam->ofp, &node);
4190 vat_json_free (&node);
4192 vam->retval = ntohl (mp->retval);
4193 vam->result_ready = 1;
4197 vl_api_one_show_pitr_mode_reply_t_handler
4198 (vl_api_one_show_pitr_mode_reply_t * mp)
4200 vat_main_t *vam = &vat_main;
4201 i32 retval = ntohl (mp->retval);
4205 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4208 vam->retval = retval;
4209 vam->result_ready = 1;
4213 vl_api_one_show_pitr_mode_reply_t_handler_json
4214 (vl_api_one_show_pitr_mode_reply_t * mp)
4216 vat_main_t *vam = &vat_main;
4217 vat_json_node_t node;
4220 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4221 vec_add1 (status, 0);
4223 vat_json_init_object (&node);
4224 vat_json_object_add_string_copy (&node, "status", status);
4228 vat_json_print (vam->ofp, &node);
4229 vat_json_free (&node);
4231 vam->retval = ntohl (mp->retval);
4232 vam->result_ready = 1;
4236 vl_api_one_show_petr_mode_reply_t_handler
4237 (vl_api_one_show_petr_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_petr_mode_reply_t_handler_json
4253 (vl_api_one_show_petr_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_show_one_use_petr_reply_t_handler
4276 (vl_api_show_one_use_petr_reply_t * mp)
4278 vat_main_t *vam = &vat_main;
4279 i32 retval = ntohl (mp->retval);
4283 print (vam->ofp, "%s\n", mp->status ? "enabled" : "disabled");
4286 print (vam->ofp, "Proxy-ETR address; %U",
4287 mp->is_ip4 ? format_ip4_address : format_ip6_address,
4292 vam->retval = retval;
4293 vam->result_ready = 1;
4297 vl_api_show_one_use_petr_reply_t_handler_json
4298 (vl_api_show_one_use_petr_reply_t * mp)
4300 vat_main_t *vam = &vat_main;
4301 vat_json_node_t node;
4304 struct in6_addr ip6;
4306 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4307 vec_add1 (status, 0);
4309 vat_json_init_object (&node);
4310 vat_json_object_add_string_copy (&node, "status", status);
4315 clib_memcpy (&ip6, mp->address, sizeof (ip6));
4316 vat_json_object_add_ip6 (&node, "address", ip6);
4320 clib_memcpy (&ip4, mp->address, sizeof (ip4));
4321 vat_json_object_add_ip4 (&node, "address", ip4);
4327 vat_json_print (vam->ofp, &node);
4328 vat_json_free (&node);
4330 vam->retval = ntohl (mp->retval);
4331 vam->result_ready = 1;
4335 vl_api_show_one_nsh_mapping_reply_t_handler
4336 (vl_api_show_one_nsh_mapping_reply_t * mp)
4338 vat_main_t *vam = &vat_main;
4339 i32 retval = ntohl (mp->retval);
4343 print (vam->ofp, "%-20s%-16s",
4344 mp->is_set ? "set" : "not-set",
4345 mp->is_set ? (char *) mp->locator_set_name : "");
4348 vam->retval = retval;
4349 vam->result_ready = 1;
4353 vl_api_show_one_nsh_mapping_reply_t_handler_json
4354 (vl_api_show_one_nsh_mapping_reply_t * mp)
4356 vat_main_t *vam = &vat_main;
4357 vat_json_node_t node;
4360 status = format (0, "%s", mp->is_set ? "yes" : "no");
4361 vec_add1 (status, 0);
4363 vat_json_init_object (&node);
4364 vat_json_object_add_string_copy (&node, "is_set", status);
4367 vat_json_object_add_string_copy (&node, "locator_set",
4368 mp->locator_set_name);
4373 vat_json_print (vam->ofp, &node);
4374 vat_json_free (&node);
4376 vam->retval = ntohl (mp->retval);
4377 vam->result_ready = 1;
4381 vl_api_show_one_map_register_ttl_reply_t_handler
4382 (vl_api_show_one_map_register_ttl_reply_t * mp)
4384 vat_main_t *vam = &vat_main;
4385 i32 retval = ntohl (mp->retval);
4387 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4391 print (vam->ofp, "ttl: %u", mp->ttl);
4394 vam->retval = retval;
4395 vam->result_ready = 1;
4399 vl_api_show_one_map_register_ttl_reply_t_handler_json
4400 (vl_api_show_one_map_register_ttl_reply_t * mp)
4402 vat_main_t *vam = &vat_main;
4403 vat_json_node_t node;
4405 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4406 vat_json_init_object (&node);
4407 vat_json_object_add_uint (&node, "ttl", mp->ttl);
4409 vat_json_print (vam->ofp, &node);
4410 vat_json_free (&node);
4412 vam->retval = ntohl (mp->retval);
4413 vam->result_ready = 1;
4417 vl_api_show_one_pitr_reply_t_handler (vl_api_show_one_pitr_reply_t * mp)
4419 vat_main_t *vam = &vat_main;
4420 i32 retval = ntohl (mp->retval);
4424 print (vam->ofp, "%-20s%-16s",
4425 mp->status ? "enabled" : "disabled",
4426 mp->status ? (char *) mp->locator_set_name : "");
4429 vam->retval = retval;
4430 vam->result_ready = 1;
4434 vl_api_show_one_pitr_reply_t_handler_json (vl_api_show_one_pitr_reply_t * mp)
4436 vat_main_t *vam = &vat_main;
4437 vat_json_node_t node;
4440 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4441 vec_add1 (status, 0);
4443 vat_json_init_object (&node);
4444 vat_json_object_add_string_copy (&node, "status", status);
4447 vat_json_object_add_string_copy (&node, "locator_set",
4448 mp->locator_set_name);
4453 vat_json_print (vam->ofp, &node);
4454 vat_json_free (&node);
4456 vam->retval = ntohl (mp->retval);
4457 vam->result_ready = 1;
4461 format_policer_type (u8 * s, va_list * va)
4463 u32 i = va_arg (*va, u32);
4465 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
4466 s = format (s, "1r2c");
4467 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
4468 s = format (s, "1r3c");
4469 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
4470 s = format (s, "2r3c-2698");
4471 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
4472 s = format (s, "2r3c-4115");
4473 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
4474 s = format (s, "2r3c-mef5cf1");
4476 s = format (s, "ILLEGAL");
4481 format_policer_rate_type (u8 * s, va_list * va)
4483 u32 i = va_arg (*va, u32);
4485 if (i == SSE2_QOS_RATE_KBPS)
4486 s = format (s, "kbps");
4487 else if (i == SSE2_QOS_RATE_PPS)
4488 s = format (s, "pps");
4490 s = format (s, "ILLEGAL");
4495 format_policer_round_type (u8 * s, va_list * va)
4497 u32 i = va_arg (*va, u32);
4499 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
4500 s = format (s, "closest");
4501 else if (i == SSE2_QOS_ROUND_TO_UP)
4502 s = format (s, "up");
4503 else if (i == SSE2_QOS_ROUND_TO_DOWN)
4504 s = format (s, "down");
4506 s = format (s, "ILLEGAL");
4511 format_policer_action_type (u8 * s, va_list * va)
4513 u32 i = va_arg (*va, u32);
4515 if (i == SSE2_QOS_ACTION_DROP)
4516 s = format (s, "drop");
4517 else if (i == SSE2_QOS_ACTION_TRANSMIT)
4518 s = format (s, "transmit");
4519 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4520 s = format (s, "mark-and-transmit");
4522 s = format (s, "ILLEGAL");
4527 format_dscp (u8 * s, va_list * va)
4529 u32 i = va_arg (*va, u32);
4534 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
4538 return format (s, "ILLEGAL");
4540 s = format (s, "%s", t);
4545 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
4547 vat_main_t *vam = &vat_main;
4548 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
4550 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4551 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4553 conform_dscp_str = format (0, "");
4555 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4556 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4558 exceed_dscp_str = format (0, "");
4560 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4561 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4563 violate_dscp_str = format (0, "");
4565 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
4566 "rate type %U, round type %U, %s rate, %s color-aware, "
4567 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
4568 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
4569 "conform action %U%s, exceed action %U%s, violate action %U%s",
4571 format_policer_type, mp->type,
4574 clib_net_to_host_u64 (mp->cb),
4575 clib_net_to_host_u64 (mp->eb),
4576 format_policer_rate_type, mp->rate_type,
4577 format_policer_round_type, mp->round_type,
4578 mp->single_rate ? "single" : "dual",
4579 mp->color_aware ? "is" : "not",
4580 ntohl (mp->cir_tokens_per_period),
4581 ntohl (mp->pir_tokens_per_period),
4583 ntohl (mp->current_limit),
4584 ntohl (mp->current_bucket),
4585 ntohl (mp->extended_limit),
4586 ntohl (mp->extended_bucket),
4587 clib_net_to_host_u64 (mp->last_update_time),
4588 format_policer_action_type, mp->conform_action_type,
4590 format_policer_action_type, mp->exceed_action_type,
4592 format_policer_action_type, mp->violate_action_type,
4595 vec_free (conform_dscp_str);
4596 vec_free (exceed_dscp_str);
4597 vec_free (violate_dscp_str);
4600 static void vl_api_policer_details_t_handler_json
4601 (vl_api_policer_details_t * mp)
4603 vat_main_t *vam = &vat_main;
4604 vat_json_node_t *node;
4605 u8 *rate_type_str, *round_type_str, *type_str;
4606 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
4608 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
4610 format (0, "%U", format_policer_round_type, mp->round_type);
4611 type_str = format (0, "%U", format_policer_type, mp->type);
4612 conform_action_str = format (0, "%U", format_policer_action_type,
4613 mp->conform_action_type);
4614 exceed_action_str = format (0, "%U", format_policer_action_type,
4615 mp->exceed_action_type);
4616 violate_action_str = format (0, "%U", format_policer_action_type,
4617 mp->violate_action_type);
4619 if (VAT_JSON_ARRAY != vam->json_tree.type)
4621 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4622 vat_json_init_array (&vam->json_tree);
4624 node = vat_json_array_add (&vam->json_tree);
4626 vat_json_init_object (node);
4627 vat_json_object_add_string_copy (node, "name", mp->name);
4628 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
4629 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
4630 vat_json_object_add_uint (node, "cb", clib_net_to_host_u64 (mp->cb));
4631 vat_json_object_add_uint (node, "eb", clib_net_to_host_u64 (mp->eb));
4632 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
4633 vat_json_object_add_string_copy (node, "round_type", round_type_str);
4634 vat_json_object_add_string_copy (node, "type", type_str);
4635 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
4636 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
4637 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
4638 vat_json_object_add_uint (node, "cir_tokens_per_period",
4639 ntohl (mp->cir_tokens_per_period));
4640 vat_json_object_add_uint (node, "eir_tokens_per_period",
4641 ntohl (mp->pir_tokens_per_period));
4642 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
4643 vat_json_object_add_uint (node, "current_bucket",
4644 ntohl (mp->current_bucket));
4645 vat_json_object_add_uint (node, "extended_limit",
4646 ntohl (mp->extended_limit));
4647 vat_json_object_add_uint (node, "extended_bucket",
4648 ntohl (mp->extended_bucket));
4649 vat_json_object_add_uint (node, "last_update_time",
4650 ntohl (mp->last_update_time));
4651 vat_json_object_add_string_copy (node, "conform_action",
4652 conform_action_str);
4653 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4655 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4656 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
4657 vec_free (dscp_str);
4659 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
4660 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4662 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4663 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
4664 vec_free (dscp_str);
4666 vat_json_object_add_string_copy (node, "violate_action",
4667 violate_action_str);
4668 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4670 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4671 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
4672 vec_free (dscp_str);
4675 vec_free (rate_type_str);
4676 vec_free (round_type_str);
4677 vec_free (type_str);
4678 vec_free (conform_action_str);
4679 vec_free (exceed_action_str);
4680 vec_free (violate_action_str);
4684 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
4687 vat_main_t *vam = &vat_main;
4688 int i, count = ntohl (mp->count);
4691 print (vam->ofp, "classify table ids (%d) : ", count);
4692 for (i = 0; i < count; i++)
4694 print (vam->ofp, "%d", ntohl (mp->ids[i]));
4695 print (vam->ofp, (i < count - 1) ? "," : "");
4697 vam->retval = ntohl (mp->retval);
4698 vam->result_ready = 1;
4702 vl_api_classify_table_ids_reply_t_handler_json
4703 (vl_api_classify_table_ids_reply_t * mp)
4705 vat_main_t *vam = &vat_main;
4706 int i, count = ntohl (mp->count);
4710 vat_json_node_t node;
4712 vat_json_init_object (&node);
4713 for (i = 0; i < count; i++)
4715 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
4717 vat_json_print (vam->ofp, &node);
4718 vat_json_free (&node);
4720 vam->retval = ntohl (mp->retval);
4721 vam->result_ready = 1;
4725 vl_api_classify_table_by_interface_reply_t_handler
4726 (vl_api_classify_table_by_interface_reply_t * mp)
4728 vat_main_t *vam = &vat_main;
4731 table_id = ntohl (mp->l2_table_id);
4733 print (vam->ofp, "l2 table id : %d", table_id);
4735 print (vam->ofp, "l2 table id : No input ACL tables configured");
4736 table_id = ntohl (mp->ip4_table_id);
4738 print (vam->ofp, "ip4 table id : %d", table_id);
4740 print (vam->ofp, "ip4 table id : No input ACL tables configured");
4741 table_id = ntohl (mp->ip6_table_id);
4743 print (vam->ofp, "ip6 table id : %d", table_id);
4745 print (vam->ofp, "ip6 table id : No input ACL tables configured");
4746 vam->retval = ntohl (mp->retval);
4747 vam->result_ready = 1;
4751 vl_api_classify_table_by_interface_reply_t_handler_json
4752 (vl_api_classify_table_by_interface_reply_t * mp)
4754 vat_main_t *vam = &vat_main;
4755 vat_json_node_t node;
4757 vat_json_init_object (&node);
4759 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
4760 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
4761 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
4763 vat_json_print (vam->ofp, &node);
4764 vat_json_free (&node);
4766 vam->retval = ntohl (mp->retval);
4767 vam->result_ready = 1;
4770 static void vl_api_policer_add_del_reply_t_handler
4771 (vl_api_policer_add_del_reply_t * mp)
4773 vat_main_t *vam = &vat_main;
4774 i32 retval = ntohl (mp->retval);
4775 if (vam->async_mode)
4777 vam->async_errors += (retval < 0);
4781 vam->retval = retval;
4782 vam->result_ready = 1;
4783 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
4785 * Note: this is just barely thread-safe, depends on
4786 * the main thread spinning waiting for an answer...
4788 errmsg ("policer index %d", ntohl (mp->policer_index));
4792 static void vl_api_policer_add_del_reply_t_handler_json
4793 (vl_api_policer_add_del_reply_t * mp)
4795 vat_main_t *vam = &vat_main;
4796 vat_json_node_t node;
4798 vat_json_init_object (&node);
4799 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
4800 vat_json_object_add_uint (&node, "policer_index",
4801 ntohl (mp->policer_index));
4803 vat_json_print (vam->ofp, &node);
4804 vat_json_free (&node);
4806 vam->retval = ntohl (mp->retval);
4807 vam->result_ready = 1;
4810 /* Format hex dump. */
4812 format_hex_bytes (u8 * s, va_list * va)
4814 u8 *bytes = va_arg (*va, u8 *);
4815 int n_bytes = va_arg (*va, int);
4818 /* Print short or long form depending on byte count. */
4819 uword short_form = n_bytes <= 32;
4820 u32 indent = format_get_indent (s);
4825 for (i = 0; i < n_bytes; i++)
4827 if (!short_form && (i % 32) == 0)
4828 s = format (s, "%08x: ", i);
4829 s = format (s, "%02x", bytes[i]);
4830 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
4831 s = format (s, "\n%U", format_white_space, indent);
4838 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
4841 vat_main_t *vam = &vat_main;
4842 i32 retval = ntohl (mp->retval);
4845 print (vam->ofp, "classify table info :");
4846 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
4847 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
4848 ntohl (mp->miss_next_index));
4849 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
4850 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
4851 ntohl (mp->match_n_vectors));
4852 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
4853 ntohl (mp->mask_length));
4855 vam->retval = retval;
4856 vam->result_ready = 1;
4860 vl_api_classify_table_info_reply_t_handler_json
4861 (vl_api_classify_table_info_reply_t * mp)
4863 vat_main_t *vam = &vat_main;
4864 vat_json_node_t node;
4866 i32 retval = ntohl (mp->retval);
4869 vat_json_init_object (&node);
4871 vat_json_object_add_int (&node, "sessions",
4872 ntohl (mp->active_sessions));
4873 vat_json_object_add_int (&node, "nexttbl",
4874 ntohl (mp->next_table_index));
4875 vat_json_object_add_int (&node, "nextnode",
4876 ntohl (mp->miss_next_index));
4877 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
4878 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
4879 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
4880 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
4881 ntohl (mp->mask_length), 0);
4882 vat_json_object_add_string_copy (&node, "mask", s);
4884 vat_json_print (vam->ofp, &node);
4885 vat_json_free (&node);
4887 vam->retval = ntohl (mp->retval);
4888 vam->result_ready = 1;
4892 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
4895 vat_main_t *vam = &vat_main;
4897 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
4898 ntohl (mp->hit_next_index), ntohl (mp->advance),
4899 ntohl (mp->opaque_index));
4900 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
4901 ntohl (mp->match_length));
4905 vl_api_classify_session_details_t_handler_json
4906 (vl_api_classify_session_details_t * mp)
4908 vat_main_t *vam = &vat_main;
4909 vat_json_node_t *node = NULL;
4911 if (VAT_JSON_ARRAY != vam->json_tree.type)
4913 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4914 vat_json_init_array (&vam->json_tree);
4916 node = vat_json_array_add (&vam->json_tree);
4918 vat_json_init_object (node);
4919 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
4920 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
4921 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
4923 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
4925 vat_json_object_add_string_copy (node, "match", s);
4928 static void vl_api_pg_create_interface_reply_t_handler
4929 (vl_api_pg_create_interface_reply_t * mp)
4931 vat_main_t *vam = &vat_main;
4933 vam->retval = ntohl (mp->retval);
4934 vam->result_ready = 1;
4937 static void vl_api_pg_create_interface_reply_t_handler_json
4938 (vl_api_pg_create_interface_reply_t * mp)
4940 vat_main_t *vam = &vat_main;
4941 vat_json_node_t node;
4943 i32 retval = ntohl (mp->retval);
4946 vat_json_init_object (&node);
4948 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
4950 vat_json_print (vam->ofp, &node);
4951 vat_json_free (&node);
4953 vam->retval = ntohl (mp->retval);
4954 vam->result_ready = 1;
4957 static void vl_api_policer_classify_details_t_handler
4958 (vl_api_policer_classify_details_t * mp)
4960 vat_main_t *vam = &vat_main;
4962 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
4963 ntohl (mp->table_index));
4966 static void vl_api_policer_classify_details_t_handler_json
4967 (vl_api_policer_classify_details_t * mp)
4969 vat_main_t *vam = &vat_main;
4970 vat_json_node_t *node;
4972 if (VAT_JSON_ARRAY != vam->json_tree.type)
4974 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4975 vat_json_init_array (&vam->json_tree);
4977 node = vat_json_array_add (&vam->json_tree);
4979 vat_json_init_object (node);
4980 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
4981 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
4984 static void vl_api_flow_classify_details_t_handler
4985 (vl_api_flow_classify_details_t * mp)
4987 vat_main_t *vam = &vat_main;
4989 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
4990 ntohl (mp->table_index));
4993 static void vl_api_flow_classify_details_t_handler_json
4994 (vl_api_flow_classify_details_t * mp)
4996 vat_main_t *vam = &vat_main;
4997 vat_json_node_t *node;
4999 if (VAT_JSON_ARRAY != vam->json_tree.type)
5001 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5002 vat_json_init_array (&vam->json_tree);
5004 node = vat_json_array_add (&vam->json_tree);
5006 vat_json_init_object (node);
5007 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5008 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5011 #define vl_api_one_adjacencies_get_reply_t_endian vl_noop_handler
5012 #define vl_api_one_adjacencies_get_reply_t_print vl_noop_handler
5013 #define vl_api_one_l2_arp_bd_get_reply_t_print vl_noop_handler
5014 #define vl_api_one_l2_arp_entries_get_reply_t_endian vl_noop_handler
5015 #define vl_api_one_l2_arp_entries_get_reply_t_print vl_noop_handler
5016 #define vl_api_one_l2_arp_bd_get_reply_t_endian vl_noop_handler
5017 #define vl_api_one_ndp_bd_get_reply_t_endian vl_noop_handler
5018 #define vl_api_one_ndp_bd_get_reply_t_print vl_noop_handler
5019 #define vl_api_one_ndp_entries_get_reply_t_print vl_noop_handler
5020 #define vl_api_one_ndp_entries_get_reply_t_endian vl_noop_handler
5023 * Generate boilerplate reply handlers, which
5024 * dig the return value out of the xxx_reply_t API message,
5025 * stick it into vam->retval, and set vam->result_ready
5027 * Could also do this by pointing N message decode slots at
5028 * a single function, but that could break in subtle ways.
5031 #define foreach_standard_reply_retval_handler \
5032 _(sw_interface_set_flags_reply) \
5033 _(sw_interface_add_del_address_reply) \
5034 _(sw_interface_set_rx_mode_reply) \
5035 _(sw_interface_set_rx_placement_reply) \
5036 _(sw_interface_set_table_reply) \
5037 _(sw_interface_set_mpls_enable_reply) \
5038 _(sw_interface_set_vpath_reply) \
5039 _(sw_interface_set_vxlan_bypass_reply) \
5040 _(sw_interface_set_geneve_bypass_reply) \
5041 _(sw_interface_set_vxlan_gpe_bypass_reply) \
5042 _(sw_interface_set_l2_bridge_reply) \
5043 _(bridge_domain_add_del_reply) \
5044 _(sw_interface_set_l2_xconnect_reply) \
5045 _(l2fib_add_del_reply) \
5046 _(l2fib_flush_int_reply) \
5047 _(l2fib_flush_bd_reply) \
5048 _(ip_route_add_del_reply) \
5049 _(ip_table_add_del_reply) \
5050 _(ip_mroute_add_del_reply) \
5051 _(mpls_route_add_del_reply) \
5052 _(mpls_table_add_del_reply) \
5053 _(mpls_ip_bind_unbind_reply) \
5054 _(bier_route_add_del_reply) \
5055 _(bier_table_add_del_reply) \
5056 _(proxy_arp_add_del_reply) \
5057 _(proxy_arp_intfc_enable_disable_reply) \
5058 _(sw_interface_set_unnumbered_reply) \
5059 _(ip_neighbor_add_del_reply) \
5060 _(reset_fib_reply) \
5061 _(dhcp_proxy_config_reply) \
5062 _(dhcp_proxy_set_vss_reply) \
5063 _(dhcp_client_config_reply) \
5064 _(set_ip_flow_hash_reply) \
5065 _(sw_interface_ip6_enable_disable_reply) \
5066 _(ip6nd_proxy_add_del_reply) \
5067 _(sw_interface_ip6nd_ra_prefix_reply) \
5068 _(sw_interface_ip6nd_ra_config_reply) \
5069 _(set_arp_neighbor_limit_reply) \
5070 _(l2_patch_add_del_reply) \
5071 _(sr_mpls_policy_add_reply) \
5072 _(sr_mpls_policy_mod_reply) \
5073 _(sr_mpls_policy_del_reply) \
5074 _(sr_policy_add_reply) \
5075 _(sr_policy_mod_reply) \
5076 _(sr_policy_del_reply) \
5077 _(sr_localsid_add_del_reply) \
5078 _(sr_steering_add_del_reply) \
5079 _(classify_add_del_session_reply) \
5080 _(classify_set_interface_ip_table_reply) \
5081 _(classify_set_interface_l2_tables_reply) \
5082 _(l2tpv3_set_tunnel_cookies_reply) \
5083 _(l2tpv3_interface_enable_disable_reply) \
5084 _(l2tpv3_set_lookup_key_reply) \
5085 _(l2_fib_clear_table_reply) \
5086 _(l2_interface_efp_filter_reply) \
5087 _(l2_interface_vlan_tag_rewrite_reply) \
5088 _(modify_vhost_user_if_reply) \
5089 _(delete_vhost_user_if_reply) \
5090 _(ip_probe_neighbor_reply) \
5091 _(ip_scan_neighbor_enable_disable_reply) \
5092 _(want_ip4_arp_events_reply) \
5093 _(want_ip6_nd_events_reply) \
5094 _(want_l2_macs_events_reply) \
5095 _(input_acl_set_interface_reply) \
5096 _(ipsec_spd_add_del_reply) \
5097 _(ipsec_interface_add_del_spd_reply) \
5098 _(ipsec_spd_entry_add_del_reply) \
5099 _(ipsec_sad_entry_add_del_reply) \
5100 _(ipsec_tunnel_if_add_del_reply) \
5101 _(ipsec_tunnel_if_set_sa_reply) \
5102 _(delete_loopback_reply) \
5103 _(bd_ip_mac_add_del_reply) \
5104 _(bd_ip_mac_flush_reply) \
5105 _(want_interface_events_reply) \
5106 _(cop_interface_enable_disable_reply) \
5107 _(cop_whitelist_enable_disable_reply) \
5108 _(sw_interface_clear_stats_reply) \
5109 _(ioam_enable_reply) \
5110 _(ioam_disable_reply) \
5111 _(one_add_del_locator_reply) \
5112 _(one_add_del_local_eid_reply) \
5113 _(one_add_del_remote_mapping_reply) \
5114 _(one_add_del_adjacency_reply) \
5115 _(one_add_del_map_resolver_reply) \
5116 _(one_add_del_map_server_reply) \
5117 _(one_enable_disable_reply) \
5118 _(one_rloc_probe_enable_disable_reply) \
5119 _(one_map_register_enable_disable_reply) \
5120 _(one_map_register_set_ttl_reply) \
5121 _(one_set_transport_protocol_reply) \
5122 _(one_map_register_fallback_threshold_reply) \
5123 _(one_pitr_set_locator_set_reply) \
5124 _(one_map_request_mode_reply) \
5125 _(one_add_del_map_request_itr_rlocs_reply) \
5126 _(one_eid_table_add_del_map_reply) \
5127 _(one_use_petr_reply) \
5128 _(one_stats_enable_disable_reply) \
5129 _(one_add_del_l2_arp_entry_reply) \
5130 _(one_add_del_ndp_entry_reply) \
5131 _(one_stats_flush_reply) \
5132 _(one_enable_disable_xtr_mode_reply) \
5133 _(one_enable_disable_pitr_mode_reply) \
5134 _(one_enable_disable_petr_mode_reply) \
5135 _(gpe_enable_disable_reply) \
5136 _(gpe_set_encap_mode_reply) \
5137 _(gpe_add_del_iface_reply) \
5138 _(gpe_add_del_native_fwd_rpath_reply) \
5139 _(af_packet_delete_reply) \
5140 _(policer_classify_set_interface_reply) \
5141 _(netmap_create_reply) \
5142 _(netmap_delete_reply) \
5143 _(set_ipfix_exporter_reply) \
5144 _(set_ipfix_classify_stream_reply) \
5145 _(ipfix_classify_table_add_del_reply) \
5146 _(flow_classify_set_interface_reply) \
5147 _(sw_interface_span_enable_disable_reply) \
5148 _(pg_capture_reply) \
5149 _(pg_enable_disable_reply) \
5150 _(ip_source_and_port_range_check_add_del_reply) \
5151 _(ip_source_and_port_range_check_interface_add_del_reply)\
5152 _(delete_subif_reply) \
5153 _(l2_interface_pbb_tag_rewrite_reply) \
5155 _(feature_enable_disable_reply) \
5156 _(sw_interface_tag_add_del_reply) \
5157 _(hw_interface_set_mtu_reply) \
5158 _(p2p_ethernet_add_reply) \
5159 _(p2p_ethernet_del_reply) \
5160 _(lldp_config_reply) \
5161 _(sw_interface_set_lldp_reply) \
5162 _(tcp_configure_src_addresses_reply) \
5163 _(session_rule_add_del_reply) \
5164 _(ip_container_proxy_add_del_reply) \
5165 _(output_acl_set_interface_reply) \
5166 _(qos_record_enable_disable_reply)
5169 static void vl_api_##n##_t_handler \
5170 (vl_api_##n##_t * mp) \
5172 vat_main_t * vam = &vat_main; \
5173 i32 retval = ntohl(mp->retval); \
5174 if (vam->async_mode) { \
5175 vam->async_errors += (retval < 0); \
5177 vam->retval = retval; \
5178 vam->result_ready = 1; \
5181 foreach_standard_reply_retval_handler;
5185 static void vl_api_##n##_t_handler_json \
5186 (vl_api_##n##_t * mp) \
5188 vat_main_t * vam = &vat_main; \
5189 vat_json_node_t node; \
5190 vat_json_init_object(&node); \
5191 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
5192 vat_json_print(vam->ofp, &node); \
5193 vam->retval = ntohl(mp->retval); \
5194 vam->result_ready = 1; \
5196 foreach_standard_reply_retval_handler;
5200 * Table of message reply handlers, must include boilerplate handlers
5204 #define foreach_vpe_api_reply_msg \
5205 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
5206 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
5207 _(SW_INTERFACE_DETAILS, sw_interface_details) \
5208 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
5209 _(CONTROL_PING_REPLY, control_ping_reply) \
5210 _(CLI_REPLY, cli_reply) \
5211 _(CLI_INBAND_REPLY, cli_inband_reply) \
5212 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
5213 sw_interface_add_del_address_reply) \
5214 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
5215 _(SW_INTERFACE_SET_RX_PLACEMENT_REPLY, sw_interface_set_rx_placement_reply) \
5216 _(SW_INTERFACE_RX_PLACEMENT_DETAILS, sw_interface_rx_placement_details) \
5217 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
5218 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
5219 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
5220 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
5221 _(SW_INTERFACE_SET_GENEVE_BYPASS_REPLY, sw_interface_set_geneve_bypass_reply) \
5222 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
5223 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
5224 sw_interface_set_l2_xconnect_reply) \
5225 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
5226 sw_interface_set_l2_bridge_reply) \
5227 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
5228 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
5229 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
5230 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
5231 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
5232 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
5233 _(L2_FLAGS_REPLY, l2_flags_reply) \
5234 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
5235 _(TAP_CREATE_V2_REPLY, tap_create_v2_reply) \
5236 _(TAP_DELETE_V2_REPLY, tap_delete_v2_reply) \
5237 _(SW_INTERFACE_TAP_V2_DETAILS, sw_interface_tap_v2_details) \
5238 _(VIRTIO_PCI_CREATE_REPLY, virtio_pci_create_reply) \
5239 _(VIRTIO_PCI_DELETE_REPLY, virtio_pci_delete_reply) \
5240 _(SW_INTERFACE_VIRTIO_PCI_DETAILS, sw_interface_virtio_pci_details) \
5241 _(BOND_CREATE_REPLY, bond_create_reply) \
5242 _(BOND_DELETE_REPLY, bond_delete_reply) \
5243 _(BOND_ENSLAVE_REPLY, bond_enslave_reply) \
5244 _(BOND_DETACH_SLAVE_REPLY, bond_detach_slave_reply) \
5245 _(SW_INTERFACE_BOND_DETAILS, sw_interface_bond_details) \
5246 _(SW_INTERFACE_SLAVE_DETAILS, sw_interface_slave_details) \
5247 _(IP_ROUTE_ADD_DEL_REPLY, ip_route_add_del_reply) \
5248 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
5249 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
5250 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
5251 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
5252 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
5253 _(BIER_ROUTE_ADD_DEL_REPLY, bier_route_add_del_reply) \
5254 _(BIER_TABLE_ADD_DEL_REPLY, bier_table_add_del_reply) \
5255 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
5256 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
5257 proxy_arp_intfc_enable_disable_reply) \
5258 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
5259 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
5260 sw_interface_set_unnumbered_reply) \
5261 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
5262 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
5263 _(CREATE_SUBIF_REPLY, create_subif_reply) \
5264 _(RESET_FIB_REPLY, reset_fib_reply) \
5265 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
5266 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
5267 _(DHCP_PROXY_DETAILS, dhcp_proxy_details) \
5268 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
5269 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
5270 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
5271 sw_interface_ip6_enable_disable_reply) \
5272 _(IP6ND_PROXY_ADD_DEL_REPLY, ip6nd_proxy_add_del_reply) \
5273 _(IP6ND_PROXY_DETAILS, ip6nd_proxy_details) \
5274 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
5275 sw_interface_ip6nd_ra_prefix_reply) \
5276 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
5277 sw_interface_ip6nd_ra_config_reply) \
5278 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
5279 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
5280 _(SR_MPLS_POLICY_ADD_REPLY, sr_mpls_policy_add_reply) \
5281 _(SR_MPLS_POLICY_MOD_REPLY, sr_mpls_policy_mod_reply) \
5282 _(SR_MPLS_POLICY_DEL_REPLY, sr_mpls_policy_del_reply) \
5283 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
5284 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
5285 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
5286 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
5287 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
5288 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
5289 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
5290 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
5291 classify_set_interface_ip_table_reply) \
5292 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
5293 classify_set_interface_l2_tables_reply) \
5294 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
5295 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
5296 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
5297 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
5298 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
5299 l2tpv3_interface_enable_disable_reply) \
5300 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
5301 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
5302 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
5303 _(VXLAN_OFFLOAD_RX_REPLY, vxlan_offload_rx_reply) \
5304 _(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
5305 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
5306 _(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
5307 _(GRE_TUNNEL_ADD_DEL_REPLY, gre_tunnel_add_del_reply) \
5308 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
5309 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
5310 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
5311 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
5312 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
5313 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
5314 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
5315 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
5316 _(SHOW_VERSION_REPLY, show_version_reply) \
5317 _(SHOW_THREADS_REPLY, show_threads_reply) \
5318 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
5319 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
5320 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
5321 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
5322 _(IP_PROBE_NEIGHBOR_REPLY, ip_probe_neighbor_reply) \
5323 _(IP_SCAN_NEIGHBOR_ENABLE_DISABLE_REPLY, ip_scan_neighbor_enable_disable_reply) \
5324 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
5325 _(IP4_ARP_EVENT, ip4_arp_event) \
5326 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
5327 _(IP6_ND_EVENT, ip6_nd_event) \
5328 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
5329 _(L2_MACS_EVENT, l2_macs_event) \
5330 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
5331 _(IP_ADDRESS_DETAILS, ip_address_details) \
5332 _(IP_DETAILS, ip_details) \
5333 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
5334 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
5335 _(IPSEC_SPD_ENTRY_ADD_DEL_REPLY, ipsec_spd_entry_add_del_reply) \
5336 _(IPSEC_SAD_ENTRY_ADD_DEL_REPLY, ipsec_sad_entry_add_del_reply) \
5337 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
5338 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
5339 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
5340 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
5341 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
5342 _(BD_IP_MAC_FLUSH_REPLY, bd_ip_mac_flush_reply) \
5343 _(BD_IP_MAC_DETAILS, bd_ip_mac_details) \
5344 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
5345 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
5346 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
5347 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
5348 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
5349 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
5350 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
5351 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
5352 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
5353 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
5354 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
5355 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
5356 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
5357 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
5358 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
5359 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
5360 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
5361 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
5362 one_map_register_enable_disable_reply) \
5363 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
5364 _(ONE_SET_TRANSPORT_PROTOCOL_REPLY, one_set_transport_protocol_reply) \
5365 _(ONE_GET_TRANSPORT_PROTOCOL_REPLY, one_get_transport_protocol_reply) \
5366 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5367 one_map_register_fallback_threshold_reply) \
5368 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
5369 one_rloc_probe_enable_disable_reply) \
5370 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
5371 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
5372 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
5373 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
5374 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
5375 _(ONE_LOCATOR_DETAILS, one_locator_details) \
5376 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
5377 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
5378 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
5379 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
5380 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
5381 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
5382 _(ONE_STATS_DETAILS, one_stats_details) \
5383 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
5384 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
5385 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
5386 show_one_stats_enable_disable_reply) \
5387 _(ONE_ADD_DEL_NDP_ENTRY_REPLY, one_add_del_ndp_entry_reply) \
5388 _(ONE_NDP_BD_GET_REPLY, one_ndp_bd_get_reply) \
5389 _(ONE_NDP_ENTRIES_GET_REPLY, one_ndp_entries_get_reply) \
5390 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
5391 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
5392 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
5393 _(ONE_ENABLE_DISABLE_XTR_MODE_REPLY, one_enable_disable_xtr_mode_reply) \
5394 _(ONE_ENABLE_DISABLE_PITR_MODE_REPLY, \
5395 one_enable_disable_pitr_mode_reply) \
5396 _(ONE_ENABLE_DISABLE_PETR_MODE_REPLY, \
5397 one_enable_disable_petr_mode_reply) \
5398 _(ONE_SHOW_XTR_MODE_REPLY, one_show_xtr_mode_reply) \
5399 _(ONE_SHOW_PITR_MODE_REPLY, one_show_pitr_mode_reply) \
5400 _(ONE_SHOW_PETR_MODE_REPLY, one_show_petr_mode_reply) \
5401 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
5402 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
5403 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
5404 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
5405 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
5406 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
5407 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
5408 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
5409 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
5410 gpe_add_del_native_fwd_rpath_reply) \
5411 _(GPE_FWD_ENTRY_PATH_DETAILS, \
5412 gpe_fwd_entry_path_details) \
5413 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
5414 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
5415 one_add_del_map_request_itr_rlocs_reply) \
5416 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
5417 one_get_map_request_itr_rlocs_reply) \
5418 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
5419 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
5420 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
5421 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
5422 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
5423 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
5424 show_one_map_register_state_reply) \
5425 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
5426 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5427 show_one_map_register_fallback_threshold_reply) \
5428 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
5429 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
5430 _(AF_PACKET_DETAILS, af_packet_details) \
5431 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
5432 _(POLICER_DETAILS, policer_details) \
5433 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
5434 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
5435 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
5436 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
5437 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
5438 _(MPLS_TABLE_DETAILS, mpls_table_details) \
5439 _(MPLS_ROUTE_DETAILS, mpls_route_details) \
5440 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
5441 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
5442 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
5443 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
5444 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
5445 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
5446 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
5447 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5448 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5449 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5450 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5451 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5452 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5453 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5454 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5455 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5456 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5457 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5458 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5459 ip_source_and_port_range_check_add_del_reply) \
5460 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5461 ip_source_and_port_range_check_interface_add_del_reply) \
5462 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5463 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5464 _(SET_PUNT_REPLY, set_punt_reply) \
5465 _(IP_TABLE_DETAILS, ip_table_details) \
5466 _(IP_ROUTE_DETAILS, ip_route_details) \
5467 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5468 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5469 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5470 _(HW_INTERFACE_SET_MTU_REPLY, hw_interface_set_mtu_reply) \
5471 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
5472 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5473 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5474 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5475 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5476 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply) \
5477 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
5478 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
5479 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
5480 _(SESSION_RULES_DETAILS, session_rules_details) \
5481 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
5482 _(OUTPUT_ACL_SET_INTERFACE_REPLY, output_acl_set_interface_reply) \
5483 _(QOS_RECORD_ENABLE_DISABLE_REPLY, qos_record_enable_disable_reply)
5485 #define foreach_standalone_reply_msg \
5486 _(SW_INTERFACE_EVENT, sw_interface_event)
5494 #define STR_VTR_OP_CASE(op) \
5495 case L2_VTR_ ## op: \
5499 str_vtr_op (u32 vtr_op)
5503 STR_VTR_OP_CASE (DISABLED);
5504 STR_VTR_OP_CASE (PUSH_1);
5505 STR_VTR_OP_CASE (PUSH_2);
5506 STR_VTR_OP_CASE (POP_1);
5507 STR_VTR_OP_CASE (POP_2);
5508 STR_VTR_OP_CASE (TRANSLATE_1_1);
5509 STR_VTR_OP_CASE (TRANSLATE_1_2);
5510 STR_VTR_OP_CASE (TRANSLATE_2_1);
5511 STR_VTR_OP_CASE (TRANSLATE_2_2);
5518 dump_sub_interface_table (vat_main_t * vam)
5520 const sw_interface_subif_t *sub = NULL;
5522 if (vam->json_output)
5525 ("JSON output supported only for VPE API calls and dump_stats_table");
5530 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5531 "Interface", "sw_if_index",
5532 "sub id", "dot1ad", "tags", "outer id",
5533 "inner id", "exact", "default", "outer any", "inner any");
5535 vec_foreach (sub, vam->sw_if_subif_table)
5538 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5539 sub->interface_name,
5541 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5542 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5543 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5544 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5545 if (sub->vtr_op != L2_VTR_DISABLED)
5548 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
5549 "tag1: %d tag2: %d ]",
5550 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
5551 sub->vtr_tag1, sub->vtr_tag2);
5559 name_sort_cmp (void *a1, void *a2)
5561 name_sort_t *n1 = a1;
5562 name_sort_t *n2 = a2;
5564 return strcmp ((char *) n1->name, (char *) n2->name);
5568 dump_interface_table (vat_main_t * vam)
5571 name_sort_t *nses = 0, *ns;
5573 if (vam->json_output)
5576 ("JSON output supported only for VPE API calls and dump_stats_table");
5581 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5583 vec_add2 (nses, ns, 1);
5584 ns->name = (u8 *)(p->key);
5585 ns->value = (u32) p->value[0];
5589 vec_sort_with_function (nses, name_sort_cmp);
5591 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
5592 vec_foreach (ns, nses)
5594 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
5601 dump_ip_table (vat_main_t * vam, int is_ipv6)
5603 const ip_details_t *det = NULL;
5604 const ip_address_details_t *address = NULL;
5607 print (vam->ofp, "%-12s", "sw_if_index");
5609 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
5616 print (vam->ofp, "%-12d", i);
5617 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
5622 vec_foreach (address, det->addr)
5626 is_ipv6 ? format_ip6_address : format_ip4_address,
5627 address->ip, address->prefix_length);
5635 dump_ipv4_table (vat_main_t * vam)
5637 if (vam->json_output)
5640 ("JSON output supported only for VPE API calls and dump_stats_table");
5644 return dump_ip_table (vam, 0);
5648 dump_ipv6_table (vat_main_t * vam)
5650 if (vam->json_output)
5653 ("JSON output supported only for VPE API calls and dump_stats_table");
5657 return dump_ip_table (vam, 1);
5661 * Pass CLI buffers directly in the CLI_INBAND API message,
5662 * instead of an additional shared memory area.
5665 exec_inband (vat_main_t * vam)
5667 vl_api_cli_inband_t *mp;
5668 unformat_input_t *i = vam->input;
5671 if (vec_len (i->buffer) == 0)
5674 if (vam->exec_mode == 0 && unformat (i, "mode"))
5679 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
5686 * In order for the CLI command to work, it
5687 * must be a vector ending in \n, not a C-string ending
5690 u32 len = vec_len (vam->input->buffer);
5691 M2 (CLI_INBAND, mp, len);
5692 vl_api_to_api_string (len - 1, (const char *) vam->input->buffer, &mp->cmd);
5696 /* json responses may or may not include a useful reply... */
5697 if (vec_len (vam->cmd_reply))
5698 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
5703 exec (vat_main_t * vam)
5705 return exec_inband (vam);
5709 api_create_loopback (vat_main_t * vam)
5711 unformat_input_t *i = vam->input;
5712 vl_api_create_loopback_t *mp;
5713 vl_api_create_loopback_instance_t *mp_lbi;
5716 u8 is_specified = 0;
5717 u32 user_instance = 0;
5720 clib_memset (mac_address, 0, sizeof (mac_address));
5722 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5724 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5726 if (unformat (i, "instance %d", &user_instance))
5734 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
5735 mp_lbi->is_specified = is_specified;
5737 mp_lbi->user_instance = htonl (user_instance);
5739 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
5744 /* Construct the API message */
5745 M (CREATE_LOOPBACK, mp);
5747 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
5756 api_delete_loopback (vat_main_t * vam)
5758 unformat_input_t *i = vam->input;
5759 vl_api_delete_loopback_t *mp;
5760 u32 sw_if_index = ~0;
5763 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5765 if (unformat (i, "sw_if_index %d", &sw_if_index))
5771 if (sw_if_index == ~0)
5773 errmsg ("missing sw_if_index");
5777 /* Construct the API message */
5778 M (DELETE_LOOPBACK, mp);
5779 mp->sw_if_index = ntohl (sw_if_index);
5787 api_want_interface_events (vat_main_t * vam)
5789 unformat_input_t *i = vam->input;
5790 vl_api_want_interface_events_t *mp;
5794 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5796 if (unformat (i, "enable"))
5798 else if (unformat (i, "disable"))
5806 errmsg ("missing enable|disable");
5810 M (WANT_INTERFACE_EVENTS, mp);
5811 mp->enable_disable = enable;
5813 vam->interface_event_display = enable;
5821 /* Note: non-static, called once to set up the initial intfc table */
5823 api_sw_interface_dump (vat_main_t * vam)
5825 vl_api_sw_interface_dump_t *mp;
5826 vl_api_control_ping_t *mp_ping;
5828 name_sort_t *nses = 0, *ns;
5829 sw_interface_subif_t *sub = NULL;
5832 /* Toss the old name table */
5834 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5836 vec_add2 (nses, ns, 1);
5837 ns->name = (u8 *)(p->key);
5838 ns->value = (u32) p->value[0];
5842 hash_free (vam->sw_if_index_by_interface_name);
5844 vec_foreach (ns, nses) vec_free (ns->name);
5848 vec_foreach (sub, vam->sw_if_subif_table)
5850 vec_free (sub->interface_name);
5852 vec_free (vam->sw_if_subif_table);
5854 /* recreate the interface name hash table */
5855 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
5858 * Ask for all interface names. Otherwise, the epic catalog of
5859 * name filters becomes ridiculously long, and vat ends up needing
5860 * to be taught about new interface types.
5862 M (SW_INTERFACE_DUMP, mp);
5865 /* Use a control ping for synchronization */
5866 MPING (CONTROL_PING, mp_ping);
5874 api_sw_interface_set_flags (vat_main_t * vam)
5876 unformat_input_t *i = vam->input;
5877 vl_api_sw_interface_set_flags_t *mp;
5879 u8 sw_if_index_set = 0;
5883 /* Parse args required to build the message */
5884 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5886 if (unformat (i, "admin-up"))
5888 else if (unformat (i, "admin-down"))
5891 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5892 sw_if_index_set = 1;
5893 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5894 sw_if_index_set = 1;
5899 if (sw_if_index_set == 0)
5901 errmsg ("missing interface name or sw_if_index");
5905 /* Construct the API message */
5906 M (SW_INTERFACE_SET_FLAGS, mp);
5907 mp->sw_if_index = ntohl (sw_if_index);
5908 mp->flags = ntohl ((admin_up) ? IF_STATUS_API_FLAG_ADMIN_UP : 0);
5913 /* Wait for a reply, return the good/bad news... */
5919 api_sw_interface_set_rx_mode (vat_main_t * vam)
5921 unformat_input_t *i = vam->input;
5922 vl_api_sw_interface_set_rx_mode_t *mp;
5924 u8 sw_if_index_set = 0;
5926 u8 queue_id_valid = 0;
5928 vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN;
5930 /* Parse args required to build the message */
5931 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5933 if (unformat (i, "queue %d", &queue_id))
5935 else if (unformat (i, "polling"))
5936 mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
5937 else if (unformat (i, "interrupt"))
5938 mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT;
5939 else if (unformat (i, "adaptive"))
5940 mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE;
5942 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5943 sw_if_index_set = 1;
5944 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5945 sw_if_index_set = 1;
5950 if (sw_if_index_set == 0)
5952 errmsg ("missing interface name or sw_if_index");
5955 if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
5957 errmsg ("missing rx-mode");
5961 /* Construct the API message */
5962 M (SW_INTERFACE_SET_RX_MODE, mp);
5963 mp->sw_if_index = ntohl (sw_if_index);
5964 mp->mode = (vl_api_rx_mode_t) mode;
5965 mp->queue_id_valid = queue_id_valid;
5966 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
5971 /* Wait for a reply, return the good/bad news... */
5977 api_sw_interface_set_rx_placement (vat_main_t * vam)
5979 unformat_input_t *i = vam->input;
5980 vl_api_sw_interface_set_rx_placement_t *mp;
5982 u8 sw_if_index_set = 0;
5985 u32 queue_id, thread_index;
5987 /* Parse args required to build the message */
5988 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5990 if (unformat (i, "queue %d", &queue_id))
5992 else if (unformat (i, "main"))
5994 else if (unformat (i, "worker %d", &thread_index))
5997 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5998 sw_if_index_set = 1;
5999 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6000 sw_if_index_set = 1;
6005 if (sw_if_index_set == 0)
6007 errmsg ("missing interface name or sw_if_index");
6013 /* Construct the API message */
6014 M (SW_INTERFACE_SET_RX_PLACEMENT, mp);
6015 mp->sw_if_index = ntohl (sw_if_index);
6016 mp->worker_id = ntohl (thread_index);
6017 mp->queue_id = ntohl (queue_id);
6018 mp->is_main = is_main;
6022 /* Wait for a reply, return the good/bad news... */
6027 static void vl_api_sw_interface_rx_placement_details_t_handler
6028 (vl_api_sw_interface_rx_placement_details_t * mp)
6030 vat_main_t *vam = &vat_main;
6031 u32 worker_id = ntohl (mp->worker_id);
6034 "\n%-11d %-11s %-6d %-5d %-9s",
6035 ntohl (mp->sw_if_index), (worker_id == 0) ? "main" : "worker",
6036 worker_id, ntohl (mp->queue_id),
6038 1) ? "polling" : ((mp->mode == 2) ? "interrupt" : "adaptive"));
6041 static void vl_api_sw_interface_rx_placement_details_t_handler_json
6042 (vl_api_sw_interface_rx_placement_details_t * mp)
6044 vat_main_t *vam = &vat_main;
6045 vat_json_node_t *node = NULL;
6047 if (VAT_JSON_ARRAY != vam->json_tree.type)
6049 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
6050 vat_json_init_array (&vam->json_tree);
6052 node = vat_json_array_add (&vam->json_tree);
6054 vat_json_init_object (node);
6055 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
6056 vat_json_object_add_uint (node, "worker_id", ntohl (mp->worker_id));
6057 vat_json_object_add_uint (node, "queue_id", ntohl (mp->queue_id));
6058 vat_json_object_add_uint (node, "mode", mp->mode);
6062 api_sw_interface_rx_placement_dump (vat_main_t * vam)
6064 unformat_input_t *i = vam->input;
6065 vl_api_sw_interface_rx_placement_dump_t *mp;
6066 vl_api_control_ping_t *mp_ping;
6069 u8 sw_if_index_set = 0;
6071 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6073 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6075 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6082 "\n%-11s %-11s %-6s %-5s %-4s",
6083 "sw_if_index", "main/worker", "thread", "queue", "mode");
6085 /* Dump Interface rx placement */
6086 M (SW_INTERFACE_RX_PLACEMENT_DUMP, mp);
6088 if (sw_if_index_set)
6089 mp->sw_if_index = htonl (sw_if_index);
6091 mp->sw_if_index = ~0;
6095 /* Use a control ping for synchronization */
6096 MPING (CONTROL_PING, mp_ping);
6104 api_sw_interface_clear_stats (vat_main_t * vam)
6106 unformat_input_t *i = vam->input;
6107 vl_api_sw_interface_clear_stats_t *mp;
6109 u8 sw_if_index_set = 0;
6112 /* Parse args required to build the message */
6113 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6115 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6116 sw_if_index_set = 1;
6117 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6118 sw_if_index_set = 1;
6123 /* Construct the API message */
6124 M (SW_INTERFACE_CLEAR_STATS, mp);
6126 if (sw_if_index_set == 1)
6127 mp->sw_if_index = ntohl (sw_if_index);
6129 mp->sw_if_index = ~0;
6134 /* Wait for a reply, return the good/bad news... */
6140 api_sw_interface_add_del_address (vat_main_t * vam)
6142 unformat_input_t *i = vam->input;
6143 vl_api_sw_interface_add_del_address_t *mp;
6145 u8 sw_if_index_set = 0;
6146 u8 is_add = 1, del_all = 0;
6147 u32 address_length = 0;
6148 u8 v4_address_set = 0;
6149 u8 v6_address_set = 0;
6150 ip4_address_t v4address;
6151 ip6_address_t v6address;
6154 /* Parse args required to build the message */
6155 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6157 if (unformat (i, "del-all"))
6159 else if (unformat (i, "del"))
6162 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6163 sw_if_index_set = 1;
6164 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6165 sw_if_index_set = 1;
6166 else if (unformat (i, "%U/%d",
6167 unformat_ip4_address, &v4address, &address_length))
6169 else if (unformat (i, "%U/%d",
6170 unformat_ip6_address, &v6address, &address_length))
6176 if (sw_if_index_set == 0)
6178 errmsg ("missing interface name or sw_if_index");
6181 if (v4_address_set && v6_address_set)
6183 errmsg ("both v4 and v6 addresses set");
6186 if (!v4_address_set && !v6_address_set && !del_all)
6188 errmsg ("no addresses set");
6192 /* Construct the API message */
6193 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
6195 mp->sw_if_index = ntohl (sw_if_index);
6196 mp->is_add = is_add;
6197 mp->del_all = del_all;
6200 mp->prefix.address.af = ADDRESS_IP6;
6201 clib_memcpy (mp->prefix.address.un.ip6, &v6address, sizeof (v6address));
6205 mp->prefix.address.af = ADDRESS_IP4;
6206 clib_memcpy (mp->prefix.address.un.ip4, &v4address, sizeof (v4address));
6208 mp->prefix.len = address_length;
6213 /* Wait for a reply, return good/bad news */
6219 api_sw_interface_set_mpls_enable (vat_main_t * vam)
6221 unformat_input_t *i = vam->input;
6222 vl_api_sw_interface_set_mpls_enable_t *mp;
6224 u8 sw_if_index_set = 0;
6228 /* Parse args required to build the message */
6229 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6231 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6232 sw_if_index_set = 1;
6233 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6234 sw_if_index_set = 1;
6235 else if (unformat (i, "disable"))
6237 else if (unformat (i, "dis"))
6243 if (sw_if_index_set == 0)
6245 errmsg ("missing interface name or sw_if_index");
6249 /* Construct the API message */
6250 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
6252 mp->sw_if_index = ntohl (sw_if_index);
6253 mp->enable = enable;
6258 /* Wait for a reply... */
6264 api_sw_interface_set_table (vat_main_t * vam)
6266 unformat_input_t *i = vam->input;
6267 vl_api_sw_interface_set_table_t *mp;
6268 u32 sw_if_index, vrf_id = 0;
6269 u8 sw_if_index_set = 0;
6273 /* Parse args required to build the message */
6274 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6276 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6277 sw_if_index_set = 1;
6278 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6279 sw_if_index_set = 1;
6280 else if (unformat (i, "vrf %d", &vrf_id))
6282 else if (unformat (i, "ipv6"))
6288 if (sw_if_index_set == 0)
6290 errmsg ("missing interface name or sw_if_index");
6294 /* Construct the API message */
6295 M (SW_INTERFACE_SET_TABLE, mp);
6297 mp->sw_if_index = ntohl (sw_if_index);
6298 mp->is_ipv6 = is_ipv6;
6299 mp->vrf_id = ntohl (vrf_id);
6304 /* Wait for a reply... */
6309 static void vl_api_sw_interface_get_table_reply_t_handler
6310 (vl_api_sw_interface_get_table_reply_t * mp)
6312 vat_main_t *vam = &vat_main;
6314 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6316 vam->retval = ntohl (mp->retval);
6317 vam->result_ready = 1;
6321 static void vl_api_sw_interface_get_table_reply_t_handler_json
6322 (vl_api_sw_interface_get_table_reply_t * mp)
6324 vat_main_t *vam = &vat_main;
6325 vat_json_node_t node;
6327 vat_json_init_object (&node);
6328 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6329 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6331 vat_json_print (vam->ofp, &node);
6332 vat_json_free (&node);
6334 vam->retval = ntohl (mp->retval);
6335 vam->result_ready = 1;
6339 api_sw_interface_get_table (vat_main_t * vam)
6341 unformat_input_t *i = vam->input;
6342 vl_api_sw_interface_get_table_t *mp;
6344 u8 sw_if_index_set = 0;
6348 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6350 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6351 sw_if_index_set = 1;
6352 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6353 sw_if_index_set = 1;
6354 else if (unformat (i, "ipv6"))
6360 if (sw_if_index_set == 0)
6362 errmsg ("missing interface name or sw_if_index");
6366 M (SW_INTERFACE_GET_TABLE, mp);
6367 mp->sw_if_index = htonl (sw_if_index);
6368 mp->is_ipv6 = is_ipv6;
6376 api_sw_interface_set_vpath (vat_main_t * vam)
6378 unformat_input_t *i = vam->input;
6379 vl_api_sw_interface_set_vpath_t *mp;
6380 u32 sw_if_index = 0;
6381 u8 sw_if_index_set = 0;
6385 /* Parse args required to build the message */
6386 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6388 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6389 sw_if_index_set = 1;
6390 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6391 sw_if_index_set = 1;
6392 else if (unformat (i, "enable"))
6394 else if (unformat (i, "disable"))
6400 if (sw_if_index_set == 0)
6402 errmsg ("missing interface name or sw_if_index");
6406 /* Construct the API message */
6407 M (SW_INTERFACE_SET_VPATH, mp);
6409 mp->sw_if_index = ntohl (sw_if_index);
6410 mp->enable = is_enable;
6415 /* Wait for a reply... */
6421 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
6423 unformat_input_t *i = vam->input;
6424 vl_api_sw_interface_set_vxlan_bypass_t *mp;
6425 u32 sw_if_index = 0;
6426 u8 sw_if_index_set = 0;
6431 /* Parse args required to build the message */
6432 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6434 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6435 sw_if_index_set = 1;
6436 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6437 sw_if_index_set = 1;
6438 else if (unformat (i, "enable"))
6440 else if (unformat (i, "disable"))
6442 else if (unformat (i, "ip4"))
6444 else if (unformat (i, "ip6"))
6450 if (sw_if_index_set == 0)
6452 errmsg ("missing interface name or sw_if_index");
6456 /* Construct the API message */
6457 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
6459 mp->sw_if_index = ntohl (sw_if_index);
6460 mp->enable = is_enable;
6461 mp->is_ipv6 = is_ipv6;
6466 /* Wait for a reply... */
6472 api_sw_interface_set_geneve_bypass (vat_main_t * vam)
6474 unformat_input_t *i = vam->input;
6475 vl_api_sw_interface_set_geneve_bypass_t *mp;
6476 u32 sw_if_index = 0;
6477 u8 sw_if_index_set = 0;
6482 /* Parse args required to build the message */
6483 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6485 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6486 sw_if_index_set = 1;
6487 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6488 sw_if_index_set = 1;
6489 else if (unformat (i, "enable"))
6491 else if (unformat (i, "disable"))
6493 else if (unformat (i, "ip4"))
6495 else if (unformat (i, "ip6"))
6501 if (sw_if_index_set == 0)
6503 errmsg ("missing interface name or sw_if_index");
6507 /* Construct the API message */
6508 M (SW_INTERFACE_SET_GENEVE_BYPASS, mp);
6510 mp->sw_if_index = ntohl (sw_if_index);
6511 mp->enable = is_enable;
6512 mp->is_ipv6 = is_ipv6;
6517 /* Wait for a reply... */
6523 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
6525 unformat_input_t *i = vam->input;
6526 vl_api_sw_interface_set_l2_xconnect_t *mp;
6528 u8 rx_sw_if_index_set = 0;
6530 u8 tx_sw_if_index_set = 0;
6534 /* Parse args required to build the message */
6535 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6537 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6538 rx_sw_if_index_set = 1;
6539 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6540 tx_sw_if_index_set = 1;
6541 else if (unformat (i, "rx"))
6543 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6545 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6547 rx_sw_if_index_set = 1;
6552 else if (unformat (i, "tx"))
6554 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6556 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6558 tx_sw_if_index_set = 1;
6563 else if (unformat (i, "enable"))
6565 else if (unformat (i, "disable"))
6571 if (rx_sw_if_index_set == 0)
6573 errmsg ("missing rx interface name or rx_sw_if_index");
6577 if (enable && (tx_sw_if_index_set == 0))
6579 errmsg ("missing tx interface name or tx_sw_if_index");
6583 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
6585 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6586 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6587 mp->enable = enable;
6595 api_sw_interface_set_l2_bridge (vat_main_t * vam)
6597 unformat_input_t *i = vam->input;
6598 vl_api_sw_interface_set_l2_bridge_t *mp;
6599 vl_api_l2_port_type_t port_type;
6601 u8 rx_sw_if_index_set = 0;
6608 port_type = L2_API_PORT_TYPE_NORMAL;
6610 /* Parse args required to build the message */
6611 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6613 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
6614 rx_sw_if_index_set = 1;
6615 else if (unformat (i, "bd_id %d", &bd_id))
6619 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
6620 rx_sw_if_index_set = 1;
6621 else if (unformat (i, "shg %d", &shg))
6623 else if (unformat (i, "bvi"))
6624 port_type = L2_API_PORT_TYPE_BVI;
6625 else if (unformat (i, "uu-fwd"))
6626 port_type = L2_API_PORT_TYPE_UU_FWD;
6627 else if (unformat (i, "enable"))
6629 else if (unformat (i, "disable"))
6635 if (rx_sw_if_index_set == 0)
6637 errmsg ("missing rx interface name or sw_if_index");
6641 if (enable && (bd_id_set == 0))
6643 errmsg ("missing bridge domain");
6647 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
6649 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6650 mp->bd_id = ntohl (bd_id);
6652 mp->port_type = ntohl (port_type);
6653 mp->enable = enable;
6661 api_bridge_domain_dump (vat_main_t * vam)
6663 unformat_input_t *i = vam->input;
6664 vl_api_bridge_domain_dump_t *mp;
6665 vl_api_control_ping_t *mp_ping;
6669 /* Parse args required to build the message */
6670 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6672 if (unformat (i, "bd_id %d", &bd_id))
6678 M (BRIDGE_DOMAIN_DUMP, mp);
6679 mp->bd_id = ntohl (bd_id);
6682 /* Use a control ping for synchronization */
6683 MPING (CONTROL_PING, mp_ping);
6691 api_bridge_domain_add_del (vat_main_t * vam)
6693 unformat_input_t *i = vam->input;
6694 vl_api_bridge_domain_add_del_t *mp;
6697 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
6702 /* Parse args required to build the message */
6703 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6705 if (unformat (i, "bd_id %d", &bd_id))
6707 else if (unformat (i, "flood %d", &flood))
6709 else if (unformat (i, "uu-flood %d", &uu_flood))
6711 else if (unformat (i, "forward %d", &forward))
6713 else if (unformat (i, "learn %d", &learn))
6715 else if (unformat (i, "arp-term %d", &arp_term))
6717 else if (unformat (i, "mac-age %d", &mac_age))
6719 else if (unformat (i, "bd-tag %s", &bd_tag))
6721 else if (unformat (i, "del"))
6724 flood = uu_flood = forward = learn = 0;
6732 errmsg ("missing bridge domain");
6739 errmsg ("mac age must be less than 256 ");
6744 if ((bd_tag) && (vec_len (bd_tag) > 63))
6746 errmsg ("bd-tag cannot be longer than 63");
6751 M (BRIDGE_DOMAIN_ADD_DEL, mp);
6753 mp->bd_id = ntohl (bd_id);
6755 mp->uu_flood = uu_flood;
6756 mp->forward = forward;
6758 mp->arp_term = arp_term;
6759 mp->is_add = is_add;
6760 mp->mac_age = (u8) mac_age;
6763 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
6764 mp->bd_tag[vec_len (bd_tag)] = 0;
6775 api_l2fib_flush_bd (vat_main_t * vam)
6777 unformat_input_t *i = vam->input;
6778 vl_api_l2fib_flush_bd_t *mp;
6782 /* Parse args required to build the message */
6783 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6785 if (unformat (i, "bd_id %d", &bd_id));
6792 errmsg ("missing bridge domain");
6796 M (L2FIB_FLUSH_BD, mp);
6798 mp->bd_id = htonl (bd_id);
6806 api_l2fib_flush_int (vat_main_t * vam)
6808 unformat_input_t *i = vam->input;
6809 vl_api_l2fib_flush_int_t *mp;
6810 u32 sw_if_index = ~0;
6813 /* Parse args required to build the message */
6814 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6816 if (unformat (i, "sw_if_index %d", &sw_if_index));
6818 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
6823 if (sw_if_index == ~0)
6825 errmsg ("missing interface name or sw_if_index");
6829 M (L2FIB_FLUSH_INT, mp);
6831 mp->sw_if_index = ntohl (sw_if_index);
6839 api_l2fib_add_del (vat_main_t * vam)
6841 unformat_input_t *i = vam->input;
6842 vl_api_l2fib_add_del_t *mp;
6848 u32 sw_if_index = 0;
6849 u8 sw_if_index_set = 0;
6858 /* Parse args required to build the message */
6859 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6861 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
6863 else if (unformat (i, "bd_id %d", &bd_id))
6865 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6866 sw_if_index_set = 1;
6867 else if (unformat (i, "sw_if"))
6869 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6872 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6873 sw_if_index_set = 1;
6878 else if (unformat (i, "static"))
6880 else if (unformat (i, "filter"))
6885 else if (unformat (i, "bvi"))
6890 else if (unformat (i, "del"))
6892 else if (unformat (i, "count %d", &count))
6900 errmsg ("missing mac address");
6906 errmsg ("missing bridge domain");
6910 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
6912 errmsg ("missing interface name or sw_if_index");
6918 /* Turn on async mode */
6919 vam->async_mode = 1;
6920 vam->async_errors = 0;
6921 before = vat_time_now (vam);
6924 for (j = 0; j < count; j++)
6926 M (L2FIB_ADD_DEL, mp);
6928 clib_memcpy (mp->mac, mac, 6);
6929 mp->bd_id = ntohl (bd_id);
6930 mp->is_add = is_add;
6931 mp->sw_if_index = ntohl (sw_if_index);
6935 mp->static_mac = static_mac;
6936 mp->filter_mac = filter_mac;
6937 mp->bvi_mac = bvi_mac;
6939 increment_mac_address (mac);
6946 vl_api_control_ping_t *mp_ping;
6949 /* Shut off async mode */
6950 vam->async_mode = 0;
6952 MPING (CONTROL_PING, mp_ping);
6955 timeout = vat_time_now (vam) + 1.0;
6956 while (vat_time_now (vam) < timeout)
6957 if (vam->result_ready == 1)
6962 if (vam->retval == -99)
6965 if (vam->async_errors > 0)
6967 errmsg ("%d asynchronous errors", vam->async_errors);
6970 vam->async_errors = 0;
6971 after = vat_time_now (vam);
6973 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6974 count, after - before, count / (after - before));
6980 /* Wait for a reply... */
6984 /* Return the good/bad news */
6985 return (vam->retval);
6989 api_bridge_domain_set_mac_age (vat_main_t * vam)
6991 unformat_input_t *i = vam->input;
6992 vl_api_bridge_domain_set_mac_age_t *mp;
6997 /* Parse args required to build the message */
6998 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7000 if (unformat (i, "bd_id %d", &bd_id));
7001 else if (unformat (i, "mac-age %d", &mac_age));
7008 errmsg ("missing bridge domain");
7014 errmsg ("mac age must be less than 256 ");
7018 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
7020 mp->bd_id = htonl (bd_id);
7021 mp->mac_age = (u8) mac_age;
7029 api_l2_flags (vat_main_t * vam)
7031 unformat_input_t *i = vam->input;
7032 vl_api_l2_flags_t *mp;
7035 u8 sw_if_index_set = 0;
7039 /* Parse args required to build the message */
7040 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7042 if (unformat (i, "sw_if_index %d", &sw_if_index))
7043 sw_if_index_set = 1;
7044 else if (unformat (i, "sw_if"))
7046 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7049 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7050 sw_if_index_set = 1;
7055 else if (unformat (i, "learn"))
7057 else if (unformat (i, "forward"))
7059 else if (unformat (i, "flood"))
7061 else if (unformat (i, "uu-flood"))
7062 flags |= L2_UU_FLOOD;
7063 else if (unformat (i, "arp-term"))
7064 flags |= L2_ARP_TERM;
7065 else if (unformat (i, "off"))
7067 else if (unformat (i, "disable"))
7073 if (sw_if_index_set == 0)
7075 errmsg ("missing interface name or sw_if_index");
7081 mp->sw_if_index = ntohl (sw_if_index);
7082 mp->feature_bitmap = ntohl (flags);
7083 mp->is_set = is_set;
7091 api_bridge_flags (vat_main_t * vam)
7093 unformat_input_t *i = vam->input;
7094 vl_api_bridge_flags_t *mp;
7098 bd_flags_t flags = 0;
7101 /* Parse args required to build the message */
7102 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7104 if (unformat (i, "bd_id %d", &bd_id))
7106 else if (unformat (i, "learn"))
7107 flags |= BRIDGE_API_FLAG_LEARN;
7108 else if (unformat (i, "forward"))
7109 flags |= BRIDGE_API_FLAG_FWD;
7110 else if (unformat (i, "flood"))
7111 flags |= BRIDGE_API_FLAG_FLOOD;
7112 else if (unformat (i, "uu-flood"))
7113 flags |= BRIDGE_API_FLAG_UU_FLOOD;
7114 else if (unformat (i, "arp-term"))
7115 flags |= BRIDGE_API_FLAG_ARP_TERM;
7116 else if (unformat (i, "off"))
7118 else if (unformat (i, "disable"))
7126 errmsg ("missing bridge domain");
7130 M (BRIDGE_FLAGS, mp);
7132 mp->bd_id = ntohl (bd_id);
7133 mp->flags = ntohl (flags);
7134 mp->is_set = is_set;
7142 api_bd_ip_mac_add_del (vat_main_t * vam)
7144 vl_api_address_t ip = VL_API_ZERO_ADDRESS;
7145 vl_api_mac_address_t mac = { 0 };
7146 unformat_input_t *i = vam->input;
7147 vl_api_bd_ip_mac_add_del_t *mp;
7156 /* Parse args required to build the message */
7157 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7159 if (unformat (i, "bd_id %d", &bd_id))
7163 else if (unformat (i, "%U", unformat_vl_api_address, &ip))
7167 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
7171 else if (unformat (i, "del"))
7179 errmsg ("missing bridge domain");
7182 else if (ip_set == 0)
7184 errmsg ("missing IP address");
7187 else if (mac_set == 0)
7189 errmsg ("missing MAC address");
7193 M (BD_IP_MAC_ADD_DEL, mp);
7195 mp->entry.bd_id = ntohl (bd_id);
7196 mp->is_add = is_add;
7198 clib_memcpy (&mp->entry.ip, &ip, sizeof (ip));
7199 clib_memcpy (&mp->entry.mac, &mac, sizeof (mac));
7207 api_bd_ip_mac_flush (vat_main_t * vam)
7209 unformat_input_t *i = vam->input;
7210 vl_api_bd_ip_mac_flush_t *mp;
7215 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7217 if (unformat (i, "bd_id %d", &bd_id))
7227 errmsg ("missing bridge domain");
7231 M (BD_IP_MAC_FLUSH, mp);
7233 mp->bd_id = ntohl (bd_id);
7240 static void vl_api_bd_ip_mac_details_t_handler
7241 (vl_api_bd_ip_mac_details_t * mp)
7243 vat_main_t *vam = &vat_main;
7247 ntohl (mp->entry.bd_id),
7248 format_vl_api_mac_address, mp->entry.mac,
7249 format_vl_api_address, &mp->entry.ip);
7252 static void vl_api_bd_ip_mac_details_t_handler_json
7253 (vl_api_bd_ip_mac_details_t * mp)
7255 vat_main_t *vam = &vat_main;
7256 vat_json_node_t *node = NULL;
7258 if (VAT_JSON_ARRAY != vam->json_tree.type)
7260 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7261 vat_json_init_array (&vam->json_tree);
7263 node = vat_json_array_add (&vam->json_tree);
7265 vat_json_init_object (node);
7266 vat_json_object_add_uint (node, "bd_id", ntohl (mp->entry.bd_id));
7267 vat_json_object_add_string_copy (node, "mac_address",
7268 format (0, "%U", format_vl_api_mac_address,
7272 ip = format (0, "%U", format_vl_api_address, &mp->entry.ip);
7273 vat_json_object_add_string_copy (node, "ip_address", ip);
7278 api_bd_ip_mac_dump (vat_main_t * vam)
7280 unformat_input_t *i = vam->input;
7281 vl_api_bd_ip_mac_dump_t *mp;
7282 vl_api_control_ping_t *mp_ping;
7287 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7289 if (unformat (i, "bd_id %d", &bd_id))
7298 "\n%-5s %-7s %-20s %-30s",
7299 "bd_id", "is_ipv6", "mac_address", "ip_address");
7301 /* Dump Bridge Domain Ip to Mac entries */
7302 M (BD_IP_MAC_DUMP, mp);
7305 mp->bd_id = htonl (bd_id);
7311 /* Use a control ping for synchronization */
7312 MPING (CONTROL_PING, mp_ping);
7320 api_tap_create_v2 (vat_main_t * vam)
7322 unformat_input_t *i = vam->input;
7323 vl_api_tap_create_v2_t *mp;
7324 #define TAP_FLAG_GSO (1 << 0)
7328 u8 *host_if_name = 0;
7330 u8 host_mac_addr[6];
7331 u8 host_mac_addr_set = 0;
7332 u8 *host_bridge = 0;
7333 ip4_address_t host_ip4_addr;
7334 ip4_address_t host_ip4_gw;
7335 u8 host_ip4_gw_set = 0;
7336 u32 host_ip4_prefix_len = 0;
7337 ip6_address_t host_ip6_addr;
7338 ip6_address_t host_ip6_gw;
7339 u8 host_ip6_gw_set = 0;
7340 u32 host_ip6_prefix_len = 0;
7341 u8 host_mtu_set = 0;
7342 u32 host_mtu_size = 0;
7345 u32 rx_ring_sz = 0, tx_ring_sz = 0;
7347 clib_memset (mac_address, 0, sizeof (mac_address));
7349 /* Parse args required to build the message */
7350 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7352 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7356 else if (unformat (i, "id %u", &id))
7358 else if (unformat (i, "host-if-name %s", &host_if_name))
7360 else if (unformat (i, "host-ns %s", &host_ns))
7362 else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
7364 host_mac_addr_set = 1;
7365 else if (unformat (i, "host-bridge %s", &host_bridge))
7367 else if (unformat (i, "host-ip4-addr %U/%d", unformat_ip4_address,
7368 &host_ip4_addr, &host_ip4_prefix_len))
7370 else if (unformat (i, "host-ip6-addr %U/%d", unformat_ip6_address,
7371 &host_ip6_addr, &host_ip6_prefix_len))
7373 else if (unformat (i, "host-ip4-gw %U", unformat_ip4_address,
7375 host_ip4_gw_set = 1;
7376 else if (unformat (i, "host-ip6-gw %U", unformat_ip6_address,
7378 host_ip6_gw_set = 1;
7379 else if (unformat (i, "rx-ring-size %d", &rx_ring_sz))
7381 else if (unformat (i, "tx-ring-size %d", &tx_ring_sz))
7383 else if (unformat (i, "host-mtu-size %d", &host_mtu_size))
7385 else if (unformat (i, "no-gso"))
7386 tap_flags &= ~TAP_FLAG_GSO;
7387 else if (unformat (i, "gso"))
7388 tap_flags |= TAP_FLAG_GSO;
7393 if (vec_len (host_if_name) > 63)
7395 errmsg ("tap name too long. ");
7398 if (vec_len (host_ns) > 63)
7400 errmsg ("host name space too long. ");
7403 if (vec_len (host_bridge) > 63)
7405 errmsg ("host bridge name too long. ");
7408 if (host_ip4_prefix_len > 32)
7410 errmsg ("host ip4 prefix length not valid. ");
7413 if (host_ip6_prefix_len > 128)
7415 errmsg ("host ip6 prefix length not valid. ");
7418 if (!is_pow2 (rx_ring_sz))
7420 errmsg ("rx ring size must be power of 2. ");
7423 if (rx_ring_sz > 32768)
7425 errmsg ("rx ring size must be 32768 or lower. ");
7428 if (!is_pow2 (tx_ring_sz))
7430 errmsg ("tx ring size must be power of 2. ");
7433 if (tx_ring_sz > 32768)
7435 errmsg ("tx ring size must be 32768 or lower. ");
7438 if (host_mtu_set && (host_mtu_size < 64 || host_mtu_size > 65355))
7440 errmsg ("host MTU size must be in between 64 and 65355. ");
7444 /* Construct the API message */
7445 M (TAP_CREATE_V2, mp);
7447 mp->use_random_mac = random_mac;
7449 mp->id = ntohl (id);
7450 mp->host_namespace_set = host_ns != 0;
7451 mp->host_bridge_set = host_bridge != 0;
7452 mp->host_ip4_addr_set = host_ip4_prefix_len != 0;
7453 mp->host_ip6_addr_set = host_ip6_prefix_len != 0;
7454 mp->rx_ring_sz = ntohs (rx_ring_sz);
7455 mp->tx_ring_sz = ntohs (tx_ring_sz);
7456 mp->host_mtu_set = host_mtu_set;
7457 mp->host_mtu_size = ntohl (host_mtu_size);
7458 mp->tap_flags = ntohl (tap_flags);
7460 if (random_mac == 0)
7461 clib_memcpy (mp->mac_address, mac_address, 6);
7462 if (host_mac_addr_set)
7463 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
7465 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
7467 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
7469 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
7470 if (host_ip4_prefix_len)
7471 clib_memcpy (mp->host_ip4_addr, &host_ip4_addr, 4);
7472 if (host_ip6_prefix_len)
7473 clib_memcpy (mp->host_ip6_addr, &host_ip6_addr, 16);
7474 if (host_ip4_gw_set)
7475 clib_memcpy (mp->host_ip4_gw, &host_ip4_gw, 4);
7476 if (host_ip6_gw_set)
7477 clib_memcpy (mp->host_ip6_gw, &host_ip6_gw, 16);
7480 vec_free (host_if_name);
7481 vec_free (host_bridge);
7486 /* Wait for a reply... */
7492 api_tap_delete_v2 (vat_main_t * vam)
7494 unformat_input_t *i = vam->input;
7495 vl_api_tap_delete_v2_t *mp;
7496 u32 sw_if_index = ~0;
7497 u8 sw_if_index_set = 0;
7500 /* Parse args required to build the message */
7501 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7503 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7504 sw_if_index_set = 1;
7505 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7506 sw_if_index_set = 1;
7511 if (sw_if_index_set == 0)
7513 errmsg ("missing vpp interface name. ");
7517 /* Construct the API message */
7518 M (TAP_DELETE_V2, mp);
7520 mp->sw_if_index = ntohl (sw_if_index);
7525 /* Wait for a reply... */
7531 unformat_pci_addr (unformat_input_t * input, va_list * args)
7540 addr = va_arg (*args, struct pci_addr_t *);
7543 if (!unformat (input, "%x:%x:%x.%x", &x[0], &x[1], &x[2], &x[3]))
7546 addr->domain = x[0];
7549 addr->function = x[3];
7555 api_virtio_pci_create (vat_main_t * vam)
7557 unformat_input_t *i = vam->input;
7558 vl_api_virtio_pci_create_t *mp;
7563 u64 features = (u64) ~ (0ULL);
7566 clib_memset (mac_address, 0, sizeof (mac_address));
7568 /* Parse args required to build the message */
7569 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7571 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7575 else if (unformat (i, "pci-addr %U", unformat_pci_addr, &pci_addr))
7577 else if (unformat (i, "features 0x%llx", &features))
7579 else if (unformat (i, "gso-enabled"))
7587 errmsg ("pci address must be non zero. ");
7591 /* Construct the API message */
7592 M (VIRTIO_PCI_CREATE, mp);
7594 mp->use_random_mac = random_mac;
7596 mp->pci_addr = htonl (pci_addr);
7597 mp->features = clib_host_to_net_u64 (features);
7598 mp->gso_enabled = gso_enabled;
7600 if (random_mac == 0)
7601 clib_memcpy (mp->mac_address, mac_address, 6);
7606 /* Wait for a reply... */
7612 api_virtio_pci_delete (vat_main_t * vam)
7614 unformat_input_t *i = vam->input;
7615 vl_api_virtio_pci_delete_t *mp;
7616 u32 sw_if_index = ~0;
7617 u8 sw_if_index_set = 0;
7620 /* Parse args required to build the message */
7621 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7623 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7624 sw_if_index_set = 1;
7625 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7626 sw_if_index_set = 1;
7631 if (sw_if_index_set == 0)
7633 errmsg ("missing vpp interface name. ");
7637 /* Construct the API message */
7638 M (VIRTIO_PCI_DELETE, mp);
7640 mp->sw_if_index = htonl (sw_if_index);
7645 /* Wait for a reply... */
7651 api_bond_create (vat_main_t * vam)
7653 unformat_input_t *i = vam->input;
7654 vl_api_bond_create_t *mp;
7664 clib_memset (mac_address, 0, sizeof (mac_address));
7667 /* Parse args required to build the message */
7668 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7670 if (unformat (i, "mode %U", unformat_bond_mode, &mode))
7672 else if (((mode == BOND_MODE_LACP) || (mode == BOND_MODE_XOR))
7673 && unformat (i, "lb %U", unformat_bond_load_balance, &lb))
7675 else if (unformat (i, "hw-addr %U", unformat_ethernet_address,
7678 else if (unformat (i, "numa-only"))
7680 else if (unformat (i, "id %u", &id))
7686 if (mode_is_set == 0)
7688 errmsg ("Missing bond mode. ");
7692 /* Construct the API message */
7693 M (BOND_CREATE, mp);
7695 mp->use_custom_mac = custom_mac;
7699 mp->id = htonl (id);
7700 mp->numa_only = numa_only;
7703 clib_memcpy (mp->mac_address, mac_address, 6);
7708 /* Wait for a reply... */
7714 api_bond_delete (vat_main_t * vam)
7716 unformat_input_t *i = vam->input;
7717 vl_api_bond_delete_t *mp;
7718 u32 sw_if_index = ~0;
7719 u8 sw_if_index_set = 0;
7722 /* Parse args required to build the message */
7723 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7725 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7726 sw_if_index_set = 1;
7727 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7728 sw_if_index_set = 1;
7733 if (sw_if_index_set == 0)
7735 errmsg ("missing vpp interface name. ");
7739 /* Construct the API message */
7740 M (BOND_DELETE, mp);
7742 mp->sw_if_index = ntohl (sw_if_index);
7747 /* Wait for a reply... */
7753 api_bond_enslave (vat_main_t * vam)
7755 unformat_input_t *i = vam->input;
7756 vl_api_bond_enslave_t *mp;
7757 u32 bond_sw_if_index;
7761 u32 bond_sw_if_index_is_set = 0;
7763 u8 sw_if_index_is_set = 0;
7765 /* Parse args required to build the message */
7766 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7768 if (unformat (i, "sw_if_index %d", &sw_if_index))
7769 sw_if_index_is_set = 1;
7770 else if (unformat (i, "bond %u", &bond_sw_if_index))
7771 bond_sw_if_index_is_set = 1;
7772 else if (unformat (i, "passive %d", &is_passive))
7774 else if (unformat (i, "long-timeout %d", &is_long_timeout))
7780 if (bond_sw_if_index_is_set == 0)
7782 errmsg ("Missing bond sw_if_index. ");
7785 if (sw_if_index_is_set == 0)
7787 errmsg ("Missing slave sw_if_index. ");
7791 /* Construct the API message */
7792 M (BOND_ENSLAVE, mp);
7794 mp->bond_sw_if_index = ntohl (bond_sw_if_index);
7795 mp->sw_if_index = ntohl (sw_if_index);
7796 mp->is_long_timeout = is_long_timeout;
7797 mp->is_passive = is_passive;
7802 /* Wait for a reply... */
7808 api_bond_detach_slave (vat_main_t * vam)
7810 unformat_input_t *i = vam->input;
7811 vl_api_bond_detach_slave_t *mp;
7812 u32 sw_if_index = ~0;
7813 u8 sw_if_index_set = 0;
7816 /* Parse args required to build the message */
7817 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7819 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7820 sw_if_index_set = 1;
7821 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7822 sw_if_index_set = 1;
7827 if (sw_if_index_set == 0)
7829 errmsg ("missing vpp interface name. ");
7833 /* Construct the API message */
7834 M (BOND_DETACH_SLAVE, mp);
7836 mp->sw_if_index = ntohl (sw_if_index);
7841 /* Wait for a reply... */
7847 api_ip_table_add_del (vat_main_t * vam)
7849 unformat_input_t *i = vam->input;
7850 vl_api_ip_table_add_del_t *mp;
7856 /* Parse args required to build the message */
7857 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7859 if (unformat (i, "ipv6"))
7861 else if (unformat (i, "del"))
7863 else if (unformat (i, "add"))
7865 else if (unformat (i, "table %d", &table_id))
7869 clib_warning ("parse error '%U'", format_unformat_error, i);
7876 errmsg ("missing table-ID");
7880 /* Construct the API message */
7881 M (IP_TABLE_ADD_DEL, mp);
7883 mp->table.table_id = ntohl (table_id);
7884 mp->table.is_ip6 = is_ipv6;
7885 mp->is_add = is_add;
7890 /* Wait for a reply... */
7897 unformat_fib_path (unformat_input_t * input, va_list * args)
7899 vat_main_t *vam = va_arg (*args, vat_main_t *);
7900 vl_api_fib_path_t *path = va_arg (*args, vl_api_fib_path_t *);
7901 u32 weight, preference;
7902 mpls_label_t out_label;
7904 clib_memset (path, 0, sizeof (*path));
7906 path->sw_if_index = ~0;
7910 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7912 if (unformat (input, "%U %U",
7913 unformat_vl_api_ip4_address,
7914 &path->nh.address.ip4,
7915 api_unformat_sw_if_index, vam, &path->sw_if_index))
7917 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7919 else if (unformat (input, "%U %U",
7920 unformat_vl_api_ip6_address,
7921 &path->nh.address.ip6,
7922 api_unformat_sw_if_index, vam, &path->sw_if_index))
7924 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7926 else if (unformat (input, "weight %u", &weight))
7928 path->weight = weight;
7930 else if (unformat (input, "preference %u", &preference))
7932 path->preference = preference;
7934 else if (unformat (input, "%U next-hop-table %d",
7935 unformat_vl_api_ip4_address,
7936 &path->nh.address.ip4, &path->table_id))
7938 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7940 else if (unformat (input, "%U next-hop-table %d",
7941 unformat_vl_api_ip6_address,
7942 &path->nh.address.ip6, &path->table_id))
7944 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7946 else if (unformat (input, "%U",
7947 unformat_vl_api_ip4_address, &path->nh.address.ip4))
7950 * the recursive next-hops are by default in the default table
7953 path->sw_if_index = ~0;
7954 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7956 else if (unformat (input, "%U",
7957 unformat_vl_api_ip6_address, &path->nh.address.ip6))
7960 * the recursive next-hops are by default in the default table
7963 path->sw_if_index = ~0;
7964 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7966 else if (unformat (input, "resolve-via-host"))
7968 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_HOST;
7970 else if (unformat (input, "resolve-via-attached"))
7972 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_ATTACHED;
7974 else if (unformat (input, "ip4-lookup-in-table %d", &path->table_id))
7976 path->type = FIB_API_PATH_TYPE_LOCAL;
7977 path->sw_if_index = ~0;
7978 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7980 else if (unformat (input, "ip6-lookup-in-table %d", &path->table_id))
7982 path->type = FIB_API_PATH_TYPE_LOCAL;
7983 path->sw_if_index = ~0;
7984 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7986 else if (unformat (input, "sw_if_index %d", &path->sw_if_index))
7988 else if (unformat (input, "via-label %d", &path->nh.via_label))
7990 path->proto = FIB_API_PATH_NH_PROTO_MPLS;
7991 path->sw_if_index = ~0;
7993 else if (unformat (input, "l2-input-on %d", &path->sw_if_index))
7995 path->proto = FIB_API_PATH_NH_PROTO_ETHERNET;
7996 path->type = FIB_API_PATH_TYPE_INTERFACE_RX;
7998 else if (unformat (input, "local"))
8000 path->type = FIB_API_PATH_TYPE_LOCAL;
8002 else if (unformat (input, "out-labels"))
8004 while (unformat (input, "%d", &out_label))
8006 path->label_stack[path->n_labels].label = out_label;
8007 path->label_stack[path->n_labels].is_uniform = 0;
8008 path->label_stack[path->n_labels].ttl = 64;
8012 else if (unformat (input, "via"))
8014 /* new path, back up and return */
8015 unformat_put_input (input);
8016 unformat_put_input (input);
8017 unformat_put_input (input);
8018 unformat_put_input (input);
8027 path->proto = ntohl (path->proto);
8028 path->type = ntohl (path->type);
8029 path->flags = ntohl (path->flags);
8030 path->table_id = ntohl (path->table_id);
8031 path->sw_if_index = ntohl (path->sw_if_index);
8037 api_ip_route_add_del (vat_main_t * vam)
8039 unformat_input_t *i = vam->input;
8040 vl_api_ip_route_add_del_t *mp;
8043 u8 is_multipath = 0;
8046 vl_api_prefix_t pfx = { };
8047 vl_api_fib_path_t paths[8];
8051 u32 random_add_del = 0;
8052 u32 *random_vector = 0;
8053 u32 random_seed = 0xdeaddabe;
8055 /* Parse args required to build the message */
8056 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8058 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8060 else if (unformat (i, "del"))
8062 else if (unformat (i, "add"))
8064 else if (unformat (i, "vrf %d", &vrf_id))
8066 else if (unformat (i, "count %d", &count))
8068 else if (unformat (i, "random"))
8070 else if (unformat (i, "multipath"))
8072 else if (unformat (i, "seed %d", &random_seed))
8076 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8079 if (8 == path_count)
8081 errmsg ("max 8 paths");
8087 clib_warning ("parse error '%U'", format_unformat_error, i);
8094 errmsg ("specify a path; via ...");
8097 if (prefix_set == 0)
8099 errmsg ("missing prefix");
8103 /* Generate a pile of unique, random routes */
8106 ip4_address_t *i = (ip4_address_t *) & paths[0].nh.address.ip4;
8107 u32 this_random_address;
8110 random_hash = hash_create (count, sizeof (uword));
8112 hash_set (random_hash, i->as_u32, 1);
8113 for (j = 0; j <= count; j++)
8117 this_random_address = random_u32 (&random_seed);
8118 this_random_address =
8119 clib_host_to_net_u32 (this_random_address);
8121 while (hash_get (random_hash, this_random_address));
8122 vec_add1 (random_vector, this_random_address);
8123 hash_set (random_hash, this_random_address, 1);
8125 hash_free (random_hash);
8126 set_ip4_address (&pfx.address, random_vector[0]);
8131 /* Turn on async mode */
8132 vam->async_mode = 1;
8133 vam->async_errors = 0;
8134 before = vat_time_now (vam);
8137 for (j = 0; j < count; j++)
8139 /* Construct the API message */
8140 M2 (IP_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8142 mp->is_add = is_add;
8143 mp->is_multipath = is_multipath;
8145 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8146 mp->route.table_id = ntohl (vrf_id);
8147 mp->route.n_paths = path_count;
8149 clib_memcpy (&mp->route.paths, &paths, sizeof (paths[0]) * path_count);
8152 set_ip4_address (&pfx.address, random_vector[j + 1]);
8154 increment_address (&pfx.address);
8157 /* If we receive SIGTERM, stop now... */
8162 /* When testing multiple add/del ops, use a control-ping to sync */
8165 vl_api_control_ping_t *mp_ping;
8169 /* Shut off async mode */
8170 vam->async_mode = 0;
8172 MPING (CONTROL_PING, mp_ping);
8175 timeout = vat_time_now (vam) + 1.0;
8176 while (vat_time_now (vam) < timeout)
8177 if (vam->result_ready == 1)
8182 if (vam->retval == -99)
8185 if (vam->async_errors > 0)
8187 errmsg ("%d asynchronous errors", vam->async_errors);
8190 vam->async_errors = 0;
8191 after = vat_time_now (vam);
8193 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8197 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8198 count, after - before, count / (after - before));
8204 /* Wait for a reply... */
8209 /* Return the good/bad news */
8210 return (vam->retval);
8214 api_ip_mroute_add_del (vat_main_t * vam)
8216 unformat_input_t *i = vam->input;
8217 u8 path_set = 0, prefix_set = 0, is_add = 1;
8218 vl_api_ip_mroute_add_del_t *mp;
8219 mfib_entry_flags_t eflags = 0;
8220 vl_api_mfib_path_t path;
8221 vl_api_mprefix_t pfx = { };
8225 /* Parse args required to build the message */
8226 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8228 if (unformat (i, "%U", unformat_vl_api_mprefix, &pfx))
8231 pfx.grp_address_length = htons (pfx.grp_address_length);
8233 else if (unformat (i, "del"))
8235 else if (unformat (i, "add"))
8237 else if (unformat (i, "vrf %d", &vrf_id))
8239 else if (unformat (i, "%U", unformat_mfib_itf_flags, &path.itf_flags))
8240 path.itf_flags = htonl (path.itf_flags);
8241 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8243 else if (unformat (i, "via %U", unformat_fib_path, vam, &path.path))
8247 clib_warning ("parse error '%U'", format_unformat_error, i);
8252 if (prefix_set == 0)
8254 errmsg ("missing addresses\n");
8259 errmsg ("missing path\n");
8263 /* Construct the API message */
8264 M (IP_MROUTE_ADD_DEL, mp);
8266 mp->is_add = is_add;
8267 mp->is_multipath = 1;
8269 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8270 mp->route.table_id = htonl (vrf_id);
8271 mp->route.n_paths = 1;
8272 mp->route.entry_flags = htonl (eflags);
8274 clib_memcpy (&mp->route.paths, &path, sizeof (path));
8278 /* Wait for a reply... */
8284 api_mpls_table_add_del (vat_main_t * vam)
8286 unformat_input_t *i = vam->input;
8287 vl_api_mpls_table_add_del_t *mp;
8292 /* Parse args required to build the message */
8293 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8295 if (unformat (i, "table %d", &table_id))
8297 else if (unformat (i, "del"))
8299 else if (unformat (i, "add"))
8303 clib_warning ("parse error '%U'", format_unformat_error, i);
8310 errmsg ("missing table-ID");
8314 /* Construct the API message */
8315 M (MPLS_TABLE_ADD_DEL, mp);
8317 mp->mt_table.mt_table_id = ntohl (table_id);
8318 mp->mt_is_add = is_add;
8323 /* Wait for a reply... */
8330 api_mpls_route_add_del (vat_main_t * vam)
8332 u8 is_add = 1, path_count = 0, is_multipath = 0, is_eos = 0;
8333 mpls_label_t local_label = MPLS_LABEL_INVALID;
8334 unformat_input_t *i = vam->input;
8335 vl_api_mpls_route_add_del_t *mp;
8336 vl_api_fib_path_t paths[8];
8340 /* Parse args required to build the message */
8341 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8343 if (unformat (i, "%d", &local_label))
8345 else if (unformat (i, "eos"))
8347 else if (unformat (i, "non-eos"))
8349 else if (unformat (i, "del"))
8351 else if (unformat (i, "add"))
8353 else if (unformat (i, "multipath"))
8355 else if (unformat (i, "count %d", &count))
8359 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8362 if (8 == path_count)
8364 errmsg ("max 8 paths");
8370 clib_warning ("parse error '%U'", format_unformat_error, i);
8377 errmsg ("specify a path; via ...");
8381 if (MPLS_LABEL_INVALID == local_label)
8383 errmsg ("missing label");
8389 /* Turn on async mode */
8390 vam->async_mode = 1;
8391 vam->async_errors = 0;
8392 before = vat_time_now (vam);
8395 for (j = 0; j < count; j++)
8397 /* Construct the API message */
8398 M2 (MPLS_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8400 mp->mr_is_add = is_add;
8401 mp->mr_is_multipath = is_multipath;
8403 mp->mr_route.mr_label = local_label;
8404 mp->mr_route.mr_eos = is_eos;
8405 mp->mr_route.mr_table_id = 0;
8406 mp->mr_route.mr_n_paths = path_count;
8408 clib_memcpy (&mp->mr_route.mr_paths, paths,
8409 sizeof (paths[0]) * path_count);
8415 /* If we receive SIGTERM, stop now... */
8420 /* When testing multiple add/del ops, use a control-ping to sync */
8423 vl_api_control_ping_t *mp_ping;
8427 /* Shut off async mode */
8428 vam->async_mode = 0;
8430 MPING (CONTROL_PING, mp_ping);
8433 timeout = vat_time_now (vam) + 1.0;
8434 while (vat_time_now (vam) < timeout)
8435 if (vam->result_ready == 1)
8440 if (vam->retval == -99)
8443 if (vam->async_errors > 0)
8445 errmsg ("%d asynchronous errors", vam->async_errors);
8448 vam->async_errors = 0;
8449 after = vat_time_now (vam);
8451 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8455 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8456 count, after - before, count / (after - before));
8462 /* Wait for a reply... */
8467 /* Return the good/bad news */
8468 return (vam->retval);
8473 api_mpls_ip_bind_unbind (vat_main_t * vam)
8475 unformat_input_t *i = vam->input;
8476 vl_api_mpls_ip_bind_unbind_t *mp;
8477 u32 ip_table_id = 0;
8479 vl_api_prefix_t pfx;
8481 mpls_label_t local_label = MPLS_LABEL_INVALID;
8484 /* Parse args required to build the message */
8485 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8487 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8489 else if (unformat (i, "%d", &local_label))
8491 else if (unformat (i, "table-id %d", &ip_table_id))
8493 else if (unformat (i, "unbind"))
8495 else if (unformat (i, "bind"))
8499 clib_warning ("parse error '%U'", format_unformat_error, i);
8506 errmsg ("IP prefix not set");
8510 if (MPLS_LABEL_INVALID == local_label)
8512 errmsg ("missing label");
8516 /* Construct the API message */
8517 M (MPLS_IP_BIND_UNBIND, mp);
8519 mp->mb_is_bind = is_bind;
8520 mp->mb_ip_table_id = ntohl (ip_table_id);
8521 mp->mb_mpls_table_id = 0;
8522 mp->mb_label = ntohl (local_label);
8523 clib_memcpy (&mp->mb_prefix, &pfx, sizeof (pfx));
8528 /* Wait for a reply... */
8535 api_sr_mpls_policy_add (vat_main_t * vam)
8537 unformat_input_t *i = vam->input;
8538 vl_api_sr_mpls_policy_add_t *mp;
8544 u32 *segments = NULL;
8547 /* Parse args required to build the message */
8548 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8550 if (unformat (i, "bsid %d", &bsid))
8552 else if (unformat (i, "weight %d", &weight))
8554 else if (unformat (i, "spray"))
8556 else if (unformat (i, "next %d", &sid))
8559 vec_add1 (segments, htonl (sid));
8563 clib_warning ("parse error '%U'", format_unformat_error, i);
8570 errmsg ("bsid not set");
8574 if (n_segments == 0)
8576 errmsg ("no sid in segment stack");
8580 /* Construct the API message */
8581 M2 (SR_MPLS_POLICY_ADD, mp, sizeof (u32) * n_segments);
8583 mp->bsid = htonl (bsid);
8584 mp->weight = htonl (weight);
8586 mp->n_segments = n_segments;
8587 memcpy (mp->segments, segments, sizeof (u32) * n_segments);
8588 vec_free (segments);
8593 /* Wait for a reply... */
8599 api_sr_mpls_policy_del (vat_main_t * vam)
8601 unformat_input_t *i = vam->input;
8602 vl_api_sr_mpls_policy_del_t *mp;
8606 /* Parse args required to build the message */
8607 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8609 if (unformat (i, "bsid %d", &bsid))
8613 clib_warning ("parse error '%U'", format_unformat_error, i);
8620 errmsg ("bsid not set");
8624 /* Construct the API message */
8625 M (SR_MPLS_POLICY_DEL, mp);
8627 mp->bsid = htonl (bsid);
8632 /* Wait for a reply... */
8638 api_bier_table_add_del (vat_main_t * vam)
8640 unformat_input_t *i = vam->input;
8641 vl_api_bier_table_add_del_t *mp;
8643 u32 set = 0, sub_domain = 0, hdr_len = 3;
8644 mpls_label_t local_label = MPLS_LABEL_INVALID;
8647 /* Parse args required to build the message */
8648 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8650 if (unformat (i, "sub-domain %d", &sub_domain))
8652 else if (unformat (i, "set %d", &set))
8654 else if (unformat (i, "label %d", &local_label))
8656 else if (unformat (i, "hdr-len %d", &hdr_len))
8658 else if (unformat (i, "add"))
8660 else if (unformat (i, "del"))
8664 clib_warning ("parse error '%U'", format_unformat_error, i);
8669 if (MPLS_LABEL_INVALID == local_label)
8671 errmsg ("missing label\n");
8675 /* Construct the API message */
8676 M (BIER_TABLE_ADD_DEL, mp);
8678 mp->bt_is_add = is_add;
8679 mp->bt_label = ntohl (local_label);
8680 mp->bt_tbl_id.bt_set = set;
8681 mp->bt_tbl_id.bt_sub_domain = sub_domain;
8682 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
8687 /* Wait for a reply... */
8694 api_bier_route_add_del (vat_main_t * vam)
8696 unformat_input_t *i = vam->input;
8697 vl_api_bier_route_add_del_t *mp;
8699 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
8700 ip4_address_t v4_next_hop_address;
8701 ip6_address_t v6_next_hop_address;
8702 u8 next_hop_set = 0;
8703 u8 next_hop_proto_is_ip4 = 1;
8704 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8707 /* Parse args required to build the message */
8708 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8710 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
8712 next_hop_proto_is_ip4 = 1;
8715 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
8717 next_hop_proto_is_ip4 = 0;
8720 if (unformat (i, "sub-domain %d", &sub_domain))
8722 else if (unformat (i, "set %d", &set))
8724 else if (unformat (i, "hdr-len %d", &hdr_len))
8726 else if (unformat (i, "bp %d", &bp))
8728 else if (unformat (i, "add"))
8730 else if (unformat (i, "del"))
8732 else if (unformat (i, "out-label %d", &next_hop_out_label))
8736 clib_warning ("parse error '%U'", format_unformat_error, i);
8741 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
8743 errmsg ("next hop / label set\n");
8748 errmsg ("bit=position not set\n");
8752 /* Construct the API message */
8753 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t));
8755 mp->br_is_add = is_add;
8756 mp->br_route.br_tbl_id.bt_set = set;
8757 mp->br_route.br_tbl_id.bt_sub_domain = sub_domain;
8758 mp->br_route.br_tbl_id.bt_hdr_len_id = hdr_len;
8759 mp->br_route.br_bp = ntohs (bp);
8760 mp->br_route.br_n_paths = 1;
8761 mp->br_route.br_paths[0].n_labels = 1;
8762 mp->br_route.br_paths[0].label_stack[0].label = ntohl (next_hop_out_label);
8763 mp->br_route.br_paths[0].proto = (next_hop_proto_is_ip4 ?
8764 FIB_API_PATH_NH_PROTO_IP4 :
8765 FIB_API_PATH_NH_PROTO_IP6);
8767 if (next_hop_proto_is_ip4)
8769 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip4,
8770 &v4_next_hop_address, sizeof (v4_next_hop_address));
8774 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip6,
8775 &v6_next_hop_address, sizeof (v6_next_hop_address));
8781 /* Wait for a reply... */
8788 api_proxy_arp_add_del (vat_main_t * vam)
8790 unformat_input_t *i = vam->input;
8791 vl_api_proxy_arp_add_del_t *mp;
8794 vl_api_ip4_address_t lo, hi;
8798 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8800 if (unformat (i, "vrf %d", &vrf_id))
8802 else if (unformat (i, "%U - %U", unformat_vl_api_ip4_address, &lo,
8803 unformat_vl_api_ip4_address, &hi))
8805 else if (unformat (i, "del"))
8809 clib_warning ("parse error '%U'", format_unformat_error, i);
8816 errmsg ("address range not set");
8820 M (PROXY_ARP_ADD_DEL, mp);
8822 mp->proxy.table_id = ntohl (vrf_id);
8823 mp->is_add = is_add;
8824 clib_memcpy (mp->proxy.low, &lo, sizeof (lo));
8825 clib_memcpy (mp->proxy.hi, &hi, sizeof (hi));
8833 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
8835 unformat_input_t *i = vam->input;
8836 vl_api_proxy_arp_intfc_enable_disable_t *mp;
8839 u8 sw_if_index_set = 0;
8842 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8844 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8845 sw_if_index_set = 1;
8846 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8847 sw_if_index_set = 1;
8848 else if (unformat (i, "enable"))
8850 else if (unformat (i, "disable"))
8854 clib_warning ("parse error '%U'", format_unformat_error, i);
8859 if (sw_if_index_set == 0)
8861 errmsg ("missing interface name or sw_if_index");
8865 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
8867 mp->sw_if_index = ntohl (sw_if_index);
8868 mp->enable_disable = enable;
8876 api_mpls_tunnel_add_del (vat_main_t * vam)
8878 unformat_input_t *i = vam->input;
8879 vl_api_mpls_tunnel_add_del_t *mp;
8881 vl_api_fib_path_t paths[8];
8882 u32 sw_if_index = ~0;
8888 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8890 if (unformat (i, "add"))
8894 (i, "del %U", api_unformat_sw_if_index, vam, &sw_if_index))
8896 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
8898 else if (unformat (i, "l2-only"))
8902 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8905 if (8 == path_count)
8907 errmsg ("max 8 paths");
8913 clib_warning ("parse error '%U'", format_unformat_error, i);
8918 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8920 mp->mt_is_add = is_add;
8921 mp->mt_tunnel.mt_sw_if_index = ntohl (sw_if_index);
8922 mp->mt_tunnel.mt_l2_only = l2_only;
8923 mp->mt_tunnel.mt_is_multicast = 0;
8924 mp->mt_tunnel.mt_n_paths = path_count;
8926 clib_memcpy (&mp->mt_tunnel.mt_paths, &paths,
8927 sizeof (paths[0]) * path_count);
8935 api_sw_interface_set_unnumbered (vat_main_t * vam)
8937 unformat_input_t *i = vam->input;
8938 vl_api_sw_interface_set_unnumbered_t *mp;
8940 u32 unnum_sw_index = ~0;
8942 u8 sw_if_index_set = 0;
8945 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8947 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8948 sw_if_index_set = 1;
8949 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8950 sw_if_index_set = 1;
8951 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
8953 else if (unformat (i, "del"))
8957 clib_warning ("parse error '%U'", format_unformat_error, i);
8962 if (sw_if_index_set == 0)
8964 errmsg ("missing interface name or sw_if_index");
8968 M (SW_INTERFACE_SET_UNNUMBERED, mp);
8970 mp->sw_if_index = ntohl (sw_if_index);
8971 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
8972 mp->is_add = is_add;
8980 api_ip_neighbor_add_del (vat_main_t * vam)
8982 vl_api_mac_address_t mac_address;
8983 unformat_input_t *i = vam->input;
8984 vl_api_ip_neighbor_add_del_t *mp;
8985 vl_api_address_t ip_address;
8987 u8 sw_if_index_set = 0;
8992 ip_neighbor_flags_t flags;
8994 flags = IP_NEIGHBOR_FLAG_NONE;
8995 clib_memset (&ip_address, 0, sizeof (ip_address));
8996 clib_memset (&mac_address, 0, sizeof (mac_address));
8998 /* Parse args required to build the message */
8999 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9001 if (unformat (i, "mac %U", unformat_vl_api_mac_address, &mac_address))
9005 else if (unformat (i, "del"))
9008 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9009 sw_if_index_set = 1;
9010 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9011 sw_if_index_set = 1;
9012 else if (unformat (i, "static"))
9013 flags |= IP_NEIGHBOR_FLAG_STATIC;
9014 else if (unformat (i, "no-fib-entry"))
9015 flags |= IP_NEIGHBOR_FLAG_NO_FIB_ENTRY;
9016 else if (unformat (i, "dst %U", unformat_vl_api_address, &ip_address))
9020 clib_warning ("parse error '%U'", format_unformat_error, i);
9025 if (sw_if_index_set == 0)
9027 errmsg ("missing interface name or sw_if_index");
9032 errmsg ("no address set");
9036 /* Construct the API message */
9037 M (IP_NEIGHBOR_ADD_DEL, mp);
9039 mp->neighbor.sw_if_index = ntohl (sw_if_index);
9040 mp->is_add = is_add;
9041 mp->neighbor.flags = htonl (flags);
9043 clib_memcpy (&mp->neighbor.mac_address, &mac_address,
9044 sizeof (mac_address));
9046 clib_memcpy (&mp->neighbor.ip_address, &ip_address, sizeof (ip_address));
9051 /* Wait for a reply, return good/bad news */
9057 api_create_vlan_subif (vat_main_t * vam)
9059 unformat_input_t *i = vam->input;
9060 vl_api_create_vlan_subif_t *mp;
9062 u8 sw_if_index_set = 0;
9067 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9069 if (unformat (i, "sw_if_index %d", &sw_if_index))
9070 sw_if_index_set = 1;
9072 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9073 sw_if_index_set = 1;
9074 else if (unformat (i, "vlan %d", &vlan_id))
9078 clib_warning ("parse error '%U'", format_unformat_error, i);
9083 if (sw_if_index_set == 0)
9085 errmsg ("missing interface name or sw_if_index");
9089 if (vlan_id_set == 0)
9091 errmsg ("missing vlan_id");
9094 M (CREATE_VLAN_SUBIF, mp);
9096 mp->sw_if_index = ntohl (sw_if_index);
9097 mp->vlan_id = ntohl (vlan_id);
9104 #define foreach_create_subif_bit \
9111 _(outer_vlan_id_any) \
9112 _(inner_vlan_id_any)
9114 #define foreach_create_subif_flag \
9119 _(4, "exact_match") \
9120 _(5, "default_sub") \
9121 _(6, "outer_vlan_id_any") \
9122 _(7, "inner_vlan_id_any")
9125 api_create_subif (vat_main_t * vam)
9127 unformat_input_t *i = vam->input;
9128 vl_api_create_subif_t *mp;
9130 u8 sw_if_index_set = 0;
9133 u32 __attribute__ ((unused)) no_tags = 0;
9134 u32 __attribute__ ((unused)) one_tag = 0;
9135 u32 __attribute__ ((unused)) two_tags = 0;
9136 u32 __attribute__ ((unused)) dot1ad = 0;
9137 u32 __attribute__ ((unused)) exact_match = 0;
9138 u32 __attribute__ ((unused)) default_sub = 0;
9139 u32 __attribute__ ((unused)) outer_vlan_id_any = 0;
9140 u32 __attribute__ ((unused)) inner_vlan_id_any = 0;
9142 u16 outer_vlan_id = 0;
9143 u16 inner_vlan_id = 0;
9146 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9148 if (unformat (i, "sw_if_index %d", &sw_if_index))
9149 sw_if_index_set = 1;
9151 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9152 sw_if_index_set = 1;
9153 else if (unformat (i, "sub_id %d", &sub_id))
9155 else if (unformat (i, "outer_vlan_id %d", &tmp))
9156 outer_vlan_id = tmp;
9157 else if (unformat (i, "inner_vlan_id %d", &tmp))
9158 inner_vlan_id = tmp;
9160 #define _(a) else if (unformat (i, #a)) a = 1 ;
9161 foreach_create_subif_bit
9165 clib_warning ("parse error '%U'", format_unformat_error, i);
9170 if (sw_if_index_set == 0)
9172 errmsg ("missing interface name or sw_if_index");
9176 if (sub_id_set == 0)
9178 errmsg ("missing sub_id");
9181 M (CREATE_SUBIF, mp);
9183 mp->sw_if_index = ntohl (sw_if_index);
9184 mp->sub_id = ntohl (sub_id);
9186 #define _(a,b) mp->sub_if_flags |= (1 << a);
9187 foreach_create_subif_flag;
9190 mp->outer_vlan_id = ntohs (outer_vlan_id);
9191 mp->inner_vlan_id = ntohs (inner_vlan_id);
9199 api_reset_fib (vat_main_t * vam)
9201 unformat_input_t *i = vam->input;
9202 vl_api_reset_fib_t *mp;
9208 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9210 if (unformat (i, "vrf %d", &vrf_id))
9212 else if (unformat (i, "ipv6"))
9216 clib_warning ("parse error '%U'", format_unformat_error, i);
9221 if (vrf_id_set == 0)
9223 errmsg ("missing vrf id");
9229 mp->vrf_id = ntohl (vrf_id);
9230 mp->is_ipv6 = is_ipv6;
9238 api_dhcp_proxy_config (vat_main_t * vam)
9240 unformat_input_t *i = vam->input;
9241 vl_api_dhcp_proxy_config_t *mp;
9243 u32 server_vrf_id = 0;
9245 u8 v4_address_set = 0;
9246 u8 v6_address_set = 0;
9247 ip4_address_t v4address;
9248 ip6_address_t v6address;
9249 u8 v4_src_address_set = 0;
9250 u8 v6_src_address_set = 0;
9251 ip4_address_t v4srcaddress;
9252 ip6_address_t v6srcaddress;
9255 /* Parse args required to build the message */
9256 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9258 if (unformat (i, "del"))
9260 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
9262 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
9264 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
9266 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
9268 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
9269 v4_src_address_set = 1;
9270 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
9271 v6_src_address_set = 1;
9276 if (v4_address_set && v6_address_set)
9278 errmsg ("both v4 and v6 server addresses set");
9281 if (!v4_address_set && !v6_address_set)
9283 errmsg ("no server addresses set");
9287 if (v4_src_address_set && v6_src_address_set)
9289 errmsg ("both v4 and v6 src addresses set");
9292 if (!v4_src_address_set && !v6_src_address_set)
9294 errmsg ("no src addresses set");
9298 if (!(v4_src_address_set && v4_address_set) &&
9299 !(v6_src_address_set && v6_address_set))
9301 errmsg ("no matching server and src addresses set");
9305 /* Construct the API message */
9306 M (DHCP_PROXY_CONFIG, mp);
9308 mp->is_add = is_add;
9309 mp->rx_vrf_id = ntohl (rx_vrf_id);
9310 mp->server_vrf_id = ntohl (server_vrf_id);
9314 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
9315 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
9319 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
9320 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
9326 /* Wait for a reply, return good/bad news */
9331 #define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
9332 #define vl_api_dhcp_proxy_details_t_print vl_noop_handler
9335 vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
9337 vat_main_t *vam = &vat_main;
9338 u32 i, count = mp->count;
9339 vl_api_dhcp_server_t *s;
9343 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9344 "VSS ASCII VPN-ID '%s', VSS RFC2685 VPN-ID (oui:id) %d:%d",
9345 ntohl (mp->rx_vrf_id),
9346 format_ip6_address, mp->dhcp_src_address,
9347 mp->vss_type, mp->vss_vpn_ascii_id,
9348 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9351 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9352 "VSS ASCII VPN-ID '%s', VSS RFC2685 VPN-ID (oui:id) %d:%d",
9353 ntohl (mp->rx_vrf_id),
9354 format_ip4_address, mp->dhcp_src_address,
9355 mp->vss_type, mp->vss_vpn_ascii_id,
9356 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9358 for (i = 0; i < count; i++)
9360 s = &mp->servers[i];
9364 " Server Table-ID %d, Server Address %U",
9365 ntohl (s->server_vrf_id), format_ip6_address, s->dhcp_server);
9368 " Server Table-ID %d, Server Address %U",
9369 ntohl (s->server_vrf_id), format_ip4_address, s->dhcp_server);
9373 static void vl_api_dhcp_proxy_details_t_handler_json
9374 (vl_api_dhcp_proxy_details_t * mp)
9376 vat_main_t *vam = &vat_main;
9377 vat_json_node_t *node = NULL;
9378 u32 i, count = mp->count;
9380 struct in6_addr ip6;
9381 vl_api_dhcp_server_t *s;
9383 if (VAT_JSON_ARRAY != vam->json_tree.type)
9385 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9386 vat_json_init_array (&vam->json_tree);
9388 node = vat_json_array_add (&vam->json_tree);
9390 vat_json_init_object (node);
9391 vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
9392 vat_json_object_add_bytes (node, "vss-type", &mp->vss_type,
9393 sizeof (mp->vss_type));
9394 vat_json_object_add_string_copy (node, "vss-vpn-ascii-id",
9395 mp->vss_vpn_ascii_id);
9396 vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
9397 vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
9401 clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
9402 vat_json_object_add_ip6 (node, "src_address", ip6);
9406 clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
9407 vat_json_object_add_ip4 (node, "src_address", ip4);
9410 for (i = 0; i < count; i++)
9412 s = &mp->servers[i];
9414 vat_json_object_add_uint (node, "server-table-id",
9415 ntohl (s->server_vrf_id));
9419 clib_memcpy (&ip4, &s->dhcp_server, sizeof (ip4));
9420 vat_json_object_add_ip4 (node, "src_address", ip4);
9424 clib_memcpy (&ip6, &s->dhcp_server, sizeof (ip6));
9425 vat_json_object_add_ip6 (node, "server_address", ip6);
9431 api_dhcp_proxy_dump (vat_main_t * vam)
9433 unformat_input_t *i = vam->input;
9434 vl_api_control_ping_t *mp_ping;
9435 vl_api_dhcp_proxy_dump_t *mp;
9439 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9441 if (unformat (i, "ipv6"))
9445 clib_warning ("parse error '%U'", format_unformat_error, i);
9450 M (DHCP_PROXY_DUMP, mp);
9452 mp->is_ip6 = is_ipv6;
9455 /* Use a control ping for synchronization */
9456 MPING (CONTROL_PING, mp_ping);
9464 api_dhcp_proxy_set_vss (vat_main_t * vam)
9466 unformat_input_t *i = vam->input;
9467 vl_api_dhcp_proxy_set_vss_t *mp;
9471 u8 vss_type = VSS_TYPE_DEFAULT;
9472 u8 *vpn_ascii_id = 0;
9477 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9479 if (unformat (i, "tbl_id %d", &tbl_id))
9481 else if (unformat (i, "vpn_ascii_id %s", &vpn_ascii_id))
9482 vss_type = VSS_TYPE_ASCII;
9483 else if (unformat (i, "fib_id %d", &fib_id))
9484 vss_type = VSS_TYPE_VPN_ID;
9485 else if (unformat (i, "oui %d", &oui))
9486 vss_type = VSS_TYPE_VPN_ID;
9487 else if (unformat (i, "ipv6"))
9489 else if (unformat (i, "del"))
9497 errmsg ("missing tbl_id ");
9498 vec_free (vpn_ascii_id);
9502 if ((vpn_ascii_id) && (vec_len (vpn_ascii_id) > 128))
9504 errmsg ("vpn_ascii_id cannot be longer than 128 ");
9505 vec_free (vpn_ascii_id);
9509 M (DHCP_PROXY_SET_VSS, mp);
9510 mp->tbl_id = ntohl (tbl_id);
9511 mp->vss_type = vss_type;
9514 clib_memcpy (mp->vpn_ascii_id, vpn_ascii_id, vec_len (vpn_ascii_id));
9515 mp->vpn_ascii_id[vec_len (vpn_ascii_id)] = 0;
9517 mp->vpn_index = ntohl (fib_id);
9518 mp->oui = ntohl (oui);
9519 mp->is_ipv6 = is_ipv6;
9520 mp->is_add = is_add;
9525 vec_free (vpn_ascii_id);
9530 api_dhcp_client_config (vat_main_t * vam)
9532 unformat_input_t *i = vam->input;
9533 vl_api_dhcp_client_config_t *mp;
9535 u8 sw_if_index_set = 0;
9538 u8 disable_event = 0;
9541 /* Parse args required to build the message */
9542 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9544 if (unformat (i, "del"))
9547 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9548 sw_if_index_set = 1;
9549 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9550 sw_if_index_set = 1;
9551 else if (unformat (i, "hostname %s", &hostname))
9553 else if (unformat (i, "disable_event"))
9559 if (sw_if_index_set == 0)
9561 errmsg ("missing interface name or sw_if_index");
9565 if (vec_len (hostname) > 63)
9567 errmsg ("hostname too long");
9569 vec_add1 (hostname, 0);
9571 /* Construct the API message */
9572 M (DHCP_CLIENT_CONFIG, mp);
9574 mp->is_add = is_add;
9575 mp->client.sw_if_index = htonl (sw_if_index);
9576 clib_memcpy (mp->client.hostname, hostname, vec_len (hostname));
9577 vec_free (hostname);
9578 mp->client.want_dhcp_event = disable_event ? 0 : 1;
9579 mp->client.pid = htonl (getpid ());
9584 /* Wait for a reply, return good/bad news */
9590 api_set_ip_flow_hash (vat_main_t * vam)
9592 unformat_input_t *i = vam->input;
9593 vl_api_set_ip_flow_hash_t *mp;
9605 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9607 if (unformat (i, "vrf %d", &vrf_id))
9609 else if (unformat (i, "ipv6"))
9611 else if (unformat (i, "src"))
9613 else if (unformat (i, "dst"))
9615 else if (unformat (i, "sport"))
9617 else if (unformat (i, "dport"))
9619 else if (unformat (i, "proto"))
9621 else if (unformat (i, "reverse"))
9626 clib_warning ("parse error '%U'", format_unformat_error, i);
9631 if (vrf_id_set == 0)
9633 errmsg ("missing vrf id");
9637 M (SET_IP_FLOW_HASH, mp);
9643 mp->reverse = reverse;
9644 mp->vrf_id = ntohl (vrf_id);
9645 mp->is_ipv6 = is_ipv6;
9653 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
9655 unformat_input_t *i = vam->input;
9656 vl_api_sw_interface_ip6_enable_disable_t *mp;
9658 u8 sw_if_index_set = 0;
9662 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9664 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9665 sw_if_index_set = 1;
9666 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9667 sw_if_index_set = 1;
9668 else if (unformat (i, "enable"))
9670 else if (unformat (i, "disable"))
9674 clib_warning ("parse error '%U'", format_unformat_error, i);
9679 if (sw_if_index_set == 0)
9681 errmsg ("missing interface name or sw_if_index");
9685 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
9687 mp->sw_if_index = ntohl (sw_if_index);
9688 mp->enable = enable;
9696 api_ip6nd_proxy_add_del (vat_main_t * vam)
9698 unformat_input_t *i = vam->input;
9699 vl_api_ip6nd_proxy_add_del_t *mp;
9700 u32 sw_if_index = ~0;
9701 u8 v6_address_set = 0;
9702 vl_api_ip6_address_t v6address;
9706 /* Parse args required to build the message */
9707 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9709 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9711 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9713 else if (unformat (i, "%U", unformat_vl_api_ip6_address, &v6address))
9715 if (unformat (i, "del"))
9719 clib_warning ("parse error '%U'", format_unformat_error, i);
9724 if (sw_if_index == ~0)
9726 errmsg ("missing interface name or sw_if_index");
9729 if (!v6_address_set)
9731 errmsg ("no address set");
9735 /* Construct the API message */
9736 M (IP6ND_PROXY_ADD_DEL, mp);
9738 mp->is_del = is_del;
9739 mp->sw_if_index = ntohl (sw_if_index);
9740 clib_memcpy (mp->ip, v6address, sizeof (v6address));
9745 /* Wait for a reply, return good/bad news */
9751 api_ip6nd_proxy_dump (vat_main_t * vam)
9753 vl_api_ip6nd_proxy_dump_t *mp;
9754 vl_api_control_ping_t *mp_ping;
9757 M (IP6ND_PROXY_DUMP, mp);
9761 /* Use a control ping for synchronization */
9762 MPING (CONTROL_PING, mp_ping);
9769 static void vl_api_ip6nd_proxy_details_t_handler
9770 (vl_api_ip6nd_proxy_details_t * mp)
9772 vat_main_t *vam = &vat_main;
9774 print (vam->ofp, "host %U sw_if_index %d",
9775 format_vl_api_ip6_address, mp->ip, ntohl (mp->sw_if_index));
9778 static void vl_api_ip6nd_proxy_details_t_handler_json
9779 (vl_api_ip6nd_proxy_details_t * mp)
9781 vat_main_t *vam = &vat_main;
9782 struct in6_addr ip6;
9783 vat_json_node_t *node = NULL;
9785 if (VAT_JSON_ARRAY != vam->json_tree.type)
9787 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9788 vat_json_init_array (&vam->json_tree);
9790 node = vat_json_array_add (&vam->json_tree);
9792 vat_json_init_object (node);
9793 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9795 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
9796 vat_json_object_add_ip6 (node, "host", ip6);
9800 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
9802 unformat_input_t *i = vam->input;
9803 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
9805 u8 sw_if_index_set = 0;
9806 u8 v6_address_set = 0;
9807 vl_api_prefix_t pfx;
9809 u8 no_advertise = 0;
9811 u8 no_autoconfig = 0;
9814 u32 val_lifetime = 0;
9815 u32 pref_lifetime = 0;
9818 /* Parse args required to build the message */
9819 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9821 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9822 sw_if_index_set = 1;
9823 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9824 sw_if_index_set = 1;
9825 else if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
9827 else if (unformat (i, "val_life %d", &val_lifetime))
9829 else if (unformat (i, "pref_life %d", &pref_lifetime))
9831 else if (unformat (i, "def"))
9833 else if (unformat (i, "noadv"))
9835 else if (unformat (i, "offl"))
9837 else if (unformat (i, "noauto"))
9839 else if (unformat (i, "nolink"))
9841 else if (unformat (i, "isno"))
9845 clib_warning ("parse error '%U'", format_unformat_error, i);
9850 if (sw_if_index_set == 0)
9852 errmsg ("missing interface name or sw_if_index");
9855 if (!v6_address_set)
9857 errmsg ("no address set");
9861 /* Construct the API message */
9862 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
9864 mp->sw_if_index = ntohl (sw_if_index);
9865 clib_memcpy (&mp->prefix, &pfx, sizeof (pfx));
9866 mp->use_default = use_default;
9867 mp->no_advertise = no_advertise;
9868 mp->off_link = off_link;
9869 mp->no_autoconfig = no_autoconfig;
9870 mp->no_onlink = no_onlink;
9872 mp->val_lifetime = ntohl (val_lifetime);
9873 mp->pref_lifetime = ntohl (pref_lifetime);
9878 /* Wait for a reply, return good/bad news */
9884 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
9886 unformat_input_t *i = vam->input;
9887 vl_api_sw_interface_ip6nd_ra_config_t *mp;
9889 u8 sw_if_index_set = 0;
9894 u8 send_unicast = 0;
9897 u8 default_router = 0;
9898 u32 max_interval = 0;
9899 u32 min_interval = 0;
9901 u32 initial_count = 0;
9902 u32 initial_interval = 0;
9906 /* Parse args required to build the message */
9907 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9909 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9910 sw_if_index_set = 1;
9911 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9912 sw_if_index_set = 1;
9913 else if (unformat (i, "maxint %d", &max_interval))
9915 else if (unformat (i, "minint %d", &min_interval))
9917 else if (unformat (i, "life %d", &lifetime))
9919 else if (unformat (i, "count %d", &initial_count))
9921 else if (unformat (i, "interval %d", &initial_interval))
9923 else if (unformat (i, "suppress") || unformat (i, "surpress"))
9925 else if (unformat (i, "managed"))
9927 else if (unformat (i, "other"))
9929 else if (unformat (i, "ll"))
9931 else if (unformat (i, "send"))
9933 else if (unformat (i, "cease"))
9935 else if (unformat (i, "isno"))
9937 else if (unformat (i, "def"))
9941 clib_warning ("parse error '%U'", format_unformat_error, i);
9946 if (sw_if_index_set == 0)
9948 errmsg ("missing interface name or sw_if_index");
9952 /* Construct the API message */
9953 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
9955 mp->sw_if_index = ntohl (sw_if_index);
9956 mp->max_interval = ntohl (max_interval);
9957 mp->min_interval = ntohl (min_interval);
9958 mp->lifetime = ntohl (lifetime);
9959 mp->initial_count = ntohl (initial_count);
9960 mp->initial_interval = ntohl (initial_interval);
9961 mp->suppress = suppress;
9962 mp->managed = managed;
9964 mp->ll_option = ll_option;
9965 mp->send_unicast = send_unicast;
9968 mp->default_router = default_router;
9973 /* Wait for a reply, return good/bad news */
9979 api_set_arp_neighbor_limit (vat_main_t * vam)
9981 unformat_input_t *i = vam->input;
9982 vl_api_set_arp_neighbor_limit_t *mp;
9988 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9990 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
9992 else if (unformat (i, "ipv6"))
9996 clib_warning ("parse error '%U'", format_unformat_error, i);
10001 if (limit_set == 0)
10003 errmsg ("missing limit value");
10007 M (SET_ARP_NEIGHBOR_LIMIT, mp);
10009 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
10010 mp->is_ipv6 = is_ipv6;
10018 api_l2_patch_add_del (vat_main_t * vam)
10020 unformat_input_t *i = vam->input;
10021 vl_api_l2_patch_add_del_t *mp;
10022 u32 rx_sw_if_index;
10023 u8 rx_sw_if_index_set = 0;
10024 u32 tx_sw_if_index;
10025 u8 tx_sw_if_index_set = 0;
10029 /* Parse args required to build the message */
10030 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10032 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
10033 rx_sw_if_index_set = 1;
10034 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
10035 tx_sw_if_index_set = 1;
10036 else if (unformat (i, "rx"))
10038 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10040 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10042 rx_sw_if_index_set = 1;
10047 else if (unformat (i, "tx"))
10049 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10051 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10053 tx_sw_if_index_set = 1;
10058 else if (unformat (i, "del"))
10064 if (rx_sw_if_index_set == 0)
10066 errmsg ("missing rx interface name or rx_sw_if_index");
10070 if (tx_sw_if_index_set == 0)
10072 errmsg ("missing tx interface name or tx_sw_if_index");
10076 M (L2_PATCH_ADD_DEL, mp);
10078 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
10079 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
10080 mp->is_add = is_add;
10088 u8 localsid_addr[16];
10097 api_sr_localsid_add_del (vat_main_t * vam)
10099 unformat_input_t *i = vam->input;
10100 vl_api_sr_localsid_add_del_t *mp;
10103 ip6_address_t localsid;
10107 u32 fib_table = ~(u32) 0;
10108 ip6_address_t nh_addr6;
10109 ip4_address_t nh_addr4;
10110 clib_memset (&nh_addr6, 0, sizeof (ip6_address_t));
10111 clib_memset (&nh_addr4, 0, sizeof (ip4_address_t));
10113 bool nexthop_set = 0;
10117 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10119 if (unformat (i, "del"))
10121 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
10122 else if (unformat (i, "next-hop %U", unformat_ip4_address, &nh_addr4))
10124 else if (unformat (i, "next-hop %U", unformat_ip6_address, &nh_addr6))
10126 else if (unformat (i, "behavior %u", &behavior));
10127 else if (unformat (i, "sw_if_index %u", &sw_if_index));
10128 else if (unformat (i, "fib-table %u", &fib_table));
10129 else if (unformat (i, "end.psp %u", &behavior));
10134 M (SR_LOCALSID_ADD_DEL, mp);
10136 clib_memcpy (mp->localsid.addr, &localsid, sizeof (mp->localsid));
10139 clib_memcpy (mp->nh_addr6, &nh_addr6, sizeof (mp->nh_addr6));
10140 clib_memcpy (mp->nh_addr4, &nh_addr4, sizeof (mp->nh_addr4));
10142 mp->behavior = behavior;
10143 mp->sw_if_index = ntohl (sw_if_index);
10144 mp->fib_table = ntohl (fib_table);
10145 mp->end_psp = end_psp;
10146 mp->is_del = is_del;
10154 api_ioam_enable (vat_main_t * vam)
10156 unformat_input_t *input = vam->input;
10157 vl_api_ioam_enable_t *mp;
10159 int has_trace_option = 0;
10160 int has_pot_option = 0;
10161 int has_seqno_option = 0;
10162 int has_analyse_option = 0;
10165 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10167 if (unformat (input, "trace"))
10168 has_trace_option = 1;
10169 else if (unformat (input, "pot"))
10170 has_pot_option = 1;
10171 else if (unformat (input, "seqno"))
10172 has_seqno_option = 1;
10173 else if (unformat (input, "analyse"))
10174 has_analyse_option = 1;
10178 M (IOAM_ENABLE, mp);
10179 mp->id = htons (id);
10180 mp->seqno = has_seqno_option;
10181 mp->analyse = has_analyse_option;
10182 mp->pot_enable = has_pot_option;
10183 mp->trace_enable = has_trace_option;
10192 api_ioam_disable (vat_main_t * vam)
10194 vl_api_ioam_disable_t *mp;
10197 M (IOAM_DISABLE, mp);
10203 #define foreach_tcp_proto_field \
10207 #define foreach_udp_proto_field \
10211 #define foreach_ip4_proto_field \
10223 u16 src_port, dst_port;
10226 #if VPP_API_TEST_BUILTIN == 0
10228 unformat_tcp_mask (unformat_input_t * input, va_list * args)
10230 u8 **maskp = va_arg (*args, u8 **);
10232 u8 found_something = 0;
10235 #define _(a) u8 a=0;
10236 foreach_tcp_proto_field;
10239 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10242 #define _(a) else if (unformat (input, #a)) a=1;
10243 foreach_tcp_proto_field
10249 #define _(a) found_something += a;
10250 foreach_tcp_proto_field;
10253 if (found_something == 0)
10256 vec_validate (mask, sizeof (*tcp) - 1);
10258 tcp = (tcp_header_t *) mask;
10260 #define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
10261 foreach_tcp_proto_field;
10269 unformat_udp_mask (unformat_input_t * input, va_list * args)
10271 u8 **maskp = va_arg (*args, u8 **);
10273 u8 found_something = 0;
10276 #define _(a) u8 a=0;
10277 foreach_udp_proto_field;
10280 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10283 #define _(a) else if (unformat (input, #a)) a=1;
10284 foreach_udp_proto_field
10290 #define _(a) found_something += a;
10291 foreach_udp_proto_field;
10294 if (found_something == 0)
10297 vec_validate (mask, sizeof (*udp) - 1);
10299 udp = (udp_header_t *) mask;
10301 #define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
10302 foreach_udp_proto_field;
10310 unformat_l4_mask (unformat_input_t * input, va_list * args)
10312 u8 **maskp = va_arg (*args, u8 **);
10313 u16 src_port = 0, dst_port = 0;
10314 tcpudp_header_t *tcpudp;
10316 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10318 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
10320 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
10322 else if (unformat (input, "src_port"))
10324 else if (unformat (input, "dst_port"))
10330 if (!src_port && !dst_port)
10334 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
10336 tcpudp = (tcpudp_header_t *) mask;
10337 tcpudp->src_port = src_port;
10338 tcpudp->dst_port = dst_port;
10346 unformat_ip4_mask (unformat_input_t * input, va_list * args)
10348 u8 **maskp = va_arg (*args, u8 **);
10350 u8 found_something = 0;
10353 #define _(a) u8 a=0;
10354 foreach_ip4_proto_field;
10360 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10362 if (unformat (input, "version"))
10364 else if (unformat (input, "hdr_length"))
10366 else if (unformat (input, "src"))
10368 else if (unformat (input, "dst"))
10370 else if (unformat (input, "proto"))
10373 #define _(a) else if (unformat (input, #a)) a=1;
10374 foreach_ip4_proto_field
10380 #define _(a) found_something += a;
10381 foreach_ip4_proto_field;
10384 if (found_something == 0)
10387 vec_validate (mask, sizeof (*ip) - 1);
10389 ip = (ip4_header_t *) mask;
10391 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
10392 foreach_ip4_proto_field;
10395 ip->ip_version_and_header_length = 0;
10398 ip->ip_version_and_header_length |= 0xF0;
10401 ip->ip_version_and_header_length |= 0x0F;
10407 #define foreach_ip6_proto_field \
10410 _(payload_length) \
10415 unformat_ip6_mask (unformat_input_t * input, va_list * args)
10417 u8 **maskp = va_arg (*args, u8 **);
10419 u8 found_something = 0;
10421 u32 ip_version_traffic_class_and_flow_label;
10423 #define _(a) u8 a=0;
10424 foreach_ip6_proto_field;
10427 u8 traffic_class = 0;
10430 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10432 if (unformat (input, "version"))
10434 else if (unformat (input, "traffic-class"))
10436 else if (unformat (input, "flow-label"))
10438 else if (unformat (input, "src"))
10440 else if (unformat (input, "dst"))
10442 else if (unformat (input, "proto"))
10445 #define _(a) else if (unformat (input, #a)) a=1;
10446 foreach_ip6_proto_field
10452 #define _(a) found_something += a;
10453 foreach_ip6_proto_field;
10456 if (found_something == 0)
10459 vec_validate (mask, sizeof (*ip) - 1);
10461 ip = (ip6_header_t *) mask;
10463 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
10464 foreach_ip6_proto_field;
10467 ip_version_traffic_class_and_flow_label = 0;
10470 ip_version_traffic_class_and_flow_label |= 0xF0000000;
10473 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
10476 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
10478 ip->ip_version_traffic_class_and_flow_label =
10479 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10486 unformat_l3_mask (unformat_input_t * input, va_list * args)
10488 u8 **maskp = va_arg (*args, u8 **);
10490 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10492 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
10494 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
10503 unformat_l2_mask (unformat_input_t * input, va_list * args)
10505 u8 **maskp = va_arg (*args, u8 **);
10512 u8 ignore_tag1 = 0;
10513 u8 ignore_tag2 = 0;
10520 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10522 if (unformat (input, "src"))
10524 else if (unformat (input, "dst"))
10526 else if (unformat (input, "proto"))
10528 else if (unformat (input, "tag1"))
10530 else if (unformat (input, "tag2"))
10532 else if (unformat (input, "ignore-tag1"))
10534 else if (unformat (input, "ignore-tag2"))
10536 else if (unformat (input, "cos1"))
10538 else if (unformat (input, "cos2"))
10540 else if (unformat (input, "dot1q"))
10542 else if (unformat (input, "dot1ad"))
10547 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
10548 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10551 if (tag1 || ignore_tag1 || cos1 || dot1q)
10553 if (tag2 || ignore_tag2 || cos2 || dot1ad)
10556 vec_validate (mask, len - 1);
10559 clib_memset (mask, 0xff, 6);
10562 clib_memset (mask + 6, 0xff, 6);
10564 if (tag2 || dot1ad)
10566 /* inner vlan tag */
10575 mask[21] = mask[20] = 0xff;
10596 mask[16] = mask[17] = 0xff;
10606 mask[12] = mask[13] = 0xff;
10613 unformat_classify_mask (unformat_input_t * input, va_list * args)
10615 u8 **maskp = va_arg (*args, u8 **);
10616 u32 *skipp = va_arg (*args, u32 *);
10617 u32 *matchp = va_arg (*args, u32 *);
10625 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10627 if (unformat (input, "hex %U", unformat_hex_string, &mask))
10629 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
10631 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
10633 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
10647 if (mask || l2 || l3 || l4)
10649 if (l2 || l3 || l4)
10651 /* "With a free Ethernet header in every package" */
10653 vec_validate (l2, 13);
10657 vec_append (mask, l3);
10662 vec_append (mask, l4);
10667 /* Scan forward looking for the first significant mask octet */
10668 for (i = 0; i < vec_len (mask); i++)
10672 /* compute (skip, match) params */
10673 *skipp = i / sizeof (u32x4);
10674 vec_delete (mask, *skipp * sizeof (u32x4), 0);
10676 /* Pad mask to an even multiple of the vector size */
10677 while (vec_len (mask) % sizeof (u32x4))
10678 vec_add1 (mask, 0);
10680 match = vec_len (mask) / sizeof (u32x4);
10682 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
10684 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
10685 if (*tmp || *(tmp + 1))
10690 clib_warning ("BUG: match 0");
10692 _vec_len (mask) = match * sizeof (u32x4);
10702 #endif /* VPP_API_TEST_BUILTIN */
10704 #define foreach_l2_next \
10706 _(ethernet, ETHERNET_INPUT) \
10707 _(ip4, IP4_INPUT) \
10711 unformat_l2_next_index (unformat_input_t * input, va_list * args)
10713 u32 *miss_next_indexp = va_arg (*args, u32 *);
10714 u32 next_index = 0;
10718 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
10722 if (unformat (input, "%d", &tmp))
10731 *miss_next_indexp = next_index;
10735 #define foreach_ip_next \
10738 _(rewrite, REWRITE)
10741 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
10743 u32 *miss_next_indexp = va_arg (*args, u32 *);
10744 u32 next_index = 0;
10748 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
10752 if (unformat (input, "%d", &tmp))
10761 *miss_next_indexp = next_index;
10765 #define foreach_acl_next \
10769 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
10771 u32 *miss_next_indexp = va_arg (*args, u32 *);
10772 u32 next_index = 0;
10776 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
10780 if (unformat (input, "permit"))
10785 else if (unformat (input, "%d", &tmp))
10794 *miss_next_indexp = next_index;
10799 unformat_policer_precolor (unformat_input_t * input, va_list * args)
10801 u32 *r = va_arg (*args, u32 *);
10803 if (unformat (input, "conform-color"))
10804 *r = POLICE_CONFORM;
10805 else if (unformat (input, "exceed-color"))
10806 *r = POLICE_EXCEED;
10814 api_classify_add_del_table (vat_main_t * vam)
10816 unformat_input_t *i = vam->input;
10817 vl_api_classify_add_del_table_t *mp;
10824 u32 table_index = ~0;
10825 u32 next_table_index = ~0;
10826 u32 miss_next_index = ~0;
10827 u32 memory_size = 32 << 20;
10829 u32 current_data_flag = 0;
10830 int current_data_offset = 0;
10833 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10835 if (unformat (i, "del"))
10837 else if (unformat (i, "del-chain"))
10842 else if (unformat (i, "buckets %d", &nbuckets))
10844 else if (unformat (i, "memory_size %d", &memory_size))
10846 else if (unformat (i, "skip %d", &skip))
10848 else if (unformat (i, "match %d", &match))
10850 else if (unformat (i, "table %d", &table_index))
10852 else if (unformat (i, "mask %U", unformat_classify_mask,
10853 &mask, &skip, &match))
10855 else if (unformat (i, "next-table %d", &next_table_index))
10857 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
10860 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
10863 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
10866 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
10868 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
10874 if (is_add && mask == 0)
10876 errmsg ("Mask required");
10880 if (is_add && skip == ~0)
10882 errmsg ("skip count required");
10886 if (is_add && match == ~0)
10888 errmsg ("match count required");
10892 if (!is_add && table_index == ~0)
10894 errmsg ("table index required for delete");
10898 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
10900 mp->is_add = is_add;
10901 mp->del_chain = del_chain;
10902 mp->table_index = ntohl (table_index);
10903 mp->nbuckets = ntohl (nbuckets);
10904 mp->memory_size = ntohl (memory_size);
10905 mp->skip_n_vectors = ntohl (skip);
10906 mp->match_n_vectors = ntohl (match);
10907 mp->next_table_index = ntohl (next_table_index);
10908 mp->miss_next_index = ntohl (miss_next_index);
10909 mp->current_data_flag = ntohl (current_data_flag);
10910 mp->current_data_offset = ntohl (current_data_offset);
10911 mp->mask_len = ntohl (vec_len (mask));
10912 clib_memcpy (mp->mask, mask, vec_len (mask));
10921 #if VPP_API_TEST_BUILTIN == 0
10923 unformat_l4_match (unformat_input_t * input, va_list * args)
10925 u8 **matchp = va_arg (*args, u8 **);
10927 u8 *proto_header = 0;
10933 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10935 if (unformat (input, "src_port %d", &src_port))
10937 else if (unformat (input, "dst_port %d", &dst_port))
10943 h.src_port = clib_host_to_net_u16 (src_port);
10944 h.dst_port = clib_host_to_net_u16 (dst_port);
10945 vec_validate (proto_header, sizeof (h) - 1);
10946 memcpy (proto_header, &h, sizeof (h));
10948 *matchp = proto_header;
10954 unformat_ip4_match (unformat_input_t * input, va_list * args)
10956 u8 **matchp = va_arg (*args, u8 **);
10961 int hdr_length = 0;
10962 u32 hdr_length_val;
10963 int src = 0, dst = 0;
10964 ip4_address_t src_val, dst_val;
10971 int fragment_id = 0;
10972 u32 fragment_id_val;
10978 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10980 if (unformat (input, "version %d", &version_val))
10982 else if (unformat (input, "hdr_length %d", &hdr_length_val))
10984 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
10986 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
10988 else if (unformat (input, "proto %d", &proto_val))
10990 else if (unformat (input, "tos %d", &tos_val))
10992 else if (unformat (input, "length %d", &length_val))
10994 else if (unformat (input, "fragment_id %d", &fragment_id_val))
10996 else if (unformat (input, "ttl %d", &ttl_val))
10998 else if (unformat (input, "checksum %d", &checksum_val))
11004 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
11005 + ttl + checksum == 0)
11009 * Aligned because we use the real comparison functions
11011 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11013 ip = (ip4_header_t *) match;
11015 /* These are realistically matched in practice */
11017 ip->src_address.as_u32 = src_val.as_u32;
11020 ip->dst_address.as_u32 = dst_val.as_u32;
11023 ip->protocol = proto_val;
11026 /* These are not, but they're included for completeness */
11028 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
11031 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
11037 ip->length = clib_host_to_net_u16 (length_val);
11043 ip->checksum = clib_host_to_net_u16 (checksum_val);
11050 unformat_ip6_match (unformat_input_t * input, va_list * args)
11052 u8 **matchp = va_arg (*args, u8 **);
11057 u8 traffic_class = 0;
11058 u32 traffic_class_val = 0;
11061 int src = 0, dst = 0;
11062 ip6_address_t src_val, dst_val;
11065 int payload_length = 0;
11066 u32 payload_length_val;
11069 u32 ip_version_traffic_class_and_flow_label;
11071 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11073 if (unformat (input, "version %d", &version_val))
11075 else if (unformat (input, "traffic_class %d", &traffic_class_val))
11077 else if (unformat (input, "flow_label %d", &flow_label_val))
11079 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
11081 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
11083 else if (unformat (input, "proto %d", &proto_val))
11085 else if (unformat (input, "payload_length %d", &payload_length_val))
11086 payload_length = 1;
11087 else if (unformat (input, "hop_limit %d", &hop_limit_val))
11093 if (version + traffic_class + flow_label + src + dst + proto +
11094 payload_length + hop_limit == 0)
11098 * Aligned because we use the real comparison functions
11100 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11102 ip = (ip6_header_t *) match;
11105 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
11108 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
11111 ip->protocol = proto_val;
11113 ip_version_traffic_class_and_flow_label = 0;
11116 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
11119 ip_version_traffic_class_and_flow_label |=
11120 (traffic_class_val & 0xFF) << 20;
11123 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
11125 ip->ip_version_traffic_class_and_flow_label =
11126 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
11128 if (payload_length)
11129 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
11132 ip->hop_limit = hop_limit_val;
11139 unformat_l3_match (unformat_input_t * input, va_list * args)
11141 u8 **matchp = va_arg (*args, u8 **);
11143 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11145 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
11147 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
11156 unformat_vlan_tag (unformat_input_t * input, va_list * args)
11158 u8 *tagp = va_arg (*args, u8 *);
11161 if (unformat (input, "%d", &tag))
11163 tagp[0] = (tag >> 8) & 0x0F;
11164 tagp[1] = tag & 0xFF;
11172 unformat_l2_match (unformat_input_t * input, va_list * args)
11174 u8 **matchp = va_arg (*args, u8 **);
11187 u8 ignore_tag1 = 0;
11188 u8 ignore_tag2 = 0;
11194 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11196 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
11199 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
11201 else if (unformat (input, "proto %U",
11202 unformat_ethernet_type_host_byte_order, &proto_val))
11204 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
11206 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
11208 else if (unformat (input, "ignore-tag1"))
11210 else if (unformat (input, "ignore-tag2"))
11212 else if (unformat (input, "cos1 %d", &cos1_val))
11214 else if (unformat (input, "cos2 %d", &cos2_val))
11219 if ((src + dst + proto + tag1 + tag2 +
11220 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
11223 if (tag1 || ignore_tag1 || cos1)
11225 if (tag2 || ignore_tag2 || cos2)
11228 vec_validate_aligned (match, len - 1, sizeof (u32x4));
11231 clib_memcpy (match, dst_val, 6);
11234 clib_memcpy (match + 6, src_val, 6);
11238 /* inner vlan tag */
11239 match[19] = tag2_val[1];
11240 match[18] = tag2_val[0];
11242 match[18] |= (cos2_val & 0x7) << 5;
11245 match[21] = proto_val & 0xff;
11246 match[20] = proto_val >> 8;
11250 match[15] = tag1_val[1];
11251 match[14] = tag1_val[0];
11254 match[14] |= (cos1_val & 0x7) << 5;
11260 match[15] = tag1_val[1];
11261 match[14] = tag1_val[0];
11264 match[17] = proto_val & 0xff;
11265 match[16] = proto_val >> 8;
11268 match[14] |= (cos1_val & 0x7) << 5;
11274 match[18] |= (cos2_val & 0x7) << 5;
11276 match[14] |= (cos1_val & 0x7) << 5;
11279 match[13] = proto_val & 0xff;
11280 match[12] = proto_val >> 8;
11288 unformat_qos_source (unformat_input_t * input, va_list * args)
11290 int *qs = va_arg (*args, int *);
11292 if (unformat (input, "ip"))
11293 *qs = QOS_SOURCE_IP;
11294 else if (unformat (input, "mpls"))
11295 *qs = QOS_SOURCE_MPLS;
11296 else if (unformat (input, "ext"))
11297 *qs = QOS_SOURCE_EXT;
11298 else if (unformat (input, "vlan"))
11299 *qs = QOS_SOURCE_VLAN;
11308 api_unformat_classify_match (unformat_input_t * input, va_list * args)
11310 u8 **matchp = va_arg (*args, u8 **);
11311 u32 skip_n_vectors = va_arg (*args, u32);
11312 u32 match_n_vectors = va_arg (*args, u32);
11319 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11321 if (unformat (input, "hex %U", unformat_hex_string, &match))
11323 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
11325 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
11327 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
11341 if (match || l2 || l3 || l4)
11343 if (l2 || l3 || l4)
11345 /* "Win a free Ethernet header in every packet" */
11347 vec_validate_aligned (l2, 13, sizeof (u32x4));
11351 vec_append_aligned (match, l3, sizeof (u32x4));
11356 vec_append_aligned (match, l4, sizeof (u32x4));
11361 /* Make sure the vector is big enough even if key is all 0's */
11362 vec_validate_aligned
11363 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
11366 /* Set size, include skipped vectors */
11367 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
11378 api_classify_add_del_session (vat_main_t * vam)
11380 unformat_input_t *i = vam->input;
11381 vl_api_classify_add_del_session_t *mp;
11383 u32 table_index = ~0;
11384 u32 hit_next_index = ~0;
11385 u32 opaque_index = ~0;
11388 u32 skip_n_vectors = 0;
11389 u32 match_n_vectors = 0;
11395 * Warning: you have to supply skip_n and match_n
11396 * because the API client cant simply look at the classify
11400 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11402 if (unformat (i, "del"))
11404 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
11407 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
11410 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
11413 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
11415 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
11417 else if (unformat (i, "opaque-index %d", &opaque_index))
11419 else if (unformat (i, "skip_n %d", &skip_n_vectors))
11421 else if (unformat (i, "match_n %d", &match_n_vectors))
11423 else if (unformat (i, "match %U", api_unformat_classify_match,
11424 &match, skip_n_vectors, match_n_vectors))
11426 else if (unformat (i, "advance %d", &advance))
11428 else if (unformat (i, "table-index %d", &table_index))
11430 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
11432 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
11434 else if (unformat (i, "action %d", &action))
11436 else if (unformat (i, "metadata %d", &metadata))
11442 if (table_index == ~0)
11444 errmsg ("Table index required");
11448 if (is_add && match == 0)
11450 errmsg ("Match value required");
11454 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
11456 mp->is_add = is_add;
11457 mp->table_index = ntohl (table_index);
11458 mp->hit_next_index = ntohl (hit_next_index);
11459 mp->opaque_index = ntohl (opaque_index);
11460 mp->advance = ntohl (advance);
11461 mp->action = action;
11462 mp->metadata = ntohl (metadata);
11463 mp->match_len = ntohl (vec_len (match));
11464 clib_memcpy (mp->match, match, vec_len (match));
11473 api_classify_set_interface_ip_table (vat_main_t * vam)
11475 unformat_input_t *i = vam->input;
11476 vl_api_classify_set_interface_ip_table_t *mp;
11478 int sw_if_index_set;
11479 u32 table_index = ~0;
11483 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11485 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11486 sw_if_index_set = 1;
11487 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11488 sw_if_index_set = 1;
11489 else if (unformat (i, "table %d", &table_index))
11493 clib_warning ("parse error '%U'", format_unformat_error, i);
11498 if (sw_if_index_set == 0)
11500 errmsg ("missing interface name or sw_if_index");
11505 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
11507 mp->sw_if_index = ntohl (sw_if_index);
11508 mp->table_index = ntohl (table_index);
11509 mp->is_ipv6 = is_ipv6;
11517 api_classify_set_interface_l2_tables (vat_main_t * vam)
11519 unformat_input_t *i = vam->input;
11520 vl_api_classify_set_interface_l2_tables_t *mp;
11522 int sw_if_index_set;
11523 u32 ip4_table_index = ~0;
11524 u32 ip6_table_index = ~0;
11525 u32 other_table_index = ~0;
11529 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11531 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11532 sw_if_index_set = 1;
11533 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11534 sw_if_index_set = 1;
11535 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11537 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11539 else if (unformat (i, "other-table %d", &other_table_index))
11541 else if (unformat (i, "is-input %d", &is_input))
11545 clib_warning ("parse error '%U'", format_unformat_error, i);
11550 if (sw_if_index_set == 0)
11552 errmsg ("missing interface name or sw_if_index");
11557 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
11559 mp->sw_if_index = ntohl (sw_if_index);
11560 mp->ip4_table_index = ntohl (ip4_table_index);
11561 mp->ip6_table_index = ntohl (ip6_table_index);
11562 mp->other_table_index = ntohl (other_table_index);
11563 mp->is_input = (u8) is_input;
11571 api_set_ipfix_exporter (vat_main_t * vam)
11573 unformat_input_t *i = vam->input;
11574 vl_api_set_ipfix_exporter_t *mp;
11575 ip4_address_t collector_address;
11576 u8 collector_address_set = 0;
11577 u32 collector_port = ~0;
11578 ip4_address_t src_address;
11579 u8 src_address_set = 0;
11582 u32 template_interval = ~0;
11583 u8 udp_checksum = 0;
11586 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11588 if (unformat (i, "collector_address %U", unformat_ip4_address,
11589 &collector_address))
11590 collector_address_set = 1;
11591 else if (unformat (i, "collector_port %d", &collector_port))
11593 else if (unformat (i, "src_address %U", unformat_ip4_address,
11595 src_address_set = 1;
11596 else if (unformat (i, "vrf_id %d", &vrf_id))
11598 else if (unformat (i, "path_mtu %d", &path_mtu))
11600 else if (unformat (i, "template_interval %d", &template_interval))
11602 else if (unformat (i, "udp_checksum"))
11608 if (collector_address_set == 0)
11610 errmsg ("collector_address required");
11614 if (src_address_set == 0)
11616 errmsg ("src_address required");
11620 M (SET_IPFIX_EXPORTER, mp);
11622 memcpy (mp->collector_address, collector_address.data,
11623 sizeof (collector_address.data));
11624 mp->collector_port = htons ((u16) collector_port);
11625 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
11626 mp->vrf_id = htonl (vrf_id);
11627 mp->path_mtu = htonl (path_mtu);
11628 mp->template_interval = htonl (template_interval);
11629 mp->udp_checksum = udp_checksum;
11637 api_set_ipfix_classify_stream (vat_main_t * vam)
11639 unformat_input_t *i = vam->input;
11640 vl_api_set_ipfix_classify_stream_t *mp;
11642 u32 src_port = UDP_DST_PORT_ipfix;
11645 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11647 if (unformat (i, "domain %d", &domain_id))
11649 else if (unformat (i, "src_port %d", &src_port))
11653 errmsg ("unknown input `%U'", format_unformat_error, i);
11658 M (SET_IPFIX_CLASSIFY_STREAM, mp);
11660 mp->domain_id = htonl (domain_id);
11661 mp->src_port = htons ((u16) src_port);
11669 api_ipfix_classify_table_add_del (vat_main_t * vam)
11671 unformat_input_t *i = vam->input;
11672 vl_api_ipfix_classify_table_add_del_t *mp;
11674 u32 classify_table_index = ~0;
11676 u8 transport_protocol = 255;
11679 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11681 if (unformat (i, "add"))
11683 else if (unformat (i, "del"))
11685 else if (unformat (i, "table %d", &classify_table_index))
11687 else if (unformat (i, "ip4"))
11689 else if (unformat (i, "ip6"))
11691 else if (unformat (i, "tcp"))
11692 transport_protocol = 6;
11693 else if (unformat (i, "udp"))
11694 transport_protocol = 17;
11697 errmsg ("unknown input `%U'", format_unformat_error, i);
11704 errmsg ("expecting: add|del");
11707 if (classify_table_index == ~0)
11709 errmsg ("classifier table not specified");
11712 if (ip_version == 0)
11714 errmsg ("IP version not specified");
11718 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
11720 mp->is_add = is_add;
11721 mp->table_id = htonl (classify_table_index);
11722 mp->ip_version = ip_version;
11723 mp->transport_protocol = transport_protocol;
11731 api_get_node_index (vat_main_t * vam)
11733 unformat_input_t *i = vam->input;
11734 vl_api_get_node_index_t *mp;
11738 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11740 if (unformat (i, "node %s", &name))
11747 errmsg ("node name required");
11750 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11752 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11756 M (GET_NODE_INDEX, mp);
11757 clib_memcpy (mp->node_name, name, vec_len (name));
11766 api_get_next_index (vat_main_t * vam)
11768 unformat_input_t *i = vam->input;
11769 vl_api_get_next_index_t *mp;
11770 u8 *node_name = 0, *next_node_name = 0;
11773 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11775 if (unformat (i, "node-name %s", &node_name))
11777 else if (unformat (i, "next-node-name %s", &next_node_name))
11781 if (node_name == 0)
11783 errmsg ("node name required");
11786 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
11788 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11792 if (next_node_name == 0)
11794 errmsg ("next node name required");
11797 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
11799 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
11803 M (GET_NEXT_INDEX, mp);
11804 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
11805 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
11806 vec_free (node_name);
11807 vec_free (next_node_name);
11815 api_add_node_next (vat_main_t * vam)
11817 unformat_input_t *i = vam->input;
11818 vl_api_add_node_next_t *mp;
11823 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11825 if (unformat (i, "node %s", &name))
11827 else if (unformat (i, "next %s", &next))
11834 errmsg ("node name required");
11837 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11839 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11844 errmsg ("next node required");
11847 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
11849 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
11853 M (ADD_NODE_NEXT, mp);
11854 clib_memcpy (mp->node_name, name, vec_len (name));
11855 clib_memcpy (mp->next_name, next, vec_len (next));
11865 api_l2tpv3_create_tunnel (vat_main_t * vam)
11867 unformat_input_t *i = vam->input;
11868 ip6_address_t client_address, our_address;
11869 int client_address_set = 0;
11870 int our_address_set = 0;
11871 u32 local_session_id = 0;
11872 u32 remote_session_id = 0;
11873 u64 local_cookie = 0;
11874 u64 remote_cookie = 0;
11875 u8 l2_sublayer_present = 0;
11876 vl_api_l2tpv3_create_tunnel_t *mp;
11879 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11881 if (unformat (i, "client_address %U", unformat_ip6_address,
11883 client_address_set = 1;
11884 else if (unformat (i, "our_address %U", unformat_ip6_address,
11886 our_address_set = 1;
11887 else if (unformat (i, "local_session_id %d", &local_session_id))
11889 else if (unformat (i, "remote_session_id %d", &remote_session_id))
11891 else if (unformat (i, "local_cookie %lld", &local_cookie))
11893 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
11895 else if (unformat (i, "l2-sublayer-present"))
11896 l2_sublayer_present = 1;
11901 if (client_address_set == 0)
11903 errmsg ("client_address required");
11907 if (our_address_set == 0)
11909 errmsg ("our_address required");
11913 M (L2TPV3_CREATE_TUNNEL, mp);
11915 clib_memcpy (mp->client_address, client_address.as_u8,
11916 sizeof (mp->client_address));
11918 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
11920 mp->local_session_id = ntohl (local_session_id);
11921 mp->remote_session_id = ntohl (remote_session_id);
11922 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
11923 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
11924 mp->l2_sublayer_present = l2_sublayer_present;
11933 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
11935 unformat_input_t *i = vam->input;
11937 u8 sw_if_index_set = 0;
11938 u64 new_local_cookie = 0;
11939 u64 new_remote_cookie = 0;
11940 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
11943 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11945 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11946 sw_if_index_set = 1;
11947 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11948 sw_if_index_set = 1;
11949 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
11951 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
11957 if (sw_if_index_set == 0)
11959 errmsg ("missing interface name or sw_if_index");
11963 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
11965 mp->sw_if_index = ntohl (sw_if_index);
11966 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
11967 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
11975 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
11977 unformat_input_t *i = vam->input;
11978 vl_api_l2tpv3_interface_enable_disable_t *mp;
11980 u8 sw_if_index_set = 0;
11981 u8 enable_disable = 1;
11984 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11986 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11987 sw_if_index_set = 1;
11988 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11989 sw_if_index_set = 1;
11990 else if (unformat (i, "enable"))
11991 enable_disable = 1;
11992 else if (unformat (i, "disable"))
11993 enable_disable = 0;
11998 if (sw_if_index_set == 0)
12000 errmsg ("missing interface name or sw_if_index");
12004 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
12006 mp->sw_if_index = ntohl (sw_if_index);
12007 mp->enable_disable = enable_disable;
12015 api_l2tpv3_set_lookup_key (vat_main_t * vam)
12017 unformat_input_t *i = vam->input;
12018 vl_api_l2tpv3_set_lookup_key_t *mp;
12022 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12024 if (unformat (i, "lookup_v6_src"))
12025 key = L2T_LOOKUP_SRC_ADDRESS;
12026 else if (unformat (i, "lookup_v6_dst"))
12027 key = L2T_LOOKUP_DST_ADDRESS;
12028 else if (unformat (i, "lookup_session_id"))
12029 key = L2T_LOOKUP_SESSION_ID;
12034 if (key == (u8) ~ 0)
12036 errmsg ("l2tp session lookup key unset");
12040 M (L2TPV3_SET_LOOKUP_KEY, mp);
12049 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
12050 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12052 vat_main_t *vam = &vat_main;
12054 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
12055 format_ip6_address, mp->our_address,
12056 format_ip6_address, mp->client_address,
12057 clib_net_to_host_u32 (mp->sw_if_index));
12060 " local cookies %016llx %016llx remote cookie %016llx",
12061 clib_net_to_host_u64 (mp->local_cookie[0]),
12062 clib_net_to_host_u64 (mp->local_cookie[1]),
12063 clib_net_to_host_u64 (mp->remote_cookie));
12065 print (vam->ofp, " local session-id %d remote session-id %d",
12066 clib_net_to_host_u32 (mp->local_session_id),
12067 clib_net_to_host_u32 (mp->remote_session_id));
12069 print (vam->ofp, " l2 specific sublayer %s\n",
12070 mp->l2_sublayer_present ? "preset" : "absent");
12074 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
12075 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12077 vat_main_t *vam = &vat_main;
12078 vat_json_node_t *node = NULL;
12079 struct in6_addr addr;
12081 if (VAT_JSON_ARRAY != vam->json_tree.type)
12083 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12084 vat_json_init_array (&vam->json_tree);
12086 node = vat_json_array_add (&vam->json_tree);
12088 vat_json_init_object (node);
12090 clib_memcpy (&addr, mp->our_address, sizeof (addr));
12091 vat_json_object_add_ip6 (node, "our_address", addr);
12092 clib_memcpy (&addr, mp->client_address, sizeof (addr));
12093 vat_json_object_add_ip6 (node, "client_address", addr);
12095 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
12096 vat_json_init_array (lc);
12097 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
12098 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
12099 vat_json_object_add_uint (node, "remote_cookie",
12100 clib_net_to_host_u64 (mp->remote_cookie));
12102 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
12103 vat_json_object_add_uint (node, "local_session_id",
12104 clib_net_to_host_u32 (mp->local_session_id));
12105 vat_json_object_add_uint (node, "remote_session_id",
12106 clib_net_to_host_u32 (mp->remote_session_id));
12107 vat_json_object_add_string_copy (node, "l2_sublayer",
12108 mp->l2_sublayer_present ? (u8 *) "present"
12109 : (u8 *) "absent");
12113 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
12115 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
12116 vl_api_control_ping_t *mp_ping;
12119 /* Get list of l2tpv3-tunnel interfaces */
12120 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
12123 /* Use a control ping for synchronization */
12124 MPING (CONTROL_PING, mp_ping);
12132 static void vl_api_sw_interface_tap_v2_details_t_handler
12133 (vl_api_sw_interface_tap_v2_details_t * mp)
12135 vat_main_t *vam = &vat_main;
12137 u8 *ip4 = format (0, "%U/%d", format_ip4_address, mp->host_ip4_addr,
12138 mp->host_ip4_prefix_len);
12139 u8 *ip6 = format (0, "%U/%d", format_ip6_address, mp->host_ip6_addr,
12140 mp->host_ip6_prefix_len);
12143 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s 0x%-08x",
12144 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
12145 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
12146 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
12147 mp->host_bridge, ip4, ip6, ntohl (mp->tap_flags));
12153 static void vl_api_sw_interface_tap_v2_details_t_handler_json
12154 (vl_api_sw_interface_tap_v2_details_t * mp)
12156 vat_main_t *vam = &vat_main;
12157 vat_json_node_t *node = NULL;
12159 if (VAT_JSON_ARRAY != vam->json_tree.type)
12161 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12162 vat_json_init_array (&vam->json_tree);
12164 node = vat_json_array_add (&vam->json_tree);
12166 vat_json_init_object (node);
12167 vat_json_object_add_uint (node, "id", ntohl (mp->id));
12168 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12169 vat_json_object_add_uint (node, "tap_flags", ntohl (mp->tap_flags));
12170 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
12171 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
12172 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
12173 vat_json_object_add_string_copy (node, "host_mac_addr",
12174 format (0, "%U", format_ethernet_address,
12175 &mp->host_mac_addr));
12176 vat_json_object_add_string_copy (node, "host_namespace",
12177 mp->host_namespace);
12178 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
12179 vat_json_object_add_string_copy (node, "host_ip4_addr",
12180 format (0, "%U/%d", format_ip4_address,
12182 mp->host_ip4_prefix_len));
12183 vat_json_object_add_string_copy (node, "host_ip6_addr",
12184 format (0, "%U/%d", format_ip6_address,
12186 mp->host_ip6_prefix_len));
12191 api_sw_interface_tap_v2_dump (vat_main_t * vam)
12193 vl_api_sw_interface_tap_v2_dump_t *mp;
12194 vl_api_control_ping_t *mp_ping;
12198 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
12199 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
12200 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
12203 /* Get list of tap interfaces */
12204 M (SW_INTERFACE_TAP_V2_DUMP, mp);
12207 /* Use a control ping for synchronization */
12208 MPING (CONTROL_PING, mp_ping);
12215 static void vl_api_sw_interface_virtio_pci_details_t_handler
12216 (vl_api_sw_interface_virtio_pci_details_t * mp)
12218 vat_main_t *vam = &vat_main;
12232 addr.as_u32 = ntohl (mp->pci_addr);
12233 u8 *pci_addr = format (0, "%04x:%02x:%02x.%x", addr.domain, addr.bus,
12234 addr.slot, addr.function);
12237 "\n%-12s %-12d %-12d %-12d %-17U 0x%-08llx",
12238 pci_addr, ntohl (mp->sw_if_index),
12239 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
12240 format_ethernet_address, mp->mac_addr,
12241 clib_net_to_host_u64 (mp->features));
12242 vec_free (pci_addr);
12245 static void vl_api_sw_interface_virtio_pci_details_t_handler_json
12246 (vl_api_sw_interface_virtio_pci_details_t * mp)
12248 vat_main_t *vam = &vat_main;
12249 vat_json_node_t *node = NULL;
12251 if (VAT_JSON_ARRAY != vam->json_tree.type)
12253 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12254 vat_json_init_array (&vam->json_tree);
12256 node = vat_json_array_add (&vam->json_tree);
12258 vat_json_init_object (node);
12259 vat_json_object_add_uint (node, "pci-addr", ntohl (mp->pci_addr));
12260 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12261 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
12262 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
12263 vat_json_object_add_uint (node, "features",
12264 clib_net_to_host_u64 (mp->features));
12265 vat_json_object_add_string_copy (node, "mac_addr",
12266 format (0, "%U", format_ethernet_address,
12271 api_sw_interface_virtio_pci_dump (vat_main_t * vam)
12273 vl_api_sw_interface_virtio_pci_dump_t *mp;
12274 vl_api_control_ping_t *mp_ping;
12278 "\n%-12s %-12s %-12s %-12s %-17s %-08s",
12279 "pci_addr", "sw_if_index", "rx_ring_sz", "tx_ring_sz",
12280 "mac_addr", "features");
12282 /* Get list of tap interfaces */
12283 M (SW_INTERFACE_VIRTIO_PCI_DUMP, mp);
12286 /* Use a control ping for synchronization */
12287 MPING (CONTROL_PING, mp_ping);
12295 api_vxlan_offload_rx (vat_main_t * vam)
12297 unformat_input_t *line_input = vam->input;
12298 vl_api_vxlan_offload_rx_t *mp;
12299 u32 hw_if_index = ~0, rx_if_index = ~0;
12303 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12305 if (unformat (line_input, "del"))
12307 else if (unformat (line_input, "hw %U", api_unformat_hw_if_index, vam,
12310 else if (unformat (line_input, "hw hw_if_index %u", &hw_if_index))
12312 else if (unformat (line_input, "rx %U", api_unformat_sw_if_index, vam,
12315 else if (unformat (line_input, "rx sw_if_index %u", &rx_if_index))
12319 errmsg ("parse error '%U'", format_unformat_error, line_input);
12324 if (hw_if_index == ~0)
12326 errmsg ("no hw interface");
12330 if (rx_if_index == ~0)
12332 errmsg ("no rx tunnel");
12336 M (VXLAN_OFFLOAD_RX, mp);
12338 mp->hw_if_index = ntohl (hw_if_index);
12339 mp->sw_if_index = ntohl (rx_if_index);
12340 mp->enable = is_add;
12347 static uword unformat_vxlan_decap_next
12348 (unformat_input_t * input, va_list * args)
12350 u32 *result = va_arg (*args, u32 *);
12353 if (unformat (input, "l2"))
12354 *result = VXLAN_INPUT_NEXT_L2_INPUT;
12355 else if (unformat (input, "%d", &tmp))
12363 api_vxlan_add_del_tunnel (vat_main_t * vam)
12365 unformat_input_t *line_input = vam->input;
12366 vl_api_vxlan_add_del_tunnel_t *mp;
12367 ip46_address_t src, dst;
12369 u8 ipv4_set = 0, ipv6_set = 0;
12374 u32 mcast_sw_if_index = ~0;
12375 u32 encap_vrf_id = 0;
12376 u32 decap_next_index = ~0;
12380 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12381 clib_memset (&src, 0, sizeof src);
12382 clib_memset (&dst, 0, sizeof dst);
12384 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12386 if (unformat (line_input, "del"))
12388 else if (unformat (line_input, "instance %d", &instance))
12391 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12397 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12403 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12409 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12414 else if (unformat (line_input, "group %U %U",
12415 unformat_ip4_address, &dst.ip4,
12416 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12418 grp_set = dst_set = 1;
12421 else if (unformat (line_input, "group %U",
12422 unformat_ip4_address, &dst.ip4))
12424 grp_set = dst_set = 1;
12427 else if (unformat (line_input, "group %U %U",
12428 unformat_ip6_address, &dst.ip6,
12429 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12431 grp_set = dst_set = 1;
12434 else if (unformat (line_input, "group %U",
12435 unformat_ip6_address, &dst.ip6))
12437 grp_set = dst_set = 1;
12441 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12443 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12445 else if (unformat (line_input, "decap-next %U",
12446 unformat_vxlan_decap_next, &decap_next_index))
12448 else if (unformat (line_input, "vni %d", &vni))
12452 errmsg ("parse error '%U'", format_unformat_error, line_input);
12459 errmsg ("tunnel src address not specified");
12464 errmsg ("tunnel dst address not specified");
12468 if (grp_set && !ip46_address_is_multicast (&dst))
12470 errmsg ("tunnel group address not multicast");
12473 if (grp_set && mcast_sw_if_index == ~0)
12475 errmsg ("tunnel nonexistent multicast device");
12478 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12480 errmsg ("tunnel dst address must be unicast");
12485 if (ipv4_set && ipv6_set)
12487 errmsg ("both IPv4 and IPv6 addresses specified");
12491 if ((vni == 0) || (vni >> 24))
12493 errmsg ("vni not specified or out of range");
12497 M (VXLAN_ADD_DEL_TUNNEL, mp);
12501 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
12502 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
12506 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
12507 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
12510 mp->instance = htonl (instance);
12511 mp->encap_vrf_id = ntohl (encap_vrf_id);
12512 mp->decap_next_index = ntohl (decap_next_index);
12513 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12514 mp->vni = ntohl (vni);
12515 mp->is_add = is_add;
12516 mp->is_ipv6 = ipv6_set;
12523 static void vl_api_vxlan_tunnel_details_t_handler
12524 (vl_api_vxlan_tunnel_details_t * mp)
12526 vat_main_t *vam = &vat_main;
12527 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12528 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12530 print (vam->ofp, "%11d%11d%24U%24U%14d%18d%13d%19d",
12531 ntohl (mp->sw_if_index),
12532 ntohl (mp->instance),
12533 format_ip46_address, &src, IP46_TYPE_ANY,
12534 format_ip46_address, &dst, IP46_TYPE_ANY,
12535 ntohl (mp->encap_vrf_id),
12536 ntohl (mp->decap_next_index), ntohl (mp->vni),
12537 ntohl (mp->mcast_sw_if_index));
12540 static void vl_api_vxlan_tunnel_details_t_handler_json
12541 (vl_api_vxlan_tunnel_details_t * mp)
12543 vat_main_t *vam = &vat_main;
12544 vat_json_node_t *node = NULL;
12546 if (VAT_JSON_ARRAY != vam->json_tree.type)
12548 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12549 vat_json_init_array (&vam->json_tree);
12551 node = vat_json_array_add (&vam->json_tree);
12553 vat_json_init_object (node);
12554 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12556 vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
12560 struct in6_addr ip6;
12562 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12563 vat_json_object_add_ip6 (node, "src_address", ip6);
12564 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12565 vat_json_object_add_ip6 (node, "dst_address", ip6);
12569 struct in_addr ip4;
12571 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12572 vat_json_object_add_ip4 (node, "src_address", ip4);
12573 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12574 vat_json_object_add_ip4 (node, "dst_address", ip4);
12576 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12577 vat_json_object_add_uint (node, "decap_next_index",
12578 ntohl (mp->decap_next_index));
12579 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12580 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12581 vat_json_object_add_uint (node, "mcast_sw_if_index",
12582 ntohl (mp->mcast_sw_if_index));
12586 api_vxlan_tunnel_dump (vat_main_t * vam)
12588 unformat_input_t *i = vam->input;
12589 vl_api_vxlan_tunnel_dump_t *mp;
12590 vl_api_control_ping_t *mp_ping;
12592 u8 sw_if_index_set = 0;
12595 /* Parse args required to build the message */
12596 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12598 if (unformat (i, "sw_if_index %d", &sw_if_index))
12599 sw_if_index_set = 1;
12604 if (sw_if_index_set == 0)
12609 if (!vam->json_output)
12611 print (vam->ofp, "%11s%11s%24s%24s%14s%18s%13s%19s",
12612 "sw_if_index", "instance", "src_address", "dst_address",
12613 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12616 /* Get list of vxlan-tunnel interfaces */
12617 M (VXLAN_TUNNEL_DUMP, mp);
12619 mp->sw_if_index = htonl (sw_if_index);
12623 /* Use a control ping for synchronization */
12624 MPING (CONTROL_PING, mp_ping);
12631 static uword unformat_geneve_decap_next
12632 (unformat_input_t * input, va_list * args)
12634 u32 *result = va_arg (*args, u32 *);
12637 if (unformat (input, "l2"))
12638 *result = GENEVE_INPUT_NEXT_L2_INPUT;
12639 else if (unformat (input, "%d", &tmp))
12647 api_geneve_add_del_tunnel (vat_main_t * vam)
12649 unformat_input_t *line_input = vam->input;
12650 vl_api_geneve_add_del_tunnel_t *mp;
12651 ip46_address_t src, dst;
12653 u8 ipv4_set = 0, ipv6_set = 0;
12657 u32 mcast_sw_if_index = ~0;
12658 u32 encap_vrf_id = 0;
12659 u32 decap_next_index = ~0;
12663 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12664 clib_memset (&src, 0, sizeof src);
12665 clib_memset (&dst, 0, sizeof dst);
12667 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12669 if (unformat (line_input, "del"))
12672 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12678 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12684 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12690 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12695 else if (unformat (line_input, "group %U %U",
12696 unformat_ip4_address, &dst.ip4,
12697 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12699 grp_set = dst_set = 1;
12702 else if (unformat (line_input, "group %U",
12703 unformat_ip4_address, &dst.ip4))
12705 grp_set = dst_set = 1;
12708 else if (unformat (line_input, "group %U %U",
12709 unformat_ip6_address, &dst.ip6,
12710 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12712 grp_set = dst_set = 1;
12715 else if (unformat (line_input, "group %U",
12716 unformat_ip6_address, &dst.ip6))
12718 grp_set = dst_set = 1;
12722 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12724 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12726 else if (unformat (line_input, "decap-next %U",
12727 unformat_geneve_decap_next, &decap_next_index))
12729 else if (unformat (line_input, "vni %d", &vni))
12733 errmsg ("parse error '%U'", format_unformat_error, line_input);
12740 errmsg ("tunnel src address not specified");
12745 errmsg ("tunnel dst address not specified");
12749 if (grp_set && !ip46_address_is_multicast (&dst))
12751 errmsg ("tunnel group address not multicast");
12754 if (grp_set && mcast_sw_if_index == ~0)
12756 errmsg ("tunnel nonexistent multicast device");
12759 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12761 errmsg ("tunnel dst address must be unicast");
12766 if (ipv4_set && ipv6_set)
12768 errmsg ("both IPv4 and IPv6 addresses specified");
12772 if ((vni == 0) || (vni >> 24))
12774 errmsg ("vni not specified or out of range");
12778 M (GENEVE_ADD_DEL_TUNNEL, mp);
12782 clib_memcpy (mp->local_address, &src.ip6, sizeof (src.ip6));
12783 clib_memcpy (mp->remote_address, &dst.ip6, sizeof (dst.ip6));
12787 clib_memcpy (mp->local_address, &src.ip4, sizeof (src.ip4));
12788 clib_memcpy (mp->remote_address, &dst.ip4, sizeof (dst.ip4));
12790 mp->encap_vrf_id = ntohl (encap_vrf_id);
12791 mp->decap_next_index = ntohl (decap_next_index);
12792 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12793 mp->vni = ntohl (vni);
12794 mp->is_add = is_add;
12795 mp->is_ipv6 = ipv6_set;
12802 static void vl_api_geneve_tunnel_details_t_handler
12803 (vl_api_geneve_tunnel_details_t * mp)
12805 vat_main_t *vam = &vat_main;
12806 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12807 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12809 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12810 ntohl (mp->sw_if_index),
12811 format_ip46_address, &src, IP46_TYPE_ANY,
12812 format_ip46_address, &dst, IP46_TYPE_ANY,
12813 ntohl (mp->encap_vrf_id),
12814 ntohl (mp->decap_next_index), ntohl (mp->vni),
12815 ntohl (mp->mcast_sw_if_index));
12818 static void vl_api_geneve_tunnel_details_t_handler_json
12819 (vl_api_geneve_tunnel_details_t * mp)
12821 vat_main_t *vam = &vat_main;
12822 vat_json_node_t *node = NULL;
12824 if (VAT_JSON_ARRAY != vam->json_tree.type)
12826 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12827 vat_json_init_array (&vam->json_tree);
12829 node = vat_json_array_add (&vam->json_tree);
12831 vat_json_init_object (node);
12832 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12835 struct in6_addr ip6;
12837 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12838 vat_json_object_add_ip6 (node, "src_address", ip6);
12839 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12840 vat_json_object_add_ip6 (node, "dst_address", ip6);
12844 struct in_addr ip4;
12846 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12847 vat_json_object_add_ip4 (node, "src_address", ip4);
12848 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12849 vat_json_object_add_ip4 (node, "dst_address", ip4);
12851 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12852 vat_json_object_add_uint (node, "decap_next_index",
12853 ntohl (mp->decap_next_index));
12854 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12855 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12856 vat_json_object_add_uint (node, "mcast_sw_if_index",
12857 ntohl (mp->mcast_sw_if_index));
12861 api_geneve_tunnel_dump (vat_main_t * vam)
12863 unformat_input_t *i = vam->input;
12864 vl_api_geneve_tunnel_dump_t *mp;
12865 vl_api_control_ping_t *mp_ping;
12867 u8 sw_if_index_set = 0;
12870 /* Parse args required to build the message */
12871 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12873 if (unformat (i, "sw_if_index %d", &sw_if_index))
12874 sw_if_index_set = 1;
12879 if (sw_if_index_set == 0)
12884 if (!vam->json_output)
12886 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12887 "sw_if_index", "local_address", "remote_address",
12888 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12891 /* Get list of geneve-tunnel interfaces */
12892 M (GENEVE_TUNNEL_DUMP, mp);
12894 mp->sw_if_index = htonl (sw_if_index);
12898 /* Use a control ping for synchronization */
12899 M (CONTROL_PING, mp_ping);
12907 api_gre_tunnel_add_del (vat_main_t * vam)
12909 unformat_input_t *line_input = vam->input;
12910 vl_api_address_t src = { }, dst =
12913 vl_api_gre_tunnel_add_del_t *mp;
12914 vl_api_gre_tunnel_type_t t_type;
12918 u32 outer_fib_id = 0;
12919 u32 session_id = 0;
12923 t_type = GRE_API_TUNNEL_TYPE_L3;
12925 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12927 if (unformat (line_input, "del"))
12929 else if (unformat (line_input, "instance %d", &instance))
12931 else if (unformat (line_input, "src %U", unformat_vl_api_address, &src))
12935 else if (unformat (line_input, "dst %U", unformat_vl_api_address, &dst))
12939 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
12941 else if (unformat (line_input, "teb"))
12942 t_type = GRE_API_TUNNEL_TYPE_TEB;
12943 else if (unformat (line_input, "erspan %d", &session_id))
12944 t_type = GRE_API_TUNNEL_TYPE_ERSPAN;
12947 errmsg ("parse error '%U'", format_unformat_error, line_input);
12954 errmsg ("tunnel src address not specified");
12959 errmsg ("tunnel dst address not specified");
12963 M (GRE_TUNNEL_ADD_DEL, mp);
12965 clib_memcpy (&mp->tunnel.src, &src, sizeof (mp->tunnel.src));
12966 clib_memcpy (&mp->tunnel.dst, &dst, sizeof (mp->tunnel.dst));
12968 mp->tunnel.instance = htonl (instance);
12969 mp->tunnel.outer_fib_id = htonl (outer_fib_id);
12970 mp->is_add = is_add;
12971 mp->tunnel.session_id = htons ((u16) session_id);
12972 mp->tunnel.type = htonl (t_type);
12979 static void vl_api_gre_tunnel_details_t_handler
12980 (vl_api_gre_tunnel_details_t * mp)
12982 vat_main_t *vam = &vat_main;
12984 print (vam->ofp, "%11d%11d%24U%24U%13d%14d%12d",
12985 ntohl (mp->tunnel.sw_if_index),
12986 ntohl (mp->tunnel.instance),
12987 format_vl_api_address, &mp->tunnel.src,
12988 format_vl_api_address, &mp->tunnel.dst,
12989 mp->tunnel.type, ntohl (mp->tunnel.outer_fib_id),
12990 ntohl (mp->tunnel.session_id));
12993 static void vl_api_gre_tunnel_details_t_handler_json
12994 (vl_api_gre_tunnel_details_t * mp)
12996 vat_main_t *vam = &vat_main;
12997 vat_json_node_t *node = NULL;
12999 if (VAT_JSON_ARRAY != vam->json_tree.type)
13001 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13002 vat_json_init_array (&vam->json_tree);
13004 node = vat_json_array_add (&vam->json_tree);
13006 vat_json_init_object (node);
13007 vat_json_object_add_uint (node, "sw_if_index",
13008 ntohl (mp->tunnel.sw_if_index));
13009 vat_json_object_add_uint (node, "instance", ntohl (mp->tunnel.instance));
13011 vat_json_object_add_address (node, "src", &mp->tunnel.src);
13012 vat_json_object_add_address (node, "dst", &mp->tunnel.dst);
13013 vat_json_object_add_uint (node, "tunnel_type", mp->tunnel.type);
13014 vat_json_object_add_uint (node, "outer_fib_id",
13015 ntohl (mp->tunnel.outer_fib_id));
13016 vat_json_object_add_uint (node, "session_id", mp->tunnel.session_id);
13020 api_gre_tunnel_dump (vat_main_t * vam)
13022 unformat_input_t *i = vam->input;
13023 vl_api_gre_tunnel_dump_t *mp;
13024 vl_api_control_ping_t *mp_ping;
13026 u8 sw_if_index_set = 0;
13029 /* Parse args required to build the message */
13030 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13032 if (unformat (i, "sw_if_index %d", &sw_if_index))
13033 sw_if_index_set = 1;
13038 if (sw_if_index_set == 0)
13043 if (!vam->json_output)
13045 print (vam->ofp, "%11s%11s%24s%24s%13s%14s%12s",
13046 "sw_if_index", "instance", "src_address", "dst_address",
13047 "tunnel_type", "outer_fib_id", "session_id");
13050 /* Get list of gre-tunnel interfaces */
13051 M (GRE_TUNNEL_DUMP, mp);
13053 mp->sw_if_index = htonl (sw_if_index);
13057 /* Use a control ping for synchronization */
13058 MPING (CONTROL_PING, mp_ping);
13066 api_l2_fib_clear_table (vat_main_t * vam)
13068 // unformat_input_t * i = vam->input;
13069 vl_api_l2_fib_clear_table_t *mp;
13072 M (L2_FIB_CLEAR_TABLE, mp);
13080 api_l2_interface_efp_filter (vat_main_t * vam)
13082 unformat_input_t *i = vam->input;
13083 vl_api_l2_interface_efp_filter_t *mp;
13086 u8 sw_if_index_set = 0;
13089 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13091 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13092 sw_if_index_set = 1;
13093 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13094 sw_if_index_set = 1;
13095 else if (unformat (i, "enable"))
13097 else if (unformat (i, "disable"))
13101 clib_warning ("parse error '%U'", format_unformat_error, i);
13106 if (sw_if_index_set == 0)
13108 errmsg ("missing sw_if_index");
13112 M (L2_INTERFACE_EFP_FILTER, mp);
13114 mp->sw_if_index = ntohl (sw_if_index);
13115 mp->enable_disable = enable;
13122 #define foreach_vtr_op \
13123 _("disable", L2_VTR_DISABLED) \
13124 _("push-1", L2_VTR_PUSH_1) \
13125 _("push-2", L2_VTR_PUSH_2) \
13126 _("pop-1", L2_VTR_POP_1) \
13127 _("pop-2", L2_VTR_POP_2) \
13128 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
13129 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
13130 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
13131 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
13134 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
13136 unformat_input_t *i = vam->input;
13137 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
13139 u8 sw_if_index_set = 0;
13142 u32 push_dot1q = 1;
13147 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13149 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13150 sw_if_index_set = 1;
13151 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13152 sw_if_index_set = 1;
13153 else if (unformat (i, "vtr_op %d", &vtr_op))
13155 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
13158 else if (unformat (i, "push_dot1q %d", &push_dot1q))
13160 else if (unformat (i, "tag1 %d", &tag1))
13162 else if (unformat (i, "tag2 %d", &tag2))
13166 clib_warning ("parse error '%U'", format_unformat_error, i);
13171 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
13173 errmsg ("missing vtr operation or sw_if_index");
13177 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
13178 mp->sw_if_index = ntohl (sw_if_index);
13179 mp->vtr_op = ntohl (vtr_op);
13180 mp->push_dot1q = ntohl (push_dot1q);
13181 mp->tag1 = ntohl (tag1);
13182 mp->tag2 = ntohl (tag2);
13190 api_create_vhost_user_if (vat_main_t * vam)
13192 unformat_input_t *i = vam->input;
13193 vl_api_create_vhost_user_if_t *mp;
13196 u8 file_name_set = 0;
13197 u32 custom_dev_instance = ~0;
13199 u8 use_custom_mac = 0;
13200 u8 disable_mrg_rxbuf = 0;
13201 u8 disable_indirect_desc = 0;
13206 /* Shut up coverity */
13207 clib_memset (hwaddr, 0, sizeof (hwaddr));
13209 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13211 if (unformat (i, "socket %s", &file_name))
13215 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13217 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
13218 use_custom_mac = 1;
13219 else if (unformat (i, "server"))
13221 else if (unformat (i, "disable_mrg_rxbuf"))
13222 disable_mrg_rxbuf = 1;
13223 else if (unformat (i, "disable_indirect_desc"))
13224 disable_indirect_desc = 1;
13225 else if (unformat (i, "gso"))
13227 else if (unformat (i, "tag %s", &tag))
13233 if (file_name_set == 0)
13235 errmsg ("missing socket file name");
13239 if (vec_len (file_name) > 255)
13241 errmsg ("socket file name too long");
13244 vec_add1 (file_name, 0);
13246 M (CREATE_VHOST_USER_IF, mp);
13248 mp->is_server = is_server;
13249 mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
13250 mp->disable_indirect_desc = disable_indirect_desc;
13251 mp->enable_gso = enable_gso;
13252 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13253 vec_free (file_name);
13254 if (custom_dev_instance != ~0)
13257 mp->custom_dev_instance = ntohl (custom_dev_instance);
13260 mp->use_custom_mac = use_custom_mac;
13261 clib_memcpy (mp->mac_address, hwaddr, 6);
13263 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
13272 api_modify_vhost_user_if (vat_main_t * vam)
13274 unformat_input_t *i = vam->input;
13275 vl_api_modify_vhost_user_if_t *mp;
13278 u8 file_name_set = 0;
13279 u32 custom_dev_instance = ~0;
13280 u8 sw_if_index_set = 0;
13281 u32 sw_if_index = (u32) ~ 0;
13285 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13287 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13288 sw_if_index_set = 1;
13289 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13290 sw_if_index_set = 1;
13291 else if (unformat (i, "socket %s", &file_name))
13295 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13297 else if (unformat (i, "server"))
13299 else if (unformat (i, "gso"))
13305 if (sw_if_index_set == 0)
13307 errmsg ("missing sw_if_index or interface name");
13311 if (file_name_set == 0)
13313 errmsg ("missing socket file name");
13317 if (vec_len (file_name) > 255)
13319 errmsg ("socket file name too long");
13322 vec_add1 (file_name, 0);
13324 M (MODIFY_VHOST_USER_IF, mp);
13326 mp->sw_if_index = ntohl (sw_if_index);
13327 mp->is_server = is_server;
13328 mp->enable_gso = enable_gso;
13329 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13330 vec_free (file_name);
13331 if (custom_dev_instance != ~0)
13334 mp->custom_dev_instance = ntohl (custom_dev_instance);
13343 api_delete_vhost_user_if (vat_main_t * vam)
13345 unformat_input_t *i = vam->input;
13346 vl_api_delete_vhost_user_if_t *mp;
13347 u32 sw_if_index = ~0;
13348 u8 sw_if_index_set = 0;
13351 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13353 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13354 sw_if_index_set = 1;
13355 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13356 sw_if_index_set = 1;
13361 if (sw_if_index_set == 0)
13363 errmsg ("missing sw_if_index or interface name");
13368 M (DELETE_VHOST_USER_IF, mp);
13370 mp->sw_if_index = ntohl (sw_if_index);
13377 static void vl_api_sw_interface_vhost_user_details_t_handler
13378 (vl_api_sw_interface_vhost_user_details_t * mp)
13380 vat_main_t *vam = &vat_main;
13382 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
13383 (char *) mp->interface_name,
13384 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
13385 clib_net_to_host_u64 (mp->features), mp->is_server,
13386 ntohl (mp->num_regions), (char *) mp->sock_filename);
13387 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
13390 static void vl_api_sw_interface_vhost_user_details_t_handler_json
13391 (vl_api_sw_interface_vhost_user_details_t * mp)
13393 vat_main_t *vam = &vat_main;
13394 vat_json_node_t *node = NULL;
13396 if (VAT_JSON_ARRAY != vam->json_tree.type)
13398 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13399 vat_json_init_array (&vam->json_tree);
13401 node = vat_json_array_add (&vam->json_tree);
13403 vat_json_init_object (node);
13404 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13405 vat_json_object_add_string_copy (node, "interface_name",
13406 mp->interface_name);
13407 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
13408 ntohl (mp->virtio_net_hdr_sz));
13409 vat_json_object_add_uint (node, "features",
13410 clib_net_to_host_u64 (mp->features));
13411 vat_json_object_add_uint (node, "is_server", mp->is_server);
13412 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
13413 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
13414 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
13418 api_sw_interface_vhost_user_dump (vat_main_t * vam)
13420 vl_api_sw_interface_vhost_user_dump_t *mp;
13421 vl_api_control_ping_t *mp_ping;
13424 "Interface name idx hdr_sz features server regions filename");
13426 /* Get list of vhost-user interfaces */
13427 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
13430 /* Use a control ping for synchronization */
13431 MPING (CONTROL_PING, mp_ping);
13439 api_show_version (vat_main_t * vam)
13441 vl_api_show_version_t *mp;
13444 M (SHOW_VERSION, mp);
13453 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
13455 unformat_input_t *line_input = vam->input;
13456 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
13457 ip4_address_t local4, remote4;
13458 ip6_address_t local6, remote6;
13460 u8 ipv4_set = 0, ipv6_set = 0;
13464 u32 mcast_sw_if_index = ~0;
13465 u32 encap_vrf_id = 0;
13466 u32 decap_vrf_id = 0;
13472 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
13473 clib_memset (&local4, 0, sizeof local4);
13474 clib_memset (&remote4, 0, sizeof remote4);
13475 clib_memset (&local6, 0, sizeof local6);
13476 clib_memset (&remote6, 0, sizeof remote6);
13478 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13480 if (unformat (line_input, "del"))
13482 else if (unformat (line_input, "local %U",
13483 unformat_ip4_address, &local4))
13488 else if (unformat (line_input, "remote %U",
13489 unformat_ip4_address, &remote4))
13494 else if (unformat (line_input, "local %U",
13495 unformat_ip6_address, &local6))
13500 else if (unformat (line_input, "remote %U",
13501 unformat_ip6_address, &remote6))
13506 else if (unformat (line_input, "group %U %U",
13507 unformat_ip4_address, &remote4,
13508 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13510 grp_set = remote_set = 1;
13513 else if (unformat (line_input, "group %U",
13514 unformat_ip4_address, &remote4))
13516 grp_set = remote_set = 1;
13519 else if (unformat (line_input, "group %U %U",
13520 unformat_ip6_address, &remote6,
13521 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13523 grp_set = remote_set = 1;
13526 else if (unformat (line_input, "group %U",
13527 unformat_ip6_address, &remote6))
13529 grp_set = remote_set = 1;
13533 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13535 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13537 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
13539 else if (unformat (line_input, "vni %d", &vni))
13541 else if (unformat (line_input, "next-ip4"))
13543 else if (unformat (line_input, "next-ip6"))
13545 else if (unformat (line_input, "next-ethernet"))
13547 else if (unformat (line_input, "next-nsh"))
13551 errmsg ("parse error '%U'", format_unformat_error, line_input);
13556 if (local_set == 0)
13558 errmsg ("tunnel local address not specified");
13561 if (remote_set == 0)
13563 errmsg ("tunnel remote address not specified");
13566 if (grp_set && mcast_sw_if_index == ~0)
13568 errmsg ("tunnel nonexistent multicast device");
13571 if (ipv4_set && ipv6_set)
13573 errmsg ("both IPv4 and IPv6 addresses specified");
13579 errmsg ("vni not specified");
13583 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
13588 clib_memcpy (&mp->local, &local6, sizeof (local6));
13589 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
13593 clib_memcpy (&mp->local, &local4, sizeof (local4));
13594 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
13597 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
13598 mp->encap_vrf_id = ntohl (encap_vrf_id);
13599 mp->decap_vrf_id = ntohl (decap_vrf_id);
13600 mp->protocol = protocol;
13601 mp->vni = ntohl (vni);
13602 mp->is_add = is_add;
13603 mp->is_ipv6 = ipv6_set;
13610 static void vl_api_vxlan_gpe_tunnel_details_t_handler
13611 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13613 vat_main_t *vam = &vat_main;
13614 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
13615 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
13617 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
13618 ntohl (mp->sw_if_index),
13619 format_ip46_address, &local, IP46_TYPE_ANY,
13620 format_ip46_address, &remote, IP46_TYPE_ANY,
13621 ntohl (mp->vni), mp->protocol,
13622 ntohl (mp->mcast_sw_if_index),
13623 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
13627 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
13628 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13630 vat_main_t *vam = &vat_main;
13631 vat_json_node_t *node = NULL;
13632 struct in_addr ip4;
13633 struct in6_addr ip6;
13635 if (VAT_JSON_ARRAY != vam->json_tree.type)
13637 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13638 vat_json_init_array (&vam->json_tree);
13640 node = vat_json_array_add (&vam->json_tree);
13642 vat_json_init_object (node);
13643 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13646 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
13647 vat_json_object_add_ip6 (node, "local", ip6);
13648 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
13649 vat_json_object_add_ip6 (node, "remote", ip6);
13653 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
13654 vat_json_object_add_ip4 (node, "local", ip4);
13655 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
13656 vat_json_object_add_ip4 (node, "remote", ip4);
13658 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
13659 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
13660 vat_json_object_add_uint (node, "mcast_sw_if_index",
13661 ntohl (mp->mcast_sw_if_index));
13662 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
13663 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
13664 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
13668 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
13670 unformat_input_t *i = vam->input;
13671 vl_api_vxlan_gpe_tunnel_dump_t *mp;
13672 vl_api_control_ping_t *mp_ping;
13674 u8 sw_if_index_set = 0;
13677 /* Parse args required to build the message */
13678 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13680 if (unformat (i, "sw_if_index %d", &sw_if_index))
13681 sw_if_index_set = 1;
13686 if (sw_if_index_set == 0)
13691 if (!vam->json_output)
13693 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
13694 "sw_if_index", "local", "remote", "vni",
13695 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
13698 /* Get list of vxlan-tunnel interfaces */
13699 M (VXLAN_GPE_TUNNEL_DUMP, mp);
13701 mp->sw_if_index = htonl (sw_if_index);
13705 /* Use a control ping for synchronization */
13706 MPING (CONTROL_PING, mp_ping);
13713 static void vl_api_l2_fib_table_details_t_handler
13714 (vl_api_l2_fib_table_details_t * mp)
13716 vat_main_t *vam = &vat_main;
13718 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
13720 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
13721 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
13725 static void vl_api_l2_fib_table_details_t_handler_json
13726 (vl_api_l2_fib_table_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, "bd_id", ntohl (mp->bd_id));
13740 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
13741 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13742 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
13743 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
13744 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
13748 api_l2_fib_table_dump (vat_main_t * vam)
13750 unformat_input_t *i = vam->input;
13751 vl_api_l2_fib_table_dump_t *mp;
13752 vl_api_control_ping_t *mp_ping;
13757 /* Parse args required to build the message */
13758 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13760 if (unformat (i, "bd_id %d", &bd_id))
13766 if (bd_id_set == 0)
13768 errmsg ("missing bridge domain");
13772 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
13774 /* Get list of l2 fib entries */
13775 M (L2_FIB_TABLE_DUMP, mp);
13777 mp->bd_id = ntohl (bd_id);
13780 /* Use a control ping for synchronization */
13781 MPING (CONTROL_PING, mp_ping);
13790 api_interface_name_renumber (vat_main_t * vam)
13792 unformat_input_t *line_input = vam->input;
13793 vl_api_interface_name_renumber_t *mp;
13794 u32 sw_if_index = ~0;
13795 u32 new_show_dev_instance = ~0;
13798 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13800 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
13803 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13805 else if (unformat (line_input, "new_show_dev_instance %d",
13806 &new_show_dev_instance))
13812 if (sw_if_index == ~0)
13814 errmsg ("missing interface name or sw_if_index");
13818 if (new_show_dev_instance == ~0)
13820 errmsg ("missing new_show_dev_instance");
13824 M (INTERFACE_NAME_RENUMBER, mp);
13826 mp->sw_if_index = ntohl (sw_if_index);
13827 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
13835 api_ip_probe_neighbor (vat_main_t * vam)
13837 unformat_input_t *i = vam->input;
13838 vl_api_ip_probe_neighbor_t *mp;
13839 vl_api_address_t dst_adr = { };
13845 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13847 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13849 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13851 else if (unformat (i, "address %U", unformat_vl_api_address, &dst_adr))
13859 errmsg ("missing interface");
13865 errmsg ("missing addresses");
13869 M (IP_PROBE_NEIGHBOR, mp);
13871 mp->sw_if_index = ntohl (sw_if_index);
13872 clib_memcpy (&mp->dst, &dst_adr, sizeof (dst_adr));
13880 api_ip_scan_neighbor_enable_disable (vat_main_t * vam)
13882 unformat_input_t *i = vam->input;
13883 vl_api_ip_scan_neighbor_enable_disable_t *mp;
13884 u8 mode = IP_SCAN_V46_NEIGHBORS;
13885 u32 interval = 0, time = 0, update = 0, delay = 0, stale = 0;
13888 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13890 if (unformat (i, "ip4"))
13891 mode = IP_SCAN_V4_NEIGHBORS;
13892 else if (unformat (i, "ip6"))
13893 mode = IP_SCAN_V6_NEIGHBORS;
13894 if (unformat (i, "both"))
13895 mode = IP_SCAN_V46_NEIGHBORS;
13896 else if (unformat (i, "disable"))
13897 mode = IP_SCAN_DISABLED;
13898 else if (unformat (i, "interval %d", &interval))
13900 else if (unformat (i, "max-time %d", &time))
13902 else if (unformat (i, "max-update %d", &update))
13904 else if (unformat (i, "delay %d", &delay))
13906 else if (unformat (i, "stale %d", &stale))
13912 if (interval > 255)
13914 errmsg ("interval cannot exceed 255 minutes.");
13919 errmsg ("max-time cannot exceed 255 usec.");
13924 errmsg ("max-update cannot exceed 255.");
13929 errmsg ("delay cannot exceed 255 msec.");
13934 errmsg ("stale cannot exceed 255 minutes.");
13938 M (IP_SCAN_NEIGHBOR_ENABLE_DISABLE, mp);
13940 mp->scan_interval = interval;
13941 mp->max_proc_time = time;
13942 mp->max_update = update;
13943 mp->scan_int_delay = delay;
13944 mp->stale_threshold = stale;
13952 api_want_ip4_arp_events (vat_main_t * vam)
13954 unformat_input_t *line_input = vam->input;
13955 vl_api_want_ip4_arp_events_t *mp;
13956 ip4_address_t address;
13957 int address_set = 0;
13958 u32 enable_disable = 1;
13961 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13963 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
13965 else if (unformat (line_input, "del"))
13966 enable_disable = 0;
13971 if (address_set == 0)
13973 errmsg ("missing addresses");
13977 M (WANT_IP4_ARP_EVENTS, mp);
13978 mp->enable_disable = enable_disable;
13979 mp->pid = htonl (getpid ());
13980 clib_memcpy (mp->ip, &address, sizeof (address));
13988 api_want_ip6_nd_events (vat_main_t * vam)
13990 unformat_input_t *line_input = vam->input;
13991 vl_api_want_ip6_nd_events_t *mp;
13992 vl_api_ip6_address_t address;
13993 int address_set = 0;
13994 u32 enable_disable = 1;
13997 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14000 (line_input, "address %U", unformat_vl_api_ip6_address, &address))
14002 else if (unformat (line_input, "del"))
14003 enable_disable = 0;
14008 if (address_set == 0)
14010 errmsg ("missing addresses");
14014 M (WANT_IP6_ND_EVENTS, mp);
14015 mp->enable_disable = enable_disable;
14016 mp->pid = htonl (getpid ());
14017 clib_memcpy (&mp->ip, &address, sizeof (address));
14025 api_want_l2_macs_events (vat_main_t * vam)
14027 unformat_input_t *line_input = vam->input;
14028 vl_api_want_l2_macs_events_t *mp;
14029 u8 enable_disable = 1;
14030 u32 scan_delay = 0;
14031 u32 max_macs_in_event = 0;
14032 u32 learn_limit = 0;
14035 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14037 if (unformat (line_input, "learn-limit %d", &learn_limit))
14039 else if (unformat (line_input, "scan-delay %d", &scan_delay))
14041 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
14043 else if (unformat (line_input, "disable"))
14044 enable_disable = 0;
14049 M (WANT_L2_MACS_EVENTS, mp);
14050 mp->enable_disable = enable_disable;
14051 mp->pid = htonl (getpid ());
14052 mp->learn_limit = htonl (learn_limit);
14053 mp->scan_delay = (u8) scan_delay;
14054 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
14061 api_input_acl_set_interface (vat_main_t * vam)
14063 unformat_input_t *i = vam->input;
14064 vl_api_input_acl_set_interface_t *mp;
14066 int sw_if_index_set;
14067 u32 ip4_table_index = ~0;
14068 u32 ip6_table_index = ~0;
14069 u32 l2_table_index = ~0;
14073 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14075 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14076 sw_if_index_set = 1;
14077 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14078 sw_if_index_set = 1;
14079 else if (unformat (i, "del"))
14081 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14083 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14085 else if (unformat (i, "l2-table %d", &l2_table_index))
14089 clib_warning ("parse error '%U'", format_unformat_error, i);
14094 if (sw_if_index_set == 0)
14096 errmsg ("missing interface name or sw_if_index");
14100 M (INPUT_ACL_SET_INTERFACE, mp);
14102 mp->sw_if_index = ntohl (sw_if_index);
14103 mp->ip4_table_index = ntohl (ip4_table_index);
14104 mp->ip6_table_index = ntohl (ip6_table_index);
14105 mp->l2_table_index = ntohl (l2_table_index);
14106 mp->is_add = is_add;
14114 api_output_acl_set_interface (vat_main_t * vam)
14116 unformat_input_t *i = vam->input;
14117 vl_api_output_acl_set_interface_t *mp;
14119 int sw_if_index_set;
14120 u32 ip4_table_index = ~0;
14121 u32 ip6_table_index = ~0;
14122 u32 l2_table_index = ~0;
14126 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14128 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14129 sw_if_index_set = 1;
14130 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14131 sw_if_index_set = 1;
14132 else if (unformat (i, "del"))
14134 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14136 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14138 else if (unformat (i, "l2-table %d", &l2_table_index))
14142 clib_warning ("parse error '%U'", format_unformat_error, i);
14147 if (sw_if_index_set == 0)
14149 errmsg ("missing interface name or sw_if_index");
14153 M (OUTPUT_ACL_SET_INTERFACE, mp);
14155 mp->sw_if_index = ntohl (sw_if_index);
14156 mp->ip4_table_index = ntohl (ip4_table_index);
14157 mp->ip6_table_index = ntohl (ip6_table_index);
14158 mp->l2_table_index = ntohl (l2_table_index);
14159 mp->is_add = is_add;
14167 api_ip_address_dump (vat_main_t * vam)
14169 unformat_input_t *i = vam->input;
14170 vl_api_ip_address_dump_t *mp;
14171 vl_api_control_ping_t *mp_ping;
14172 u32 sw_if_index = ~0;
14173 u8 sw_if_index_set = 0;
14178 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14180 if (unformat (i, "sw_if_index %d", &sw_if_index))
14181 sw_if_index_set = 1;
14183 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14184 sw_if_index_set = 1;
14185 else if (unformat (i, "ipv4"))
14187 else if (unformat (i, "ipv6"))
14193 if (ipv4_set && ipv6_set)
14195 errmsg ("ipv4 and ipv6 flags cannot be both set");
14199 if ((!ipv4_set) && (!ipv6_set))
14201 errmsg ("no ipv4 nor ipv6 flag set");
14205 if (sw_if_index_set == 0)
14207 errmsg ("missing interface name or sw_if_index");
14211 vam->current_sw_if_index = sw_if_index;
14212 vam->is_ipv6 = ipv6_set;
14214 M (IP_ADDRESS_DUMP, mp);
14215 mp->sw_if_index = ntohl (sw_if_index);
14216 mp->is_ipv6 = ipv6_set;
14219 /* Use a control ping for synchronization */
14220 MPING (CONTROL_PING, mp_ping);
14228 api_ip_dump (vat_main_t * vam)
14230 vl_api_ip_dump_t *mp;
14231 vl_api_control_ping_t *mp_ping;
14232 unformat_input_t *in = vam->input;
14239 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
14241 if (unformat (in, "ipv4"))
14243 else if (unformat (in, "ipv6"))
14249 if (ipv4_set && ipv6_set)
14251 errmsg ("ipv4 and ipv6 flags cannot be both set");
14255 if ((!ipv4_set) && (!ipv6_set))
14257 errmsg ("no ipv4 nor ipv6 flag set");
14261 is_ipv6 = ipv6_set;
14262 vam->is_ipv6 = is_ipv6;
14264 /* free old data */
14265 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
14267 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
14269 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
14272 mp->is_ipv6 = ipv6_set;
14275 /* Use a control ping for synchronization */
14276 MPING (CONTROL_PING, mp_ping);
14284 api_ipsec_spd_add_del (vat_main_t * vam)
14286 unformat_input_t *i = vam->input;
14287 vl_api_ipsec_spd_add_del_t *mp;
14292 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14294 if (unformat (i, "spd_id %d", &spd_id))
14296 else if (unformat (i, "del"))
14300 clib_warning ("parse error '%U'", format_unformat_error, i);
14306 errmsg ("spd_id must be set");
14310 M (IPSEC_SPD_ADD_DEL, mp);
14312 mp->spd_id = ntohl (spd_id);
14313 mp->is_add = is_add;
14321 api_ipsec_interface_add_del_spd (vat_main_t * vam)
14323 unformat_input_t *i = vam->input;
14324 vl_api_ipsec_interface_add_del_spd_t *mp;
14326 u8 sw_if_index_set = 0;
14327 u32 spd_id = (u32) ~ 0;
14331 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14333 if (unformat (i, "del"))
14335 else if (unformat (i, "spd_id %d", &spd_id))
14338 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14339 sw_if_index_set = 1;
14340 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14341 sw_if_index_set = 1;
14344 clib_warning ("parse error '%U'", format_unformat_error, i);
14350 if (spd_id == (u32) ~ 0)
14352 errmsg ("spd_id must be set");
14356 if (sw_if_index_set == 0)
14358 errmsg ("missing interface name or sw_if_index");
14362 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
14364 mp->spd_id = ntohl (spd_id);
14365 mp->sw_if_index = ntohl (sw_if_index);
14366 mp->is_add = is_add;
14374 api_ipsec_spd_entry_add_del (vat_main_t * vam)
14376 unformat_input_t *i = vam->input;
14377 vl_api_ipsec_spd_entry_add_del_t *mp;
14378 u8 is_add = 1, is_outbound = 0;
14379 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
14381 u32 rport_start = 0, rport_stop = (u32) ~ 0;
14382 u32 lport_start = 0, lport_stop = (u32) ~ 0;
14383 vl_api_address_t laddr_start = { }, laddr_stop =
14392 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14394 if (unformat (i, "del"))
14396 if (unformat (i, "outbound"))
14398 if (unformat (i, "inbound"))
14400 else if (unformat (i, "spd_id %d", &spd_id))
14402 else if (unformat (i, "sa_id %d", &sa_id))
14404 else if (unformat (i, "priority %d", &priority))
14406 else if (unformat (i, "protocol %d", &protocol))
14408 else if (unformat (i, "lport_start %d", &lport_start))
14410 else if (unformat (i, "lport_stop %d", &lport_stop))
14412 else if (unformat (i, "rport_start %d", &rport_start))
14414 else if (unformat (i, "rport_stop %d", &rport_stop))
14416 else if (unformat (i, "laddr_start %U",
14417 unformat_vl_api_address, &laddr_start))
14419 else if (unformat (i, "laddr_stop %U", unformat_vl_api_address,
14422 else if (unformat (i, "raddr_start %U", unformat_vl_api_address,
14425 else if (unformat (i, "raddr_stop %U", unformat_vl_api_address,
14429 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
14431 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
14433 clib_warning ("unsupported action: 'resolve'");
14439 clib_warning ("parse error '%U'", format_unformat_error, i);
14445 M (IPSEC_SPD_ENTRY_ADD_DEL, mp);
14447 mp->is_add = is_add;
14449 mp->entry.spd_id = ntohl (spd_id);
14450 mp->entry.priority = ntohl (priority);
14451 mp->entry.is_outbound = is_outbound;
14453 clib_memcpy (&mp->entry.remote_address_start, &raddr_start,
14454 sizeof (vl_api_address_t));
14455 clib_memcpy (&mp->entry.remote_address_stop, &raddr_stop,
14456 sizeof (vl_api_address_t));
14457 clib_memcpy (&mp->entry.local_address_start, &laddr_start,
14458 sizeof (vl_api_address_t));
14459 clib_memcpy (&mp->entry.local_address_stop, &laddr_stop,
14460 sizeof (vl_api_address_t));
14462 mp->entry.protocol = (u8) protocol;
14463 mp->entry.local_port_start = ntohs ((u16) lport_start);
14464 mp->entry.local_port_stop = ntohs ((u16) lport_stop);
14465 mp->entry.remote_port_start = ntohs ((u16) rport_start);
14466 mp->entry.remote_port_stop = ntohs ((u16) rport_stop);
14467 mp->entry.policy = (u8) policy;
14468 mp->entry.sa_id = ntohl (sa_id);
14476 api_ipsec_sad_entry_add_del (vat_main_t * vam)
14478 unformat_input_t *i = vam->input;
14479 vl_api_ipsec_sad_entry_add_del_t *mp;
14480 u32 sad_id = 0, spi = 0;
14481 u8 *ck = 0, *ik = 0;
14484 vl_api_ipsec_crypto_alg_t crypto_alg = IPSEC_API_CRYPTO_ALG_NONE;
14485 vl_api_ipsec_integ_alg_t integ_alg = IPSEC_API_INTEG_ALG_NONE;
14486 vl_api_ipsec_sad_flags_t flags = IPSEC_API_SAD_FLAG_NONE;
14487 vl_api_ipsec_proto_t protocol = IPSEC_API_PROTO_AH;
14488 vl_api_address_t tun_src, tun_dst;
14491 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14493 if (unformat (i, "del"))
14495 else if (unformat (i, "sad_id %d", &sad_id))
14497 else if (unformat (i, "spi %d", &spi))
14499 else if (unformat (i, "esp"))
14500 protocol = IPSEC_API_PROTO_ESP;
14502 if (unformat (i, "tunnel_src %U", unformat_vl_api_address, &tun_src))
14504 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
14505 if (ADDRESS_IP6 == tun_src.af)
14506 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
14509 if (unformat (i, "tunnel_dst %U", unformat_vl_api_address, &tun_dst))
14511 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
14512 if (ADDRESS_IP6 == tun_src.af)
14513 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
14516 if (unformat (i, "crypto_alg %U",
14517 unformat_ipsec_api_crypto_alg, &crypto_alg))
14519 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14521 else if (unformat (i, "integ_alg %U",
14522 unformat_ipsec_api_integ_alg, &integ_alg))
14524 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14528 clib_warning ("parse error '%U'", format_unformat_error, i);
14534 M (IPSEC_SAD_ENTRY_ADD_DEL, mp);
14536 mp->is_add = is_add;
14537 mp->entry.sad_id = ntohl (sad_id);
14538 mp->entry.protocol = protocol;
14539 mp->entry.spi = ntohl (spi);
14540 mp->entry.flags = flags;
14542 mp->entry.crypto_algorithm = crypto_alg;
14543 mp->entry.integrity_algorithm = integ_alg;
14544 mp->entry.crypto_key.length = vec_len (ck);
14545 mp->entry.integrity_key.length = vec_len (ik);
14547 if (mp->entry.crypto_key.length > sizeof (mp->entry.crypto_key.data))
14548 mp->entry.crypto_key.length = sizeof (mp->entry.crypto_key.data);
14550 if (mp->entry.integrity_key.length > sizeof (mp->entry.integrity_key.data))
14551 mp->entry.integrity_key.length = sizeof (mp->entry.integrity_key.data);
14554 clib_memcpy (mp->entry.crypto_key.data, ck, mp->entry.crypto_key.length);
14556 clib_memcpy (mp->entry.integrity_key.data, ik,
14557 mp->entry.integrity_key.length);
14559 if (flags & IPSEC_API_SAD_FLAG_IS_TUNNEL)
14561 clib_memcpy (&mp->entry.tunnel_src, &tun_src,
14562 sizeof (mp->entry.tunnel_src));
14563 clib_memcpy (&mp->entry.tunnel_dst, &tun_dst,
14564 sizeof (mp->entry.tunnel_dst));
14573 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
14575 unformat_input_t *i = vam->input;
14576 vl_api_ipsec_tunnel_if_add_del_t *mp;
14577 u32 local_spi = 0, remote_spi = 0;
14578 u32 crypto_alg = 0, integ_alg = 0;
14579 u8 *lck = NULL, *rck = NULL;
14580 u8 *lik = NULL, *rik = NULL;
14581 vl_api_address_t local_ip = { 0 };
14582 vl_api_address_t remote_ip = { 0 };
14586 u8 anti_replay = 0;
14592 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14594 if (unformat (i, "del"))
14596 else if (unformat (i, "esn"))
14598 else if (unformat (i, "anti-replay"))
14600 else if (unformat (i, "count %d", &count))
14602 else if (unformat (i, "local_spi %d", &local_spi))
14604 else if (unformat (i, "remote_spi %d", &remote_spi))
14607 if (unformat (i, "local_ip %U", unformat_vl_api_address, &local_ip))
14610 if (unformat (i, "remote_ip %U", unformat_vl_api_address, &remote_ip))
14612 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
14615 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
14617 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
14619 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
14623 (i, "crypto_alg %U", unformat_ipsec_api_crypto_alg, &crypto_alg))
14625 if (crypto_alg >= IPSEC_CRYPTO_N_ALG)
14627 errmsg ("unsupported crypto-alg: '%U'\n",
14628 format_ipsec_crypto_alg, crypto_alg);
14634 (i, "integ_alg %U", unformat_ipsec_api_integ_alg, &integ_alg))
14636 if (integ_alg >= IPSEC_INTEG_N_ALG)
14638 errmsg ("unsupported integ-alg: '%U'\n",
14639 format_ipsec_integ_alg, integ_alg);
14643 else if (unformat (i, "instance %u", &instance))
14647 errmsg ("parse error '%U'\n", format_unformat_error, i);
14654 /* Turn on async mode */
14655 vam->async_mode = 1;
14656 vam->async_errors = 0;
14657 before = vat_time_now (vam);
14660 for (jj = 0; jj < count; jj++)
14662 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
14664 mp->is_add = is_add;
14666 mp->anti_replay = anti_replay;
14669 increment_address (&remote_ip);
14671 clib_memcpy (&mp->local_ip, &local_ip, sizeof (local_ip));
14672 clib_memcpy (&mp->remote_ip, &remote_ip, sizeof (remote_ip));
14674 mp->local_spi = htonl (local_spi + jj);
14675 mp->remote_spi = htonl (remote_spi + jj);
14676 mp->crypto_alg = (u8) crypto_alg;
14678 mp->local_crypto_key_len = 0;
14681 mp->local_crypto_key_len = vec_len (lck);
14682 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
14683 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
14684 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
14687 mp->remote_crypto_key_len = 0;
14690 mp->remote_crypto_key_len = vec_len (rck);
14691 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
14692 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
14693 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
14696 mp->integ_alg = (u8) integ_alg;
14698 mp->local_integ_key_len = 0;
14701 mp->local_integ_key_len = vec_len (lik);
14702 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
14703 mp->local_integ_key_len = sizeof (mp->local_integ_key);
14704 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
14707 mp->remote_integ_key_len = 0;
14710 mp->remote_integ_key_len = vec_len (rik);
14711 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
14712 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
14713 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
14718 mp->renumber = renumber;
14719 mp->show_instance = ntohl (instance);
14724 /* When testing multiple add/del ops, use a control-ping to sync */
14727 vl_api_control_ping_t *mp_ping;
14731 /* Shut off async mode */
14732 vam->async_mode = 0;
14734 MPING (CONTROL_PING, mp_ping);
14737 timeout = vat_time_now (vam) + 1.0;
14738 while (vat_time_now (vam) < timeout)
14739 if (vam->result_ready == 1)
14744 if (vam->retval == -99)
14745 errmsg ("timeout");
14747 if (vam->async_errors > 0)
14749 errmsg ("%d asynchronous errors", vam->async_errors);
14752 vam->async_errors = 0;
14753 after = vat_time_now (vam);
14755 /* slim chance, but we might have eaten SIGTERM on the first iteration */
14759 print (vam->ofp, "%d tunnels in %.6f secs, %.2f tunnels/sec",
14760 count, after - before, count / (after - before));
14764 /* Wait for a reply... */
14773 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
14775 vat_main_t *vam = &vat_main;
14777 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
14778 "crypto_key %U integ_alg %u integ_key %U flags %x "
14779 "tunnel_src_addr %U tunnel_dst_addr %U "
14780 "salt %u seq_outbound %lu last_seq_inbound %lu "
14781 "replay_window %lu\n",
14782 ntohl (mp->entry.sad_id),
14783 ntohl (mp->sw_if_index),
14784 ntohl (mp->entry.spi),
14785 ntohl (mp->entry.protocol),
14786 ntohl (mp->entry.crypto_algorithm),
14787 format_hex_bytes, mp->entry.crypto_key.data,
14788 mp->entry.crypto_key.length, ntohl (mp->entry.integrity_algorithm),
14789 format_hex_bytes, mp->entry.integrity_key.data,
14790 mp->entry.integrity_key.length, ntohl (mp->entry.flags),
14791 format_vl_api_address, &mp->entry.tunnel_src, format_vl_api_address,
14792 &mp->entry.tunnel_dst, ntohl (mp->salt),
14793 clib_net_to_host_u64 (mp->seq_outbound),
14794 clib_net_to_host_u64 (mp->last_seq_inbound),
14795 clib_net_to_host_u64 (mp->replay_window));
14798 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
14799 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
14801 static void vl_api_ipsec_sa_details_t_handler_json
14802 (vl_api_ipsec_sa_details_t * mp)
14804 vat_main_t *vam = &vat_main;
14805 vat_json_node_t *node = NULL;
14806 vl_api_ipsec_sad_flags_t flags;
14808 if (VAT_JSON_ARRAY != vam->json_tree.type)
14810 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14811 vat_json_init_array (&vam->json_tree);
14813 node = vat_json_array_add (&vam->json_tree);
14815 vat_json_init_object (node);
14816 vat_json_object_add_uint (node, "sa_id", ntohl (mp->entry.sad_id));
14817 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14818 vat_json_object_add_uint (node, "spi", ntohl (mp->entry.spi));
14819 vat_json_object_add_uint (node, "proto", ntohl (mp->entry.protocol));
14820 vat_json_object_add_uint (node, "crypto_alg",
14821 ntohl (mp->entry.crypto_algorithm));
14822 vat_json_object_add_uint (node, "integ_alg",
14823 ntohl (mp->entry.integrity_algorithm));
14824 flags = ntohl (mp->entry.flags);
14825 vat_json_object_add_uint (node, "use_esn",
14826 ! !(flags & IPSEC_API_SAD_FLAG_USE_ESN));
14827 vat_json_object_add_uint (node, "use_anti_replay",
14828 ! !(flags & IPSEC_API_SAD_FLAG_USE_ANTI_REPLAY));
14829 vat_json_object_add_uint (node, "is_tunnel",
14830 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL));
14831 vat_json_object_add_uint (node, "is_tunnel_ip6",
14832 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL_V6));
14833 vat_json_object_add_uint (node, "udp_encap",
14834 ! !(flags & IPSEC_API_SAD_FLAG_UDP_ENCAP));
14835 vat_json_object_add_bytes (node, "crypto_key", mp->entry.crypto_key.data,
14836 mp->entry.crypto_key.length);
14837 vat_json_object_add_bytes (node, "integ_key", mp->entry.integrity_key.data,
14838 mp->entry.integrity_key.length);
14839 vat_json_object_add_address (node, "src", &mp->entry.tunnel_src);
14840 vat_json_object_add_address (node, "dst", &mp->entry.tunnel_dst);
14841 vat_json_object_add_uint (node, "replay_window",
14842 clib_net_to_host_u64 (mp->replay_window));
14846 api_ipsec_sa_dump (vat_main_t * vam)
14848 unformat_input_t *i = vam->input;
14849 vl_api_ipsec_sa_dump_t *mp;
14850 vl_api_control_ping_t *mp_ping;
14854 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14856 if (unformat (i, "sa_id %d", &sa_id))
14860 clib_warning ("parse error '%U'", format_unformat_error, i);
14865 M (IPSEC_SA_DUMP, mp);
14867 mp->sa_id = ntohl (sa_id);
14871 /* Use a control ping for synchronization */
14872 M (CONTROL_PING, mp_ping);
14880 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
14882 unformat_input_t *i = vam->input;
14883 vl_api_ipsec_tunnel_if_set_sa_t *mp;
14884 u32 sw_if_index = ~0;
14886 u8 is_outbound = (u8) ~ 0;
14889 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14891 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14893 else if (unformat (i, "sa_id %d", &sa_id))
14895 else if (unformat (i, "outbound"))
14897 else if (unformat (i, "inbound"))
14901 clib_warning ("parse error '%U'", format_unformat_error, i);
14906 if (sw_if_index == ~0)
14908 errmsg ("interface must be specified");
14914 errmsg ("SA ID must be specified");
14918 M (IPSEC_TUNNEL_IF_SET_SA, mp);
14920 mp->sw_if_index = htonl (sw_if_index);
14921 mp->sa_id = htonl (sa_id);
14922 mp->is_outbound = is_outbound;
14931 api_get_first_msg_id (vat_main_t * vam)
14933 vl_api_get_first_msg_id_t *mp;
14934 unformat_input_t *i = vam->input;
14939 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14941 if (unformat (i, "client %s", &name))
14949 errmsg ("missing client name");
14952 vec_add1 (name, 0);
14954 if (vec_len (name) > 63)
14956 errmsg ("client name too long");
14960 M (GET_FIRST_MSG_ID, mp);
14961 clib_memcpy (mp->name, name, vec_len (name));
14968 api_cop_interface_enable_disable (vat_main_t * vam)
14970 unformat_input_t *line_input = vam->input;
14971 vl_api_cop_interface_enable_disable_t *mp;
14972 u32 sw_if_index = ~0;
14973 u8 enable_disable = 1;
14976 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14978 if (unformat (line_input, "disable"))
14979 enable_disable = 0;
14980 if (unformat (line_input, "enable"))
14981 enable_disable = 1;
14982 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14983 vam, &sw_if_index))
14985 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14991 if (sw_if_index == ~0)
14993 errmsg ("missing interface name or sw_if_index");
14997 /* Construct the API message */
14998 M (COP_INTERFACE_ENABLE_DISABLE, mp);
14999 mp->sw_if_index = ntohl (sw_if_index);
15000 mp->enable_disable = enable_disable;
15004 /* Wait for the reply */
15010 api_cop_whitelist_enable_disable (vat_main_t * vam)
15012 unformat_input_t *line_input = vam->input;
15013 vl_api_cop_whitelist_enable_disable_t *mp;
15014 u32 sw_if_index = ~0;
15015 u8 ip4 = 0, ip6 = 0, default_cop = 0;
15019 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15021 if (unformat (line_input, "ip4"))
15023 else if (unformat (line_input, "ip6"))
15025 else if (unformat (line_input, "default"))
15027 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
15028 vam, &sw_if_index))
15030 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
15032 else if (unformat (line_input, "fib-id %d", &fib_id))
15038 if (sw_if_index == ~0)
15040 errmsg ("missing interface name or sw_if_index");
15044 /* Construct the API message */
15045 M (COP_WHITELIST_ENABLE_DISABLE, mp);
15046 mp->sw_if_index = ntohl (sw_if_index);
15047 mp->fib_id = ntohl (fib_id);
15050 mp->default_cop = default_cop;
15054 /* Wait for the reply */
15060 api_get_node_graph (vat_main_t * vam)
15062 vl_api_get_node_graph_t *mp;
15065 M (GET_NODE_GRAPH, mp);
15069 /* Wait for the reply */
15075 /** Used for parsing LISP eids */
15076 typedef CLIB_PACKED(struct{
15077 u8 addr[16]; /**< eid address */
15078 u32 len; /**< prefix length if IP */
15079 u8 type; /**< type of eid */
15084 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
15086 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
15088 clib_memset (a, 0, sizeof (a[0]));
15090 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
15092 a->type = 0; /* ipv4 type */
15094 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
15096 a->type = 1; /* ipv6 type */
15098 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
15100 a->type = 2; /* mac type */
15102 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
15104 a->type = 3; /* NSH type */
15105 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
15106 nsh->spi = clib_host_to_net_u32 (nsh->spi);
15113 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
15122 lisp_eid_size_vat (u8 type)
15139 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
15141 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
15145 api_one_add_del_locator_set (vat_main_t * vam)
15147 unformat_input_t *input = vam->input;
15148 vl_api_one_add_del_locator_set_t *mp;
15150 u8 *locator_set_name = NULL;
15151 u8 locator_set_name_set = 0;
15152 vl_api_local_locator_t locator, *locators = 0;
15153 u32 sw_if_index, priority, weight;
15157 /* Parse args required to build the message */
15158 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15160 if (unformat (input, "del"))
15164 else if (unformat (input, "locator-set %s", &locator_set_name))
15166 locator_set_name_set = 1;
15168 else if (unformat (input, "sw_if_index %u p %u w %u",
15169 &sw_if_index, &priority, &weight))
15171 locator.sw_if_index = htonl (sw_if_index);
15172 locator.priority = priority;
15173 locator.weight = weight;
15174 vec_add1 (locators, locator);
15178 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
15179 &sw_if_index, &priority, &weight))
15181 locator.sw_if_index = htonl (sw_if_index);
15182 locator.priority = priority;
15183 locator.weight = weight;
15184 vec_add1 (locators, locator);
15190 if (locator_set_name_set == 0)
15192 errmsg ("missing locator-set name");
15193 vec_free (locators);
15197 if (vec_len (locator_set_name) > 64)
15199 errmsg ("locator-set name too long");
15200 vec_free (locator_set_name);
15201 vec_free (locators);
15204 vec_add1 (locator_set_name, 0);
15206 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
15208 /* Construct the API message */
15209 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
15211 mp->is_add = is_add;
15212 clib_memcpy (mp->locator_set_name, locator_set_name,
15213 vec_len (locator_set_name));
15214 vec_free (locator_set_name);
15216 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
15218 clib_memcpy (mp->locators, locators, data_len);
15219 vec_free (locators);
15224 /* Wait for a reply... */
15229 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
15232 api_one_add_del_locator (vat_main_t * vam)
15234 unformat_input_t *input = vam->input;
15235 vl_api_one_add_del_locator_t *mp;
15236 u32 tmp_if_index = ~0;
15237 u32 sw_if_index = ~0;
15238 u8 sw_if_index_set = 0;
15239 u8 sw_if_index_if_name_set = 0;
15241 u8 priority_set = 0;
15245 u8 *locator_set_name = NULL;
15246 u8 locator_set_name_set = 0;
15249 /* Parse args required to build the message */
15250 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15252 if (unformat (input, "del"))
15256 else if (unformat (input, "locator-set %s", &locator_set_name))
15258 locator_set_name_set = 1;
15260 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
15263 sw_if_index_if_name_set = 1;
15264 sw_if_index = tmp_if_index;
15266 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
15268 sw_if_index_set = 1;
15269 sw_if_index = tmp_if_index;
15271 else if (unformat (input, "p %d", &priority))
15275 else if (unformat (input, "w %d", &weight))
15283 if (locator_set_name_set == 0)
15285 errmsg ("missing locator-set name");
15289 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
15291 errmsg ("missing sw_if_index");
15292 vec_free (locator_set_name);
15296 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
15298 errmsg ("cannot use both params interface name and sw_if_index");
15299 vec_free (locator_set_name);
15303 if (priority_set == 0)
15305 errmsg ("missing locator-set priority");
15306 vec_free (locator_set_name);
15310 if (weight_set == 0)
15312 errmsg ("missing locator-set weight");
15313 vec_free (locator_set_name);
15317 if (vec_len (locator_set_name) > 64)
15319 errmsg ("locator-set name too long");
15320 vec_free (locator_set_name);
15323 vec_add1 (locator_set_name, 0);
15325 /* Construct the API message */
15326 M (ONE_ADD_DEL_LOCATOR, mp);
15328 mp->is_add = is_add;
15329 mp->sw_if_index = ntohl (sw_if_index);
15330 mp->priority = priority;
15331 mp->weight = weight;
15332 clib_memcpy (mp->locator_set_name, locator_set_name,
15333 vec_len (locator_set_name));
15334 vec_free (locator_set_name);
15339 /* Wait for a reply... */
15344 #define api_lisp_add_del_locator api_one_add_del_locator
15347 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
15349 u32 *key_id = va_arg (*args, u32 *);
15352 if (unformat (input, "%s", &s))
15354 if (!strcmp ((char *) s, "sha1"))
15355 key_id[0] = HMAC_SHA_1_96;
15356 else if (!strcmp ((char *) s, "sha256"))
15357 key_id[0] = HMAC_SHA_256_128;
15360 clib_warning ("invalid key_id: '%s'", s);
15361 key_id[0] = HMAC_NO_KEY;
15372 api_one_add_del_local_eid (vat_main_t * vam)
15374 unformat_input_t *input = vam->input;
15375 vl_api_one_add_del_local_eid_t *mp;
15378 lisp_eid_vat_t _eid, *eid = &_eid;
15379 u8 *locator_set_name = 0;
15380 u8 locator_set_name_set = 0;
15386 /* Parse args required to build the message */
15387 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15389 if (unformat (input, "del"))
15393 else if (unformat (input, "vni %d", &vni))
15397 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
15401 else if (unformat (input, "locator-set %s", &locator_set_name))
15403 locator_set_name_set = 1;
15405 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
15407 else if (unformat (input, "secret-key %_%v%_", &key))
15413 if (locator_set_name_set == 0)
15415 errmsg ("missing locator-set name");
15421 errmsg ("EID address not set!");
15422 vec_free (locator_set_name);
15426 if (key && (0 == key_id))
15428 errmsg ("invalid key_id!");
15432 if (vec_len (key) > 64)
15434 errmsg ("key too long");
15439 if (vec_len (locator_set_name) > 64)
15441 errmsg ("locator-set name too long");
15442 vec_free (locator_set_name);
15445 vec_add1 (locator_set_name, 0);
15447 /* Construct the API message */
15448 M (ONE_ADD_DEL_LOCAL_EID, mp);
15450 mp->is_add = is_add;
15451 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
15452 mp->eid_type = eid->type;
15453 mp->prefix_len = eid->len;
15454 mp->vni = clib_host_to_net_u32 (vni);
15455 mp->key_id = clib_host_to_net_u16 (key_id);
15456 clib_memcpy (mp->locator_set_name, locator_set_name,
15457 vec_len (locator_set_name));
15458 clib_memcpy (mp->key, key, vec_len (key));
15460 vec_free (locator_set_name);
15466 /* Wait for a reply... */
15471 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
15474 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
15476 u32 dp_table = 0, vni = 0;;
15477 unformat_input_t *input = vam->input;
15478 vl_api_gpe_add_del_fwd_entry_t *mp;
15480 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
15481 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
15482 u8 rmt_eid_set = 0, lcl_eid_set = 0;
15483 u32 action = ~0, w;
15484 ip4_address_t rmt_rloc4, lcl_rloc4;
15485 ip6_address_t rmt_rloc6, lcl_rloc6;
15486 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
15489 clib_memset (&rloc, 0, sizeof (rloc));
15491 /* Parse args required to build the message */
15492 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15494 if (unformat (input, "del"))
15496 else if (unformat (input, "add"))
15498 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
15502 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
15506 else if (unformat (input, "vrf %d", &dp_table))
15508 else if (unformat (input, "bd %d", &dp_table))
15510 else if (unformat (input, "vni %d", &vni))
15512 else if (unformat (input, "w %d", &w))
15516 errmsg ("No RLOC configured for setting priority/weight!");
15519 curr_rloc->weight = w;
15521 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
15522 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
15526 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
15528 vec_add1 (lcl_locs, rloc);
15530 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
15531 vec_add1 (rmt_locs, rloc);
15532 /* weight saved in rmt loc */
15533 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
15535 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
15536 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
15539 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
15541 vec_add1 (lcl_locs, rloc);
15543 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
15544 vec_add1 (rmt_locs, rloc);
15545 /* weight saved in rmt loc */
15546 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
15548 else if (unformat (input, "action %d", &action))
15554 clib_warning ("parse error '%U'", format_unformat_error, input);
15561 errmsg ("remote eid addresses not set");
15565 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
15567 errmsg ("eid types don't match");
15571 if (0 == rmt_locs && (u32) ~ 0 == action)
15573 errmsg ("action not set for negative mapping");
15577 /* Construct the API message */
15578 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
15579 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
15581 mp->is_add = is_add;
15582 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
15583 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
15584 mp->eid_type = rmt_eid->type;
15585 mp->dp_table = clib_host_to_net_u32 (dp_table);
15586 mp->vni = clib_host_to_net_u32 (vni);
15587 mp->rmt_len = rmt_eid->len;
15588 mp->lcl_len = lcl_eid->len;
15589 mp->action = action;
15591 if (0 != rmt_locs && 0 != lcl_locs)
15593 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
15594 clib_memcpy (mp->locs, lcl_locs,
15595 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
15597 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
15598 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
15599 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
15601 vec_free (lcl_locs);
15602 vec_free (rmt_locs);
15607 /* Wait for a reply... */
15613 api_one_add_del_map_server (vat_main_t * vam)
15615 unformat_input_t *input = vam->input;
15616 vl_api_one_add_del_map_server_t *mp;
15620 ip4_address_t ipv4;
15621 ip6_address_t ipv6;
15624 /* Parse args required to build the message */
15625 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15627 if (unformat (input, "del"))
15631 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
15635 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
15643 if (ipv4_set && ipv6_set)
15645 errmsg ("both eid v4 and v6 addresses set");
15649 if (!ipv4_set && !ipv6_set)
15651 errmsg ("eid addresses not set");
15655 /* Construct the API message */
15656 M (ONE_ADD_DEL_MAP_SERVER, mp);
15658 mp->is_add = is_add;
15662 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
15667 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
15673 /* Wait for a reply... */
15678 #define api_lisp_add_del_map_server api_one_add_del_map_server
15681 api_one_add_del_map_resolver (vat_main_t * vam)
15683 unformat_input_t *input = vam->input;
15684 vl_api_one_add_del_map_resolver_t *mp;
15688 ip4_address_t ipv4;
15689 ip6_address_t ipv6;
15692 /* Parse args required to build the message */
15693 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15695 if (unformat (input, "del"))
15699 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
15703 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
15711 if (ipv4_set && ipv6_set)
15713 errmsg ("both eid v4 and v6 addresses set");
15717 if (!ipv4_set && !ipv6_set)
15719 errmsg ("eid addresses not set");
15723 /* Construct the API message */
15724 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
15726 mp->is_add = is_add;
15730 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
15735 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
15741 /* Wait for a reply... */
15746 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
15749 api_lisp_gpe_enable_disable (vat_main_t * vam)
15751 unformat_input_t *input = vam->input;
15752 vl_api_gpe_enable_disable_t *mp;
15757 /* Parse args required to build the message */
15758 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15760 if (unformat (input, "enable"))
15765 else if (unformat (input, "disable"))
15776 errmsg ("Value not set");
15780 /* Construct the API message */
15781 M (GPE_ENABLE_DISABLE, mp);
15788 /* Wait for a reply... */
15794 api_one_rloc_probe_enable_disable (vat_main_t * vam)
15796 unformat_input_t *input = vam->input;
15797 vl_api_one_rloc_probe_enable_disable_t *mp;
15802 /* Parse args required to build the message */
15803 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15805 if (unformat (input, "enable"))
15810 else if (unformat (input, "disable"))
15818 errmsg ("Value not set");
15822 /* Construct the API message */
15823 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
15825 mp->is_enabled = is_en;
15830 /* Wait for a reply... */
15835 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
15838 api_one_map_register_enable_disable (vat_main_t * vam)
15840 unformat_input_t *input = vam->input;
15841 vl_api_one_map_register_enable_disable_t *mp;
15846 /* Parse args required to build the message */
15847 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15849 if (unformat (input, "enable"))
15854 else if (unformat (input, "disable"))
15862 errmsg ("Value not set");
15866 /* Construct the API message */
15867 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
15869 mp->is_enabled = is_en;
15874 /* Wait for a reply... */
15879 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
15882 api_one_enable_disable (vat_main_t * vam)
15884 unformat_input_t *input = vam->input;
15885 vl_api_one_enable_disable_t *mp;
15890 /* Parse args required to build the message */
15891 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15893 if (unformat (input, "enable"))
15898 else if (unformat (input, "disable"))
15908 errmsg ("Value not set");
15912 /* Construct the API message */
15913 M (ONE_ENABLE_DISABLE, mp);
15920 /* Wait for a reply... */
15925 #define api_lisp_enable_disable api_one_enable_disable
15928 api_one_enable_disable_xtr_mode (vat_main_t * vam)
15930 unformat_input_t *input = vam->input;
15931 vl_api_one_enable_disable_xtr_mode_t *mp;
15936 /* Parse args required to build the message */
15937 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15939 if (unformat (input, "enable"))
15944 else if (unformat (input, "disable"))
15954 errmsg ("Value not set");
15958 /* Construct the API message */
15959 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
15966 /* Wait for a reply... */
15972 api_one_show_xtr_mode (vat_main_t * vam)
15974 vl_api_one_show_xtr_mode_t *mp;
15977 /* Construct the API message */
15978 M (ONE_SHOW_XTR_MODE, mp);
15983 /* Wait for a reply... */
15989 api_one_enable_disable_pitr_mode (vat_main_t * vam)
15991 unformat_input_t *input = vam->input;
15992 vl_api_one_enable_disable_pitr_mode_t *mp;
15997 /* Parse args required to build the message */
15998 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16000 if (unformat (input, "enable"))
16005 else if (unformat (input, "disable"))
16015 errmsg ("Value not set");
16019 /* Construct the API message */
16020 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
16027 /* Wait for a reply... */
16033 api_one_show_pitr_mode (vat_main_t * vam)
16035 vl_api_one_show_pitr_mode_t *mp;
16038 /* Construct the API message */
16039 M (ONE_SHOW_PITR_MODE, mp);
16044 /* Wait for a reply... */
16050 api_one_enable_disable_petr_mode (vat_main_t * vam)
16052 unformat_input_t *input = vam->input;
16053 vl_api_one_enable_disable_petr_mode_t *mp;
16058 /* Parse args required to build the message */
16059 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16061 if (unformat (input, "enable"))
16066 else if (unformat (input, "disable"))
16076 errmsg ("Value not set");
16080 /* Construct the API message */
16081 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
16088 /* Wait for a reply... */
16094 api_one_show_petr_mode (vat_main_t * vam)
16096 vl_api_one_show_petr_mode_t *mp;
16099 /* Construct the API message */
16100 M (ONE_SHOW_PETR_MODE, mp);
16105 /* Wait for a reply... */
16111 api_show_one_map_register_state (vat_main_t * vam)
16113 vl_api_show_one_map_register_state_t *mp;
16116 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
16121 /* wait for reply */
16126 #define api_show_lisp_map_register_state api_show_one_map_register_state
16129 api_show_one_rloc_probe_state (vat_main_t * vam)
16131 vl_api_show_one_rloc_probe_state_t *mp;
16134 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
16139 /* wait for reply */
16144 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
16147 api_one_add_del_ndp_entry (vat_main_t * vam)
16149 vl_api_one_add_del_ndp_entry_t *mp;
16150 unformat_input_t *input = vam->input;
16155 u8 mac[6] = { 0, };
16156 u8 ip6[16] = { 0, };
16160 /* Parse args required to build the message */
16161 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16163 if (unformat (input, "del"))
16165 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
16167 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
16169 else if (unformat (input, "bd %d", &bd))
16173 errmsg ("parse error '%U'", format_unformat_error, input);
16178 if (!bd_set || !ip_set || (!mac_set && is_add))
16180 errmsg ("Missing BD, IP or MAC!");
16184 M (ONE_ADD_DEL_NDP_ENTRY, mp);
16185 mp->is_add = is_add;
16186 clib_memcpy (mp->mac, mac, 6);
16187 mp->bd = clib_host_to_net_u32 (bd);
16188 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
16193 /* wait for reply */
16199 api_one_add_del_l2_arp_entry (vat_main_t * vam)
16201 vl_api_one_add_del_l2_arp_entry_t *mp;
16202 unformat_input_t *input = vam->input;
16207 u8 mac[6] = { 0, };
16208 u32 ip4 = 0, bd = ~0;
16211 /* Parse args required to build the message */
16212 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16214 if (unformat (input, "del"))
16216 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
16218 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
16220 else if (unformat (input, "bd %d", &bd))
16224 errmsg ("parse error '%U'", format_unformat_error, input);
16229 if (!bd_set || !ip_set || (!mac_set && is_add))
16231 errmsg ("Missing BD, IP or MAC!");
16235 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
16236 mp->is_add = is_add;
16237 clib_memcpy (mp->mac, mac, 6);
16238 mp->bd = clib_host_to_net_u32 (bd);
16244 /* wait for reply */
16250 api_one_ndp_bd_get (vat_main_t * vam)
16252 vl_api_one_ndp_bd_get_t *mp;
16255 M (ONE_NDP_BD_GET, mp);
16260 /* wait for reply */
16266 api_one_ndp_entries_get (vat_main_t * vam)
16268 vl_api_one_ndp_entries_get_t *mp;
16269 unformat_input_t *input = vam->input;
16274 /* Parse args required to build the message */
16275 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16277 if (unformat (input, "bd %d", &bd))
16281 errmsg ("parse error '%U'", format_unformat_error, input);
16288 errmsg ("Expected bridge domain!");
16292 M (ONE_NDP_ENTRIES_GET, mp);
16293 mp->bd = clib_host_to_net_u32 (bd);
16298 /* wait for reply */
16304 api_one_l2_arp_bd_get (vat_main_t * vam)
16306 vl_api_one_l2_arp_bd_get_t *mp;
16309 M (ONE_L2_ARP_BD_GET, mp);
16314 /* wait for reply */
16320 api_one_l2_arp_entries_get (vat_main_t * vam)
16322 vl_api_one_l2_arp_entries_get_t *mp;
16323 unformat_input_t *input = vam->input;
16328 /* Parse args required to build the message */
16329 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16331 if (unformat (input, "bd %d", &bd))
16335 errmsg ("parse error '%U'", format_unformat_error, input);
16342 errmsg ("Expected bridge domain!");
16346 M (ONE_L2_ARP_ENTRIES_GET, mp);
16347 mp->bd = clib_host_to_net_u32 (bd);
16352 /* wait for reply */
16358 api_one_stats_enable_disable (vat_main_t * vam)
16360 vl_api_one_stats_enable_disable_t *mp;
16361 unformat_input_t *input = vam->input;
16366 /* Parse args required to build the message */
16367 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16369 if (unformat (input, "enable"))
16374 else if (unformat (input, "disable"))
16384 errmsg ("Value not set");
16388 M (ONE_STATS_ENABLE_DISABLE, mp);
16394 /* wait for reply */
16400 api_show_one_stats_enable_disable (vat_main_t * vam)
16402 vl_api_show_one_stats_enable_disable_t *mp;
16405 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
16410 /* wait for reply */
16416 api_show_one_map_request_mode (vat_main_t * vam)
16418 vl_api_show_one_map_request_mode_t *mp;
16421 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
16426 /* wait for reply */
16431 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
16434 api_one_map_request_mode (vat_main_t * vam)
16436 unformat_input_t *input = vam->input;
16437 vl_api_one_map_request_mode_t *mp;
16441 /* Parse args required to build the message */
16442 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16444 if (unformat (input, "dst-only"))
16446 else if (unformat (input, "src-dst"))
16450 errmsg ("parse error '%U'", format_unformat_error, input);
16455 M (ONE_MAP_REQUEST_MODE, mp);
16462 /* wait for reply */
16467 #define api_lisp_map_request_mode api_one_map_request_mode
16470 * Enable/disable ONE proxy ITR.
16472 * @param vam vpp API test context
16473 * @return return code
16476 api_one_pitr_set_locator_set (vat_main_t * vam)
16478 u8 ls_name_set = 0;
16479 unformat_input_t *input = vam->input;
16480 vl_api_one_pitr_set_locator_set_t *mp;
16485 /* Parse args required to build the message */
16486 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16488 if (unformat (input, "del"))
16490 else if (unformat (input, "locator-set %s", &ls_name))
16494 errmsg ("parse error '%U'", format_unformat_error, input);
16501 errmsg ("locator-set name not set!");
16505 M (ONE_PITR_SET_LOCATOR_SET, mp);
16507 mp->is_add = is_add;
16508 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
16509 vec_free (ls_name);
16514 /* wait for reply */
16519 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
16522 api_one_nsh_set_locator_set (vat_main_t * vam)
16524 u8 ls_name_set = 0;
16525 unformat_input_t *input = vam->input;
16526 vl_api_one_nsh_set_locator_set_t *mp;
16531 /* Parse args required to build the message */
16532 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16534 if (unformat (input, "del"))
16536 else if (unformat (input, "ls %s", &ls_name))
16540 errmsg ("parse error '%U'", format_unformat_error, input);
16545 if (!ls_name_set && is_add)
16547 errmsg ("locator-set name not set!");
16551 M (ONE_NSH_SET_LOCATOR_SET, mp);
16553 mp->is_add = is_add;
16554 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
16555 vec_free (ls_name);
16560 /* wait for reply */
16566 api_show_one_pitr (vat_main_t * vam)
16568 vl_api_show_one_pitr_t *mp;
16571 if (!vam->json_output)
16573 print (vam->ofp, "%=20s", "lisp status:");
16576 M (SHOW_ONE_PITR, mp);
16580 /* Wait for a reply... */
16585 #define api_show_lisp_pitr api_show_one_pitr
16588 api_one_use_petr (vat_main_t * vam)
16590 unformat_input_t *input = vam->input;
16591 vl_api_one_use_petr_t *mp;
16596 clib_memset (&ip, 0, sizeof (ip));
16598 /* Parse args required to build the message */
16599 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16601 if (unformat (input, "disable"))
16604 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
16607 ip_addr_version (&ip) = IP4;
16610 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
16613 ip_addr_version (&ip) = IP6;
16617 errmsg ("parse error '%U'", format_unformat_error, input);
16622 M (ONE_USE_PETR, mp);
16624 mp->is_add = is_add;
16627 mp->is_ip4 = ip_addr_version (&ip) == IP4 ? 1 : 0;
16629 clib_memcpy (mp->address, &ip, 4);
16631 clib_memcpy (mp->address, &ip, 16);
16637 /* wait for reply */
16642 #define api_lisp_use_petr api_one_use_petr
16645 api_show_one_nsh_mapping (vat_main_t * vam)
16647 vl_api_show_one_use_petr_t *mp;
16650 if (!vam->json_output)
16652 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
16655 M (SHOW_ONE_NSH_MAPPING, mp);
16659 /* Wait for a reply... */
16665 api_show_one_use_petr (vat_main_t * vam)
16667 vl_api_show_one_use_petr_t *mp;
16670 if (!vam->json_output)
16672 print (vam->ofp, "%=20s", "Proxy-ETR status:");
16675 M (SHOW_ONE_USE_PETR, mp);
16679 /* Wait for a reply... */
16684 #define api_show_lisp_use_petr api_show_one_use_petr
16687 * Add/delete mapping between vni and vrf
16690 api_one_eid_table_add_del_map (vat_main_t * vam)
16692 unformat_input_t *input = vam->input;
16693 vl_api_one_eid_table_add_del_map_t *mp;
16694 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
16695 u32 vni, vrf, bd_index;
16698 /* Parse args required to build the message */
16699 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16701 if (unformat (input, "del"))
16703 else if (unformat (input, "vrf %d", &vrf))
16705 else if (unformat (input, "bd_index %d", &bd_index))
16707 else if (unformat (input, "vni %d", &vni))
16713 if (!vni_set || (!vrf_set && !bd_index_set))
16715 errmsg ("missing arguments!");
16719 if (vrf_set && bd_index_set)
16721 errmsg ("error: both vrf and bd entered!");
16725 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
16727 mp->is_add = is_add;
16728 mp->vni = htonl (vni);
16729 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
16730 mp->is_l2 = bd_index_set;
16735 /* wait for reply */
16740 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
16743 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
16745 u32 *action = va_arg (*args, u32 *);
16748 if (unformat (input, "%s", &s))
16750 if (!strcmp ((char *) s, "no-action"))
16752 else if (!strcmp ((char *) s, "natively-forward"))
16754 else if (!strcmp ((char *) s, "send-map-request"))
16756 else if (!strcmp ((char *) s, "drop"))
16760 clib_warning ("invalid action: '%s'", s);
16772 * Add/del remote mapping to/from ONE control plane
16774 * @param vam vpp API test context
16775 * @return return code
16778 api_one_add_del_remote_mapping (vat_main_t * vam)
16780 unformat_input_t *input = vam->input;
16781 vl_api_one_add_del_remote_mapping_t *mp;
16783 lisp_eid_vat_t _eid, *eid = &_eid;
16784 lisp_eid_vat_t _seid, *seid = &_seid;
16785 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
16786 u32 action = ~0, p, w, data_len;
16787 ip4_address_t rloc4;
16788 ip6_address_t rloc6;
16789 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
16792 clib_memset (&rloc, 0, sizeof (rloc));
16794 /* Parse args required to build the message */
16795 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16797 if (unformat (input, "del-all"))
16801 else if (unformat (input, "del"))
16805 else if (unformat (input, "add"))
16809 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
16813 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
16817 else if (unformat (input, "vni %d", &vni))
16821 else if (unformat (input, "p %d w %d", &p, &w))
16825 errmsg ("No RLOC configured for setting priority/weight!");
16828 curr_rloc->priority = p;
16829 curr_rloc->weight = w;
16831 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
16834 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
16835 vec_add1 (rlocs, rloc);
16836 curr_rloc = &rlocs[vec_len (rlocs) - 1];
16838 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
16841 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
16842 vec_add1 (rlocs, rloc);
16843 curr_rloc = &rlocs[vec_len (rlocs) - 1];
16845 else if (unformat (input, "action %U",
16846 unformat_negative_mapping_action, &action))
16852 clib_warning ("parse error '%U'", format_unformat_error, input);
16859 errmsg ("missing params!");
16863 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
16865 errmsg ("no action set for negative map-reply!");
16869 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
16871 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
16872 mp->is_add = is_add;
16873 mp->vni = htonl (vni);
16874 mp->action = (u8) action;
16875 mp->is_src_dst = seid_set;
16876 mp->eid_len = eid->len;
16877 mp->seid_len = seid->len;
16878 mp->del_all = del_all;
16879 mp->eid_type = eid->type;
16880 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
16881 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
16883 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
16884 clib_memcpy (mp->rlocs, rlocs, data_len);
16890 /* Wait for a reply... */
16895 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
16898 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
16899 * forwarding entries in data-plane accordingly.
16901 * @param vam vpp API test context
16902 * @return return code
16905 api_one_add_del_adjacency (vat_main_t * vam)
16907 unformat_input_t *input = vam->input;
16908 vl_api_one_add_del_adjacency_t *mp;
16910 ip4_address_t leid4, reid4;
16911 ip6_address_t leid6, reid6;
16912 u8 reid_mac[6] = { 0 };
16913 u8 leid_mac[6] = { 0 };
16914 u8 reid_type, leid_type;
16915 u32 leid_len = 0, reid_len = 0, len;
16919 leid_type = reid_type = (u8) ~ 0;
16921 /* Parse args required to build the message */
16922 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16924 if (unformat (input, "del"))
16928 else if (unformat (input, "add"))
16932 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
16935 reid_type = 0; /* ipv4 */
16938 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
16941 reid_type = 1; /* ipv6 */
16944 else if (unformat (input, "reid %U", unformat_ethernet_address,
16947 reid_type = 2; /* mac */
16949 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
16952 leid_type = 0; /* ipv4 */
16955 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
16958 leid_type = 1; /* ipv6 */
16961 else if (unformat (input, "leid %U", unformat_ethernet_address,
16964 leid_type = 2; /* mac */
16966 else if (unformat (input, "vni %d", &vni))
16972 errmsg ("parse error '%U'", format_unformat_error, input);
16977 if ((u8) ~ 0 == reid_type)
16979 errmsg ("missing params!");
16983 if (leid_type != reid_type)
16985 errmsg ("remote and local EIDs are of different types!");
16989 M (ONE_ADD_DEL_ADJACENCY, mp);
16990 mp->is_add = is_add;
16991 mp->vni = htonl (vni);
16992 mp->leid_len = leid_len;
16993 mp->reid_len = reid_len;
16994 mp->eid_type = reid_type;
16996 switch (mp->eid_type)
16999 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
17000 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
17003 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
17004 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
17007 clib_memcpy (mp->leid, leid_mac, 6);
17008 clib_memcpy (mp->reid, reid_mac, 6);
17011 errmsg ("unknown EID type %d!", mp->eid_type);
17018 /* Wait for a reply... */
17023 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
17026 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
17028 u32 *mode = va_arg (*args, u32 *);
17030 if (unformat (input, "lisp"))
17032 else if (unformat (input, "vxlan"))
17041 api_gpe_get_encap_mode (vat_main_t * vam)
17043 vl_api_gpe_get_encap_mode_t *mp;
17046 /* Construct the API message */
17047 M (GPE_GET_ENCAP_MODE, mp);
17052 /* Wait for a reply... */
17058 api_gpe_set_encap_mode (vat_main_t * vam)
17060 unformat_input_t *input = vam->input;
17061 vl_api_gpe_set_encap_mode_t *mp;
17065 /* Parse args required to build the message */
17066 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17068 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
17074 /* Construct the API message */
17075 M (GPE_SET_ENCAP_MODE, mp);
17082 /* Wait for a reply... */
17088 api_lisp_gpe_add_del_iface (vat_main_t * vam)
17090 unformat_input_t *input = vam->input;
17091 vl_api_gpe_add_del_iface_t *mp;
17092 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
17093 u32 dp_table = 0, vni = 0;
17096 /* Parse args required to build the message */
17097 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17099 if (unformat (input, "up"))
17104 else if (unformat (input, "down"))
17109 else if (unformat (input, "table_id %d", &dp_table))
17113 else if (unformat (input, "bd_id %d", &dp_table))
17118 else if (unformat (input, "vni %d", &vni))
17126 if (action_set == 0)
17128 errmsg ("Action not set");
17131 if (dp_table_set == 0 || vni_set == 0)
17133 errmsg ("vni and dp_table must be set");
17137 /* Construct the API message */
17138 M (GPE_ADD_DEL_IFACE, mp);
17140 mp->is_add = is_add;
17141 mp->dp_table = clib_host_to_net_u32 (dp_table);
17143 mp->vni = clib_host_to_net_u32 (vni);
17148 /* Wait for a reply... */
17154 api_one_map_register_fallback_threshold (vat_main_t * vam)
17156 unformat_input_t *input = vam->input;
17157 vl_api_one_map_register_fallback_threshold_t *mp;
17162 /* Parse args required to build the message */
17163 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17165 if (unformat (input, "%u", &value))
17169 clib_warning ("parse error '%U'", format_unformat_error, input);
17176 errmsg ("fallback threshold value is missing!");
17180 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
17181 mp->value = clib_host_to_net_u32 (value);
17186 /* Wait for a reply... */
17192 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
17194 vl_api_show_one_map_register_fallback_threshold_t *mp;
17197 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
17202 /* Wait for a reply... */
17208 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
17210 u32 *proto = va_arg (*args, u32 *);
17212 if (unformat (input, "udp"))
17214 else if (unformat (input, "api"))
17223 api_one_set_transport_protocol (vat_main_t * vam)
17225 unformat_input_t *input = vam->input;
17226 vl_api_one_set_transport_protocol_t *mp;
17231 /* Parse args required to build the message */
17232 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17234 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
17238 clib_warning ("parse error '%U'", format_unformat_error, input);
17245 errmsg ("Transport protocol missing!");
17249 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
17250 mp->protocol = (u8) protocol;
17255 /* Wait for a reply... */
17261 api_one_get_transport_protocol (vat_main_t * vam)
17263 vl_api_one_get_transport_protocol_t *mp;
17266 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
17271 /* Wait for a reply... */
17277 api_one_map_register_set_ttl (vat_main_t * vam)
17279 unformat_input_t *input = vam->input;
17280 vl_api_one_map_register_set_ttl_t *mp;
17285 /* Parse args required to build the message */
17286 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17288 if (unformat (input, "%u", &ttl))
17292 clib_warning ("parse error '%U'", format_unformat_error, input);
17299 errmsg ("TTL value missing!");
17303 M (ONE_MAP_REGISTER_SET_TTL, mp);
17304 mp->ttl = clib_host_to_net_u32 (ttl);
17309 /* Wait for a reply... */
17315 api_show_one_map_register_ttl (vat_main_t * vam)
17317 vl_api_show_one_map_register_ttl_t *mp;
17320 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
17325 /* Wait for a reply... */
17331 * Add/del map request itr rlocs from ONE control plane and updates
17333 * @param vam vpp API test context
17334 * @return return code
17337 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
17339 unformat_input_t *input = vam->input;
17340 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
17341 u8 *locator_set_name = 0;
17342 u8 locator_set_name_set = 0;
17346 /* Parse args required to build the message */
17347 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17349 if (unformat (input, "del"))
17353 else if (unformat (input, "%_%v%_", &locator_set_name))
17355 locator_set_name_set = 1;
17359 clib_warning ("parse error '%U'", format_unformat_error, input);
17364 if (is_add && !locator_set_name_set)
17366 errmsg ("itr-rloc is not set!");
17370 if (is_add && vec_len (locator_set_name) > 64)
17372 errmsg ("itr-rloc locator-set name too long");
17373 vec_free (locator_set_name);
17377 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
17378 mp->is_add = is_add;
17381 clib_memcpy (mp->locator_set_name, locator_set_name,
17382 vec_len (locator_set_name));
17386 clib_memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
17388 vec_free (locator_set_name);
17393 /* Wait for a reply... */
17398 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
17401 api_one_locator_dump (vat_main_t * vam)
17403 unformat_input_t *input = vam->input;
17404 vl_api_one_locator_dump_t *mp;
17405 vl_api_control_ping_t *mp_ping;
17406 u8 is_index_set = 0, is_name_set = 0;
17411 /* Parse args required to build the message */
17412 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17414 if (unformat (input, "ls_name %_%v%_", &ls_name))
17418 else if (unformat (input, "ls_index %d", &ls_index))
17424 errmsg ("parse error '%U'", format_unformat_error, input);
17429 if (!is_index_set && !is_name_set)
17431 errmsg ("error: expected one of index or name!");
17435 if (is_index_set && is_name_set)
17437 errmsg ("error: only one param expected!");
17441 if (vec_len (ls_name) > 62)
17443 errmsg ("error: locator set name too long!");
17447 if (!vam->json_output)
17449 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
17452 M (ONE_LOCATOR_DUMP, mp);
17453 mp->is_index_set = is_index_set;
17456 mp->ls_index = clib_host_to_net_u32 (ls_index);
17459 vec_add1 (ls_name, 0);
17460 strncpy ((char *) mp->ls_name, (char *) ls_name,
17461 sizeof (mp->ls_name) - 1);
17467 /* Use a control ping for synchronization */
17468 MPING (CONTROL_PING, mp_ping);
17471 /* Wait for a reply... */
17476 #define api_lisp_locator_dump api_one_locator_dump
17479 api_one_locator_set_dump (vat_main_t * vam)
17481 vl_api_one_locator_set_dump_t *mp;
17482 vl_api_control_ping_t *mp_ping;
17483 unformat_input_t *input = vam->input;
17487 /* Parse args required to build the message */
17488 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17490 if (unformat (input, "local"))
17494 else if (unformat (input, "remote"))
17500 errmsg ("parse error '%U'", format_unformat_error, input);
17505 if (!vam->json_output)
17507 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
17510 M (ONE_LOCATOR_SET_DUMP, mp);
17512 mp->filter = filter;
17517 /* Use a control ping for synchronization */
17518 MPING (CONTROL_PING, mp_ping);
17521 /* Wait for a reply... */
17526 #define api_lisp_locator_set_dump api_one_locator_set_dump
17529 api_one_eid_table_map_dump (vat_main_t * vam)
17533 unformat_input_t *input = vam->input;
17534 vl_api_one_eid_table_map_dump_t *mp;
17535 vl_api_control_ping_t *mp_ping;
17538 /* Parse args required to build the message */
17539 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17541 if (unformat (input, "l2"))
17546 else if (unformat (input, "l3"))
17553 errmsg ("parse error '%U'", format_unformat_error, input);
17560 errmsg ("expected one of 'l2' or 'l3' parameter!");
17564 if (!vam->json_output)
17566 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
17569 M (ONE_EID_TABLE_MAP_DUMP, mp);
17575 /* Use a control ping for synchronization */
17576 MPING (CONTROL_PING, mp_ping);
17579 /* Wait for a reply... */
17584 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
17587 api_one_eid_table_vni_dump (vat_main_t * vam)
17589 vl_api_one_eid_table_vni_dump_t *mp;
17590 vl_api_control_ping_t *mp_ping;
17593 if (!vam->json_output)
17595 print (vam->ofp, "VNI");
17598 M (ONE_EID_TABLE_VNI_DUMP, mp);
17603 /* Use a control ping for synchronization */
17604 MPING (CONTROL_PING, mp_ping);
17607 /* Wait for a reply... */
17612 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
17615 api_one_eid_table_dump (vat_main_t * vam)
17617 unformat_input_t *i = vam->input;
17618 vl_api_one_eid_table_dump_t *mp;
17619 vl_api_control_ping_t *mp_ping;
17620 struct in_addr ip4;
17621 struct in6_addr ip6;
17623 u8 eid_type = ~0, eid_set = 0;
17624 u32 prefix_length = ~0, t, vni = 0;
17627 lisp_nsh_api_t nsh;
17629 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17631 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
17637 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
17643 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
17648 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
17653 else if (unformat (i, "vni %d", &t))
17657 else if (unformat (i, "local"))
17661 else if (unformat (i, "remote"))
17667 errmsg ("parse error '%U'", format_unformat_error, i);
17672 if (!vam->json_output)
17674 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
17675 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
17678 M (ONE_EID_TABLE_DUMP, mp);
17680 mp->filter = filter;
17684 mp->vni = htonl (vni);
17685 mp->eid_type = eid_type;
17689 mp->prefix_length = prefix_length;
17690 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
17693 mp->prefix_length = prefix_length;
17694 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
17697 clib_memcpy (mp->eid, mac, sizeof (mac));
17700 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
17703 errmsg ("unknown EID type %d!", eid_type);
17711 /* Use a control ping for synchronization */
17712 MPING (CONTROL_PING, mp_ping);
17715 /* Wait for a reply... */
17720 #define api_lisp_eid_table_dump api_one_eid_table_dump
17723 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
17725 unformat_input_t *i = vam->input;
17726 vl_api_gpe_fwd_entries_get_t *mp;
17731 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17733 if (unformat (i, "vni %d", &vni))
17739 errmsg ("parse error '%U'", format_unformat_error, i);
17746 errmsg ("vni not set!");
17750 if (!vam->json_output)
17752 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
17756 M (GPE_FWD_ENTRIES_GET, mp);
17757 mp->vni = clib_host_to_net_u32 (vni);
17762 /* Wait for a reply... */
17767 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
17768 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
17769 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
17770 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
17771 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
17772 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
17773 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
17774 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
17777 api_one_adjacencies_get (vat_main_t * vam)
17779 unformat_input_t *i = vam->input;
17780 vl_api_one_adjacencies_get_t *mp;
17785 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17787 if (unformat (i, "vni %d", &vni))
17793 errmsg ("parse error '%U'", format_unformat_error, i);
17800 errmsg ("vni not set!");
17804 if (!vam->json_output)
17806 print (vam->ofp, "%s %40s", "leid", "reid");
17809 M (ONE_ADJACENCIES_GET, mp);
17810 mp->vni = clib_host_to_net_u32 (vni);
17815 /* Wait for a reply... */
17820 #define api_lisp_adjacencies_get api_one_adjacencies_get
17823 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
17825 unformat_input_t *i = vam->input;
17826 vl_api_gpe_native_fwd_rpaths_get_t *mp;
17828 u8 ip_family_set = 0, is_ip4 = 1;
17830 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17832 if (unformat (i, "ip4"))
17837 else if (unformat (i, "ip6"))
17844 errmsg ("parse error '%U'", format_unformat_error, i);
17849 if (!ip_family_set)
17851 errmsg ("ip family not set!");
17855 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
17856 mp->is_ip4 = is_ip4;
17861 /* Wait for a reply... */
17867 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
17869 vl_api_gpe_fwd_entry_vnis_get_t *mp;
17872 if (!vam->json_output)
17874 print (vam->ofp, "VNIs");
17877 M (GPE_FWD_ENTRY_VNIS_GET, mp);
17882 /* Wait for a reply... */
17888 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
17890 unformat_input_t *i = vam->input;
17891 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
17893 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
17894 struct in_addr ip4;
17895 struct in6_addr ip6;
17896 u32 table_id = 0, nh_sw_if_index = ~0;
17898 clib_memset (&ip4, 0, sizeof (ip4));
17899 clib_memset (&ip6, 0, sizeof (ip6));
17901 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17903 if (unformat (i, "del"))
17905 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
17906 api_unformat_sw_if_index, vam, &nh_sw_if_index))
17911 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
17912 api_unformat_sw_if_index, vam, &nh_sw_if_index))
17917 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
17921 nh_sw_if_index = ~0;
17923 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
17927 nh_sw_if_index = ~0;
17929 else if (unformat (i, "table %d", &table_id))
17933 errmsg ("parse error '%U'", format_unformat_error, i);
17940 errmsg ("nh addr not set!");
17944 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
17945 mp->is_add = is_add;
17946 mp->table_id = clib_host_to_net_u32 (table_id);
17947 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
17948 mp->is_ip4 = is_ip4;
17950 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
17952 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
17957 /* Wait for a reply... */
17963 api_one_map_server_dump (vat_main_t * vam)
17965 vl_api_one_map_server_dump_t *mp;
17966 vl_api_control_ping_t *mp_ping;
17969 if (!vam->json_output)
17971 print (vam->ofp, "%=20s", "Map server");
17974 M (ONE_MAP_SERVER_DUMP, mp);
17978 /* Use a control ping for synchronization */
17979 MPING (CONTROL_PING, mp_ping);
17982 /* Wait for a reply... */
17987 #define api_lisp_map_server_dump api_one_map_server_dump
17990 api_one_map_resolver_dump (vat_main_t * vam)
17992 vl_api_one_map_resolver_dump_t *mp;
17993 vl_api_control_ping_t *mp_ping;
17996 if (!vam->json_output)
17998 print (vam->ofp, "%=20s", "Map resolver");
18001 M (ONE_MAP_RESOLVER_DUMP, mp);
18005 /* Use a control ping for synchronization */
18006 MPING (CONTROL_PING, mp_ping);
18009 /* Wait for a reply... */
18014 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
18017 api_one_stats_flush (vat_main_t * vam)
18019 vl_api_one_stats_flush_t *mp;
18022 M (ONE_STATS_FLUSH, mp);
18029 api_one_stats_dump (vat_main_t * vam)
18031 vl_api_one_stats_dump_t *mp;
18032 vl_api_control_ping_t *mp_ping;
18035 M (ONE_STATS_DUMP, mp);
18039 /* Use a control ping for synchronization */
18040 MPING (CONTROL_PING, mp_ping);
18043 /* Wait for a reply... */
18049 api_show_one_status (vat_main_t * vam)
18051 vl_api_show_one_status_t *mp;
18054 if (!vam->json_output)
18056 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
18059 M (SHOW_ONE_STATUS, mp);
18062 /* Wait for a reply... */
18067 #define api_show_lisp_status api_show_one_status
18070 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
18072 vl_api_gpe_fwd_entry_path_dump_t *mp;
18073 vl_api_control_ping_t *mp_ping;
18074 unformat_input_t *i = vam->input;
18075 u32 fwd_entry_index = ~0;
18078 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18080 if (unformat (i, "index %d", &fwd_entry_index))
18086 if (~0 == fwd_entry_index)
18088 errmsg ("no index specified!");
18092 if (!vam->json_output)
18094 print (vam->ofp, "first line");
18097 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
18101 /* Use a control ping for synchronization */
18102 MPING (CONTROL_PING, mp_ping);
18105 /* Wait for a reply... */
18111 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
18113 vl_api_one_get_map_request_itr_rlocs_t *mp;
18116 if (!vam->json_output)
18118 print (vam->ofp, "%=20s", "itr-rlocs:");
18121 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
18124 /* Wait for a reply... */
18129 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
18132 api_af_packet_create (vat_main_t * vam)
18134 unformat_input_t *i = vam->input;
18135 vl_api_af_packet_create_t *mp;
18136 u8 *host_if_name = 0;
18138 u8 random_hw_addr = 1;
18141 clib_memset (hw_addr, 0, sizeof (hw_addr));
18143 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18145 if (unformat (i, "name %s", &host_if_name))
18146 vec_add1 (host_if_name, 0);
18147 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
18148 random_hw_addr = 0;
18153 if (!vec_len (host_if_name))
18155 errmsg ("host-interface name must be specified");
18159 if (vec_len (host_if_name) > 64)
18161 errmsg ("host-interface name too long");
18165 M (AF_PACKET_CREATE, mp);
18167 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
18168 clib_memcpy (mp->hw_addr, hw_addr, 6);
18169 mp->use_random_hw_addr = random_hw_addr;
18170 vec_free (host_if_name);
18178 fprintf (vam->ofp ? vam->ofp : stderr,
18179 " new sw_if_index = %d\n", vam->sw_if_index);
18186 api_af_packet_delete (vat_main_t * vam)
18188 unformat_input_t *i = vam->input;
18189 vl_api_af_packet_delete_t *mp;
18190 u8 *host_if_name = 0;
18193 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18195 if (unformat (i, "name %s", &host_if_name))
18196 vec_add1 (host_if_name, 0);
18201 if (!vec_len (host_if_name))
18203 errmsg ("host-interface name must be specified");
18207 if (vec_len (host_if_name) > 64)
18209 errmsg ("host-interface name too long");
18213 M (AF_PACKET_DELETE, mp);
18215 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
18216 vec_free (host_if_name);
18223 static void vl_api_af_packet_details_t_handler
18224 (vl_api_af_packet_details_t * mp)
18226 vat_main_t *vam = &vat_main;
18228 print (vam->ofp, "%-16s %d",
18229 mp->host_if_name, clib_net_to_host_u32 (mp->sw_if_index));
18232 static void vl_api_af_packet_details_t_handler_json
18233 (vl_api_af_packet_details_t * mp)
18235 vat_main_t *vam = &vat_main;
18236 vat_json_node_t *node = NULL;
18238 if (VAT_JSON_ARRAY != vam->json_tree.type)
18240 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18241 vat_json_init_array (&vam->json_tree);
18243 node = vat_json_array_add (&vam->json_tree);
18245 vat_json_init_object (node);
18246 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
18247 vat_json_object_add_string_copy (node, "dev_name", mp->host_if_name);
18251 api_af_packet_dump (vat_main_t * vam)
18253 vl_api_af_packet_dump_t *mp;
18254 vl_api_control_ping_t *mp_ping;
18257 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
18258 /* Get list of tap interfaces */
18259 M (AF_PACKET_DUMP, mp);
18262 /* Use a control ping for synchronization */
18263 MPING (CONTROL_PING, mp_ping);
18271 api_policer_add_del (vat_main_t * vam)
18273 unformat_input_t *i = vam->input;
18274 vl_api_policer_add_del_t *mp;
18284 u8 color_aware = 0;
18285 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
18288 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
18289 conform_action.dscp = 0;
18290 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
18291 exceed_action.dscp = 0;
18292 violate_action.action_type = SSE2_QOS_ACTION_DROP;
18293 violate_action.dscp = 0;
18295 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18297 if (unformat (i, "del"))
18299 else if (unformat (i, "name %s", &name))
18300 vec_add1 (name, 0);
18301 else if (unformat (i, "cir %u", &cir))
18303 else if (unformat (i, "eir %u", &eir))
18305 else if (unformat (i, "cb %u", &cb))
18307 else if (unformat (i, "eb %u", &eb))
18309 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
18312 else if (unformat (i, "round_type %U", unformat_policer_round_type,
18315 else if (unformat (i, "type %U", unformat_policer_type, &type))
18317 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
18320 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
18323 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
18326 else if (unformat (i, "color-aware"))
18332 if (!vec_len (name))
18334 errmsg ("policer name must be specified");
18338 if (vec_len (name) > 64)
18340 errmsg ("policer name too long");
18344 M (POLICER_ADD_DEL, mp);
18346 clib_memcpy (mp->name, name, vec_len (name));
18348 mp->is_add = is_add;
18349 mp->cir = ntohl (cir);
18350 mp->eir = ntohl (eir);
18351 mp->cb = clib_net_to_host_u64 (cb);
18352 mp->eb = clib_net_to_host_u64 (eb);
18353 mp->rate_type = rate_type;
18354 mp->round_type = round_type;
18356 mp->conform_action_type = conform_action.action_type;
18357 mp->conform_dscp = conform_action.dscp;
18358 mp->exceed_action_type = exceed_action.action_type;
18359 mp->exceed_dscp = exceed_action.dscp;
18360 mp->violate_action_type = violate_action.action_type;
18361 mp->violate_dscp = violate_action.dscp;
18362 mp->color_aware = color_aware;
18370 api_policer_dump (vat_main_t * vam)
18372 unformat_input_t *i = vam->input;
18373 vl_api_policer_dump_t *mp;
18374 vl_api_control_ping_t *mp_ping;
18375 u8 *match_name = 0;
18376 u8 match_name_valid = 0;
18379 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18381 if (unformat (i, "name %s", &match_name))
18383 vec_add1 (match_name, 0);
18384 match_name_valid = 1;
18390 M (POLICER_DUMP, mp);
18391 mp->match_name_valid = match_name_valid;
18392 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
18393 vec_free (match_name);
18397 /* Use a control ping for synchronization */
18398 MPING (CONTROL_PING, mp_ping);
18401 /* Wait for a reply... */
18407 api_policer_classify_set_interface (vat_main_t * vam)
18409 unformat_input_t *i = vam->input;
18410 vl_api_policer_classify_set_interface_t *mp;
18412 int sw_if_index_set;
18413 u32 ip4_table_index = ~0;
18414 u32 ip6_table_index = ~0;
18415 u32 l2_table_index = ~0;
18419 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18421 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18422 sw_if_index_set = 1;
18423 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18424 sw_if_index_set = 1;
18425 else if (unformat (i, "del"))
18427 else if (unformat (i, "ip4-table %d", &ip4_table_index))
18429 else if (unformat (i, "ip6-table %d", &ip6_table_index))
18431 else if (unformat (i, "l2-table %d", &l2_table_index))
18435 clib_warning ("parse error '%U'", format_unformat_error, i);
18440 if (sw_if_index_set == 0)
18442 errmsg ("missing interface name or sw_if_index");
18446 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
18448 mp->sw_if_index = ntohl (sw_if_index);
18449 mp->ip4_table_index = ntohl (ip4_table_index);
18450 mp->ip6_table_index = ntohl (ip6_table_index);
18451 mp->l2_table_index = ntohl (l2_table_index);
18452 mp->is_add = is_add;
18460 api_policer_classify_dump (vat_main_t * vam)
18462 unformat_input_t *i = vam->input;
18463 vl_api_policer_classify_dump_t *mp;
18464 vl_api_control_ping_t *mp_ping;
18465 u8 type = POLICER_CLASSIFY_N_TABLES;
18468 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
18472 errmsg ("classify table type must be specified");
18476 if (!vam->json_output)
18478 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
18481 M (POLICER_CLASSIFY_DUMP, mp);
18486 /* Use a control ping for synchronization */
18487 MPING (CONTROL_PING, mp_ping);
18490 /* Wait for a reply... */
18496 api_netmap_create (vat_main_t * vam)
18498 unformat_input_t *i = vam->input;
18499 vl_api_netmap_create_t *mp;
18502 u8 random_hw_addr = 1;
18507 clib_memset (hw_addr, 0, sizeof (hw_addr));
18509 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18511 if (unformat (i, "name %s", &if_name))
18512 vec_add1 (if_name, 0);
18513 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
18514 random_hw_addr = 0;
18515 else if (unformat (i, "pipe"))
18517 else if (unformat (i, "master"))
18519 else if (unformat (i, "slave"))
18525 if (!vec_len (if_name))
18527 errmsg ("interface name must be specified");
18531 if (vec_len (if_name) > 64)
18533 errmsg ("interface name too long");
18537 M (NETMAP_CREATE, mp);
18539 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
18540 clib_memcpy (mp->hw_addr, hw_addr, 6);
18541 mp->use_random_hw_addr = random_hw_addr;
18542 mp->is_pipe = is_pipe;
18543 mp->is_master = is_master;
18544 vec_free (if_name);
18552 api_netmap_delete (vat_main_t * vam)
18554 unformat_input_t *i = vam->input;
18555 vl_api_netmap_delete_t *mp;
18559 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18561 if (unformat (i, "name %s", &if_name))
18562 vec_add1 (if_name, 0);
18567 if (!vec_len (if_name))
18569 errmsg ("interface name must be specified");
18573 if (vec_len (if_name) > 64)
18575 errmsg ("interface name too long");
18579 M (NETMAP_DELETE, mp);
18581 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
18582 vec_free (if_name);
18590 format_fib_api_path_nh_proto (u8 * s, va_list * args)
18592 vl_api_fib_path_nh_proto_t proto =
18593 va_arg (*args, vl_api_fib_path_nh_proto_t);
18597 case FIB_API_PATH_NH_PROTO_IP4:
18598 s = format (s, "ip4");
18600 case FIB_API_PATH_NH_PROTO_IP6:
18601 s = format (s, "ip6");
18603 case FIB_API_PATH_NH_PROTO_MPLS:
18604 s = format (s, "mpls");
18606 case FIB_API_PATH_NH_PROTO_BIER:
18607 s = format (s, "bier");
18609 case FIB_API_PATH_NH_PROTO_ETHERNET:
18610 s = format (s, "ethernet");
18618 format_vl_api_ip_address_union (u8 * s, va_list * args)
18620 vl_api_address_family_t af = va_arg (*args, vl_api_address_family_t);
18621 const vl_api_address_union_t *u = va_arg (*args, vl_api_address_union_t *);
18626 s = format (s, "%U", format_ip4_address, u->ip4);
18629 s = format (s, "%U", format_ip6_address, u->ip6);
18636 format_vl_api_fib_path_type (u8 * s, va_list * args)
18638 vl_api_fib_path_type_t t = va_arg (*args, vl_api_fib_path_type_t);
18642 case FIB_API_PATH_TYPE_NORMAL:
18643 s = format (s, "normal");
18645 case FIB_API_PATH_TYPE_LOCAL:
18646 s = format (s, "local");
18648 case FIB_API_PATH_TYPE_DROP:
18649 s = format (s, "drop");
18651 case FIB_API_PATH_TYPE_UDP_ENCAP:
18652 s = format (s, "udp-encap");
18654 case FIB_API_PATH_TYPE_BIER_IMP:
18655 s = format (s, "bier-imp");
18657 case FIB_API_PATH_TYPE_ICMP_UNREACH:
18658 s = format (s, "unreach");
18660 case FIB_API_PATH_TYPE_ICMP_PROHIBIT:
18661 s = format (s, "prohibit");
18663 case FIB_API_PATH_TYPE_SOURCE_LOOKUP:
18664 s = format (s, "src-lookup");
18666 case FIB_API_PATH_TYPE_DVR:
18667 s = format (s, "dvr");
18669 case FIB_API_PATH_TYPE_INTERFACE_RX:
18670 s = format (s, "interface-rx");
18672 case FIB_API_PATH_TYPE_CLASSIFY:
18673 s = format (s, "classify");
18681 vl_api_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
18684 " weight %d, sw_if_index %d, type %U, afi %U, next_hop %U",
18685 ntohl (fp->weight), ntohl (fp->sw_if_index),
18686 format_vl_api_fib_path_type, fp->type,
18687 format_fib_api_path_nh_proto, fp->proto,
18688 format_vl_api_ip_address_union, &fp->nh.address);
18692 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
18693 vl_api_fib_path_t * fp)
18695 struct in_addr ip4;
18696 struct in6_addr ip6;
18698 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
18699 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
18700 vat_json_object_add_uint (node, "type", fp->type);
18701 vat_json_object_add_uint (node, "next_hop_proto", fp->proto);
18702 if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
18704 clib_memcpy (&ip4, &fp->nh.address.ip4, sizeof (ip4));
18705 vat_json_object_add_ip4 (node, "next_hop", ip4);
18707 else if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
18709 clib_memcpy (&ip6, &fp->nh.address.ip6, sizeof (ip6));
18710 vat_json_object_add_ip6 (node, "next_hop", ip6);
18715 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
18717 vat_main_t *vam = &vat_main;
18718 int count = ntohl (mp->mt_tunnel.mt_n_paths);
18719 vl_api_fib_path_t *fp;
18722 print (vam->ofp, "sw_if_index %d via:",
18723 ntohl (mp->mt_tunnel.mt_sw_if_index));
18724 fp = mp->mt_tunnel.mt_paths;
18725 for (i = 0; i < count; i++)
18727 vl_api_fib_path_print (vam, fp);
18731 print (vam->ofp, "");
18734 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
18735 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
18738 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
18740 vat_main_t *vam = &vat_main;
18741 vat_json_node_t *node = NULL;
18742 int count = ntohl (mp->mt_tunnel.mt_n_paths);
18743 vl_api_fib_path_t *fp;
18746 if (VAT_JSON_ARRAY != vam->json_tree.type)
18748 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18749 vat_json_init_array (&vam->json_tree);
18751 node = vat_json_array_add (&vam->json_tree);
18753 vat_json_init_object (node);
18754 vat_json_object_add_uint (node, "sw_if_index",
18755 ntohl (mp->mt_tunnel.mt_sw_if_index));
18757 vat_json_object_add_uint (node, "l2_only", mp->mt_tunnel.mt_l2_only);
18759 fp = mp->mt_tunnel.mt_paths;
18760 for (i = 0; i < count; i++)
18762 vl_api_mpls_fib_path_json_print (node, fp);
18768 api_mpls_tunnel_dump (vat_main_t * vam)
18770 vl_api_mpls_tunnel_dump_t *mp;
18771 vl_api_control_ping_t *mp_ping;
18774 M (MPLS_TUNNEL_DUMP, mp);
18778 /* Use a control ping for synchronization */
18779 MPING (CONTROL_PING, mp_ping);
18786 #define vl_api_mpls_table_details_t_endian vl_noop_handler
18787 #define vl_api_mpls_table_details_t_print vl_noop_handler
18791 vl_api_mpls_table_details_t_handler (vl_api_mpls_table_details_t * mp)
18793 vat_main_t *vam = &vat_main;
18795 print (vam->ofp, "table-id %d,", ntohl (mp->mt_table.mt_table_id));
18798 static void vl_api_mpls_table_details_t_handler_json
18799 (vl_api_mpls_table_details_t * mp)
18801 vat_main_t *vam = &vat_main;
18802 vat_json_node_t *node = NULL;
18804 if (VAT_JSON_ARRAY != vam->json_tree.type)
18806 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18807 vat_json_init_array (&vam->json_tree);
18809 node = vat_json_array_add (&vam->json_tree);
18811 vat_json_init_object (node);
18812 vat_json_object_add_uint (node, "table", ntohl (mp->mt_table.mt_table_id));
18816 api_mpls_table_dump (vat_main_t * vam)
18818 vl_api_mpls_table_dump_t *mp;
18819 vl_api_control_ping_t *mp_ping;
18822 M (MPLS_TABLE_DUMP, mp);
18825 /* Use a control ping for synchronization */
18826 MPING (CONTROL_PING, mp_ping);
18833 #define vl_api_mpls_route_details_t_endian vl_noop_handler
18834 #define vl_api_mpls_route_details_t_print vl_noop_handler
18837 vl_api_mpls_route_details_t_handler (vl_api_mpls_route_details_t * mp)
18839 vat_main_t *vam = &vat_main;
18840 int count = (int) clib_net_to_host_u32 (mp->mr_route.mr_n_paths);
18841 vl_api_fib_path_t *fp;
18845 "table-id %d, label %u, ess_bit %u",
18846 ntohl (mp->mr_route.mr_table_id),
18847 ntohl (mp->mr_route.mr_label), mp->mr_route.mr_eos);
18848 fp = mp->mr_route.mr_paths;
18849 for (i = 0; i < count; i++)
18851 vl_api_fib_path_print (vam, fp);
18856 static void vl_api_mpls_route_details_t_handler_json
18857 (vl_api_mpls_route_details_t * mp)
18859 vat_main_t *vam = &vat_main;
18860 int count = (int) clib_host_to_net_u32 (mp->mr_route.mr_n_paths);
18861 vat_json_node_t *node = NULL;
18862 vl_api_fib_path_t *fp;
18865 if (VAT_JSON_ARRAY != vam->json_tree.type)
18867 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18868 vat_json_init_array (&vam->json_tree);
18870 node = vat_json_array_add (&vam->json_tree);
18872 vat_json_init_object (node);
18873 vat_json_object_add_uint (node, "table", ntohl (mp->mr_route.mr_table_id));
18874 vat_json_object_add_uint (node, "s_bit", mp->mr_route.mr_eos);
18875 vat_json_object_add_uint (node, "label", ntohl (mp->mr_route.mr_label));
18876 vat_json_object_add_uint (node, "path_count", count);
18877 fp = mp->mr_route.mr_paths;
18878 for (i = 0; i < count; i++)
18880 vl_api_mpls_fib_path_json_print (node, fp);
18886 api_mpls_route_dump (vat_main_t * vam)
18888 unformat_input_t *input = vam->input;
18889 vl_api_mpls_route_dump_t *mp;
18890 vl_api_control_ping_t *mp_ping;
18894 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18896 if (unformat (input, "table_id %d", &table_id))
18901 if (table_id == ~0)
18903 errmsg ("missing table id");
18907 M (MPLS_ROUTE_DUMP, mp);
18909 mp->table.mt_table_id = ntohl (table_id);
18912 /* Use a control ping for synchronization */
18913 MPING (CONTROL_PING, mp_ping);
18920 #define vl_api_ip_table_details_t_endian vl_noop_handler
18921 #define vl_api_ip_table_details_t_print vl_noop_handler
18924 vl_api_ip_table_details_t_handler (vl_api_ip_table_details_t * mp)
18926 vat_main_t *vam = &vat_main;
18929 "%s; table-id %d, prefix %U/%d",
18930 mp->table.name, ntohl (mp->table.table_id));
18934 static void vl_api_ip_table_details_t_handler_json
18935 (vl_api_ip_table_details_t * mp)
18937 vat_main_t *vam = &vat_main;
18938 vat_json_node_t *node = NULL;
18940 if (VAT_JSON_ARRAY != vam->json_tree.type)
18942 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18943 vat_json_init_array (&vam->json_tree);
18945 node = vat_json_array_add (&vam->json_tree);
18947 vat_json_init_object (node);
18948 vat_json_object_add_uint (node, "table", ntohl (mp->table.table_id));
18952 api_ip_table_dump (vat_main_t * vam)
18954 vl_api_ip_table_dump_t *mp;
18955 vl_api_control_ping_t *mp_ping;
18958 M (IP_TABLE_DUMP, mp);
18961 /* Use a control ping for synchronization */
18962 MPING (CONTROL_PING, mp_ping);
18970 api_ip_mtable_dump (vat_main_t * vam)
18972 vl_api_ip_mtable_dump_t *mp;
18973 vl_api_control_ping_t *mp_ping;
18976 M (IP_MTABLE_DUMP, mp);
18979 /* Use a control ping for synchronization */
18980 MPING (CONTROL_PING, mp_ping);
18988 api_ip_mroute_dump (vat_main_t * vam)
18990 unformat_input_t *input = vam->input;
18991 vl_api_control_ping_t *mp_ping;
18992 vl_api_ip_mroute_dump_t *mp;
18997 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18999 if (unformat (input, "table_id %d", &table_id))
19001 else if (unformat (input, "ip6"))
19003 else if (unformat (input, "ip4"))
19008 if (table_id == ~0)
19010 errmsg ("missing table id");
19014 M (IP_MROUTE_DUMP, mp);
19015 mp->table.table_id = table_id;
19016 mp->table.is_ip6 = is_ip6;
19019 /* Use a control ping for synchronization */
19020 MPING (CONTROL_PING, mp_ping);
19027 static void vl_api_ip_neighbor_details_t_handler
19028 (vl_api_ip_neighbor_details_t * mp)
19030 vat_main_t *vam = &vat_main;
19032 print (vam->ofp, "%c %U %U",
19033 (ntohl (mp->neighbor.flags) & IP_NEIGHBOR_FLAG_STATIC) ? 'S' : 'D',
19034 format_vl_api_mac_address, &mp->neighbor.mac_address,
19035 format_vl_api_address, &mp->neighbor.ip_address);
19038 static void vl_api_ip_neighbor_details_t_handler_json
19039 (vl_api_ip_neighbor_details_t * mp)
19042 vat_main_t *vam = &vat_main;
19043 vat_json_node_t *node;
19045 if (VAT_JSON_ARRAY != vam->json_tree.type)
19047 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19048 vat_json_init_array (&vam->json_tree);
19050 node = vat_json_array_add (&vam->json_tree);
19052 vat_json_init_object (node);
19053 vat_json_object_add_string_copy
19055 ((ntohl (mp->neighbor.flags) & IP_NEIGHBOR_FLAG_STATIC) ?
19056 (u8 *) "static" : (u8 *) "dynamic"));
19058 vat_json_object_add_string_copy (node, "link_layer",
19059 format (0, "%U", format_vl_api_mac_address,
19060 &mp->neighbor.mac_address));
19061 vat_json_object_add_address (node, "ip", &mp->neighbor.ip_address);
19065 api_ip_neighbor_dump (vat_main_t * vam)
19067 unformat_input_t *i = vam->input;
19068 vl_api_ip_neighbor_dump_t *mp;
19069 vl_api_control_ping_t *mp_ping;
19071 u32 sw_if_index = ~0;
19074 /* Parse args required to build the message */
19075 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19077 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19079 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19081 else if (unformat (i, "ip6"))
19087 if (sw_if_index == ~0)
19089 errmsg ("missing interface name or sw_if_index");
19093 M (IP_NEIGHBOR_DUMP, mp);
19094 mp->is_ipv6 = (u8) is_ipv6;
19095 mp->sw_if_index = ntohl (sw_if_index);
19098 /* Use a control ping for synchronization */
19099 MPING (CONTROL_PING, mp_ping);
19106 #define vl_api_ip_route_details_t_endian vl_noop_handler
19107 #define vl_api_ip_route_details_t_print vl_noop_handler
19110 vl_api_ip_route_details_t_handler (vl_api_ip_route_details_t * mp)
19112 vat_main_t *vam = &vat_main;
19113 u8 count = mp->route.n_paths;
19114 vl_api_fib_path_t *fp;
19118 "table-id %d, prefix %U/%d",
19119 ntohl (mp->route.table_id),
19120 format_ip46_address, mp->route.prefix.address, mp->route.prefix.len);
19121 for (i = 0; i < count; i++)
19123 fp = &mp->route.paths[i];
19125 vl_api_fib_path_print (vam, fp);
19130 static void vl_api_ip_route_details_t_handler_json
19131 (vl_api_ip_route_details_t * mp)
19133 vat_main_t *vam = &vat_main;
19134 u8 count = mp->route.n_paths;
19135 vat_json_node_t *node = NULL;
19136 struct in_addr ip4;
19137 struct in6_addr ip6;
19138 vl_api_fib_path_t *fp;
19141 if (VAT_JSON_ARRAY != vam->json_tree.type)
19143 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19144 vat_json_init_array (&vam->json_tree);
19146 node = vat_json_array_add (&vam->json_tree);
19148 vat_json_init_object (node);
19149 vat_json_object_add_uint (node, "table", ntohl (mp->route.table_id));
19150 if (ADDRESS_IP6 == mp->route.prefix.address.af)
19152 clib_memcpy (&ip6, &mp->route.prefix.address.un.ip6, sizeof (ip6));
19153 vat_json_object_add_ip6 (node, "prefix", ip6);
19157 clib_memcpy (&ip4, &mp->route.prefix.address.un.ip4, sizeof (ip4));
19158 vat_json_object_add_ip4 (node, "prefix", ip4);
19160 vat_json_object_add_uint (node, "mask_length", mp->route.prefix.len);
19161 vat_json_object_add_uint (node, "path_count", count);
19162 for (i = 0; i < count; i++)
19164 fp = &mp->route.paths[i];
19165 vl_api_mpls_fib_path_json_print (node, fp);
19170 api_ip_route_dump (vat_main_t * vam)
19172 unformat_input_t *input = vam->input;
19173 vl_api_ip_route_dump_t *mp;
19174 vl_api_control_ping_t *mp_ping;
19180 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19182 if (unformat (input, "table_id %d", &table_id))
19184 else if (unformat (input, "ip6"))
19186 else if (unformat (input, "ip4"))
19191 if (table_id == ~0)
19193 errmsg ("missing table id");
19197 M (IP_ROUTE_DUMP, mp);
19199 mp->table.table_id = table_id;
19200 mp->table.is_ip6 = is_ip6;
19204 /* Use a control ping for synchronization */
19205 MPING (CONTROL_PING, mp_ping);
19213 api_classify_table_ids (vat_main_t * vam)
19215 vl_api_classify_table_ids_t *mp;
19218 /* Construct the API message */
19219 M (CLASSIFY_TABLE_IDS, mp);
19228 api_classify_table_by_interface (vat_main_t * vam)
19230 unformat_input_t *input = vam->input;
19231 vl_api_classify_table_by_interface_t *mp;
19233 u32 sw_if_index = ~0;
19235 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19237 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19239 else if (unformat (input, "sw_if_index %d", &sw_if_index))
19244 if (sw_if_index == ~0)
19246 errmsg ("missing interface name or sw_if_index");
19250 /* Construct the API message */
19251 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
19253 mp->sw_if_index = ntohl (sw_if_index);
19261 api_classify_table_info (vat_main_t * vam)
19263 unformat_input_t *input = vam->input;
19264 vl_api_classify_table_info_t *mp;
19268 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19270 if (unformat (input, "table_id %d", &table_id))
19275 if (table_id == ~0)
19277 errmsg ("missing table id");
19281 /* Construct the API message */
19282 M (CLASSIFY_TABLE_INFO, mp);
19284 mp->table_id = ntohl (table_id);
19292 api_classify_session_dump (vat_main_t * vam)
19294 unformat_input_t *input = vam->input;
19295 vl_api_classify_session_dump_t *mp;
19296 vl_api_control_ping_t *mp_ping;
19300 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19302 if (unformat (input, "table_id %d", &table_id))
19307 if (table_id == ~0)
19309 errmsg ("missing table id");
19313 /* Construct the API message */
19314 M (CLASSIFY_SESSION_DUMP, mp);
19316 mp->table_id = ntohl (table_id);
19319 /* Use a control ping for synchronization */
19320 MPING (CONTROL_PING, mp_ping);
19328 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
19330 vat_main_t *vam = &vat_main;
19332 print (vam->ofp, "collector_address %U, collector_port %d, "
19333 "src_address %U, vrf_id %d, path_mtu %u, "
19334 "template_interval %u, udp_checksum %d",
19335 format_ip4_address, mp->collector_address,
19336 ntohs (mp->collector_port),
19337 format_ip4_address, mp->src_address,
19338 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
19339 ntohl (mp->template_interval), mp->udp_checksum);
19342 vam->result_ready = 1;
19346 vl_api_ipfix_exporter_details_t_handler_json
19347 (vl_api_ipfix_exporter_details_t * mp)
19349 vat_main_t *vam = &vat_main;
19350 vat_json_node_t node;
19351 struct in_addr collector_address;
19352 struct in_addr src_address;
19354 vat_json_init_object (&node);
19355 clib_memcpy (&collector_address, &mp->collector_address,
19356 sizeof (collector_address));
19357 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
19358 vat_json_object_add_uint (&node, "collector_port",
19359 ntohs (mp->collector_port));
19360 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
19361 vat_json_object_add_ip4 (&node, "src_address", src_address);
19362 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
19363 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
19364 vat_json_object_add_uint (&node, "template_interval",
19365 ntohl (mp->template_interval));
19366 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
19368 vat_json_print (vam->ofp, &node);
19369 vat_json_free (&node);
19371 vam->result_ready = 1;
19375 api_ipfix_exporter_dump (vat_main_t * vam)
19377 vl_api_ipfix_exporter_dump_t *mp;
19380 /* Construct the API message */
19381 M (IPFIX_EXPORTER_DUMP, mp);
19390 api_ipfix_classify_stream_dump (vat_main_t * vam)
19392 vl_api_ipfix_classify_stream_dump_t *mp;
19395 /* Construct the API message */
19396 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
19407 vl_api_ipfix_classify_stream_details_t_handler
19408 (vl_api_ipfix_classify_stream_details_t * mp)
19410 vat_main_t *vam = &vat_main;
19411 print (vam->ofp, "domain_id %d, src_port %d",
19412 ntohl (mp->domain_id), ntohs (mp->src_port));
19414 vam->result_ready = 1;
19418 vl_api_ipfix_classify_stream_details_t_handler_json
19419 (vl_api_ipfix_classify_stream_details_t * mp)
19421 vat_main_t *vam = &vat_main;
19422 vat_json_node_t node;
19424 vat_json_init_object (&node);
19425 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
19426 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
19428 vat_json_print (vam->ofp, &node);
19429 vat_json_free (&node);
19431 vam->result_ready = 1;
19435 api_ipfix_classify_table_dump (vat_main_t * vam)
19437 vl_api_ipfix_classify_table_dump_t *mp;
19438 vl_api_control_ping_t *mp_ping;
19441 if (!vam->json_output)
19443 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
19444 "transport_protocol");
19447 /* Construct the API message */
19448 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
19453 /* Use a control ping for synchronization */
19454 MPING (CONTROL_PING, mp_ping);
19462 vl_api_ipfix_classify_table_details_t_handler
19463 (vl_api_ipfix_classify_table_details_t * mp)
19465 vat_main_t *vam = &vat_main;
19466 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
19467 mp->transport_protocol);
19471 vl_api_ipfix_classify_table_details_t_handler_json
19472 (vl_api_ipfix_classify_table_details_t * mp)
19474 vat_json_node_t *node = NULL;
19475 vat_main_t *vam = &vat_main;
19477 if (VAT_JSON_ARRAY != vam->json_tree.type)
19479 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19480 vat_json_init_array (&vam->json_tree);
19483 node = vat_json_array_add (&vam->json_tree);
19484 vat_json_init_object (node);
19486 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
19487 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
19488 vat_json_object_add_uint (node, "transport_protocol",
19489 mp->transport_protocol);
19493 api_sw_interface_span_enable_disable (vat_main_t * vam)
19495 unformat_input_t *i = vam->input;
19496 vl_api_sw_interface_span_enable_disable_t *mp;
19497 u32 src_sw_if_index = ~0;
19498 u32 dst_sw_if_index = ~0;
19503 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19506 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
19508 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
19512 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
19514 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
19516 else if (unformat (i, "disable"))
19518 else if (unformat (i, "rx"))
19520 else if (unformat (i, "tx"))
19522 else if (unformat (i, "both"))
19524 else if (unformat (i, "l2"))
19530 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
19532 mp->sw_if_index_from = htonl (src_sw_if_index);
19533 mp->sw_if_index_to = htonl (dst_sw_if_index);
19543 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
19546 vat_main_t *vam = &vat_main;
19547 u8 *sw_if_from_name = 0;
19548 u8 *sw_if_to_name = 0;
19549 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
19550 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
19551 char *states[] = { "none", "rx", "tx", "both" };
19555 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
19557 if ((u32) p->value[0] == sw_if_index_from)
19559 sw_if_from_name = (u8 *)(p->key);
19563 if ((u32) p->value[0] == sw_if_index_to)
19565 sw_if_to_name = (u8 *)(p->key);
19566 if (sw_if_from_name)
19571 print (vam->ofp, "%20s => %20s (%s) %s",
19572 sw_if_from_name, sw_if_to_name, states[mp->state],
19573 mp->is_l2 ? "l2" : "device");
19577 vl_api_sw_interface_span_details_t_handler_json
19578 (vl_api_sw_interface_span_details_t * mp)
19580 vat_main_t *vam = &vat_main;
19581 vat_json_node_t *node = NULL;
19582 u8 *sw_if_from_name = 0;
19583 u8 *sw_if_to_name = 0;
19584 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
19585 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
19589 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
19591 if ((u32) p->value[0] == sw_if_index_from)
19593 sw_if_from_name = (u8 *)(p->key);
19597 if ((u32) p->value[0] == sw_if_index_to)
19599 sw_if_to_name = (u8 *)(p->key);
19600 if (sw_if_from_name)
19606 if (VAT_JSON_ARRAY != vam->json_tree.type)
19608 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19609 vat_json_init_array (&vam->json_tree);
19611 node = vat_json_array_add (&vam->json_tree);
19613 vat_json_init_object (node);
19614 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
19615 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
19616 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
19617 if (0 != sw_if_to_name)
19619 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
19621 vat_json_object_add_uint (node, "state", mp->state);
19622 vat_json_object_add_uint (node, "is-l2", mp->is_l2);
19626 api_sw_interface_span_dump (vat_main_t * vam)
19628 unformat_input_t *input = vam->input;
19629 vl_api_sw_interface_span_dump_t *mp;
19630 vl_api_control_ping_t *mp_ping;
19634 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19636 if (unformat (input, "l2"))
19642 M (SW_INTERFACE_SPAN_DUMP, mp);
19646 /* Use a control ping for synchronization */
19647 MPING (CONTROL_PING, mp_ping);
19655 api_pg_create_interface (vat_main_t * vam)
19657 unformat_input_t *input = vam->input;
19658 vl_api_pg_create_interface_t *mp;
19660 u32 if_id = ~0, gso_size = 0;
19661 u8 gso_enabled = 0;
19663 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19665 if (unformat (input, "if_id %d", &if_id))
19667 else if (unformat (input, "gso-enabled"))
19670 if (unformat (input, "gso-size %u", &gso_size))
19674 errmsg ("missing gso-size");
19683 errmsg ("missing pg interface index");
19687 /* Construct the API message */
19688 M (PG_CREATE_INTERFACE, mp);
19690 mp->interface_id = ntohl (if_id);
19691 mp->gso_enabled = gso_enabled;
19699 api_pg_capture (vat_main_t * vam)
19701 unformat_input_t *input = vam->input;
19702 vl_api_pg_capture_t *mp;
19707 u8 pcap_file_set = 0;
19710 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19712 if (unformat (input, "if_id %d", &if_id))
19714 else if (unformat (input, "pcap %s", &pcap_file))
19716 else if (unformat (input, "count %d", &count))
19718 else if (unformat (input, "disable"))
19725 errmsg ("missing pg interface index");
19728 if (pcap_file_set > 0)
19730 if (vec_len (pcap_file) > 255)
19732 errmsg ("pcap file name is too long");
19737 u32 name_len = vec_len (pcap_file);
19738 /* Construct the API message */
19739 M (PG_CAPTURE, mp);
19741 mp->interface_id = ntohl (if_id);
19742 mp->is_enabled = enable;
19743 mp->count = ntohl (count);
19744 mp->pcap_name_length = ntohl (name_len);
19745 if (pcap_file_set != 0)
19747 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
19749 vec_free (pcap_file);
19757 api_pg_enable_disable (vat_main_t * vam)
19759 unformat_input_t *input = vam->input;
19760 vl_api_pg_enable_disable_t *mp;
19763 u8 stream_name_set = 0;
19764 u8 *stream_name = 0;
19766 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19768 if (unformat (input, "stream %s", &stream_name))
19769 stream_name_set = 1;
19770 else if (unformat (input, "disable"))
19776 if (stream_name_set > 0)
19778 if (vec_len (stream_name) > 255)
19780 errmsg ("stream name too long");
19785 u32 name_len = vec_len (stream_name);
19786 /* Construct the API message */
19787 M (PG_ENABLE_DISABLE, mp);
19789 mp->is_enabled = enable;
19790 if (stream_name_set != 0)
19792 mp->stream_name_length = ntohl (name_len);
19793 clib_memcpy (mp->stream_name, stream_name, name_len);
19795 vec_free (stream_name);
19803 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
19805 unformat_input_t *input = vam->input;
19806 vl_api_ip_source_and_port_range_check_add_del_t *mp;
19808 u16 *low_ports = 0;
19809 u16 *high_ports = 0;
19812 vl_api_prefix_t prefix;
19819 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19821 if (unformat (input, "%U", unformat_vl_api_prefix, &prefix))
19823 else if (unformat (input, "vrf %d", &vrf_id))
19825 else if (unformat (input, "del"))
19827 else if (unformat (input, "port %d", &tmp))
19829 if (tmp == 0 || tmp > 65535)
19831 errmsg ("port %d out of range", tmp);
19835 this_hi = this_low + 1;
19836 vec_add1 (low_ports, this_low);
19837 vec_add1 (high_ports, this_hi);
19839 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
19841 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
19843 errmsg ("incorrect range parameters");
19847 /* Note: in debug CLI +1 is added to high before
19848 passing to real fn that does "the work"
19849 (ip_source_and_port_range_check_add_del).
19850 This fn is a wrapper around the binary API fn a
19851 control plane will call, which expects this increment
19852 to have occurred. Hence letting the binary API control
19853 plane fn do the increment for consistency between VAT
19854 and other control planes.
19857 vec_add1 (low_ports, this_low);
19858 vec_add1 (high_ports, this_hi);
19864 if (prefix_set == 0)
19866 errmsg ("<address>/<mask> not specified");
19872 errmsg ("VRF ID required, not specified");
19879 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
19883 if (vec_len (low_ports) == 0)
19885 errmsg ("At least one port or port range required");
19889 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
19891 mp->is_add = is_add;
19893 clib_memcpy (&mp->prefix, &prefix, sizeof (prefix));
19895 mp->number_of_ranges = vec_len (low_ports);
19897 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
19898 vec_free (low_ports);
19900 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
19901 vec_free (high_ports);
19903 mp->vrf_id = ntohl (vrf_id);
19911 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
19913 unformat_input_t *input = vam->input;
19914 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
19915 u32 sw_if_index = ~0;
19917 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
19918 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
19922 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19924 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19926 else if (unformat (input, "sw_if_index %d", &sw_if_index))
19928 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
19930 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
19932 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
19934 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
19936 else if (unformat (input, "del"))
19942 if (sw_if_index == ~0)
19944 errmsg ("Interface required but not specified");
19950 errmsg ("VRF ID required but not specified");
19954 if (tcp_out_vrf_id == 0
19955 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
19958 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
19962 /* Construct the API message */
19963 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
19965 mp->sw_if_index = ntohl (sw_if_index);
19966 mp->is_add = is_add;
19967 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
19968 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
19969 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
19970 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
19975 /* Wait for a reply... */
19981 api_set_punt (vat_main_t * vam)
19983 unformat_input_t *i = vam->input;
19984 vl_api_address_family_t af;
19985 vl_api_set_punt_t *mp;
19991 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19993 if (unformat (i, "%U", unformat_vl_api_address_family, &af))
19995 else if (unformat (i, "protocol %d", &protocol))
19997 else if (unformat (i, "port %d", &port))
19999 else if (unformat (i, "del"))
20003 clib_warning ("parse error '%U'", format_unformat_error, i);
20010 mp->is_add = (u8) is_add;
20011 mp->punt.type = PUNT_API_TYPE_L4;
20012 mp->punt.punt.l4.af = af;
20013 mp->punt.punt.l4.protocol = (u8) protocol;
20014 mp->punt.punt.l4.port = htons ((u16) port);
20022 api_delete_subif (vat_main_t * vam)
20024 unformat_input_t *i = vam->input;
20025 vl_api_delete_subif_t *mp;
20026 u32 sw_if_index = ~0;
20029 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20031 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20033 if (unformat (i, "sw_if_index %d", &sw_if_index))
20039 if (sw_if_index == ~0)
20041 errmsg ("missing sw_if_index");
20045 /* Construct the API message */
20046 M (DELETE_SUBIF, mp);
20047 mp->sw_if_index = ntohl (sw_if_index);
20054 #define foreach_pbb_vtr_op \
20055 _("disable", L2_VTR_DISABLED) \
20056 _("pop", L2_VTR_POP_2) \
20057 _("push", L2_VTR_PUSH_2)
20060 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
20062 unformat_input_t *i = vam->input;
20063 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
20064 u32 sw_if_index = ~0, vtr_op = ~0;
20065 u16 outer_tag = ~0;
20066 u8 dmac[6], smac[6];
20067 u8 dmac_set = 0, smac_set = 0;
20073 /* Shut up coverity */
20074 clib_memset (dmac, 0, sizeof (dmac));
20075 clib_memset (smac, 0, sizeof (smac));
20077 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20079 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20081 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20083 else if (unformat (i, "vtr_op %d", &vtr_op))
20085 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
20088 else if (unformat (i, "translate_pbb_stag"))
20090 if (unformat (i, "%d", &tmp))
20092 vtr_op = L2_VTR_TRANSLATE_2_1;
20098 ("translate_pbb_stag operation requires outer tag definition");
20102 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
20104 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
20106 else if (unformat (i, "sid %d", &sid))
20108 else if (unformat (i, "vlanid %d", &tmp))
20112 clib_warning ("parse error '%U'", format_unformat_error, i);
20117 if ((sw_if_index == ~0) || (vtr_op == ~0))
20119 errmsg ("missing sw_if_index or vtr operation");
20122 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
20123 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
20126 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
20130 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
20131 mp->sw_if_index = ntohl (sw_if_index);
20132 mp->vtr_op = ntohl (vtr_op);
20133 mp->outer_tag = ntohs (outer_tag);
20134 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
20135 clib_memcpy (mp->b_smac, smac, sizeof (smac));
20136 mp->b_vlanid = ntohs (vlanid);
20137 mp->i_sid = ntohl (sid);
20145 api_flow_classify_set_interface (vat_main_t * vam)
20147 unformat_input_t *i = vam->input;
20148 vl_api_flow_classify_set_interface_t *mp;
20150 int sw_if_index_set;
20151 u32 ip4_table_index = ~0;
20152 u32 ip6_table_index = ~0;
20156 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20158 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20159 sw_if_index_set = 1;
20160 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20161 sw_if_index_set = 1;
20162 else if (unformat (i, "del"))
20164 else if (unformat (i, "ip4-table %d", &ip4_table_index))
20166 else if (unformat (i, "ip6-table %d", &ip6_table_index))
20170 clib_warning ("parse error '%U'", format_unformat_error, i);
20175 if (sw_if_index_set == 0)
20177 errmsg ("missing interface name or sw_if_index");
20181 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
20183 mp->sw_if_index = ntohl (sw_if_index);
20184 mp->ip4_table_index = ntohl (ip4_table_index);
20185 mp->ip6_table_index = ntohl (ip6_table_index);
20186 mp->is_add = is_add;
20194 api_flow_classify_dump (vat_main_t * vam)
20196 unformat_input_t *i = vam->input;
20197 vl_api_flow_classify_dump_t *mp;
20198 vl_api_control_ping_t *mp_ping;
20199 u8 type = FLOW_CLASSIFY_N_TABLES;
20202 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
20206 errmsg ("classify table type must be specified");
20210 if (!vam->json_output)
20212 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
20215 M (FLOW_CLASSIFY_DUMP, mp);
20220 /* Use a control ping for synchronization */
20221 MPING (CONTROL_PING, mp_ping);
20224 /* Wait for a reply... */
20230 api_feature_enable_disable (vat_main_t * vam)
20232 unformat_input_t *i = vam->input;
20233 vl_api_feature_enable_disable_t *mp;
20235 u8 *feature_name = 0;
20236 u32 sw_if_index = ~0;
20240 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20242 if (unformat (i, "arc_name %s", &arc_name))
20244 else if (unformat (i, "feature_name %s", &feature_name))
20247 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20249 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20251 else if (unformat (i, "disable"))
20259 errmsg ("missing arc name");
20262 if (vec_len (arc_name) > 63)
20264 errmsg ("arc name too long");
20267 if (feature_name == 0)
20269 errmsg ("missing feature name");
20272 if (vec_len (feature_name) > 63)
20274 errmsg ("feature name too long");
20277 if (sw_if_index == ~0)
20279 errmsg ("missing interface name or sw_if_index");
20283 /* Construct the API message */
20284 M (FEATURE_ENABLE_DISABLE, mp);
20285 mp->sw_if_index = ntohl (sw_if_index);
20286 mp->enable = enable;
20287 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
20288 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
20289 vec_free (arc_name);
20290 vec_free (feature_name);
20298 api_sw_interface_tag_add_del (vat_main_t * vam)
20300 unformat_input_t *i = vam->input;
20301 vl_api_sw_interface_tag_add_del_t *mp;
20302 u32 sw_if_index = ~0;
20307 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20309 if (unformat (i, "tag %s", &tag))
20311 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20313 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20315 else if (unformat (i, "del"))
20321 if (sw_if_index == ~0)
20323 errmsg ("missing interface name or sw_if_index");
20327 if (enable && (tag == 0))
20329 errmsg ("no tag specified");
20333 /* Construct the API message */
20334 M (SW_INTERFACE_TAG_ADD_DEL, mp);
20335 mp->sw_if_index = ntohl (sw_if_index);
20336 mp->is_add = enable;
20338 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
20346 static void vl_api_l2_xconnect_details_t_handler
20347 (vl_api_l2_xconnect_details_t * mp)
20349 vat_main_t *vam = &vat_main;
20351 print (vam->ofp, "%15d%15d",
20352 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
20355 static void vl_api_l2_xconnect_details_t_handler_json
20356 (vl_api_l2_xconnect_details_t * mp)
20358 vat_main_t *vam = &vat_main;
20359 vat_json_node_t *node = NULL;
20361 if (VAT_JSON_ARRAY != vam->json_tree.type)
20363 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20364 vat_json_init_array (&vam->json_tree);
20366 node = vat_json_array_add (&vam->json_tree);
20368 vat_json_init_object (node);
20369 vat_json_object_add_uint (node, "rx_sw_if_index",
20370 ntohl (mp->rx_sw_if_index));
20371 vat_json_object_add_uint (node, "tx_sw_if_index",
20372 ntohl (mp->tx_sw_if_index));
20376 api_l2_xconnect_dump (vat_main_t * vam)
20378 vl_api_l2_xconnect_dump_t *mp;
20379 vl_api_control_ping_t *mp_ping;
20382 if (!vam->json_output)
20384 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
20387 M (L2_XCONNECT_DUMP, mp);
20391 /* Use a control ping for synchronization */
20392 MPING (CONTROL_PING, mp_ping);
20400 api_hw_interface_set_mtu (vat_main_t * vam)
20402 unformat_input_t *i = vam->input;
20403 vl_api_hw_interface_set_mtu_t *mp;
20404 u32 sw_if_index = ~0;
20408 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20410 if (unformat (i, "mtu %d", &mtu))
20412 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20414 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20420 if (sw_if_index == ~0)
20422 errmsg ("missing interface name or sw_if_index");
20428 errmsg ("no mtu specified");
20432 /* Construct the API message */
20433 M (HW_INTERFACE_SET_MTU, mp);
20434 mp->sw_if_index = ntohl (sw_if_index);
20435 mp->mtu = ntohs ((u16) mtu);
20443 api_p2p_ethernet_add (vat_main_t * vam)
20445 unformat_input_t *i = vam->input;
20446 vl_api_p2p_ethernet_add_t *mp;
20447 u32 parent_if_index = ~0;
20453 clib_memset (remote_mac, 0, sizeof (remote_mac));
20454 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20456 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
20458 else if (unformat (i, "sw_if_index %d", &parent_if_index))
20462 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
20464 else if (unformat (i, "sub_id %d", &sub_id))
20468 clib_warning ("parse error '%U'", format_unformat_error, i);
20473 if (parent_if_index == ~0)
20475 errmsg ("missing interface name or sw_if_index");
20480 errmsg ("missing remote mac address");
20485 errmsg ("missing sub-interface id");
20489 M (P2P_ETHERNET_ADD, mp);
20490 mp->parent_if_index = ntohl (parent_if_index);
20491 mp->subif_id = ntohl (sub_id);
20492 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
20500 api_p2p_ethernet_del (vat_main_t * vam)
20502 unformat_input_t *i = vam->input;
20503 vl_api_p2p_ethernet_del_t *mp;
20504 u32 parent_if_index = ~0;
20509 clib_memset (remote_mac, 0, sizeof (remote_mac));
20510 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20512 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
20514 else if (unformat (i, "sw_if_index %d", &parent_if_index))
20518 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
20522 clib_warning ("parse error '%U'", format_unformat_error, i);
20527 if (parent_if_index == ~0)
20529 errmsg ("missing interface name or sw_if_index");
20534 errmsg ("missing remote mac address");
20538 M (P2P_ETHERNET_DEL, mp);
20539 mp->parent_if_index = ntohl (parent_if_index);
20540 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
20548 api_lldp_config (vat_main_t * vam)
20550 unformat_input_t *i = vam->input;
20551 vl_api_lldp_config_t *mp;
20553 int tx_interval = 0;
20554 u8 *sys_name = NULL;
20557 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20559 if (unformat (i, "system-name %s", &sys_name))
20561 else if (unformat (i, "tx-hold %d", &tx_hold))
20563 else if (unformat (i, "tx-interval %d", &tx_interval))
20567 clib_warning ("parse error '%U'", format_unformat_error, i);
20572 vec_add1 (sys_name, 0);
20574 M (LLDP_CONFIG, mp);
20575 mp->tx_hold = htonl (tx_hold);
20576 mp->tx_interval = htonl (tx_interval);
20577 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
20578 vec_free (sys_name);
20586 api_sw_interface_set_lldp (vat_main_t * vam)
20588 unformat_input_t *i = vam->input;
20589 vl_api_sw_interface_set_lldp_t *mp;
20590 u32 sw_if_index = ~0;
20592 u8 *port_desc = NULL, *mgmt_oid = NULL;
20593 ip4_address_t ip4_addr;
20594 ip6_address_t ip6_addr;
20597 clib_memset (&ip4_addr, 0, sizeof (ip4_addr));
20598 clib_memset (&ip6_addr, 0, sizeof (ip6_addr));
20600 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20602 if (unformat (i, "disable"))
20605 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20607 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20609 else if (unformat (i, "port-desc %s", &port_desc))
20611 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
20613 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
20615 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
20621 if (sw_if_index == ~0)
20623 errmsg ("missing interface name or sw_if_index");
20627 /* Construct the API message */
20628 vec_add1 (port_desc, 0);
20629 vec_add1 (mgmt_oid, 0);
20630 M (SW_INTERFACE_SET_LLDP, mp);
20631 mp->sw_if_index = ntohl (sw_if_index);
20632 mp->enable = enable;
20633 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
20634 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
20635 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
20636 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
20637 vec_free (port_desc);
20638 vec_free (mgmt_oid);
20646 api_tcp_configure_src_addresses (vat_main_t * vam)
20648 vl_api_tcp_configure_src_addresses_t *mp;
20649 unformat_input_t *i = vam->input;
20650 ip4_address_t v4first, v4last;
20651 ip6_address_t v6first, v6last;
20656 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20658 if (unformat (i, "%U - %U",
20659 unformat_ip4_address, &v4first,
20660 unformat_ip4_address, &v4last))
20664 errmsg ("one range per message (range already set)");
20669 else if (unformat (i, "%U - %U",
20670 unformat_ip6_address, &v6first,
20671 unformat_ip6_address, &v6last))
20675 errmsg ("one range per message (range already set)");
20680 else if (unformat (i, "vrf %d", &vrf_id))
20686 if (range_set == 0)
20688 errmsg ("address range not set");
20692 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
20693 mp->vrf_id = ntohl (vrf_id);
20695 if (range_set == 2)
20698 clib_memcpy (mp->first_address, &v6first, sizeof (v6first));
20699 clib_memcpy (mp->last_address, &v6last, sizeof (v6last));
20704 clib_memcpy (mp->first_address, &v4first, sizeof (v4first));
20705 clib_memcpy (mp->last_address, &v4last, sizeof (v4last));
20712 static void vl_api_app_namespace_add_del_reply_t_handler
20713 (vl_api_app_namespace_add_del_reply_t * mp)
20715 vat_main_t *vam = &vat_main;
20716 i32 retval = ntohl (mp->retval);
20717 if (vam->async_mode)
20719 vam->async_errors += (retval < 0);
20723 vam->retval = retval;
20725 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
20726 vam->result_ready = 1;
20730 static void vl_api_app_namespace_add_del_reply_t_handler_json
20731 (vl_api_app_namespace_add_del_reply_t * mp)
20733 vat_main_t *vam = &vat_main;
20734 vat_json_node_t node;
20736 vat_json_init_object (&node);
20737 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
20738 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
20740 vat_json_print (vam->ofp, &node);
20741 vat_json_free (&node);
20743 vam->retval = ntohl (mp->retval);
20744 vam->result_ready = 1;
20748 api_app_namespace_add_del (vat_main_t * vam)
20750 vl_api_app_namespace_add_del_t *mp;
20751 unformat_input_t *i = vam->input;
20752 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
20753 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
20757 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20759 if (unformat (i, "id %_%v%_", &ns_id))
20761 else if (unformat (i, "secret %lu", &secret))
20763 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20764 sw_if_index_set = 1;
20765 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
20767 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
20772 if (!ns_id || !secret_set || !sw_if_index_set)
20774 errmsg ("namespace id, secret and sw_if_index must be set");
20777 if (vec_len (ns_id) > 64)
20779 errmsg ("namespace id too long");
20782 M (APP_NAMESPACE_ADD_DEL, mp);
20784 clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
20785 mp->namespace_id_len = vec_len (ns_id);
20786 mp->secret = clib_host_to_net_u64 (secret);
20787 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
20788 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
20789 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
20797 api_sock_init_shm (vat_main_t * vam)
20799 #if VPP_API_TEST_BUILTIN == 0
20800 unformat_input_t *i = vam->input;
20801 vl_api_shm_elem_config_t *config = 0;
20802 u64 size = 64 << 20;
20805 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20807 if (unformat (i, "size %U", unformat_memory_size, &size))
20814 * Canned custom ring allocator config.
20815 * Should probably parse all of this
20817 vec_validate (config, 6);
20818 config[0].type = VL_API_VLIB_RING;
20819 config[0].size = 256;
20820 config[0].count = 32;
20822 config[1].type = VL_API_VLIB_RING;
20823 config[1].size = 1024;
20824 config[1].count = 16;
20826 config[2].type = VL_API_VLIB_RING;
20827 config[2].size = 4096;
20828 config[2].count = 2;
20830 config[3].type = VL_API_CLIENT_RING;
20831 config[3].size = 256;
20832 config[3].count = 32;
20834 config[4].type = VL_API_CLIENT_RING;
20835 config[4].size = 1024;
20836 config[4].count = 16;
20838 config[5].type = VL_API_CLIENT_RING;
20839 config[5].size = 4096;
20840 config[5].count = 2;
20842 config[6].type = VL_API_QUEUE;
20843 config[6].count = 128;
20844 config[6].size = sizeof (uword);
20846 rv = vl_socket_client_init_shm (config, 1 /* want_pthread */ );
20848 vam->client_index_invalid = 1;
20856 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
20858 vat_main_t *vam = &vat_main;
20863 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
20864 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
20865 mp->scope, format_ip4_address, &mp->lcl_ip, mp->lcl_plen,
20866 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
20867 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
20868 clib_net_to_host_u32 (mp->action_index), mp->tag);
20873 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
20874 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
20875 mp->scope, format_ip6_address, &mp->lcl_ip, mp->lcl_plen,
20876 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
20877 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
20878 clib_net_to_host_u32 (mp->action_index), mp->tag);
20883 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
20886 vat_main_t *vam = &vat_main;
20887 vat_json_node_t *node = NULL;
20888 struct in6_addr ip6;
20889 struct in_addr ip4;
20891 if (VAT_JSON_ARRAY != vam->json_tree.type)
20893 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20894 vat_json_init_array (&vam->json_tree);
20896 node = vat_json_array_add (&vam->json_tree);
20897 vat_json_init_object (node);
20899 vat_json_object_add_uint (node, "is_ip4", mp->is_ip4 ? 1 : 0);
20900 vat_json_object_add_uint (node, "appns_index",
20901 clib_net_to_host_u32 (mp->appns_index));
20902 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
20903 vat_json_object_add_uint (node, "scope", mp->scope);
20904 vat_json_object_add_uint (node, "action_index",
20905 clib_net_to_host_u32 (mp->action_index));
20906 vat_json_object_add_uint (node, "lcl_port",
20907 clib_net_to_host_u16 (mp->lcl_port));
20908 vat_json_object_add_uint (node, "rmt_port",
20909 clib_net_to_host_u16 (mp->rmt_port));
20910 vat_json_object_add_uint (node, "lcl_plen", mp->lcl_plen);
20911 vat_json_object_add_uint (node, "rmt_plen", mp->rmt_plen);
20912 vat_json_object_add_string_copy (node, "tag", mp->tag);
20915 clib_memcpy (&ip4, mp->lcl_ip, sizeof (ip4));
20916 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
20917 clib_memcpy (&ip4, mp->rmt_ip, sizeof (ip4));
20918 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
20922 clib_memcpy (&ip6, mp->lcl_ip, sizeof (ip6));
20923 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
20924 clib_memcpy (&ip6, mp->rmt_ip, sizeof (ip6));
20925 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
20930 api_session_rule_add_del (vat_main_t * vam)
20932 vl_api_session_rule_add_del_t *mp;
20933 unformat_input_t *i = vam->input;
20934 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
20935 u32 appns_index = 0, scope = 0;
20936 ip4_address_t lcl_ip4, rmt_ip4;
20937 ip6_address_t lcl_ip6, rmt_ip6;
20938 u8 is_ip4 = 1, conn_set = 0;
20939 u8 is_add = 1, *tag = 0;
20942 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20944 if (unformat (i, "del"))
20946 else if (unformat (i, "add"))
20948 else if (unformat (i, "proto tcp"))
20950 else if (unformat (i, "proto udp"))
20952 else if (unformat (i, "appns %d", &appns_index))
20954 else if (unformat (i, "scope %d", &scope))
20956 else if (unformat (i, "tag %_%v%_", &tag))
20960 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
20961 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
20969 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
20970 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
20976 else if (unformat (i, "action %d", &action))
20981 if (proto == ~0 || !conn_set || action == ~0)
20983 errmsg ("transport proto, connection and action must be set");
20989 errmsg ("scope should be 0-3");
20993 M (SESSION_RULE_ADD_DEL, mp);
20995 mp->is_ip4 = is_ip4;
20996 mp->transport_proto = proto;
20997 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
20998 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
20999 mp->lcl_plen = lcl_plen;
21000 mp->rmt_plen = rmt_plen;
21001 mp->action_index = clib_host_to_net_u32 (action);
21002 mp->appns_index = clib_host_to_net_u32 (appns_index);
21004 mp->is_add = is_add;
21007 clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
21008 clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
21012 clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
21013 clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
21017 clib_memcpy (mp->tag, tag, vec_len (tag));
21027 api_session_rules_dump (vat_main_t * vam)
21029 vl_api_session_rules_dump_t *mp;
21030 vl_api_control_ping_t *mp_ping;
21033 if (!vam->json_output)
21035 print (vam->ofp, "%=20s", "Session Rules");
21038 M (SESSION_RULES_DUMP, mp);
21042 /* Use a control ping for synchronization */
21043 MPING (CONTROL_PING, mp_ping);
21046 /* Wait for a reply... */
21052 api_ip_container_proxy_add_del (vat_main_t * vam)
21054 vl_api_ip_container_proxy_add_del_t *mp;
21055 unformat_input_t *i = vam->input;
21056 u32 sw_if_index = ~0;
21057 vl_api_prefix_t pfx = { };
21061 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21063 if (unformat (i, "del"))
21065 else if (unformat (i, "add"))
21067 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
21069 else if (unformat (i, "sw_if_index %u", &sw_if_index))
21074 if (sw_if_index == ~0 || pfx.len == 0)
21076 errmsg ("address and sw_if_index must be set");
21080 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
21082 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
21083 mp->is_add = is_add;
21084 clib_memcpy (&mp->pfx, &pfx, sizeof (pfx));
21092 api_qos_record_enable_disable (vat_main_t * vam)
21094 unformat_input_t *i = vam->input;
21095 vl_api_qos_record_enable_disable_t *mp;
21096 u32 sw_if_index, qs = 0xff;
21097 u8 sw_if_index_set = 0;
21101 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21103 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21104 sw_if_index_set = 1;
21105 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21106 sw_if_index_set = 1;
21107 else if (unformat (i, "%U", unformat_qos_source, &qs))
21109 else if (unformat (i, "disable"))
21113 clib_warning ("parse error '%U'", format_unformat_error, i);
21118 if (sw_if_index_set == 0)
21120 errmsg ("missing interface name or sw_if_index");
21125 errmsg ("input location must be specified");
21129 M (QOS_RECORD_ENABLE_DISABLE, mp);
21131 mp->record.sw_if_index = ntohl (sw_if_index);
21132 mp->record.input_source = qs;
21133 mp->enable = enable;
21142 q_or_quit (vat_main_t * vam)
21144 #if VPP_API_TEST_BUILTIN == 0
21145 longjmp (vam->jump_buf, 1);
21147 return 0; /* not so much */
21151 q (vat_main_t * vam)
21153 return q_or_quit (vam);
21157 quit (vat_main_t * vam)
21159 return q_or_quit (vam);
21163 comment (vat_main_t * vam)
21169 elog_save (vat_main_t * vam)
21171 #if VPP_API_TEST_BUILTIN == 0
21172 elog_main_t *em = &vam->elog_main;
21173 unformat_input_t *i = vam->input;
21174 char *file, *chroot_file;
21175 clib_error_t *error;
21177 if (!unformat (i, "%s", &file))
21179 errmsg ("expected file name, got `%U'", format_unformat_error, i);
21183 /* It's fairly hard to get "../oopsie" through unformat; just in case */
21184 if (strstr (file, "..") || index (file, '/'))
21186 errmsg ("illegal characters in filename '%s'", file);
21190 chroot_file = (char *) format (0, "/tmp/%s%c", file, 0);
21194 errmsg ("Saving %wd of %wd events to %s",
21195 elog_n_events_in_buffer (em),
21196 elog_buffer_capacity (em), chroot_file);
21198 error = elog_write_file (em, chroot_file, 1 /* flush ring */ );
21199 vec_free (chroot_file);
21202 clib_error_report (error);
21204 errmsg ("Use the vpp event loger...");
21211 elog_setup (vat_main_t * vam)
21213 #if VPP_API_TEST_BUILTIN == 0
21214 elog_main_t *em = &vam->elog_main;
21215 unformat_input_t *i = vam->input;
21216 u32 nevents = 128 << 10;
21218 (void) unformat (i, "nevents %d", &nevents);
21220 elog_init (em, nevents);
21221 vl_api_set_elog_main (em);
21222 vl_api_set_elog_trace_api_messages (1);
21223 errmsg ("Event logger initialized with %u events", nevents);
21225 errmsg ("Use the vpp event loger...");
21231 elog_enable (vat_main_t * vam)
21233 #if VPP_API_TEST_BUILTIN == 0
21234 elog_main_t *em = &vam->elog_main;
21236 elog_enable_disable (em, 1 /* enable */ );
21237 vl_api_set_elog_trace_api_messages (1);
21238 errmsg ("Event logger enabled...");
21240 errmsg ("Use the vpp event loger...");
21246 elog_disable (vat_main_t * vam)
21248 #if VPP_API_TEST_BUILTIN == 0
21249 elog_main_t *em = &vam->elog_main;
21251 elog_enable_disable (em, 0 /* enable */ );
21252 vl_api_set_elog_trace_api_messages (1);
21253 errmsg ("Event logger disabled...");
21255 errmsg ("Use the vpp event loger...");
21261 statseg (vat_main_t * vam)
21263 ssvm_private_t *ssvmp = &vam->stat_segment;
21264 ssvm_shared_header_t *shared_header = ssvmp->sh;
21265 vlib_counter_t **counters;
21266 u64 thread0_index1_packets;
21267 u64 thread0_index1_bytes;
21268 f64 vector_rate, input_rate;
21271 uword *counter_vector_by_name;
21272 if (vam->stat_segment_lockp == 0)
21274 errmsg ("Stat segment not mapped...");
21278 /* look up "/if/rx for sw_if_index 1 as a test */
21280 clib_spinlock_lock (vam->stat_segment_lockp);
21282 counter_vector_by_name = (uword *) shared_header->opaque[1];
21284 p = hash_get_mem (counter_vector_by_name, "/if/rx");
21287 clib_spinlock_unlock (vam->stat_segment_lockp);
21288 errmsg ("/if/tx not found?");
21292 /* Fish per-thread vector of combined counters from shared memory */
21293 counters = (vlib_counter_t **) p[0];
21295 if (vec_len (counters[0]) < 2)
21297 clib_spinlock_unlock (vam->stat_segment_lockp);
21298 errmsg ("/if/tx vector length %d", vec_len (counters[0]));
21302 /* Read thread 0 sw_if_index 1 counter */
21303 thread0_index1_packets = counters[0][1].packets;
21304 thread0_index1_bytes = counters[0][1].bytes;
21306 p = hash_get_mem (counter_vector_by_name, "vector_rate");
21309 clib_spinlock_unlock (vam->stat_segment_lockp);
21310 errmsg ("vector_rate not found?");
21314 vector_rate = *(f64 *) (p[0]);
21315 p = hash_get_mem (counter_vector_by_name, "input_rate");
21318 clib_spinlock_unlock (vam->stat_segment_lockp);
21319 errmsg ("input_rate not found?");
21322 input_rate = *(f64 *) (p[0]);
21324 clib_spinlock_unlock (vam->stat_segment_lockp);
21326 print (vam->ofp, "vector_rate %.2f input_rate %.2f",
21327 vector_rate, input_rate);
21328 print (vam->ofp, "thread 0 sw_if_index 1 rx pkts %lld, bytes %lld",
21329 thread0_index1_packets, thread0_index1_bytes);
21335 cmd_cmp (void *a1, void *a2)
21340 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
21344 help (vat_main_t * vam)
21349 unformat_input_t *i = vam->input;
21352 if (unformat (i, "%s", &name))
21356 vec_add1 (name, 0);
21358 hs = hash_get_mem (vam->help_by_name, name);
21360 print (vam->ofp, "usage: %s %s", name, hs[0]);
21362 print (vam->ofp, "No such msg / command '%s'", name);
21367 print (vam->ofp, "Help is available for the following:");
21370 hash_foreach_pair (p, vam->function_by_name,
21372 vec_add1 (cmds, (u8 *)(p->key));
21376 vec_sort_with_function (cmds, cmd_cmp);
21378 for (j = 0; j < vec_len (cmds); j++)
21379 print (vam->ofp, "%s", cmds[j]);
21386 set (vat_main_t * vam)
21388 u8 *name = 0, *value = 0;
21389 unformat_input_t *i = vam->input;
21391 if (unformat (i, "%s", &name))
21393 /* The input buffer is a vector, not a string. */
21394 value = vec_dup (i->buffer);
21395 vec_delete (value, i->index, 0);
21396 /* Almost certainly has a trailing newline */
21397 if (value[vec_len (value) - 1] == '\n')
21398 value[vec_len (value) - 1] = 0;
21399 /* Make sure it's a proper string, one way or the other */
21400 vec_add1 (value, 0);
21401 (void) clib_macro_set_value (&vam->macro_main,
21402 (char *) name, (char *) value);
21405 errmsg ("usage: set <name> <value>");
21413 unset (vat_main_t * vam)
21417 if (unformat (vam->input, "%s", &name))
21418 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
21419 errmsg ("unset: %s wasn't set", name);
21432 macro_sort_cmp (void *a1, void *a2)
21434 macro_sort_t *s1 = a1;
21435 macro_sort_t *s2 = a2;
21437 return strcmp ((char *) (s1->name), (char *) (s2->name));
21441 dump_macro_table (vat_main_t * vam)
21443 macro_sort_t *sort_me = 0, *sm;
21448 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
21450 vec_add2 (sort_me, sm, 1);
21451 sm->name = (u8 *)(p->key);
21452 sm->value = (u8 *) (p->value[0]);
21456 vec_sort_with_function (sort_me, macro_sort_cmp);
21458 if (vec_len (sort_me))
21459 print (vam->ofp, "%-15s%s", "Name", "Value");
21461 print (vam->ofp, "The macro table is empty...");
21463 for (i = 0; i < vec_len (sort_me); i++)
21464 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
21469 dump_node_table (vat_main_t * vam)
21472 vlib_node_t *node, *next_node;
21474 if (vec_len (vam->graph_nodes) == 0)
21476 print (vam->ofp, "Node table empty, issue get_node_graph...");
21480 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
21482 node = vam->graph_nodes[0][i];
21483 print (vam->ofp, "[%d] %s", i, node->name);
21484 for (j = 0; j < vec_len (node->next_nodes); j++)
21486 if (node->next_nodes[j] != ~0)
21488 next_node = vam->graph_nodes[0][node->next_nodes[j]];
21489 print (vam->ofp, " [%d] %s", j, next_node->name);
21497 value_sort_cmp (void *a1, void *a2)
21499 name_sort_t *n1 = a1;
21500 name_sort_t *n2 = a2;
21502 if (n1->value < n2->value)
21504 if (n1->value > n2->value)
21511 dump_msg_api_table (vat_main_t * vam)
21513 api_main_t *am = &api_main;
21514 name_sort_t *nses = 0, *ns;
21519 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
21521 vec_add2 (nses, ns, 1);
21522 ns->name = (u8 *)(hp->key);
21523 ns->value = (u32) hp->value[0];
21527 vec_sort_with_function (nses, value_sort_cmp);
21529 for (i = 0; i < vec_len (nses); i++)
21530 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
21536 get_msg_id (vat_main_t * vam)
21541 if (unformat (vam->input, "%s", &name_and_crc))
21543 message_index = vl_msg_api_get_msg_index (name_and_crc);
21544 if (message_index == ~0)
21546 print (vam->ofp, " '%s' not found", name_and_crc);
21549 print (vam->ofp, " '%s' has message index %d",
21550 name_and_crc, message_index);
21553 errmsg ("name_and_crc required...");
21558 search_node_table (vat_main_t * vam)
21560 unformat_input_t *line_input = vam->input;
21563 vlib_node_t *node, *next_node;
21566 if (vam->graph_node_index_by_name == 0)
21568 print (vam->ofp, "Node table empty, issue get_node_graph...");
21572 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21574 if (unformat (line_input, "%s", &node_to_find))
21576 vec_add1 (node_to_find, 0);
21577 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
21580 print (vam->ofp, "%s not found...", node_to_find);
21583 node = vam->graph_nodes[0][p[0]];
21584 print (vam->ofp, "[%d] %s", p[0], node->name);
21585 for (j = 0; j < vec_len (node->next_nodes); j++)
21587 if (node->next_nodes[j] != ~0)
21589 next_node = vam->graph_nodes[0][node->next_nodes[j]];
21590 print (vam->ofp, " [%d] %s", j, next_node->name);
21597 clib_warning ("parse error '%U'", format_unformat_error,
21603 vec_free (node_to_find);
21612 script (vat_main_t * vam)
21614 #if (VPP_API_TEST_BUILTIN==0)
21616 char *save_current_file;
21617 unformat_input_t save_input;
21618 jmp_buf save_jump_buf;
21619 u32 save_line_number;
21621 FILE *new_fp, *save_ifp;
21623 if (unformat (vam->input, "%s", &s))
21625 new_fp = fopen ((char *) s, "r");
21628 errmsg ("Couldn't open script file %s", s);
21635 errmsg ("Missing script name");
21639 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
21640 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
21641 save_ifp = vam->ifp;
21642 save_line_number = vam->input_line_number;
21643 save_current_file = (char *) vam->current_file;
21645 vam->input_line_number = 0;
21647 vam->current_file = s;
21650 clib_memcpy (&vam->input, &save_input, sizeof (save_input));
21651 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
21652 vam->ifp = save_ifp;
21653 vam->input_line_number = save_line_number;
21654 vam->current_file = (u8 *) save_current_file;
21659 clib_warning ("use the exec command...");
21665 echo (vat_main_t * vam)
21667 print (vam->ofp, "%v", vam->input->buffer);
21671 /* List of API message constructors, CLI names map to api_xxx */
21672 #define foreach_vpe_api_msg \
21673 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
21674 _(sw_interface_dump,"") \
21675 _(sw_interface_set_flags, \
21676 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
21677 _(sw_interface_add_del_address, \
21678 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
21679 _(sw_interface_set_rx_mode, \
21680 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
21681 _(sw_interface_set_rx_placement, \
21682 "<intfc> | sw_if_index <id> [queue <id>] [worker <id> | main]") \
21683 _(sw_interface_rx_placement_dump, \
21684 "[<intfc> | sw_if_index <id>]") \
21685 _(sw_interface_set_table, \
21686 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
21687 _(sw_interface_set_mpls_enable, \
21688 "<intfc> | sw_if_index [disable | dis]") \
21689 _(sw_interface_set_vpath, \
21690 "<intfc> | sw_if_index <id> enable | disable") \
21691 _(sw_interface_set_vxlan_bypass, \
21692 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
21693 _(sw_interface_set_geneve_bypass, \
21694 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
21695 _(sw_interface_set_l2_xconnect, \
21696 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
21697 "enable | disable") \
21698 _(sw_interface_set_l2_bridge, \
21699 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
21700 "[shg <split-horizon-group>] [bvi]\n" \
21701 "enable | disable") \
21702 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
21703 _(bridge_domain_add_del, \
21704 "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") \
21705 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
21707 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
21708 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
21709 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
21711 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
21713 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
21715 "id <num> [hw-addr <mac-addr>] [host-ns <name>] [rx-ring-size <num> [tx-ring-size <num>] [host-mtu-size <mtu>] [gso | no-gso]") \
21717 "<vpp-if-name> | sw_if_index <id>") \
21718 _(sw_interface_tap_v2_dump, "") \
21719 _(virtio_pci_create, \
21720 "pci-addr <pci-address> [use_random_mac | hw-addr <mac-addr>] [features <hex-value>] [gso-enabled]") \
21721 _(virtio_pci_delete, \
21722 "<vpp-if-name> | sw_if_index <id>") \
21723 _(sw_interface_virtio_pci_dump, "") \
21725 "[hw-addr <mac-addr>] {round-robin | active-backup | " \
21726 "broadcast | {lacp | xor} [load-balance { l2 | l23 | l34 }]} " \
21729 "<vpp-if-name> | sw_if_index <id>") \
21731 "sw_if_index <n> bond <sw_if_index> [is_passive] [is_long_timeout]") \
21732 _(bond_detach_slave, \
21733 "sw_if_index <n>") \
21734 _(sw_interface_bond_dump, "") \
21735 _(sw_interface_slave_dump, \
21736 "<vpp-if-name> | sw_if_index <id>") \
21737 _(ip_table_add_del, \
21738 "table <n> [ipv6] [add | del]\n") \
21739 _(ip_route_add_del, \
21740 "<addr>/<mask> via <<addr>|<intfc>|sw_if_index <id>|via-label <n>>\n" \
21741 "[table-id <n>] [<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n"\
21742 "[weight <n>] [drop] [local] [classify <n>] [out-label <n>]\n" \
21743 "[multipath] [count <n>] [del]") \
21744 _(ip_mroute_add_del, \
21745 "<src> <grp>/<mask> [table-id <n>]\n" \
21746 "[<intfc> | sw_if_index <id>] [local] [del]") \
21747 _(mpls_table_add_del, \
21748 "table <n> [add | del]\n") \
21749 _(mpls_route_add_del, \
21750 "<label> <eos> via <addr | next-hop-table <n> | via-label <n> |\n" \
21751 "lookup-ip4-table <n> | lookup-in-ip6-table <n> |\n" \
21752 "l2-input-on <intfc> | l2-input-on sw_if_index <id>>\n" \
21753 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>] [weight <n>]\n" \
21754 "[drop] [local] [classify <n>] [out-label <n>] [multipath]\n" \
21755 "[count <n>] [del]") \
21756 _(mpls_ip_bind_unbind, \
21757 "<label> <addr/len>") \
21758 _(mpls_tunnel_add_del, \
21759 "[add | del <intfc | sw_if_index <id>>] via <addr | via-label <n>>\n" \
21760 "[<intfc> | sw_if_index <id> | next-hop-table <id>]\n" \
21761 "[l2-only] [out-label <n>]") \
21762 _(sr_mpls_policy_add, \
21763 "bsid <id> [weight <n>] [spray] next <sid> [next <sid>]") \
21764 _(sr_mpls_policy_del, \
21766 _(bier_table_add_del, \
21767 "<label> <sub-domain> <set> <bsl> [del]") \
21768 _(bier_route_add_del, \
21769 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
21770 "[<intfc> | sw_if_index <id>]" \
21771 "[weight <n>] [del] [multipath]") \
21772 _(proxy_arp_add_del, \
21773 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
21774 _(proxy_arp_intfc_enable_disable, \
21775 "<intfc> | sw_if_index <id> enable | disable") \
21776 _(sw_interface_set_unnumbered, \
21777 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
21778 _(ip_neighbor_add_del, \
21779 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
21780 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
21781 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
21782 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
21783 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
21784 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
21785 "[outer_vlan_id_any][inner_vlan_id_any]") \
21786 _(reset_fib, "vrf <n> [ipv6]") \
21787 _(dhcp_proxy_config, \
21788 "svr <v46-address> src <v46-address>\n" \
21789 "rx_vrf_id <nn> server_vrf_id <nn> [del]") \
21790 _(dhcp_proxy_set_vss, \
21791 "tbl_id <n> [fib_id <n> oui <n> | vpn_ascii_id <text>] [ipv6] [del]") \
21792 _(dhcp_proxy_dump, "ip6") \
21793 _(dhcp_client_config, \
21794 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
21795 _(set_ip_flow_hash, \
21796 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
21797 _(sw_interface_ip6_enable_disable, \
21798 "<intfc> | sw_if_index <id> enable | disable") \
21799 _(ip6nd_proxy_add_del, \
21800 "<intfc> | sw_if_index <id> <ip6-address>") \
21801 _(ip6nd_proxy_dump, "") \
21802 _(sw_interface_ip6nd_ra_prefix, \
21803 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
21804 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
21805 "[nolink] [isno]") \
21806 _(sw_interface_ip6nd_ra_config, \
21807 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
21808 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
21809 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
21810 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
21811 _(l2_patch_add_del, \
21812 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
21813 "enable | disable") \
21814 _(sr_localsid_add_del, \
21815 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
21816 "fib-table <num> (end.psp) sw_if_index <num>") \
21817 _(classify_add_del_table, \
21818 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
21819 " [del] [del-chain] mask <mask-value>\n" \
21820 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
21821 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
21822 _(classify_add_del_session, \
21823 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
21824 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
21825 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
21826 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
21827 _(classify_set_interface_ip_table, \
21828 "<intfc> | sw_if_index <nn> table <nn>") \
21829 _(classify_set_interface_l2_tables, \
21830 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
21831 " [other-table <nn>]") \
21832 _(get_node_index, "node <node-name") \
21833 _(add_node_next, "node <node-name> next <next-node-name>") \
21834 _(l2tpv3_create_tunnel, \
21835 "client_address <ip6-addr> our_address <ip6-addr>\n" \
21836 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
21837 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
21838 _(l2tpv3_set_tunnel_cookies, \
21839 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
21840 "[new_remote_cookie <nn>]\n") \
21841 _(l2tpv3_interface_enable_disable, \
21842 "<intfc> | sw_if_index <nn> enable | disable") \
21843 _(l2tpv3_set_lookup_key, \
21844 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
21845 _(sw_if_l2tpv3_tunnel_dump, "") \
21846 _(vxlan_offload_rx, \
21847 "hw { <interface name> | hw_if_index <nn>} " \
21848 "rx { <vxlan tunnel name> | sw_if_index <nn> } [del]") \
21849 _(vxlan_add_del_tunnel, \
21850 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
21851 "{ <intfc> | mcast_sw_if_index <nn> } [instance <id>]}\n" \
21852 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
21853 _(geneve_add_del_tunnel, \
21854 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
21855 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
21856 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
21857 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
21858 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
21859 _(gre_tunnel_add_del, \
21860 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [instance <n>]\n" \
21861 "[teb | erspan <session-id>] [del]") \
21862 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
21863 _(l2_fib_clear_table, "") \
21864 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
21865 _(l2_interface_vlan_tag_rewrite, \
21866 "<intfc> | sw_if_index <nn> \n" \
21867 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
21868 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
21869 _(create_vhost_user_if, \
21870 "socket <filename> [server] [renumber <dev_instance>] " \
21871 "[disable_mrg_rxbuf] [disable_indirect_desc] [gso] " \
21872 "[mac <mac_address>]") \
21873 _(modify_vhost_user_if, \
21874 "<intfc> | sw_if_index <nn> socket <filename>\n" \
21875 "[server] [renumber <dev_instance>] [gso]") \
21876 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
21877 _(sw_interface_vhost_user_dump, "") \
21878 _(show_version, "") \
21879 _(show_threads, "") \
21880 _(vxlan_gpe_add_del_tunnel, \
21881 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
21882 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
21883 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
21884 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
21885 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
21886 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
21887 _(interface_name_renumber, \
21888 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
21889 _(input_acl_set_interface, \
21890 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
21891 " [l2-table <nn>] [del]") \
21892 _(ip_probe_neighbor, "(<intc> | sw_if_index <nn>) address <ip4|ip6-addr>") \
21893 _(ip_scan_neighbor_enable_disable, "[ip4|ip6|both|disable] [interval <n-min>]\n" \
21894 " [max-time <n-usec>] [max-update <n>] [delay <n-msec>] [stale <n-min>]") \
21895 _(want_ip4_arp_events, "address <ip4-address> [del]") \
21896 _(want_ip6_nd_events, "address <ip6-address> [del]") \
21897 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
21898 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
21899 _(ip_dump, "ipv4 | ipv6") \
21900 _(ipsec_spd_add_del, "spd_id <n> [del]") \
21901 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
21903 _(ipsec_sad_entry_add_del, "sad_id <n> spi <n> crypto_alg <alg>\n" \
21904 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
21905 " integ_alg <alg> integ_key <hex>") \
21906 _(ipsec_spd_entry_add_del, "spd_id <n> priority <n> action <action>\n" \
21907 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
21908 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
21909 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
21910 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
21911 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
21912 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
21913 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n" \
21914 " [instance <n>]") \
21915 _(ipsec_sa_dump, "[sa_id <n>]") \
21916 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
21917 _(delete_loopback,"sw_if_index <nn>") \
21918 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
21919 _(bd_ip_mac_flush, "bd_id <bridge-domain-id>") \
21920 _(bd_ip_mac_dump, "[bd_id] <bridge-domain-id>") \
21921 _(want_interface_events, "enable|disable") \
21922 _(get_first_msg_id, "client <name>") \
21923 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
21924 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
21925 "fib-id <nn> [ip4][ip6][default]") \
21926 _(get_node_graph, " ") \
21927 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
21928 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
21929 _(ioam_disable, "") \
21930 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
21931 " sw_if_index <sw_if_index> p <priority> " \
21932 "w <weight>] [del]") \
21933 _(one_add_del_locator, "locator-set <locator_name> " \
21934 "iface <intf> | sw_if_index <sw_if_index> " \
21935 "p <priority> w <weight> [del]") \
21936 _(one_add_del_local_eid,"vni <vni> eid " \
21937 "<ipv4|ipv6>/<prefix> | <L2 address> " \
21938 "locator-set <locator_name> [del]" \
21939 "[key-id sha1|sha256 secret-key <secret-key>]")\
21940 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
21941 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
21942 _(one_enable_disable, "enable|disable") \
21943 _(one_map_register_enable_disable, "enable|disable") \
21944 _(one_map_register_fallback_threshold, "<value>") \
21945 _(one_rloc_probe_enable_disable, "enable|disable") \
21946 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
21948 "rloc <locator> p <prio> " \
21949 "w <weight> [rloc <loc> ... ] " \
21950 "action <action> [del-all]") \
21951 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
21953 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
21954 _(one_use_petr, "ip-address> | disable") \
21955 _(one_map_request_mode, "src-dst|dst-only") \
21956 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
21957 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
21958 _(one_locator_set_dump, "[local | remote]") \
21959 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
21960 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
21961 "[local] | [remote]") \
21962 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
21963 _(one_ndp_bd_get, "") \
21964 _(one_ndp_entries_get, "bd <bridge-domain>") \
21965 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
21966 _(one_l2_arp_bd_get, "") \
21967 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
21968 _(one_stats_enable_disable, "enable|disable") \
21969 _(show_one_stats_enable_disable, "") \
21970 _(one_eid_table_vni_dump, "") \
21971 _(one_eid_table_map_dump, "l2|l3") \
21972 _(one_map_resolver_dump, "") \
21973 _(one_map_server_dump, "") \
21974 _(one_adjacencies_get, "vni <vni>") \
21975 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
21976 _(show_one_rloc_probe_state, "") \
21977 _(show_one_map_register_state, "") \
21978 _(show_one_status, "") \
21979 _(one_stats_dump, "") \
21980 _(one_stats_flush, "") \
21981 _(one_get_map_request_itr_rlocs, "") \
21982 _(one_map_register_set_ttl, "<ttl>") \
21983 _(one_set_transport_protocol, "udp|api") \
21984 _(one_get_transport_protocol, "") \
21985 _(one_enable_disable_xtr_mode, "enable|disable") \
21986 _(one_show_xtr_mode, "") \
21987 _(one_enable_disable_pitr_mode, "enable|disable") \
21988 _(one_show_pitr_mode, "") \
21989 _(one_enable_disable_petr_mode, "enable|disable") \
21990 _(one_show_petr_mode, "") \
21991 _(show_one_nsh_mapping, "") \
21992 _(show_one_pitr, "") \
21993 _(show_one_use_petr, "") \
21994 _(show_one_map_request_mode, "") \
21995 _(show_one_map_register_ttl, "") \
21996 _(show_one_map_register_fallback_threshold, "") \
21997 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
21998 " sw_if_index <sw_if_index> p <priority> " \
21999 "w <weight>] [del]") \
22000 _(lisp_add_del_locator, "locator-set <locator_name> " \
22001 "iface <intf> | sw_if_index <sw_if_index> " \
22002 "p <priority> w <weight> [del]") \
22003 _(lisp_add_del_local_eid,"vni <vni> eid " \
22004 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22005 "locator-set <locator_name> [del]" \
22006 "[key-id sha1|sha256 secret-key <secret-key>]") \
22007 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
22008 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
22009 _(lisp_enable_disable, "enable|disable") \
22010 _(lisp_map_register_enable_disable, "enable|disable") \
22011 _(lisp_rloc_probe_enable_disable, "enable|disable") \
22012 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22014 "rloc <locator> p <prio> " \
22015 "w <weight> [rloc <loc> ... ] " \
22016 "action <action> [del-all]") \
22017 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22019 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22020 _(lisp_use_petr, "<ip-address> | disable") \
22021 _(lisp_map_request_mode, "src-dst|dst-only") \
22022 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22023 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22024 _(lisp_locator_set_dump, "[local | remote]") \
22025 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
22026 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22027 "[local] | [remote]") \
22028 _(lisp_eid_table_vni_dump, "") \
22029 _(lisp_eid_table_map_dump, "l2|l3") \
22030 _(lisp_map_resolver_dump, "") \
22031 _(lisp_map_server_dump, "") \
22032 _(lisp_adjacencies_get, "vni <vni>") \
22033 _(gpe_fwd_entry_vnis_get, "") \
22034 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
22035 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
22036 "[table <table-id>]") \
22037 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
22038 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
22039 _(gpe_set_encap_mode, "lisp|vxlan") \
22040 _(gpe_get_encap_mode, "") \
22041 _(lisp_gpe_add_del_iface, "up|down") \
22042 _(lisp_gpe_enable_disable, "enable|disable") \
22043 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
22044 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
22045 _(show_lisp_rloc_probe_state, "") \
22046 _(show_lisp_map_register_state, "") \
22047 _(show_lisp_status, "") \
22048 _(lisp_get_map_request_itr_rlocs, "") \
22049 _(show_lisp_pitr, "") \
22050 _(show_lisp_use_petr, "") \
22051 _(show_lisp_map_request_mode, "") \
22052 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
22053 _(af_packet_delete, "name <host interface name>") \
22054 _(af_packet_dump, "") \
22055 _(policer_add_del, "name <policer name> <params> [del]") \
22056 _(policer_dump, "[name <policer name>]") \
22057 _(policer_classify_set_interface, \
22058 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22059 " [l2-table <nn>] [del]") \
22060 _(policer_classify_dump, "type [ip4|ip6|l2]") \
22061 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
22062 "[master|slave]") \
22063 _(netmap_delete, "name <interface name>") \
22064 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
22065 _(mpls_table_dump, "") \
22066 _(mpls_route_dump, "table-id <ID>") \
22067 _(classify_table_ids, "") \
22068 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
22069 _(classify_table_info, "table_id <nn>") \
22070 _(classify_session_dump, "table_id <nn>") \
22071 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
22072 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
22073 "[template_interval <nn>] [udp_checksum]") \
22074 _(ipfix_exporter_dump, "") \
22075 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
22076 _(ipfix_classify_stream_dump, "") \
22077 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
22078 _(ipfix_classify_table_dump, "") \
22079 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
22080 _(sw_interface_span_dump, "[l2]") \
22081 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
22082 _(pg_create_interface, "if_id <nn> [gso-enabled gso-size <size>]") \
22083 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
22084 _(pg_enable_disable, "[stream <id>] disable") \
22085 _(ip_source_and_port_range_check_add_del, \
22086 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
22087 _(ip_source_and_port_range_check_interface_add_del, \
22088 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
22089 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
22090 _(delete_subif,"<intfc> | sw_if_index <nn>") \
22091 _(l2_interface_pbb_tag_rewrite, \
22092 "<intfc> | sw_if_index <nn> \n" \
22093 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
22094 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
22095 _(set_punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
22096 _(flow_classify_set_interface, \
22097 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
22098 _(flow_classify_dump, "type [ip4|ip6]") \
22099 _(ip_table_dump, "") \
22100 _(ip_route_dump, "table-id [ip4|ip6]") \
22101 _(ip_mtable_dump, "") \
22102 _(ip_mroute_dump, "table-id [ip4|ip6]") \
22103 _(feature_enable_disable, "arc_name <arc_name> " \
22104 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
22105 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
22107 _(l2_xconnect_dump, "") \
22108 _(hw_interface_set_mtu, "<intfc> | hw_if_index <nn> mtu <nn>") \
22109 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
22110 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
22111 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
22112 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
22113 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
22114 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
22115 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
22116 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
22117 _(sock_init_shm, "size <nnn>") \
22118 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
22119 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
22120 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
22121 _(session_rules_dump, "") \
22122 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
22123 _(output_acl_set_interface, \
22124 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22125 " [l2-table <nn>] [del]") \
22126 _(qos_record_enable_disable, "<record-source> <intfc> | sw_if_index <id> [disable]")
22128 /* List of command functions, CLI names map directly to functions */
22129 #define foreach_cli_function \
22130 _(comment, "usage: comment <ignore-rest-of-line>") \
22131 _(dump_interface_table, "usage: dump_interface_table") \
22132 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
22133 _(dump_ipv4_table, "usage: dump_ipv4_table") \
22134 _(dump_ipv6_table, "usage: dump_ipv6_table") \
22135 _(dump_macro_table, "usage: dump_macro_table ") \
22136 _(dump_node_table, "usage: dump_node_table") \
22137 _(dump_msg_api_table, "usage: dump_msg_api_table") \
22138 _(elog_setup, "usage: elog_setup [nevents, default 128K]") \
22139 _(elog_disable, "usage: elog_disable") \
22140 _(elog_enable, "usage: elog_enable") \
22141 _(elog_save, "usage: elog_save <filename>") \
22142 _(get_msg_id, "usage: get_msg_id name_and_crc") \
22143 _(echo, "usage: echo <message>") \
22144 _(exec, "usage: exec <vpe-debug-CLI-command>") \
22145 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
22146 _(help, "usage: help") \
22147 _(q, "usage: quit") \
22148 _(quit, "usage: quit") \
22149 _(search_node_table, "usage: search_node_table <name>...") \
22150 _(set, "usage: set <variable-name> <value>") \
22151 _(script, "usage: script <file-name>") \
22152 _(statseg, "usage: statseg") \
22153 _(unset, "usage: unset <variable-name>")
22156 static void vl_api_##n##_t_handler_uni \
22157 (vl_api_##n##_t * mp) \
22159 vat_main_t * vam = &vat_main; \
22160 if (vam->json_output) { \
22161 vl_api_##n##_t_handler_json(mp); \
22163 vl_api_##n##_t_handler(mp); \
22166 foreach_vpe_api_reply_msg;
22167 #if VPP_API_TEST_BUILTIN == 0
22168 foreach_standalone_reply_msg;
22173 vat_api_hookup (vat_main_t * vam)
22176 vl_msg_api_set_handlers(VL_API_##N, #n, \
22177 vl_api_##n##_t_handler_uni, \
22179 vl_api_##n##_t_endian, \
22180 vl_api_##n##_t_print, \
22181 sizeof(vl_api_##n##_t), 1);
22182 foreach_vpe_api_reply_msg;
22183 #if VPP_API_TEST_BUILTIN == 0
22184 foreach_standalone_reply_msg;
22188 #if (VPP_API_TEST_BUILTIN==0)
22189 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
22191 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
22193 vam->function_by_name = hash_create_string (0, sizeof (uword));
22195 vam->help_by_name = hash_create_string (0, sizeof (uword));
22198 /* API messages we can send */
22199 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
22200 foreach_vpe_api_msg;
22204 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
22205 foreach_vpe_api_msg;
22208 /* CLI functions */
22209 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
22210 foreach_cli_function;
22214 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
22215 foreach_cli_function;
22219 #if VPP_API_TEST_BUILTIN
22220 static clib_error_t *
22221 vat_api_hookup_shim (vlib_main_t * vm)
22223 vat_api_hookup (&vat_main);
22227 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
22231 * fd.io coding-style-patch-verification: ON
22234 * eval: (c-set-style "gnu")