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",
978 vl_api_from_api_string (&mp->interface_name), 0);
980 hash_set_mem (vam->sw_if_index_by_interface_name, s,
981 ntohl (mp->sw_if_index));
983 /* In sub interface case, fill the sub interface table entry */
984 if (mp->sw_if_index != mp->sup_sw_if_index)
986 sw_interface_subif_t *sub = NULL;
988 vec_add2 (vam->sw_if_subif_table, sub, 1);
990 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
991 strncpy ((char *) sub->interface_name, (char *) s,
992 vec_len (sub->interface_name));
993 sub->sw_if_index = ntohl (mp->sw_if_index);
994 sub->sub_id = ntohl (mp->sub_id);
996 sub->raw_flags = ntohl (mp->sub_if_flags & SUB_IF_API_FLAG_MASK_VNET);
998 sub->sub_number_of_tags = mp->sub_number_of_tags;
999 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
1000 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
1002 /* vlan tag rewrite */
1003 sub->vtr_op = ntohl (mp->vtr_op);
1004 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
1005 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
1006 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
1010 static void vl_api_sw_interface_details_t_handler_json
1011 (vl_api_sw_interface_details_t * mp)
1013 vat_main_t *vam = &vat_main;
1014 vat_json_node_t *node = NULL;
1016 if (VAT_JSON_ARRAY != vam->json_tree.type)
1018 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1019 vat_json_init_array (&vam->json_tree);
1021 node = vat_json_array_add (&vam->json_tree);
1023 vat_json_init_object (node);
1024 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
1025 vat_json_object_add_uint (node, "sup_sw_if_index",
1026 ntohl (mp->sup_sw_if_index));
1027 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
1028 sizeof (mp->l2_address));
1029 vat_json_object_add_string_copy (node, "interface_name",
1030 mp->interface_name.buf);
1031 vat_json_object_add_uint (node, "flags", mp->flags);
1032 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
1033 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
1034 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
1035 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
1036 vat_json_object_add_uint (node, "sub_number_of_tags",
1037 mp->sub_number_of_tags);
1038 vat_json_object_add_uint (node, "sub_outer_vlan_id",
1039 ntohs (mp->sub_outer_vlan_id));
1040 vat_json_object_add_uint (node, "sub_inner_vlan_id",
1041 ntohs (mp->sub_inner_vlan_id));
1042 vat_json_object_add_uint (node, "sub_if_flags", ntohl (mp->sub_if_flags));
1043 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
1044 vat_json_object_add_uint (node, "vtr_push_dot1q",
1045 ntohl (mp->vtr_push_dot1q));
1046 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
1047 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
1048 if (ntohl (mp->sub_if_flags) & SUB_IF_API_FLAG_DOT1AH)
1050 vat_json_object_add_string_copy (node, "pbb_vtr_dmac",
1052 format_ethernet_address,
1054 vat_json_object_add_string_copy (node, "pbb_vtr_smac",
1056 format_ethernet_address,
1058 vat_json_object_add_uint (node, "pbb_vtr_b_vlanid", mp->b_vlanid);
1059 vat_json_object_add_uint (node, "pbb_vtr_i_sid", mp->i_sid);
1063 #if VPP_API_TEST_BUILTIN == 0
1064 static void vl_api_sw_interface_event_t_handler
1065 (vl_api_sw_interface_event_t * mp)
1067 vat_main_t *vam = &vat_main;
1068 if (vam->interface_event_display)
1069 errmsg ("interface flags: sw_if_index %d %s %s",
1070 ntohl (mp->sw_if_index),
1071 ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_ADMIN_UP) ?
1072 "admin-up" : "admin-down",
1073 ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_LINK_UP) ?
1074 "link-up" : "link-down");
1078 __clib_unused static void
1079 vl_api_sw_interface_event_t_handler_json (vl_api_sw_interface_event_t * mp)
1081 /* JSON output not supported */
1085 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
1087 vat_main_t *vam = &vat_main;
1088 i32 retval = ntohl (mp->retval);
1090 vam->retval = retval;
1091 vam->shmem_result = uword_to_pointer (mp->reply_in_shmem, u8 *);
1092 vam->result_ready = 1;
1096 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
1098 vat_main_t *vam = &vat_main;
1099 vat_json_node_t node;
1100 api_main_t *am = &api_main;
1104 vat_json_init_object (&node);
1105 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1106 vat_json_object_add_uint (&node, "reply_in_shmem",
1107 ntohl (mp->reply_in_shmem));
1108 /* Toss the shared-memory original... */
1109 pthread_mutex_lock (&am->vlib_rp->mutex);
1110 oldheap = svm_push_data_heap (am->vlib_rp);
1112 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
1115 svm_pop_heap (oldheap);
1116 pthread_mutex_unlock (&am->vlib_rp->mutex);
1118 vat_json_print (vam->ofp, &node);
1119 vat_json_free (&node);
1121 vam->retval = ntohl (mp->retval);
1122 vam->result_ready = 1;
1126 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
1128 vat_main_t *vam = &vat_main;
1129 i32 retval = ntohl (mp->retval);
1130 u32 length = vl_api_string_len (&mp->reply);
1132 vec_reset_length (vam->cmd_reply);
1134 vam->retval = retval;
1137 vec_validate (vam->cmd_reply, length);
1138 clib_memcpy ((char *) (vam->cmd_reply),
1139 vl_api_from_api_string (&mp->reply), length);
1140 vam->cmd_reply[length] = 0;
1142 vam->result_ready = 1;
1146 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
1148 vat_main_t *vam = &vat_main;
1149 vat_json_node_t node;
1151 vec_reset_length (vam->cmd_reply);
1153 vat_json_init_object (&node);
1154 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1155 vat_json_object_add_string_copy (&node, "reply",
1156 vl_api_from_api_string (&mp->reply));
1158 vat_json_print (vam->ofp, &node);
1159 vat_json_free (&node);
1161 vam->retval = ntohl (mp->retval);
1162 vam->result_ready = 1;
1165 static void vl_api_classify_add_del_table_reply_t_handler
1166 (vl_api_classify_add_del_table_reply_t * mp)
1168 vat_main_t *vam = &vat_main;
1169 i32 retval = ntohl (mp->retval);
1170 if (vam->async_mode)
1172 vam->async_errors += (retval < 0);
1176 vam->retval = retval;
1178 ((mp->new_table_index != 0xFFFFFFFF) ||
1179 (mp->skip_n_vectors != 0xFFFFFFFF) ||
1180 (mp->match_n_vectors != 0xFFFFFFFF)))
1182 * Note: this is just barely thread-safe, depends on
1183 * the main thread spinning waiting for an answer...
1185 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d",
1186 ntohl (mp->new_table_index),
1187 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
1188 vam->result_ready = 1;
1192 static void vl_api_classify_add_del_table_reply_t_handler_json
1193 (vl_api_classify_add_del_table_reply_t * mp)
1195 vat_main_t *vam = &vat_main;
1196 vat_json_node_t node;
1198 vat_json_init_object (&node);
1199 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1200 vat_json_object_add_uint (&node, "new_table_index",
1201 ntohl (mp->new_table_index));
1202 vat_json_object_add_uint (&node, "skip_n_vectors",
1203 ntohl (mp->skip_n_vectors));
1204 vat_json_object_add_uint (&node, "match_n_vectors",
1205 ntohl (mp->match_n_vectors));
1207 vat_json_print (vam->ofp, &node);
1208 vat_json_free (&node);
1210 vam->retval = ntohl (mp->retval);
1211 vam->result_ready = 1;
1214 static void vl_api_get_node_index_reply_t_handler
1215 (vl_api_get_node_index_reply_t * mp)
1217 vat_main_t *vam = &vat_main;
1218 i32 retval = ntohl (mp->retval);
1219 if (vam->async_mode)
1221 vam->async_errors += (retval < 0);
1225 vam->retval = retval;
1227 errmsg ("node index %d", ntohl (mp->node_index));
1228 vam->result_ready = 1;
1232 static void vl_api_get_node_index_reply_t_handler_json
1233 (vl_api_get_node_index_reply_t * mp)
1235 vat_main_t *vam = &vat_main;
1236 vat_json_node_t node;
1238 vat_json_init_object (&node);
1239 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1240 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1242 vat_json_print (vam->ofp, &node);
1243 vat_json_free (&node);
1245 vam->retval = ntohl (mp->retval);
1246 vam->result_ready = 1;
1249 static void vl_api_get_next_index_reply_t_handler
1250 (vl_api_get_next_index_reply_t * mp)
1252 vat_main_t *vam = &vat_main;
1253 i32 retval = ntohl (mp->retval);
1254 if (vam->async_mode)
1256 vam->async_errors += (retval < 0);
1260 vam->retval = retval;
1262 errmsg ("next node index %d", ntohl (mp->next_index));
1263 vam->result_ready = 1;
1267 static void vl_api_get_next_index_reply_t_handler_json
1268 (vl_api_get_next_index_reply_t * mp)
1270 vat_main_t *vam = &vat_main;
1271 vat_json_node_t node;
1273 vat_json_init_object (&node);
1274 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1275 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1277 vat_json_print (vam->ofp, &node);
1278 vat_json_free (&node);
1280 vam->retval = ntohl (mp->retval);
1281 vam->result_ready = 1;
1284 static void vl_api_add_node_next_reply_t_handler
1285 (vl_api_add_node_next_reply_t * mp)
1287 vat_main_t *vam = &vat_main;
1288 i32 retval = ntohl (mp->retval);
1289 if (vam->async_mode)
1291 vam->async_errors += (retval < 0);
1295 vam->retval = retval;
1297 errmsg ("next index %d", ntohl (mp->next_index));
1298 vam->result_ready = 1;
1302 static void vl_api_add_node_next_reply_t_handler_json
1303 (vl_api_add_node_next_reply_t * mp)
1305 vat_main_t *vam = &vat_main;
1306 vat_json_node_t node;
1308 vat_json_init_object (&node);
1309 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1310 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1312 vat_json_print (vam->ofp, &node);
1313 vat_json_free (&node);
1315 vam->retval = ntohl (mp->retval);
1316 vam->result_ready = 1;
1319 static void vl_api_show_version_reply_t_handler
1320 (vl_api_show_version_reply_t * mp)
1322 vat_main_t *vam = &vat_main;
1323 i32 retval = ntohl (mp->retval);
1328 char *p = (char *) &mp->program;
1330 s = vl_api_from_api_to_vec ((vl_api_string_t *) p);
1331 errmsg (" program: %v\n", s);
1335 vl_api_string_len ((vl_api_string_t *) p) + sizeof (vl_api_string_t);
1336 s = vl_api_from_api_to_vec ((vl_api_string_t *) p);
1337 errmsg (" version: %v\n", s);
1341 vl_api_string_len ((vl_api_string_t *) p) + sizeof (vl_api_string_t);
1342 s = vl_api_from_api_to_vec ((vl_api_string_t *) p);
1343 errmsg (" build date: %v\n", s);
1347 vl_api_string_len ((vl_api_string_t *) p) + sizeof (vl_api_string_t);
1348 s = vl_api_from_api_to_vec ((vl_api_string_t *) p);
1349 errmsg ("build directory: %v\n", s);
1352 vam->retval = retval;
1353 vam->result_ready = 1;
1356 static void vl_api_show_version_reply_t_handler_json
1357 (vl_api_show_version_reply_t * mp)
1359 vat_main_t *vam = &vat_main;
1360 vat_json_node_t node;
1362 vat_json_init_object (&node);
1363 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1364 char *p = (char *) &mp->program;
1365 vat_json_object_add_string_copy (&node, "program",
1366 vl_api_from_api_string ((vl_api_string_t *)
1368 p += vl_api_string_len ((vl_api_string_t *) p) + sizeof (u32);
1369 vat_json_object_add_string_copy (&node, "version",
1370 vl_api_from_api_string ((vl_api_string_t *)
1372 p += vl_api_string_len ((vl_api_string_t *) p) + sizeof (u32);
1373 vat_json_object_add_string_copy (&node, "build_date",
1374 vl_api_from_api_string ((vl_api_string_t *)
1376 p += vl_api_string_len ((vl_api_string_t *) p) + sizeof (u32);
1377 vat_json_object_add_string_copy (&node, "build_directory",
1378 vl_api_from_api_string ((vl_api_string_t *)
1381 vat_json_print (vam->ofp, &node);
1382 vat_json_free (&node);
1384 vam->retval = ntohl (mp->retval);
1385 vam->result_ready = 1;
1388 static void vl_api_show_threads_reply_t_handler
1389 (vl_api_show_threads_reply_t * mp)
1391 vat_main_t *vam = &vat_main;
1392 i32 retval = ntohl (mp->retval);
1396 count = ntohl (mp->count);
1398 for (i = 0; i < count; i++)
1400 "\n%-2d %-11s %-11s %-5d %-6d %-4d %-6d",
1401 ntohl (mp->thread_data[i].id), mp->thread_data[i].name,
1402 mp->thread_data[i].type, ntohl (mp->thread_data[i].pid),
1403 ntohl (mp->thread_data[i].cpu_id), ntohl (mp->thread_data[i].core),
1404 ntohl (mp->thread_data[i].cpu_socket));
1406 vam->retval = retval;
1407 vam->result_ready = 1;
1410 static void vl_api_show_threads_reply_t_handler_json
1411 (vl_api_show_threads_reply_t * mp)
1413 vat_main_t *vam = &vat_main;
1414 vat_json_node_t node;
1415 vl_api_thread_data_t *td;
1416 i32 retval = ntohl (mp->retval);
1420 count = ntohl (mp->count);
1422 vat_json_init_object (&node);
1423 vat_json_object_add_int (&node, "retval", retval);
1424 vat_json_object_add_uint (&node, "count", count);
1426 for (i = 0; i < count; i++)
1428 td = &mp->thread_data[i];
1429 vat_json_object_add_uint (&node, "id", ntohl (td->id));
1430 vat_json_object_add_string_copy (&node, "name", td->name);
1431 vat_json_object_add_string_copy (&node, "type", td->type);
1432 vat_json_object_add_uint (&node, "pid", ntohl (td->pid));
1433 vat_json_object_add_int (&node, "cpu_id", ntohl (td->cpu_id));
1434 vat_json_object_add_int (&node, "core", ntohl (td->id));
1435 vat_json_object_add_int (&node, "cpu_socket", ntohl (td->cpu_socket));
1438 vat_json_print (vam->ofp, &node);
1439 vat_json_free (&node);
1441 vam->retval = retval;
1442 vam->result_ready = 1;
1446 api_show_threads (vat_main_t * vam)
1448 vl_api_show_threads_t *mp;
1452 "\n%-2s %-11s %-11s %-5s %-6s %-4s %-6s",
1453 "ID", "Name", "Type", "LWP", "cpu_id", "Core", "Socket");
1455 M (SHOW_THREADS, mp);
1463 vl_api_ip4_arp_event_t_handler (vl_api_ip4_arp_event_t * mp)
1465 u32 sw_if_index = ntohl (mp->sw_if_index);
1466 errmsg ("arp %s event: pid %d address %U new mac %U sw_if_index %d\n",
1467 mp->mac_ip ? "mac/ip binding" : "address resolution",
1468 ntohl (mp->pid), format_ip4_address, mp->ip,
1469 format_vl_api_mac_address, &mp->mac, sw_if_index);
1473 vl_api_ip4_arp_event_t_handler_json (vl_api_ip4_arp_event_t * mp)
1475 /* JSON output not supported */
1479 vl_api_ip6_nd_event_t_handler (vl_api_ip6_nd_event_t * mp)
1481 u32 sw_if_index = ntohl (mp->sw_if_index);
1482 errmsg ("ip6 nd %s event: pid %d address %U new mac %U sw_if_index %d\n",
1483 mp->mac_ip ? "mac/ip binding" : "address resolution",
1484 ntohl (mp->pid), format_vl_api_ip6_address, mp->ip,
1485 format_vl_api_mac_address, mp->mac, sw_if_index);
1489 vl_api_ip6_nd_event_t_handler_json (vl_api_ip6_nd_event_t * mp)
1491 /* JSON output not supported */
1495 vl_api_l2_macs_event_t_handler (vl_api_l2_macs_event_t * mp)
1497 u32 n_macs = ntohl (mp->n_macs);
1498 errmsg ("L2MAC event received with pid %d cl-idx %d for %d macs: \n",
1499 ntohl (mp->pid), mp->client_index, n_macs);
1501 for (i = 0; i < n_macs; i++)
1503 vl_api_mac_entry_t *mac = &mp->mac[i];
1504 errmsg (" [%d] sw_if_index %d mac_addr %U action %d \n",
1505 i + 1, ntohl (mac->sw_if_index),
1506 format_ethernet_address, mac->mac_addr, mac->action);
1513 vl_api_l2_macs_event_t_handler_json (vl_api_l2_macs_event_t * mp)
1515 /* JSON output not supported */
1518 #define vl_api_bridge_domain_details_t_endian vl_noop_handler
1519 #define vl_api_bridge_domain_details_t_print vl_noop_handler
1522 * Special-case: build the bridge domain table, maintain
1523 * the next bd id vbl.
1525 static void vl_api_bridge_domain_details_t_handler
1526 (vl_api_bridge_domain_details_t * mp)
1528 vat_main_t *vam = &vat_main;
1529 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1532 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-6s %-3s",
1533 " ID", "LRN", "FWD", "FLD", "BVI", "UU-FWD", "#IF");
1535 print (vam->ofp, "%3d %3d %3d %3d %3d %6d %3d",
1536 ntohl (mp->bd_id), mp->learn, mp->forward,
1537 mp->flood, ntohl (mp->bvi_sw_if_index),
1538 ntohl (mp->uu_fwd_sw_if_index), n_sw_ifs);
1542 vl_api_bridge_domain_sw_if_t *sw_ifs;
1543 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG",
1546 sw_ifs = mp->sw_if_details;
1547 for (i = 0; i < n_sw_ifs; i++)
1553 sw_if_index = ntohl (sw_ifs->sw_if_index);
1556 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1558 if ((u32) p->value[0] == sw_if_index)
1560 sw_if_name = (u8 *)(p->key);
1565 print (vam->ofp, "%7d %3d %s", sw_if_index,
1566 sw_ifs->shg, sw_if_name ? (char *) sw_if_name :
1567 "sw_if_index not found!");
1574 static void vl_api_bridge_domain_details_t_handler_json
1575 (vl_api_bridge_domain_details_t * mp)
1577 vat_main_t *vam = &vat_main;
1578 vat_json_node_t *node, *array = NULL;
1579 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1581 if (VAT_JSON_ARRAY != vam->json_tree.type)
1583 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1584 vat_json_init_array (&vam->json_tree);
1586 node = vat_json_array_add (&vam->json_tree);
1588 vat_json_init_object (node);
1589 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1590 vat_json_object_add_uint (node, "flood", mp->flood);
1591 vat_json_object_add_uint (node, "forward", mp->forward);
1592 vat_json_object_add_uint (node, "learn", mp->learn);
1593 vat_json_object_add_uint (node, "bvi_sw_if_index",
1594 ntohl (mp->bvi_sw_if_index));
1595 vat_json_object_add_uint (node, "n_sw_ifs", n_sw_ifs);
1596 array = vat_json_object_add (node, "sw_if");
1597 vat_json_init_array (array);
1603 vl_api_bridge_domain_sw_if_t *sw_ifs;
1606 sw_ifs = mp->sw_if_details;
1607 for (i = 0; i < n_sw_ifs; i++)
1609 node = vat_json_array_add (array);
1610 vat_json_init_object (node);
1611 vat_json_object_add_uint (node, "sw_if_index",
1612 ntohl (sw_ifs->sw_if_index));
1613 vat_json_object_add_uint (node, "shg", sw_ifs->shg);
1619 static void vl_api_control_ping_reply_t_handler
1620 (vl_api_control_ping_reply_t * mp)
1622 vat_main_t *vam = &vat_main;
1623 i32 retval = ntohl (mp->retval);
1624 if (vam->async_mode)
1626 vam->async_errors += (retval < 0);
1630 vam->retval = retval;
1631 vam->result_ready = 1;
1633 if (vam->socket_client_main)
1634 vam->socket_client_main->control_pings_outstanding--;
1637 static void vl_api_control_ping_reply_t_handler_json
1638 (vl_api_control_ping_reply_t * mp)
1640 vat_main_t *vam = &vat_main;
1641 i32 retval = ntohl (mp->retval);
1643 if (VAT_JSON_NONE != vam->json_tree.type)
1645 vat_json_print (vam->ofp, &vam->json_tree);
1646 vat_json_free (&vam->json_tree);
1647 vam->json_tree.type = VAT_JSON_NONE;
1652 vat_json_init_array (&vam->json_tree);
1653 vat_json_print (vam->ofp, &vam->json_tree);
1654 vam->json_tree.type = VAT_JSON_NONE;
1657 vam->retval = retval;
1658 vam->result_ready = 1;
1662 vl_api_bridge_domain_set_mac_age_reply_t_handler
1663 (vl_api_bridge_domain_set_mac_age_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_bridge_domain_set_mac_age_reply_t_handler_json
1679 (vl_api_bridge_domain_set_mac_age_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));
1687 vat_json_print (vam->ofp, &node);
1688 vat_json_free (&node);
1690 vam->retval = ntohl (mp->retval);
1691 vam->result_ready = 1;
1695 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1697 vat_main_t *vam = &vat_main;
1698 i32 retval = ntohl (mp->retval);
1699 if (vam->async_mode)
1701 vam->async_errors += (retval < 0);
1705 vam->retval = retval;
1706 vam->result_ready = 1;
1710 static void vl_api_l2_flags_reply_t_handler_json
1711 (vl_api_l2_flags_reply_t * mp)
1713 vat_main_t *vam = &vat_main;
1714 vat_json_node_t node;
1716 vat_json_init_object (&node);
1717 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1718 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1719 ntohl (mp->resulting_feature_bitmap));
1721 vat_json_print (vam->ofp, &node);
1722 vat_json_free (&node);
1724 vam->retval = ntohl (mp->retval);
1725 vam->result_ready = 1;
1728 static void vl_api_bridge_flags_reply_t_handler
1729 (vl_api_bridge_flags_reply_t * mp)
1731 vat_main_t *vam = &vat_main;
1732 i32 retval = ntohl (mp->retval);
1733 if (vam->async_mode)
1735 vam->async_errors += (retval < 0);
1739 vam->retval = retval;
1740 vam->result_ready = 1;
1744 static void vl_api_bridge_flags_reply_t_handler_json
1745 (vl_api_bridge_flags_reply_t * mp)
1747 vat_main_t *vam = &vat_main;
1748 vat_json_node_t node;
1750 vat_json_init_object (&node);
1751 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1752 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1753 ntohl (mp->resulting_feature_bitmap));
1755 vat_json_print (vam->ofp, &node);
1756 vat_json_free (&node);
1758 vam->retval = ntohl (mp->retval);
1759 vam->result_ready = 1;
1763 vl_api_tap_create_v2_reply_t_handler (vl_api_tap_create_v2_reply_t * mp)
1765 vat_main_t *vam = &vat_main;
1766 i32 retval = ntohl (mp->retval);
1767 if (vam->async_mode)
1769 vam->async_errors += (retval < 0);
1773 vam->retval = retval;
1774 vam->sw_if_index = ntohl (mp->sw_if_index);
1775 vam->result_ready = 1;
1780 static void vl_api_tap_create_v2_reply_t_handler_json
1781 (vl_api_tap_create_v2_reply_t * mp)
1783 vat_main_t *vam = &vat_main;
1784 vat_json_node_t node;
1786 vat_json_init_object (&node);
1787 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1788 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1790 vat_json_print (vam->ofp, &node);
1791 vat_json_free (&node);
1793 vam->retval = ntohl (mp->retval);
1794 vam->result_ready = 1;
1799 vl_api_tap_delete_v2_reply_t_handler (vl_api_tap_delete_v2_reply_t * mp)
1801 vat_main_t *vam = &vat_main;
1802 i32 retval = ntohl (mp->retval);
1803 if (vam->async_mode)
1805 vam->async_errors += (retval < 0);
1809 vam->retval = retval;
1810 vam->result_ready = 1;
1814 static void vl_api_tap_delete_v2_reply_t_handler_json
1815 (vl_api_tap_delete_v2_reply_t * mp)
1817 vat_main_t *vam = &vat_main;
1818 vat_json_node_t node;
1820 vat_json_init_object (&node);
1821 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1823 vat_json_print (vam->ofp, &node);
1824 vat_json_free (&node);
1826 vam->retval = ntohl (mp->retval);
1827 vam->result_ready = 1;
1831 vl_api_virtio_pci_create_reply_t_handler (vl_api_virtio_pci_create_reply_t *
1834 vat_main_t *vam = &vat_main;
1835 i32 retval = ntohl (mp->retval);
1836 if (vam->async_mode)
1838 vam->async_errors += (retval < 0);
1842 vam->retval = retval;
1843 vam->sw_if_index = ntohl (mp->sw_if_index);
1844 vam->result_ready = 1;
1848 static void vl_api_virtio_pci_create_reply_t_handler_json
1849 (vl_api_virtio_pci_create_reply_t * mp)
1851 vat_main_t *vam = &vat_main;
1852 vat_json_node_t node;
1854 vat_json_init_object (&node);
1855 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1856 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1858 vat_json_print (vam->ofp, &node);
1859 vat_json_free (&node);
1861 vam->retval = ntohl (mp->retval);
1862 vam->result_ready = 1;
1867 vl_api_virtio_pci_delete_reply_t_handler (vl_api_virtio_pci_delete_reply_t *
1870 vat_main_t *vam = &vat_main;
1871 i32 retval = ntohl (mp->retval);
1872 if (vam->async_mode)
1874 vam->async_errors += (retval < 0);
1878 vam->retval = retval;
1879 vam->result_ready = 1;
1883 static void vl_api_virtio_pci_delete_reply_t_handler_json
1884 (vl_api_virtio_pci_delete_reply_t * mp)
1886 vat_main_t *vam = &vat_main;
1887 vat_json_node_t node;
1889 vat_json_init_object (&node);
1890 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1892 vat_json_print (vam->ofp, &node);
1893 vat_json_free (&node);
1895 vam->retval = ntohl (mp->retval);
1896 vam->result_ready = 1;
1900 vl_api_bond_create_reply_t_handler (vl_api_bond_create_reply_t * mp)
1902 vat_main_t *vam = &vat_main;
1903 i32 retval = ntohl (mp->retval);
1905 if (vam->async_mode)
1907 vam->async_errors += (retval < 0);
1911 vam->retval = retval;
1912 vam->sw_if_index = ntohl (mp->sw_if_index);
1913 vam->result_ready = 1;
1917 static void vl_api_bond_create_reply_t_handler_json
1918 (vl_api_bond_create_reply_t * mp)
1920 vat_main_t *vam = &vat_main;
1921 vat_json_node_t node;
1923 vat_json_init_object (&node);
1924 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1925 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1927 vat_json_print (vam->ofp, &node);
1928 vat_json_free (&node);
1930 vam->retval = ntohl (mp->retval);
1931 vam->result_ready = 1;
1935 vl_api_bond_delete_reply_t_handler (vl_api_bond_delete_reply_t * mp)
1937 vat_main_t *vam = &vat_main;
1938 i32 retval = ntohl (mp->retval);
1940 if (vam->async_mode)
1942 vam->async_errors += (retval < 0);
1946 vam->retval = retval;
1947 vam->result_ready = 1;
1951 static void vl_api_bond_delete_reply_t_handler_json
1952 (vl_api_bond_delete_reply_t * mp)
1954 vat_main_t *vam = &vat_main;
1955 vat_json_node_t node;
1957 vat_json_init_object (&node);
1958 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1960 vat_json_print (vam->ofp, &node);
1961 vat_json_free (&node);
1963 vam->retval = ntohl (mp->retval);
1964 vam->result_ready = 1;
1968 vl_api_bond_enslave_reply_t_handler (vl_api_bond_enslave_reply_t * mp)
1970 vat_main_t *vam = &vat_main;
1971 i32 retval = ntohl (mp->retval);
1973 if (vam->async_mode)
1975 vam->async_errors += (retval < 0);
1979 vam->retval = retval;
1980 vam->result_ready = 1;
1984 static void vl_api_bond_enslave_reply_t_handler_json
1985 (vl_api_bond_enslave_reply_t * mp)
1987 vat_main_t *vam = &vat_main;
1988 vat_json_node_t node;
1990 vat_json_init_object (&node);
1991 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1993 vat_json_print (vam->ofp, &node);
1994 vat_json_free (&node);
1996 vam->retval = ntohl (mp->retval);
1997 vam->result_ready = 1;
2001 vl_api_bond_detach_slave_reply_t_handler (vl_api_bond_detach_slave_reply_t *
2004 vat_main_t *vam = &vat_main;
2005 i32 retval = ntohl (mp->retval);
2007 if (vam->async_mode)
2009 vam->async_errors += (retval < 0);
2013 vam->retval = retval;
2014 vam->result_ready = 1;
2018 static void vl_api_bond_detach_slave_reply_t_handler_json
2019 (vl_api_bond_detach_slave_reply_t * mp)
2021 vat_main_t *vam = &vat_main;
2022 vat_json_node_t node;
2024 vat_json_init_object (&node);
2025 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2027 vat_json_print (vam->ofp, &node);
2028 vat_json_free (&node);
2030 vam->retval = ntohl (mp->retval);
2031 vam->result_ready = 1;
2034 static void vl_api_sw_interface_bond_details_t_handler
2035 (vl_api_sw_interface_bond_details_t * mp)
2037 vat_main_t *vam = &vat_main;
2040 "%-16s %-12d %-12U %-13U %-14u %-14u",
2041 mp->interface_name, ntohl (mp->sw_if_index),
2042 format_bond_mode, mp->mode, format_bond_load_balance, mp->lb,
2043 ntohl (mp->active_slaves), ntohl (mp->slaves));
2046 static void vl_api_sw_interface_bond_details_t_handler_json
2047 (vl_api_sw_interface_bond_details_t * mp)
2049 vat_main_t *vam = &vat_main;
2050 vat_json_node_t *node = NULL;
2052 if (VAT_JSON_ARRAY != vam->json_tree.type)
2054 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2055 vat_json_init_array (&vam->json_tree);
2057 node = vat_json_array_add (&vam->json_tree);
2059 vat_json_init_object (node);
2060 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2061 vat_json_object_add_string_copy (node, "interface_name",
2062 mp->interface_name);
2063 vat_json_object_add_uint (node, "mode", mp->mode);
2064 vat_json_object_add_uint (node, "load_balance", mp->lb);
2065 vat_json_object_add_uint (node, "active_slaves", ntohl (mp->active_slaves));
2066 vat_json_object_add_uint (node, "slaves", ntohl (mp->slaves));
2070 api_sw_interface_bond_dump (vat_main_t * vam)
2072 vl_api_sw_interface_bond_dump_t *mp;
2073 vl_api_control_ping_t *mp_ping;
2077 "\n%-16s %-12s %-12s %-13s %-14s %-14s",
2078 "interface name", "sw_if_index", "mode", "load balance",
2079 "active slaves", "slaves");
2081 /* Get list of bond interfaces */
2082 M (SW_INTERFACE_BOND_DUMP, mp);
2085 /* Use a control ping for synchronization */
2086 MPING (CONTROL_PING, mp_ping);
2093 static void vl_api_sw_interface_slave_details_t_handler
2094 (vl_api_sw_interface_slave_details_t * mp)
2096 vat_main_t *vam = &vat_main;
2099 "%-25s %-12d %-12d %d", mp->interface_name,
2100 ntohl (mp->sw_if_index), mp->is_passive, mp->is_long_timeout);
2103 static void vl_api_sw_interface_slave_details_t_handler_json
2104 (vl_api_sw_interface_slave_details_t * mp)
2106 vat_main_t *vam = &vat_main;
2107 vat_json_node_t *node = NULL;
2109 if (VAT_JSON_ARRAY != vam->json_tree.type)
2111 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2112 vat_json_init_array (&vam->json_tree);
2114 node = vat_json_array_add (&vam->json_tree);
2116 vat_json_init_object (node);
2117 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2118 vat_json_object_add_string_copy (node, "interface_name",
2119 mp->interface_name);
2120 vat_json_object_add_uint (node, "passive", mp->is_passive);
2121 vat_json_object_add_uint (node, "long_timeout", mp->is_long_timeout);
2125 api_sw_interface_slave_dump (vat_main_t * vam)
2127 unformat_input_t *i = vam->input;
2128 vl_api_sw_interface_slave_dump_t *mp;
2129 vl_api_control_ping_t *mp_ping;
2130 u32 sw_if_index = ~0;
2131 u8 sw_if_index_set = 0;
2134 /* Parse args required to build the message */
2135 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2137 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2138 sw_if_index_set = 1;
2139 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2140 sw_if_index_set = 1;
2145 if (sw_if_index_set == 0)
2147 errmsg ("missing vpp interface name. ");
2152 "\n%-25s %-12s %-12s %s",
2153 "slave interface name", "sw_if_index", "passive", "long_timeout");
2155 /* Get list of bond interfaces */
2156 M (SW_INTERFACE_SLAVE_DUMP, mp);
2157 mp->sw_if_index = ntohl (sw_if_index);
2160 /* Use a control ping for synchronization */
2161 MPING (CONTROL_PING, mp_ping);
2168 static void vl_api_mpls_tunnel_add_del_reply_t_handler
2169 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2171 vat_main_t *vam = &vat_main;
2172 i32 retval = ntohl (mp->retval);
2173 if (vam->async_mode)
2175 vam->async_errors += (retval < 0);
2179 vam->retval = retval;
2180 vam->sw_if_index = ntohl (mp->sw_if_index);
2181 vam->result_ready = 1;
2183 vam->regenerate_interface_table = 1;
2186 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
2187 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2189 vat_main_t *vam = &vat_main;
2190 vat_json_node_t node;
2192 vat_json_init_object (&node);
2193 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2194 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
2195 ntohl (mp->sw_if_index));
2197 vat_json_print (vam->ofp, &node);
2198 vat_json_free (&node);
2200 vam->retval = ntohl (mp->retval);
2201 vam->result_ready = 1;
2204 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
2205 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2207 vat_main_t *vam = &vat_main;
2208 i32 retval = ntohl (mp->retval);
2209 if (vam->async_mode)
2211 vam->async_errors += (retval < 0);
2215 vam->retval = retval;
2216 vam->sw_if_index = ntohl (mp->sw_if_index);
2217 vam->result_ready = 1;
2221 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
2222 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2224 vat_main_t *vam = &vat_main;
2225 vat_json_node_t node;
2227 vat_json_init_object (&node);
2228 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2229 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2231 vat_json_print (vam->ofp, &node);
2232 vat_json_free (&node);
2234 vam->retval = ntohl (mp->retval);
2235 vam->result_ready = 1;
2238 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler
2239 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2241 vat_main_t *vam = &vat_main;
2242 i32 retval = ntohl (mp->retval);
2243 if (vam->async_mode)
2245 vam->async_errors += (retval < 0);
2249 vam->retval = retval;
2250 vam->result_ready = 1;
2254 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler_json
2255 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2257 vat_main_t *vam = &vat_main;
2258 vat_json_node_t node;
2260 vat_json_init_object (&node);
2261 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2262 vat_json_object_add_uint (&node, "fwd_entry_index",
2263 clib_net_to_host_u32 (mp->fwd_entry_index));
2265 vat_json_print (vam->ofp, &node);
2266 vat_json_free (&node);
2268 vam->retval = ntohl (mp->retval);
2269 vam->result_ready = 1;
2273 format_lisp_transport_protocol (u8 * s, va_list * args)
2275 u32 proto = va_arg (*args, u32);
2280 return format (s, "udp");
2282 return format (s, "api");
2289 static void vl_api_one_get_transport_protocol_reply_t_handler
2290 (vl_api_one_get_transport_protocol_reply_t * mp)
2292 vat_main_t *vam = &vat_main;
2293 i32 retval = ntohl (mp->retval);
2294 if (vam->async_mode)
2296 vam->async_errors += (retval < 0);
2300 u32 proto = mp->protocol;
2301 print (vam->ofp, "Transport protocol: %U",
2302 format_lisp_transport_protocol, proto);
2303 vam->retval = retval;
2304 vam->result_ready = 1;
2308 static void vl_api_one_get_transport_protocol_reply_t_handler_json
2309 (vl_api_one_get_transport_protocol_reply_t * mp)
2311 vat_main_t *vam = &vat_main;
2312 vat_json_node_t node;
2315 s = format (0, "%U", format_lisp_transport_protocol, mp->protocol);
2318 vat_json_init_object (&node);
2319 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2320 vat_json_object_add_string_copy (&node, "transport-protocol", s);
2323 vat_json_print (vam->ofp, &node);
2324 vat_json_free (&node);
2326 vam->retval = ntohl (mp->retval);
2327 vam->result_ready = 1;
2330 static void vl_api_one_add_del_locator_set_reply_t_handler
2331 (vl_api_one_add_del_locator_set_reply_t * mp)
2333 vat_main_t *vam = &vat_main;
2334 i32 retval = ntohl (mp->retval);
2335 if (vam->async_mode)
2337 vam->async_errors += (retval < 0);
2341 vam->retval = retval;
2342 vam->result_ready = 1;
2346 static void vl_api_one_add_del_locator_set_reply_t_handler_json
2347 (vl_api_one_add_del_locator_set_reply_t * mp)
2349 vat_main_t *vam = &vat_main;
2350 vat_json_node_t node;
2352 vat_json_init_object (&node);
2353 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2354 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
2356 vat_json_print (vam->ofp, &node);
2357 vat_json_free (&node);
2359 vam->retval = ntohl (mp->retval);
2360 vam->result_ready = 1;
2363 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
2364 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2366 vat_main_t *vam = &vat_main;
2367 i32 retval = ntohl (mp->retval);
2368 if (vam->async_mode)
2370 vam->async_errors += (retval < 0);
2374 vam->retval = retval;
2375 vam->sw_if_index = ntohl (mp->sw_if_index);
2376 vam->result_ready = 1;
2378 vam->regenerate_interface_table = 1;
2381 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
2382 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2384 vat_main_t *vam = &vat_main;
2385 vat_json_node_t node;
2387 vat_json_init_object (&node);
2388 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2389 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
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_vxlan_offload_rx_reply_t_handler
2399 (vl_api_vxlan_offload_rx_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->result_ready = 1;
2414 static void vl_api_vxlan_offload_rx_reply_t_handler_json
2415 (vl_api_vxlan_offload_rx_reply_t * mp)
2417 vat_main_t *vam = &vat_main;
2418 vat_json_node_t node;
2420 vat_json_init_object (&node);
2421 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2423 vat_json_print (vam->ofp, &node);
2424 vat_json_free (&node);
2426 vam->retval = ntohl (mp->retval);
2427 vam->result_ready = 1;
2430 static void vl_api_geneve_add_del_tunnel_reply_t_handler
2431 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2433 vat_main_t *vam = &vat_main;
2434 i32 retval = ntohl (mp->retval);
2435 if (vam->async_mode)
2437 vam->async_errors += (retval < 0);
2441 vam->retval = retval;
2442 vam->sw_if_index = ntohl (mp->sw_if_index);
2443 vam->result_ready = 1;
2447 static void vl_api_geneve_add_del_tunnel_reply_t_handler_json
2448 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2450 vat_main_t *vam = &vat_main;
2451 vat_json_node_t node;
2453 vat_json_init_object (&node);
2454 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2455 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2457 vat_json_print (vam->ofp, &node);
2458 vat_json_free (&node);
2460 vam->retval = ntohl (mp->retval);
2461 vam->result_ready = 1;
2464 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler
2465 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2467 vat_main_t *vam = &vat_main;
2468 i32 retval = ntohl (mp->retval);
2469 if (vam->async_mode)
2471 vam->async_errors += (retval < 0);
2475 vam->retval = retval;
2476 vam->sw_if_index = ntohl (mp->sw_if_index);
2477 vam->result_ready = 1;
2479 vam->regenerate_interface_table = 1;
2482 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler_json
2483 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2485 vat_main_t *vam = &vat_main;
2486 vat_json_node_t node;
2488 vat_json_init_object (&node);
2489 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2490 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2492 vat_json_print (vam->ofp, &node);
2493 vat_json_free (&node);
2495 vam->retval = ntohl (mp->retval);
2496 vam->result_ready = 1;
2499 static void vl_api_gre_tunnel_add_del_reply_t_handler
2500 (vl_api_gre_tunnel_add_del_reply_t * mp)
2502 vat_main_t *vam = &vat_main;
2503 i32 retval = ntohl (mp->retval);
2504 if (vam->async_mode)
2506 vam->async_errors += (retval < 0);
2510 vam->retval = retval;
2511 vam->sw_if_index = ntohl (mp->sw_if_index);
2512 vam->result_ready = 1;
2516 static void vl_api_gre_tunnel_add_del_reply_t_handler_json
2517 (vl_api_gre_tunnel_add_del_reply_t * mp)
2519 vat_main_t *vam = &vat_main;
2520 vat_json_node_t node;
2522 vat_json_init_object (&node);
2523 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2524 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2526 vat_json_print (vam->ofp, &node);
2527 vat_json_free (&node);
2529 vam->retval = ntohl (mp->retval);
2530 vam->result_ready = 1;
2533 static void vl_api_create_vhost_user_if_reply_t_handler
2534 (vl_api_create_vhost_user_if_reply_t * mp)
2536 vat_main_t *vam = &vat_main;
2537 i32 retval = ntohl (mp->retval);
2538 if (vam->async_mode)
2540 vam->async_errors += (retval < 0);
2544 vam->retval = retval;
2545 vam->sw_if_index = ntohl (mp->sw_if_index);
2546 vam->result_ready = 1;
2548 vam->regenerate_interface_table = 1;
2551 static void vl_api_create_vhost_user_if_reply_t_handler_json
2552 (vl_api_create_vhost_user_if_reply_t * mp)
2554 vat_main_t *vam = &vat_main;
2555 vat_json_node_t node;
2557 vat_json_init_object (&node);
2558 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2559 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2561 vat_json_print (vam->ofp, &node);
2562 vat_json_free (&node);
2564 vam->retval = ntohl (mp->retval);
2565 vam->result_ready = 1;
2568 static void vl_api_dns_resolve_name_reply_t_handler
2569 (vl_api_dns_resolve_name_reply_t * mp)
2571 vat_main_t *vam = &vat_main;
2572 i32 retval = ntohl (mp->retval);
2573 if (vam->async_mode)
2575 vam->async_errors += (retval < 0);
2579 vam->retval = retval;
2580 vam->result_ready = 1;
2585 clib_warning ("ip4 address %U", format_ip4_address,
2586 (ip4_address_t *) mp->ip4_address);
2588 clib_warning ("ip6 address %U", format_ip6_address,
2589 (ip6_address_t *) mp->ip6_address);
2592 clib_warning ("retval %d", retval);
2596 static void vl_api_dns_resolve_name_reply_t_handler_json
2597 (vl_api_dns_resolve_name_reply_t * mp)
2599 clib_warning ("not implemented");
2602 static void vl_api_dns_resolve_ip_reply_t_handler
2603 (vl_api_dns_resolve_ip_reply_t * mp)
2605 vat_main_t *vam = &vat_main;
2606 i32 retval = ntohl (mp->retval);
2607 if (vam->async_mode)
2609 vam->async_errors += (retval < 0);
2613 vam->retval = retval;
2614 vam->result_ready = 1;
2618 clib_warning ("canonical name %s", mp->name);
2621 clib_warning ("retval %d", retval);
2625 static void vl_api_dns_resolve_ip_reply_t_handler_json
2626 (vl_api_dns_resolve_ip_reply_t * mp)
2628 clib_warning ("not implemented");
2632 static void vl_api_ip_address_details_t_handler
2633 (vl_api_ip_address_details_t * mp)
2635 vat_main_t *vam = &vat_main;
2636 static ip_address_details_t empty_ip_address_details = { {0} };
2637 ip_address_details_t *address = NULL;
2638 ip_details_t *current_ip_details = NULL;
2639 ip_details_t *details = NULL;
2641 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
2643 if (!details || vam->current_sw_if_index >= vec_len (details)
2644 || !details[vam->current_sw_if_index].present)
2646 errmsg ("ip address details arrived but not stored");
2647 errmsg ("ip_dump should be called first");
2651 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
2653 #define addresses (current_ip_details->addr)
2655 vec_validate_init_empty (addresses, vec_len (addresses),
2656 empty_ip_address_details);
2658 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
2660 clib_memcpy (&address->ip, &mp->prefix.address.un, sizeof (address->ip));
2661 address->prefix_length = mp->prefix.len;
2665 static void vl_api_ip_address_details_t_handler_json
2666 (vl_api_ip_address_details_t * mp)
2668 vat_main_t *vam = &vat_main;
2669 vat_json_node_t *node = NULL;
2671 if (VAT_JSON_ARRAY != vam->json_tree.type)
2673 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2674 vat_json_init_array (&vam->json_tree);
2676 node = vat_json_array_add (&vam->json_tree);
2678 vat_json_init_object (node);
2679 vat_json_object_add_prefix (node, &mp->prefix);
2683 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
2685 vat_main_t *vam = &vat_main;
2686 static ip_details_t empty_ip_details = { 0 };
2687 ip_details_t *ip = NULL;
2688 u32 sw_if_index = ~0;
2690 sw_if_index = ntohl (mp->sw_if_index);
2692 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2693 sw_if_index, empty_ip_details);
2695 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2702 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
2704 vat_main_t *vam = &vat_main;
2706 if (VAT_JSON_ARRAY != vam->json_tree.type)
2708 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2709 vat_json_init_array (&vam->json_tree);
2711 vat_json_array_add_uint (&vam->json_tree,
2712 clib_net_to_host_u32 (mp->sw_if_index));
2716 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
2720 s = format (0, "DHCP compl event: pid %d %s hostname %s host_addr %U "
2721 "host_mac %U router_addr %U",
2722 ntohl (mp->pid), mp->lease.is_ipv6 ? "ipv6" : "ipv4",
2724 format_ip4_address, mp->lease.host_address,
2725 format_ethernet_address, mp->lease.host_mac,
2726 format_ip4_address, mp->lease.router_address);
2728 for (i = 0; i < mp->lease.count; i++)
2730 format (s, " domain_server_addr %U", format_ip4_address,
2731 mp->lease.domain_server[i].address);
2733 errmsg ((char *) s);
2737 static void vl_api_dhcp_compl_event_t_handler_json
2738 (vl_api_dhcp_compl_event_t * mp)
2740 /* JSON output not supported */
2743 static void vl_api_get_first_msg_id_reply_t_handler
2744 (vl_api_get_first_msg_id_reply_t * mp)
2746 vat_main_t *vam = &vat_main;
2747 i32 retval = ntohl (mp->retval);
2749 if (vam->async_mode)
2751 vam->async_errors += (retval < 0);
2755 vam->retval = retval;
2756 vam->result_ready = 1;
2760 errmsg ("first message id %d", ntohs (mp->first_msg_id));
2764 static void vl_api_get_first_msg_id_reply_t_handler_json
2765 (vl_api_get_first_msg_id_reply_t * mp)
2767 vat_main_t *vam = &vat_main;
2768 vat_json_node_t node;
2770 vat_json_init_object (&node);
2771 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2772 vat_json_object_add_uint (&node, "first_msg_id",
2773 (uint) ntohs (mp->first_msg_id));
2775 vat_json_print (vam->ofp, &node);
2776 vat_json_free (&node);
2778 vam->retval = ntohl (mp->retval);
2779 vam->result_ready = 1;
2782 static void vl_api_get_node_graph_reply_t_handler
2783 (vl_api_get_node_graph_reply_t * mp)
2785 vat_main_t *vam = &vat_main;
2786 api_main_t *am = &api_main;
2787 i32 retval = ntohl (mp->retval);
2788 u8 *pvt_copy, *reply;
2793 if (vam->async_mode)
2795 vam->async_errors += (retval < 0);
2799 vam->retval = retval;
2800 vam->result_ready = 1;
2803 /* "Should never happen..." */
2807 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2808 pvt_copy = vec_dup (reply);
2810 /* Toss the shared-memory original... */
2811 pthread_mutex_lock (&am->vlib_rp->mutex);
2812 oldheap = svm_push_data_heap (am->vlib_rp);
2816 svm_pop_heap (oldheap);
2817 pthread_mutex_unlock (&am->vlib_rp->mutex);
2819 if (vam->graph_nodes)
2821 hash_free (vam->graph_node_index_by_name);
2823 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2825 node = vam->graph_nodes[0][i];
2826 vec_free (node->name);
2827 vec_free (node->next_nodes);
2830 vec_free (vam->graph_nodes[0]);
2831 vec_free (vam->graph_nodes);
2834 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2835 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2836 vec_free (pvt_copy);
2838 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2840 node = vam->graph_nodes[0][i];
2841 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2845 static void vl_api_get_node_graph_reply_t_handler_json
2846 (vl_api_get_node_graph_reply_t * mp)
2848 vat_main_t *vam = &vat_main;
2849 api_main_t *am = &api_main;
2851 vat_json_node_t node;
2854 /* $$$$ make this real? */
2855 vat_json_init_object (&node);
2856 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2857 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2859 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2861 /* Toss the shared-memory original... */
2862 pthread_mutex_lock (&am->vlib_rp->mutex);
2863 oldheap = svm_push_data_heap (am->vlib_rp);
2867 svm_pop_heap (oldheap);
2868 pthread_mutex_unlock (&am->vlib_rp->mutex);
2870 vat_json_print (vam->ofp, &node);
2871 vat_json_free (&node);
2873 vam->retval = ntohl (mp->retval);
2874 vam->result_ready = 1;
2878 vl_api_one_locator_details_t_handler (vl_api_one_locator_details_t * mp)
2880 vat_main_t *vam = &vat_main;
2885 s = format (s, "%=16d%=16d%=16d",
2886 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2890 s = format (s, "%=16U%=16d%=16d",
2891 mp->is_ipv6 ? format_ip6_address :
2893 mp->ip_address, mp->priority, mp->weight);
2896 print (vam->ofp, "%v", s);
2901 vl_api_one_locator_details_t_handler_json (vl_api_one_locator_details_t * mp)
2903 vat_main_t *vam = &vat_main;
2904 vat_json_node_t *node = NULL;
2905 struct in6_addr ip6;
2908 if (VAT_JSON_ARRAY != vam->json_tree.type)
2910 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2911 vat_json_init_array (&vam->json_tree);
2913 node = vat_json_array_add (&vam->json_tree);
2914 vat_json_init_object (node);
2916 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2917 vat_json_object_add_uint (node, "priority", mp->priority);
2918 vat_json_object_add_uint (node, "weight", mp->weight);
2921 vat_json_object_add_uint (node, "sw_if_index",
2922 clib_net_to_host_u32 (mp->sw_if_index));
2927 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2928 vat_json_object_add_ip6 (node, "address", ip6);
2932 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2933 vat_json_object_add_ip4 (node, "address", ip4);
2939 vl_api_one_locator_set_details_t_handler (vl_api_one_locator_set_details_t *
2942 vat_main_t *vam = &vat_main;
2945 ls_name = format (0, "%s", mp->ls_name);
2947 print (vam->ofp, "%=10d%=15v", clib_net_to_host_u32 (mp->ls_index),
2953 vl_api_one_locator_set_details_t_handler_json
2954 (vl_api_one_locator_set_details_t * mp)
2956 vat_main_t *vam = &vat_main;
2957 vat_json_node_t *node = 0;
2960 ls_name = format (0, "%s", mp->ls_name);
2961 vec_add1 (ls_name, 0);
2963 if (VAT_JSON_ARRAY != vam->json_tree.type)
2965 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2966 vat_json_init_array (&vam->json_tree);
2968 node = vat_json_array_add (&vam->json_tree);
2970 vat_json_init_object (node);
2971 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2972 vat_json_object_add_uint (node, "ls_index",
2973 clib_net_to_host_u32 (mp->ls_index));
2981 } __attribute__ ((__packed__)) lisp_nsh_api_t;
2984 unformat_nsh_address (unformat_input_t * input, va_list * args)
2986 lisp_nsh_api_t *nsh = va_arg (*args, lisp_nsh_api_t *);
2987 return unformat (input, "SPI:%d SI:%d", &nsh->spi, &nsh->si);
2991 format_nsh_address_vat (u8 * s, va_list * args)
2993 nsh_t *a = va_arg (*args, nsh_t *);
2994 return format (s, "SPI:%d SI:%d", clib_net_to_host_u32 (a->spi), a->si);
2998 format_lisp_flat_eid (u8 * s, va_list * args)
3000 u32 type = va_arg (*args, u32);
3001 u8 *eid = va_arg (*args, u8 *);
3002 u32 eid_len = va_arg (*args, u32);
3007 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
3009 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
3011 return format (s, "%U", format_ethernet_address, eid);
3013 return format (s, "%U", format_nsh_address_vat, eid);
3019 format_lisp_eid_vat (u8 * s, va_list * args)
3021 u32 type = va_arg (*args, u32);
3022 u8 *eid = va_arg (*args, u8 *);
3023 u32 eid_len = va_arg (*args, u32);
3024 u8 *seid = va_arg (*args, u8 *);
3025 u32 seid_len = va_arg (*args, u32);
3026 u32 is_src_dst = va_arg (*args, u32);
3029 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
3031 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
3037 vl_api_one_eid_table_details_t_handler (vl_api_one_eid_table_details_t * mp)
3039 vat_main_t *vam = &vat_main;
3040 u8 *s = 0, *eid = 0;
3042 if (~0 == mp->locator_set_index)
3043 s = format (0, "action: %d", mp->action);
3045 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
3047 eid = format (0, "%U", format_lisp_eid_vat,
3051 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
3054 print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
3055 clib_net_to_host_u32 (mp->vni),
3057 mp->is_local ? "local" : "remote",
3058 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
3059 clib_net_to_host_u16 (mp->key_id), mp->key);
3066 vl_api_one_eid_table_details_t_handler_json (vl_api_one_eid_table_details_t
3069 vat_main_t *vam = &vat_main;
3070 vat_json_node_t *node = 0;
3073 if (VAT_JSON_ARRAY != vam->json_tree.type)
3075 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3076 vat_json_init_array (&vam->json_tree);
3078 node = vat_json_array_add (&vam->json_tree);
3080 vat_json_init_object (node);
3081 if (~0 == mp->locator_set_index)
3082 vat_json_object_add_uint (node, "action", mp->action);
3084 vat_json_object_add_uint (node, "locator_set_index",
3085 clib_net_to_host_u32 (mp->locator_set_index));
3087 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
3088 if (mp->eid_type == 3)
3090 vat_json_node_t *nsh_json = vat_json_object_add (node, "eid");
3091 vat_json_init_object (nsh_json);
3092 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) mp->eid;
3093 vat_json_object_add_uint (nsh_json, "spi",
3094 clib_net_to_host_u32 (nsh->spi));
3095 vat_json_object_add_uint (nsh_json, "si", nsh->si);
3099 eid = format (0, "%U", format_lisp_eid_vat,
3103 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
3105 vat_json_object_add_string_copy (node, "eid", eid);
3108 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3109 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
3110 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
3114 vat_json_object_add_uint (node, "key_id",
3115 clib_net_to_host_u16 (mp->key_id));
3116 vat_json_object_add_string_copy (node, "key", mp->key);
3121 vl_api_one_stats_details_t_handler (vl_api_one_stats_details_t * mp)
3123 vat_main_t *vam = &vat_main;
3124 u8 *seid = 0, *deid = 0;
3125 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3127 deid = format (0, "%U", format_lisp_eid_vat,
3128 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3130 seid = format (0, "%U", format_lisp_eid_vat,
3131 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3137 format_ip_address_fcn = format_ip4_address;
3139 format_ip_address_fcn = format_ip6_address;
3142 print (vam->ofp, "([%d] %s %s) (%U %U) %u %u",
3143 clib_net_to_host_u32 (mp->vni),
3145 format_ip_address_fcn, mp->lloc,
3146 format_ip_address_fcn, mp->rloc,
3147 clib_net_to_host_u32 (mp->pkt_count),
3148 clib_net_to_host_u32 (mp->bytes));
3155 vl_api_one_stats_details_t_handler_json (vl_api_one_stats_details_t * mp)
3157 struct in6_addr ip6;
3159 vat_main_t *vam = &vat_main;
3160 vat_json_node_t *node = 0;
3161 u8 *deid = 0, *seid = 0;
3163 if (VAT_JSON_ARRAY != vam->json_tree.type)
3165 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3166 vat_json_init_array (&vam->json_tree);
3168 node = vat_json_array_add (&vam->json_tree);
3170 vat_json_init_object (node);
3171 deid = format (0, "%U", format_lisp_eid_vat,
3172 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3174 seid = format (0, "%U", format_lisp_eid_vat,
3175 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3180 vat_json_object_add_string_copy (node, "seid", seid);
3181 vat_json_object_add_string_copy (node, "deid", deid);
3182 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3186 clib_memcpy (&ip4, mp->lloc, sizeof (ip4));
3187 vat_json_object_add_ip4 (node, "lloc", ip4);
3188 clib_memcpy (&ip4, mp->rloc, sizeof (ip4));
3189 vat_json_object_add_ip4 (node, "rloc", ip4);
3193 clib_memcpy (&ip6, mp->lloc, sizeof (ip6));
3194 vat_json_object_add_ip6 (node, "lloc", ip6);
3195 clib_memcpy (&ip6, mp->rloc, sizeof (ip6));
3196 vat_json_object_add_ip6 (node, "rloc", ip6);
3198 vat_json_object_add_uint (node, "pkt_count",
3199 clib_net_to_host_u32 (mp->pkt_count));
3200 vat_json_object_add_uint (node, "bytes", clib_net_to_host_u32 (mp->bytes));
3207 vl_api_one_eid_table_map_details_t_handler
3208 (vl_api_one_eid_table_map_details_t * mp)
3210 vat_main_t *vam = &vat_main;
3212 u8 *line = format (0, "%=10d%=10d",
3213 clib_net_to_host_u32 (mp->vni),
3214 clib_net_to_host_u32 (mp->dp_table));
3215 print (vam->ofp, "%v", line);
3220 vl_api_one_eid_table_map_details_t_handler_json
3221 (vl_api_one_eid_table_map_details_t * mp)
3223 vat_main_t *vam = &vat_main;
3224 vat_json_node_t *node = NULL;
3226 if (VAT_JSON_ARRAY != vam->json_tree.type)
3228 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3229 vat_json_init_array (&vam->json_tree);
3231 node = vat_json_array_add (&vam->json_tree);
3232 vat_json_init_object (node);
3233 vat_json_object_add_uint (node, "dp_table",
3234 clib_net_to_host_u32 (mp->dp_table));
3235 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3239 vl_api_one_eid_table_vni_details_t_handler
3240 (vl_api_one_eid_table_vni_details_t * mp)
3242 vat_main_t *vam = &vat_main;
3244 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
3245 print (vam->ofp, "%v", line);
3250 vl_api_one_eid_table_vni_details_t_handler_json
3251 (vl_api_one_eid_table_vni_details_t * mp)
3253 vat_main_t *vam = &vat_main;
3254 vat_json_node_t *node = NULL;
3256 if (VAT_JSON_ARRAY != vam->json_tree.type)
3258 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3259 vat_json_init_array (&vam->json_tree);
3261 node = vat_json_array_add (&vam->json_tree);
3262 vat_json_init_object (node);
3263 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3267 vl_api_show_one_map_register_fallback_threshold_reply_t_handler
3268 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3270 vat_main_t *vam = &vat_main;
3271 int retval = clib_net_to_host_u32 (mp->retval);
3273 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3274 print (vam->ofp, "fallback threshold value: %d", mp->value);
3276 vam->retval = retval;
3277 vam->result_ready = 1;
3281 vl_api_show_one_map_register_fallback_threshold_reply_t_handler_json
3282 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3284 vat_main_t *vam = &vat_main;
3285 vat_json_node_t _node, *node = &_node;
3286 int retval = clib_net_to_host_u32 (mp->retval);
3288 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3289 vat_json_init_object (node);
3290 vat_json_object_add_uint (node, "value", mp->value);
3292 vat_json_print (vam->ofp, node);
3293 vat_json_free (node);
3295 vam->retval = retval;
3296 vam->result_ready = 1;
3300 vl_api_show_one_map_register_state_reply_t_handler
3301 (vl_api_show_one_map_register_state_reply_t * mp)
3303 vat_main_t *vam = &vat_main;
3304 int retval = clib_net_to_host_u32 (mp->retval);
3306 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3308 vam->retval = retval;
3309 vam->result_ready = 1;
3313 vl_api_show_one_map_register_state_reply_t_handler_json
3314 (vl_api_show_one_map_register_state_reply_t * mp)
3316 vat_main_t *vam = &vat_main;
3317 vat_json_node_t _node, *node = &_node;
3318 int retval = clib_net_to_host_u32 (mp->retval);
3320 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3322 vat_json_init_object (node);
3323 vat_json_object_add_string_copy (node, "state", s);
3325 vat_json_print (vam->ofp, node);
3326 vat_json_free (node);
3328 vam->retval = retval;
3329 vam->result_ready = 1;
3334 vl_api_show_one_rloc_probe_state_reply_t_handler
3335 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3337 vat_main_t *vam = &vat_main;
3338 int retval = clib_net_to_host_u32 (mp->retval);
3343 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3345 vam->retval = retval;
3346 vam->result_ready = 1;
3350 vl_api_show_one_rloc_probe_state_reply_t_handler_json
3351 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3353 vat_main_t *vam = &vat_main;
3354 vat_json_node_t _node, *node = &_node;
3355 int retval = clib_net_to_host_u32 (mp->retval);
3357 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3358 vat_json_init_object (node);
3359 vat_json_object_add_string_copy (node, "state", s);
3361 vat_json_print (vam->ofp, node);
3362 vat_json_free (node);
3364 vam->retval = retval;
3365 vam->result_ready = 1;
3370 vl_api_show_one_stats_enable_disable_reply_t_handler
3371 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3373 vat_main_t *vam = &vat_main;
3374 int retval = clib_net_to_host_u32 (mp->retval);
3379 print (vam->ofp, "%s", mp->is_en ? "enabled" : "disabled");
3381 vam->retval = retval;
3382 vam->result_ready = 1;
3386 vl_api_show_one_stats_enable_disable_reply_t_handler_json
3387 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3389 vat_main_t *vam = &vat_main;
3390 vat_json_node_t _node, *node = &_node;
3391 int retval = clib_net_to_host_u32 (mp->retval);
3393 u8 *s = format (0, "%s", mp->is_en ? "enabled" : "disabled");
3394 vat_json_init_object (node);
3395 vat_json_object_add_string_copy (node, "state", s);
3397 vat_json_print (vam->ofp, node);
3398 vat_json_free (node);
3400 vam->retval = retval;
3401 vam->result_ready = 1;
3406 api_gpe_fwd_entry_net_to_host (vl_api_gpe_fwd_entry_t * e)
3408 e->dp_table = clib_net_to_host_u32 (e->dp_table);
3409 e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
3410 e->vni = clib_net_to_host_u32 (e->vni);
3414 gpe_fwd_entries_get_reply_t_net_to_host
3415 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3419 mp->count = clib_net_to_host_u32 (mp->count);
3420 for (i = 0; i < mp->count; i++)
3422 api_gpe_fwd_entry_net_to_host (&mp->entries[i]);
3427 format_gpe_encap_mode (u8 * s, va_list * args)
3429 u32 mode = va_arg (*args, u32);
3434 return format (s, "lisp");
3436 return format (s, "vxlan");
3442 vl_api_gpe_get_encap_mode_reply_t_handler
3443 (vl_api_gpe_get_encap_mode_reply_t * mp)
3445 vat_main_t *vam = &vat_main;
3447 print (vam->ofp, "gpe mode: %U", format_gpe_encap_mode, mp->encap_mode);
3448 vam->retval = ntohl (mp->retval);
3449 vam->result_ready = 1;
3453 vl_api_gpe_get_encap_mode_reply_t_handler_json
3454 (vl_api_gpe_get_encap_mode_reply_t * mp)
3456 vat_main_t *vam = &vat_main;
3457 vat_json_node_t node;
3459 u8 *encap_mode = format (0, "%U", format_gpe_encap_mode, mp->encap_mode);
3460 vec_add1 (encap_mode, 0);
3462 vat_json_init_object (&node);
3463 vat_json_object_add_string_copy (&node, "gpe_mode", encap_mode);
3465 vec_free (encap_mode);
3466 vat_json_print (vam->ofp, &node);
3467 vat_json_free (&node);
3469 vam->retval = ntohl (mp->retval);
3470 vam->result_ready = 1;
3474 vl_api_gpe_fwd_entry_path_details_t_handler
3475 (vl_api_gpe_fwd_entry_path_details_t * mp)
3477 vat_main_t *vam = &vat_main;
3478 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3480 if (mp->lcl_loc.is_ip4)
3481 format_ip_address_fcn = format_ip4_address;
3483 format_ip_address_fcn = format_ip6_address;
3485 print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
3486 format_ip_address_fcn, &mp->lcl_loc,
3487 format_ip_address_fcn, &mp->rmt_loc);
3491 lisp_fill_locator_node (vat_json_node_t * n, vl_api_gpe_locator_t * loc)
3493 struct in6_addr ip6;
3498 clib_memcpy (&ip4, loc->addr, sizeof (ip4));
3499 vat_json_object_add_ip4 (n, "address", ip4);
3503 clib_memcpy (&ip6, loc->addr, sizeof (ip6));
3504 vat_json_object_add_ip6 (n, "address", ip6);
3506 vat_json_object_add_uint (n, "weight", loc->weight);
3510 vl_api_gpe_fwd_entry_path_details_t_handler_json
3511 (vl_api_gpe_fwd_entry_path_details_t * mp)
3513 vat_main_t *vam = &vat_main;
3514 vat_json_node_t *node = NULL;
3515 vat_json_node_t *loc_node;
3517 if (VAT_JSON_ARRAY != vam->json_tree.type)
3519 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3520 vat_json_init_array (&vam->json_tree);
3522 node = vat_json_array_add (&vam->json_tree);
3523 vat_json_init_object (node);
3525 loc_node = vat_json_object_add (node, "local_locator");
3526 vat_json_init_object (loc_node);
3527 lisp_fill_locator_node (loc_node, &mp->lcl_loc);
3529 loc_node = vat_json_object_add (node, "remote_locator");
3530 vat_json_init_object (loc_node);
3531 lisp_fill_locator_node (loc_node, &mp->rmt_loc);
3535 vl_api_gpe_fwd_entries_get_reply_t_handler
3536 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3538 vat_main_t *vam = &vat_main;
3540 int retval = clib_net_to_host_u32 (mp->retval);
3541 vl_api_gpe_fwd_entry_t *e;
3546 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3548 for (i = 0; i < mp->count; i++)
3550 e = &mp->entries[i];
3551 print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
3552 format_lisp_flat_eid, e->eid_type, e->leid, e->leid_prefix_len,
3553 format_lisp_flat_eid, e->eid_type, e->reid, e->reid_prefix_len);
3557 vam->retval = retval;
3558 vam->result_ready = 1;
3562 vl_api_gpe_fwd_entries_get_reply_t_handler_json
3563 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3566 vat_main_t *vam = &vat_main;
3567 vat_json_node_t *e = 0, root;
3569 int retval = clib_net_to_host_u32 (mp->retval);
3570 vl_api_gpe_fwd_entry_t *fwd;
3575 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3576 vat_json_init_array (&root);
3578 for (i = 0; i < mp->count; i++)
3580 e = vat_json_array_add (&root);
3581 fwd = &mp->entries[i];
3583 vat_json_init_object (e);
3584 vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
3585 vat_json_object_add_int (e, "dp_table", fwd->dp_table);
3586 vat_json_object_add_int (e, "vni", fwd->vni);
3587 vat_json_object_add_int (e, "action", fwd->action);
3589 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->leid,
3590 fwd->leid_prefix_len);
3592 vat_json_object_add_string_copy (e, "leid", s);
3595 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->reid,
3596 fwd->reid_prefix_len);
3598 vat_json_object_add_string_copy (e, "reid", s);
3602 vat_json_print (vam->ofp, &root);
3603 vat_json_free (&root);
3606 vam->retval = retval;
3607 vam->result_ready = 1;
3611 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler
3612 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3614 vat_main_t *vam = &vat_main;
3616 int retval = clib_net_to_host_u32 (mp->retval);
3617 vl_api_gpe_native_fwd_rpath_t *r;
3622 n = clib_net_to_host_u32 (mp->count);
3624 for (i = 0; i < n; i++)
3626 r = &mp->entries[i];
3627 print (vam->ofp, "fib_index: %d sw_if_index %d nh %U",
3628 clib_net_to_host_u32 (r->fib_index),
3629 clib_net_to_host_u32 (r->nh_sw_if_index),
3630 r->is_ip4 ? format_ip4_address : format_ip6_address, r->nh_addr);
3634 vam->retval = retval;
3635 vam->result_ready = 1;
3639 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler_json
3640 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3642 vat_main_t *vam = &vat_main;
3643 vat_json_node_t root, *e;
3645 int retval = clib_net_to_host_u32 (mp->retval);
3646 vl_api_gpe_native_fwd_rpath_t *r;
3652 n = clib_net_to_host_u32 (mp->count);
3653 vat_json_init_array (&root);
3655 for (i = 0; i < n; i++)
3657 e = vat_json_array_add (&root);
3658 vat_json_init_object (e);
3659 r = &mp->entries[i];
3661 format (0, "%U", r->is_ip4 ? format_ip4_address : format_ip6_address,
3664 vat_json_object_add_string_copy (e, "ip4", s);
3667 vat_json_object_add_uint (e, "fib_index",
3668 clib_net_to_host_u32 (r->fib_index));
3669 vat_json_object_add_uint (e, "nh_sw_if_index",
3670 clib_net_to_host_u32 (r->nh_sw_if_index));
3673 vat_json_print (vam->ofp, &root);
3674 vat_json_free (&root);
3677 vam->retval = retval;
3678 vam->result_ready = 1;
3682 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler
3683 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3685 vat_main_t *vam = &vat_main;
3687 int retval = clib_net_to_host_u32 (mp->retval);
3692 n = clib_net_to_host_u32 (mp->count);
3694 for (i = 0; i < n; i++)
3695 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->vnis[i]));
3698 vam->retval = retval;
3699 vam->result_ready = 1;
3703 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler_json
3704 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3706 vat_main_t *vam = &vat_main;
3707 vat_json_node_t root;
3709 int retval = clib_net_to_host_u32 (mp->retval);
3714 n = clib_net_to_host_u32 (mp->count);
3715 vat_json_init_array (&root);
3717 for (i = 0; i < n; i++)
3718 vat_json_array_add_uint (&root, clib_net_to_host_u32 (mp->vnis[i]));
3720 vat_json_print (vam->ofp, &root);
3721 vat_json_free (&root);
3724 vam->retval = retval;
3725 vam->result_ready = 1;
3729 vl_api_one_ndp_entries_get_reply_t_handler
3730 (vl_api_one_ndp_entries_get_reply_t * mp)
3732 vat_main_t *vam = &vat_main;
3734 int retval = clib_net_to_host_u32 (mp->retval);
3739 n = clib_net_to_host_u32 (mp->count);
3741 for (i = 0; i < n; i++)
3742 print (vam->ofp, "%U -> %U", format_ip6_address, &mp->entries[i].ip6,
3743 format_ethernet_address, mp->entries[i].mac);
3746 vam->retval = retval;
3747 vam->result_ready = 1;
3751 vl_api_one_ndp_entries_get_reply_t_handler_json
3752 (vl_api_one_ndp_entries_get_reply_t * mp)
3755 vat_main_t *vam = &vat_main;
3756 vat_json_node_t *e = 0, root;
3758 int retval = clib_net_to_host_u32 (mp->retval);
3759 vl_api_one_ndp_entry_t *arp_entry;
3764 n = clib_net_to_host_u32 (mp->count);
3765 vat_json_init_array (&root);
3767 for (i = 0; i < n; i++)
3769 e = vat_json_array_add (&root);
3770 arp_entry = &mp->entries[i];
3772 vat_json_init_object (e);
3773 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3776 vat_json_object_add_string_copy (e, "mac", s);
3779 s = format (0, "%U", format_ip6_address, &arp_entry->ip6);
3781 vat_json_object_add_string_copy (e, "ip6", s);
3785 vat_json_print (vam->ofp, &root);
3786 vat_json_free (&root);
3789 vam->retval = retval;
3790 vam->result_ready = 1;
3794 vl_api_one_l2_arp_entries_get_reply_t_handler
3795 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3797 vat_main_t *vam = &vat_main;
3799 int retval = clib_net_to_host_u32 (mp->retval);
3804 n = clib_net_to_host_u32 (mp->count);
3806 for (i = 0; i < n; i++)
3807 print (vam->ofp, "%U -> %U", format_ip4_address, &mp->entries[i].ip4,
3808 format_ethernet_address, mp->entries[i].mac);
3811 vam->retval = retval;
3812 vam->result_ready = 1;
3816 vl_api_one_l2_arp_entries_get_reply_t_handler_json
3817 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3820 vat_main_t *vam = &vat_main;
3821 vat_json_node_t *e = 0, root;
3823 int retval = clib_net_to_host_u32 (mp->retval);
3824 vl_api_one_l2_arp_entry_t *arp_entry;
3829 n = clib_net_to_host_u32 (mp->count);
3830 vat_json_init_array (&root);
3832 for (i = 0; i < n; i++)
3834 e = vat_json_array_add (&root);
3835 arp_entry = &mp->entries[i];
3837 vat_json_init_object (e);
3838 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3841 vat_json_object_add_string_copy (e, "mac", s);
3844 s = format (0, "%U", format_ip4_address, &arp_entry->ip4);
3846 vat_json_object_add_string_copy (e, "ip4", s);
3850 vat_json_print (vam->ofp, &root);
3851 vat_json_free (&root);
3854 vam->retval = retval;
3855 vam->result_ready = 1;
3859 vl_api_one_ndp_bd_get_reply_t_handler (vl_api_one_ndp_bd_get_reply_t * mp)
3861 vat_main_t *vam = &vat_main;
3863 int retval = clib_net_to_host_u32 (mp->retval);
3868 n = clib_net_to_host_u32 (mp->count);
3870 for (i = 0; i < n; i++)
3872 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3876 vam->retval = retval;
3877 vam->result_ready = 1;
3881 vl_api_one_ndp_bd_get_reply_t_handler_json
3882 (vl_api_one_ndp_bd_get_reply_t * mp)
3884 vat_main_t *vam = &vat_main;
3885 vat_json_node_t root;
3887 int retval = clib_net_to_host_u32 (mp->retval);
3892 n = clib_net_to_host_u32 (mp->count);
3893 vat_json_init_array (&root);
3895 for (i = 0; i < n; i++)
3897 vat_json_array_add_uint (&root,
3898 clib_net_to_host_u32 (mp->bridge_domains[i]));
3901 vat_json_print (vam->ofp, &root);
3902 vat_json_free (&root);
3905 vam->retval = retval;
3906 vam->result_ready = 1;
3910 vl_api_one_l2_arp_bd_get_reply_t_handler
3911 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3913 vat_main_t *vam = &vat_main;
3915 int retval = clib_net_to_host_u32 (mp->retval);
3920 n = clib_net_to_host_u32 (mp->count);
3922 for (i = 0; i < n; i++)
3924 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3928 vam->retval = retval;
3929 vam->result_ready = 1;
3933 vl_api_one_l2_arp_bd_get_reply_t_handler_json
3934 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3936 vat_main_t *vam = &vat_main;
3937 vat_json_node_t root;
3939 int retval = clib_net_to_host_u32 (mp->retval);
3944 n = clib_net_to_host_u32 (mp->count);
3945 vat_json_init_array (&root);
3947 for (i = 0; i < n; i++)
3949 vat_json_array_add_uint (&root,
3950 clib_net_to_host_u32 (mp->bridge_domains[i]));
3953 vat_json_print (vam->ofp, &root);
3954 vat_json_free (&root);
3957 vam->retval = retval;
3958 vam->result_ready = 1;
3962 vl_api_one_adjacencies_get_reply_t_handler
3963 (vl_api_one_adjacencies_get_reply_t * mp)
3965 vat_main_t *vam = &vat_main;
3967 int retval = clib_net_to_host_u32 (mp->retval);
3968 vl_api_one_adjacency_t *a;
3973 n = clib_net_to_host_u32 (mp->count);
3975 for (i = 0; i < n; i++)
3977 a = &mp->adjacencies[i];
3978 print (vam->ofp, "%U %40U",
3979 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
3980 format_lisp_flat_eid, a->eid_type, a->reid, a->reid_prefix_len);
3984 vam->retval = retval;
3985 vam->result_ready = 1;
3989 vl_api_one_adjacencies_get_reply_t_handler_json
3990 (vl_api_one_adjacencies_get_reply_t * mp)
3993 vat_main_t *vam = &vat_main;
3994 vat_json_node_t *e = 0, root;
3996 int retval = clib_net_to_host_u32 (mp->retval);
3997 vl_api_one_adjacency_t *a;
4002 n = clib_net_to_host_u32 (mp->count);
4003 vat_json_init_array (&root);
4005 for (i = 0; i < n; i++)
4007 e = vat_json_array_add (&root);
4008 a = &mp->adjacencies[i];
4010 vat_json_init_object (e);
4011 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
4012 a->leid_prefix_len);
4014 vat_json_object_add_string_copy (e, "leid", s);
4017 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
4018 a->reid_prefix_len);
4020 vat_json_object_add_string_copy (e, "reid", s);
4024 vat_json_print (vam->ofp, &root);
4025 vat_json_free (&root);
4028 vam->retval = retval;
4029 vam->result_ready = 1;
4033 vl_api_one_map_server_details_t_handler (vl_api_one_map_server_details_t * mp)
4035 vat_main_t *vam = &vat_main;
4037 print (vam->ofp, "%=20U",
4038 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
4043 vl_api_one_map_server_details_t_handler_json
4044 (vl_api_one_map_server_details_t * mp)
4046 vat_main_t *vam = &vat_main;
4047 vat_json_node_t *node = NULL;
4048 struct in6_addr ip6;
4051 if (VAT_JSON_ARRAY != vam->json_tree.type)
4053 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4054 vat_json_init_array (&vam->json_tree);
4056 node = vat_json_array_add (&vam->json_tree);
4058 vat_json_init_object (node);
4061 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
4062 vat_json_object_add_ip6 (node, "map-server", ip6);
4066 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
4067 vat_json_object_add_ip4 (node, "map-server", ip4);
4072 vl_api_one_map_resolver_details_t_handler (vl_api_one_map_resolver_details_t
4075 vat_main_t *vam = &vat_main;
4077 print (vam->ofp, "%=20U",
4078 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
4083 vl_api_one_map_resolver_details_t_handler_json
4084 (vl_api_one_map_resolver_details_t * mp)
4086 vat_main_t *vam = &vat_main;
4087 vat_json_node_t *node = NULL;
4088 struct in6_addr ip6;
4091 if (VAT_JSON_ARRAY != vam->json_tree.type)
4093 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4094 vat_json_init_array (&vam->json_tree);
4096 node = vat_json_array_add (&vam->json_tree);
4098 vat_json_init_object (node);
4101 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
4102 vat_json_object_add_ip6 (node, "map resolver", ip6);
4106 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
4107 vat_json_object_add_ip4 (node, "map resolver", ip4);
4112 vl_api_show_one_status_reply_t_handler (vl_api_show_one_status_reply_t * mp)
4114 vat_main_t *vam = &vat_main;
4115 i32 retval = ntohl (mp->retval);
4119 print (vam->ofp, "feature: %s\ngpe: %s",
4120 mp->feature_status ? "enabled" : "disabled",
4121 mp->gpe_status ? "enabled" : "disabled");
4124 vam->retval = retval;
4125 vam->result_ready = 1;
4129 vl_api_show_one_status_reply_t_handler_json
4130 (vl_api_show_one_status_reply_t * mp)
4132 vat_main_t *vam = &vat_main;
4133 vat_json_node_t node;
4134 u8 *gpe_status = NULL;
4135 u8 *feature_status = NULL;
4137 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
4138 feature_status = format (0, "%s",
4139 mp->feature_status ? "enabled" : "disabled");
4140 vec_add1 (gpe_status, 0);
4141 vec_add1 (feature_status, 0);
4143 vat_json_init_object (&node);
4144 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
4145 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
4147 vec_free (gpe_status);
4148 vec_free (feature_status);
4150 vat_json_print (vam->ofp, &node);
4151 vat_json_free (&node);
4153 vam->retval = ntohl (mp->retval);
4154 vam->result_ready = 1;
4158 vl_api_one_get_map_request_itr_rlocs_reply_t_handler
4159 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4161 vat_main_t *vam = &vat_main;
4162 i32 retval = ntohl (mp->retval);
4166 print (vam->ofp, "%=20s", mp->locator_set_name);
4169 vam->retval = retval;
4170 vam->result_ready = 1;
4174 vl_api_one_get_map_request_itr_rlocs_reply_t_handler_json
4175 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4177 vat_main_t *vam = &vat_main;
4178 vat_json_node_t *node = NULL;
4180 if (VAT_JSON_ARRAY != vam->json_tree.type)
4182 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4183 vat_json_init_array (&vam->json_tree);
4185 node = vat_json_array_add (&vam->json_tree);
4187 vat_json_init_object (node);
4188 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
4190 vat_json_print (vam->ofp, node);
4191 vat_json_free (node);
4193 vam->retval = ntohl (mp->retval);
4194 vam->result_ready = 1;
4198 format_lisp_map_request_mode (u8 * s, va_list * args)
4200 u32 mode = va_arg (*args, u32);
4205 return format (0, "dst-only");
4207 return format (0, "src-dst");
4213 vl_api_show_one_map_request_mode_reply_t_handler
4214 (vl_api_show_one_map_request_mode_reply_t * mp)
4216 vat_main_t *vam = &vat_main;
4217 i32 retval = ntohl (mp->retval);
4221 u32 mode = mp->mode;
4222 print (vam->ofp, "map_request_mode: %U",
4223 format_lisp_map_request_mode, mode);
4226 vam->retval = retval;
4227 vam->result_ready = 1;
4231 vl_api_show_one_map_request_mode_reply_t_handler_json
4232 (vl_api_show_one_map_request_mode_reply_t * mp)
4234 vat_main_t *vam = &vat_main;
4235 vat_json_node_t node;
4240 s = format (0, "%U", format_lisp_map_request_mode, mode);
4243 vat_json_init_object (&node);
4244 vat_json_object_add_string_copy (&node, "map_request_mode", s);
4245 vat_json_print (vam->ofp, &node);
4246 vat_json_free (&node);
4249 vam->retval = ntohl (mp->retval);
4250 vam->result_ready = 1;
4254 vl_api_one_show_xtr_mode_reply_t_handler
4255 (vl_api_one_show_xtr_mode_reply_t * mp)
4257 vat_main_t *vam = &vat_main;
4258 i32 retval = ntohl (mp->retval);
4262 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4265 vam->retval = retval;
4266 vam->result_ready = 1;
4270 vl_api_one_show_xtr_mode_reply_t_handler_json
4271 (vl_api_one_show_xtr_mode_reply_t * mp)
4273 vat_main_t *vam = &vat_main;
4274 vat_json_node_t node;
4277 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4278 vec_add1 (status, 0);
4280 vat_json_init_object (&node);
4281 vat_json_object_add_string_copy (&node, "status", status);
4285 vat_json_print (vam->ofp, &node);
4286 vat_json_free (&node);
4288 vam->retval = ntohl (mp->retval);
4289 vam->result_ready = 1;
4293 vl_api_one_show_pitr_mode_reply_t_handler
4294 (vl_api_one_show_pitr_mode_reply_t * mp)
4296 vat_main_t *vam = &vat_main;
4297 i32 retval = ntohl (mp->retval);
4301 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4304 vam->retval = retval;
4305 vam->result_ready = 1;
4309 vl_api_one_show_pitr_mode_reply_t_handler_json
4310 (vl_api_one_show_pitr_mode_reply_t * mp)
4312 vat_main_t *vam = &vat_main;
4313 vat_json_node_t node;
4316 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4317 vec_add1 (status, 0);
4319 vat_json_init_object (&node);
4320 vat_json_object_add_string_copy (&node, "status", status);
4324 vat_json_print (vam->ofp, &node);
4325 vat_json_free (&node);
4327 vam->retval = ntohl (mp->retval);
4328 vam->result_ready = 1;
4332 vl_api_one_show_petr_mode_reply_t_handler
4333 (vl_api_one_show_petr_mode_reply_t * mp)
4335 vat_main_t *vam = &vat_main;
4336 i32 retval = ntohl (mp->retval);
4340 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4343 vam->retval = retval;
4344 vam->result_ready = 1;
4348 vl_api_one_show_petr_mode_reply_t_handler_json
4349 (vl_api_one_show_petr_mode_reply_t * mp)
4351 vat_main_t *vam = &vat_main;
4352 vat_json_node_t node;
4355 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4356 vec_add1 (status, 0);
4358 vat_json_init_object (&node);
4359 vat_json_object_add_string_copy (&node, "status", status);
4363 vat_json_print (vam->ofp, &node);
4364 vat_json_free (&node);
4366 vam->retval = ntohl (mp->retval);
4367 vam->result_ready = 1;
4371 vl_api_show_one_use_petr_reply_t_handler
4372 (vl_api_show_one_use_petr_reply_t * mp)
4374 vat_main_t *vam = &vat_main;
4375 i32 retval = ntohl (mp->retval);
4379 print (vam->ofp, "%s\n", mp->status ? "enabled" : "disabled");
4382 print (vam->ofp, "Proxy-ETR address; %U",
4383 mp->is_ip4 ? format_ip4_address : format_ip6_address,
4388 vam->retval = retval;
4389 vam->result_ready = 1;
4393 vl_api_show_one_use_petr_reply_t_handler_json
4394 (vl_api_show_one_use_petr_reply_t * mp)
4396 vat_main_t *vam = &vat_main;
4397 vat_json_node_t node;
4400 struct in6_addr ip6;
4402 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4403 vec_add1 (status, 0);
4405 vat_json_init_object (&node);
4406 vat_json_object_add_string_copy (&node, "status", status);
4411 clib_memcpy (&ip6, mp->address, sizeof (ip6));
4412 vat_json_object_add_ip6 (&node, "address", ip6);
4416 clib_memcpy (&ip4, mp->address, sizeof (ip4));
4417 vat_json_object_add_ip4 (&node, "address", ip4);
4423 vat_json_print (vam->ofp, &node);
4424 vat_json_free (&node);
4426 vam->retval = ntohl (mp->retval);
4427 vam->result_ready = 1;
4431 vl_api_show_one_nsh_mapping_reply_t_handler
4432 (vl_api_show_one_nsh_mapping_reply_t * mp)
4434 vat_main_t *vam = &vat_main;
4435 i32 retval = ntohl (mp->retval);
4439 print (vam->ofp, "%-20s%-16s",
4440 mp->is_set ? "set" : "not-set",
4441 mp->is_set ? (char *) mp->locator_set_name : "");
4444 vam->retval = retval;
4445 vam->result_ready = 1;
4449 vl_api_show_one_nsh_mapping_reply_t_handler_json
4450 (vl_api_show_one_nsh_mapping_reply_t * mp)
4452 vat_main_t *vam = &vat_main;
4453 vat_json_node_t node;
4456 status = format (0, "%s", mp->is_set ? "yes" : "no");
4457 vec_add1 (status, 0);
4459 vat_json_init_object (&node);
4460 vat_json_object_add_string_copy (&node, "is_set", status);
4463 vat_json_object_add_string_copy (&node, "locator_set",
4464 mp->locator_set_name);
4469 vat_json_print (vam->ofp, &node);
4470 vat_json_free (&node);
4472 vam->retval = ntohl (mp->retval);
4473 vam->result_ready = 1;
4477 vl_api_show_one_map_register_ttl_reply_t_handler
4478 (vl_api_show_one_map_register_ttl_reply_t * mp)
4480 vat_main_t *vam = &vat_main;
4481 i32 retval = ntohl (mp->retval);
4483 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4487 print (vam->ofp, "ttl: %u", mp->ttl);
4490 vam->retval = retval;
4491 vam->result_ready = 1;
4495 vl_api_show_one_map_register_ttl_reply_t_handler_json
4496 (vl_api_show_one_map_register_ttl_reply_t * mp)
4498 vat_main_t *vam = &vat_main;
4499 vat_json_node_t node;
4501 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4502 vat_json_init_object (&node);
4503 vat_json_object_add_uint (&node, "ttl", mp->ttl);
4505 vat_json_print (vam->ofp, &node);
4506 vat_json_free (&node);
4508 vam->retval = ntohl (mp->retval);
4509 vam->result_ready = 1;
4513 vl_api_show_one_pitr_reply_t_handler (vl_api_show_one_pitr_reply_t * mp)
4515 vat_main_t *vam = &vat_main;
4516 i32 retval = ntohl (mp->retval);
4520 print (vam->ofp, "%-20s%-16s",
4521 mp->status ? "enabled" : "disabled",
4522 mp->status ? (char *) mp->locator_set_name : "");
4525 vam->retval = retval;
4526 vam->result_ready = 1;
4530 vl_api_show_one_pitr_reply_t_handler_json (vl_api_show_one_pitr_reply_t * mp)
4532 vat_main_t *vam = &vat_main;
4533 vat_json_node_t node;
4536 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4537 vec_add1 (status, 0);
4539 vat_json_init_object (&node);
4540 vat_json_object_add_string_copy (&node, "status", status);
4543 vat_json_object_add_string_copy (&node, "locator_set",
4544 mp->locator_set_name);
4549 vat_json_print (vam->ofp, &node);
4550 vat_json_free (&node);
4552 vam->retval = ntohl (mp->retval);
4553 vam->result_ready = 1;
4557 format_policer_type (u8 * s, va_list * va)
4559 u32 i = va_arg (*va, u32);
4561 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
4562 s = format (s, "1r2c");
4563 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
4564 s = format (s, "1r3c");
4565 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
4566 s = format (s, "2r3c-2698");
4567 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
4568 s = format (s, "2r3c-4115");
4569 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
4570 s = format (s, "2r3c-mef5cf1");
4572 s = format (s, "ILLEGAL");
4577 format_policer_rate_type (u8 * s, va_list * va)
4579 u32 i = va_arg (*va, u32);
4581 if (i == SSE2_QOS_RATE_KBPS)
4582 s = format (s, "kbps");
4583 else if (i == SSE2_QOS_RATE_PPS)
4584 s = format (s, "pps");
4586 s = format (s, "ILLEGAL");
4591 format_policer_round_type (u8 * s, va_list * va)
4593 u32 i = va_arg (*va, u32);
4595 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
4596 s = format (s, "closest");
4597 else if (i == SSE2_QOS_ROUND_TO_UP)
4598 s = format (s, "up");
4599 else if (i == SSE2_QOS_ROUND_TO_DOWN)
4600 s = format (s, "down");
4602 s = format (s, "ILLEGAL");
4607 format_policer_action_type (u8 * s, va_list * va)
4609 u32 i = va_arg (*va, u32);
4611 if (i == SSE2_QOS_ACTION_DROP)
4612 s = format (s, "drop");
4613 else if (i == SSE2_QOS_ACTION_TRANSMIT)
4614 s = format (s, "transmit");
4615 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4616 s = format (s, "mark-and-transmit");
4618 s = format (s, "ILLEGAL");
4623 format_dscp (u8 * s, va_list * va)
4625 u32 i = va_arg (*va, u32);
4630 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
4634 return format (s, "ILLEGAL");
4636 s = format (s, "%s", t);
4641 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
4643 vat_main_t *vam = &vat_main;
4644 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
4646 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4647 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4649 conform_dscp_str = format (0, "");
4651 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4652 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4654 exceed_dscp_str = format (0, "");
4656 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4657 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4659 violate_dscp_str = format (0, "");
4661 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
4662 "rate type %U, round type %U, %s rate, %s color-aware, "
4663 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
4664 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
4665 "conform action %U%s, exceed action %U%s, violate action %U%s",
4667 format_policer_type, mp->type,
4670 clib_net_to_host_u64 (mp->cb),
4671 clib_net_to_host_u64 (mp->eb),
4672 format_policer_rate_type, mp->rate_type,
4673 format_policer_round_type, mp->round_type,
4674 mp->single_rate ? "single" : "dual",
4675 mp->color_aware ? "is" : "not",
4676 ntohl (mp->cir_tokens_per_period),
4677 ntohl (mp->pir_tokens_per_period),
4679 ntohl (mp->current_limit),
4680 ntohl (mp->current_bucket),
4681 ntohl (mp->extended_limit),
4682 ntohl (mp->extended_bucket),
4683 clib_net_to_host_u64 (mp->last_update_time),
4684 format_policer_action_type, mp->conform_action_type,
4686 format_policer_action_type, mp->exceed_action_type,
4688 format_policer_action_type, mp->violate_action_type,
4691 vec_free (conform_dscp_str);
4692 vec_free (exceed_dscp_str);
4693 vec_free (violate_dscp_str);
4696 static void vl_api_policer_details_t_handler_json
4697 (vl_api_policer_details_t * mp)
4699 vat_main_t *vam = &vat_main;
4700 vat_json_node_t *node;
4701 u8 *rate_type_str, *round_type_str, *type_str;
4702 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
4704 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
4706 format (0, "%U", format_policer_round_type, mp->round_type);
4707 type_str = format (0, "%U", format_policer_type, mp->type);
4708 conform_action_str = format (0, "%U", format_policer_action_type,
4709 mp->conform_action_type);
4710 exceed_action_str = format (0, "%U", format_policer_action_type,
4711 mp->exceed_action_type);
4712 violate_action_str = format (0, "%U", format_policer_action_type,
4713 mp->violate_action_type);
4715 if (VAT_JSON_ARRAY != vam->json_tree.type)
4717 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4718 vat_json_init_array (&vam->json_tree);
4720 node = vat_json_array_add (&vam->json_tree);
4722 vat_json_init_object (node);
4723 vat_json_object_add_string_copy (node, "name", mp->name);
4724 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
4725 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
4726 vat_json_object_add_uint (node, "cb", clib_net_to_host_u64 (mp->cb));
4727 vat_json_object_add_uint (node, "eb", clib_net_to_host_u64 (mp->eb));
4728 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
4729 vat_json_object_add_string_copy (node, "round_type", round_type_str);
4730 vat_json_object_add_string_copy (node, "type", type_str);
4731 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
4732 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
4733 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
4734 vat_json_object_add_uint (node, "cir_tokens_per_period",
4735 ntohl (mp->cir_tokens_per_period));
4736 vat_json_object_add_uint (node, "eir_tokens_per_period",
4737 ntohl (mp->pir_tokens_per_period));
4738 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
4739 vat_json_object_add_uint (node, "current_bucket",
4740 ntohl (mp->current_bucket));
4741 vat_json_object_add_uint (node, "extended_limit",
4742 ntohl (mp->extended_limit));
4743 vat_json_object_add_uint (node, "extended_bucket",
4744 ntohl (mp->extended_bucket));
4745 vat_json_object_add_uint (node, "last_update_time",
4746 ntohl (mp->last_update_time));
4747 vat_json_object_add_string_copy (node, "conform_action",
4748 conform_action_str);
4749 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4751 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4752 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
4753 vec_free (dscp_str);
4755 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
4756 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4758 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4759 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
4760 vec_free (dscp_str);
4762 vat_json_object_add_string_copy (node, "violate_action",
4763 violate_action_str);
4764 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4766 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4767 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
4768 vec_free (dscp_str);
4771 vec_free (rate_type_str);
4772 vec_free (round_type_str);
4773 vec_free (type_str);
4774 vec_free (conform_action_str);
4775 vec_free (exceed_action_str);
4776 vec_free (violate_action_str);
4780 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
4783 vat_main_t *vam = &vat_main;
4784 int i, count = ntohl (mp->count);
4787 print (vam->ofp, "classify table ids (%d) : ", count);
4788 for (i = 0; i < count; i++)
4790 print (vam->ofp, "%d", ntohl (mp->ids[i]));
4791 print (vam->ofp, (i < count - 1) ? "," : "");
4793 vam->retval = ntohl (mp->retval);
4794 vam->result_ready = 1;
4798 vl_api_classify_table_ids_reply_t_handler_json
4799 (vl_api_classify_table_ids_reply_t * mp)
4801 vat_main_t *vam = &vat_main;
4802 int i, count = ntohl (mp->count);
4806 vat_json_node_t node;
4808 vat_json_init_object (&node);
4809 for (i = 0; i < count; i++)
4811 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
4813 vat_json_print (vam->ofp, &node);
4814 vat_json_free (&node);
4816 vam->retval = ntohl (mp->retval);
4817 vam->result_ready = 1;
4821 vl_api_classify_table_by_interface_reply_t_handler
4822 (vl_api_classify_table_by_interface_reply_t * mp)
4824 vat_main_t *vam = &vat_main;
4827 table_id = ntohl (mp->l2_table_id);
4829 print (vam->ofp, "l2 table id : %d", table_id);
4831 print (vam->ofp, "l2 table id : No input ACL tables configured");
4832 table_id = ntohl (mp->ip4_table_id);
4834 print (vam->ofp, "ip4 table id : %d", table_id);
4836 print (vam->ofp, "ip4 table id : No input ACL tables configured");
4837 table_id = ntohl (mp->ip6_table_id);
4839 print (vam->ofp, "ip6 table id : %d", table_id);
4841 print (vam->ofp, "ip6 table id : No input ACL tables configured");
4842 vam->retval = ntohl (mp->retval);
4843 vam->result_ready = 1;
4847 vl_api_classify_table_by_interface_reply_t_handler_json
4848 (vl_api_classify_table_by_interface_reply_t * mp)
4850 vat_main_t *vam = &vat_main;
4851 vat_json_node_t node;
4853 vat_json_init_object (&node);
4855 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
4856 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
4857 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
4859 vat_json_print (vam->ofp, &node);
4860 vat_json_free (&node);
4862 vam->retval = ntohl (mp->retval);
4863 vam->result_ready = 1;
4866 static void vl_api_policer_add_del_reply_t_handler
4867 (vl_api_policer_add_del_reply_t * mp)
4869 vat_main_t *vam = &vat_main;
4870 i32 retval = ntohl (mp->retval);
4871 if (vam->async_mode)
4873 vam->async_errors += (retval < 0);
4877 vam->retval = retval;
4878 vam->result_ready = 1;
4879 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
4881 * Note: this is just barely thread-safe, depends on
4882 * the main thread spinning waiting for an answer...
4884 errmsg ("policer index %d", ntohl (mp->policer_index));
4888 static void vl_api_policer_add_del_reply_t_handler_json
4889 (vl_api_policer_add_del_reply_t * mp)
4891 vat_main_t *vam = &vat_main;
4892 vat_json_node_t node;
4894 vat_json_init_object (&node);
4895 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
4896 vat_json_object_add_uint (&node, "policer_index",
4897 ntohl (mp->policer_index));
4899 vat_json_print (vam->ofp, &node);
4900 vat_json_free (&node);
4902 vam->retval = ntohl (mp->retval);
4903 vam->result_ready = 1;
4906 /* Format hex dump. */
4908 format_hex_bytes (u8 * s, va_list * va)
4910 u8 *bytes = va_arg (*va, u8 *);
4911 int n_bytes = va_arg (*va, int);
4914 /* Print short or long form depending on byte count. */
4915 uword short_form = n_bytes <= 32;
4916 u32 indent = format_get_indent (s);
4921 for (i = 0; i < n_bytes; i++)
4923 if (!short_form && (i % 32) == 0)
4924 s = format (s, "%08x: ", i);
4925 s = format (s, "%02x", bytes[i]);
4926 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
4927 s = format (s, "\n%U", format_white_space, indent);
4934 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
4937 vat_main_t *vam = &vat_main;
4938 i32 retval = ntohl (mp->retval);
4941 print (vam->ofp, "classify table info :");
4942 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
4943 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
4944 ntohl (mp->miss_next_index));
4945 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
4946 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
4947 ntohl (mp->match_n_vectors));
4948 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
4949 ntohl (mp->mask_length));
4951 vam->retval = retval;
4952 vam->result_ready = 1;
4956 vl_api_classify_table_info_reply_t_handler_json
4957 (vl_api_classify_table_info_reply_t * mp)
4959 vat_main_t *vam = &vat_main;
4960 vat_json_node_t node;
4962 i32 retval = ntohl (mp->retval);
4965 vat_json_init_object (&node);
4967 vat_json_object_add_int (&node, "sessions",
4968 ntohl (mp->active_sessions));
4969 vat_json_object_add_int (&node, "nexttbl",
4970 ntohl (mp->next_table_index));
4971 vat_json_object_add_int (&node, "nextnode",
4972 ntohl (mp->miss_next_index));
4973 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
4974 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
4975 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
4976 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
4977 ntohl (mp->mask_length), 0);
4978 vat_json_object_add_string_copy (&node, "mask", s);
4980 vat_json_print (vam->ofp, &node);
4981 vat_json_free (&node);
4983 vam->retval = ntohl (mp->retval);
4984 vam->result_ready = 1;
4988 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
4991 vat_main_t *vam = &vat_main;
4993 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
4994 ntohl (mp->hit_next_index), ntohl (mp->advance),
4995 ntohl (mp->opaque_index));
4996 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
4997 ntohl (mp->match_length));
5001 vl_api_classify_session_details_t_handler_json
5002 (vl_api_classify_session_details_t * mp)
5004 vat_main_t *vam = &vat_main;
5005 vat_json_node_t *node = NULL;
5007 if (VAT_JSON_ARRAY != vam->json_tree.type)
5009 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5010 vat_json_init_array (&vam->json_tree);
5012 node = vat_json_array_add (&vam->json_tree);
5014 vat_json_init_object (node);
5015 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
5016 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
5017 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
5019 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
5021 vat_json_object_add_string_copy (node, "match", s);
5024 static void vl_api_pg_create_interface_reply_t_handler
5025 (vl_api_pg_create_interface_reply_t * mp)
5027 vat_main_t *vam = &vat_main;
5029 vam->retval = ntohl (mp->retval);
5030 vam->result_ready = 1;
5033 static void vl_api_pg_create_interface_reply_t_handler_json
5034 (vl_api_pg_create_interface_reply_t * mp)
5036 vat_main_t *vam = &vat_main;
5037 vat_json_node_t node;
5039 i32 retval = ntohl (mp->retval);
5042 vat_json_init_object (&node);
5044 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
5046 vat_json_print (vam->ofp, &node);
5047 vat_json_free (&node);
5049 vam->retval = ntohl (mp->retval);
5050 vam->result_ready = 1;
5053 static void vl_api_policer_classify_details_t_handler
5054 (vl_api_policer_classify_details_t * mp)
5056 vat_main_t *vam = &vat_main;
5058 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
5059 ntohl (mp->table_index));
5062 static void vl_api_policer_classify_details_t_handler_json
5063 (vl_api_policer_classify_details_t * mp)
5065 vat_main_t *vam = &vat_main;
5066 vat_json_node_t *node;
5068 if (VAT_JSON_ARRAY != vam->json_tree.type)
5070 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5071 vat_json_init_array (&vam->json_tree);
5073 node = vat_json_array_add (&vam->json_tree);
5075 vat_json_init_object (node);
5076 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5077 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5080 static void vl_api_flow_classify_details_t_handler
5081 (vl_api_flow_classify_details_t * mp)
5083 vat_main_t *vam = &vat_main;
5085 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
5086 ntohl (mp->table_index));
5089 static void vl_api_flow_classify_details_t_handler_json
5090 (vl_api_flow_classify_details_t * mp)
5092 vat_main_t *vam = &vat_main;
5093 vat_json_node_t *node;
5095 if (VAT_JSON_ARRAY != vam->json_tree.type)
5097 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5098 vat_json_init_array (&vam->json_tree);
5100 node = vat_json_array_add (&vam->json_tree);
5102 vat_json_init_object (node);
5103 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5104 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5107 #define vl_api_one_adjacencies_get_reply_t_endian vl_noop_handler
5108 #define vl_api_one_adjacencies_get_reply_t_print vl_noop_handler
5109 #define vl_api_one_l2_arp_bd_get_reply_t_print vl_noop_handler
5110 #define vl_api_one_l2_arp_entries_get_reply_t_endian vl_noop_handler
5111 #define vl_api_one_l2_arp_entries_get_reply_t_print vl_noop_handler
5112 #define vl_api_one_l2_arp_bd_get_reply_t_endian vl_noop_handler
5113 #define vl_api_one_ndp_bd_get_reply_t_endian vl_noop_handler
5114 #define vl_api_one_ndp_bd_get_reply_t_print vl_noop_handler
5115 #define vl_api_one_ndp_entries_get_reply_t_print vl_noop_handler
5116 #define vl_api_one_ndp_entries_get_reply_t_endian vl_noop_handler
5119 * Generate boilerplate reply handlers, which
5120 * dig the return value out of the xxx_reply_t API message,
5121 * stick it into vam->retval, and set vam->result_ready
5123 * Could also do this by pointing N message decode slots at
5124 * a single function, but that could break in subtle ways.
5127 #define foreach_standard_reply_retval_handler \
5128 _(sw_interface_set_flags_reply) \
5129 _(sw_interface_add_del_address_reply) \
5130 _(sw_interface_set_rx_mode_reply) \
5131 _(sw_interface_set_rx_placement_reply) \
5132 _(sw_interface_set_table_reply) \
5133 _(sw_interface_set_mpls_enable_reply) \
5134 _(sw_interface_set_vpath_reply) \
5135 _(sw_interface_set_vxlan_bypass_reply) \
5136 _(sw_interface_set_geneve_bypass_reply) \
5137 _(sw_interface_set_vxlan_gpe_bypass_reply) \
5138 _(sw_interface_set_l2_bridge_reply) \
5139 _(bridge_domain_add_del_reply) \
5140 _(sw_interface_set_l2_xconnect_reply) \
5141 _(l2fib_add_del_reply) \
5142 _(l2fib_flush_int_reply) \
5143 _(l2fib_flush_bd_reply) \
5144 _(ip_route_add_del_reply) \
5145 _(ip_table_add_del_reply) \
5146 _(ip_mroute_add_del_reply) \
5147 _(mpls_route_add_del_reply) \
5148 _(mpls_table_add_del_reply) \
5149 _(mpls_ip_bind_unbind_reply) \
5150 _(bier_route_add_del_reply) \
5151 _(bier_table_add_del_reply) \
5152 _(proxy_arp_add_del_reply) \
5153 _(proxy_arp_intfc_enable_disable_reply) \
5154 _(sw_interface_set_unnumbered_reply) \
5155 _(ip_neighbor_add_del_reply) \
5156 _(reset_fib_reply) \
5157 _(dhcp_proxy_config_reply) \
5158 _(dhcp_proxy_set_vss_reply) \
5159 _(dhcp_client_config_reply) \
5160 _(set_ip_flow_hash_reply) \
5161 _(sw_interface_ip6_enable_disable_reply) \
5162 _(ip6nd_proxy_add_del_reply) \
5163 _(sw_interface_ip6nd_ra_prefix_reply) \
5164 _(sw_interface_ip6nd_ra_config_reply) \
5165 _(set_arp_neighbor_limit_reply) \
5166 _(l2_patch_add_del_reply) \
5167 _(sr_mpls_policy_add_reply) \
5168 _(sr_mpls_policy_mod_reply) \
5169 _(sr_mpls_policy_del_reply) \
5170 _(sr_policy_add_reply) \
5171 _(sr_policy_mod_reply) \
5172 _(sr_policy_del_reply) \
5173 _(sr_localsid_add_del_reply) \
5174 _(sr_steering_add_del_reply) \
5175 _(classify_add_del_session_reply) \
5176 _(classify_set_interface_ip_table_reply) \
5177 _(classify_set_interface_l2_tables_reply) \
5178 _(l2tpv3_set_tunnel_cookies_reply) \
5179 _(l2tpv3_interface_enable_disable_reply) \
5180 _(l2tpv3_set_lookup_key_reply) \
5181 _(l2_fib_clear_table_reply) \
5182 _(l2_interface_efp_filter_reply) \
5183 _(l2_interface_vlan_tag_rewrite_reply) \
5184 _(modify_vhost_user_if_reply) \
5185 _(delete_vhost_user_if_reply) \
5186 _(ip_probe_neighbor_reply) \
5187 _(ip_scan_neighbor_enable_disable_reply) \
5188 _(want_ip4_arp_events_reply) \
5189 _(want_ip6_nd_events_reply) \
5190 _(want_l2_macs_events_reply) \
5191 _(input_acl_set_interface_reply) \
5192 _(ipsec_spd_add_del_reply) \
5193 _(ipsec_interface_add_del_spd_reply) \
5194 _(ipsec_spd_entry_add_del_reply) \
5195 _(ipsec_sad_entry_add_del_reply) \
5196 _(ipsec_tunnel_if_add_del_reply) \
5197 _(ipsec_tunnel_if_set_sa_reply) \
5198 _(delete_loopback_reply) \
5199 _(bd_ip_mac_add_del_reply) \
5200 _(bd_ip_mac_flush_reply) \
5201 _(want_interface_events_reply) \
5202 _(cop_interface_enable_disable_reply) \
5203 _(cop_whitelist_enable_disable_reply) \
5204 _(sw_interface_clear_stats_reply) \
5205 _(ioam_enable_reply) \
5206 _(ioam_disable_reply) \
5207 _(one_add_del_locator_reply) \
5208 _(one_add_del_local_eid_reply) \
5209 _(one_add_del_remote_mapping_reply) \
5210 _(one_add_del_adjacency_reply) \
5211 _(one_add_del_map_resolver_reply) \
5212 _(one_add_del_map_server_reply) \
5213 _(one_enable_disable_reply) \
5214 _(one_rloc_probe_enable_disable_reply) \
5215 _(one_map_register_enable_disable_reply) \
5216 _(one_map_register_set_ttl_reply) \
5217 _(one_set_transport_protocol_reply) \
5218 _(one_map_register_fallback_threshold_reply) \
5219 _(one_pitr_set_locator_set_reply) \
5220 _(one_map_request_mode_reply) \
5221 _(one_add_del_map_request_itr_rlocs_reply) \
5222 _(one_eid_table_add_del_map_reply) \
5223 _(one_use_petr_reply) \
5224 _(one_stats_enable_disable_reply) \
5225 _(one_add_del_l2_arp_entry_reply) \
5226 _(one_add_del_ndp_entry_reply) \
5227 _(one_stats_flush_reply) \
5228 _(one_enable_disable_xtr_mode_reply) \
5229 _(one_enable_disable_pitr_mode_reply) \
5230 _(one_enable_disable_petr_mode_reply) \
5231 _(gpe_enable_disable_reply) \
5232 _(gpe_set_encap_mode_reply) \
5233 _(gpe_add_del_iface_reply) \
5234 _(gpe_add_del_native_fwd_rpath_reply) \
5235 _(af_packet_delete_reply) \
5236 _(policer_classify_set_interface_reply) \
5237 _(netmap_create_reply) \
5238 _(netmap_delete_reply) \
5239 _(set_ipfix_exporter_reply) \
5240 _(set_ipfix_classify_stream_reply) \
5241 _(ipfix_classify_table_add_del_reply) \
5242 _(flow_classify_set_interface_reply) \
5243 _(sw_interface_span_enable_disable_reply) \
5244 _(pg_capture_reply) \
5245 _(pg_enable_disable_reply) \
5246 _(ip_source_and_port_range_check_add_del_reply) \
5247 _(ip_source_and_port_range_check_interface_add_del_reply)\
5248 _(delete_subif_reply) \
5249 _(l2_interface_pbb_tag_rewrite_reply) \
5251 _(feature_enable_disable_reply) \
5252 _(sw_interface_tag_add_del_reply) \
5253 _(hw_interface_set_mtu_reply) \
5254 _(p2p_ethernet_add_reply) \
5255 _(p2p_ethernet_del_reply) \
5256 _(lldp_config_reply) \
5257 _(sw_interface_set_lldp_reply) \
5258 _(tcp_configure_src_addresses_reply) \
5259 _(dns_enable_disable_reply) \
5260 _(dns_name_server_add_del_reply) \
5261 _(session_rule_add_del_reply) \
5262 _(ip_container_proxy_add_del_reply) \
5263 _(output_acl_set_interface_reply) \
5264 _(qos_record_enable_disable_reply)
5267 static void vl_api_##n##_t_handler \
5268 (vl_api_##n##_t * mp) \
5270 vat_main_t * vam = &vat_main; \
5271 i32 retval = ntohl(mp->retval); \
5272 if (vam->async_mode) { \
5273 vam->async_errors += (retval < 0); \
5275 vam->retval = retval; \
5276 vam->result_ready = 1; \
5279 foreach_standard_reply_retval_handler;
5283 static void vl_api_##n##_t_handler_json \
5284 (vl_api_##n##_t * mp) \
5286 vat_main_t * vam = &vat_main; \
5287 vat_json_node_t node; \
5288 vat_json_init_object(&node); \
5289 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
5290 vat_json_print(vam->ofp, &node); \
5291 vam->retval = ntohl(mp->retval); \
5292 vam->result_ready = 1; \
5294 foreach_standard_reply_retval_handler;
5298 * Table of message reply handlers, must include boilerplate handlers
5302 #define foreach_vpe_api_reply_msg \
5303 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
5304 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
5305 _(SW_INTERFACE_DETAILS, sw_interface_details) \
5306 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
5307 _(CONTROL_PING_REPLY, control_ping_reply) \
5308 _(CLI_REPLY, cli_reply) \
5309 _(CLI_INBAND_REPLY, cli_inband_reply) \
5310 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
5311 sw_interface_add_del_address_reply) \
5312 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
5313 _(SW_INTERFACE_SET_RX_PLACEMENT_REPLY, sw_interface_set_rx_placement_reply) \
5314 _(SW_INTERFACE_RX_PLACEMENT_DETAILS, sw_interface_rx_placement_details) \
5315 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
5316 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
5317 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
5318 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
5319 _(SW_INTERFACE_SET_GENEVE_BYPASS_REPLY, sw_interface_set_geneve_bypass_reply) \
5320 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
5321 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
5322 sw_interface_set_l2_xconnect_reply) \
5323 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
5324 sw_interface_set_l2_bridge_reply) \
5325 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
5326 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
5327 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
5328 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
5329 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
5330 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
5331 _(L2_FLAGS_REPLY, l2_flags_reply) \
5332 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
5333 _(TAP_CREATE_V2_REPLY, tap_create_v2_reply) \
5334 _(TAP_DELETE_V2_REPLY, tap_delete_v2_reply) \
5335 _(SW_INTERFACE_TAP_V2_DETAILS, sw_interface_tap_v2_details) \
5336 _(VIRTIO_PCI_CREATE_REPLY, virtio_pci_create_reply) \
5337 _(VIRTIO_PCI_DELETE_REPLY, virtio_pci_delete_reply) \
5338 _(SW_INTERFACE_VIRTIO_PCI_DETAILS, sw_interface_virtio_pci_details) \
5339 _(BOND_CREATE_REPLY, bond_create_reply) \
5340 _(BOND_DELETE_REPLY, bond_delete_reply) \
5341 _(BOND_ENSLAVE_REPLY, bond_enslave_reply) \
5342 _(BOND_DETACH_SLAVE_REPLY, bond_detach_slave_reply) \
5343 _(SW_INTERFACE_BOND_DETAILS, sw_interface_bond_details) \
5344 _(SW_INTERFACE_SLAVE_DETAILS, sw_interface_slave_details) \
5345 _(IP_ROUTE_ADD_DEL_REPLY, ip_route_add_del_reply) \
5346 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
5347 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
5348 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
5349 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
5350 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
5351 _(BIER_ROUTE_ADD_DEL_REPLY, bier_route_add_del_reply) \
5352 _(BIER_TABLE_ADD_DEL_REPLY, bier_table_add_del_reply) \
5353 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
5354 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
5355 proxy_arp_intfc_enable_disable_reply) \
5356 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
5357 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
5358 sw_interface_set_unnumbered_reply) \
5359 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
5360 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
5361 _(CREATE_SUBIF_REPLY, create_subif_reply) \
5362 _(RESET_FIB_REPLY, reset_fib_reply) \
5363 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
5364 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
5365 _(DHCP_PROXY_DETAILS, dhcp_proxy_details) \
5366 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
5367 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
5368 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
5369 sw_interface_ip6_enable_disable_reply) \
5370 _(IP6ND_PROXY_ADD_DEL_REPLY, ip6nd_proxy_add_del_reply) \
5371 _(IP6ND_PROXY_DETAILS, ip6nd_proxy_details) \
5372 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
5373 sw_interface_ip6nd_ra_prefix_reply) \
5374 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
5375 sw_interface_ip6nd_ra_config_reply) \
5376 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
5377 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
5378 _(SR_MPLS_POLICY_ADD_REPLY, sr_mpls_policy_add_reply) \
5379 _(SR_MPLS_POLICY_MOD_REPLY, sr_mpls_policy_mod_reply) \
5380 _(SR_MPLS_POLICY_DEL_REPLY, sr_mpls_policy_del_reply) \
5381 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
5382 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
5383 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
5384 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
5385 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
5386 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
5387 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
5388 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
5389 classify_set_interface_ip_table_reply) \
5390 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
5391 classify_set_interface_l2_tables_reply) \
5392 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
5393 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
5394 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
5395 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
5396 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
5397 l2tpv3_interface_enable_disable_reply) \
5398 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
5399 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
5400 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
5401 _(VXLAN_OFFLOAD_RX_REPLY, vxlan_offload_rx_reply) \
5402 _(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
5403 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
5404 _(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
5405 _(GRE_TUNNEL_ADD_DEL_REPLY, gre_tunnel_add_del_reply) \
5406 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
5407 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
5408 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
5409 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
5410 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
5411 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
5412 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
5413 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
5414 _(SHOW_VERSION_REPLY, show_version_reply) \
5415 _(SHOW_THREADS_REPLY, show_threads_reply) \
5416 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
5417 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
5418 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
5419 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
5420 _(IP_PROBE_NEIGHBOR_REPLY, ip_probe_neighbor_reply) \
5421 _(IP_SCAN_NEIGHBOR_ENABLE_DISABLE_REPLY, ip_scan_neighbor_enable_disable_reply) \
5422 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
5423 _(IP4_ARP_EVENT, ip4_arp_event) \
5424 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
5425 _(IP6_ND_EVENT, ip6_nd_event) \
5426 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
5427 _(L2_MACS_EVENT, l2_macs_event) \
5428 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
5429 _(IP_ADDRESS_DETAILS, ip_address_details) \
5430 _(IP_DETAILS, ip_details) \
5431 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
5432 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
5433 _(IPSEC_SPD_ENTRY_ADD_DEL_REPLY, ipsec_spd_entry_add_del_reply) \
5434 _(IPSEC_SAD_ENTRY_ADD_DEL_REPLY, ipsec_sad_entry_add_del_reply) \
5435 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
5436 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
5437 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
5438 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
5439 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
5440 _(BD_IP_MAC_FLUSH_REPLY, bd_ip_mac_flush_reply) \
5441 _(BD_IP_MAC_DETAILS, bd_ip_mac_details) \
5442 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
5443 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
5444 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
5445 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
5446 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
5447 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
5448 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
5449 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
5450 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
5451 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
5452 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
5453 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
5454 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
5455 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
5456 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
5457 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
5458 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
5459 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
5460 one_map_register_enable_disable_reply) \
5461 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
5462 _(ONE_SET_TRANSPORT_PROTOCOL_REPLY, one_set_transport_protocol_reply) \
5463 _(ONE_GET_TRANSPORT_PROTOCOL_REPLY, one_get_transport_protocol_reply) \
5464 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5465 one_map_register_fallback_threshold_reply) \
5466 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
5467 one_rloc_probe_enable_disable_reply) \
5468 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
5469 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
5470 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
5471 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
5472 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
5473 _(ONE_LOCATOR_DETAILS, one_locator_details) \
5474 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
5475 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
5476 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
5477 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
5478 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
5479 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
5480 _(ONE_STATS_DETAILS, one_stats_details) \
5481 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
5482 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
5483 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
5484 show_one_stats_enable_disable_reply) \
5485 _(ONE_ADD_DEL_NDP_ENTRY_REPLY, one_add_del_ndp_entry_reply) \
5486 _(ONE_NDP_BD_GET_REPLY, one_ndp_bd_get_reply) \
5487 _(ONE_NDP_ENTRIES_GET_REPLY, one_ndp_entries_get_reply) \
5488 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
5489 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
5490 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
5491 _(ONE_ENABLE_DISABLE_XTR_MODE_REPLY, one_enable_disable_xtr_mode_reply) \
5492 _(ONE_ENABLE_DISABLE_PITR_MODE_REPLY, \
5493 one_enable_disable_pitr_mode_reply) \
5494 _(ONE_ENABLE_DISABLE_PETR_MODE_REPLY, \
5495 one_enable_disable_petr_mode_reply) \
5496 _(ONE_SHOW_XTR_MODE_REPLY, one_show_xtr_mode_reply) \
5497 _(ONE_SHOW_PITR_MODE_REPLY, one_show_pitr_mode_reply) \
5498 _(ONE_SHOW_PETR_MODE_REPLY, one_show_petr_mode_reply) \
5499 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
5500 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
5501 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
5502 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
5503 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
5504 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
5505 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
5506 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
5507 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
5508 gpe_add_del_native_fwd_rpath_reply) \
5509 _(GPE_FWD_ENTRY_PATH_DETAILS, \
5510 gpe_fwd_entry_path_details) \
5511 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
5512 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
5513 one_add_del_map_request_itr_rlocs_reply) \
5514 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
5515 one_get_map_request_itr_rlocs_reply) \
5516 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
5517 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
5518 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
5519 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
5520 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
5521 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
5522 show_one_map_register_state_reply) \
5523 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
5524 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5525 show_one_map_register_fallback_threshold_reply) \
5526 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
5527 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
5528 _(AF_PACKET_DETAILS, af_packet_details) \
5529 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
5530 _(POLICER_DETAILS, policer_details) \
5531 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
5532 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
5533 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
5534 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
5535 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
5536 _(MPLS_TABLE_DETAILS, mpls_table_details) \
5537 _(MPLS_ROUTE_DETAILS, mpls_route_details) \
5538 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
5539 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
5540 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
5541 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
5542 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
5543 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
5544 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
5545 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5546 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5547 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5548 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5549 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5550 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5551 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5552 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5553 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5554 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5555 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5556 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5557 ip_source_and_port_range_check_add_del_reply) \
5558 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5559 ip_source_and_port_range_check_interface_add_del_reply) \
5560 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5561 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5562 _(SET_PUNT_REPLY, set_punt_reply) \
5563 _(IP_TABLE_DETAILS, ip_table_details) \
5564 _(IP_ROUTE_DETAILS, ip_route_details) \
5565 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5566 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5567 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5568 _(HW_INTERFACE_SET_MTU_REPLY, hw_interface_set_mtu_reply) \
5569 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
5570 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5571 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5572 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5573 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5574 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply) \
5575 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
5576 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
5577 _(DNS_ENABLE_DISABLE_REPLY, dns_enable_disable_reply) \
5578 _(DNS_NAME_SERVER_ADD_DEL_REPLY, dns_name_server_add_del_reply) \
5579 _(DNS_RESOLVE_NAME_REPLY, dns_resolve_name_reply) \
5580 _(DNS_RESOLVE_IP_REPLY, dns_resolve_ip_reply) \
5581 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
5582 _(SESSION_RULES_DETAILS, session_rules_details) \
5583 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
5584 _(OUTPUT_ACL_SET_INTERFACE_REPLY, output_acl_set_interface_reply) \
5585 _(QOS_RECORD_ENABLE_DISABLE_REPLY, qos_record_enable_disable_reply)
5587 #define foreach_standalone_reply_msg \
5588 _(SW_INTERFACE_EVENT, sw_interface_event)
5596 #define STR_VTR_OP_CASE(op) \
5597 case L2_VTR_ ## op: \
5601 str_vtr_op (u32 vtr_op)
5605 STR_VTR_OP_CASE (DISABLED);
5606 STR_VTR_OP_CASE (PUSH_1);
5607 STR_VTR_OP_CASE (PUSH_2);
5608 STR_VTR_OP_CASE (POP_1);
5609 STR_VTR_OP_CASE (POP_2);
5610 STR_VTR_OP_CASE (TRANSLATE_1_1);
5611 STR_VTR_OP_CASE (TRANSLATE_1_2);
5612 STR_VTR_OP_CASE (TRANSLATE_2_1);
5613 STR_VTR_OP_CASE (TRANSLATE_2_2);
5620 dump_sub_interface_table (vat_main_t * vam)
5622 const sw_interface_subif_t *sub = NULL;
5624 if (vam->json_output)
5627 ("JSON output supported only for VPE API calls and dump_stats_table");
5632 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5633 "Interface", "sw_if_index",
5634 "sub id", "dot1ad", "tags", "outer id",
5635 "inner id", "exact", "default", "outer any", "inner any");
5637 vec_foreach (sub, vam->sw_if_subif_table)
5640 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5641 sub->interface_name,
5643 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5644 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5645 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5646 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5647 if (sub->vtr_op != L2_VTR_DISABLED)
5650 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
5651 "tag1: %d tag2: %d ]",
5652 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
5653 sub->vtr_tag1, sub->vtr_tag2);
5661 name_sort_cmp (void *a1, void *a2)
5663 name_sort_t *n1 = a1;
5664 name_sort_t *n2 = a2;
5666 return strcmp ((char *) n1->name, (char *) n2->name);
5670 dump_interface_table (vat_main_t * vam)
5673 name_sort_t *nses = 0, *ns;
5675 if (vam->json_output)
5678 ("JSON output supported only for VPE API calls and dump_stats_table");
5683 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5685 vec_add2 (nses, ns, 1);
5686 ns->name = (u8 *)(p->key);
5687 ns->value = (u32) p->value[0];
5691 vec_sort_with_function (nses, name_sort_cmp);
5693 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
5694 vec_foreach (ns, nses)
5696 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
5703 dump_ip_table (vat_main_t * vam, int is_ipv6)
5705 const ip_details_t *det = NULL;
5706 const ip_address_details_t *address = NULL;
5709 print (vam->ofp, "%-12s", "sw_if_index");
5711 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
5718 print (vam->ofp, "%-12d", i);
5719 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
5724 vec_foreach (address, det->addr)
5728 is_ipv6 ? format_ip6_address : format_ip4_address,
5729 address->ip, address->prefix_length);
5737 dump_ipv4_table (vat_main_t * vam)
5739 if (vam->json_output)
5742 ("JSON output supported only for VPE API calls and dump_stats_table");
5746 return dump_ip_table (vam, 0);
5750 dump_ipv6_table (vat_main_t * vam)
5752 if (vam->json_output)
5755 ("JSON output supported only for VPE API calls and dump_stats_table");
5759 return dump_ip_table (vam, 1);
5763 * Pass CLI buffers directly in the CLI_INBAND API message,
5764 * instead of an additional shared memory area.
5767 exec_inband (vat_main_t * vam)
5769 vl_api_cli_inband_t *mp;
5770 unformat_input_t *i = vam->input;
5773 if (vec_len (i->buffer) == 0)
5776 if (vam->exec_mode == 0 && unformat (i, "mode"))
5781 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
5788 * In order for the CLI command to work, it
5789 * must be a vector ending in \n, not a C-string ending
5792 u32 len = vec_len (vam->input->buffer);
5793 M2 (CLI_INBAND, mp, len);
5794 vl_api_to_api_string (len - 1, (const char *) vam->input->buffer, &mp->cmd);
5798 /* json responses may or may not include a useful reply... */
5799 if (vec_len (vam->cmd_reply))
5800 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
5805 exec (vat_main_t * vam)
5807 return exec_inband (vam);
5811 api_create_loopback (vat_main_t * vam)
5813 unformat_input_t *i = vam->input;
5814 vl_api_create_loopback_t *mp;
5815 vl_api_create_loopback_instance_t *mp_lbi;
5818 u8 is_specified = 0;
5819 u32 user_instance = 0;
5822 clib_memset (mac_address, 0, sizeof (mac_address));
5824 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5826 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5828 if (unformat (i, "instance %d", &user_instance))
5836 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
5837 mp_lbi->is_specified = is_specified;
5839 mp_lbi->user_instance = htonl (user_instance);
5841 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
5846 /* Construct the API message */
5847 M (CREATE_LOOPBACK, mp);
5849 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
5858 api_delete_loopback (vat_main_t * vam)
5860 unformat_input_t *i = vam->input;
5861 vl_api_delete_loopback_t *mp;
5862 u32 sw_if_index = ~0;
5865 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5867 if (unformat (i, "sw_if_index %d", &sw_if_index))
5873 if (sw_if_index == ~0)
5875 errmsg ("missing sw_if_index");
5879 /* Construct the API message */
5880 M (DELETE_LOOPBACK, mp);
5881 mp->sw_if_index = ntohl (sw_if_index);
5889 api_want_interface_events (vat_main_t * vam)
5891 unformat_input_t *i = vam->input;
5892 vl_api_want_interface_events_t *mp;
5896 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5898 if (unformat (i, "enable"))
5900 else if (unformat (i, "disable"))
5908 errmsg ("missing enable|disable");
5912 M (WANT_INTERFACE_EVENTS, mp);
5913 mp->enable_disable = enable;
5915 vam->interface_event_display = enable;
5923 /* Note: non-static, called once to set up the initial intfc table */
5925 api_sw_interface_dump (vat_main_t * vam)
5927 vl_api_sw_interface_dump_t *mp;
5928 vl_api_control_ping_t *mp_ping;
5930 name_sort_t *nses = 0, *ns;
5931 sw_interface_subif_t *sub = NULL;
5934 /* Toss the old name table */
5936 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5938 vec_add2 (nses, ns, 1);
5939 ns->name = (u8 *)(p->key);
5940 ns->value = (u32) p->value[0];
5944 hash_free (vam->sw_if_index_by_interface_name);
5946 vec_foreach (ns, nses) vec_free (ns->name);
5950 vec_foreach (sub, vam->sw_if_subif_table)
5952 vec_free (sub->interface_name);
5954 vec_free (vam->sw_if_subif_table);
5956 /* recreate the interface name hash table */
5957 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
5960 * Ask for all interface names. Otherwise, the epic catalog of
5961 * name filters becomes ridiculously long, and vat ends up needing
5962 * to be taught about new interface types.
5964 M (SW_INTERFACE_DUMP, mp);
5967 /* Use a control ping for synchronization */
5968 MPING (CONTROL_PING, mp_ping);
5976 api_sw_interface_set_flags (vat_main_t * vam)
5978 unformat_input_t *i = vam->input;
5979 vl_api_sw_interface_set_flags_t *mp;
5981 u8 sw_if_index_set = 0;
5985 /* Parse args required to build the message */
5986 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5988 if (unformat (i, "admin-up"))
5990 else if (unformat (i, "admin-down"))
5993 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5994 sw_if_index_set = 1;
5995 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5996 sw_if_index_set = 1;
6001 if (sw_if_index_set == 0)
6003 errmsg ("missing interface name or sw_if_index");
6007 /* Construct the API message */
6008 M (SW_INTERFACE_SET_FLAGS, mp);
6009 mp->sw_if_index = ntohl (sw_if_index);
6010 mp->flags = ntohl ((admin_up) ? IF_STATUS_API_FLAG_ADMIN_UP : 0);
6015 /* Wait for a reply, return the good/bad news... */
6021 api_sw_interface_set_rx_mode (vat_main_t * vam)
6023 unformat_input_t *i = vam->input;
6024 vl_api_sw_interface_set_rx_mode_t *mp;
6026 u8 sw_if_index_set = 0;
6028 u8 queue_id_valid = 0;
6030 vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN;
6032 /* Parse args required to build the message */
6033 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6035 if (unformat (i, "queue %d", &queue_id))
6037 else if (unformat (i, "polling"))
6038 mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
6039 else if (unformat (i, "interrupt"))
6040 mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT;
6041 else if (unformat (i, "adaptive"))
6042 mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE;
6044 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6045 sw_if_index_set = 1;
6046 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6047 sw_if_index_set = 1;
6052 if (sw_if_index_set == 0)
6054 errmsg ("missing interface name or sw_if_index");
6057 if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
6059 errmsg ("missing rx-mode");
6063 /* Construct the API message */
6064 M (SW_INTERFACE_SET_RX_MODE, mp);
6065 mp->sw_if_index = ntohl (sw_if_index);
6066 mp->mode = (vl_api_rx_mode_t) mode;
6067 mp->queue_id_valid = queue_id_valid;
6068 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
6073 /* Wait for a reply, return the good/bad news... */
6079 api_sw_interface_set_rx_placement (vat_main_t * vam)
6081 unformat_input_t *i = vam->input;
6082 vl_api_sw_interface_set_rx_placement_t *mp;
6084 u8 sw_if_index_set = 0;
6087 u32 queue_id, thread_index;
6089 /* Parse args required to build the message */
6090 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6092 if (unformat (i, "queue %d", &queue_id))
6094 else if (unformat (i, "main"))
6096 else if (unformat (i, "worker %d", &thread_index))
6099 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6100 sw_if_index_set = 1;
6101 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6102 sw_if_index_set = 1;
6107 if (sw_if_index_set == 0)
6109 errmsg ("missing interface name or sw_if_index");
6115 /* Construct the API message */
6116 M (SW_INTERFACE_SET_RX_PLACEMENT, mp);
6117 mp->sw_if_index = ntohl (sw_if_index);
6118 mp->worker_id = ntohl (thread_index);
6119 mp->queue_id = ntohl (queue_id);
6120 mp->is_main = is_main;
6124 /* Wait for a reply, return the good/bad news... */
6129 static void vl_api_sw_interface_rx_placement_details_t_handler
6130 (vl_api_sw_interface_rx_placement_details_t * mp)
6132 vat_main_t *vam = &vat_main;
6133 u32 worker_id = ntohl (mp->worker_id);
6136 "\n%-11d %-11s %-6d %-5d %-9s",
6137 ntohl (mp->sw_if_index), (worker_id == 0) ? "main" : "worker",
6138 worker_id, ntohl (mp->queue_id),
6140 1) ? "polling" : ((mp->mode == 2) ? "interrupt" : "adaptive"));
6143 static void vl_api_sw_interface_rx_placement_details_t_handler_json
6144 (vl_api_sw_interface_rx_placement_details_t * mp)
6146 vat_main_t *vam = &vat_main;
6147 vat_json_node_t *node = NULL;
6149 if (VAT_JSON_ARRAY != vam->json_tree.type)
6151 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
6152 vat_json_init_array (&vam->json_tree);
6154 node = vat_json_array_add (&vam->json_tree);
6156 vat_json_init_object (node);
6157 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
6158 vat_json_object_add_uint (node, "worker_id", ntohl (mp->worker_id));
6159 vat_json_object_add_uint (node, "queue_id", ntohl (mp->queue_id));
6160 vat_json_object_add_uint (node, "mode", mp->mode);
6164 api_sw_interface_rx_placement_dump (vat_main_t * vam)
6166 unformat_input_t *i = vam->input;
6167 vl_api_sw_interface_rx_placement_dump_t *mp;
6168 vl_api_control_ping_t *mp_ping;
6171 u8 sw_if_index_set = 0;
6173 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6175 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6177 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6184 "\n%-11s %-11s %-6s %-5s %-4s",
6185 "sw_if_index", "main/worker", "thread", "queue", "mode");
6187 /* Dump Interface rx placement */
6188 M (SW_INTERFACE_RX_PLACEMENT_DUMP, mp);
6190 if (sw_if_index_set)
6191 mp->sw_if_index = htonl (sw_if_index);
6193 mp->sw_if_index = ~0;
6197 /* Use a control ping for synchronization */
6198 MPING (CONTROL_PING, mp_ping);
6206 api_sw_interface_clear_stats (vat_main_t * vam)
6208 unformat_input_t *i = vam->input;
6209 vl_api_sw_interface_clear_stats_t *mp;
6211 u8 sw_if_index_set = 0;
6214 /* Parse args required to build the message */
6215 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6217 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6218 sw_if_index_set = 1;
6219 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6220 sw_if_index_set = 1;
6225 /* Construct the API message */
6226 M (SW_INTERFACE_CLEAR_STATS, mp);
6228 if (sw_if_index_set == 1)
6229 mp->sw_if_index = ntohl (sw_if_index);
6231 mp->sw_if_index = ~0;
6236 /* Wait for a reply, return the good/bad news... */
6242 api_sw_interface_add_del_address (vat_main_t * vam)
6244 unformat_input_t *i = vam->input;
6245 vl_api_sw_interface_add_del_address_t *mp;
6247 u8 sw_if_index_set = 0;
6248 u8 is_add = 1, del_all = 0;
6249 u32 address_length = 0;
6250 u8 v4_address_set = 0;
6251 u8 v6_address_set = 0;
6252 ip4_address_t v4address;
6253 ip6_address_t v6address;
6256 /* Parse args required to build the message */
6257 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6259 if (unformat (i, "del-all"))
6261 else if (unformat (i, "del"))
6264 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6265 sw_if_index_set = 1;
6266 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6267 sw_if_index_set = 1;
6268 else if (unformat (i, "%U/%d",
6269 unformat_ip4_address, &v4address, &address_length))
6271 else if (unformat (i, "%U/%d",
6272 unformat_ip6_address, &v6address, &address_length))
6278 if (sw_if_index_set == 0)
6280 errmsg ("missing interface name or sw_if_index");
6283 if (v4_address_set && v6_address_set)
6285 errmsg ("both v4 and v6 addresses set");
6288 if (!v4_address_set && !v6_address_set && !del_all)
6290 errmsg ("no addresses set");
6294 /* Construct the API message */
6295 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
6297 mp->sw_if_index = ntohl (sw_if_index);
6298 mp->is_add = is_add;
6299 mp->del_all = del_all;
6302 mp->prefix.address.af = ADDRESS_IP6;
6303 clib_memcpy (mp->prefix.address.un.ip6, &v6address, sizeof (v6address));
6307 mp->prefix.address.af = ADDRESS_IP4;
6308 clib_memcpy (mp->prefix.address.un.ip4, &v4address, sizeof (v4address));
6310 mp->prefix.len = address_length;
6315 /* Wait for a reply, return good/bad news */
6321 api_sw_interface_set_mpls_enable (vat_main_t * vam)
6323 unformat_input_t *i = vam->input;
6324 vl_api_sw_interface_set_mpls_enable_t *mp;
6326 u8 sw_if_index_set = 0;
6330 /* Parse args required to build the message */
6331 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6333 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6334 sw_if_index_set = 1;
6335 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6336 sw_if_index_set = 1;
6337 else if (unformat (i, "disable"))
6339 else if (unformat (i, "dis"))
6345 if (sw_if_index_set == 0)
6347 errmsg ("missing interface name or sw_if_index");
6351 /* Construct the API message */
6352 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
6354 mp->sw_if_index = ntohl (sw_if_index);
6355 mp->enable = enable;
6360 /* Wait for a reply... */
6366 api_sw_interface_set_table (vat_main_t * vam)
6368 unformat_input_t *i = vam->input;
6369 vl_api_sw_interface_set_table_t *mp;
6370 u32 sw_if_index, vrf_id = 0;
6371 u8 sw_if_index_set = 0;
6375 /* Parse args required to build the message */
6376 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6378 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6379 sw_if_index_set = 1;
6380 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6381 sw_if_index_set = 1;
6382 else if (unformat (i, "vrf %d", &vrf_id))
6384 else if (unformat (i, "ipv6"))
6390 if (sw_if_index_set == 0)
6392 errmsg ("missing interface name or sw_if_index");
6396 /* Construct the API message */
6397 M (SW_INTERFACE_SET_TABLE, mp);
6399 mp->sw_if_index = ntohl (sw_if_index);
6400 mp->is_ipv6 = is_ipv6;
6401 mp->vrf_id = ntohl (vrf_id);
6406 /* Wait for a reply... */
6411 static void vl_api_sw_interface_get_table_reply_t_handler
6412 (vl_api_sw_interface_get_table_reply_t * mp)
6414 vat_main_t *vam = &vat_main;
6416 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6418 vam->retval = ntohl (mp->retval);
6419 vam->result_ready = 1;
6423 static void vl_api_sw_interface_get_table_reply_t_handler_json
6424 (vl_api_sw_interface_get_table_reply_t * mp)
6426 vat_main_t *vam = &vat_main;
6427 vat_json_node_t node;
6429 vat_json_init_object (&node);
6430 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6431 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6433 vat_json_print (vam->ofp, &node);
6434 vat_json_free (&node);
6436 vam->retval = ntohl (mp->retval);
6437 vam->result_ready = 1;
6441 api_sw_interface_get_table (vat_main_t * vam)
6443 unformat_input_t *i = vam->input;
6444 vl_api_sw_interface_get_table_t *mp;
6446 u8 sw_if_index_set = 0;
6450 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6452 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6453 sw_if_index_set = 1;
6454 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6455 sw_if_index_set = 1;
6456 else if (unformat (i, "ipv6"))
6462 if (sw_if_index_set == 0)
6464 errmsg ("missing interface name or sw_if_index");
6468 M (SW_INTERFACE_GET_TABLE, mp);
6469 mp->sw_if_index = htonl (sw_if_index);
6470 mp->is_ipv6 = is_ipv6;
6478 api_sw_interface_set_vpath (vat_main_t * vam)
6480 unformat_input_t *i = vam->input;
6481 vl_api_sw_interface_set_vpath_t *mp;
6482 u32 sw_if_index = 0;
6483 u8 sw_if_index_set = 0;
6487 /* Parse args required to build the message */
6488 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6490 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6491 sw_if_index_set = 1;
6492 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6493 sw_if_index_set = 1;
6494 else if (unformat (i, "enable"))
6496 else if (unformat (i, "disable"))
6502 if (sw_if_index_set == 0)
6504 errmsg ("missing interface name or sw_if_index");
6508 /* Construct the API message */
6509 M (SW_INTERFACE_SET_VPATH, mp);
6511 mp->sw_if_index = ntohl (sw_if_index);
6512 mp->enable = is_enable;
6517 /* Wait for a reply... */
6523 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
6525 unformat_input_t *i = vam->input;
6526 vl_api_sw_interface_set_vxlan_bypass_t *mp;
6527 u32 sw_if_index = 0;
6528 u8 sw_if_index_set = 0;
6533 /* Parse args required to build the message */
6534 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6536 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6537 sw_if_index_set = 1;
6538 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6539 sw_if_index_set = 1;
6540 else if (unformat (i, "enable"))
6542 else if (unformat (i, "disable"))
6544 else if (unformat (i, "ip4"))
6546 else if (unformat (i, "ip6"))
6552 if (sw_if_index_set == 0)
6554 errmsg ("missing interface name or sw_if_index");
6558 /* Construct the API message */
6559 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
6561 mp->sw_if_index = ntohl (sw_if_index);
6562 mp->enable = is_enable;
6563 mp->is_ipv6 = is_ipv6;
6568 /* Wait for a reply... */
6574 api_sw_interface_set_geneve_bypass (vat_main_t * vam)
6576 unformat_input_t *i = vam->input;
6577 vl_api_sw_interface_set_geneve_bypass_t *mp;
6578 u32 sw_if_index = 0;
6579 u8 sw_if_index_set = 0;
6584 /* Parse args required to build the message */
6585 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6587 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6588 sw_if_index_set = 1;
6589 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6590 sw_if_index_set = 1;
6591 else if (unformat (i, "enable"))
6593 else if (unformat (i, "disable"))
6595 else if (unformat (i, "ip4"))
6597 else if (unformat (i, "ip6"))
6603 if (sw_if_index_set == 0)
6605 errmsg ("missing interface name or sw_if_index");
6609 /* Construct the API message */
6610 M (SW_INTERFACE_SET_GENEVE_BYPASS, mp);
6612 mp->sw_if_index = ntohl (sw_if_index);
6613 mp->enable = is_enable;
6614 mp->is_ipv6 = is_ipv6;
6619 /* Wait for a reply... */
6625 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
6627 unformat_input_t *i = vam->input;
6628 vl_api_sw_interface_set_l2_xconnect_t *mp;
6630 u8 rx_sw_if_index_set = 0;
6632 u8 tx_sw_if_index_set = 0;
6636 /* Parse args required to build the message */
6637 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6639 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6640 rx_sw_if_index_set = 1;
6641 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6642 tx_sw_if_index_set = 1;
6643 else if (unformat (i, "rx"))
6645 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6647 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6649 rx_sw_if_index_set = 1;
6654 else if (unformat (i, "tx"))
6656 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6658 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6660 tx_sw_if_index_set = 1;
6665 else if (unformat (i, "enable"))
6667 else if (unformat (i, "disable"))
6673 if (rx_sw_if_index_set == 0)
6675 errmsg ("missing rx interface name or rx_sw_if_index");
6679 if (enable && (tx_sw_if_index_set == 0))
6681 errmsg ("missing tx interface name or tx_sw_if_index");
6685 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
6687 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6688 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6689 mp->enable = enable;
6697 api_sw_interface_set_l2_bridge (vat_main_t * vam)
6699 unformat_input_t *i = vam->input;
6700 vl_api_sw_interface_set_l2_bridge_t *mp;
6701 vl_api_l2_port_type_t port_type;
6703 u8 rx_sw_if_index_set = 0;
6710 port_type = L2_API_PORT_TYPE_NORMAL;
6712 /* Parse args required to build the message */
6713 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6715 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
6716 rx_sw_if_index_set = 1;
6717 else if (unformat (i, "bd_id %d", &bd_id))
6721 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
6722 rx_sw_if_index_set = 1;
6723 else if (unformat (i, "shg %d", &shg))
6725 else if (unformat (i, "bvi"))
6726 port_type = L2_API_PORT_TYPE_BVI;
6727 else if (unformat (i, "uu-fwd"))
6728 port_type = L2_API_PORT_TYPE_UU_FWD;
6729 else if (unformat (i, "enable"))
6731 else if (unformat (i, "disable"))
6737 if (rx_sw_if_index_set == 0)
6739 errmsg ("missing rx interface name or sw_if_index");
6743 if (enable && (bd_id_set == 0))
6745 errmsg ("missing bridge domain");
6749 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
6751 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6752 mp->bd_id = ntohl (bd_id);
6754 mp->port_type = ntohl (port_type);
6755 mp->enable = enable;
6763 api_bridge_domain_dump (vat_main_t * vam)
6765 unformat_input_t *i = vam->input;
6766 vl_api_bridge_domain_dump_t *mp;
6767 vl_api_control_ping_t *mp_ping;
6771 /* Parse args required to build the message */
6772 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6774 if (unformat (i, "bd_id %d", &bd_id))
6780 M (BRIDGE_DOMAIN_DUMP, mp);
6781 mp->bd_id = ntohl (bd_id);
6784 /* Use a control ping for synchronization */
6785 MPING (CONTROL_PING, mp_ping);
6793 api_bridge_domain_add_del (vat_main_t * vam)
6795 unformat_input_t *i = vam->input;
6796 vl_api_bridge_domain_add_del_t *mp;
6799 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
6804 /* Parse args required to build the message */
6805 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6807 if (unformat (i, "bd_id %d", &bd_id))
6809 else if (unformat (i, "flood %d", &flood))
6811 else if (unformat (i, "uu-flood %d", &uu_flood))
6813 else if (unformat (i, "forward %d", &forward))
6815 else if (unformat (i, "learn %d", &learn))
6817 else if (unformat (i, "arp-term %d", &arp_term))
6819 else if (unformat (i, "mac-age %d", &mac_age))
6821 else if (unformat (i, "bd-tag %s", &bd_tag))
6823 else if (unformat (i, "del"))
6826 flood = uu_flood = forward = learn = 0;
6834 errmsg ("missing bridge domain");
6841 errmsg ("mac age must be less than 256 ");
6846 if ((bd_tag) && (vec_len (bd_tag) > 63))
6848 errmsg ("bd-tag cannot be longer than 63");
6853 M (BRIDGE_DOMAIN_ADD_DEL, mp);
6855 mp->bd_id = ntohl (bd_id);
6857 mp->uu_flood = uu_flood;
6858 mp->forward = forward;
6860 mp->arp_term = arp_term;
6861 mp->is_add = is_add;
6862 mp->mac_age = (u8) mac_age;
6865 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
6866 mp->bd_tag[vec_len (bd_tag)] = 0;
6877 api_l2fib_flush_bd (vat_main_t * vam)
6879 unformat_input_t *i = vam->input;
6880 vl_api_l2fib_flush_bd_t *mp;
6884 /* Parse args required to build the message */
6885 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6887 if (unformat (i, "bd_id %d", &bd_id));
6894 errmsg ("missing bridge domain");
6898 M (L2FIB_FLUSH_BD, mp);
6900 mp->bd_id = htonl (bd_id);
6908 api_l2fib_flush_int (vat_main_t * vam)
6910 unformat_input_t *i = vam->input;
6911 vl_api_l2fib_flush_int_t *mp;
6912 u32 sw_if_index = ~0;
6915 /* Parse args required to build the message */
6916 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6918 if (unformat (i, "sw_if_index %d", &sw_if_index));
6920 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
6925 if (sw_if_index == ~0)
6927 errmsg ("missing interface name or sw_if_index");
6931 M (L2FIB_FLUSH_INT, mp);
6933 mp->sw_if_index = ntohl (sw_if_index);
6941 api_l2fib_add_del (vat_main_t * vam)
6943 unformat_input_t *i = vam->input;
6944 vl_api_l2fib_add_del_t *mp;
6950 u32 sw_if_index = 0;
6951 u8 sw_if_index_set = 0;
6960 /* Parse args required to build the message */
6961 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6963 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
6965 else if (unformat (i, "bd_id %d", &bd_id))
6967 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6968 sw_if_index_set = 1;
6969 else if (unformat (i, "sw_if"))
6971 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6974 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6975 sw_if_index_set = 1;
6980 else if (unformat (i, "static"))
6982 else if (unformat (i, "filter"))
6987 else if (unformat (i, "bvi"))
6992 else if (unformat (i, "del"))
6994 else if (unformat (i, "count %d", &count))
7002 errmsg ("missing mac address");
7008 errmsg ("missing bridge domain");
7012 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
7014 errmsg ("missing interface name or sw_if_index");
7020 /* Turn on async mode */
7021 vam->async_mode = 1;
7022 vam->async_errors = 0;
7023 before = vat_time_now (vam);
7026 for (j = 0; j < count; j++)
7028 M (L2FIB_ADD_DEL, mp);
7030 clib_memcpy (mp->mac, mac, 6);
7031 mp->bd_id = ntohl (bd_id);
7032 mp->is_add = is_add;
7033 mp->sw_if_index = ntohl (sw_if_index);
7037 mp->static_mac = static_mac;
7038 mp->filter_mac = filter_mac;
7039 mp->bvi_mac = bvi_mac;
7041 increment_mac_address (mac);
7048 vl_api_control_ping_t *mp_ping;
7051 /* Shut off async mode */
7052 vam->async_mode = 0;
7054 MPING (CONTROL_PING, mp_ping);
7057 timeout = vat_time_now (vam) + 1.0;
7058 while (vat_time_now (vam) < timeout)
7059 if (vam->result_ready == 1)
7064 if (vam->retval == -99)
7067 if (vam->async_errors > 0)
7069 errmsg ("%d asynchronous errors", vam->async_errors);
7072 vam->async_errors = 0;
7073 after = vat_time_now (vam);
7075 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
7076 count, after - before, count / (after - before));
7082 /* Wait for a reply... */
7086 /* Return the good/bad news */
7087 return (vam->retval);
7091 api_bridge_domain_set_mac_age (vat_main_t * vam)
7093 unformat_input_t *i = vam->input;
7094 vl_api_bridge_domain_set_mac_age_t *mp;
7099 /* Parse args required to build the message */
7100 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7102 if (unformat (i, "bd_id %d", &bd_id));
7103 else if (unformat (i, "mac-age %d", &mac_age));
7110 errmsg ("missing bridge domain");
7116 errmsg ("mac age must be less than 256 ");
7120 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
7122 mp->bd_id = htonl (bd_id);
7123 mp->mac_age = (u8) mac_age;
7131 api_l2_flags (vat_main_t * vam)
7133 unformat_input_t *i = vam->input;
7134 vl_api_l2_flags_t *mp;
7137 u8 sw_if_index_set = 0;
7141 /* Parse args required to build the message */
7142 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7144 if (unformat (i, "sw_if_index %d", &sw_if_index))
7145 sw_if_index_set = 1;
7146 else if (unformat (i, "sw_if"))
7148 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7151 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7152 sw_if_index_set = 1;
7157 else if (unformat (i, "learn"))
7159 else if (unformat (i, "forward"))
7161 else if (unformat (i, "flood"))
7163 else if (unformat (i, "uu-flood"))
7164 flags |= L2_UU_FLOOD;
7165 else if (unformat (i, "arp-term"))
7166 flags |= L2_ARP_TERM;
7167 else if (unformat (i, "off"))
7169 else if (unformat (i, "disable"))
7175 if (sw_if_index_set == 0)
7177 errmsg ("missing interface name or sw_if_index");
7183 mp->sw_if_index = ntohl (sw_if_index);
7184 mp->feature_bitmap = ntohl (flags);
7185 mp->is_set = is_set;
7193 api_bridge_flags (vat_main_t * vam)
7195 unformat_input_t *i = vam->input;
7196 vl_api_bridge_flags_t *mp;
7200 bd_flags_t flags = 0;
7203 /* Parse args required to build the message */
7204 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7206 if (unformat (i, "bd_id %d", &bd_id))
7208 else if (unformat (i, "learn"))
7209 flags |= BRIDGE_API_FLAG_LEARN;
7210 else if (unformat (i, "forward"))
7211 flags |= BRIDGE_API_FLAG_FWD;
7212 else if (unformat (i, "flood"))
7213 flags |= BRIDGE_API_FLAG_FLOOD;
7214 else if (unformat (i, "uu-flood"))
7215 flags |= BRIDGE_API_FLAG_UU_FLOOD;
7216 else if (unformat (i, "arp-term"))
7217 flags |= BRIDGE_API_FLAG_ARP_TERM;
7218 else if (unformat (i, "off"))
7220 else if (unformat (i, "disable"))
7228 errmsg ("missing bridge domain");
7232 M (BRIDGE_FLAGS, mp);
7234 mp->bd_id = ntohl (bd_id);
7235 mp->flags = ntohl (flags);
7236 mp->is_set = is_set;
7244 api_bd_ip_mac_add_del (vat_main_t * vam)
7246 vl_api_address_t ip = VL_API_ZERO_ADDRESS;
7247 vl_api_mac_address_t mac = { 0 };
7248 unformat_input_t *i = vam->input;
7249 vl_api_bd_ip_mac_add_del_t *mp;
7258 /* Parse args required to build the message */
7259 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7261 if (unformat (i, "bd_id %d", &bd_id))
7265 else if (unformat (i, "%U", unformat_vl_api_address, &ip))
7269 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
7273 else if (unformat (i, "del"))
7281 errmsg ("missing bridge domain");
7284 else if (ip_set == 0)
7286 errmsg ("missing IP address");
7289 else if (mac_set == 0)
7291 errmsg ("missing MAC address");
7295 M (BD_IP_MAC_ADD_DEL, mp);
7297 mp->entry.bd_id = ntohl (bd_id);
7298 mp->is_add = is_add;
7300 clib_memcpy (&mp->entry.ip, &ip, sizeof (ip));
7301 clib_memcpy (&mp->entry.mac, &mac, sizeof (mac));
7309 api_bd_ip_mac_flush (vat_main_t * vam)
7311 unformat_input_t *i = vam->input;
7312 vl_api_bd_ip_mac_flush_t *mp;
7317 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7319 if (unformat (i, "bd_id %d", &bd_id))
7329 errmsg ("missing bridge domain");
7333 M (BD_IP_MAC_FLUSH, mp);
7335 mp->bd_id = ntohl (bd_id);
7342 static void vl_api_bd_ip_mac_details_t_handler
7343 (vl_api_bd_ip_mac_details_t * mp)
7345 vat_main_t *vam = &vat_main;
7349 ntohl (mp->entry.bd_id),
7350 format_vl_api_mac_address, mp->entry.mac,
7351 format_vl_api_address, &mp->entry.ip);
7354 static void vl_api_bd_ip_mac_details_t_handler_json
7355 (vl_api_bd_ip_mac_details_t * mp)
7357 vat_main_t *vam = &vat_main;
7358 vat_json_node_t *node = NULL;
7360 if (VAT_JSON_ARRAY != vam->json_tree.type)
7362 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7363 vat_json_init_array (&vam->json_tree);
7365 node = vat_json_array_add (&vam->json_tree);
7367 vat_json_init_object (node);
7368 vat_json_object_add_uint (node, "bd_id", ntohl (mp->entry.bd_id));
7369 vat_json_object_add_string_copy (node, "mac_address",
7370 format (0, "%U", format_vl_api_mac_address,
7374 ip = format (0, "%U", format_vl_api_address, &mp->entry.ip);
7375 vat_json_object_add_string_copy (node, "ip_address", ip);
7380 api_bd_ip_mac_dump (vat_main_t * vam)
7382 unformat_input_t *i = vam->input;
7383 vl_api_bd_ip_mac_dump_t *mp;
7384 vl_api_control_ping_t *mp_ping;
7389 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7391 if (unformat (i, "bd_id %d", &bd_id))
7400 "\n%-5s %-7s %-20s %-30s",
7401 "bd_id", "is_ipv6", "mac_address", "ip_address");
7403 /* Dump Bridge Domain Ip to Mac entries */
7404 M (BD_IP_MAC_DUMP, mp);
7407 mp->bd_id = htonl (bd_id);
7413 /* Use a control ping for synchronization */
7414 MPING (CONTROL_PING, mp_ping);
7422 api_tap_create_v2 (vat_main_t * vam)
7424 unformat_input_t *i = vam->input;
7425 vl_api_tap_create_v2_t *mp;
7426 #define TAP_FLAG_GSO (1 << 0)
7430 u8 *host_if_name = 0;
7432 u8 host_mac_addr[6];
7433 u8 host_mac_addr_set = 0;
7434 u8 *host_bridge = 0;
7435 ip4_address_t host_ip4_addr;
7436 ip4_address_t host_ip4_gw;
7437 u8 host_ip4_gw_set = 0;
7438 u32 host_ip4_prefix_len = 0;
7439 ip6_address_t host_ip6_addr;
7440 ip6_address_t host_ip6_gw;
7441 u8 host_ip6_gw_set = 0;
7442 u32 host_ip6_prefix_len = 0;
7443 u8 host_mtu_set = 0;
7444 u32 host_mtu_size = 0;
7447 u32 rx_ring_sz = 0, tx_ring_sz = 0;
7449 clib_memset (mac_address, 0, sizeof (mac_address));
7451 /* Parse args required to build the message */
7452 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7454 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7458 else if (unformat (i, "id %u", &id))
7460 else if (unformat (i, "host-if-name %s", &host_if_name))
7462 else if (unformat (i, "host-ns %s", &host_ns))
7464 else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
7466 host_mac_addr_set = 1;
7467 else if (unformat (i, "host-bridge %s", &host_bridge))
7469 else if (unformat (i, "host-ip4-addr %U/%d", unformat_ip4_address,
7470 &host_ip4_addr, &host_ip4_prefix_len))
7472 else if (unformat (i, "host-ip6-addr %U/%d", unformat_ip6_address,
7473 &host_ip6_addr, &host_ip6_prefix_len))
7475 else if (unformat (i, "host-ip4-gw %U", unformat_ip4_address,
7477 host_ip4_gw_set = 1;
7478 else if (unformat (i, "host-ip6-gw %U", unformat_ip6_address,
7480 host_ip6_gw_set = 1;
7481 else if (unformat (i, "rx-ring-size %d", &rx_ring_sz))
7483 else if (unformat (i, "tx-ring-size %d", &tx_ring_sz))
7485 else if (unformat (i, "host-mtu-size %d", &host_mtu_size))
7487 else if (unformat (i, "no-gso"))
7488 tap_flags &= ~TAP_FLAG_GSO;
7489 else if (unformat (i, "gso"))
7490 tap_flags |= TAP_FLAG_GSO;
7495 if (vec_len (host_if_name) > 63)
7497 errmsg ("tap name too long. ");
7500 if (vec_len (host_ns) > 63)
7502 errmsg ("host name space too long. ");
7505 if (vec_len (host_bridge) > 63)
7507 errmsg ("host bridge name too long. ");
7510 if (host_ip4_prefix_len > 32)
7512 errmsg ("host ip4 prefix length not valid. ");
7515 if (host_ip6_prefix_len > 128)
7517 errmsg ("host ip6 prefix length not valid. ");
7520 if (!is_pow2 (rx_ring_sz))
7522 errmsg ("rx ring size must be power of 2. ");
7525 if (rx_ring_sz > 32768)
7527 errmsg ("rx ring size must be 32768 or lower. ");
7530 if (!is_pow2 (tx_ring_sz))
7532 errmsg ("tx ring size must be power of 2. ");
7535 if (tx_ring_sz > 32768)
7537 errmsg ("tx ring size must be 32768 or lower. ");
7540 if (host_mtu_set && (host_mtu_size < 64 || host_mtu_size > 65355))
7542 errmsg ("host MTU size must be in between 64 and 65355. ");
7546 /* Construct the API message */
7547 M (TAP_CREATE_V2, mp);
7549 mp->use_random_mac = random_mac;
7551 mp->id = ntohl (id);
7552 mp->host_namespace_set = host_ns != 0;
7553 mp->host_bridge_set = host_bridge != 0;
7554 mp->host_ip4_addr_set = host_ip4_prefix_len != 0;
7555 mp->host_ip6_addr_set = host_ip6_prefix_len != 0;
7556 mp->rx_ring_sz = ntohs (rx_ring_sz);
7557 mp->tx_ring_sz = ntohs (tx_ring_sz);
7558 mp->host_mtu_set = host_mtu_set;
7559 mp->host_mtu_size = ntohl (host_mtu_size);
7560 mp->tap_flags = ntohl (tap_flags);
7562 if (random_mac == 0)
7563 clib_memcpy (mp->mac_address, mac_address, 6);
7564 if (host_mac_addr_set)
7565 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
7567 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
7569 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
7571 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
7572 if (host_ip4_prefix_len)
7573 clib_memcpy (mp->host_ip4_addr, &host_ip4_addr, 4);
7574 if (host_ip6_prefix_len)
7575 clib_memcpy (mp->host_ip6_addr, &host_ip6_addr, 16);
7576 if (host_ip4_gw_set)
7577 clib_memcpy (mp->host_ip4_gw, &host_ip4_gw, 4);
7578 if (host_ip6_gw_set)
7579 clib_memcpy (mp->host_ip6_gw, &host_ip6_gw, 16);
7582 vec_free (host_if_name);
7583 vec_free (host_bridge);
7588 /* Wait for a reply... */
7594 api_tap_delete_v2 (vat_main_t * vam)
7596 unformat_input_t *i = vam->input;
7597 vl_api_tap_delete_v2_t *mp;
7598 u32 sw_if_index = ~0;
7599 u8 sw_if_index_set = 0;
7602 /* Parse args required to build the message */
7603 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7605 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7606 sw_if_index_set = 1;
7607 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7608 sw_if_index_set = 1;
7613 if (sw_if_index_set == 0)
7615 errmsg ("missing vpp interface name. ");
7619 /* Construct the API message */
7620 M (TAP_DELETE_V2, mp);
7622 mp->sw_if_index = ntohl (sw_if_index);
7627 /* Wait for a reply... */
7633 unformat_pci_addr (unformat_input_t * input, va_list * args)
7642 addr = va_arg (*args, struct pci_addr_t *);
7645 if (!unformat (input, "%x:%x:%x.%x", &x[0], &x[1], &x[2], &x[3]))
7648 addr->domain = x[0];
7651 addr->function = x[3];
7657 api_virtio_pci_create (vat_main_t * vam)
7659 unformat_input_t *i = vam->input;
7660 vl_api_virtio_pci_create_t *mp;
7665 u64 features = (u64) ~ (0ULL);
7668 clib_memset (mac_address, 0, sizeof (mac_address));
7670 /* Parse args required to build the message */
7671 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7673 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7677 else if (unformat (i, "pci-addr %U", unformat_pci_addr, &pci_addr))
7679 else if (unformat (i, "features 0x%llx", &features))
7681 else if (unformat (i, "gso-enabled"))
7689 errmsg ("pci address must be non zero. ");
7693 /* Construct the API message */
7694 M (VIRTIO_PCI_CREATE, mp);
7696 mp->use_random_mac = random_mac;
7698 mp->pci_addr = htonl (pci_addr);
7699 mp->features = clib_host_to_net_u64 (features);
7700 mp->gso_enabled = gso_enabled;
7702 if (random_mac == 0)
7703 clib_memcpy (mp->mac_address, mac_address, 6);
7708 /* Wait for a reply... */
7714 api_virtio_pci_delete (vat_main_t * vam)
7716 unformat_input_t *i = vam->input;
7717 vl_api_virtio_pci_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 (VIRTIO_PCI_DELETE, mp);
7742 mp->sw_if_index = htonl (sw_if_index);
7747 /* Wait for a reply... */
7753 api_bond_create (vat_main_t * vam)
7755 unformat_input_t *i = vam->input;
7756 vl_api_bond_create_t *mp;
7766 clib_memset (mac_address, 0, sizeof (mac_address));
7769 /* Parse args required to build the message */
7770 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7772 if (unformat (i, "mode %U", unformat_bond_mode, &mode))
7774 else if (((mode == BOND_MODE_LACP) || (mode == BOND_MODE_XOR))
7775 && unformat (i, "lb %U", unformat_bond_load_balance, &lb))
7777 else if (unformat (i, "hw-addr %U", unformat_ethernet_address,
7780 else if (unformat (i, "numa-only"))
7782 else if (unformat (i, "id %u", &id))
7788 if (mode_is_set == 0)
7790 errmsg ("Missing bond mode. ");
7794 /* Construct the API message */
7795 M (BOND_CREATE, mp);
7797 mp->use_custom_mac = custom_mac;
7801 mp->id = htonl (id);
7802 mp->numa_only = numa_only;
7805 clib_memcpy (mp->mac_address, mac_address, 6);
7810 /* Wait for a reply... */
7816 api_bond_delete (vat_main_t * vam)
7818 unformat_input_t *i = vam->input;
7819 vl_api_bond_delete_t *mp;
7820 u32 sw_if_index = ~0;
7821 u8 sw_if_index_set = 0;
7824 /* Parse args required to build the message */
7825 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7827 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7828 sw_if_index_set = 1;
7829 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7830 sw_if_index_set = 1;
7835 if (sw_if_index_set == 0)
7837 errmsg ("missing vpp interface name. ");
7841 /* Construct the API message */
7842 M (BOND_DELETE, mp);
7844 mp->sw_if_index = ntohl (sw_if_index);
7849 /* Wait for a reply... */
7855 api_bond_enslave (vat_main_t * vam)
7857 unformat_input_t *i = vam->input;
7858 vl_api_bond_enslave_t *mp;
7859 u32 bond_sw_if_index;
7863 u32 bond_sw_if_index_is_set = 0;
7865 u8 sw_if_index_is_set = 0;
7867 /* Parse args required to build the message */
7868 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7870 if (unformat (i, "sw_if_index %d", &sw_if_index))
7871 sw_if_index_is_set = 1;
7872 else if (unformat (i, "bond %u", &bond_sw_if_index))
7873 bond_sw_if_index_is_set = 1;
7874 else if (unformat (i, "passive %d", &is_passive))
7876 else if (unformat (i, "long-timeout %d", &is_long_timeout))
7882 if (bond_sw_if_index_is_set == 0)
7884 errmsg ("Missing bond sw_if_index. ");
7887 if (sw_if_index_is_set == 0)
7889 errmsg ("Missing slave sw_if_index. ");
7893 /* Construct the API message */
7894 M (BOND_ENSLAVE, mp);
7896 mp->bond_sw_if_index = ntohl (bond_sw_if_index);
7897 mp->sw_if_index = ntohl (sw_if_index);
7898 mp->is_long_timeout = is_long_timeout;
7899 mp->is_passive = is_passive;
7904 /* Wait for a reply... */
7910 api_bond_detach_slave (vat_main_t * vam)
7912 unformat_input_t *i = vam->input;
7913 vl_api_bond_detach_slave_t *mp;
7914 u32 sw_if_index = ~0;
7915 u8 sw_if_index_set = 0;
7918 /* Parse args required to build the message */
7919 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7921 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7922 sw_if_index_set = 1;
7923 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7924 sw_if_index_set = 1;
7929 if (sw_if_index_set == 0)
7931 errmsg ("missing vpp interface name. ");
7935 /* Construct the API message */
7936 M (BOND_DETACH_SLAVE, mp);
7938 mp->sw_if_index = ntohl (sw_if_index);
7943 /* Wait for a reply... */
7949 api_ip_table_add_del (vat_main_t * vam)
7951 unformat_input_t *i = vam->input;
7952 vl_api_ip_table_add_del_t *mp;
7958 /* Parse args required to build the message */
7959 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7961 if (unformat (i, "ipv6"))
7963 else if (unformat (i, "del"))
7965 else if (unformat (i, "add"))
7967 else if (unformat (i, "table %d", &table_id))
7971 clib_warning ("parse error '%U'", format_unformat_error, i);
7978 errmsg ("missing table-ID");
7982 /* Construct the API message */
7983 M (IP_TABLE_ADD_DEL, mp);
7985 mp->table.table_id = ntohl (table_id);
7986 mp->table.is_ip6 = is_ipv6;
7987 mp->is_add = is_add;
7992 /* Wait for a reply... */
7999 unformat_fib_path (unformat_input_t * input, va_list * args)
8001 vat_main_t *vam = va_arg (*args, vat_main_t *);
8002 vl_api_fib_path_t *path = va_arg (*args, vl_api_fib_path_t *);
8003 u32 weight, preference;
8004 mpls_label_t out_label;
8006 clib_memset (path, 0, sizeof (*path));
8008 path->sw_if_index = ~0;
8012 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8014 if (unformat (input, "%U %U",
8015 unformat_vl_api_ip4_address,
8016 &path->nh.address.ip4,
8017 api_unformat_sw_if_index, vam, &path->sw_if_index))
8019 path->proto = FIB_API_PATH_NH_PROTO_IP4;
8021 else if (unformat (input, "%U %U",
8022 unformat_vl_api_ip6_address,
8023 &path->nh.address.ip6,
8024 api_unformat_sw_if_index, vam, &path->sw_if_index))
8026 path->proto = FIB_API_PATH_NH_PROTO_IP6;
8028 else if (unformat (input, "weight %u", &weight))
8030 path->weight = weight;
8032 else if (unformat (input, "preference %u", &preference))
8034 path->preference = preference;
8036 else if (unformat (input, "%U next-hop-table %d",
8037 unformat_vl_api_ip4_address,
8038 &path->nh.address.ip4, &path->table_id))
8040 path->proto = FIB_API_PATH_NH_PROTO_IP4;
8042 else if (unformat (input, "%U next-hop-table %d",
8043 unformat_vl_api_ip6_address,
8044 &path->nh.address.ip6, &path->table_id))
8046 path->proto = FIB_API_PATH_NH_PROTO_IP6;
8048 else if (unformat (input, "%U",
8049 unformat_vl_api_ip4_address, &path->nh.address.ip4))
8052 * the recursive next-hops are by default in the default table
8055 path->sw_if_index = ~0;
8056 path->proto = FIB_API_PATH_NH_PROTO_IP4;
8058 else if (unformat (input, "%U",
8059 unformat_vl_api_ip6_address, &path->nh.address.ip6))
8062 * the recursive next-hops are by default in the default table
8065 path->sw_if_index = ~0;
8066 path->proto = FIB_API_PATH_NH_PROTO_IP6;
8068 else if (unformat (input, "resolve-via-host"))
8070 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_HOST;
8072 else if (unformat (input, "resolve-via-attached"))
8074 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_ATTACHED;
8076 else if (unformat (input, "ip4-lookup-in-table %d", &path->table_id))
8078 path->type = FIB_API_PATH_TYPE_LOCAL;
8079 path->sw_if_index = ~0;
8080 path->proto = FIB_API_PATH_NH_PROTO_IP4;
8082 else if (unformat (input, "ip6-lookup-in-table %d", &path->table_id))
8084 path->type = FIB_API_PATH_TYPE_LOCAL;
8085 path->sw_if_index = ~0;
8086 path->proto = FIB_API_PATH_NH_PROTO_IP6;
8088 else if (unformat (input, "sw_if_index %d", &path->sw_if_index))
8090 else if (unformat (input, "via-label %d", &path->nh.via_label))
8092 path->proto = FIB_API_PATH_NH_PROTO_MPLS;
8093 path->sw_if_index = ~0;
8095 else if (unformat (input, "l2-input-on %d", &path->sw_if_index))
8097 path->proto = FIB_API_PATH_NH_PROTO_ETHERNET;
8098 path->type = FIB_API_PATH_TYPE_INTERFACE_RX;
8100 else if (unformat (input, "local"))
8102 path->type = FIB_API_PATH_TYPE_LOCAL;
8104 else if (unformat (input, "out-labels"))
8106 while (unformat (input, "%d", &out_label))
8108 path->label_stack[path->n_labels].label = out_label;
8109 path->label_stack[path->n_labels].is_uniform = 0;
8110 path->label_stack[path->n_labels].ttl = 64;
8114 else if (unformat (input, "via"))
8116 /* new path, back up and return */
8117 unformat_put_input (input);
8118 unformat_put_input (input);
8119 unformat_put_input (input);
8120 unformat_put_input (input);
8129 path->proto = ntohl (path->proto);
8130 path->type = ntohl (path->type);
8131 path->flags = ntohl (path->flags);
8132 path->table_id = ntohl (path->table_id);
8133 path->sw_if_index = ntohl (path->sw_if_index);
8139 api_ip_route_add_del (vat_main_t * vam)
8141 unformat_input_t *i = vam->input;
8142 vl_api_ip_route_add_del_t *mp;
8145 u8 is_multipath = 0;
8148 vl_api_prefix_t pfx = { };
8149 vl_api_fib_path_t paths[8];
8153 u32 random_add_del = 0;
8154 u32 *random_vector = 0;
8155 u32 random_seed = 0xdeaddabe;
8157 /* Parse args required to build the message */
8158 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8160 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8162 else if (unformat (i, "del"))
8164 else if (unformat (i, "add"))
8166 else if (unformat (i, "vrf %d", &vrf_id))
8168 else if (unformat (i, "count %d", &count))
8170 else if (unformat (i, "random"))
8172 else if (unformat (i, "multipath"))
8174 else if (unformat (i, "seed %d", &random_seed))
8178 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8181 if (8 == path_count)
8183 errmsg ("max 8 paths");
8189 clib_warning ("parse error '%U'", format_unformat_error, i);
8196 errmsg ("specify a path; via ...");
8199 if (prefix_set == 0)
8201 errmsg ("missing prefix");
8205 /* Generate a pile of unique, random routes */
8208 ip4_address_t *i = (ip4_address_t *) & paths[0].nh.address.ip4;
8209 u32 this_random_address;
8212 random_hash = hash_create (count, sizeof (uword));
8214 hash_set (random_hash, i->as_u32, 1);
8215 for (j = 0; j <= count; j++)
8219 this_random_address = random_u32 (&random_seed);
8220 this_random_address =
8221 clib_host_to_net_u32 (this_random_address);
8223 while (hash_get (random_hash, this_random_address));
8224 vec_add1 (random_vector, this_random_address);
8225 hash_set (random_hash, this_random_address, 1);
8227 hash_free (random_hash);
8228 set_ip4_address (&pfx.address, random_vector[0]);
8233 /* Turn on async mode */
8234 vam->async_mode = 1;
8235 vam->async_errors = 0;
8236 before = vat_time_now (vam);
8239 for (j = 0; j < count; j++)
8241 /* Construct the API message */
8242 M2 (IP_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8244 mp->is_add = is_add;
8245 mp->is_multipath = is_multipath;
8247 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8248 mp->route.table_id = ntohl (vrf_id);
8249 mp->route.n_paths = path_count;
8251 clib_memcpy (&mp->route.paths, &paths, sizeof (paths[0]) * path_count);
8254 set_ip4_address (&pfx.address, random_vector[j + 1]);
8256 increment_address (&pfx.address);
8259 /* If we receive SIGTERM, stop now... */
8264 /* When testing multiple add/del ops, use a control-ping to sync */
8267 vl_api_control_ping_t *mp_ping;
8271 /* Shut off async mode */
8272 vam->async_mode = 0;
8274 MPING (CONTROL_PING, mp_ping);
8277 timeout = vat_time_now (vam) + 1.0;
8278 while (vat_time_now (vam) < timeout)
8279 if (vam->result_ready == 1)
8284 if (vam->retval == -99)
8287 if (vam->async_errors > 0)
8289 errmsg ("%d asynchronous errors", vam->async_errors);
8292 vam->async_errors = 0;
8293 after = vat_time_now (vam);
8295 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8299 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8300 count, after - before, count / (after - before));
8306 /* Wait for a reply... */
8311 /* Return the good/bad news */
8312 return (vam->retval);
8316 api_ip_mroute_add_del (vat_main_t * vam)
8318 unformat_input_t *i = vam->input;
8319 u8 path_set = 0, prefix_set = 0, is_add = 1;
8320 vl_api_ip_mroute_add_del_t *mp;
8321 mfib_entry_flags_t eflags = 0;
8322 vl_api_mfib_path_t path;
8323 vl_api_mprefix_t pfx = { };
8327 /* Parse args required to build the message */
8328 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8330 if (unformat (i, "%U", unformat_vl_api_mprefix, &pfx))
8333 pfx.grp_address_length = htons (pfx.grp_address_length);
8335 else if (unformat (i, "del"))
8337 else if (unformat (i, "add"))
8339 else if (unformat (i, "vrf %d", &vrf_id))
8341 else if (unformat (i, "%U", unformat_mfib_itf_flags, &path.itf_flags))
8342 path.itf_flags = htonl (path.itf_flags);
8343 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8345 else if (unformat (i, "via %U", unformat_fib_path, vam, &path.path))
8349 clib_warning ("parse error '%U'", format_unformat_error, i);
8354 if (prefix_set == 0)
8356 errmsg ("missing addresses\n");
8361 errmsg ("missing path\n");
8365 /* Construct the API message */
8366 M (IP_MROUTE_ADD_DEL, mp);
8368 mp->is_add = is_add;
8369 mp->is_multipath = 1;
8371 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8372 mp->route.table_id = htonl (vrf_id);
8373 mp->route.n_paths = 1;
8374 mp->route.entry_flags = htonl (eflags);
8376 clib_memcpy (&mp->route.paths, &path, sizeof (path));
8380 /* Wait for a reply... */
8386 api_mpls_table_add_del (vat_main_t * vam)
8388 unformat_input_t *i = vam->input;
8389 vl_api_mpls_table_add_del_t *mp;
8394 /* Parse args required to build the message */
8395 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8397 if (unformat (i, "table %d", &table_id))
8399 else if (unformat (i, "del"))
8401 else if (unformat (i, "add"))
8405 clib_warning ("parse error '%U'", format_unformat_error, i);
8412 errmsg ("missing table-ID");
8416 /* Construct the API message */
8417 M (MPLS_TABLE_ADD_DEL, mp);
8419 mp->mt_table.mt_table_id = ntohl (table_id);
8420 mp->mt_is_add = is_add;
8425 /* Wait for a reply... */
8432 api_mpls_route_add_del (vat_main_t * vam)
8434 u8 is_add = 1, path_count = 0, is_multipath = 0, is_eos = 0;
8435 mpls_label_t local_label = MPLS_LABEL_INVALID;
8436 unformat_input_t *i = vam->input;
8437 vl_api_mpls_route_add_del_t *mp;
8438 vl_api_fib_path_t paths[8];
8442 /* Parse args required to build the message */
8443 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8445 if (unformat (i, "%d", &local_label))
8447 else if (unformat (i, "eos"))
8449 else if (unformat (i, "non-eos"))
8451 else if (unformat (i, "del"))
8453 else if (unformat (i, "add"))
8455 else if (unformat (i, "multipath"))
8457 else if (unformat (i, "count %d", &count))
8461 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8464 if (8 == path_count)
8466 errmsg ("max 8 paths");
8472 clib_warning ("parse error '%U'", format_unformat_error, i);
8479 errmsg ("specify a path; via ...");
8483 if (MPLS_LABEL_INVALID == local_label)
8485 errmsg ("missing label");
8491 /* Turn on async mode */
8492 vam->async_mode = 1;
8493 vam->async_errors = 0;
8494 before = vat_time_now (vam);
8497 for (j = 0; j < count; j++)
8499 /* Construct the API message */
8500 M2 (MPLS_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8502 mp->mr_is_add = is_add;
8503 mp->mr_is_multipath = is_multipath;
8505 mp->mr_route.mr_label = local_label;
8506 mp->mr_route.mr_eos = is_eos;
8507 mp->mr_route.mr_table_id = 0;
8508 mp->mr_route.mr_n_paths = path_count;
8510 clib_memcpy (&mp->mr_route.mr_paths, paths,
8511 sizeof (paths[0]) * path_count);
8517 /* If we receive SIGTERM, stop now... */
8522 /* When testing multiple add/del ops, use a control-ping to sync */
8525 vl_api_control_ping_t *mp_ping;
8529 /* Shut off async mode */
8530 vam->async_mode = 0;
8532 MPING (CONTROL_PING, mp_ping);
8535 timeout = vat_time_now (vam) + 1.0;
8536 while (vat_time_now (vam) < timeout)
8537 if (vam->result_ready == 1)
8542 if (vam->retval == -99)
8545 if (vam->async_errors > 0)
8547 errmsg ("%d asynchronous errors", vam->async_errors);
8550 vam->async_errors = 0;
8551 after = vat_time_now (vam);
8553 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8557 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8558 count, after - before, count / (after - before));
8564 /* Wait for a reply... */
8569 /* Return the good/bad news */
8570 return (vam->retval);
8575 api_mpls_ip_bind_unbind (vat_main_t * vam)
8577 unformat_input_t *i = vam->input;
8578 vl_api_mpls_ip_bind_unbind_t *mp;
8579 u32 ip_table_id = 0;
8581 vl_api_prefix_t pfx;
8583 mpls_label_t local_label = MPLS_LABEL_INVALID;
8586 /* Parse args required to build the message */
8587 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8589 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8591 else if (unformat (i, "%d", &local_label))
8593 else if (unformat (i, "table-id %d", &ip_table_id))
8595 else if (unformat (i, "unbind"))
8597 else if (unformat (i, "bind"))
8601 clib_warning ("parse error '%U'", format_unformat_error, i);
8608 errmsg ("IP prefix not set");
8612 if (MPLS_LABEL_INVALID == local_label)
8614 errmsg ("missing label");
8618 /* Construct the API message */
8619 M (MPLS_IP_BIND_UNBIND, mp);
8621 mp->mb_is_bind = is_bind;
8622 mp->mb_ip_table_id = ntohl (ip_table_id);
8623 mp->mb_mpls_table_id = 0;
8624 mp->mb_label = ntohl (local_label);
8625 clib_memcpy (&mp->mb_prefix, &pfx, sizeof (pfx));
8630 /* Wait for a reply... */
8637 api_sr_mpls_policy_add (vat_main_t * vam)
8639 unformat_input_t *i = vam->input;
8640 vl_api_sr_mpls_policy_add_t *mp;
8646 u32 *segments = NULL;
8649 /* Parse args required to build the message */
8650 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8652 if (unformat (i, "bsid %d", &bsid))
8654 else if (unformat (i, "weight %d", &weight))
8656 else if (unformat (i, "spray"))
8658 else if (unformat (i, "next %d", &sid))
8661 vec_add1 (segments, htonl (sid));
8665 clib_warning ("parse error '%U'", format_unformat_error, i);
8672 errmsg ("bsid not set");
8676 if (n_segments == 0)
8678 errmsg ("no sid in segment stack");
8682 /* Construct the API message */
8683 M2 (SR_MPLS_POLICY_ADD, mp, sizeof (u32) * n_segments);
8685 mp->bsid = htonl (bsid);
8686 mp->weight = htonl (weight);
8688 mp->n_segments = n_segments;
8689 memcpy (mp->segments, segments, sizeof (u32) * n_segments);
8690 vec_free (segments);
8695 /* Wait for a reply... */
8701 api_sr_mpls_policy_del (vat_main_t * vam)
8703 unformat_input_t *i = vam->input;
8704 vl_api_sr_mpls_policy_del_t *mp;
8708 /* Parse args required to build the message */
8709 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8711 if (unformat (i, "bsid %d", &bsid))
8715 clib_warning ("parse error '%U'", format_unformat_error, i);
8722 errmsg ("bsid not set");
8726 /* Construct the API message */
8727 M (SR_MPLS_POLICY_DEL, mp);
8729 mp->bsid = htonl (bsid);
8734 /* Wait for a reply... */
8740 api_bier_table_add_del (vat_main_t * vam)
8742 unformat_input_t *i = vam->input;
8743 vl_api_bier_table_add_del_t *mp;
8745 u32 set = 0, sub_domain = 0, hdr_len = 3;
8746 mpls_label_t local_label = MPLS_LABEL_INVALID;
8749 /* Parse args required to build the message */
8750 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8752 if (unformat (i, "sub-domain %d", &sub_domain))
8754 else if (unformat (i, "set %d", &set))
8756 else if (unformat (i, "label %d", &local_label))
8758 else if (unformat (i, "hdr-len %d", &hdr_len))
8760 else if (unformat (i, "add"))
8762 else if (unformat (i, "del"))
8766 clib_warning ("parse error '%U'", format_unformat_error, i);
8771 if (MPLS_LABEL_INVALID == local_label)
8773 errmsg ("missing label\n");
8777 /* Construct the API message */
8778 M (BIER_TABLE_ADD_DEL, mp);
8780 mp->bt_is_add = is_add;
8781 mp->bt_label = ntohl (local_label);
8782 mp->bt_tbl_id.bt_set = set;
8783 mp->bt_tbl_id.bt_sub_domain = sub_domain;
8784 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
8789 /* Wait for a reply... */
8796 api_bier_route_add_del (vat_main_t * vam)
8798 unformat_input_t *i = vam->input;
8799 vl_api_bier_route_add_del_t *mp;
8801 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
8802 ip4_address_t v4_next_hop_address;
8803 ip6_address_t v6_next_hop_address;
8804 u8 next_hop_set = 0;
8805 u8 next_hop_proto_is_ip4 = 1;
8806 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8809 /* Parse args required to build the message */
8810 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8812 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
8814 next_hop_proto_is_ip4 = 1;
8817 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
8819 next_hop_proto_is_ip4 = 0;
8822 if (unformat (i, "sub-domain %d", &sub_domain))
8824 else if (unformat (i, "set %d", &set))
8826 else if (unformat (i, "hdr-len %d", &hdr_len))
8828 else if (unformat (i, "bp %d", &bp))
8830 else if (unformat (i, "add"))
8832 else if (unformat (i, "del"))
8834 else if (unformat (i, "out-label %d", &next_hop_out_label))
8838 clib_warning ("parse error '%U'", format_unformat_error, i);
8843 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
8845 errmsg ("next hop / label set\n");
8850 errmsg ("bit=position not set\n");
8854 /* Construct the API message */
8855 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t));
8857 mp->br_is_add = is_add;
8858 mp->br_route.br_tbl_id.bt_set = set;
8859 mp->br_route.br_tbl_id.bt_sub_domain = sub_domain;
8860 mp->br_route.br_tbl_id.bt_hdr_len_id = hdr_len;
8861 mp->br_route.br_bp = ntohs (bp);
8862 mp->br_route.br_n_paths = 1;
8863 mp->br_route.br_paths[0].n_labels = 1;
8864 mp->br_route.br_paths[0].label_stack[0].label = ntohl (next_hop_out_label);
8865 mp->br_route.br_paths[0].proto = (next_hop_proto_is_ip4 ?
8866 FIB_API_PATH_NH_PROTO_IP4 :
8867 FIB_API_PATH_NH_PROTO_IP6);
8869 if (next_hop_proto_is_ip4)
8871 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip4,
8872 &v4_next_hop_address, sizeof (v4_next_hop_address));
8876 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip6,
8877 &v6_next_hop_address, sizeof (v6_next_hop_address));
8883 /* Wait for a reply... */
8890 api_proxy_arp_add_del (vat_main_t * vam)
8892 unformat_input_t *i = vam->input;
8893 vl_api_proxy_arp_add_del_t *mp;
8896 vl_api_ip4_address_t lo, hi;
8900 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8902 if (unformat (i, "vrf %d", &vrf_id))
8904 else if (unformat (i, "%U - %U", unformat_vl_api_ip4_address, &lo,
8905 unformat_vl_api_ip4_address, &hi))
8907 else if (unformat (i, "del"))
8911 clib_warning ("parse error '%U'", format_unformat_error, i);
8918 errmsg ("address range not set");
8922 M (PROXY_ARP_ADD_DEL, mp);
8924 mp->proxy.table_id = ntohl (vrf_id);
8925 mp->is_add = is_add;
8926 clib_memcpy (mp->proxy.low, &lo, sizeof (lo));
8927 clib_memcpy (mp->proxy.hi, &hi, sizeof (hi));
8935 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
8937 unformat_input_t *i = vam->input;
8938 vl_api_proxy_arp_intfc_enable_disable_t *mp;
8941 u8 sw_if_index_set = 0;
8944 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8946 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8947 sw_if_index_set = 1;
8948 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8949 sw_if_index_set = 1;
8950 else if (unformat (i, "enable"))
8952 else if (unformat (i, "disable"))
8956 clib_warning ("parse error '%U'", format_unformat_error, i);
8961 if (sw_if_index_set == 0)
8963 errmsg ("missing interface name or sw_if_index");
8967 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
8969 mp->sw_if_index = ntohl (sw_if_index);
8970 mp->enable_disable = enable;
8978 api_mpls_tunnel_add_del (vat_main_t * vam)
8980 unformat_input_t *i = vam->input;
8981 vl_api_mpls_tunnel_add_del_t *mp;
8983 vl_api_fib_path_t paths[8];
8984 u32 sw_if_index = ~0;
8990 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8992 if (unformat (i, "add"))
8996 (i, "del %U", api_unformat_sw_if_index, vam, &sw_if_index))
8998 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
9000 else if (unformat (i, "l2-only"))
9004 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
9007 if (8 == path_count)
9009 errmsg ("max 8 paths");
9015 clib_warning ("parse error '%U'", format_unformat_error, i);
9020 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
9022 mp->mt_is_add = is_add;
9023 mp->mt_tunnel.mt_sw_if_index = ntohl (sw_if_index);
9024 mp->mt_tunnel.mt_l2_only = l2_only;
9025 mp->mt_tunnel.mt_is_multicast = 0;
9026 mp->mt_tunnel.mt_n_paths = path_count;
9028 clib_memcpy (&mp->mt_tunnel.mt_paths, &paths,
9029 sizeof (paths[0]) * path_count);
9037 api_sw_interface_set_unnumbered (vat_main_t * vam)
9039 unformat_input_t *i = vam->input;
9040 vl_api_sw_interface_set_unnumbered_t *mp;
9042 u32 unnum_sw_index = ~0;
9044 u8 sw_if_index_set = 0;
9047 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9049 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9050 sw_if_index_set = 1;
9051 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9052 sw_if_index_set = 1;
9053 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
9055 else if (unformat (i, "del"))
9059 clib_warning ("parse error '%U'", format_unformat_error, i);
9064 if (sw_if_index_set == 0)
9066 errmsg ("missing interface name or sw_if_index");
9070 M (SW_INTERFACE_SET_UNNUMBERED, mp);
9072 mp->sw_if_index = ntohl (sw_if_index);
9073 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
9074 mp->is_add = is_add;
9082 api_ip_neighbor_add_del (vat_main_t * vam)
9084 vl_api_mac_address_t mac_address;
9085 unformat_input_t *i = vam->input;
9086 vl_api_ip_neighbor_add_del_t *mp;
9087 vl_api_address_t ip_address;
9089 u8 sw_if_index_set = 0;
9094 ip_neighbor_flags_t flags;
9096 flags = IP_NEIGHBOR_FLAG_NONE;
9097 clib_memset (&ip_address, 0, sizeof (ip_address));
9098 clib_memset (&mac_address, 0, sizeof (mac_address));
9100 /* Parse args required to build the message */
9101 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9103 if (unformat (i, "mac %U", unformat_vl_api_mac_address, &mac_address))
9107 else if (unformat (i, "del"))
9110 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9111 sw_if_index_set = 1;
9112 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9113 sw_if_index_set = 1;
9114 else if (unformat (i, "static"))
9115 flags |= IP_NEIGHBOR_FLAG_STATIC;
9116 else if (unformat (i, "no-fib-entry"))
9117 flags |= IP_NEIGHBOR_FLAG_NO_FIB_ENTRY;
9118 else if (unformat (i, "dst %U", unformat_vl_api_address, &ip_address))
9122 clib_warning ("parse error '%U'", format_unformat_error, i);
9127 if (sw_if_index_set == 0)
9129 errmsg ("missing interface name or sw_if_index");
9134 errmsg ("no address set");
9138 /* Construct the API message */
9139 M (IP_NEIGHBOR_ADD_DEL, mp);
9141 mp->neighbor.sw_if_index = ntohl (sw_if_index);
9142 mp->is_add = is_add;
9143 mp->neighbor.flags = htonl (flags);
9145 clib_memcpy (&mp->neighbor.mac_address, &mac_address,
9146 sizeof (mac_address));
9148 clib_memcpy (&mp->neighbor.ip_address, &ip_address, sizeof (ip_address));
9153 /* Wait for a reply, return good/bad news */
9159 api_create_vlan_subif (vat_main_t * vam)
9161 unformat_input_t *i = vam->input;
9162 vl_api_create_vlan_subif_t *mp;
9164 u8 sw_if_index_set = 0;
9169 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9171 if (unformat (i, "sw_if_index %d", &sw_if_index))
9172 sw_if_index_set = 1;
9174 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9175 sw_if_index_set = 1;
9176 else if (unformat (i, "vlan %d", &vlan_id))
9180 clib_warning ("parse error '%U'", format_unformat_error, i);
9185 if (sw_if_index_set == 0)
9187 errmsg ("missing interface name or sw_if_index");
9191 if (vlan_id_set == 0)
9193 errmsg ("missing vlan_id");
9196 M (CREATE_VLAN_SUBIF, mp);
9198 mp->sw_if_index = ntohl (sw_if_index);
9199 mp->vlan_id = ntohl (vlan_id);
9206 #define foreach_create_subif_bit \
9213 _(outer_vlan_id_any) \
9214 _(inner_vlan_id_any)
9216 #define foreach_create_subif_flag \
9221 _(4, "exact_match") \
9222 _(5, "default_sub") \
9223 _(6, "outer_vlan_id_any") \
9224 _(7, "inner_vlan_id_any")
9227 api_create_subif (vat_main_t * vam)
9229 unformat_input_t *i = vam->input;
9230 vl_api_create_subif_t *mp;
9232 u8 sw_if_index_set = 0;
9235 u32 __attribute__ ((unused)) no_tags = 0;
9236 u32 __attribute__ ((unused)) one_tag = 0;
9237 u32 __attribute__ ((unused)) two_tags = 0;
9238 u32 __attribute__ ((unused)) dot1ad = 0;
9239 u32 __attribute__ ((unused)) exact_match = 0;
9240 u32 __attribute__ ((unused)) default_sub = 0;
9241 u32 __attribute__ ((unused)) outer_vlan_id_any = 0;
9242 u32 __attribute__ ((unused)) inner_vlan_id_any = 0;
9244 u16 outer_vlan_id = 0;
9245 u16 inner_vlan_id = 0;
9248 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9250 if (unformat (i, "sw_if_index %d", &sw_if_index))
9251 sw_if_index_set = 1;
9253 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9254 sw_if_index_set = 1;
9255 else if (unformat (i, "sub_id %d", &sub_id))
9257 else if (unformat (i, "outer_vlan_id %d", &tmp))
9258 outer_vlan_id = tmp;
9259 else if (unformat (i, "inner_vlan_id %d", &tmp))
9260 inner_vlan_id = tmp;
9262 #define _(a) else if (unformat (i, #a)) a = 1 ;
9263 foreach_create_subif_bit
9267 clib_warning ("parse error '%U'", format_unformat_error, i);
9272 if (sw_if_index_set == 0)
9274 errmsg ("missing interface name or sw_if_index");
9278 if (sub_id_set == 0)
9280 errmsg ("missing sub_id");
9283 M (CREATE_SUBIF, mp);
9285 mp->sw_if_index = ntohl (sw_if_index);
9286 mp->sub_id = ntohl (sub_id);
9288 #define _(a,b) mp->sub_if_flags |= (1 << a);
9289 foreach_create_subif_flag;
9292 mp->outer_vlan_id = ntohs (outer_vlan_id);
9293 mp->inner_vlan_id = ntohs (inner_vlan_id);
9301 api_reset_fib (vat_main_t * vam)
9303 unformat_input_t *i = vam->input;
9304 vl_api_reset_fib_t *mp;
9310 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9312 if (unformat (i, "vrf %d", &vrf_id))
9314 else if (unformat (i, "ipv6"))
9318 clib_warning ("parse error '%U'", format_unformat_error, i);
9323 if (vrf_id_set == 0)
9325 errmsg ("missing vrf id");
9331 mp->vrf_id = ntohl (vrf_id);
9332 mp->is_ipv6 = is_ipv6;
9340 api_dhcp_proxy_config (vat_main_t * vam)
9342 unformat_input_t *i = vam->input;
9343 vl_api_dhcp_proxy_config_t *mp;
9345 u32 server_vrf_id = 0;
9347 u8 v4_address_set = 0;
9348 u8 v6_address_set = 0;
9349 ip4_address_t v4address;
9350 ip6_address_t v6address;
9351 u8 v4_src_address_set = 0;
9352 u8 v6_src_address_set = 0;
9353 ip4_address_t v4srcaddress;
9354 ip6_address_t v6srcaddress;
9357 /* Parse args required to build the message */
9358 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9360 if (unformat (i, "del"))
9362 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
9364 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
9366 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
9368 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
9370 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
9371 v4_src_address_set = 1;
9372 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
9373 v6_src_address_set = 1;
9378 if (v4_address_set && v6_address_set)
9380 errmsg ("both v4 and v6 server addresses set");
9383 if (!v4_address_set && !v6_address_set)
9385 errmsg ("no server addresses set");
9389 if (v4_src_address_set && v6_src_address_set)
9391 errmsg ("both v4 and v6 src addresses set");
9394 if (!v4_src_address_set && !v6_src_address_set)
9396 errmsg ("no src addresses set");
9400 if (!(v4_src_address_set && v4_address_set) &&
9401 !(v6_src_address_set && v6_address_set))
9403 errmsg ("no matching server and src addresses set");
9407 /* Construct the API message */
9408 M (DHCP_PROXY_CONFIG, mp);
9410 mp->is_add = is_add;
9411 mp->rx_vrf_id = ntohl (rx_vrf_id);
9412 mp->server_vrf_id = ntohl (server_vrf_id);
9416 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
9417 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
9421 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
9422 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
9428 /* Wait for a reply, return good/bad news */
9433 #define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
9434 #define vl_api_dhcp_proxy_details_t_print vl_noop_handler
9437 vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
9439 vat_main_t *vam = &vat_main;
9440 u32 i, count = mp->count;
9441 vl_api_dhcp_server_t *s;
9445 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9446 "VSS ASCII VPN-ID '%s', VSS RFC2685 VPN-ID (oui:id) %d:%d",
9447 ntohl (mp->rx_vrf_id),
9448 format_ip6_address, mp->dhcp_src_address,
9449 mp->vss_type, mp->vss_vpn_ascii_id,
9450 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9453 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9454 "VSS ASCII VPN-ID '%s', VSS RFC2685 VPN-ID (oui:id) %d:%d",
9455 ntohl (mp->rx_vrf_id),
9456 format_ip4_address, mp->dhcp_src_address,
9457 mp->vss_type, mp->vss_vpn_ascii_id,
9458 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9460 for (i = 0; i < count; i++)
9462 s = &mp->servers[i];
9466 " Server Table-ID %d, Server Address %U",
9467 ntohl (s->server_vrf_id), format_ip6_address, s->dhcp_server);
9470 " Server Table-ID %d, Server Address %U",
9471 ntohl (s->server_vrf_id), format_ip4_address, s->dhcp_server);
9475 static void vl_api_dhcp_proxy_details_t_handler_json
9476 (vl_api_dhcp_proxy_details_t * mp)
9478 vat_main_t *vam = &vat_main;
9479 vat_json_node_t *node = NULL;
9480 u32 i, count = mp->count;
9482 struct in6_addr ip6;
9483 vl_api_dhcp_server_t *s;
9485 if (VAT_JSON_ARRAY != vam->json_tree.type)
9487 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9488 vat_json_init_array (&vam->json_tree);
9490 node = vat_json_array_add (&vam->json_tree);
9492 vat_json_init_object (node);
9493 vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
9494 vat_json_object_add_bytes (node, "vss-type", &mp->vss_type,
9495 sizeof (mp->vss_type));
9496 vat_json_object_add_string_copy (node, "vss-vpn-ascii-id",
9497 mp->vss_vpn_ascii_id);
9498 vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
9499 vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
9503 clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
9504 vat_json_object_add_ip6 (node, "src_address", ip6);
9508 clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
9509 vat_json_object_add_ip4 (node, "src_address", ip4);
9512 for (i = 0; i < count; i++)
9514 s = &mp->servers[i];
9516 vat_json_object_add_uint (node, "server-table-id",
9517 ntohl (s->server_vrf_id));
9521 clib_memcpy (&ip4, &s->dhcp_server, sizeof (ip4));
9522 vat_json_object_add_ip4 (node, "src_address", ip4);
9526 clib_memcpy (&ip6, &s->dhcp_server, sizeof (ip6));
9527 vat_json_object_add_ip6 (node, "server_address", ip6);
9533 api_dhcp_proxy_dump (vat_main_t * vam)
9535 unformat_input_t *i = vam->input;
9536 vl_api_control_ping_t *mp_ping;
9537 vl_api_dhcp_proxy_dump_t *mp;
9541 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9543 if (unformat (i, "ipv6"))
9547 clib_warning ("parse error '%U'", format_unformat_error, i);
9552 M (DHCP_PROXY_DUMP, mp);
9554 mp->is_ip6 = is_ipv6;
9557 /* Use a control ping for synchronization */
9558 MPING (CONTROL_PING, mp_ping);
9566 api_dhcp_proxy_set_vss (vat_main_t * vam)
9568 unformat_input_t *i = vam->input;
9569 vl_api_dhcp_proxy_set_vss_t *mp;
9573 u8 vss_type = VSS_TYPE_DEFAULT;
9574 u8 *vpn_ascii_id = 0;
9579 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9581 if (unformat (i, "tbl_id %d", &tbl_id))
9583 else if (unformat (i, "vpn_ascii_id %s", &vpn_ascii_id))
9584 vss_type = VSS_TYPE_ASCII;
9585 else if (unformat (i, "fib_id %d", &fib_id))
9586 vss_type = VSS_TYPE_VPN_ID;
9587 else if (unformat (i, "oui %d", &oui))
9588 vss_type = VSS_TYPE_VPN_ID;
9589 else if (unformat (i, "ipv6"))
9591 else if (unformat (i, "del"))
9599 errmsg ("missing tbl_id ");
9600 vec_free (vpn_ascii_id);
9604 if ((vpn_ascii_id) && (vec_len (vpn_ascii_id) > 128))
9606 errmsg ("vpn_ascii_id cannot be longer than 128 ");
9607 vec_free (vpn_ascii_id);
9611 M (DHCP_PROXY_SET_VSS, mp);
9612 mp->tbl_id = ntohl (tbl_id);
9613 mp->vss_type = vss_type;
9616 clib_memcpy (mp->vpn_ascii_id, vpn_ascii_id, vec_len (vpn_ascii_id));
9617 mp->vpn_ascii_id[vec_len (vpn_ascii_id)] = 0;
9619 mp->vpn_index = ntohl (fib_id);
9620 mp->oui = ntohl (oui);
9621 mp->is_ipv6 = is_ipv6;
9622 mp->is_add = is_add;
9627 vec_free (vpn_ascii_id);
9632 api_dhcp_client_config (vat_main_t * vam)
9634 unformat_input_t *i = vam->input;
9635 vl_api_dhcp_client_config_t *mp;
9637 u8 sw_if_index_set = 0;
9640 u8 disable_event = 0;
9643 /* Parse args required to build the message */
9644 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9646 if (unformat (i, "del"))
9649 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9650 sw_if_index_set = 1;
9651 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9652 sw_if_index_set = 1;
9653 else if (unformat (i, "hostname %s", &hostname))
9655 else if (unformat (i, "disable_event"))
9661 if (sw_if_index_set == 0)
9663 errmsg ("missing interface name or sw_if_index");
9667 if (vec_len (hostname) > 63)
9669 errmsg ("hostname too long");
9671 vec_add1 (hostname, 0);
9673 /* Construct the API message */
9674 M (DHCP_CLIENT_CONFIG, mp);
9676 mp->is_add = is_add;
9677 mp->client.sw_if_index = htonl (sw_if_index);
9678 clib_memcpy (mp->client.hostname, hostname, vec_len (hostname));
9679 vec_free (hostname);
9680 mp->client.want_dhcp_event = disable_event ? 0 : 1;
9681 mp->client.pid = htonl (getpid ());
9686 /* Wait for a reply, return good/bad news */
9692 api_set_ip_flow_hash (vat_main_t * vam)
9694 unformat_input_t *i = vam->input;
9695 vl_api_set_ip_flow_hash_t *mp;
9707 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9709 if (unformat (i, "vrf %d", &vrf_id))
9711 else if (unformat (i, "ipv6"))
9713 else if (unformat (i, "src"))
9715 else if (unformat (i, "dst"))
9717 else if (unformat (i, "sport"))
9719 else if (unformat (i, "dport"))
9721 else if (unformat (i, "proto"))
9723 else if (unformat (i, "reverse"))
9728 clib_warning ("parse error '%U'", format_unformat_error, i);
9733 if (vrf_id_set == 0)
9735 errmsg ("missing vrf id");
9739 M (SET_IP_FLOW_HASH, mp);
9745 mp->reverse = reverse;
9746 mp->vrf_id = ntohl (vrf_id);
9747 mp->is_ipv6 = is_ipv6;
9755 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
9757 unformat_input_t *i = vam->input;
9758 vl_api_sw_interface_ip6_enable_disable_t *mp;
9760 u8 sw_if_index_set = 0;
9764 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9766 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9767 sw_if_index_set = 1;
9768 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9769 sw_if_index_set = 1;
9770 else if (unformat (i, "enable"))
9772 else if (unformat (i, "disable"))
9776 clib_warning ("parse error '%U'", format_unformat_error, i);
9781 if (sw_if_index_set == 0)
9783 errmsg ("missing interface name or sw_if_index");
9787 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
9789 mp->sw_if_index = ntohl (sw_if_index);
9790 mp->enable = enable;
9798 api_ip6nd_proxy_add_del (vat_main_t * vam)
9800 unformat_input_t *i = vam->input;
9801 vl_api_ip6nd_proxy_add_del_t *mp;
9802 u32 sw_if_index = ~0;
9803 u8 v6_address_set = 0;
9804 vl_api_ip6_address_t v6address;
9808 /* Parse args required to build the message */
9809 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9811 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9813 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9815 else if (unformat (i, "%U", unformat_vl_api_ip6_address, &v6address))
9817 if (unformat (i, "del"))
9821 clib_warning ("parse error '%U'", format_unformat_error, i);
9826 if (sw_if_index == ~0)
9828 errmsg ("missing interface name or sw_if_index");
9831 if (!v6_address_set)
9833 errmsg ("no address set");
9837 /* Construct the API message */
9838 M (IP6ND_PROXY_ADD_DEL, mp);
9840 mp->is_del = is_del;
9841 mp->sw_if_index = ntohl (sw_if_index);
9842 clib_memcpy (mp->ip, v6address, sizeof (v6address));
9847 /* Wait for a reply, return good/bad news */
9853 api_ip6nd_proxy_dump (vat_main_t * vam)
9855 vl_api_ip6nd_proxy_dump_t *mp;
9856 vl_api_control_ping_t *mp_ping;
9859 M (IP6ND_PROXY_DUMP, mp);
9863 /* Use a control ping for synchronization */
9864 MPING (CONTROL_PING, mp_ping);
9871 static void vl_api_ip6nd_proxy_details_t_handler
9872 (vl_api_ip6nd_proxy_details_t * mp)
9874 vat_main_t *vam = &vat_main;
9876 print (vam->ofp, "host %U sw_if_index %d",
9877 format_vl_api_ip6_address, mp->ip, ntohl (mp->sw_if_index));
9880 static void vl_api_ip6nd_proxy_details_t_handler_json
9881 (vl_api_ip6nd_proxy_details_t * mp)
9883 vat_main_t *vam = &vat_main;
9884 struct in6_addr ip6;
9885 vat_json_node_t *node = NULL;
9887 if (VAT_JSON_ARRAY != vam->json_tree.type)
9889 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9890 vat_json_init_array (&vam->json_tree);
9892 node = vat_json_array_add (&vam->json_tree);
9894 vat_json_init_object (node);
9895 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9897 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
9898 vat_json_object_add_ip6 (node, "host", ip6);
9902 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
9904 unformat_input_t *i = vam->input;
9905 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
9907 u8 sw_if_index_set = 0;
9908 u8 v6_address_set = 0;
9909 vl_api_prefix_t pfx;
9911 u8 no_advertise = 0;
9913 u8 no_autoconfig = 0;
9916 u32 val_lifetime = 0;
9917 u32 pref_lifetime = 0;
9920 /* Parse args required to build the message */
9921 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9923 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9924 sw_if_index_set = 1;
9925 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9926 sw_if_index_set = 1;
9927 else if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
9929 else if (unformat (i, "val_life %d", &val_lifetime))
9931 else if (unformat (i, "pref_life %d", &pref_lifetime))
9933 else if (unformat (i, "def"))
9935 else if (unformat (i, "noadv"))
9937 else if (unformat (i, "offl"))
9939 else if (unformat (i, "noauto"))
9941 else if (unformat (i, "nolink"))
9943 else if (unformat (i, "isno"))
9947 clib_warning ("parse error '%U'", format_unformat_error, i);
9952 if (sw_if_index_set == 0)
9954 errmsg ("missing interface name or sw_if_index");
9957 if (!v6_address_set)
9959 errmsg ("no address set");
9963 /* Construct the API message */
9964 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
9966 mp->sw_if_index = ntohl (sw_if_index);
9967 clib_memcpy (&mp->prefix, &pfx, sizeof (pfx));
9968 mp->use_default = use_default;
9969 mp->no_advertise = no_advertise;
9970 mp->off_link = off_link;
9971 mp->no_autoconfig = no_autoconfig;
9972 mp->no_onlink = no_onlink;
9974 mp->val_lifetime = ntohl (val_lifetime);
9975 mp->pref_lifetime = ntohl (pref_lifetime);
9980 /* Wait for a reply, return good/bad news */
9986 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
9988 unformat_input_t *i = vam->input;
9989 vl_api_sw_interface_ip6nd_ra_config_t *mp;
9991 u8 sw_if_index_set = 0;
9996 u8 send_unicast = 0;
9999 u8 default_router = 0;
10000 u32 max_interval = 0;
10001 u32 min_interval = 0;
10003 u32 initial_count = 0;
10004 u32 initial_interval = 0;
10008 /* Parse args required to build the message */
10009 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10011 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10012 sw_if_index_set = 1;
10013 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10014 sw_if_index_set = 1;
10015 else if (unformat (i, "maxint %d", &max_interval))
10017 else if (unformat (i, "minint %d", &min_interval))
10019 else if (unformat (i, "life %d", &lifetime))
10021 else if (unformat (i, "count %d", &initial_count))
10023 else if (unformat (i, "interval %d", &initial_interval))
10025 else if (unformat (i, "suppress") || unformat (i, "surpress"))
10027 else if (unformat (i, "managed"))
10029 else if (unformat (i, "other"))
10031 else if (unformat (i, "ll"))
10033 else if (unformat (i, "send"))
10035 else if (unformat (i, "cease"))
10037 else if (unformat (i, "isno"))
10039 else if (unformat (i, "def"))
10040 default_router = 1;
10043 clib_warning ("parse error '%U'", format_unformat_error, i);
10048 if (sw_if_index_set == 0)
10050 errmsg ("missing interface name or sw_if_index");
10054 /* Construct the API message */
10055 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
10057 mp->sw_if_index = ntohl (sw_if_index);
10058 mp->max_interval = ntohl (max_interval);
10059 mp->min_interval = ntohl (min_interval);
10060 mp->lifetime = ntohl (lifetime);
10061 mp->initial_count = ntohl (initial_count);
10062 mp->initial_interval = ntohl (initial_interval);
10063 mp->suppress = suppress;
10064 mp->managed = managed;
10066 mp->ll_option = ll_option;
10067 mp->send_unicast = send_unicast;
10070 mp->default_router = default_router;
10075 /* Wait for a reply, return good/bad news */
10081 api_set_arp_neighbor_limit (vat_main_t * vam)
10083 unformat_input_t *i = vam->input;
10084 vl_api_set_arp_neighbor_limit_t *mp;
10090 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10092 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
10094 else if (unformat (i, "ipv6"))
10098 clib_warning ("parse error '%U'", format_unformat_error, i);
10103 if (limit_set == 0)
10105 errmsg ("missing limit value");
10109 M (SET_ARP_NEIGHBOR_LIMIT, mp);
10111 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
10112 mp->is_ipv6 = is_ipv6;
10120 api_l2_patch_add_del (vat_main_t * vam)
10122 unformat_input_t *i = vam->input;
10123 vl_api_l2_patch_add_del_t *mp;
10124 u32 rx_sw_if_index;
10125 u8 rx_sw_if_index_set = 0;
10126 u32 tx_sw_if_index;
10127 u8 tx_sw_if_index_set = 0;
10131 /* Parse args required to build the message */
10132 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10134 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
10135 rx_sw_if_index_set = 1;
10136 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
10137 tx_sw_if_index_set = 1;
10138 else if (unformat (i, "rx"))
10140 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10142 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10144 rx_sw_if_index_set = 1;
10149 else if (unformat (i, "tx"))
10151 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10153 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10155 tx_sw_if_index_set = 1;
10160 else if (unformat (i, "del"))
10166 if (rx_sw_if_index_set == 0)
10168 errmsg ("missing rx interface name or rx_sw_if_index");
10172 if (tx_sw_if_index_set == 0)
10174 errmsg ("missing tx interface name or tx_sw_if_index");
10178 M (L2_PATCH_ADD_DEL, mp);
10180 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
10181 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
10182 mp->is_add = is_add;
10190 u8 localsid_addr[16];
10199 api_sr_localsid_add_del (vat_main_t * vam)
10201 unformat_input_t *i = vam->input;
10202 vl_api_sr_localsid_add_del_t *mp;
10205 ip6_address_t localsid;
10209 u32 fib_table = ~(u32) 0;
10210 ip6_address_t nh_addr6;
10211 ip4_address_t nh_addr4;
10212 clib_memset (&nh_addr6, 0, sizeof (ip6_address_t));
10213 clib_memset (&nh_addr4, 0, sizeof (ip4_address_t));
10215 bool nexthop_set = 0;
10219 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10221 if (unformat (i, "del"))
10223 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
10224 else if (unformat (i, "next-hop %U", unformat_ip4_address, &nh_addr4))
10226 else if (unformat (i, "next-hop %U", unformat_ip6_address, &nh_addr6))
10228 else if (unformat (i, "behavior %u", &behavior));
10229 else if (unformat (i, "sw_if_index %u", &sw_if_index));
10230 else if (unformat (i, "fib-table %u", &fib_table));
10231 else if (unformat (i, "end.psp %u", &behavior));
10236 M (SR_LOCALSID_ADD_DEL, mp);
10238 clib_memcpy (mp->localsid.addr, &localsid, sizeof (mp->localsid));
10241 clib_memcpy (mp->nh_addr6, &nh_addr6, sizeof (mp->nh_addr6));
10242 clib_memcpy (mp->nh_addr4, &nh_addr4, sizeof (mp->nh_addr4));
10244 mp->behavior = behavior;
10245 mp->sw_if_index = ntohl (sw_if_index);
10246 mp->fib_table = ntohl (fib_table);
10247 mp->end_psp = end_psp;
10248 mp->is_del = is_del;
10256 api_ioam_enable (vat_main_t * vam)
10258 unformat_input_t *input = vam->input;
10259 vl_api_ioam_enable_t *mp;
10261 int has_trace_option = 0;
10262 int has_pot_option = 0;
10263 int has_seqno_option = 0;
10264 int has_analyse_option = 0;
10267 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10269 if (unformat (input, "trace"))
10270 has_trace_option = 1;
10271 else if (unformat (input, "pot"))
10272 has_pot_option = 1;
10273 else if (unformat (input, "seqno"))
10274 has_seqno_option = 1;
10275 else if (unformat (input, "analyse"))
10276 has_analyse_option = 1;
10280 M (IOAM_ENABLE, mp);
10281 mp->id = htons (id);
10282 mp->seqno = has_seqno_option;
10283 mp->analyse = has_analyse_option;
10284 mp->pot_enable = has_pot_option;
10285 mp->trace_enable = has_trace_option;
10294 api_ioam_disable (vat_main_t * vam)
10296 vl_api_ioam_disable_t *mp;
10299 M (IOAM_DISABLE, mp);
10305 #define foreach_tcp_proto_field \
10309 #define foreach_udp_proto_field \
10313 #define foreach_ip4_proto_field \
10325 u16 src_port, dst_port;
10328 #if VPP_API_TEST_BUILTIN == 0
10330 unformat_tcp_mask (unformat_input_t * input, va_list * args)
10332 u8 **maskp = va_arg (*args, u8 **);
10334 u8 found_something = 0;
10337 #define _(a) u8 a=0;
10338 foreach_tcp_proto_field;
10341 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10344 #define _(a) else if (unformat (input, #a)) a=1;
10345 foreach_tcp_proto_field
10351 #define _(a) found_something += a;
10352 foreach_tcp_proto_field;
10355 if (found_something == 0)
10358 vec_validate (mask, sizeof (*tcp) - 1);
10360 tcp = (tcp_header_t *) mask;
10362 #define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
10363 foreach_tcp_proto_field;
10371 unformat_udp_mask (unformat_input_t * input, va_list * args)
10373 u8 **maskp = va_arg (*args, u8 **);
10375 u8 found_something = 0;
10378 #define _(a) u8 a=0;
10379 foreach_udp_proto_field;
10382 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10385 #define _(a) else if (unformat (input, #a)) a=1;
10386 foreach_udp_proto_field
10392 #define _(a) found_something += a;
10393 foreach_udp_proto_field;
10396 if (found_something == 0)
10399 vec_validate (mask, sizeof (*udp) - 1);
10401 udp = (udp_header_t *) mask;
10403 #define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
10404 foreach_udp_proto_field;
10412 unformat_l4_mask (unformat_input_t * input, va_list * args)
10414 u8 **maskp = va_arg (*args, u8 **);
10415 u16 src_port = 0, dst_port = 0;
10416 tcpudp_header_t *tcpudp;
10418 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10420 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
10422 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
10424 else if (unformat (input, "src_port"))
10426 else if (unformat (input, "dst_port"))
10432 if (!src_port && !dst_port)
10436 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
10438 tcpudp = (tcpudp_header_t *) mask;
10439 tcpudp->src_port = src_port;
10440 tcpudp->dst_port = dst_port;
10448 unformat_ip4_mask (unformat_input_t * input, va_list * args)
10450 u8 **maskp = va_arg (*args, u8 **);
10452 u8 found_something = 0;
10455 #define _(a) u8 a=0;
10456 foreach_ip4_proto_field;
10462 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10464 if (unformat (input, "version"))
10466 else if (unformat (input, "hdr_length"))
10468 else if (unformat (input, "src"))
10470 else if (unformat (input, "dst"))
10472 else if (unformat (input, "proto"))
10475 #define _(a) else if (unformat (input, #a)) a=1;
10476 foreach_ip4_proto_field
10482 #define _(a) found_something += a;
10483 foreach_ip4_proto_field;
10486 if (found_something == 0)
10489 vec_validate (mask, sizeof (*ip) - 1);
10491 ip = (ip4_header_t *) mask;
10493 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
10494 foreach_ip4_proto_field;
10497 ip->ip_version_and_header_length = 0;
10500 ip->ip_version_and_header_length |= 0xF0;
10503 ip->ip_version_and_header_length |= 0x0F;
10509 #define foreach_ip6_proto_field \
10512 _(payload_length) \
10517 unformat_ip6_mask (unformat_input_t * input, va_list * args)
10519 u8 **maskp = va_arg (*args, u8 **);
10521 u8 found_something = 0;
10523 u32 ip_version_traffic_class_and_flow_label;
10525 #define _(a) u8 a=0;
10526 foreach_ip6_proto_field;
10529 u8 traffic_class = 0;
10532 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10534 if (unformat (input, "version"))
10536 else if (unformat (input, "traffic-class"))
10538 else if (unformat (input, "flow-label"))
10540 else if (unformat (input, "src"))
10542 else if (unformat (input, "dst"))
10544 else if (unformat (input, "proto"))
10547 #define _(a) else if (unformat (input, #a)) a=1;
10548 foreach_ip6_proto_field
10554 #define _(a) found_something += a;
10555 foreach_ip6_proto_field;
10558 if (found_something == 0)
10561 vec_validate (mask, sizeof (*ip) - 1);
10563 ip = (ip6_header_t *) mask;
10565 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
10566 foreach_ip6_proto_field;
10569 ip_version_traffic_class_and_flow_label = 0;
10572 ip_version_traffic_class_and_flow_label |= 0xF0000000;
10575 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
10578 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
10580 ip->ip_version_traffic_class_and_flow_label =
10581 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10588 unformat_l3_mask (unformat_input_t * input, va_list * args)
10590 u8 **maskp = va_arg (*args, u8 **);
10592 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10594 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
10596 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
10605 unformat_l2_mask (unformat_input_t * input, va_list * args)
10607 u8 **maskp = va_arg (*args, u8 **);
10614 u8 ignore_tag1 = 0;
10615 u8 ignore_tag2 = 0;
10622 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10624 if (unformat (input, "src"))
10626 else if (unformat (input, "dst"))
10628 else if (unformat (input, "proto"))
10630 else if (unformat (input, "tag1"))
10632 else if (unformat (input, "tag2"))
10634 else if (unformat (input, "ignore-tag1"))
10636 else if (unformat (input, "ignore-tag2"))
10638 else if (unformat (input, "cos1"))
10640 else if (unformat (input, "cos2"))
10642 else if (unformat (input, "dot1q"))
10644 else if (unformat (input, "dot1ad"))
10649 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
10650 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10653 if (tag1 || ignore_tag1 || cos1 || dot1q)
10655 if (tag2 || ignore_tag2 || cos2 || dot1ad)
10658 vec_validate (mask, len - 1);
10661 clib_memset (mask, 0xff, 6);
10664 clib_memset (mask + 6, 0xff, 6);
10666 if (tag2 || dot1ad)
10668 /* inner vlan tag */
10677 mask[21] = mask[20] = 0xff;
10698 mask[16] = mask[17] = 0xff;
10708 mask[12] = mask[13] = 0xff;
10715 unformat_classify_mask (unformat_input_t * input, va_list * args)
10717 u8 **maskp = va_arg (*args, u8 **);
10718 u32 *skipp = va_arg (*args, u32 *);
10719 u32 *matchp = va_arg (*args, u32 *);
10727 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10729 if (unformat (input, "hex %U", unformat_hex_string, &mask))
10731 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
10733 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
10735 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
10749 if (mask || l2 || l3 || l4)
10751 if (l2 || l3 || l4)
10753 /* "With a free Ethernet header in every package" */
10755 vec_validate (l2, 13);
10759 vec_append (mask, l3);
10764 vec_append (mask, l4);
10769 /* Scan forward looking for the first significant mask octet */
10770 for (i = 0; i < vec_len (mask); i++)
10774 /* compute (skip, match) params */
10775 *skipp = i / sizeof (u32x4);
10776 vec_delete (mask, *skipp * sizeof (u32x4), 0);
10778 /* Pad mask to an even multiple of the vector size */
10779 while (vec_len (mask) % sizeof (u32x4))
10780 vec_add1 (mask, 0);
10782 match = vec_len (mask) / sizeof (u32x4);
10784 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
10786 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
10787 if (*tmp || *(tmp + 1))
10792 clib_warning ("BUG: match 0");
10794 _vec_len (mask) = match * sizeof (u32x4);
10804 #endif /* VPP_API_TEST_BUILTIN */
10806 #define foreach_l2_next \
10808 _(ethernet, ETHERNET_INPUT) \
10809 _(ip4, IP4_INPUT) \
10813 unformat_l2_next_index (unformat_input_t * input, va_list * args)
10815 u32 *miss_next_indexp = va_arg (*args, u32 *);
10816 u32 next_index = 0;
10820 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
10824 if (unformat (input, "%d", &tmp))
10833 *miss_next_indexp = next_index;
10837 #define foreach_ip_next \
10840 _(rewrite, REWRITE)
10843 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
10845 u32 *miss_next_indexp = va_arg (*args, u32 *);
10846 u32 next_index = 0;
10850 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
10854 if (unformat (input, "%d", &tmp))
10863 *miss_next_indexp = next_index;
10867 #define foreach_acl_next \
10871 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
10873 u32 *miss_next_indexp = va_arg (*args, u32 *);
10874 u32 next_index = 0;
10878 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
10882 if (unformat (input, "permit"))
10887 else if (unformat (input, "%d", &tmp))
10896 *miss_next_indexp = next_index;
10901 unformat_policer_precolor (unformat_input_t * input, va_list * args)
10903 u32 *r = va_arg (*args, u32 *);
10905 if (unformat (input, "conform-color"))
10906 *r = POLICE_CONFORM;
10907 else if (unformat (input, "exceed-color"))
10908 *r = POLICE_EXCEED;
10916 api_classify_add_del_table (vat_main_t * vam)
10918 unformat_input_t *i = vam->input;
10919 vl_api_classify_add_del_table_t *mp;
10926 u32 table_index = ~0;
10927 u32 next_table_index = ~0;
10928 u32 miss_next_index = ~0;
10929 u32 memory_size = 32 << 20;
10931 u32 current_data_flag = 0;
10932 int current_data_offset = 0;
10935 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10937 if (unformat (i, "del"))
10939 else if (unformat (i, "del-chain"))
10944 else if (unformat (i, "buckets %d", &nbuckets))
10946 else if (unformat (i, "memory_size %d", &memory_size))
10948 else if (unformat (i, "skip %d", &skip))
10950 else if (unformat (i, "match %d", &match))
10952 else if (unformat (i, "table %d", &table_index))
10954 else if (unformat (i, "mask %U", unformat_classify_mask,
10955 &mask, &skip, &match))
10957 else if (unformat (i, "next-table %d", &next_table_index))
10959 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
10962 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
10965 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
10968 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
10970 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
10976 if (is_add && mask == 0)
10978 errmsg ("Mask required");
10982 if (is_add && skip == ~0)
10984 errmsg ("skip count required");
10988 if (is_add && match == ~0)
10990 errmsg ("match count required");
10994 if (!is_add && table_index == ~0)
10996 errmsg ("table index required for delete");
11000 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
11002 mp->is_add = is_add;
11003 mp->del_chain = del_chain;
11004 mp->table_index = ntohl (table_index);
11005 mp->nbuckets = ntohl (nbuckets);
11006 mp->memory_size = ntohl (memory_size);
11007 mp->skip_n_vectors = ntohl (skip);
11008 mp->match_n_vectors = ntohl (match);
11009 mp->next_table_index = ntohl (next_table_index);
11010 mp->miss_next_index = ntohl (miss_next_index);
11011 mp->current_data_flag = ntohl (current_data_flag);
11012 mp->current_data_offset = ntohl (current_data_offset);
11013 mp->mask_len = ntohl (vec_len (mask));
11014 clib_memcpy (mp->mask, mask, vec_len (mask));
11023 #if VPP_API_TEST_BUILTIN == 0
11025 unformat_l4_match (unformat_input_t * input, va_list * args)
11027 u8 **matchp = va_arg (*args, u8 **);
11029 u8 *proto_header = 0;
11035 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11037 if (unformat (input, "src_port %d", &src_port))
11039 else if (unformat (input, "dst_port %d", &dst_port))
11045 h.src_port = clib_host_to_net_u16 (src_port);
11046 h.dst_port = clib_host_to_net_u16 (dst_port);
11047 vec_validate (proto_header, sizeof (h) - 1);
11048 memcpy (proto_header, &h, sizeof (h));
11050 *matchp = proto_header;
11056 unformat_ip4_match (unformat_input_t * input, va_list * args)
11058 u8 **matchp = va_arg (*args, u8 **);
11063 int hdr_length = 0;
11064 u32 hdr_length_val;
11065 int src = 0, dst = 0;
11066 ip4_address_t src_val, dst_val;
11073 int fragment_id = 0;
11074 u32 fragment_id_val;
11080 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11082 if (unformat (input, "version %d", &version_val))
11084 else if (unformat (input, "hdr_length %d", &hdr_length_val))
11086 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
11088 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
11090 else if (unformat (input, "proto %d", &proto_val))
11092 else if (unformat (input, "tos %d", &tos_val))
11094 else if (unformat (input, "length %d", &length_val))
11096 else if (unformat (input, "fragment_id %d", &fragment_id_val))
11098 else if (unformat (input, "ttl %d", &ttl_val))
11100 else if (unformat (input, "checksum %d", &checksum_val))
11106 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
11107 + ttl + checksum == 0)
11111 * Aligned because we use the real comparison functions
11113 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11115 ip = (ip4_header_t *) match;
11117 /* These are realistically matched in practice */
11119 ip->src_address.as_u32 = src_val.as_u32;
11122 ip->dst_address.as_u32 = dst_val.as_u32;
11125 ip->protocol = proto_val;
11128 /* These are not, but they're included for completeness */
11130 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
11133 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
11139 ip->length = clib_host_to_net_u16 (length_val);
11145 ip->checksum = clib_host_to_net_u16 (checksum_val);
11152 unformat_ip6_match (unformat_input_t * input, va_list * args)
11154 u8 **matchp = va_arg (*args, u8 **);
11159 u8 traffic_class = 0;
11160 u32 traffic_class_val = 0;
11163 int src = 0, dst = 0;
11164 ip6_address_t src_val, dst_val;
11167 int payload_length = 0;
11168 u32 payload_length_val;
11171 u32 ip_version_traffic_class_and_flow_label;
11173 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11175 if (unformat (input, "version %d", &version_val))
11177 else if (unformat (input, "traffic_class %d", &traffic_class_val))
11179 else if (unformat (input, "flow_label %d", &flow_label_val))
11181 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
11183 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
11185 else if (unformat (input, "proto %d", &proto_val))
11187 else if (unformat (input, "payload_length %d", &payload_length_val))
11188 payload_length = 1;
11189 else if (unformat (input, "hop_limit %d", &hop_limit_val))
11195 if (version + traffic_class + flow_label + src + dst + proto +
11196 payload_length + hop_limit == 0)
11200 * Aligned because we use the real comparison functions
11202 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11204 ip = (ip6_header_t *) match;
11207 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
11210 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
11213 ip->protocol = proto_val;
11215 ip_version_traffic_class_and_flow_label = 0;
11218 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
11221 ip_version_traffic_class_and_flow_label |=
11222 (traffic_class_val & 0xFF) << 20;
11225 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
11227 ip->ip_version_traffic_class_and_flow_label =
11228 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
11230 if (payload_length)
11231 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
11234 ip->hop_limit = hop_limit_val;
11241 unformat_l3_match (unformat_input_t * input, va_list * args)
11243 u8 **matchp = va_arg (*args, u8 **);
11245 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11247 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
11249 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
11258 unformat_vlan_tag (unformat_input_t * input, va_list * args)
11260 u8 *tagp = va_arg (*args, u8 *);
11263 if (unformat (input, "%d", &tag))
11265 tagp[0] = (tag >> 8) & 0x0F;
11266 tagp[1] = tag & 0xFF;
11274 unformat_l2_match (unformat_input_t * input, va_list * args)
11276 u8 **matchp = va_arg (*args, u8 **);
11289 u8 ignore_tag1 = 0;
11290 u8 ignore_tag2 = 0;
11296 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11298 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
11301 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
11303 else if (unformat (input, "proto %U",
11304 unformat_ethernet_type_host_byte_order, &proto_val))
11306 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
11308 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
11310 else if (unformat (input, "ignore-tag1"))
11312 else if (unformat (input, "ignore-tag2"))
11314 else if (unformat (input, "cos1 %d", &cos1_val))
11316 else if (unformat (input, "cos2 %d", &cos2_val))
11321 if ((src + dst + proto + tag1 + tag2 +
11322 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
11325 if (tag1 || ignore_tag1 || cos1)
11327 if (tag2 || ignore_tag2 || cos2)
11330 vec_validate_aligned (match, len - 1, sizeof (u32x4));
11333 clib_memcpy (match, dst_val, 6);
11336 clib_memcpy (match + 6, src_val, 6);
11340 /* inner vlan tag */
11341 match[19] = tag2_val[1];
11342 match[18] = tag2_val[0];
11344 match[18] |= (cos2_val & 0x7) << 5;
11347 match[21] = proto_val & 0xff;
11348 match[20] = proto_val >> 8;
11352 match[15] = tag1_val[1];
11353 match[14] = tag1_val[0];
11356 match[14] |= (cos1_val & 0x7) << 5;
11362 match[15] = tag1_val[1];
11363 match[14] = tag1_val[0];
11366 match[17] = proto_val & 0xff;
11367 match[16] = proto_val >> 8;
11370 match[14] |= (cos1_val & 0x7) << 5;
11376 match[18] |= (cos2_val & 0x7) << 5;
11378 match[14] |= (cos1_val & 0x7) << 5;
11381 match[13] = proto_val & 0xff;
11382 match[12] = proto_val >> 8;
11390 unformat_qos_source (unformat_input_t * input, va_list * args)
11392 int *qs = va_arg (*args, int *);
11394 if (unformat (input, "ip"))
11395 *qs = QOS_SOURCE_IP;
11396 else if (unformat (input, "mpls"))
11397 *qs = QOS_SOURCE_MPLS;
11398 else if (unformat (input, "ext"))
11399 *qs = QOS_SOURCE_EXT;
11400 else if (unformat (input, "vlan"))
11401 *qs = QOS_SOURCE_VLAN;
11410 api_unformat_classify_match (unformat_input_t * input, va_list * args)
11412 u8 **matchp = va_arg (*args, u8 **);
11413 u32 skip_n_vectors = va_arg (*args, u32);
11414 u32 match_n_vectors = va_arg (*args, u32);
11421 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11423 if (unformat (input, "hex %U", unformat_hex_string, &match))
11425 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
11427 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
11429 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
11443 if (match || l2 || l3 || l4)
11445 if (l2 || l3 || l4)
11447 /* "Win a free Ethernet header in every packet" */
11449 vec_validate_aligned (l2, 13, sizeof (u32x4));
11453 vec_append_aligned (match, l3, sizeof (u32x4));
11458 vec_append_aligned (match, l4, sizeof (u32x4));
11463 /* Make sure the vector is big enough even if key is all 0's */
11464 vec_validate_aligned
11465 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
11468 /* Set size, include skipped vectors */
11469 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
11480 api_classify_add_del_session (vat_main_t * vam)
11482 unformat_input_t *i = vam->input;
11483 vl_api_classify_add_del_session_t *mp;
11485 u32 table_index = ~0;
11486 u32 hit_next_index = ~0;
11487 u32 opaque_index = ~0;
11490 u32 skip_n_vectors = 0;
11491 u32 match_n_vectors = 0;
11497 * Warning: you have to supply skip_n and match_n
11498 * because the API client cant simply look at the classify
11502 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11504 if (unformat (i, "del"))
11506 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
11509 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
11512 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
11515 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
11517 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
11519 else if (unformat (i, "opaque-index %d", &opaque_index))
11521 else if (unformat (i, "skip_n %d", &skip_n_vectors))
11523 else if (unformat (i, "match_n %d", &match_n_vectors))
11525 else if (unformat (i, "match %U", api_unformat_classify_match,
11526 &match, skip_n_vectors, match_n_vectors))
11528 else if (unformat (i, "advance %d", &advance))
11530 else if (unformat (i, "table-index %d", &table_index))
11532 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
11534 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
11536 else if (unformat (i, "action %d", &action))
11538 else if (unformat (i, "metadata %d", &metadata))
11544 if (table_index == ~0)
11546 errmsg ("Table index required");
11550 if (is_add && match == 0)
11552 errmsg ("Match value required");
11556 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
11558 mp->is_add = is_add;
11559 mp->table_index = ntohl (table_index);
11560 mp->hit_next_index = ntohl (hit_next_index);
11561 mp->opaque_index = ntohl (opaque_index);
11562 mp->advance = ntohl (advance);
11563 mp->action = action;
11564 mp->metadata = ntohl (metadata);
11565 mp->match_len = ntohl (vec_len (match));
11566 clib_memcpy (mp->match, match, vec_len (match));
11575 api_classify_set_interface_ip_table (vat_main_t * vam)
11577 unformat_input_t *i = vam->input;
11578 vl_api_classify_set_interface_ip_table_t *mp;
11580 int sw_if_index_set;
11581 u32 table_index = ~0;
11585 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11587 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11588 sw_if_index_set = 1;
11589 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11590 sw_if_index_set = 1;
11591 else if (unformat (i, "table %d", &table_index))
11595 clib_warning ("parse error '%U'", format_unformat_error, i);
11600 if (sw_if_index_set == 0)
11602 errmsg ("missing interface name or sw_if_index");
11607 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
11609 mp->sw_if_index = ntohl (sw_if_index);
11610 mp->table_index = ntohl (table_index);
11611 mp->is_ipv6 = is_ipv6;
11619 api_classify_set_interface_l2_tables (vat_main_t * vam)
11621 unformat_input_t *i = vam->input;
11622 vl_api_classify_set_interface_l2_tables_t *mp;
11624 int sw_if_index_set;
11625 u32 ip4_table_index = ~0;
11626 u32 ip6_table_index = ~0;
11627 u32 other_table_index = ~0;
11631 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11633 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11634 sw_if_index_set = 1;
11635 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11636 sw_if_index_set = 1;
11637 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11639 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11641 else if (unformat (i, "other-table %d", &other_table_index))
11643 else if (unformat (i, "is-input %d", &is_input))
11647 clib_warning ("parse error '%U'", format_unformat_error, i);
11652 if (sw_if_index_set == 0)
11654 errmsg ("missing interface name or sw_if_index");
11659 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
11661 mp->sw_if_index = ntohl (sw_if_index);
11662 mp->ip4_table_index = ntohl (ip4_table_index);
11663 mp->ip6_table_index = ntohl (ip6_table_index);
11664 mp->other_table_index = ntohl (other_table_index);
11665 mp->is_input = (u8) is_input;
11673 api_set_ipfix_exporter (vat_main_t * vam)
11675 unformat_input_t *i = vam->input;
11676 vl_api_set_ipfix_exporter_t *mp;
11677 ip4_address_t collector_address;
11678 u8 collector_address_set = 0;
11679 u32 collector_port = ~0;
11680 ip4_address_t src_address;
11681 u8 src_address_set = 0;
11684 u32 template_interval = ~0;
11685 u8 udp_checksum = 0;
11688 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11690 if (unformat (i, "collector_address %U", unformat_ip4_address,
11691 &collector_address))
11692 collector_address_set = 1;
11693 else if (unformat (i, "collector_port %d", &collector_port))
11695 else if (unformat (i, "src_address %U", unformat_ip4_address,
11697 src_address_set = 1;
11698 else if (unformat (i, "vrf_id %d", &vrf_id))
11700 else if (unformat (i, "path_mtu %d", &path_mtu))
11702 else if (unformat (i, "template_interval %d", &template_interval))
11704 else if (unformat (i, "udp_checksum"))
11710 if (collector_address_set == 0)
11712 errmsg ("collector_address required");
11716 if (src_address_set == 0)
11718 errmsg ("src_address required");
11722 M (SET_IPFIX_EXPORTER, mp);
11724 memcpy (mp->collector_address, collector_address.data,
11725 sizeof (collector_address.data));
11726 mp->collector_port = htons ((u16) collector_port);
11727 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
11728 mp->vrf_id = htonl (vrf_id);
11729 mp->path_mtu = htonl (path_mtu);
11730 mp->template_interval = htonl (template_interval);
11731 mp->udp_checksum = udp_checksum;
11739 api_set_ipfix_classify_stream (vat_main_t * vam)
11741 unformat_input_t *i = vam->input;
11742 vl_api_set_ipfix_classify_stream_t *mp;
11744 u32 src_port = UDP_DST_PORT_ipfix;
11747 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11749 if (unformat (i, "domain %d", &domain_id))
11751 else if (unformat (i, "src_port %d", &src_port))
11755 errmsg ("unknown input `%U'", format_unformat_error, i);
11760 M (SET_IPFIX_CLASSIFY_STREAM, mp);
11762 mp->domain_id = htonl (domain_id);
11763 mp->src_port = htons ((u16) src_port);
11771 api_ipfix_classify_table_add_del (vat_main_t * vam)
11773 unformat_input_t *i = vam->input;
11774 vl_api_ipfix_classify_table_add_del_t *mp;
11776 u32 classify_table_index = ~0;
11778 u8 transport_protocol = 255;
11781 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11783 if (unformat (i, "add"))
11785 else if (unformat (i, "del"))
11787 else if (unformat (i, "table %d", &classify_table_index))
11789 else if (unformat (i, "ip4"))
11791 else if (unformat (i, "ip6"))
11793 else if (unformat (i, "tcp"))
11794 transport_protocol = 6;
11795 else if (unformat (i, "udp"))
11796 transport_protocol = 17;
11799 errmsg ("unknown input `%U'", format_unformat_error, i);
11806 errmsg ("expecting: add|del");
11809 if (classify_table_index == ~0)
11811 errmsg ("classifier table not specified");
11814 if (ip_version == 0)
11816 errmsg ("IP version not specified");
11820 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
11822 mp->is_add = is_add;
11823 mp->table_id = htonl (classify_table_index);
11824 mp->ip_version = ip_version;
11825 mp->transport_protocol = transport_protocol;
11833 api_get_node_index (vat_main_t * vam)
11835 unformat_input_t *i = vam->input;
11836 vl_api_get_node_index_t *mp;
11840 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11842 if (unformat (i, "node %s", &name))
11849 errmsg ("node name required");
11852 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11854 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11858 M (GET_NODE_INDEX, mp);
11859 clib_memcpy (mp->node_name, name, vec_len (name));
11868 api_get_next_index (vat_main_t * vam)
11870 unformat_input_t *i = vam->input;
11871 vl_api_get_next_index_t *mp;
11872 u8 *node_name = 0, *next_node_name = 0;
11875 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11877 if (unformat (i, "node-name %s", &node_name))
11879 else if (unformat (i, "next-node-name %s", &next_node_name))
11883 if (node_name == 0)
11885 errmsg ("node name required");
11888 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
11890 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11894 if (next_node_name == 0)
11896 errmsg ("next node name required");
11899 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
11901 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
11905 M (GET_NEXT_INDEX, mp);
11906 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
11907 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
11908 vec_free (node_name);
11909 vec_free (next_node_name);
11917 api_add_node_next (vat_main_t * vam)
11919 unformat_input_t *i = vam->input;
11920 vl_api_add_node_next_t *mp;
11925 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11927 if (unformat (i, "node %s", &name))
11929 else if (unformat (i, "next %s", &next))
11936 errmsg ("node name required");
11939 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11941 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11946 errmsg ("next node required");
11949 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
11951 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
11955 M (ADD_NODE_NEXT, mp);
11956 clib_memcpy (mp->node_name, name, vec_len (name));
11957 clib_memcpy (mp->next_name, next, vec_len (next));
11967 api_l2tpv3_create_tunnel (vat_main_t * vam)
11969 unformat_input_t *i = vam->input;
11970 ip6_address_t client_address, our_address;
11971 int client_address_set = 0;
11972 int our_address_set = 0;
11973 u32 local_session_id = 0;
11974 u32 remote_session_id = 0;
11975 u64 local_cookie = 0;
11976 u64 remote_cookie = 0;
11977 u8 l2_sublayer_present = 0;
11978 vl_api_l2tpv3_create_tunnel_t *mp;
11981 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11983 if (unformat (i, "client_address %U", unformat_ip6_address,
11985 client_address_set = 1;
11986 else if (unformat (i, "our_address %U", unformat_ip6_address,
11988 our_address_set = 1;
11989 else if (unformat (i, "local_session_id %d", &local_session_id))
11991 else if (unformat (i, "remote_session_id %d", &remote_session_id))
11993 else if (unformat (i, "local_cookie %lld", &local_cookie))
11995 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
11997 else if (unformat (i, "l2-sublayer-present"))
11998 l2_sublayer_present = 1;
12003 if (client_address_set == 0)
12005 errmsg ("client_address required");
12009 if (our_address_set == 0)
12011 errmsg ("our_address required");
12015 M (L2TPV3_CREATE_TUNNEL, mp);
12017 clib_memcpy (mp->client_address, client_address.as_u8,
12018 sizeof (mp->client_address));
12020 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
12022 mp->local_session_id = ntohl (local_session_id);
12023 mp->remote_session_id = ntohl (remote_session_id);
12024 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
12025 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
12026 mp->l2_sublayer_present = l2_sublayer_present;
12035 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
12037 unformat_input_t *i = vam->input;
12039 u8 sw_if_index_set = 0;
12040 u64 new_local_cookie = 0;
12041 u64 new_remote_cookie = 0;
12042 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
12045 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12047 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12048 sw_if_index_set = 1;
12049 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12050 sw_if_index_set = 1;
12051 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
12053 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
12059 if (sw_if_index_set == 0)
12061 errmsg ("missing interface name or sw_if_index");
12065 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
12067 mp->sw_if_index = ntohl (sw_if_index);
12068 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
12069 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
12077 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
12079 unformat_input_t *i = vam->input;
12080 vl_api_l2tpv3_interface_enable_disable_t *mp;
12082 u8 sw_if_index_set = 0;
12083 u8 enable_disable = 1;
12086 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12088 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12089 sw_if_index_set = 1;
12090 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12091 sw_if_index_set = 1;
12092 else if (unformat (i, "enable"))
12093 enable_disable = 1;
12094 else if (unformat (i, "disable"))
12095 enable_disable = 0;
12100 if (sw_if_index_set == 0)
12102 errmsg ("missing interface name or sw_if_index");
12106 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
12108 mp->sw_if_index = ntohl (sw_if_index);
12109 mp->enable_disable = enable_disable;
12117 api_l2tpv3_set_lookup_key (vat_main_t * vam)
12119 unformat_input_t *i = vam->input;
12120 vl_api_l2tpv3_set_lookup_key_t *mp;
12124 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12126 if (unformat (i, "lookup_v6_src"))
12127 key = L2T_LOOKUP_SRC_ADDRESS;
12128 else if (unformat (i, "lookup_v6_dst"))
12129 key = L2T_LOOKUP_DST_ADDRESS;
12130 else if (unformat (i, "lookup_session_id"))
12131 key = L2T_LOOKUP_SESSION_ID;
12136 if (key == (u8) ~ 0)
12138 errmsg ("l2tp session lookup key unset");
12142 M (L2TPV3_SET_LOOKUP_KEY, mp);
12151 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
12152 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12154 vat_main_t *vam = &vat_main;
12156 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
12157 format_ip6_address, mp->our_address,
12158 format_ip6_address, mp->client_address,
12159 clib_net_to_host_u32 (mp->sw_if_index));
12162 " local cookies %016llx %016llx remote cookie %016llx",
12163 clib_net_to_host_u64 (mp->local_cookie[0]),
12164 clib_net_to_host_u64 (mp->local_cookie[1]),
12165 clib_net_to_host_u64 (mp->remote_cookie));
12167 print (vam->ofp, " local session-id %d remote session-id %d",
12168 clib_net_to_host_u32 (mp->local_session_id),
12169 clib_net_to_host_u32 (mp->remote_session_id));
12171 print (vam->ofp, " l2 specific sublayer %s\n",
12172 mp->l2_sublayer_present ? "preset" : "absent");
12176 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
12177 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12179 vat_main_t *vam = &vat_main;
12180 vat_json_node_t *node = NULL;
12181 struct in6_addr addr;
12183 if (VAT_JSON_ARRAY != vam->json_tree.type)
12185 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12186 vat_json_init_array (&vam->json_tree);
12188 node = vat_json_array_add (&vam->json_tree);
12190 vat_json_init_object (node);
12192 clib_memcpy (&addr, mp->our_address, sizeof (addr));
12193 vat_json_object_add_ip6 (node, "our_address", addr);
12194 clib_memcpy (&addr, mp->client_address, sizeof (addr));
12195 vat_json_object_add_ip6 (node, "client_address", addr);
12197 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
12198 vat_json_init_array (lc);
12199 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
12200 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
12201 vat_json_object_add_uint (node, "remote_cookie",
12202 clib_net_to_host_u64 (mp->remote_cookie));
12204 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
12205 vat_json_object_add_uint (node, "local_session_id",
12206 clib_net_to_host_u32 (mp->local_session_id));
12207 vat_json_object_add_uint (node, "remote_session_id",
12208 clib_net_to_host_u32 (mp->remote_session_id));
12209 vat_json_object_add_string_copy (node, "l2_sublayer",
12210 mp->l2_sublayer_present ? (u8 *) "present"
12211 : (u8 *) "absent");
12215 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
12217 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
12218 vl_api_control_ping_t *mp_ping;
12221 /* Get list of l2tpv3-tunnel interfaces */
12222 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
12225 /* Use a control ping for synchronization */
12226 MPING (CONTROL_PING, mp_ping);
12234 static void vl_api_sw_interface_tap_v2_details_t_handler
12235 (vl_api_sw_interface_tap_v2_details_t * mp)
12237 vat_main_t *vam = &vat_main;
12239 u8 *ip4 = format (0, "%U/%d", format_ip4_address, mp->host_ip4_addr,
12240 mp->host_ip4_prefix_len);
12241 u8 *ip6 = format (0, "%U/%d", format_ip6_address, mp->host_ip6_addr,
12242 mp->host_ip6_prefix_len);
12245 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s 0x%-08x",
12246 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
12247 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
12248 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
12249 mp->host_bridge, ip4, ip6, ntohl (mp->tap_flags));
12255 static void vl_api_sw_interface_tap_v2_details_t_handler_json
12256 (vl_api_sw_interface_tap_v2_details_t * mp)
12258 vat_main_t *vam = &vat_main;
12259 vat_json_node_t *node = NULL;
12261 if (VAT_JSON_ARRAY != vam->json_tree.type)
12263 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12264 vat_json_init_array (&vam->json_tree);
12266 node = vat_json_array_add (&vam->json_tree);
12268 vat_json_init_object (node);
12269 vat_json_object_add_uint (node, "id", ntohl (mp->id));
12270 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12271 vat_json_object_add_uint (node, "tap_flags", ntohl (mp->tap_flags));
12272 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
12273 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
12274 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
12275 vat_json_object_add_string_copy (node, "host_mac_addr",
12276 format (0, "%U", format_ethernet_address,
12277 &mp->host_mac_addr));
12278 vat_json_object_add_string_copy (node, "host_namespace",
12279 mp->host_namespace);
12280 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
12281 vat_json_object_add_string_copy (node, "host_ip4_addr",
12282 format (0, "%U/%d", format_ip4_address,
12284 mp->host_ip4_prefix_len));
12285 vat_json_object_add_string_copy (node, "host_ip6_addr",
12286 format (0, "%U/%d", format_ip6_address,
12288 mp->host_ip6_prefix_len));
12293 api_sw_interface_tap_v2_dump (vat_main_t * vam)
12295 vl_api_sw_interface_tap_v2_dump_t *mp;
12296 vl_api_control_ping_t *mp_ping;
12300 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
12301 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
12302 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
12305 /* Get list of tap interfaces */
12306 M (SW_INTERFACE_TAP_V2_DUMP, mp);
12309 /* Use a control ping for synchronization */
12310 MPING (CONTROL_PING, mp_ping);
12317 static void vl_api_sw_interface_virtio_pci_details_t_handler
12318 (vl_api_sw_interface_virtio_pci_details_t * mp)
12320 vat_main_t *vam = &vat_main;
12334 addr.as_u32 = ntohl (mp->pci_addr);
12335 u8 *pci_addr = format (0, "%04x:%02x:%02x.%x", addr.domain, addr.bus,
12336 addr.slot, addr.function);
12339 "\n%-12s %-12d %-12d %-12d %-17U 0x%-08llx",
12340 pci_addr, ntohl (mp->sw_if_index),
12341 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
12342 format_ethernet_address, mp->mac_addr,
12343 clib_net_to_host_u64 (mp->features));
12344 vec_free (pci_addr);
12347 static void vl_api_sw_interface_virtio_pci_details_t_handler_json
12348 (vl_api_sw_interface_virtio_pci_details_t * mp)
12350 vat_main_t *vam = &vat_main;
12351 vat_json_node_t *node = NULL;
12353 if (VAT_JSON_ARRAY != vam->json_tree.type)
12355 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12356 vat_json_init_array (&vam->json_tree);
12358 node = vat_json_array_add (&vam->json_tree);
12360 vat_json_init_object (node);
12361 vat_json_object_add_uint (node, "pci-addr", ntohl (mp->pci_addr));
12362 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12363 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
12364 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
12365 vat_json_object_add_uint (node, "features",
12366 clib_net_to_host_u64 (mp->features));
12367 vat_json_object_add_string_copy (node, "mac_addr",
12368 format (0, "%U", format_ethernet_address,
12373 api_sw_interface_virtio_pci_dump (vat_main_t * vam)
12375 vl_api_sw_interface_virtio_pci_dump_t *mp;
12376 vl_api_control_ping_t *mp_ping;
12380 "\n%-12s %-12s %-12s %-12s %-17s %-08s",
12381 "pci_addr", "sw_if_index", "rx_ring_sz", "tx_ring_sz",
12382 "mac_addr", "features");
12384 /* Get list of tap interfaces */
12385 M (SW_INTERFACE_VIRTIO_PCI_DUMP, mp);
12388 /* Use a control ping for synchronization */
12389 MPING (CONTROL_PING, mp_ping);
12397 api_vxlan_offload_rx (vat_main_t * vam)
12399 unformat_input_t *line_input = vam->input;
12400 vl_api_vxlan_offload_rx_t *mp;
12401 u32 hw_if_index = ~0, rx_if_index = ~0;
12405 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12407 if (unformat (line_input, "del"))
12409 else if (unformat (line_input, "hw %U", api_unformat_hw_if_index, vam,
12412 else if (unformat (line_input, "hw hw_if_index %u", &hw_if_index))
12414 else if (unformat (line_input, "rx %U", api_unformat_sw_if_index, vam,
12417 else if (unformat (line_input, "rx sw_if_index %u", &rx_if_index))
12421 errmsg ("parse error '%U'", format_unformat_error, line_input);
12426 if (hw_if_index == ~0)
12428 errmsg ("no hw interface");
12432 if (rx_if_index == ~0)
12434 errmsg ("no rx tunnel");
12438 M (VXLAN_OFFLOAD_RX, mp);
12440 mp->hw_if_index = ntohl (hw_if_index);
12441 mp->sw_if_index = ntohl (rx_if_index);
12442 mp->enable = is_add;
12449 static uword unformat_vxlan_decap_next
12450 (unformat_input_t * input, va_list * args)
12452 u32 *result = va_arg (*args, u32 *);
12455 if (unformat (input, "l2"))
12456 *result = VXLAN_INPUT_NEXT_L2_INPUT;
12457 else if (unformat (input, "%d", &tmp))
12465 api_vxlan_add_del_tunnel (vat_main_t * vam)
12467 unformat_input_t *line_input = vam->input;
12468 vl_api_vxlan_add_del_tunnel_t *mp;
12469 ip46_address_t src, dst;
12471 u8 ipv4_set = 0, ipv6_set = 0;
12476 u32 mcast_sw_if_index = ~0;
12477 u32 encap_vrf_id = 0;
12478 u32 decap_next_index = ~0;
12482 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12483 clib_memset (&src, 0, sizeof src);
12484 clib_memset (&dst, 0, sizeof dst);
12486 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12488 if (unformat (line_input, "del"))
12490 else if (unformat (line_input, "instance %d", &instance))
12493 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12499 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12505 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12511 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12516 else if (unformat (line_input, "group %U %U",
12517 unformat_ip4_address, &dst.ip4,
12518 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12520 grp_set = dst_set = 1;
12523 else if (unformat (line_input, "group %U",
12524 unformat_ip4_address, &dst.ip4))
12526 grp_set = dst_set = 1;
12529 else if (unformat (line_input, "group %U %U",
12530 unformat_ip6_address, &dst.ip6,
12531 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12533 grp_set = dst_set = 1;
12536 else if (unformat (line_input, "group %U",
12537 unformat_ip6_address, &dst.ip6))
12539 grp_set = dst_set = 1;
12543 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12545 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12547 else if (unformat (line_input, "decap-next %U",
12548 unformat_vxlan_decap_next, &decap_next_index))
12550 else if (unformat (line_input, "vni %d", &vni))
12554 errmsg ("parse error '%U'", format_unformat_error, line_input);
12561 errmsg ("tunnel src address not specified");
12566 errmsg ("tunnel dst address not specified");
12570 if (grp_set && !ip46_address_is_multicast (&dst))
12572 errmsg ("tunnel group address not multicast");
12575 if (grp_set && mcast_sw_if_index == ~0)
12577 errmsg ("tunnel nonexistent multicast device");
12580 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12582 errmsg ("tunnel dst address must be unicast");
12587 if (ipv4_set && ipv6_set)
12589 errmsg ("both IPv4 and IPv6 addresses specified");
12593 if ((vni == 0) || (vni >> 24))
12595 errmsg ("vni not specified or out of range");
12599 M (VXLAN_ADD_DEL_TUNNEL, mp);
12603 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
12604 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
12608 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
12609 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
12612 mp->instance = htonl (instance);
12613 mp->encap_vrf_id = ntohl (encap_vrf_id);
12614 mp->decap_next_index = ntohl (decap_next_index);
12615 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12616 mp->vni = ntohl (vni);
12617 mp->is_add = is_add;
12618 mp->is_ipv6 = ipv6_set;
12625 static void vl_api_vxlan_tunnel_details_t_handler
12626 (vl_api_vxlan_tunnel_details_t * mp)
12628 vat_main_t *vam = &vat_main;
12629 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12630 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12632 print (vam->ofp, "%11d%11d%24U%24U%14d%18d%13d%19d",
12633 ntohl (mp->sw_if_index),
12634 ntohl (mp->instance),
12635 format_ip46_address, &src, IP46_TYPE_ANY,
12636 format_ip46_address, &dst, IP46_TYPE_ANY,
12637 ntohl (mp->encap_vrf_id),
12638 ntohl (mp->decap_next_index), ntohl (mp->vni),
12639 ntohl (mp->mcast_sw_if_index));
12642 static void vl_api_vxlan_tunnel_details_t_handler_json
12643 (vl_api_vxlan_tunnel_details_t * mp)
12645 vat_main_t *vam = &vat_main;
12646 vat_json_node_t *node = NULL;
12648 if (VAT_JSON_ARRAY != vam->json_tree.type)
12650 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12651 vat_json_init_array (&vam->json_tree);
12653 node = vat_json_array_add (&vam->json_tree);
12655 vat_json_init_object (node);
12656 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12658 vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
12662 struct in6_addr ip6;
12664 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12665 vat_json_object_add_ip6 (node, "src_address", ip6);
12666 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12667 vat_json_object_add_ip6 (node, "dst_address", ip6);
12671 struct in_addr ip4;
12673 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12674 vat_json_object_add_ip4 (node, "src_address", ip4);
12675 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12676 vat_json_object_add_ip4 (node, "dst_address", ip4);
12678 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12679 vat_json_object_add_uint (node, "decap_next_index",
12680 ntohl (mp->decap_next_index));
12681 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12682 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12683 vat_json_object_add_uint (node, "mcast_sw_if_index",
12684 ntohl (mp->mcast_sw_if_index));
12688 api_vxlan_tunnel_dump (vat_main_t * vam)
12690 unformat_input_t *i = vam->input;
12691 vl_api_vxlan_tunnel_dump_t *mp;
12692 vl_api_control_ping_t *mp_ping;
12694 u8 sw_if_index_set = 0;
12697 /* Parse args required to build the message */
12698 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12700 if (unformat (i, "sw_if_index %d", &sw_if_index))
12701 sw_if_index_set = 1;
12706 if (sw_if_index_set == 0)
12711 if (!vam->json_output)
12713 print (vam->ofp, "%11s%11s%24s%24s%14s%18s%13s%19s",
12714 "sw_if_index", "instance", "src_address", "dst_address",
12715 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12718 /* Get list of vxlan-tunnel interfaces */
12719 M (VXLAN_TUNNEL_DUMP, mp);
12721 mp->sw_if_index = htonl (sw_if_index);
12725 /* Use a control ping for synchronization */
12726 MPING (CONTROL_PING, mp_ping);
12733 static uword unformat_geneve_decap_next
12734 (unformat_input_t * input, va_list * args)
12736 u32 *result = va_arg (*args, u32 *);
12739 if (unformat (input, "l2"))
12740 *result = GENEVE_INPUT_NEXT_L2_INPUT;
12741 else if (unformat (input, "%d", &tmp))
12749 api_geneve_add_del_tunnel (vat_main_t * vam)
12751 unformat_input_t *line_input = vam->input;
12752 vl_api_geneve_add_del_tunnel_t *mp;
12753 ip46_address_t src, dst;
12755 u8 ipv4_set = 0, ipv6_set = 0;
12759 u32 mcast_sw_if_index = ~0;
12760 u32 encap_vrf_id = 0;
12761 u32 decap_next_index = ~0;
12765 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12766 clib_memset (&src, 0, sizeof src);
12767 clib_memset (&dst, 0, sizeof dst);
12769 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12771 if (unformat (line_input, "del"))
12774 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12780 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12786 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12792 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12797 else if (unformat (line_input, "group %U %U",
12798 unformat_ip4_address, &dst.ip4,
12799 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12801 grp_set = dst_set = 1;
12804 else if (unformat (line_input, "group %U",
12805 unformat_ip4_address, &dst.ip4))
12807 grp_set = dst_set = 1;
12810 else if (unformat (line_input, "group %U %U",
12811 unformat_ip6_address, &dst.ip6,
12812 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12814 grp_set = dst_set = 1;
12817 else if (unformat (line_input, "group %U",
12818 unformat_ip6_address, &dst.ip6))
12820 grp_set = dst_set = 1;
12824 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12826 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12828 else if (unformat (line_input, "decap-next %U",
12829 unformat_geneve_decap_next, &decap_next_index))
12831 else if (unformat (line_input, "vni %d", &vni))
12835 errmsg ("parse error '%U'", format_unformat_error, line_input);
12842 errmsg ("tunnel src address not specified");
12847 errmsg ("tunnel dst address not specified");
12851 if (grp_set && !ip46_address_is_multicast (&dst))
12853 errmsg ("tunnel group address not multicast");
12856 if (grp_set && mcast_sw_if_index == ~0)
12858 errmsg ("tunnel nonexistent multicast device");
12861 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12863 errmsg ("tunnel dst address must be unicast");
12868 if (ipv4_set && ipv6_set)
12870 errmsg ("both IPv4 and IPv6 addresses specified");
12874 if ((vni == 0) || (vni >> 24))
12876 errmsg ("vni not specified or out of range");
12880 M (GENEVE_ADD_DEL_TUNNEL, mp);
12884 clib_memcpy (mp->local_address, &src.ip6, sizeof (src.ip6));
12885 clib_memcpy (mp->remote_address, &dst.ip6, sizeof (dst.ip6));
12889 clib_memcpy (mp->local_address, &src.ip4, sizeof (src.ip4));
12890 clib_memcpy (mp->remote_address, &dst.ip4, sizeof (dst.ip4));
12892 mp->encap_vrf_id = ntohl (encap_vrf_id);
12893 mp->decap_next_index = ntohl (decap_next_index);
12894 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12895 mp->vni = ntohl (vni);
12896 mp->is_add = is_add;
12897 mp->is_ipv6 = ipv6_set;
12904 static void vl_api_geneve_tunnel_details_t_handler
12905 (vl_api_geneve_tunnel_details_t * mp)
12907 vat_main_t *vam = &vat_main;
12908 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12909 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12911 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12912 ntohl (mp->sw_if_index),
12913 format_ip46_address, &src, IP46_TYPE_ANY,
12914 format_ip46_address, &dst, IP46_TYPE_ANY,
12915 ntohl (mp->encap_vrf_id),
12916 ntohl (mp->decap_next_index), ntohl (mp->vni),
12917 ntohl (mp->mcast_sw_if_index));
12920 static void vl_api_geneve_tunnel_details_t_handler_json
12921 (vl_api_geneve_tunnel_details_t * mp)
12923 vat_main_t *vam = &vat_main;
12924 vat_json_node_t *node = NULL;
12926 if (VAT_JSON_ARRAY != vam->json_tree.type)
12928 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12929 vat_json_init_array (&vam->json_tree);
12931 node = vat_json_array_add (&vam->json_tree);
12933 vat_json_init_object (node);
12934 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12937 struct in6_addr ip6;
12939 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12940 vat_json_object_add_ip6 (node, "src_address", ip6);
12941 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12942 vat_json_object_add_ip6 (node, "dst_address", ip6);
12946 struct in_addr ip4;
12948 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12949 vat_json_object_add_ip4 (node, "src_address", ip4);
12950 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12951 vat_json_object_add_ip4 (node, "dst_address", ip4);
12953 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12954 vat_json_object_add_uint (node, "decap_next_index",
12955 ntohl (mp->decap_next_index));
12956 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12957 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12958 vat_json_object_add_uint (node, "mcast_sw_if_index",
12959 ntohl (mp->mcast_sw_if_index));
12963 api_geneve_tunnel_dump (vat_main_t * vam)
12965 unformat_input_t *i = vam->input;
12966 vl_api_geneve_tunnel_dump_t *mp;
12967 vl_api_control_ping_t *mp_ping;
12969 u8 sw_if_index_set = 0;
12972 /* Parse args required to build the message */
12973 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12975 if (unformat (i, "sw_if_index %d", &sw_if_index))
12976 sw_if_index_set = 1;
12981 if (sw_if_index_set == 0)
12986 if (!vam->json_output)
12988 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12989 "sw_if_index", "local_address", "remote_address",
12990 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12993 /* Get list of geneve-tunnel interfaces */
12994 M (GENEVE_TUNNEL_DUMP, mp);
12996 mp->sw_if_index = htonl (sw_if_index);
13000 /* Use a control ping for synchronization */
13001 M (CONTROL_PING, mp_ping);
13009 api_gre_tunnel_add_del (vat_main_t * vam)
13011 unformat_input_t *line_input = vam->input;
13012 vl_api_address_t src = { }, dst =
13015 vl_api_gre_tunnel_add_del_t *mp;
13016 vl_api_gre_tunnel_type_t t_type;
13020 u32 outer_fib_id = 0;
13021 u32 session_id = 0;
13025 t_type = GRE_API_TUNNEL_TYPE_L3;
13027 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13029 if (unformat (line_input, "del"))
13031 else if (unformat (line_input, "instance %d", &instance))
13033 else if (unformat (line_input, "src %U", unformat_vl_api_address, &src))
13037 else if (unformat (line_input, "dst %U", unformat_vl_api_address, &dst))
13041 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
13043 else if (unformat (line_input, "teb"))
13044 t_type = GRE_API_TUNNEL_TYPE_TEB;
13045 else if (unformat (line_input, "erspan %d", &session_id))
13046 t_type = GRE_API_TUNNEL_TYPE_ERSPAN;
13049 errmsg ("parse error '%U'", format_unformat_error, line_input);
13056 errmsg ("tunnel src address not specified");
13061 errmsg ("tunnel dst address not specified");
13065 M (GRE_TUNNEL_ADD_DEL, mp);
13067 clib_memcpy (&mp->tunnel.src, &src, sizeof (mp->tunnel.src));
13068 clib_memcpy (&mp->tunnel.dst, &dst, sizeof (mp->tunnel.dst));
13070 mp->tunnel.instance = htonl (instance);
13071 mp->tunnel.outer_fib_id = htonl (outer_fib_id);
13072 mp->is_add = is_add;
13073 mp->tunnel.session_id = htons ((u16) session_id);
13074 mp->tunnel.type = htonl (t_type);
13081 static void vl_api_gre_tunnel_details_t_handler
13082 (vl_api_gre_tunnel_details_t * mp)
13084 vat_main_t *vam = &vat_main;
13086 print (vam->ofp, "%11d%11d%24U%24U%13d%14d%12d",
13087 ntohl (mp->tunnel.sw_if_index),
13088 ntohl (mp->tunnel.instance),
13089 format_vl_api_address, &mp->tunnel.src,
13090 format_vl_api_address, &mp->tunnel.dst,
13091 mp->tunnel.type, ntohl (mp->tunnel.outer_fib_id),
13092 ntohl (mp->tunnel.session_id));
13095 static void vl_api_gre_tunnel_details_t_handler_json
13096 (vl_api_gre_tunnel_details_t * mp)
13098 vat_main_t *vam = &vat_main;
13099 vat_json_node_t *node = NULL;
13101 if (VAT_JSON_ARRAY != vam->json_tree.type)
13103 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13104 vat_json_init_array (&vam->json_tree);
13106 node = vat_json_array_add (&vam->json_tree);
13108 vat_json_init_object (node);
13109 vat_json_object_add_uint (node, "sw_if_index",
13110 ntohl (mp->tunnel.sw_if_index));
13111 vat_json_object_add_uint (node, "instance", ntohl (mp->tunnel.instance));
13113 vat_json_object_add_address (node, "src", &mp->tunnel.src);
13114 vat_json_object_add_address (node, "dst", &mp->tunnel.dst);
13115 vat_json_object_add_uint (node, "tunnel_type", mp->tunnel.type);
13116 vat_json_object_add_uint (node, "outer_fib_id",
13117 ntohl (mp->tunnel.outer_fib_id));
13118 vat_json_object_add_uint (node, "session_id", mp->tunnel.session_id);
13122 api_gre_tunnel_dump (vat_main_t * vam)
13124 unformat_input_t *i = vam->input;
13125 vl_api_gre_tunnel_dump_t *mp;
13126 vl_api_control_ping_t *mp_ping;
13128 u8 sw_if_index_set = 0;
13131 /* Parse args required to build the message */
13132 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13134 if (unformat (i, "sw_if_index %d", &sw_if_index))
13135 sw_if_index_set = 1;
13140 if (sw_if_index_set == 0)
13145 if (!vam->json_output)
13147 print (vam->ofp, "%11s%11s%24s%24s%13s%14s%12s",
13148 "sw_if_index", "instance", "src_address", "dst_address",
13149 "tunnel_type", "outer_fib_id", "session_id");
13152 /* Get list of gre-tunnel interfaces */
13153 M (GRE_TUNNEL_DUMP, mp);
13155 mp->sw_if_index = htonl (sw_if_index);
13159 /* Use a control ping for synchronization */
13160 MPING (CONTROL_PING, mp_ping);
13168 api_l2_fib_clear_table (vat_main_t * vam)
13170 // unformat_input_t * i = vam->input;
13171 vl_api_l2_fib_clear_table_t *mp;
13174 M (L2_FIB_CLEAR_TABLE, mp);
13182 api_l2_interface_efp_filter (vat_main_t * vam)
13184 unformat_input_t *i = vam->input;
13185 vl_api_l2_interface_efp_filter_t *mp;
13188 u8 sw_if_index_set = 0;
13191 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13193 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13194 sw_if_index_set = 1;
13195 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13196 sw_if_index_set = 1;
13197 else if (unformat (i, "enable"))
13199 else if (unformat (i, "disable"))
13203 clib_warning ("parse error '%U'", format_unformat_error, i);
13208 if (sw_if_index_set == 0)
13210 errmsg ("missing sw_if_index");
13214 M (L2_INTERFACE_EFP_FILTER, mp);
13216 mp->sw_if_index = ntohl (sw_if_index);
13217 mp->enable_disable = enable;
13224 #define foreach_vtr_op \
13225 _("disable", L2_VTR_DISABLED) \
13226 _("push-1", L2_VTR_PUSH_1) \
13227 _("push-2", L2_VTR_PUSH_2) \
13228 _("pop-1", L2_VTR_POP_1) \
13229 _("pop-2", L2_VTR_POP_2) \
13230 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
13231 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
13232 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
13233 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
13236 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
13238 unformat_input_t *i = vam->input;
13239 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
13241 u8 sw_if_index_set = 0;
13244 u32 push_dot1q = 1;
13249 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13251 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13252 sw_if_index_set = 1;
13253 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13254 sw_if_index_set = 1;
13255 else if (unformat (i, "vtr_op %d", &vtr_op))
13257 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
13260 else if (unformat (i, "push_dot1q %d", &push_dot1q))
13262 else if (unformat (i, "tag1 %d", &tag1))
13264 else if (unformat (i, "tag2 %d", &tag2))
13268 clib_warning ("parse error '%U'", format_unformat_error, i);
13273 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
13275 errmsg ("missing vtr operation or sw_if_index");
13279 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
13280 mp->sw_if_index = ntohl (sw_if_index);
13281 mp->vtr_op = ntohl (vtr_op);
13282 mp->push_dot1q = ntohl (push_dot1q);
13283 mp->tag1 = ntohl (tag1);
13284 mp->tag2 = ntohl (tag2);
13292 api_create_vhost_user_if (vat_main_t * vam)
13294 unformat_input_t *i = vam->input;
13295 vl_api_create_vhost_user_if_t *mp;
13298 u8 file_name_set = 0;
13299 u32 custom_dev_instance = ~0;
13301 u8 use_custom_mac = 0;
13302 u8 disable_mrg_rxbuf = 0;
13303 u8 disable_indirect_desc = 0;
13308 /* Shut up coverity */
13309 clib_memset (hwaddr, 0, sizeof (hwaddr));
13311 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13313 if (unformat (i, "socket %s", &file_name))
13317 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13319 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
13320 use_custom_mac = 1;
13321 else if (unformat (i, "server"))
13323 else if (unformat (i, "disable_mrg_rxbuf"))
13324 disable_mrg_rxbuf = 1;
13325 else if (unformat (i, "disable_indirect_desc"))
13326 disable_indirect_desc = 1;
13327 else if (unformat (i, "gso"))
13329 else if (unformat (i, "tag %s", &tag))
13335 if (file_name_set == 0)
13337 errmsg ("missing socket file name");
13341 if (vec_len (file_name) > 255)
13343 errmsg ("socket file name too long");
13346 vec_add1 (file_name, 0);
13348 M (CREATE_VHOST_USER_IF, mp);
13350 mp->is_server = is_server;
13351 mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
13352 mp->disable_indirect_desc = disable_indirect_desc;
13353 mp->enable_gso = enable_gso;
13354 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13355 vec_free (file_name);
13356 if (custom_dev_instance != ~0)
13359 mp->custom_dev_instance = ntohl (custom_dev_instance);
13362 mp->use_custom_mac = use_custom_mac;
13363 clib_memcpy (mp->mac_address, hwaddr, 6);
13365 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
13374 api_modify_vhost_user_if (vat_main_t * vam)
13376 unformat_input_t *i = vam->input;
13377 vl_api_modify_vhost_user_if_t *mp;
13380 u8 file_name_set = 0;
13381 u32 custom_dev_instance = ~0;
13382 u8 sw_if_index_set = 0;
13383 u32 sw_if_index = (u32) ~ 0;
13387 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13389 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13390 sw_if_index_set = 1;
13391 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13392 sw_if_index_set = 1;
13393 else if (unformat (i, "socket %s", &file_name))
13397 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13399 else if (unformat (i, "server"))
13401 else if (unformat (i, "gso"))
13407 if (sw_if_index_set == 0)
13409 errmsg ("missing sw_if_index or interface name");
13413 if (file_name_set == 0)
13415 errmsg ("missing socket file name");
13419 if (vec_len (file_name) > 255)
13421 errmsg ("socket file name too long");
13424 vec_add1 (file_name, 0);
13426 M (MODIFY_VHOST_USER_IF, mp);
13428 mp->sw_if_index = ntohl (sw_if_index);
13429 mp->is_server = is_server;
13430 mp->enable_gso = enable_gso;
13431 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13432 vec_free (file_name);
13433 if (custom_dev_instance != ~0)
13436 mp->custom_dev_instance = ntohl (custom_dev_instance);
13445 api_delete_vhost_user_if (vat_main_t * vam)
13447 unformat_input_t *i = vam->input;
13448 vl_api_delete_vhost_user_if_t *mp;
13449 u32 sw_if_index = ~0;
13450 u8 sw_if_index_set = 0;
13453 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13455 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13456 sw_if_index_set = 1;
13457 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13458 sw_if_index_set = 1;
13463 if (sw_if_index_set == 0)
13465 errmsg ("missing sw_if_index or interface name");
13470 M (DELETE_VHOST_USER_IF, mp);
13472 mp->sw_if_index = ntohl (sw_if_index);
13479 static void vl_api_sw_interface_vhost_user_details_t_handler
13480 (vl_api_sw_interface_vhost_user_details_t * mp)
13482 vat_main_t *vam = &vat_main;
13484 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
13485 (char *) mp->interface_name,
13486 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
13487 clib_net_to_host_u64 (mp->features), mp->is_server,
13488 ntohl (mp->num_regions), (char *) mp->sock_filename);
13489 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
13492 static void vl_api_sw_interface_vhost_user_details_t_handler_json
13493 (vl_api_sw_interface_vhost_user_details_t * mp)
13495 vat_main_t *vam = &vat_main;
13496 vat_json_node_t *node = NULL;
13498 if (VAT_JSON_ARRAY != vam->json_tree.type)
13500 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13501 vat_json_init_array (&vam->json_tree);
13503 node = vat_json_array_add (&vam->json_tree);
13505 vat_json_init_object (node);
13506 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13507 vat_json_object_add_string_copy (node, "interface_name",
13508 mp->interface_name);
13509 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
13510 ntohl (mp->virtio_net_hdr_sz));
13511 vat_json_object_add_uint (node, "features",
13512 clib_net_to_host_u64 (mp->features));
13513 vat_json_object_add_uint (node, "is_server", mp->is_server);
13514 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
13515 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
13516 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
13520 api_sw_interface_vhost_user_dump (vat_main_t * vam)
13522 vl_api_sw_interface_vhost_user_dump_t *mp;
13523 vl_api_control_ping_t *mp_ping;
13526 "Interface name idx hdr_sz features server regions filename");
13528 /* Get list of vhost-user interfaces */
13529 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
13532 /* Use a control ping for synchronization */
13533 MPING (CONTROL_PING, mp_ping);
13541 api_show_version (vat_main_t * vam)
13543 vl_api_show_version_t *mp;
13546 M (SHOW_VERSION, mp);
13555 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
13557 unformat_input_t *line_input = vam->input;
13558 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
13559 ip4_address_t local4, remote4;
13560 ip6_address_t local6, remote6;
13562 u8 ipv4_set = 0, ipv6_set = 0;
13566 u32 mcast_sw_if_index = ~0;
13567 u32 encap_vrf_id = 0;
13568 u32 decap_vrf_id = 0;
13574 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
13575 clib_memset (&local4, 0, sizeof local4);
13576 clib_memset (&remote4, 0, sizeof remote4);
13577 clib_memset (&local6, 0, sizeof local6);
13578 clib_memset (&remote6, 0, sizeof remote6);
13580 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13582 if (unformat (line_input, "del"))
13584 else if (unformat (line_input, "local %U",
13585 unformat_ip4_address, &local4))
13590 else if (unformat (line_input, "remote %U",
13591 unformat_ip4_address, &remote4))
13596 else if (unformat (line_input, "local %U",
13597 unformat_ip6_address, &local6))
13602 else if (unformat (line_input, "remote %U",
13603 unformat_ip6_address, &remote6))
13608 else if (unformat (line_input, "group %U %U",
13609 unformat_ip4_address, &remote4,
13610 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13612 grp_set = remote_set = 1;
13615 else if (unformat (line_input, "group %U",
13616 unformat_ip4_address, &remote4))
13618 grp_set = remote_set = 1;
13621 else if (unformat (line_input, "group %U %U",
13622 unformat_ip6_address, &remote6,
13623 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13625 grp_set = remote_set = 1;
13628 else if (unformat (line_input, "group %U",
13629 unformat_ip6_address, &remote6))
13631 grp_set = remote_set = 1;
13635 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13637 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13639 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
13641 else if (unformat (line_input, "vni %d", &vni))
13643 else if (unformat (line_input, "next-ip4"))
13645 else if (unformat (line_input, "next-ip6"))
13647 else if (unformat (line_input, "next-ethernet"))
13649 else if (unformat (line_input, "next-nsh"))
13653 errmsg ("parse error '%U'", format_unformat_error, line_input);
13658 if (local_set == 0)
13660 errmsg ("tunnel local address not specified");
13663 if (remote_set == 0)
13665 errmsg ("tunnel remote address not specified");
13668 if (grp_set && mcast_sw_if_index == ~0)
13670 errmsg ("tunnel nonexistent multicast device");
13673 if (ipv4_set && ipv6_set)
13675 errmsg ("both IPv4 and IPv6 addresses specified");
13681 errmsg ("vni not specified");
13685 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
13690 clib_memcpy (&mp->local, &local6, sizeof (local6));
13691 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
13695 clib_memcpy (&mp->local, &local4, sizeof (local4));
13696 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
13699 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
13700 mp->encap_vrf_id = ntohl (encap_vrf_id);
13701 mp->decap_vrf_id = ntohl (decap_vrf_id);
13702 mp->protocol = protocol;
13703 mp->vni = ntohl (vni);
13704 mp->is_add = is_add;
13705 mp->is_ipv6 = ipv6_set;
13712 static void vl_api_vxlan_gpe_tunnel_details_t_handler
13713 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13715 vat_main_t *vam = &vat_main;
13716 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
13717 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
13719 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
13720 ntohl (mp->sw_if_index),
13721 format_ip46_address, &local, IP46_TYPE_ANY,
13722 format_ip46_address, &remote, IP46_TYPE_ANY,
13723 ntohl (mp->vni), mp->protocol,
13724 ntohl (mp->mcast_sw_if_index),
13725 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
13729 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
13730 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13732 vat_main_t *vam = &vat_main;
13733 vat_json_node_t *node = NULL;
13734 struct in_addr ip4;
13735 struct in6_addr ip6;
13737 if (VAT_JSON_ARRAY != vam->json_tree.type)
13739 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13740 vat_json_init_array (&vam->json_tree);
13742 node = vat_json_array_add (&vam->json_tree);
13744 vat_json_init_object (node);
13745 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13748 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
13749 vat_json_object_add_ip6 (node, "local", ip6);
13750 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
13751 vat_json_object_add_ip6 (node, "remote", ip6);
13755 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
13756 vat_json_object_add_ip4 (node, "local", ip4);
13757 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
13758 vat_json_object_add_ip4 (node, "remote", ip4);
13760 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
13761 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
13762 vat_json_object_add_uint (node, "mcast_sw_if_index",
13763 ntohl (mp->mcast_sw_if_index));
13764 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
13765 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
13766 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
13770 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
13772 unformat_input_t *i = vam->input;
13773 vl_api_vxlan_gpe_tunnel_dump_t *mp;
13774 vl_api_control_ping_t *mp_ping;
13776 u8 sw_if_index_set = 0;
13779 /* Parse args required to build the message */
13780 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13782 if (unformat (i, "sw_if_index %d", &sw_if_index))
13783 sw_if_index_set = 1;
13788 if (sw_if_index_set == 0)
13793 if (!vam->json_output)
13795 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
13796 "sw_if_index", "local", "remote", "vni",
13797 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
13800 /* Get list of vxlan-tunnel interfaces */
13801 M (VXLAN_GPE_TUNNEL_DUMP, mp);
13803 mp->sw_if_index = htonl (sw_if_index);
13807 /* Use a control ping for synchronization */
13808 MPING (CONTROL_PING, mp_ping);
13815 static void vl_api_l2_fib_table_details_t_handler
13816 (vl_api_l2_fib_table_details_t * mp)
13818 vat_main_t *vam = &vat_main;
13820 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
13822 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
13823 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
13827 static void vl_api_l2_fib_table_details_t_handler_json
13828 (vl_api_l2_fib_table_details_t * mp)
13830 vat_main_t *vam = &vat_main;
13831 vat_json_node_t *node = NULL;
13833 if (VAT_JSON_ARRAY != vam->json_tree.type)
13835 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13836 vat_json_init_array (&vam->json_tree);
13838 node = vat_json_array_add (&vam->json_tree);
13840 vat_json_init_object (node);
13841 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
13842 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
13843 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13844 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
13845 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
13846 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
13850 api_l2_fib_table_dump (vat_main_t * vam)
13852 unformat_input_t *i = vam->input;
13853 vl_api_l2_fib_table_dump_t *mp;
13854 vl_api_control_ping_t *mp_ping;
13859 /* Parse args required to build the message */
13860 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13862 if (unformat (i, "bd_id %d", &bd_id))
13868 if (bd_id_set == 0)
13870 errmsg ("missing bridge domain");
13874 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
13876 /* Get list of l2 fib entries */
13877 M (L2_FIB_TABLE_DUMP, mp);
13879 mp->bd_id = ntohl (bd_id);
13882 /* Use a control ping for synchronization */
13883 MPING (CONTROL_PING, mp_ping);
13892 api_interface_name_renumber (vat_main_t * vam)
13894 unformat_input_t *line_input = vam->input;
13895 vl_api_interface_name_renumber_t *mp;
13896 u32 sw_if_index = ~0;
13897 u32 new_show_dev_instance = ~0;
13900 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13902 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
13905 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13907 else if (unformat (line_input, "new_show_dev_instance %d",
13908 &new_show_dev_instance))
13914 if (sw_if_index == ~0)
13916 errmsg ("missing interface name or sw_if_index");
13920 if (new_show_dev_instance == ~0)
13922 errmsg ("missing new_show_dev_instance");
13926 M (INTERFACE_NAME_RENUMBER, mp);
13928 mp->sw_if_index = ntohl (sw_if_index);
13929 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
13937 api_ip_probe_neighbor (vat_main_t * vam)
13939 unformat_input_t *i = vam->input;
13940 vl_api_ip_probe_neighbor_t *mp;
13941 vl_api_address_t dst_adr = { };
13947 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13949 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13951 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13953 else if (unformat (i, "address %U", unformat_vl_api_address, &dst_adr))
13961 errmsg ("missing interface");
13967 errmsg ("missing addresses");
13971 M (IP_PROBE_NEIGHBOR, mp);
13973 mp->sw_if_index = ntohl (sw_if_index);
13974 clib_memcpy (&mp->dst, &dst_adr, sizeof (dst_adr));
13982 api_ip_scan_neighbor_enable_disable (vat_main_t * vam)
13984 unformat_input_t *i = vam->input;
13985 vl_api_ip_scan_neighbor_enable_disable_t *mp;
13986 u8 mode = IP_SCAN_V46_NEIGHBORS;
13987 u32 interval = 0, time = 0, update = 0, delay = 0, stale = 0;
13990 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13992 if (unformat (i, "ip4"))
13993 mode = IP_SCAN_V4_NEIGHBORS;
13994 else if (unformat (i, "ip6"))
13995 mode = IP_SCAN_V6_NEIGHBORS;
13996 if (unformat (i, "both"))
13997 mode = IP_SCAN_V46_NEIGHBORS;
13998 else if (unformat (i, "disable"))
13999 mode = IP_SCAN_DISABLED;
14000 else if (unformat (i, "interval %d", &interval))
14002 else if (unformat (i, "max-time %d", &time))
14004 else if (unformat (i, "max-update %d", &update))
14006 else if (unformat (i, "delay %d", &delay))
14008 else if (unformat (i, "stale %d", &stale))
14014 if (interval > 255)
14016 errmsg ("interval cannot exceed 255 minutes.");
14021 errmsg ("max-time cannot exceed 255 usec.");
14026 errmsg ("max-update cannot exceed 255.");
14031 errmsg ("delay cannot exceed 255 msec.");
14036 errmsg ("stale cannot exceed 255 minutes.");
14040 M (IP_SCAN_NEIGHBOR_ENABLE_DISABLE, mp);
14042 mp->scan_interval = interval;
14043 mp->max_proc_time = time;
14044 mp->max_update = update;
14045 mp->scan_int_delay = delay;
14046 mp->stale_threshold = stale;
14054 api_want_ip4_arp_events (vat_main_t * vam)
14056 unformat_input_t *line_input = vam->input;
14057 vl_api_want_ip4_arp_events_t *mp;
14058 ip4_address_t address;
14059 int address_set = 0;
14060 u32 enable_disable = 1;
14063 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14065 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
14067 else if (unformat (line_input, "del"))
14068 enable_disable = 0;
14073 if (address_set == 0)
14075 errmsg ("missing addresses");
14079 M (WANT_IP4_ARP_EVENTS, mp);
14080 mp->enable_disable = enable_disable;
14081 mp->pid = htonl (getpid ());
14082 clib_memcpy (mp->ip, &address, sizeof (address));
14090 api_want_ip6_nd_events (vat_main_t * vam)
14092 unformat_input_t *line_input = vam->input;
14093 vl_api_want_ip6_nd_events_t *mp;
14094 vl_api_ip6_address_t address;
14095 int address_set = 0;
14096 u32 enable_disable = 1;
14099 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14102 (line_input, "address %U", unformat_vl_api_ip6_address, &address))
14104 else if (unformat (line_input, "del"))
14105 enable_disable = 0;
14110 if (address_set == 0)
14112 errmsg ("missing addresses");
14116 M (WANT_IP6_ND_EVENTS, mp);
14117 mp->enable_disable = enable_disable;
14118 mp->pid = htonl (getpid ());
14119 clib_memcpy (&mp->ip, &address, sizeof (address));
14127 api_want_l2_macs_events (vat_main_t * vam)
14129 unformat_input_t *line_input = vam->input;
14130 vl_api_want_l2_macs_events_t *mp;
14131 u8 enable_disable = 1;
14132 u32 scan_delay = 0;
14133 u32 max_macs_in_event = 0;
14134 u32 learn_limit = 0;
14137 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14139 if (unformat (line_input, "learn-limit %d", &learn_limit))
14141 else if (unformat (line_input, "scan-delay %d", &scan_delay))
14143 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
14145 else if (unformat (line_input, "disable"))
14146 enable_disable = 0;
14151 M (WANT_L2_MACS_EVENTS, mp);
14152 mp->enable_disable = enable_disable;
14153 mp->pid = htonl (getpid ());
14154 mp->learn_limit = htonl (learn_limit);
14155 mp->scan_delay = (u8) scan_delay;
14156 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
14163 api_input_acl_set_interface (vat_main_t * vam)
14165 unformat_input_t *i = vam->input;
14166 vl_api_input_acl_set_interface_t *mp;
14168 int sw_if_index_set;
14169 u32 ip4_table_index = ~0;
14170 u32 ip6_table_index = ~0;
14171 u32 l2_table_index = ~0;
14175 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14177 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14178 sw_if_index_set = 1;
14179 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14180 sw_if_index_set = 1;
14181 else if (unformat (i, "del"))
14183 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14185 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14187 else if (unformat (i, "l2-table %d", &l2_table_index))
14191 clib_warning ("parse error '%U'", format_unformat_error, i);
14196 if (sw_if_index_set == 0)
14198 errmsg ("missing interface name or sw_if_index");
14202 M (INPUT_ACL_SET_INTERFACE, mp);
14204 mp->sw_if_index = ntohl (sw_if_index);
14205 mp->ip4_table_index = ntohl (ip4_table_index);
14206 mp->ip6_table_index = ntohl (ip6_table_index);
14207 mp->l2_table_index = ntohl (l2_table_index);
14208 mp->is_add = is_add;
14216 api_output_acl_set_interface (vat_main_t * vam)
14218 unformat_input_t *i = vam->input;
14219 vl_api_output_acl_set_interface_t *mp;
14221 int sw_if_index_set;
14222 u32 ip4_table_index = ~0;
14223 u32 ip6_table_index = ~0;
14224 u32 l2_table_index = ~0;
14228 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14230 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14231 sw_if_index_set = 1;
14232 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14233 sw_if_index_set = 1;
14234 else if (unformat (i, "del"))
14236 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14238 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14240 else if (unformat (i, "l2-table %d", &l2_table_index))
14244 clib_warning ("parse error '%U'", format_unformat_error, i);
14249 if (sw_if_index_set == 0)
14251 errmsg ("missing interface name or sw_if_index");
14255 M (OUTPUT_ACL_SET_INTERFACE, mp);
14257 mp->sw_if_index = ntohl (sw_if_index);
14258 mp->ip4_table_index = ntohl (ip4_table_index);
14259 mp->ip6_table_index = ntohl (ip6_table_index);
14260 mp->l2_table_index = ntohl (l2_table_index);
14261 mp->is_add = is_add;
14269 api_ip_address_dump (vat_main_t * vam)
14271 unformat_input_t *i = vam->input;
14272 vl_api_ip_address_dump_t *mp;
14273 vl_api_control_ping_t *mp_ping;
14274 u32 sw_if_index = ~0;
14275 u8 sw_if_index_set = 0;
14280 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14282 if (unformat (i, "sw_if_index %d", &sw_if_index))
14283 sw_if_index_set = 1;
14285 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14286 sw_if_index_set = 1;
14287 else if (unformat (i, "ipv4"))
14289 else if (unformat (i, "ipv6"))
14295 if (ipv4_set && ipv6_set)
14297 errmsg ("ipv4 and ipv6 flags cannot be both set");
14301 if ((!ipv4_set) && (!ipv6_set))
14303 errmsg ("no ipv4 nor ipv6 flag set");
14307 if (sw_if_index_set == 0)
14309 errmsg ("missing interface name or sw_if_index");
14313 vam->current_sw_if_index = sw_if_index;
14314 vam->is_ipv6 = ipv6_set;
14316 M (IP_ADDRESS_DUMP, mp);
14317 mp->sw_if_index = ntohl (sw_if_index);
14318 mp->is_ipv6 = ipv6_set;
14321 /* Use a control ping for synchronization */
14322 MPING (CONTROL_PING, mp_ping);
14330 api_ip_dump (vat_main_t * vam)
14332 vl_api_ip_dump_t *mp;
14333 vl_api_control_ping_t *mp_ping;
14334 unformat_input_t *in = vam->input;
14341 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
14343 if (unformat (in, "ipv4"))
14345 else if (unformat (in, "ipv6"))
14351 if (ipv4_set && ipv6_set)
14353 errmsg ("ipv4 and ipv6 flags cannot be both set");
14357 if ((!ipv4_set) && (!ipv6_set))
14359 errmsg ("no ipv4 nor ipv6 flag set");
14363 is_ipv6 = ipv6_set;
14364 vam->is_ipv6 = is_ipv6;
14366 /* free old data */
14367 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
14369 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
14371 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
14374 mp->is_ipv6 = ipv6_set;
14377 /* Use a control ping for synchronization */
14378 MPING (CONTROL_PING, mp_ping);
14386 api_ipsec_spd_add_del (vat_main_t * vam)
14388 unformat_input_t *i = vam->input;
14389 vl_api_ipsec_spd_add_del_t *mp;
14394 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14396 if (unformat (i, "spd_id %d", &spd_id))
14398 else if (unformat (i, "del"))
14402 clib_warning ("parse error '%U'", format_unformat_error, i);
14408 errmsg ("spd_id must be set");
14412 M (IPSEC_SPD_ADD_DEL, mp);
14414 mp->spd_id = ntohl (spd_id);
14415 mp->is_add = is_add;
14423 api_ipsec_interface_add_del_spd (vat_main_t * vam)
14425 unformat_input_t *i = vam->input;
14426 vl_api_ipsec_interface_add_del_spd_t *mp;
14428 u8 sw_if_index_set = 0;
14429 u32 spd_id = (u32) ~ 0;
14433 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14435 if (unformat (i, "del"))
14437 else if (unformat (i, "spd_id %d", &spd_id))
14440 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14441 sw_if_index_set = 1;
14442 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14443 sw_if_index_set = 1;
14446 clib_warning ("parse error '%U'", format_unformat_error, i);
14452 if (spd_id == (u32) ~ 0)
14454 errmsg ("spd_id must be set");
14458 if (sw_if_index_set == 0)
14460 errmsg ("missing interface name or sw_if_index");
14464 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
14466 mp->spd_id = ntohl (spd_id);
14467 mp->sw_if_index = ntohl (sw_if_index);
14468 mp->is_add = is_add;
14476 api_ipsec_spd_entry_add_del (vat_main_t * vam)
14478 unformat_input_t *i = vam->input;
14479 vl_api_ipsec_spd_entry_add_del_t *mp;
14480 u8 is_add = 1, is_outbound = 0;
14481 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
14483 u32 rport_start = 0, rport_stop = (u32) ~ 0;
14484 u32 lport_start = 0, lport_stop = (u32) ~ 0;
14485 vl_api_address_t laddr_start = { }, laddr_stop =
14494 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14496 if (unformat (i, "del"))
14498 if (unformat (i, "outbound"))
14500 if (unformat (i, "inbound"))
14502 else if (unformat (i, "spd_id %d", &spd_id))
14504 else if (unformat (i, "sa_id %d", &sa_id))
14506 else if (unformat (i, "priority %d", &priority))
14508 else if (unformat (i, "protocol %d", &protocol))
14510 else if (unformat (i, "lport_start %d", &lport_start))
14512 else if (unformat (i, "lport_stop %d", &lport_stop))
14514 else if (unformat (i, "rport_start %d", &rport_start))
14516 else if (unformat (i, "rport_stop %d", &rport_stop))
14518 else if (unformat (i, "laddr_start %U",
14519 unformat_vl_api_address, &laddr_start))
14521 else if (unformat (i, "laddr_stop %U", unformat_vl_api_address,
14524 else if (unformat (i, "raddr_start %U", unformat_vl_api_address,
14527 else if (unformat (i, "raddr_stop %U", unformat_vl_api_address,
14531 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
14533 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
14535 clib_warning ("unsupported action: 'resolve'");
14541 clib_warning ("parse error '%U'", format_unformat_error, i);
14547 M (IPSEC_SPD_ENTRY_ADD_DEL, mp);
14549 mp->is_add = is_add;
14551 mp->entry.spd_id = ntohl (spd_id);
14552 mp->entry.priority = ntohl (priority);
14553 mp->entry.is_outbound = is_outbound;
14555 clib_memcpy (&mp->entry.remote_address_start, &raddr_start,
14556 sizeof (vl_api_address_t));
14557 clib_memcpy (&mp->entry.remote_address_stop, &raddr_stop,
14558 sizeof (vl_api_address_t));
14559 clib_memcpy (&mp->entry.local_address_start, &laddr_start,
14560 sizeof (vl_api_address_t));
14561 clib_memcpy (&mp->entry.local_address_stop, &laddr_stop,
14562 sizeof (vl_api_address_t));
14564 mp->entry.protocol = (u8) protocol;
14565 mp->entry.local_port_start = ntohs ((u16) lport_start);
14566 mp->entry.local_port_stop = ntohs ((u16) lport_stop);
14567 mp->entry.remote_port_start = ntohs ((u16) rport_start);
14568 mp->entry.remote_port_stop = ntohs ((u16) rport_stop);
14569 mp->entry.policy = (u8) policy;
14570 mp->entry.sa_id = ntohl (sa_id);
14578 api_ipsec_sad_entry_add_del (vat_main_t * vam)
14580 unformat_input_t *i = vam->input;
14581 vl_api_ipsec_sad_entry_add_del_t *mp;
14582 u32 sad_id = 0, spi = 0;
14583 u8 *ck = 0, *ik = 0;
14586 vl_api_ipsec_crypto_alg_t crypto_alg = IPSEC_API_CRYPTO_ALG_NONE;
14587 vl_api_ipsec_integ_alg_t integ_alg = IPSEC_API_INTEG_ALG_NONE;
14588 vl_api_ipsec_sad_flags_t flags = IPSEC_API_SAD_FLAG_NONE;
14589 vl_api_ipsec_proto_t protocol = IPSEC_API_PROTO_AH;
14590 vl_api_address_t tun_src, tun_dst;
14593 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14595 if (unformat (i, "del"))
14597 else if (unformat (i, "sad_id %d", &sad_id))
14599 else if (unformat (i, "spi %d", &spi))
14601 else if (unformat (i, "esp"))
14602 protocol = IPSEC_API_PROTO_ESP;
14604 if (unformat (i, "tunnel_src %U", unformat_vl_api_address, &tun_src))
14606 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
14607 if (ADDRESS_IP6 == tun_src.af)
14608 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
14611 if (unformat (i, "tunnel_dst %U", unformat_vl_api_address, &tun_dst))
14613 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
14614 if (ADDRESS_IP6 == tun_src.af)
14615 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
14618 if (unformat (i, "crypto_alg %U",
14619 unformat_ipsec_api_crypto_alg, &crypto_alg))
14621 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14623 else if (unformat (i, "integ_alg %U",
14624 unformat_ipsec_api_integ_alg, &integ_alg))
14626 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14630 clib_warning ("parse error '%U'", format_unformat_error, i);
14636 M (IPSEC_SAD_ENTRY_ADD_DEL, mp);
14638 mp->is_add = is_add;
14639 mp->entry.sad_id = ntohl (sad_id);
14640 mp->entry.protocol = protocol;
14641 mp->entry.spi = ntohl (spi);
14642 mp->entry.flags = flags;
14644 mp->entry.crypto_algorithm = crypto_alg;
14645 mp->entry.integrity_algorithm = integ_alg;
14646 mp->entry.crypto_key.length = vec_len (ck);
14647 mp->entry.integrity_key.length = vec_len (ik);
14649 if (mp->entry.crypto_key.length > sizeof (mp->entry.crypto_key.data))
14650 mp->entry.crypto_key.length = sizeof (mp->entry.crypto_key.data);
14652 if (mp->entry.integrity_key.length > sizeof (mp->entry.integrity_key.data))
14653 mp->entry.integrity_key.length = sizeof (mp->entry.integrity_key.data);
14656 clib_memcpy (mp->entry.crypto_key.data, ck, mp->entry.crypto_key.length);
14658 clib_memcpy (mp->entry.integrity_key.data, ik,
14659 mp->entry.integrity_key.length);
14661 if (flags & IPSEC_API_SAD_FLAG_IS_TUNNEL)
14663 clib_memcpy (&mp->entry.tunnel_src, &tun_src,
14664 sizeof (mp->entry.tunnel_src));
14665 clib_memcpy (&mp->entry.tunnel_dst, &tun_dst,
14666 sizeof (mp->entry.tunnel_dst));
14675 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
14677 unformat_input_t *i = vam->input;
14678 vl_api_ipsec_tunnel_if_add_del_t *mp;
14679 u32 local_spi = 0, remote_spi = 0;
14680 u32 crypto_alg = 0, integ_alg = 0;
14681 u8 *lck = NULL, *rck = NULL;
14682 u8 *lik = NULL, *rik = NULL;
14683 vl_api_address_t local_ip = { 0 };
14684 vl_api_address_t remote_ip = { 0 };
14688 u8 anti_replay = 0;
14694 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14696 if (unformat (i, "del"))
14698 else if (unformat (i, "esn"))
14700 else if (unformat (i, "anti-replay"))
14702 else if (unformat (i, "count %d", &count))
14704 else if (unformat (i, "local_spi %d", &local_spi))
14706 else if (unformat (i, "remote_spi %d", &remote_spi))
14709 if (unformat (i, "local_ip %U", unformat_vl_api_address, &local_ip))
14712 if (unformat (i, "remote_ip %U", unformat_vl_api_address, &remote_ip))
14714 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
14717 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
14719 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
14721 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
14725 (i, "crypto_alg %U", unformat_ipsec_api_crypto_alg, &crypto_alg))
14727 if (crypto_alg >= IPSEC_CRYPTO_N_ALG)
14729 errmsg ("unsupported crypto-alg: '%U'\n",
14730 format_ipsec_crypto_alg, crypto_alg);
14736 (i, "integ_alg %U", unformat_ipsec_api_integ_alg, &integ_alg))
14738 if (integ_alg >= IPSEC_INTEG_N_ALG)
14740 errmsg ("unsupported integ-alg: '%U'\n",
14741 format_ipsec_integ_alg, integ_alg);
14745 else if (unformat (i, "instance %u", &instance))
14749 errmsg ("parse error '%U'\n", format_unformat_error, i);
14756 /* Turn on async mode */
14757 vam->async_mode = 1;
14758 vam->async_errors = 0;
14759 before = vat_time_now (vam);
14762 for (jj = 0; jj < count; jj++)
14764 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
14766 mp->is_add = is_add;
14768 mp->anti_replay = anti_replay;
14771 increment_address (&remote_ip);
14773 clib_memcpy (&mp->local_ip, &local_ip, sizeof (local_ip));
14774 clib_memcpy (&mp->remote_ip, &remote_ip, sizeof (remote_ip));
14776 mp->local_spi = htonl (local_spi + jj);
14777 mp->remote_spi = htonl (remote_spi + jj);
14778 mp->crypto_alg = (u8) crypto_alg;
14780 mp->local_crypto_key_len = 0;
14783 mp->local_crypto_key_len = vec_len (lck);
14784 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
14785 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
14786 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
14789 mp->remote_crypto_key_len = 0;
14792 mp->remote_crypto_key_len = vec_len (rck);
14793 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
14794 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
14795 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
14798 mp->integ_alg = (u8) integ_alg;
14800 mp->local_integ_key_len = 0;
14803 mp->local_integ_key_len = vec_len (lik);
14804 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
14805 mp->local_integ_key_len = sizeof (mp->local_integ_key);
14806 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
14809 mp->remote_integ_key_len = 0;
14812 mp->remote_integ_key_len = vec_len (rik);
14813 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
14814 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
14815 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
14820 mp->renumber = renumber;
14821 mp->show_instance = ntohl (instance);
14826 /* When testing multiple add/del ops, use a control-ping to sync */
14829 vl_api_control_ping_t *mp_ping;
14833 /* Shut off async mode */
14834 vam->async_mode = 0;
14836 MPING (CONTROL_PING, mp_ping);
14839 timeout = vat_time_now (vam) + 1.0;
14840 while (vat_time_now (vam) < timeout)
14841 if (vam->result_ready == 1)
14846 if (vam->retval == -99)
14847 errmsg ("timeout");
14849 if (vam->async_errors > 0)
14851 errmsg ("%d asynchronous errors", vam->async_errors);
14854 vam->async_errors = 0;
14855 after = vat_time_now (vam);
14857 /* slim chance, but we might have eaten SIGTERM on the first iteration */
14861 print (vam->ofp, "%d tunnels in %.6f secs, %.2f tunnels/sec",
14862 count, after - before, count / (after - before));
14866 /* Wait for a reply... */
14875 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
14877 vat_main_t *vam = &vat_main;
14879 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
14880 "crypto_key %U integ_alg %u integ_key %U flags %x "
14881 "tunnel_src_addr %U tunnel_dst_addr %U "
14882 "salt %u seq_outbound %lu last_seq_inbound %lu "
14883 "replay_window %lu\n",
14884 ntohl (mp->entry.sad_id),
14885 ntohl (mp->sw_if_index),
14886 ntohl (mp->entry.spi),
14887 ntohl (mp->entry.protocol),
14888 ntohl (mp->entry.crypto_algorithm),
14889 format_hex_bytes, mp->entry.crypto_key.data,
14890 mp->entry.crypto_key.length, ntohl (mp->entry.integrity_algorithm),
14891 format_hex_bytes, mp->entry.integrity_key.data,
14892 mp->entry.integrity_key.length, ntohl (mp->entry.flags),
14893 format_vl_api_address, &mp->entry.tunnel_src, format_vl_api_address,
14894 &mp->entry.tunnel_dst, ntohl (mp->salt),
14895 clib_net_to_host_u64 (mp->seq_outbound),
14896 clib_net_to_host_u64 (mp->last_seq_inbound),
14897 clib_net_to_host_u64 (mp->replay_window));
14900 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
14901 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
14903 static void vl_api_ipsec_sa_details_t_handler_json
14904 (vl_api_ipsec_sa_details_t * mp)
14906 vat_main_t *vam = &vat_main;
14907 vat_json_node_t *node = NULL;
14908 vl_api_ipsec_sad_flags_t flags;
14910 if (VAT_JSON_ARRAY != vam->json_tree.type)
14912 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14913 vat_json_init_array (&vam->json_tree);
14915 node = vat_json_array_add (&vam->json_tree);
14917 vat_json_init_object (node);
14918 vat_json_object_add_uint (node, "sa_id", ntohl (mp->entry.sad_id));
14919 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14920 vat_json_object_add_uint (node, "spi", ntohl (mp->entry.spi));
14921 vat_json_object_add_uint (node, "proto", ntohl (mp->entry.protocol));
14922 vat_json_object_add_uint (node, "crypto_alg",
14923 ntohl (mp->entry.crypto_algorithm));
14924 vat_json_object_add_uint (node, "integ_alg",
14925 ntohl (mp->entry.integrity_algorithm));
14926 flags = ntohl (mp->entry.flags);
14927 vat_json_object_add_uint (node, "use_esn",
14928 ! !(flags & IPSEC_API_SAD_FLAG_USE_ESN));
14929 vat_json_object_add_uint (node, "use_anti_replay",
14930 ! !(flags & IPSEC_API_SAD_FLAG_USE_ANTI_REPLAY));
14931 vat_json_object_add_uint (node, "is_tunnel",
14932 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL));
14933 vat_json_object_add_uint (node, "is_tunnel_ip6",
14934 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL_V6));
14935 vat_json_object_add_uint (node, "udp_encap",
14936 ! !(flags & IPSEC_API_SAD_FLAG_UDP_ENCAP));
14937 vat_json_object_add_bytes (node, "crypto_key", mp->entry.crypto_key.data,
14938 mp->entry.crypto_key.length);
14939 vat_json_object_add_bytes (node, "integ_key", mp->entry.integrity_key.data,
14940 mp->entry.integrity_key.length);
14941 vat_json_object_add_address (node, "src", &mp->entry.tunnel_src);
14942 vat_json_object_add_address (node, "dst", &mp->entry.tunnel_dst);
14943 vat_json_object_add_uint (node, "replay_window",
14944 clib_net_to_host_u64 (mp->replay_window));
14948 api_ipsec_sa_dump (vat_main_t * vam)
14950 unformat_input_t *i = vam->input;
14951 vl_api_ipsec_sa_dump_t *mp;
14952 vl_api_control_ping_t *mp_ping;
14956 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14958 if (unformat (i, "sa_id %d", &sa_id))
14962 clib_warning ("parse error '%U'", format_unformat_error, i);
14967 M (IPSEC_SA_DUMP, mp);
14969 mp->sa_id = ntohl (sa_id);
14973 /* Use a control ping for synchronization */
14974 M (CONTROL_PING, mp_ping);
14982 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
14984 unformat_input_t *i = vam->input;
14985 vl_api_ipsec_tunnel_if_set_sa_t *mp;
14986 u32 sw_if_index = ~0;
14988 u8 is_outbound = (u8) ~ 0;
14991 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14993 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14995 else if (unformat (i, "sa_id %d", &sa_id))
14997 else if (unformat (i, "outbound"))
14999 else if (unformat (i, "inbound"))
15003 clib_warning ("parse error '%U'", format_unformat_error, i);
15008 if (sw_if_index == ~0)
15010 errmsg ("interface must be specified");
15016 errmsg ("SA ID must be specified");
15020 M (IPSEC_TUNNEL_IF_SET_SA, mp);
15022 mp->sw_if_index = htonl (sw_if_index);
15023 mp->sa_id = htonl (sa_id);
15024 mp->is_outbound = is_outbound;
15033 api_get_first_msg_id (vat_main_t * vam)
15035 vl_api_get_first_msg_id_t *mp;
15036 unformat_input_t *i = vam->input;
15041 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15043 if (unformat (i, "client %s", &name))
15051 errmsg ("missing client name");
15054 vec_add1 (name, 0);
15056 if (vec_len (name) > 63)
15058 errmsg ("client name too long");
15062 M (GET_FIRST_MSG_ID, mp);
15063 clib_memcpy (mp->name, name, vec_len (name));
15070 api_cop_interface_enable_disable (vat_main_t * vam)
15072 unformat_input_t *line_input = vam->input;
15073 vl_api_cop_interface_enable_disable_t *mp;
15074 u32 sw_if_index = ~0;
15075 u8 enable_disable = 1;
15078 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15080 if (unformat (line_input, "disable"))
15081 enable_disable = 0;
15082 if (unformat (line_input, "enable"))
15083 enable_disable = 1;
15084 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
15085 vam, &sw_if_index))
15087 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
15093 if (sw_if_index == ~0)
15095 errmsg ("missing interface name or sw_if_index");
15099 /* Construct the API message */
15100 M (COP_INTERFACE_ENABLE_DISABLE, mp);
15101 mp->sw_if_index = ntohl (sw_if_index);
15102 mp->enable_disable = enable_disable;
15106 /* Wait for the reply */
15112 api_cop_whitelist_enable_disable (vat_main_t * vam)
15114 unformat_input_t *line_input = vam->input;
15115 vl_api_cop_whitelist_enable_disable_t *mp;
15116 u32 sw_if_index = ~0;
15117 u8 ip4 = 0, ip6 = 0, default_cop = 0;
15121 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15123 if (unformat (line_input, "ip4"))
15125 else if (unformat (line_input, "ip6"))
15127 else if (unformat (line_input, "default"))
15129 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
15130 vam, &sw_if_index))
15132 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
15134 else if (unformat (line_input, "fib-id %d", &fib_id))
15140 if (sw_if_index == ~0)
15142 errmsg ("missing interface name or sw_if_index");
15146 /* Construct the API message */
15147 M (COP_WHITELIST_ENABLE_DISABLE, mp);
15148 mp->sw_if_index = ntohl (sw_if_index);
15149 mp->fib_id = ntohl (fib_id);
15152 mp->default_cop = default_cop;
15156 /* Wait for the reply */
15162 api_get_node_graph (vat_main_t * vam)
15164 vl_api_get_node_graph_t *mp;
15167 M (GET_NODE_GRAPH, mp);
15171 /* Wait for the reply */
15177 /** Used for parsing LISP eids */
15178 typedef CLIB_PACKED(struct{
15179 u8 addr[16]; /**< eid address */
15180 u32 len; /**< prefix length if IP */
15181 u8 type; /**< type of eid */
15186 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
15188 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
15190 clib_memset (a, 0, sizeof (a[0]));
15192 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
15194 a->type = 0; /* ipv4 type */
15196 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
15198 a->type = 1; /* ipv6 type */
15200 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
15202 a->type = 2; /* mac type */
15204 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
15206 a->type = 3; /* NSH type */
15207 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
15208 nsh->spi = clib_host_to_net_u32 (nsh->spi);
15215 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
15224 lisp_eid_size_vat (u8 type)
15241 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
15243 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
15247 api_one_add_del_locator_set (vat_main_t * vam)
15249 unformat_input_t *input = vam->input;
15250 vl_api_one_add_del_locator_set_t *mp;
15252 u8 *locator_set_name = NULL;
15253 u8 locator_set_name_set = 0;
15254 vl_api_local_locator_t locator, *locators = 0;
15255 u32 sw_if_index, priority, weight;
15259 /* Parse args required to build the message */
15260 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15262 if (unformat (input, "del"))
15266 else if (unformat (input, "locator-set %s", &locator_set_name))
15268 locator_set_name_set = 1;
15270 else if (unformat (input, "sw_if_index %u p %u w %u",
15271 &sw_if_index, &priority, &weight))
15273 locator.sw_if_index = htonl (sw_if_index);
15274 locator.priority = priority;
15275 locator.weight = weight;
15276 vec_add1 (locators, locator);
15280 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
15281 &sw_if_index, &priority, &weight))
15283 locator.sw_if_index = htonl (sw_if_index);
15284 locator.priority = priority;
15285 locator.weight = weight;
15286 vec_add1 (locators, locator);
15292 if (locator_set_name_set == 0)
15294 errmsg ("missing locator-set name");
15295 vec_free (locators);
15299 if (vec_len (locator_set_name) > 64)
15301 errmsg ("locator-set name too long");
15302 vec_free (locator_set_name);
15303 vec_free (locators);
15306 vec_add1 (locator_set_name, 0);
15308 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
15310 /* Construct the API message */
15311 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
15313 mp->is_add = is_add;
15314 clib_memcpy (mp->locator_set_name, locator_set_name,
15315 vec_len (locator_set_name));
15316 vec_free (locator_set_name);
15318 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
15320 clib_memcpy (mp->locators, locators, data_len);
15321 vec_free (locators);
15326 /* Wait for a reply... */
15331 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
15334 api_one_add_del_locator (vat_main_t * vam)
15336 unformat_input_t *input = vam->input;
15337 vl_api_one_add_del_locator_t *mp;
15338 u32 tmp_if_index = ~0;
15339 u32 sw_if_index = ~0;
15340 u8 sw_if_index_set = 0;
15341 u8 sw_if_index_if_name_set = 0;
15343 u8 priority_set = 0;
15347 u8 *locator_set_name = NULL;
15348 u8 locator_set_name_set = 0;
15351 /* Parse args required to build the message */
15352 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15354 if (unformat (input, "del"))
15358 else if (unformat (input, "locator-set %s", &locator_set_name))
15360 locator_set_name_set = 1;
15362 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
15365 sw_if_index_if_name_set = 1;
15366 sw_if_index = tmp_if_index;
15368 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
15370 sw_if_index_set = 1;
15371 sw_if_index = tmp_if_index;
15373 else if (unformat (input, "p %d", &priority))
15377 else if (unformat (input, "w %d", &weight))
15385 if (locator_set_name_set == 0)
15387 errmsg ("missing locator-set name");
15391 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
15393 errmsg ("missing sw_if_index");
15394 vec_free (locator_set_name);
15398 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
15400 errmsg ("cannot use both params interface name and sw_if_index");
15401 vec_free (locator_set_name);
15405 if (priority_set == 0)
15407 errmsg ("missing locator-set priority");
15408 vec_free (locator_set_name);
15412 if (weight_set == 0)
15414 errmsg ("missing locator-set weight");
15415 vec_free (locator_set_name);
15419 if (vec_len (locator_set_name) > 64)
15421 errmsg ("locator-set name too long");
15422 vec_free (locator_set_name);
15425 vec_add1 (locator_set_name, 0);
15427 /* Construct the API message */
15428 M (ONE_ADD_DEL_LOCATOR, mp);
15430 mp->is_add = is_add;
15431 mp->sw_if_index = ntohl (sw_if_index);
15432 mp->priority = priority;
15433 mp->weight = weight;
15434 clib_memcpy (mp->locator_set_name, locator_set_name,
15435 vec_len (locator_set_name));
15436 vec_free (locator_set_name);
15441 /* Wait for a reply... */
15446 #define api_lisp_add_del_locator api_one_add_del_locator
15449 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
15451 u32 *key_id = va_arg (*args, u32 *);
15454 if (unformat (input, "%s", &s))
15456 if (!strcmp ((char *) s, "sha1"))
15457 key_id[0] = HMAC_SHA_1_96;
15458 else if (!strcmp ((char *) s, "sha256"))
15459 key_id[0] = HMAC_SHA_256_128;
15462 clib_warning ("invalid key_id: '%s'", s);
15463 key_id[0] = HMAC_NO_KEY;
15474 api_one_add_del_local_eid (vat_main_t * vam)
15476 unformat_input_t *input = vam->input;
15477 vl_api_one_add_del_local_eid_t *mp;
15480 lisp_eid_vat_t _eid, *eid = &_eid;
15481 u8 *locator_set_name = 0;
15482 u8 locator_set_name_set = 0;
15488 /* Parse args required to build the message */
15489 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15491 if (unformat (input, "del"))
15495 else if (unformat (input, "vni %d", &vni))
15499 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
15503 else if (unformat (input, "locator-set %s", &locator_set_name))
15505 locator_set_name_set = 1;
15507 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
15509 else if (unformat (input, "secret-key %_%v%_", &key))
15515 if (locator_set_name_set == 0)
15517 errmsg ("missing locator-set name");
15523 errmsg ("EID address not set!");
15524 vec_free (locator_set_name);
15528 if (key && (0 == key_id))
15530 errmsg ("invalid key_id!");
15534 if (vec_len (key) > 64)
15536 errmsg ("key too long");
15541 if (vec_len (locator_set_name) > 64)
15543 errmsg ("locator-set name too long");
15544 vec_free (locator_set_name);
15547 vec_add1 (locator_set_name, 0);
15549 /* Construct the API message */
15550 M (ONE_ADD_DEL_LOCAL_EID, mp);
15552 mp->is_add = is_add;
15553 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
15554 mp->eid_type = eid->type;
15555 mp->prefix_len = eid->len;
15556 mp->vni = clib_host_to_net_u32 (vni);
15557 mp->key_id = clib_host_to_net_u16 (key_id);
15558 clib_memcpy (mp->locator_set_name, locator_set_name,
15559 vec_len (locator_set_name));
15560 clib_memcpy (mp->key, key, vec_len (key));
15562 vec_free (locator_set_name);
15568 /* Wait for a reply... */
15573 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
15576 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
15578 u32 dp_table = 0, vni = 0;;
15579 unformat_input_t *input = vam->input;
15580 vl_api_gpe_add_del_fwd_entry_t *mp;
15582 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
15583 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
15584 u8 rmt_eid_set = 0, lcl_eid_set = 0;
15585 u32 action = ~0, w;
15586 ip4_address_t rmt_rloc4, lcl_rloc4;
15587 ip6_address_t rmt_rloc6, lcl_rloc6;
15588 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
15591 clib_memset (&rloc, 0, sizeof (rloc));
15593 /* Parse args required to build the message */
15594 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15596 if (unformat (input, "del"))
15598 else if (unformat (input, "add"))
15600 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
15604 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
15608 else if (unformat (input, "vrf %d", &dp_table))
15610 else if (unformat (input, "bd %d", &dp_table))
15612 else if (unformat (input, "vni %d", &vni))
15614 else if (unformat (input, "w %d", &w))
15618 errmsg ("No RLOC configured for setting priority/weight!");
15621 curr_rloc->weight = w;
15623 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
15624 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
15628 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
15630 vec_add1 (lcl_locs, rloc);
15632 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
15633 vec_add1 (rmt_locs, rloc);
15634 /* weight saved in rmt loc */
15635 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
15637 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
15638 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
15641 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
15643 vec_add1 (lcl_locs, rloc);
15645 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
15646 vec_add1 (rmt_locs, rloc);
15647 /* weight saved in rmt loc */
15648 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
15650 else if (unformat (input, "action %d", &action))
15656 clib_warning ("parse error '%U'", format_unformat_error, input);
15663 errmsg ("remote eid addresses not set");
15667 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
15669 errmsg ("eid types don't match");
15673 if (0 == rmt_locs && (u32) ~ 0 == action)
15675 errmsg ("action not set for negative mapping");
15679 /* Construct the API message */
15680 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
15681 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
15683 mp->is_add = is_add;
15684 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
15685 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
15686 mp->eid_type = rmt_eid->type;
15687 mp->dp_table = clib_host_to_net_u32 (dp_table);
15688 mp->vni = clib_host_to_net_u32 (vni);
15689 mp->rmt_len = rmt_eid->len;
15690 mp->lcl_len = lcl_eid->len;
15691 mp->action = action;
15693 if (0 != rmt_locs && 0 != lcl_locs)
15695 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
15696 clib_memcpy (mp->locs, lcl_locs,
15697 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
15699 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
15700 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
15701 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
15703 vec_free (lcl_locs);
15704 vec_free (rmt_locs);
15709 /* Wait for a reply... */
15715 api_one_add_del_map_server (vat_main_t * vam)
15717 unformat_input_t *input = vam->input;
15718 vl_api_one_add_del_map_server_t *mp;
15722 ip4_address_t ipv4;
15723 ip6_address_t ipv6;
15726 /* Parse args required to build the message */
15727 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15729 if (unformat (input, "del"))
15733 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
15737 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
15745 if (ipv4_set && ipv6_set)
15747 errmsg ("both eid v4 and v6 addresses set");
15751 if (!ipv4_set && !ipv6_set)
15753 errmsg ("eid addresses not set");
15757 /* Construct the API message */
15758 M (ONE_ADD_DEL_MAP_SERVER, mp);
15760 mp->is_add = is_add;
15764 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
15769 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
15775 /* Wait for a reply... */
15780 #define api_lisp_add_del_map_server api_one_add_del_map_server
15783 api_one_add_del_map_resolver (vat_main_t * vam)
15785 unformat_input_t *input = vam->input;
15786 vl_api_one_add_del_map_resolver_t *mp;
15790 ip4_address_t ipv4;
15791 ip6_address_t ipv6;
15794 /* Parse args required to build the message */
15795 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15797 if (unformat (input, "del"))
15801 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
15805 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
15813 if (ipv4_set && ipv6_set)
15815 errmsg ("both eid v4 and v6 addresses set");
15819 if (!ipv4_set && !ipv6_set)
15821 errmsg ("eid addresses not set");
15825 /* Construct the API message */
15826 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
15828 mp->is_add = is_add;
15832 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
15837 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
15843 /* Wait for a reply... */
15848 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
15851 api_lisp_gpe_enable_disable (vat_main_t * vam)
15853 unformat_input_t *input = vam->input;
15854 vl_api_gpe_enable_disable_t *mp;
15859 /* Parse args required to build the message */
15860 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15862 if (unformat (input, "enable"))
15867 else if (unformat (input, "disable"))
15878 errmsg ("Value not set");
15882 /* Construct the API message */
15883 M (GPE_ENABLE_DISABLE, mp);
15890 /* Wait for a reply... */
15896 api_one_rloc_probe_enable_disable (vat_main_t * vam)
15898 unformat_input_t *input = vam->input;
15899 vl_api_one_rloc_probe_enable_disable_t *mp;
15904 /* Parse args required to build the message */
15905 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15907 if (unformat (input, "enable"))
15912 else if (unformat (input, "disable"))
15920 errmsg ("Value not set");
15924 /* Construct the API message */
15925 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
15927 mp->is_enabled = is_en;
15932 /* Wait for a reply... */
15937 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
15940 api_one_map_register_enable_disable (vat_main_t * vam)
15942 unformat_input_t *input = vam->input;
15943 vl_api_one_map_register_enable_disable_t *mp;
15948 /* Parse args required to build the message */
15949 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15951 if (unformat (input, "enable"))
15956 else if (unformat (input, "disable"))
15964 errmsg ("Value not set");
15968 /* Construct the API message */
15969 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
15971 mp->is_enabled = is_en;
15976 /* Wait for a reply... */
15981 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
15984 api_one_enable_disable (vat_main_t * vam)
15986 unformat_input_t *input = vam->input;
15987 vl_api_one_enable_disable_t *mp;
15992 /* Parse args required to build the message */
15993 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15995 if (unformat (input, "enable"))
16000 else if (unformat (input, "disable"))
16010 errmsg ("Value not set");
16014 /* Construct the API message */
16015 M (ONE_ENABLE_DISABLE, mp);
16022 /* Wait for a reply... */
16027 #define api_lisp_enable_disable api_one_enable_disable
16030 api_one_enable_disable_xtr_mode (vat_main_t * vam)
16032 unformat_input_t *input = vam->input;
16033 vl_api_one_enable_disable_xtr_mode_t *mp;
16038 /* Parse args required to build the message */
16039 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16041 if (unformat (input, "enable"))
16046 else if (unformat (input, "disable"))
16056 errmsg ("Value not set");
16060 /* Construct the API message */
16061 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
16068 /* Wait for a reply... */
16074 api_one_show_xtr_mode (vat_main_t * vam)
16076 vl_api_one_show_xtr_mode_t *mp;
16079 /* Construct the API message */
16080 M (ONE_SHOW_XTR_MODE, mp);
16085 /* Wait for a reply... */
16091 api_one_enable_disable_pitr_mode (vat_main_t * vam)
16093 unformat_input_t *input = vam->input;
16094 vl_api_one_enable_disable_pitr_mode_t *mp;
16099 /* Parse args required to build the message */
16100 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16102 if (unformat (input, "enable"))
16107 else if (unformat (input, "disable"))
16117 errmsg ("Value not set");
16121 /* Construct the API message */
16122 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
16129 /* Wait for a reply... */
16135 api_one_show_pitr_mode (vat_main_t * vam)
16137 vl_api_one_show_pitr_mode_t *mp;
16140 /* Construct the API message */
16141 M (ONE_SHOW_PITR_MODE, mp);
16146 /* Wait for a reply... */
16152 api_one_enable_disable_petr_mode (vat_main_t * vam)
16154 unformat_input_t *input = vam->input;
16155 vl_api_one_enable_disable_petr_mode_t *mp;
16160 /* Parse args required to build the message */
16161 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16163 if (unformat (input, "enable"))
16168 else if (unformat (input, "disable"))
16178 errmsg ("Value not set");
16182 /* Construct the API message */
16183 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
16190 /* Wait for a reply... */
16196 api_one_show_petr_mode (vat_main_t * vam)
16198 vl_api_one_show_petr_mode_t *mp;
16201 /* Construct the API message */
16202 M (ONE_SHOW_PETR_MODE, mp);
16207 /* Wait for a reply... */
16213 api_show_one_map_register_state (vat_main_t * vam)
16215 vl_api_show_one_map_register_state_t *mp;
16218 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
16223 /* wait for reply */
16228 #define api_show_lisp_map_register_state api_show_one_map_register_state
16231 api_show_one_rloc_probe_state (vat_main_t * vam)
16233 vl_api_show_one_rloc_probe_state_t *mp;
16236 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
16241 /* wait for reply */
16246 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
16249 api_one_add_del_ndp_entry (vat_main_t * vam)
16251 vl_api_one_add_del_ndp_entry_t *mp;
16252 unformat_input_t *input = vam->input;
16257 u8 mac[6] = { 0, };
16258 u8 ip6[16] = { 0, };
16262 /* Parse args required to build the message */
16263 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16265 if (unformat (input, "del"))
16267 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
16269 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
16271 else if (unformat (input, "bd %d", &bd))
16275 errmsg ("parse error '%U'", format_unformat_error, input);
16280 if (!bd_set || !ip_set || (!mac_set && is_add))
16282 errmsg ("Missing BD, IP or MAC!");
16286 M (ONE_ADD_DEL_NDP_ENTRY, mp);
16287 mp->is_add = is_add;
16288 clib_memcpy (mp->mac, mac, 6);
16289 mp->bd = clib_host_to_net_u32 (bd);
16290 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
16295 /* wait for reply */
16301 api_one_add_del_l2_arp_entry (vat_main_t * vam)
16303 vl_api_one_add_del_l2_arp_entry_t *mp;
16304 unformat_input_t *input = vam->input;
16309 u8 mac[6] = { 0, };
16310 u32 ip4 = 0, bd = ~0;
16313 /* Parse args required to build the message */
16314 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16316 if (unformat (input, "del"))
16318 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
16320 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
16322 else if (unformat (input, "bd %d", &bd))
16326 errmsg ("parse error '%U'", format_unformat_error, input);
16331 if (!bd_set || !ip_set || (!mac_set && is_add))
16333 errmsg ("Missing BD, IP or MAC!");
16337 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
16338 mp->is_add = is_add;
16339 clib_memcpy (mp->mac, mac, 6);
16340 mp->bd = clib_host_to_net_u32 (bd);
16346 /* wait for reply */
16352 api_one_ndp_bd_get (vat_main_t * vam)
16354 vl_api_one_ndp_bd_get_t *mp;
16357 M (ONE_NDP_BD_GET, mp);
16362 /* wait for reply */
16368 api_one_ndp_entries_get (vat_main_t * vam)
16370 vl_api_one_ndp_entries_get_t *mp;
16371 unformat_input_t *input = vam->input;
16376 /* Parse args required to build the message */
16377 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16379 if (unformat (input, "bd %d", &bd))
16383 errmsg ("parse error '%U'", format_unformat_error, input);
16390 errmsg ("Expected bridge domain!");
16394 M (ONE_NDP_ENTRIES_GET, mp);
16395 mp->bd = clib_host_to_net_u32 (bd);
16400 /* wait for reply */
16406 api_one_l2_arp_bd_get (vat_main_t * vam)
16408 vl_api_one_l2_arp_bd_get_t *mp;
16411 M (ONE_L2_ARP_BD_GET, mp);
16416 /* wait for reply */
16422 api_one_l2_arp_entries_get (vat_main_t * vam)
16424 vl_api_one_l2_arp_entries_get_t *mp;
16425 unformat_input_t *input = vam->input;
16430 /* Parse args required to build the message */
16431 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16433 if (unformat (input, "bd %d", &bd))
16437 errmsg ("parse error '%U'", format_unformat_error, input);
16444 errmsg ("Expected bridge domain!");
16448 M (ONE_L2_ARP_ENTRIES_GET, mp);
16449 mp->bd = clib_host_to_net_u32 (bd);
16454 /* wait for reply */
16460 api_one_stats_enable_disable (vat_main_t * vam)
16462 vl_api_one_stats_enable_disable_t *mp;
16463 unformat_input_t *input = vam->input;
16468 /* Parse args required to build the message */
16469 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16471 if (unformat (input, "enable"))
16476 else if (unformat (input, "disable"))
16486 errmsg ("Value not set");
16490 M (ONE_STATS_ENABLE_DISABLE, mp);
16496 /* wait for reply */
16502 api_show_one_stats_enable_disable (vat_main_t * vam)
16504 vl_api_show_one_stats_enable_disable_t *mp;
16507 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
16512 /* wait for reply */
16518 api_show_one_map_request_mode (vat_main_t * vam)
16520 vl_api_show_one_map_request_mode_t *mp;
16523 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
16528 /* wait for reply */
16533 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
16536 api_one_map_request_mode (vat_main_t * vam)
16538 unformat_input_t *input = vam->input;
16539 vl_api_one_map_request_mode_t *mp;
16543 /* Parse args required to build the message */
16544 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16546 if (unformat (input, "dst-only"))
16548 else if (unformat (input, "src-dst"))
16552 errmsg ("parse error '%U'", format_unformat_error, input);
16557 M (ONE_MAP_REQUEST_MODE, mp);
16564 /* wait for reply */
16569 #define api_lisp_map_request_mode api_one_map_request_mode
16572 * Enable/disable ONE proxy ITR.
16574 * @param vam vpp API test context
16575 * @return return code
16578 api_one_pitr_set_locator_set (vat_main_t * vam)
16580 u8 ls_name_set = 0;
16581 unformat_input_t *input = vam->input;
16582 vl_api_one_pitr_set_locator_set_t *mp;
16587 /* Parse args required to build the message */
16588 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16590 if (unformat (input, "del"))
16592 else if (unformat (input, "locator-set %s", &ls_name))
16596 errmsg ("parse error '%U'", format_unformat_error, input);
16603 errmsg ("locator-set name not set!");
16607 M (ONE_PITR_SET_LOCATOR_SET, mp);
16609 mp->is_add = is_add;
16610 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
16611 vec_free (ls_name);
16616 /* wait for reply */
16621 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
16624 api_one_nsh_set_locator_set (vat_main_t * vam)
16626 u8 ls_name_set = 0;
16627 unformat_input_t *input = vam->input;
16628 vl_api_one_nsh_set_locator_set_t *mp;
16633 /* Parse args required to build the message */
16634 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16636 if (unformat (input, "del"))
16638 else if (unformat (input, "ls %s", &ls_name))
16642 errmsg ("parse error '%U'", format_unformat_error, input);
16647 if (!ls_name_set && is_add)
16649 errmsg ("locator-set name not set!");
16653 M (ONE_NSH_SET_LOCATOR_SET, mp);
16655 mp->is_add = is_add;
16656 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
16657 vec_free (ls_name);
16662 /* wait for reply */
16668 api_show_one_pitr (vat_main_t * vam)
16670 vl_api_show_one_pitr_t *mp;
16673 if (!vam->json_output)
16675 print (vam->ofp, "%=20s", "lisp status:");
16678 M (SHOW_ONE_PITR, mp);
16682 /* Wait for a reply... */
16687 #define api_show_lisp_pitr api_show_one_pitr
16690 api_one_use_petr (vat_main_t * vam)
16692 unformat_input_t *input = vam->input;
16693 vl_api_one_use_petr_t *mp;
16698 clib_memset (&ip, 0, sizeof (ip));
16700 /* Parse args required to build the message */
16701 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16703 if (unformat (input, "disable"))
16706 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
16709 ip_addr_version (&ip) = IP4;
16712 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
16715 ip_addr_version (&ip) = IP6;
16719 errmsg ("parse error '%U'", format_unformat_error, input);
16724 M (ONE_USE_PETR, mp);
16726 mp->is_add = is_add;
16729 mp->is_ip4 = ip_addr_version (&ip) == IP4 ? 1 : 0;
16731 clib_memcpy (mp->address, &ip, 4);
16733 clib_memcpy (mp->address, &ip, 16);
16739 /* wait for reply */
16744 #define api_lisp_use_petr api_one_use_petr
16747 api_show_one_nsh_mapping (vat_main_t * vam)
16749 vl_api_show_one_use_petr_t *mp;
16752 if (!vam->json_output)
16754 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
16757 M (SHOW_ONE_NSH_MAPPING, mp);
16761 /* Wait for a reply... */
16767 api_show_one_use_petr (vat_main_t * vam)
16769 vl_api_show_one_use_petr_t *mp;
16772 if (!vam->json_output)
16774 print (vam->ofp, "%=20s", "Proxy-ETR status:");
16777 M (SHOW_ONE_USE_PETR, mp);
16781 /* Wait for a reply... */
16786 #define api_show_lisp_use_petr api_show_one_use_petr
16789 * Add/delete mapping between vni and vrf
16792 api_one_eid_table_add_del_map (vat_main_t * vam)
16794 unformat_input_t *input = vam->input;
16795 vl_api_one_eid_table_add_del_map_t *mp;
16796 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
16797 u32 vni, vrf, bd_index;
16800 /* Parse args required to build the message */
16801 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16803 if (unformat (input, "del"))
16805 else if (unformat (input, "vrf %d", &vrf))
16807 else if (unformat (input, "bd_index %d", &bd_index))
16809 else if (unformat (input, "vni %d", &vni))
16815 if (!vni_set || (!vrf_set && !bd_index_set))
16817 errmsg ("missing arguments!");
16821 if (vrf_set && bd_index_set)
16823 errmsg ("error: both vrf and bd entered!");
16827 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
16829 mp->is_add = is_add;
16830 mp->vni = htonl (vni);
16831 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
16832 mp->is_l2 = bd_index_set;
16837 /* wait for reply */
16842 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
16845 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
16847 u32 *action = va_arg (*args, u32 *);
16850 if (unformat (input, "%s", &s))
16852 if (!strcmp ((char *) s, "no-action"))
16854 else if (!strcmp ((char *) s, "natively-forward"))
16856 else if (!strcmp ((char *) s, "send-map-request"))
16858 else if (!strcmp ((char *) s, "drop"))
16862 clib_warning ("invalid action: '%s'", s);
16874 * Add/del remote mapping to/from ONE control plane
16876 * @param vam vpp API test context
16877 * @return return code
16880 api_one_add_del_remote_mapping (vat_main_t * vam)
16882 unformat_input_t *input = vam->input;
16883 vl_api_one_add_del_remote_mapping_t *mp;
16885 lisp_eid_vat_t _eid, *eid = &_eid;
16886 lisp_eid_vat_t _seid, *seid = &_seid;
16887 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
16888 u32 action = ~0, p, w, data_len;
16889 ip4_address_t rloc4;
16890 ip6_address_t rloc6;
16891 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
16894 clib_memset (&rloc, 0, sizeof (rloc));
16896 /* Parse args required to build the message */
16897 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16899 if (unformat (input, "del-all"))
16903 else if (unformat (input, "del"))
16907 else if (unformat (input, "add"))
16911 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
16915 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
16919 else if (unformat (input, "vni %d", &vni))
16923 else if (unformat (input, "p %d w %d", &p, &w))
16927 errmsg ("No RLOC configured for setting priority/weight!");
16930 curr_rloc->priority = p;
16931 curr_rloc->weight = w;
16933 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
16936 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
16937 vec_add1 (rlocs, rloc);
16938 curr_rloc = &rlocs[vec_len (rlocs) - 1];
16940 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
16943 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
16944 vec_add1 (rlocs, rloc);
16945 curr_rloc = &rlocs[vec_len (rlocs) - 1];
16947 else if (unformat (input, "action %U",
16948 unformat_negative_mapping_action, &action))
16954 clib_warning ("parse error '%U'", format_unformat_error, input);
16961 errmsg ("missing params!");
16965 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
16967 errmsg ("no action set for negative map-reply!");
16971 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
16973 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
16974 mp->is_add = is_add;
16975 mp->vni = htonl (vni);
16976 mp->action = (u8) action;
16977 mp->is_src_dst = seid_set;
16978 mp->eid_len = eid->len;
16979 mp->seid_len = seid->len;
16980 mp->del_all = del_all;
16981 mp->eid_type = eid->type;
16982 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
16983 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
16985 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
16986 clib_memcpy (mp->rlocs, rlocs, data_len);
16992 /* Wait for a reply... */
16997 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
17000 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
17001 * forwarding entries in data-plane accordingly.
17003 * @param vam vpp API test context
17004 * @return return code
17007 api_one_add_del_adjacency (vat_main_t * vam)
17009 unformat_input_t *input = vam->input;
17010 vl_api_one_add_del_adjacency_t *mp;
17012 ip4_address_t leid4, reid4;
17013 ip6_address_t leid6, reid6;
17014 u8 reid_mac[6] = { 0 };
17015 u8 leid_mac[6] = { 0 };
17016 u8 reid_type, leid_type;
17017 u32 leid_len = 0, reid_len = 0, len;
17021 leid_type = reid_type = (u8) ~ 0;
17023 /* Parse args required to build the message */
17024 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17026 if (unformat (input, "del"))
17030 else if (unformat (input, "add"))
17034 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
17037 reid_type = 0; /* ipv4 */
17040 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
17043 reid_type = 1; /* ipv6 */
17046 else if (unformat (input, "reid %U", unformat_ethernet_address,
17049 reid_type = 2; /* mac */
17051 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
17054 leid_type = 0; /* ipv4 */
17057 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
17060 leid_type = 1; /* ipv6 */
17063 else if (unformat (input, "leid %U", unformat_ethernet_address,
17066 leid_type = 2; /* mac */
17068 else if (unformat (input, "vni %d", &vni))
17074 errmsg ("parse error '%U'", format_unformat_error, input);
17079 if ((u8) ~ 0 == reid_type)
17081 errmsg ("missing params!");
17085 if (leid_type != reid_type)
17087 errmsg ("remote and local EIDs are of different types!");
17091 M (ONE_ADD_DEL_ADJACENCY, mp);
17092 mp->is_add = is_add;
17093 mp->vni = htonl (vni);
17094 mp->leid_len = leid_len;
17095 mp->reid_len = reid_len;
17096 mp->eid_type = reid_type;
17098 switch (mp->eid_type)
17101 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
17102 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
17105 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
17106 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
17109 clib_memcpy (mp->leid, leid_mac, 6);
17110 clib_memcpy (mp->reid, reid_mac, 6);
17113 errmsg ("unknown EID type %d!", mp->eid_type);
17120 /* Wait for a reply... */
17125 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
17128 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
17130 u32 *mode = va_arg (*args, u32 *);
17132 if (unformat (input, "lisp"))
17134 else if (unformat (input, "vxlan"))
17143 api_gpe_get_encap_mode (vat_main_t * vam)
17145 vl_api_gpe_get_encap_mode_t *mp;
17148 /* Construct the API message */
17149 M (GPE_GET_ENCAP_MODE, mp);
17154 /* Wait for a reply... */
17160 api_gpe_set_encap_mode (vat_main_t * vam)
17162 unformat_input_t *input = vam->input;
17163 vl_api_gpe_set_encap_mode_t *mp;
17167 /* Parse args required to build the message */
17168 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17170 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
17176 /* Construct the API message */
17177 M (GPE_SET_ENCAP_MODE, mp);
17184 /* Wait for a reply... */
17190 api_lisp_gpe_add_del_iface (vat_main_t * vam)
17192 unformat_input_t *input = vam->input;
17193 vl_api_gpe_add_del_iface_t *mp;
17194 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
17195 u32 dp_table = 0, vni = 0;
17198 /* Parse args required to build the message */
17199 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17201 if (unformat (input, "up"))
17206 else if (unformat (input, "down"))
17211 else if (unformat (input, "table_id %d", &dp_table))
17215 else if (unformat (input, "bd_id %d", &dp_table))
17220 else if (unformat (input, "vni %d", &vni))
17228 if (action_set == 0)
17230 errmsg ("Action not set");
17233 if (dp_table_set == 0 || vni_set == 0)
17235 errmsg ("vni and dp_table must be set");
17239 /* Construct the API message */
17240 M (GPE_ADD_DEL_IFACE, mp);
17242 mp->is_add = is_add;
17243 mp->dp_table = clib_host_to_net_u32 (dp_table);
17245 mp->vni = clib_host_to_net_u32 (vni);
17250 /* Wait for a reply... */
17256 api_one_map_register_fallback_threshold (vat_main_t * vam)
17258 unformat_input_t *input = vam->input;
17259 vl_api_one_map_register_fallback_threshold_t *mp;
17264 /* Parse args required to build the message */
17265 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17267 if (unformat (input, "%u", &value))
17271 clib_warning ("parse error '%U'", format_unformat_error, input);
17278 errmsg ("fallback threshold value is missing!");
17282 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
17283 mp->value = clib_host_to_net_u32 (value);
17288 /* Wait for a reply... */
17294 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
17296 vl_api_show_one_map_register_fallback_threshold_t *mp;
17299 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
17304 /* Wait for a reply... */
17310 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
17312 u32 *proto = va_arg (*args, u32 *);
17314 if (unformat (input, "udp"))
17316 else if (unformat (input, "api"))
17325 api_one_set_transport_protocol (vat_main_t * vam)
17327 unformat_input_t *input = vam->input;
17328 vl_api_one_set_transport_protocol_t *mp;
17333 /* Parse args required to build the message */
17334 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17336 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
17340 clib_warning ("parse error '%U'", format_unformat_error, input);
17347 errmsg ("Transport protocol missing!");
17351 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
17352 mp->protocol = (u8) protocol;
17357 /* Wait for a reply... */
17363 api_one_get_transport_protocol (vat_main_t * vam)
17365 vl_api_one_get_transport_protocol_t *mp;
17368 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
17373 /* Wait for a reply... */
17379 api_one_map_register_set_ttl (vat_main_t * vam)
17381 unformat_input_t *input = vam->input;
17382 vl_api_one_map_register_set_ttl_t *mp;
17387 /* Parse args required to build the message */
17388 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17390 if (unformat (input, "%u", &ttl))
17394 clib_warning ("parse error '%U'", format_unformat_error, input);
17401 errmsg ("TTL value missing!");
17405 M (ONE_MAP_REGISTER_SET_TTL, mp);
17406 mp->ttl = clib_host_to_net_u32 (ttl);
17411 /* Wait for a reply... */
17417 api_show_one_map_register_ttl (vat_main_t * vam)
17419 vl_api_show_one_map_register_ttl_t *mp;
17422 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
17427 /* Wait for a reply... */
17433 * Add/del map request itr rlocs from ONE control plane and updates
17435 * @param vam vpp API test context
17436 * @return return code
17439 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
17441 unformat_input_t *input = vam->input;
17442 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
17443 u8 *locator_set_name = 0;
17444 u8 locator_set_name_set = 0;
17448 /* Parse args required to build the message */
17449 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17451 if (unformat (input, "del"))
17455 else if (unformat (input, "%_%v%_", &locator_set_name))
17457 locator_set_name_set = 1;
17461 clib_warning ("parse error '%U'", format_unformat_error, input);
17466 if (is_add && !locator_set_name_set)
17468 errmsg ("itr-rloc is not set!");
17472 if (is_add && vec_len (locator_set_name) > 64)
17474 errmsg ("itr-rloc locator-set name too long");
17475 vec_free (locator_set_name);
17479 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
17480 mp->is_add = is_add;
17483 clib_memcpy (mp->locator_set_name, locator_set_name,
17484 vec_len (locator_set_name));
17488 clib_memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
17490 vec_free (locator_set_name);
17495 /* Wait for a reply... */
17500 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
17503 api_one_locator_dump (vat_main_t * vam)
17505 unformat_input_t *input = vam->input;
17506 vl_api_one_locator_dump_t *mp;
17507 vl_api_control_ping_t *mp_ping;
17508 u8 is_index_set = 0, is_name_set = 0;
17513 /* Parse args required to build the message */
17514 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17516 if (unformat (input, "ls_name %_%v%_", &ls_name))
17520 else if (unformat (input, "ls_index %d", &ls_index))
17526 errmsg ("parse error '%U'", format_unformat_error, input);
17531 if (!is_index_set && !is_name_set)
17533 errmsg ("error: expected one of index or name!");
17537 if (is_index_set && is_name_set)
17539 errmsg ("error: only one param expected!");
17543 if (vec_len (ls_name) > 62)
17545 errmsg ("error: locator set name too long!");
17549 if (!vam->json_output)
17551 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
17554 M (ONE_LOCATOR_DUMP, mp);
17555 mp->is_index_set = is_index_set;
17558 mp->ls_index = clib_host_to_net_u32 (ls_index);
17561 vec_add1 (ls_name, 0);
17562 strncpy ((char *) mp->ls_name, (char *) ls_name,
17563 sizeof (mp->ls_name) - 1);
17569 /* Use a control ping for synchronization */
17570 MPING (CONTROL_PING, mp_ping);
17573 /* Wait for a reply... */
17578 #define api_lisp_locator_dump api_one_locator_dump
17581 api_one_locator_set_dump (vat_main_t * vam)
17583 vl_api_one_locator_set_dump_t *mp;
17584 vl_api_control_ping_t *mp_ping;
17585 unformat_input_t *input = vam->input;
17589 /* Parse args required to build the message */
17590 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17592 if (unformat (input, "local"))
17596 else if (unformat (input, "remote"))
17602 errmsg ("parse error '%U'", format_unformat_error, input);
17607 if (!vam->json_output)
17609 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
17612 M (ONE_LOCATOR_SET_DUMP, mp);
17614 mp->filter = filter;
17619 /* Use a control ping for synchronization */
17620 MPING (CONTROL_PING, mp_ping);
17623 /* Wait for a reply... */
17628 #define api_lisp_locator_set_dump api_one_locator_set_dump
17631 api_one_eid_table_map_dump (vat_main_t * vam)
17635 unformat_input_t *input = vam->input;
17636 vl_api_one_eid_table_map_dump_t *mp;
17637 vl_api_control_ping_t *mp_ping;
17640 /* Parse args required to build the message */
17641 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17643 if (unformat (input, "l2"))
17648 else if (unformat (input, "l3"))
17655 errmsg ("parse error '%U'", format_unformat_error, input);
17662 errmsg ("expected one of 'l2' or 'l3' parameter!");
17666 if (!vam->json_output)
17668 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
17671 M (ONE_EID_TABLE_MAP_DUMP, mp);
17677 /* Use a control ping for synchronization */
17678 MPING (CONTROL_PING, mp_ping);
17681 /* Wait for a reply... */
17686 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
17689 api_one_eid_table_vni_dump (vat_main_t * vam)
17691 vl_api_one_eid_table_vni_dump_t *mp;
17692 vl_api_control_ping_t *mp_ping;
17695 if (!vam->json_output)
17697 print (vam->ofp, "VNI");
17700 M (ONE_EID_TABLE_VNI_DUMP, mp);
17705 /* Use a control ping for synchronization */
17706 MPING (CONTROL_PING, mp_ping);
17709 /* Wait for a reply... */
17714 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
17717 api_one_eid_table_dump (vat_main_t * vam)
17719 unformat_input_t *i = vam->input;
17720 vl_api_one_eid_table_dump_t *mp;
17721 vl_api_control_ping_t *mp_ping;
17722 struct in_addr ip4;
17723 struct in6_addr ip6;
17725 u8 eid_type = ~0, eid_set = 0;
17726 u32 prefix_length = ~0, t, vni = 0;
17729 lisp_nsh_api_t nsh;
17731 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17733 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
17739 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
17745 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
17750 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
17755 else if (unformat (i, "vni %d", &t))
17759 else if (unformat (i, "local"))
17763 else if (unformat (i, "remote"))
17769 errmsg ("parse error '%U'", format_unformat_error, i);
17774 if (!vam->json_output)
17776 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
17777 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
17780 M (ONE_EID_TABLE_DUMP, mp);
17782 mp->filter = filter;
17786 mp->vni = htonl (vni);
17787 mp->eid_type = eid_type;
17791 mp->prefix_length = prefix_length;
17792 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
17795 mp->prefix_length = prefix_length;
17796 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
17799 clib_memcpy (mp->eid, mac, sizeof (mac));
17802 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
17805 errmsg ("unknown EID type %d!", eid_type);
17813 /* Use a control ping for synchronization */
17814 MPING (CONTROL_PING, mp_ping);
17817 /* Wait for a reply... */
17822 #define api_lisp_eid_table_dump api_one_eid_table_dump
17825 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
17827 unformat_input_t *i = vam->input;
17828 vl_api_gpe_fwd_entries_get_t *mp;
17833 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17835 if (unformat (i, "vni %d", &vni))
17841 errmsg ("parse error '%U'", format_unformat_error, i);
17848 errmsg ("vni not set!");
17852 if (!vam->json_output)
17854 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
17858 M (GPE_FWD_ENTRIES_GET, mp);
17859 mp->vni = clib_host_to_net_u32 (vni);
17864 /* Wait for a reply... */
17869 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
17870 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
17871 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
17872 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
17873 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
17874 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
17875 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
17876 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
17879 api_one_adjacencies_get (vat_main_t * vam)
17881 unformat_input_t *i = vam->input;
17882 vl_api_one_adjacencies_get_t *mp;
17887 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17889 if (unformat (i, "vni %d", &vni))
17895 errmsg ("parse error '%U'", format_unformat_error, i);
17902 errmsg ("vni not set!");
17906 if (!vam->json_output)
17908 print (vam->ofp, "%s %40s", "leid", "reid");
17911 M (ONE_ADJACENCIES_GET, mp);
17912 mp->vni = clib_host_to_net_u32 (vni);
17917 /* Wait for a reply... */
17922 #define api_lisp_adjacencies_get api_one_adjacencies_get
17925 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
17927 unformat_input_t *i = vam->input;
17928 vl_api_gpe_native_fwd_rpaths_get_t *mp;
17930 u8 ip_family_set = 0, is_ip4 = 1;
17932 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17934 if (unformat (i, "ip4"))
17939 else if (unformat (i, "ip6"))
17946 errmsg ("parse error '%U'", format_unformat_error, i);
17951 if (!ip_family_set)
17953 errmsg ("ip family not set!");
17957 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
17958 mp->is_ip4 = is_ip4;
17963 /* Wait for a reply... */
17969 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
17971 vl_api_gpe_fwd_entry_vnis_get_t *mp;
17974 if (!vam->json_output)
17976 print (vam->ofp, "VNIs");
17979 M (GPE_FWD_ENTRY_VNIS_GET, mp);
17984 /* Wait for a reply... */
17990 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
17992 unformat_input_t *i = vam->input;
17993 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
17995 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
17996 struct in_addr ip4;
17997 struct in6_addr ip6;
17998 u32 table_id = 0, nh_sw_if_index = ~0;
18000 clib_memset (&ip4, 0, sizeof (ip4));
18001 clib_memset (&ip6, 0, sizeof (ip6));
18003 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18005 if (unformat (i, "del"))
18007 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
18008 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18013 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
18014 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18019 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
18023 nh_sw_if_index = ~0;
18025 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
18029 nh_sw_if_index = ~0;
18031 else if (unformat (i, "table %d", &table_id))
18035 errmsg ("parse error '%U'", format_unformat_error, i);
18042 errmsg ("nh addr not set!");
18046 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
18047 mp->is_add = is_add;
18048 mp->table_id = clib_host_to_net_u32 (table_id);
18049 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
18050 mp->is_ip4 = is_ip4;
18052 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
18054 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
18059 /* Wait for a reply... */
18065 api_one_map_server_dump (vat_main_t * vam)
18067 vl_api_one_map_server_dump_t *mp;
18068 vl_api_control_ping_t *mp_ping;
18071 if (!vam->json_output)
18073 print (vam->ofp, "%=20s", "Map server");
18076 M (ONE_MAP_SERVER_DUMP, mp);
18080 /* Use a control ping for synchronization */
18081 MPING (CONTROL_PING, mp_ping);
18084 /* Wait for a reply... */
18089 #define api_lisp_map_server_dump api_one_map_server_dump
18092 api_one_map_resolver_dump (vat_main_t * vam)
18094 vl_api_one_map_resolver_dump_t *mp;
18095 vl_api_control_ping_t *mp_ping;
18098 if (!vam->json_output)
18100 print (vam->ofp, "%=20s", "Map resolver");
18103 M (ONE_MAP_RESOLVER_DUMP, mp);
18107 /* Use a control ping for synchronization */
18108 MPING (CONTROL_PING, mp_ping);
18111 /* Wait for a reply... */
18116 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
18119 api_one_stats_flush (vat_main_t * vam)
18121 vl_api_one_stats_flush_t *mp;
18124 M (ONE_STATS_FLUSH, mp);
18131 api_one_stats_dump (vat_main_t * vam)
18133 vl_api_one_stats_dump_t *mp;
18134 vl_api_control_ping_t *mp_ping;
18137 M (ONE_STATS_DUMP, mp);
18141 /* Use a control ping for synchronization */
18142 MPING (CONTROL_PING, mp_ping);
18145 /* Wait for a reply... */
18151 api_show_one_status (vat_main_t * vam)
18153 vl_api_show_one_status_t *mp;
18156 if (!vam->json_output)
18158 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
18161 M (SHOW_ONE_STATUS, mp);
18164 /* Wait for a reply... */
18169 #define api_show_lisp_status api_show_one_status
18172 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
18174 vl_api_gpe_fwd_entry_path_dump_t *mp;
18175 vl_api_control_ping_t *mp_ping;
18176 unformat_input_t *i = vam->input;
18177 u32 fwd_entry_index = ~0;
18180 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18182 if (unformat (i, "index %d", &fwd_entry_index))
18188 if (~0 == fwd_entry_index)
18190 errmsg ("no index specified!");
18194 if (!vam->json_output)
18196 print (vam->ofp, "first line");
18199 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
18203 /* Use a control ping for synchronization */
18204 MPING (CONTROL_PING, mp_ping);
18207 /* Wait for a reply... */
18213 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
18215 vl_api_one_get_map_request_itr_rlocs_t *mp;
18218 if (!vam->json_output)
18220 print (vam->ofp, "%=20s", "itr-rlocs:");
18223 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
18226 /* Wait for a reply... */
18231 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
18234 api_af_packet_create (vat_main_t * vam)
18236 unformat_input_t *i = vam->input;
18237 vl_api_af_packet_create_t *mp;
18238 u8 *host_if_name = 0;
18240 u8 random_hw_addr = 1;
18243 clib_memset (hw_addr, 0, sizeof (hw_addr));
18245 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18247 if (unformat (i, "name %s", &host_if_name))
18248 vec_add1 (host_if_name, 0);
18249 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
18250 random_hw_addr = 0;
18255 if (!vec_len (host_if_name))
18257 errmsg ("host-interface name must be specified");
18261 if (vec_len (host_if_name) > 64)
18263 errmsg ("host-interface name too long");
18267 M (AF_PACKET_CREATE, mp);
18269 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
18270 clib_memcpy (mp->hw_addr, hw_addr, 6);
18271 mp->use_random_hw_addr = random_hw_addr;
18272 vec_free (host_if_name);
18280 fprintf (vam->ofp ? vam->ofp : stderr,
18281 " new sw_if_index = %d\n", vam->sw_if_index);
18288 api_af_packet_delete (vat_main_t * vam)
18290 unformat_input_t *i = vam->input;
18291 vl_api_af_packet_delete_t *mp;
18292 u8 *host_if_name = 0;
18295 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18297 if (unformat (i, "name %s", &host_if_name))
18298 vec_add1 (host_if_name, 0);
18303 if (!vec_len (host_if_name))
18305 errmsg ("host-interface name must be specified");
18309 if (vec_len (host_if_name) > 64)
18311 errmsg ("host-interface name too long");
18315 M (AF_PACKET_DELETE, mp);
18317 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
18318 vec_free (host_if_name);
18325 static void vl_api_af_packet_details_t_handler
18326 (vl_api_af_packet_details_t * mp)
18328 vat_main_t *vam = &vat_main;
18330 print (vam->ofp, "%-16s %d",
18331 mp->host_if_name, clib_net_to_host_u32 (mp->sw_if_index));
18334 static void vl_api_af_packet_details_t_handler_json
18335 (vl_api_af_packet_details_t * mp)
18337 vat_main_t *vam = &vat_main;
18338 vat_json_node_t *node = NULL;
18340 if (VAT_JSON_ARRAY != vam->json_tree.type)
18342 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18343 vat_json_init_array (&vam->json_tree);
18345 node = vat_json_array_add (&vam->json_tree);
18347 vat_json_init_object (node);
18348 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
18349 vat_json_object_add_string_copy (node, "dev_name", mp->host_if_name);
18353 api_af_packet_dump (vat_main_t * vam)
18355 vl_api_af_packet_dump_t *mp;
18356 vl_api_control_ping_t *mp_ping;
18359 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
18360 /* Get list of tap interfaces */
18361 M (AF_PACKET_DUMP, mp);
18364 /* Use a control ping for synchronization */
18365 MPING (CONTROL_PING, mp_ping);
18373 api_policer_add_del (vat_main_t * vam)
18375 unformat_input_t *i = vam->input;
18376 vl_api_policer_add_del_t *mp;
18386 u8 color_aware = 0;
18387 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
18390 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
18391 conform_action.dscp = 0;
18392 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
18393 exceed_action.dscp = 0;
18394 violate_action.action_type = SSE2_QOS_ACTION_DROP;
18395 violate_action.dscp = 0;
18397 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18399 if (unformat (i, "del"))
18401 else if (unformat (i, "name %s", &name))
18402 vec_add1 (name, 0);
18403 else if (unformat (i, "cir %u", &cir))
18405 else if (unformat (i, "eir %u", &eir))
18407 else if (unformat (i, "cb %u", &cb))
18409 else if (unformat (i, "eb %u", &eb))
18411 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
18414 else if (unformat (i, "round_type %U", unformat_policer_round_type,
18417 else if (unformat (i, "type %U", unformat_policer_type, &type))
18419 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
18422 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
18425 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
18428 else if (unformat (i, "color-aware"))
18434 if (!vec_len (name))
18436 errmsg ("policer name must be specified");
18440 if (vec_len (name) > 64)
18442 errmsg ("policer name too long");
18446 M (POLICER_ADD_DEL, mp);
18448 clib_memcpy (mp->name, name, vec_len (name));
18450 mp->is_add = is_add;
18451 mp->cir = ntohl (cir);
18452 mp->eir = ntohl (eir);
18453 mp->cb = clib_net_to_host_u64 (cb);
18454 mp->eb = clib_net_to_host_u64 (eb);
18455 mp->rate_type = rate_type;
18456 mp->round_type = round_type;
18458 mp->conform_action_type = conform_action.action_type;
18459 mp->conform_dscp = conform_action.dscp;
18460 mp->exceed_action_type = exceed_action.action_type;
18461 mp->exceed_dscp = exceed_action.dscp;
18462 mp->violate_action_type = violate_action.action_type;
18463 mp->violate_dscp = violate_action.dscp;
18464 mp->color_aware = color_aware;
18472 api_policer_dump (vat_main_t * vam)
18474 unformat_input_t *i = vam->input;
18475 vl_api_policer_dump_t *mp;
18476 vl_api_control_ping_t *mp_ping;
18477 u8 *match_name = 0;
18478 u8 match_name_valid = 0;
18481 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18483 if (unformat (i, "name %s", &match_name))
18485 vec_add1 (match_name, 0);
18486 match_name_valid = 1;
18492 M (POLICER_DUMP, mp);
18493 mp->match_name_valid = match_name_valid;
18494 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
18495 vec_free (match_name);
18499 /* Use a control ping for synchronization */
18500 MPING (CONTROL_PING, mp_ping);
18503 /* Wait for a reply... */
18509 api_policer_classify_set_interface (vat_main_t * vam)
18511 unformat_input_t *i = vam->input;
18512 vl_api_policer_classify_set_interface_t *mp;
18514 int sw_if_index_set;
18515 u32 ip4_table_index = ~0;
18516 u32 ip6_table_index = ~0;
18517 u32 l2_table_index = ~0;
18521 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18523 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18524 sw_if_index_set = 1;
18525 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18526 sw_if_index_set = 1;
18527 else if (unformat (i, "del"))
18529 else if (unformat (i, "ip4-table %d", &ip4_table_index))
18531 else if (unformat (i, "ip6-table %d", &ip6_table_index))
18533 else if (unformat (i, "l2-table %d", &l2_table_index))
18537 clib_warning ("parse error '%U'", format_unformat_error, i);
18542 if (sw_if_index_set == 0)
18544 errmsg ("missing interface name or sw_if_index");
18548 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
18550 mp->sw_if_index = ntohl (sw_if_index);
18551 mp->ip4_table_index = ntohl (ip4_table_index);
18552 mp->ip6_table_index = ntohl (ip6_table_index);
18553 mp->l2_table_index = ntohl (l2_table_index);
18554 mp->is_add = is_add;
18562 api_policer_classify_dump (vat_main_t * vam)
18564 unformat_input_t *i = vam->input;
18565 vl_api_policer_classify_dump_t *mp;
18566 vl_api_control_ping_t *mp_ping;
18567 u8 type = POLICER_CLASSIFY_N_TABLES;
18570 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
18574 errmsg ("classify table type must be specified");
18578 if (!vam->json_output)
18580 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
18583 M (POLICER_CLASSIFY_DUMP, mp);
18588 /* Use a control ping for synchronization */
18589 MPING (CONTROL_PING, mp_ping);
18592 /* Wait for a reply... */
18598 api_netmap_create (vat_main_t * vam)
18600 unformat_input_t *i = vam->input;
18601 vl_api_netmap_create_t *mp;
18604 u8 random_hw_addr = 1;
18609 clib_memset (hw_addr, 0, sizeof (hw_addr));
18611 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18613 if (unformat (i, "name %s", &if_name))
18614 vec_add1 (if_name, 0);
18615 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
18616 random_hw_addr = 0;
18617 else if (unformat (i, "pipe"))
18619 else if (unformat (i, "master"))
18621 else if (unformat (i, "slave"))
18627 if (!vec_len (if_name))
18629 errmsg ("interface name must be specified");
18633 if (vec_len (if_name) > 64)
18635 errmsg ("interface name too long");
18639 M (NETMAP_CREATE, mp);
18641 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
18642 clib_memcpy (mp->hw_addr, hw_addr, 6);
18643 mp->use_random_hw_addr = random_hw_addr;
18644 mp->is_pipe = is_pipe;
18645 mp->is_master = is_master;
18646 vec_free (if_name);
18654 api_netmap_delete (vat_main_t * vam)
18656 unformat_input_t *i = vam->input;
18657 vl_api_netmap_delete_t *mp;
18661 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18663 if (unformat (i, "name %s", &if_name))
18664 vec_add1 (if_name, 0);
18669 if (!vec_len (if_name))
18671 errmsg ("interface name must be specified");
18675 if (vec_len (if_name) > 64)
18677 errmsg ("interface name too long");
18681 M (NETMAP_DELETE, mp);
18683 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
18684 vec_free (if_name);
18692 format_fib_api_path_nh_proto (u8 * s, va_list * args)
18694 vl_api_fib_path_nh_proto_t proto =
18695 va_arg (*args, vl_api_fib_path_nh_proto_t);
18699 case FIB_API_PATH_NH_PROTO_IP4:
18700 s = format (s, "ip4");
18702 case FIB_API_PATH_NH_PROTO_IP6:
18703 s = format (s, "ip6");
18705 case FIB_API_PATH_NH_PROTO_MPLS:
18706 s = format (s, "mpls");
18708 case FIB_API_PATH_NH_PROTO_BIER:
18709 s = format (s, "bier");
18711 case FIB_API_PATH_NH_PROTO_ETHERNET:
18712 s = format (s, "ethernet");
18720 format_vl_api_ip_address_union (u8 * s, va_list * args)
18722 vl_api_address_family_t af = va_arg (*args, vl_api_address_family_t);
18723 const vl_api_address_union_t *u = va_arg (*args, vl_api_address_union_t *);
18728 s = format (s, "%U", format_ip4_address, u->ip4);
18731 s = format (s, "%U", format_ip6_address, u->ip6);
18738 format_vl_api_fib_path_type (u8 * s, va_list * args)
18740 vl_api_fib_path_type_t t = va_arg (*args, vl_api_fib_path_type_t);
18744 case FIB_API_PATH_TYPE_NORMAL:
18745 s = format (s, "normal");
18747 case FIB_API_PATH_TYPE_LOCAL:
18748 s = format (s, "local");
18750 case FIB_API_PATH_TYPE_DROP:
18751 s = format (s, "drop");
18753 case FIB_API_PATH_TYPE_UDP_ENCAP:
18754 s = format (s, "udp-encap");
18756 case FIB_API_PATH_TYPE_BIER_IMP:
18757 s = format (s, "bier-imp");
18759 case FIB_API_PATH_TYPE_ICMP_UNREACH:
18760 s = format (s, "unreach");
18762 case FIB_API_PATH_TYPE_ICMP_PROHIBIT:
18763 s = format (s, "prohibit");
18765 case FIB_API_PATH_TYPE_SOURCE_LOOKUP:
18766 s = format (s, "src-lookup");
18768 case FIB_API_PATH_TYPE_DVR:
18769 s = format (s, "dvr");
18771 case FIB_API_PATH_TYPE_INTERFACE_RX:
18772 s = format (s, "interface-rx");
18774 case FIB_API_PATH_TYPE_CLASSIFY:
18775 s = format (s, "classify");
18783 vl_api_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
18786 " weight %d, sw_if_index %d, type %U, afi %U, next_hop %U",
18787 ntohl (fp->weight), ntohl (fp->sw_if_index),
18788 format_vl_api_fib_path_type, fp->type,
18789 format_fib_api_path_nh_proto, fp->proto,
18790 format_vl_api_ip_address_union, &fp->nh.address);
18794 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
18795 vl_api_fib_path_t * fp)
18797 struct in_addr ip4;
18798 struct in6_addr ip6;
18800 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
18801 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
18802 vat_json_object_add_uint (node, "type", fp->type);
18803 vat_json_object_add_uint (node, "next_hop_proto", fp->proto);
18804 if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
18806 clib_memcpy (&ip4, &fp->nh.address.ip4, sizeof (ip4));
18807 vat_json_object_add_ip4 (node, "next_hop", ip4);
18809 else if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
18811 clib_memcpy (&ip6, &fp->nh.address.ip6, sizeof (ip6));
18812 vat_json_object_add_ip6 (node, "next_hop", ip6);
18817 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
18819 vat_main_t *vam = &vat_main;
18820 int count = ntohl (mp->mt_tunnel.mt_n_paths);
18821 vl_api_fib_path_t *fp;
18824 print (vam->ofp, "sw_if_index %d via:",
18825 ntohl (mp->mt_tunnel.mt_sw_if_index));
18826 fp = mp->mt_tunnel.mt_paths;
18827 for (i = 0; i < count; i++)
18829 vl_api_fib_path_print (vam, fp);
18833 print (vam->ofp, "");
18836 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
18837 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
18840 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
18842 vat_main_t *vam = &vat_main;
18843 vat_json_node_t *node = NULL;
18844 int count = ntohl (mp->mt_tunnel.mt_n_paths);
18845 vl_api_fib_path_t *fp;
18848 if (VAT_JSON_ARRAY != vam->json_tree.type)
18850 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18851 vat_json_init_array (&vam->json_tree);
18853 node = vat_json_array_add (&vam->json_tree);
18855 vat_json_init_object (node);
18856 vat_json_object_add_uint (node, "sw_if_index",
18857 ntohl (mp->mt_tunnel.mt_sw_if_index));
18859 vat_json_object_add_uint (node, "l2_only", mp->mt_tunnel.mt_l2_only);
18861 fp = mp->mt_tunnel.mt_paths;
18862 for (i = 0; i < count; i++)
18864 vl_api_mpls_fib_path_json_print (node, fp);
18870 api_mpls_tunnel_dump (vat_main_t * vam)
18872 vl_api_mpls_tunnel_dump_t *mp;
18873 vl_api_control_ping_t *mp_ping;
18876 M (MPLS_TUNNEL_DUMP, mp);
18880 /* Use a control ping for synchronization */
18881 MPING (CONTROL_PING, mp_ping);
18888 #define vl_api_mpls_table_details_t_endian vl_noop_handler
18889 #define vl_api_mpls_table_details_t_print vl_noop_handler
18893 vl_api_mpls_table_details_t_handler (vl_api_mpls_table_details_t * mp)
18895 vat_main_t *vam = &vat_main;
18897 print (vam->ofp, "table-id %d,", ntohl (mp->mt_table.mt_table_id));
18900 static void vl_api_mpls_table_details_t_handler_json
18901 (vl_api_mpls_table_details_t * mp)
18903 vat_main_t *vam = &vat_main;
18904 vat_json_node_t *node = NULL;
18906 if (VAT_JSON_ARRAY != vam->json_tree.type)
18908 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18909 vat_json_init_array (&vam->json_tree);
18911 node = vat_json_array_add (&vam->json_tree);
18913 vat_json_init_object (node);
18914 vat_json_object_add_uint (node, "table", ntohl (mp->mt_table.mt_table_id));
18918 api_mpls_table_dump (vat_main_t * vam)
18920 vl_api_mpls_table_dump_t *mp;
18921 vl_api_control_ping_t *mp_ping;
18924 M (MPLS_TABLE_DUMP, mp);
18927 /* Use a control ping for synchronization */
18928 MPING (CONTROL_PING, mp_ping);
18935 #define vl_api_mpls_route_details_t_endian vl_noop_handler
18936 #define vl_api_mpls_route_details_t_print vl_noop_handler
18939 vl_api_mpls_route_details_t_handler (vl_api_mpls_route_details_t * mp)
18941 vat_main_t *vam = &vat_main;
18942 int count = (int) clib_net_to_host_u32 (mp->mr_route.mr_n_paths);
18943 vl_api_fib_path_t *fp;
18947 "table-id %d, label %u, ess_bit %u",
18948 ntohl (mp->mr_route.mr_table_id),
18949 ntohl (mp->mr_route.mr_label), mp->mr_route.mr_eos);
18950 fp = mp->mr_route.mr_paths;
18951 for (i = 0; i < count; i++)
18953 vl_api_fib_path_print (vam, fp);
18958 static void vl_api_mpls_route_details_t_handler_json
18959 (vl_api_mpls_route_details_t * mp)
18961 vat_main_t *vam = &vat_main;
18962 int count = (int) clib_host_to_net_u32 (mp->mr_route.mr_n_paths);
18963 vat_json_node_t *node = NULL;
18964 vl_api_fib_path_t *fp;
18967 if (VAT_JSON_ARRAY != vam->json_tree.type)
18969 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18970 vat_json_init_array (&vam->json_tree);
18972 node = vat_json_array_add (&vam->json_tree);
18974 vat_json_init_object (node);
18975 vat_json_object_add_uint (node, "table", ntohl (mp->mr_route.mr_table_id));
18976 vat_json_object_add_uint (node, "s_bit", mp->mr_route.mr_eos);
18977 vat_json_object_add_uint (node, "label", ntohl (mp->mr_route.mr_label));
18978 vat_json_object_add_uint (node, "path_count", count);
18979 fp = mp->mr_route.mr_paths;
18980 for (i = 0; i < count; i++)
18982 vl_api_mpls_fib_path_json_print (node, fp);
18988 api_mpls_route_dump (vat_main_t * vam)
18990 unformat_input_t *input = vam->input;
18991 vl_api_mpls_route_dump_t *mp;
18992 vl_api_control_ping_t *mp_ping;
18996 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18998 if (unformat (input, "table_id %d", &table_id))
19003 if (table_id == ~0)
19005 errmsg ("missing table id");
19009 M (MPLS_ROUTE_DUMP, mp);
19011 mp->table.mt_table_id = ntohl (table_id);
19014 /* Use a control ping for synchronization */
19015 MPING (CONTROL_PING, mp_ping);
19022 #define vl_api_ip_table_details_t_endian vl_noop_handler
19023 #define vl_api_ip_table_details_t_print vl_noop_handler
19026 vl_api_ip_table_details_t_handler (vl_api_ip_table_details_t * mp)
19028 vat_main_t *vam = &vat_main;
19031 "%s; table-id %d, prefix %U/%d",
19032 mp->table.name, ntohl (mp->table.table_id));
19036 static void vl_api_ip_table_details_t_handler_json
19037 (vl_api_ip_table_details_t * mp)
19039 vat_main_t *vam = &vat_main;
19040 vat_json_node_t *node = NULL;
19042 if (VAT_JSON_ARRAY != vam->json_tree.type)
19044 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19045 vat_json_init_array (&vam->json_tree);
19047 node = vat_json_array_add (&vam->json_tree);
19049 vat_json_init_object (node);
19050 vat_json_object_add_uint (node, "table", ntohl (mp->table.table_id));
19054 api_ip_table_dump (vat_main_t * vam)
19056 vl_api_ip_table_dump_t *mp;
19057 vl_api_control_ping_t *mp_ping;
19060 M (IP_TABLE_DUMP, mp);
19063 /* Use a control ping for synchronization */
19064 MPING (CONTROL_PING, mp_ping);
19072 api_ip_mtable_dump (vat_main_t * vam)
19074 vl_api_ip_mtable_dump_t *mp;
19075 vl_api_control_ping_t *mp_ping;
19078 M (IP_MTABLE_DUMP, mp);
19081 /* Use a control ping for synchronization */
19082 MPING (CONTROL_PING, mp_ping);
19090 api_ip_mroute_dump (vat_main_t * vam)
19092 unformat_input_t *input = vam->input;
19093 vl_api_control_ping_t *mp_ping;
19094 vl_api_ip_mroute_dump_t *mp;
19099 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19101 if (unformat (input, "table_id %d", &table_id))
19103 else if (unformat (input, "ip6"))
19105 else if (unformat (input, "ip4"))
19110 if (table_id == ~0)
19112 errmsg ("missing table id");
19116 M (IP_MROUTE_DUMP, mp);
19117 mp->table.table_id = table_id;
19118 mp->table.is_ip6 = is_ip6;
19121 /* Use a control ping for synchronization */
19122 MPING (CONTROL_PING, mp_ping);
19129 static void vl_api_ip_neighbor_details_t_handler
19130 (vl_api_ip_neighbor_details_t * mp)
19132 vat_main_t *vam = &vat_main;
19134 print (vam->ofp, "%c %U %U",
19135 (ntohl (mp->neighbor.flags) & IP_NEIGHBOR_FLAG_STATIC) ? 'S' : 'D',
19136 format_vl_api_mac_address, &mp->neighbor.mac_address,
19137 format_vl_api_address, &mp->neighbor.ip_address);
19140 static void vl_api_ip_neighbor_details_t_handler_json
19141 (vl_api_ip_neighbor_details_t * mp)
19144 vat_main_t *vam = &vat_main;
19145 vat_json_node_t *node;
19147 if (VAT_JSON_ARRAY != vam->json_tree.type)
19149 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19150 vat_json_init_array (&vam->json_tree);
19152 node = vat_json_array_add (&vam->json_tree);
19154 vat_json_init_object (node);
19155 vat_json_object_add_string_copy
19157 ((ntohl (mp->neighbor.flags) & IP_NEIGHBOR_FLAG_STATIC) ?
19158 (u8 *) "static" : (u8 *) "dynamic"));
19160 vat_json_object_add_string_copy (node, "link_layer",
19161 format (0, "%U", format_vl_api_mac_address,
19162 &mp->neighbor.mac_address));
19163 vat_json_object_add_address (node, "ip", &mp->neighbor.ip_address);
19167 api_ip_neighbor_dump (vat_main_t * vam)
19169 unformat_input_t *i = vam->input;
19170 vl_api_ip_neighbor_dump_t *mp;
19171 vl_api_control_ping_t *mp_ping;
19173 u32 sw_if_index = ~0;
19176 /* Parse args required to build the message */
19177 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19179 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19181 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19183 else if (unformat (i, "ip6"))
19189 if (sw_if_index == ~0)
19191 errmsg ("missing interface name or sw_if_index");
19195 M (IP_NEIGHBOR_DUMP, mp);
19196 mp->is_ipv6 = (u8) is_ipv6;
19197 mp->sw_if_index = ntohl (sw_if_index);
19200 /* Use a control ping for synchronization */
19201 MPING (CONTROL_PING, mp_ping);
19208 #define vl_api_ip_route_details_t_endian vl_noop_handler
19209 #define vl_api_ip_route_details_t_print vl_noop_handler
19212 vl_api_ip_route_details_t_handler (vl_api_ip_route_details_t * mp)
19214 vat_main_t *vam = &vat_main;
19215 u8 count = mp->route.n_paths;
19216 vl_api_fib_path_t *fp;
19220 "table-id %d, prefix %U/%d",
19221 ntohl (mp->route.table_id),
19222 format_ip46_address, mp->route.prefix.address, mp->route.prefix.len);
19223 for (i = 0; i < count; i++)
19225 fp = &mp->route.paths[i];
19227 vl_api_fib_path_print (vam, fp);
19232 static void vl_api_ip_route_details_t_handler_json
19233 (vl_api_ip_route_details_t * mp)
19235 vat_main_t *vam = &vat_main;
19236 u8 count = mp->route.n_paths;
19237 vat_json_node_t *node = NULL;
19238 struct in_addr ip4;
19239 struct in6_addr ip6;
19240 vl_api_fib_path_t *fp;
19243 if (VAT_JSON_ARRAY != vam->json_tree.type)
19245 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19246 vat_json_init_array (&vam->json_tree);
19248 node = vat_json_array_add (&vam->json_tree);
19250 vat_json_init_object (node);
19251 vat_json_object_add_uint (node, "table", ntohl (mp->route.table_id));
19252 if (ADDRESS_IP6 == mp->route.prefix.address.af)
19254 clib_memcpy (&ip6, &mp->route.prefix.address.un.ip6, sizeof (ip6));
19255 vat_json_object_add_ip6 (node, "prefix", ip6);
19259 clib_memcpy (&ip4, &mp->route.prefix.address.un.ip4, sizeof (ip4));
19260 vat_json_object_add_ip4 (node, "prefix", ip4);
19262 vat_json_object_add_uint (node, "mask_length", mp->route.prefix.len);
19263 vat_json_object_add_uint (node, "path_count", count);
19264 for (i = 0; i < count; i++)
19266 fp = &mp->route.paths[i];
19267 vl_api_mpls_fib_path_json_print (node, fp);
19272 api_ip_route_dump (vat_main_t * vam)
19274 unformat_input_t *input = vam->input;
19275 vl_api_ip_route_dump_t *mp;
19276 vl_api_control_ping_t *mp_ping;
19282 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19284 if (unformat (input, "table_id %d", &table_id))
19286 else if (unformat (input, "ip6"))
19288 else if (unformat (input, "ip4"))
19293 if (table_id == ~0)
19295 errmsg ("missing table id");
19299 M (IP_ROUTE_DUMP, mp);
19301 mp->table.table_id = table_id;
19302 mp->table.is_ip6 = is_ip6;
19306 /* Use a control ping for synchronization */
19307 MPING (CONTROL_PING, mp_ping);
19315 api_classify_table_ids (vat_main_t * vam)
19317 vl_api_classify_table_ids_t *mp;
19320 /* Construct the API message */
19321 M (CLASSIFY_TABLE_IDS, mp);
19330 api_classify_table_by_interface (vat_main_t * vam)
19332 unformat_input_t *input = vam->input;
19333 vl_api_classify_table_by_interface_t *mp;
19335 u32 sw_if_index = ~0;
19337 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19339 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19341 else if (unformat (input, "sw_if_index %d", &sw_if_index))
19346 if (sw_if_index == ~0)
19348 errmsg ("missing interface name or sw_if_index");
19352 /* Construct the API message */
19353 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
19355 mp->sw_if_index = ntohl (sw_if_index);
19363 api_classify_table_info (vat_main_t * vam)
19365 unformat_input_t *input = vam->input;
19366 vl_api_classify_table_info_t *mp;
19370 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19372 if (unformat (input, "table_id %d", &table_id))
19377 if (table_id == ~0)
19379 errmsg ("missing table id");
19383 /* Construct the API message */
19384 M (CLASSIFY_TABLE_INFO, mp);
19386 mp->table_id = ntohl (table_id);
19394 api_classify_session_dump (vat_main_t * vam)
19396 unformat_input_t *input = vam->input;
19397 vl_api_classify_session_dump_t *mp;
19398 vl_api_control_ping_t *mp_ping;
19402 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19404 if (unformat (input, "table_id %d", &table_id))
19409 if (table_id == ~0)
19411 errmsg ("missing table id");
19415 /* Construct the API message */
19416 M (CLASSIFY_SESSION_DUMP, mp);
19418 mp->table_id = ntohl (table_id);
19421 /* Use a control ping for synchronization */
19422 MPING (CONTROL_PING, mp_ping);
19430 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
19432 vat_main_t *vam = &vat_main;
19434 print (vam->ofp, "collector_address %U, collector_port %d, "
19435 "src_address %U, vrf_id %d, path_mtu %u, "
19436 "template_interval %u, udp_checksum %d",
19437 format_ip4_address, mp->collector_address,
19438 ntohs (mp->collector_port),
19439 format_ip4_address, mp->src_address,
19440 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
19441 ntohl (mp->template_interval), mp->udp_checksum);
19444 vam->result_ready = 1;
19448 vl_api_ipfix_exporter_details_t_handler_json
19449 (vl_api_ipfix_exporter_details_t * mp)
19451 vat_main_t *vam = &vat_main;
19452 vat_json_node_t node;
19453 struct in_addr collector_address;
19454 struct in_addr src_address;
19456 vat_json_init_object (&node);
19457 clib_memcpy (&collector_address, &mp->collector_address,
19458 sizeof (collector_address));
19459 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
19460 vat_json_object_add_uint (&node, "collector_port",
19461 ntohs (mp->collector_port));
19462 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
19463 vat_json_object_add_ip4 (&node, "src_address", src_address);
19464 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
19465 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
19466 vat_json_object_add_uint (&node, "template_interval",
19467 ntohl (mp->template_interval));
19468 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
19470 vat_json_print (vam->ofp, &node);
19471 vat_json_free (&node);
19473 vam->result_ready = 1;
19477 api_ipfix_exporter_dump (vat_main_t * vam)
19479 vl_api_ipfix_exporter_dump_t *mp;
19482 /* Construct the API message */
19483 M (IPFIX_EXPORTER_DUMP, mp);
19492 api_ipfix_classify_stream_dump (vat_main_t * vam)
19494 vl_api_ipfix_classify_stream_dump_t *mp;
19497 /* Construct the API message */
19498 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
19509 vl_api_ipfix_classify_stream_details_t_handler
19510 (vl_api_ipfix_classify_stream_details_t * mp)
19512 vat_main_t *vam = &vat_main;
19513 print (vam->ofp, "domain_id %d, src_port %d",
19514 ntohl (mp->domain_id), ntohs (mp->src_port));
19516 vam->result_ready = 1;
19520 vl_api_ipfix_classify_stream_details_t_handler_json
19521 (vl_api_ipfix_classify_stream_details_t * mp)
19523 vat_main_t *vam = &vat_main;
19524 vat_json_node_t node;
19526 vat_json_init_object (&node);
19527 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
19528 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
19530 vat_json_print (vam->ofp, &node);
19531 vat_json_free (&node);
19533 vam->result_ready = 1;
19537 api_ipfix_classify_table_dump (vat_main_t * vam)
19539 vl_api_ipfix_classify_table_dump_t *mp;
19540 vl_api_control_ping_t *mp_ping;
19543 if (!vam->json_output)
19545 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
19546 "transport_protocol");
19549 /* Construct the API message */
19550 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
19555 /* Use a control ping for synchronization */
19556 MPING (CONTROL_PING, mp_ping);
19564 vl_api_ipfix_classify_table_details_t_handler
19565 (vl_api_ipfix_classify_table_details_t * mp)
19567 vat_main_t *vam = &vat_main;
19568 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
19569 mp->transport_protocol);
19573 vl_api_ipfix_classify_table_details_t_handler_json
19574 (vl_api_ipfix_classify_table_details_t * mp)
19576 vat_json_node_t *node = NULL;
19577 vat_main_t *vam = &vat_main;
19579 if (VAT_JSON_ARRAY != vam->json_tree.type)
19581 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19582 vat_json_init_array (&vam->json_tree);
19585 node = vat_json_array_add (&vam->json_tree);
19586 vat_json_init_object (node);
19588 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
19589 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
19590 vat_json_object_add_uint (node, "transport_protocol",
19591 mp->transport_protocol);
19595 api_sw_interface_span_enable_disable (vat_main_t * vam)
19597 unformat_input_t *i = vam->input;
19598 vl_api_sw_interface_span_enable_disable_t *mp;
19599 u32 src_sw_if_index = ~0;
19600 u32 dst_sw_if_index = ~0;
19605 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19608 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
19610 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
19614 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
19616 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
19618 else if (unformat (i, "disable"))
19620 else if (unformat (i, "rx"))
19622 else if (unformat (i, "tx"))
19624 else if (unformat (i, "both"))
19626 else if (unformat (i, "l2"))
19632 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
19634 mp->sw_if_index_from = htonl (src_sw_if_index);
19635 mp->sw_if_index_to = htonl (dst_sw_if_index);
19645 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
19648 vat_main_t *vam = &vat_main;
19649 u8 *sw_if_from_name = 0;
19650 u8 *sw_if_to_name = 0;
19651 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
19652 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
19653 char *states[] = { "none", "rx", "tx", "both" };
19657 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
19659 if ((u32) p->value[0] == sw_if_index_from)
19661 sw_if_from_name = (u8 *)(p->key);
19665 if ((u32) p->value[0] == sw_if_index_to)
19667 sw_if_to_name = (u8 *)(p->key);
19668 if (sw_if_from_name)
19673 print (vam->ofp, "%20s => %20s (%s) %s",
19674 sw_if_from_name, sw_if_to_name, states[mp->state],
19675 mp->is_l2 ? "l2" : "device");
19679 vl_api_sw_interface_span_details_t_handler_json
19680 (vl_api_sw_interface_span_details_t * mp)
19682 vat_main_t *vam = &vat_main;
19683 vat_json_node_t *node = NULL;
19684 u8 *sw_if_from_name = 0;
19685 u8 *sw_if_to_name = 0;
19686 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
19687 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
19691 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
19693 if ((u32) p->value[0] == sw_if_index_from)
19695 sw_if_from_name = (u8 *)(p->key);
19699 if ((u32) p->value[0] == sw_if_index_to)
19701 sw_if_to_name = (u8 *)(p->key);
19702 if (sw_if_from_name)
19708 if (VAT_JSON_ARRAY != vam->json_tree.type)
19710 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19711 vat_json_init_array (&vam->json_tree);
19713 node = vat_json_array_add (&vam->json_tree);
19715 vat_json_init_object (node);
19716 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
19717 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
19718 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
19719 if (0 != sw_if_to_name)
19721 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
19723 vat_json_object_add_uint (node, "state", mp->state);
19724 vat_json_object_add_uint (node, "is-l2", mp->is_l2);
19728 api_sw_interface_span_dump (vat_main_t * vam)
19730 unformat_input_t *input = vam->input;
19731 vl_api_sw_interface_span_dump_t *mp;
19732 vl_api_control_ping_t *mp_ping;
19736 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19738 if (unformat (input, "l2"))
19744 M (SW_INTERFACE_SPAN_DUMP, mp);
19748 /* Use a control ping for synchronization */
19749 MPING (CONTROL_PING, mp_ping);
19757 api_pg_create_interface (vat_main_t * vam)
19759 unformat_input_t *input = vam->input;
19760 vl_api_pg_create_interface_t *mp;
19762 u32 if_id = ~0, gso_size = 0;
19763 u8 gso_enabled = 0;
19765 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19767 if (unformat (input, "if_id %d", &if_id))
19769 else if (unformat (input, "gso-enabled"))
19772 if (unformat (input, "gso-size %u", &gso_size))
19776 errmsg ("missing gso-size");
19785 errmsg ("missing pg interface index");
19789 /* Construct the API message */
19790 M (PG_CREATE_INTERFACE, mp);
19792 mp->interface_id = ntohl (if_id);
19793 mp->gso_enabled = gso_enabled;
19801 api_pg_capture (vat_main_t * vam)
19803 unformat_input_t *input = vam->input;
19804 vl_api_pg_capture_t *mp;
19809 u8 pcap_file_set = 0;
19812 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19814 if (unformat (input, "if_id %d", &if_id))
19816 else if (unformat (input, "pcap %s", &pcap_file))
19818 else if (unformat (input, "count %d", &count))
19820 else if (unformat (input, "disable"))
19827 errmsg ("missing pg interface index");
19830 if (pcap_file_set > 0)
19832 if (vec_len (pcap_file) > 255)
19834 errmsg ("pcap file name is too long");
19839 u32 name_len = vec_len (pcap_file);
19840 /* Construct the API message */
19841 M (PG_CAPTURE, mp);
19843 mp->interface_id = ntohl (if_id);
19844 mp->is_enabled = enable;
19845 mp->count = ntohl (count);
19846 mp->pcap_name_length = ntohl (name_len);
19847 if (pcap_file_set != 0)
19849 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
19851 vec_free (pcap_file);
19859 api_pg_enable_disable (vat_main_t * vam)
19861 unformat_input_t *input = vam->input;
19862 vl_api_pg_enable_disable_t *mp;
19865 u8 stream_name_set = 0;
19866 u8 *stream_name = 0;
19868 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19870 if (unformat (input, "stream %s", &stream_name))
19871 stream_name_set = 1;
19872 else if (unformat (input, "disable"))
19878 if (stream_name_set > 0)
19880 if (vec_len (stream_name) > 255)
19882 errmsg ("stream name too long");
19887 u32 name_len = vec_len (stream_name);
19888 /* Construct the API message */
19889 M (PG_ENABLE_DISABLE, mp);
19891 mp->is_enabled = enable;
19892 if (stream_name_set != 0)
19894 mp->stream_name_length = ntohl (name_len);
19895 clib_memcpy (mp->stream_name, stream_name, name_len);
19897 vec_free (stream_name);
19905 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
19907 unformat_input_t *input = vam->input;
19908 vl_api_ip_source_and_port_range_check_add_del_t *mp;
19910 u16 *low_ports = 0;
19911 u16 *high_ports = 0;
19914 vl_api_prefix_t prefix;
19921 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
19923 if (unformat (input, "%U", unformat_vl_api_prefix, &prefix))
19925 else if (unformat (input, "vrf %d", &vrf_id))
19927 else if (unformat (input, "del"))
19929 else if (unformat (input, "port %d", &tmp))
19931 if (tmp == 0 || tmp > 65535)
19933 errmsg ("port %d out of range", tmp);
19937 this_hi = this_low + 1;
19938 vec_add1 (low_ports, this_low);
19939 vec_add1 (high_ports, this_hi);
19941 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
19943 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
19945 errmsg ("incorrect range parameters");
19949 /* Note: in debug CLI +1 is added to high before
19950 passing to real fn that does "the work"
19951 (ip_source_and_port_range_check_add_del).
19952 This fn is a wrapper around the binary API fn a
19953 control plane will call, which expects this increment
19954 to have occurred. Hence letting the binary API control
19955 plane fn do the increment for consistency between VAT
19956 and other control planes.
19959 vec_add1 (low_ports, this_low);
19960 vec_add1 (high_ports, this_hi);
19966 if (prefix_set == 0)
19968 errmsg ("<address>/<mask> not specified");
19974 errmsg ("VRF ID required, not specified");
19981 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
19985 if (vec_len (low_ports) == 0)
19987 errmsg ("At least one port or port range required");
19991 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
19993 mp->is_add = is_add;
19995 clib_memcpy (&mp->prefix, &prefix, sizeof (prefix));
19997 mp->number_of_ranges = vec_len (low_ports);
19999 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
20000 vec_free (low_ports);
20002 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
20003 vec_free (high_ports);
20005 mp->vrf_id = ntohl (vrf_id);
20013 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
20015 unformat_input_t *input = vam->input;
20016 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
20017 u32 sw_if_index = ~0;
20019 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
20020 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
20024 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20026 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20028 else if (unformat (input, "sw_if_index %d", &sw_if_index))
20030 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
20032 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
20034 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
20036 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
20038 else if (unformat (input, "del"))
20044 if (sw_if_index == ~0)
20046 errmsg ("Interface required but not specified");
20052 errmsg ("VRF ID required but not specified");
20056 if (tcp_out_vrf_id == 0
20057 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
20060 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
20064 /* Construct the API message */
20065 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
20067 mp->sw_if_index = ntohl (sw_if_index);
20068 mp->is_add = is_add;
20069 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
20070 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
20071 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
20072 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
20077 /* Wait for a reply... */
20083 api_set_punt (vat_main_t * vam)
20085 unformat_input_t *i = vam->input;
20086 vl_api_address_family_t af;
20087 vl_api_set_punt_t *mp;
20093 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20095 if (unformat (i, "%U", unformat_vl_api_address_family, &af))
20097 else if (unformat (i, "protocol %d", &protocol))
20099 else if (unformat (i, "port %d", &port))
20101 else if (unformat (i, "del"))
20105 clib_warning ("parse error '%U'", format_unformat_error, i);
20112 mp->is_add = (u8) is_add;
20113 mp->punt.type = PUNT_API_TYPE_L4;
20114 mp->punt.punt.l4.af = af;
20115 mp->punt.punt.l4.protocol = (u8) protocol;
20116 mp->punt.punt.l4.port = htons ((u16) port);
20124 api_delete_subif (vat_main_t * vam)
20126 unformat_input_t *i = vam->input;
20127 vl_api_delete_subif_t *mp;
20128 u32 sw_if_index = ~0;
20131 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20133 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20135 if (unformat (i, "sw_if_index %d", &sw_if_index))
20141 if (sw_if_index == ~0)
20143 errmsg ("missing sw_if_index");
20147 /* Construct the API message */
20148 M (DELETE_SUBIF, mp);
20149 mp->sw_if_index = ntohl (sw_if_index);
20156 #define foreach_pbb_vtr_op \
20157 _("disable", L2_VTR_DISABLED) \
20158 _("pop", L2_VTR_POP_2) \
20159 _("push", L2_VTR_PUSH_2)
20162 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
20164 unformat_input_t *i = vam->input;
20165 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
20166 u32 sw_if_index = ~0, vtr_op = ~0;
20167 u16 outer_tag = ~0;
20168 u8 dmac[6], smac[6];
20169 u8 dmac_set = 0, smac_set = 0;
20175 /* Shut up coverity */
20176 clib_memset (dmac, 0, sizeof (dmac));
20177 clib_memset (smac, 0, sizeof (smac));
20179 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20181 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20183 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20185 else if (unformat (i, "vtr_op %d", &vtr_op))
20187 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
20190 else if (unformat (i, "translate_pbb_stag"))
20192 if (unformat (i, "%d", &tmp))
20194 vtr_op = L2_VTR_TRANSLATE_2_1;
20200 ("translate_pbb_stag operation requires outer tag definition");
20204 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
20206 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
20208 else if (unformat (i, "sid %d", &sid))
20210 else if (unformat (i, "vlanid %d", &tmp))
20214 clib_warning ("parse error '%U'", format_unformat_error, i);
20219 if ((sw_if_index == ~0) || (vtr_op == ~0))
20221 errmsg ("missing sw_if_index or vtr operation");
20224 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
20225 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
20228 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
20232 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
20233 mp->sw_if_index = ntohl (sw_if_index);
20234 mp->vtr_op = ntohl (vtr_op);
20235 mp->outer_tag = ntohs (outer_tag);
20236 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
20237 clib_memcpy (mp->b_smac, smac, sizeof (smac));
20238 mp->b_vlanid = ntohs (vlanid);
20239 mp->i_sid = ntohl (sid);
20247 api_flow_classify_set_interface (vat_main_t * vam)
20249 unformat_input_t *i = vam->input;
20250 vl_api_flow_classify_set_interface_t *mp;
20252 int sw_if_index_set;
20253 u32 ip4_table_index = ~0;
20254 u32 ip6_table_index = ~0;
20258 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20260 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20261 sw_if_index_set = 1;
20262 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20263 sw_if_index_set = 1;
20264 else if (unformat (i, "del"))
20266 else if (unformat (i, "ip4-table %d", &ip4_table_index))
20268 else if (unformat (i, "ip6-table %d", &ip6_table_index))
20272 clib_warning ("parse error '%U'", format_unformat_error, i);
20277 if (sw_if_index_set == 0)
20279 errmsg ("missing interface name or sw_if_index");
20283 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
20285 mp->sw_if_index = ntohl (sw_if_index);
20286 mp->ip4_table_index = ntohl (ip4_table_index);
20287 mp->ip6_table_index = ntohl (ip6_table_index);
20288 mp->is_add = is_add;
20296 api_flow_classify_dump (vat_main_t * vam)
20298 unformat_input_t *i = vam->input;
20299 vl_api_flow_classify_dump_t *mp;
20300 vl_api_control_ping_t *mp_ping;
20301 u8 type = FLOW_CLASSIFY_N_TABLES;
20304 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
20308 errmsg ("classify table type must be specified");
20312 if (!vam->json_output)
20314 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
20317 M (FLOW_CLASSIFY_DUMP, mp);
20322 /* Use a control ping for synchronization */
20323 MPING (CONTROL_PING, mp_ping);
20326 /* Wait for a reply... */
20332 api_feature_enable_disable (vat_main_t * vam)
20334 unformat_input_t *i = vam->input;
20335 vl_api_feature_enable_disable_t *mp;
20337 u8 *feature_name = 0;
20338 u32 sw_if_index = ~0;
20342 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20344 if (unformat (i, "arc_name %s", &arc_name))
20346 else if (unformat (i, "feature_name %s", &feature_name))
20349 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20351 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20353 else if (unformat (i, "disable"))
20361 errmsg ("missing arc name");
20364 if (vec_len (arc_name) > 63)
20366 errmsg ("arc name too long");
20369 if (feature_name == 0)
20371 errmsg ("missing feature name");
20374 if (vec_len (feature_name) > 63)
20376 errmsg ("feature name too long");
20379 if (sw_if_index == ~0)
20381 errmsg ("missing interface name or sw_if_index");
20385 /* Construct the API message */
20386 M (FEATURE_ENABLE_DISABLE, mp);
20387 mp->sw_if_index = ntohl (sw_if_index);
20388 mp->enable = enable;
20389 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
20390 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
20391 vec_free (arc_name);
20392 vec_free (feature_name);
20400 api_sw_interface_tag_add_del (vat_main_t * vam)
20402 unformat_input_t *i = vam->input;
20403 vl_api_sw_interface_tag_add_del_t *mp;
20404 u32 sw_if_index = ~0;
20409 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20411 if (unformat (i, "tag %s", &tag))
20413 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20415 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20417 else if (unformat (i, "del"))
20423 if (sw_if_index == ~0)
20425 errmsg ("missing interface name or sw_if_index");
20429 if (enable && (tag == 0))
20431 errmsg ("no tag specified");
20435 /* Construct the API message */
20436 M (SW_INTERFACE_TAG_ADD_DEL, mp);
20437 mp->sw_if_index = ntohl (sw_if_index);
20438 mp->is_add = enable;
20440 vl_api_to_api_string (strlen ((char *) tag), (char *) tag, &mp->tag);
20448 static void vl_api_l2_xconnect_details_t_handler
20449 (vl_api_l2_xconnect_details_t * mp)
20451 vat_main_t *vam = &vat_main;
20453 print (vam->ofp, "%15d%15d",
20454 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
20457 static void vl_api_l2_xconnect_details_t_handler_json
20458 (vl_api_l2_xconnect_details_t * mp)
20460 vat_main_t *vam = &vat_main;
20461 vat_json_node_t *node = NULL;
20463 if (VAT_JSON_ARRAY != vam->json_tree.type)
20465 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20466 vat_json_init_array (&vam->json_tree);
20468 node = vat_json_array_add (&vam->json_tree);
20470 vat_json_init_object (node);
20471 vat_json_object_add_uint (node, "rx_sw_if_index",
20472 ntohl (mp->rx_sw_if_index));
20473 vat_json_object_add_uint (node, "tx_sw_if_index",
20474 ntohl (mp->tx_sw_if_index));
20478 api_l2_xconnect_dump (vat_main_t * vam)
20480 vl_api_l2_xconnect_dump_t *mp;
20481 vl_api_control_ping_t *mp_ping;
20484 if (!vam->json_output)
20486 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
20489 M (L2_XCONNECT_DUMP, mp);
20493 /* Use a control ping for synchronization */
20494 MPING (CONTROL_PING, mp_ping);
20502 api_hw_interface_set_mtu (vat_main_t * vam)
20504 unformat_input_t *i = vam->input;
20505 vl_api_hw_interface_set_mtu_t *mp;
20506 u32 sw_if_index = ~0;
20510 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20512 if (unformat (i, "mtu %d", &mtu))
20514 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20516 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20522 if (sw_if_index == ~0)
20524 errmsg ("missing interface name or sw_if_index");
20530 errmsg ("no mtu specified");
20534 /* Construct the API message */
20535 M (HW_INTERFACE_SET_MTU, mp);
20536 mp->sw_if_index = ntohl (sw_if_index);
20537 mp->mtu = ntohs ((u16) mtu);
20545 api_p2p_ethernet_add (vat_main_t * vam)
20547 unformat_input_t *i = vam->input;
20548 vl_api_p2p_ethernet_add_t *mp;
20549 u32 parent_if_index = ~0;
20555 clib_memset (remote_mac, 0, sizeof (remote_mac));
20556 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20558 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
20560 else if (unformat (i, "sw_if_index %d", &parent_if_index))
20564 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
20566 else if (unformat (i, "sub_id %d", &sub_id))
20570 clib_warning ("parse error '%U'", format_unformat_error, i);
20575 if (parent_if_index == ~0)
20577 errmsg ("missing interface name or sw_if_index");
20582 errmsg ("missing remote mac address");
20587 errmsg ("missing sub-interface id");
20591 M (P2P_ETHERNET_ADD, mp);
20592 mp->parent_if_index = ntohl (parent_if_index);
20593 mp->subif_id = ntohl (sub_id);
20594 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
20602 api_p2p_ethernet_del (vat_main_t * vam)
20604 unformat_input_t *i = vam->input;
20605 vl_api_p2p_ethernet_del_t *mp;
20606 u32 parent_if_index = ~0;
20611 clib_memset (remote_mac, 0, sizeof (remote_mac));
20612 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20614 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
20616 else if (unformat (i, "sw_if_index %d", &parent_if_index))
20620 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
20624 clib_warning ("parse error '%U'", format_unformat_error, i);
20629 if (parent_if_index == ~0)
20631 errmsg ("missing interface name or sw_if_index");
20636 errmsg ("missing remote mac address");
20640 M (P2P_ETHERNET_DEL, mp);
20641 mp->parent_if_index = ntohl (parent_if_index);
20642 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
20650 api_lldp_config (vat_main_t * vam)
20652 unformat_input_t *i = vam->input;
20653 vl_api_lldp_config_t *mp;
20655 int tx_interval = 0;
20656 u8 *sys_name = NULL;
20659 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20661 if (unformat (i, "system-name %s", &sys_name))
20663 else if (unformat (i, "tx-hold %d", &tx_hold))
20665 else if (unformat (i, "tx-interval %d", &tx_interval))
20669 clib_warning ("parse error '%U'", format_unformat_error, i);
20674 vec_add1 (sys_name, 0);
20676 M (LLDP_CONFIG, mp);
20677 mp->tx_hold = htonl (tx_hold);
20678 mp->tx_interval = htonl (tx_interval);
20679 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
20680 vec_free (sys_name);
20688 api_sw_interface_set_lldp (vat_main_t * vam)
20690 unformat_input_t *i = vam->input;
20691 vl_api_sw_interface_set_lldp_t *mp;
20692 u32 sw_if_index = ~0;
20694 u8 *port_desc = NULL, *mgmt_oid = NULL;
20695 ip4_address_t ip4_addr;
20696 ip6_address_t ip6_addr;
20699 clib_memset (&ip4_addr, 0, sizeof (ip4_addr));
20700 clib_memset (&ip6_addr, 0, sizeof (ip6_addr));
20702 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20704 if (unformat (i, "disable"))
20707 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20709 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20711 else if (unformat (i, "port-desc %s", &port_desc))
20713 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
20715 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
20717 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
20723 if (sw_if_index == ~0)
20725 errmsg ("missing interface name or sw_if_index");
20729 /* Construct the API message */
20730 vec_add1 (port_desc, 0);
20731 vec_add1 (mgmt_oid, 0);
20732 M (SW_INTERFACE_SET_LLDP, mp);
20733 mp->sw_if_index = ntohl (sw_if_index);
20734 mp->enable = enable;
20735 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
20736 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
20737 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
20738 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
20739 vec_free (port_desc);
20740 vec_free (mgmt_oid);
20748 api_tcp_configure_src_addresses (vat_main_t * vam)
20750 vl_api_tcp_configure_src_addresses_t *mp;
20751 unformat_input_t *i = vam->input;
20752 ip4_address_t v4first, v4last;
20753 ip6_address_t v6first, v6last;
20758 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20760 if (unformat (i, "%U - %U",
20761 unformat_ip4_address, &v4first,
20762 unformat_ip4_address, &v4last))
20766 errmsg ("one range per message (range already set)");
20771 else if (unformat (i, "%U - %U",
20772 unformat_ip6_address, &v6first,
20773 unformat_ip6_address, &v6last))
20777 errmsg ("one range per message (range already set)");
20782 else if (unformat (i, "vrf %d", &vrf_id))
20788 if (range_set == 0)
20790 errmsg ("address range not set");
20794 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
20795 mp->vrf_id = ntohl (vrf_id);
20797 if (range_set == 2)
20800 clib_memcpy (mp->first_address, &v6first, sizeof (v6first));
20801 clib_memcpy (mp->last_address, &v6last, sizeof (v6last));
20806 clib_memcpy (mp->first_address, &v4first, sizeof (v4first));
20807 clib_memcpy (mp->last_address, &v4last, sizeof (v4last));
20814 static void vl_api_app_namespace_add_del_reply_t_handler
20815 (vl_api_app_namespace_add_del_reply_t * mp)
20817 vat_main_t *vam = &vat_main;
20818 i32 retval = ntohl (mp->retval);
20819 if (vam->async_mode)
20821 vam->async_errors += (retval < 0);
20825 vam->retval = retval;
20827 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
20828 vam->result_ready = 1;
20832 static void vl_api_app_namespace_add_del_reply_t_handler_json
20833 (vl_api_app_namespace_add_del_reply_t * mp)
20835 vat_main_t *vam = &vat_main;
20836 vat_json_node_t node;
20838 vat_json_init_object (&node);
20839 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
20840 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
20842 vat_json_print (vam->ofp, &node);
20843 vat_json_free (&node);
20845 vam->retval = ntohl (mp->retval);
20846 vam->result_ready = 1;
20850 api_app_namespace_add_del (vat_main_t * vam)
20852 vl_api_app_namespace_add_del_t *mp;
20853 unformat_input_t *i = vam->input;
20854 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
20855 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
20859 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20861 if (unformat (i, "id %_%v%_", &ns_id))
20863 else if (unformat (i, "secret %lu", &secret))
20865 else if (unformat (i, "sw_if_index %d", &sw_if_index))
20866 sw_if_index_set = 1;
20867 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
20869 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
20874 if (!ns_id || !secret_set || !sw_if_index_set)
20876 errmsg ("namespace id, secret and sw_if_index must be set");
20879 if (vec_len (ns_id) > 64)
20881 errmsg ("namespace id too long");
20884 M (APP_NAMESPACE_ADD_DEL, mp);
20886 clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
20887 mp->namespace_id_len = vec_len (ns_id);
20888 mp->secret = clib_host_to_net_u64 (secret);
20889 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
20890 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
20891 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
20899 api_sock_init_shm (vat_main_t * vam)
20901 #if VPP_API_TEST_BUILTIN == 0
20902 unformat_input_t *i = vam->input;
20903 vl_api_shm_elem_config_t *config = 0;
20904 u64 size = 64 << 20;
20907 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20909 if (unformat (i, "size %U", unformat_memory_size, &size))
20916 * Canned custom ring allocator config.
20917 * Should probably parse all of this
20919 vec_validate (config, 6);
20920 config[0].type = VL_API_VLIB_RING;
20921 config[0].size = 256;
20922 config[0].count = 32;
20924 config[1].type = VL_API_VLIB_RING;
20925 config[1].size = 1024;
20926 config[1].count = 16;
20928 config[2].type = VL_API_VLIB_RING;
20929 config[2].size = 4096;
20930 config[2].count = 2;
20932 config[3].type = VL_API_CLIENT_RING;
20933 config[3].size = 256;
20934 config[3].count = 32;
20936 config[4].type = VL_API_CLIENT_RING;
20937 config[4].size = 1024;
20938 config[4].count = 16;
20940 config[5].type = VL_API_CLIENT_RING;
20941 config[5].size = 4096;
20942 config[5].count = 2;
20944 config[6].type = VL_API_QUEUE;
20945 config[6].count = 128;
20946 config[6].size = sizeof (uword);
20948 rv = vl_socket_client_init_shm (config, 1 /* want_pthread */ );
20950 vam->client_index_invalid = 1;
20958 api_dns_enable_disable (vat_main_t * vam)
20960 unformat_input_t *line_input = vam->input;
20961 vl_api_dns_enable_disable_t *mp;
20962 u8 enable_disable = 1;
20965 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
20967 if (unformat (line_input, "disable"))
20968 enable_disable = 0;
20969 if (unformat (line_input, "enable"))
20970 enable_disable = 1;
20975 /* Construct the API message */
20976 M (DNS_ENABLE_DISABLE, mp);
20977 mp->enable = enable_disable;
20981 /* Wait for the reply */
20987 api_dns_resolve_name (vat_main_t * vam)
20989 unformat_input_t *line_input = vam->input;
20990 vl_api_dns_resolve_name_t *mp;
20994 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
20996 if (unformat (line_input, "%s", &name))
21002 if (vec_len (name) > 127)
21004 errmsg ("name too long");
21008 /* Construct the API message */
21009 M (DNS_RESOLVE_NAME, mp);
21010 memcpy (mp->name, name, vec_len (name));
21015 /* Wait for the reply */
21021 api_dns_resolve_ip (vat_main_t * vam)
21023 unformat_input_t *line_input = vam->input;
21024 vl_api_dns_resolve_ip_t *mp;
21026 ip4_address_t addr4;
21027 ip6_address_t addr6;
21030 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21032 if (unformat (line_input, "%U", unformat_ip6_address, &addr6))
21034 else if (unformat (line_input, "%U", unformat_ip4_address, &addr4))
21042 errmsg ("missing address");
21046 /* Construct the API message */
21047 M (DNS_RESOLVE_IP, mp);
21048 mp->is_ip6 = is_ip6;
21050 memcpy (mp->address, &addr6, sizeof (addr6));
21052 memcpy (mp->address, &addr4, sizeof (addr4));
21056 /* Wait for the reply */
21062 api_dns_name_server_add_del (vat_main_t * vam)
21064 unformat_input_t *i = vam->input;
21065 vl_api_dns_name_server_add_del_t *mp;
21067 ip6_address_t ip6_server;
21068 ip4_address_t ip4_server;
21073 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21075 if (unformat (i, "%U", unformat_ip6_address, &ip6_server))
21077 else if (unformat (i, "%U", unformat_ip4_address, &ip4_server))
21079 else if (unformat (i, "del"))
21083 clib_warning ("parse error '%U'", format_unformat_error, i);
21088 if (ip4_set && ip6_set)
21090 errmsg ("Only one server address allowed per message");
21093 if ((ip4_set + ip6_set) == 0)
21095 errmsg ("Server address required");
21099 /* Construct the API message */
21100 M (DNS_NAME_SERVER_ADD_DEL, mp);
21104 memcpy (mp->server_address, &ip6_server, sizeof (ip6_address_t));
21109 memcpy (mp->server_address, &ip4_server, sizeof (ip4_address_t));
21113 mp->is_add = is_add;
21118 /* Wait for a reply, return good/bad news */
21124 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
21126 vat_main_t *vam = &vat_main;
21131 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
21132 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
21133 mp->scope, format_ip4_address, &mp->lcl_ip, mp->lcl_plen,
21134 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
21135 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
21136 clib_net_to_host_u32 (mp->action_index), mp->tag);
21141 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
21142 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
21143 mp->scope, format_ip6_address, &mp->lcl_ip, mp->lcl_plen,
21144 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
21145 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
21146 clib_net_to_host_u32 (mp->action_index), mp->tag);
21151 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
21154 vat_main_t *vam = &vat_main;
21155 vat_json_node_t *node = NULL;
21156 struct in6_addr ip6;
21157 struct in_addr ip4;
21159 if (VAT_JSON_ARRAY != vam->json_tree.type)
21161 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
21162 vat_json_init_array (&vam->json_tree);
21164 node = vat_json_array_add (&vam->json_tree);
21165 vat_json_init_object (node);
21167 vat_json_object_add_uint (node, "is_ip4", mp->is_ip4 ? 1 : 0);
21168 vat_json_object_add_uint (node, "appns_index",
21169 clib_net_to_host_u32 (mp->appns_index));
21170 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
21171 vat_json_object_add_uint (node, "scope", mp->scope);
21172 vat_json_object_add_uint (node, "action_index",
21173 clib_net_to_host_u32 (mp->action_index));
21174 vat_json_object_add_uint (node, "lcl_port",
21175 clib_net_to_host_u16 (mp->lcl_port));
21176 vat_json_object_add_uint (node, "rmt_port",
21177 clib_net_to_host_u16 (mp->rmt_port));
21178 vat_json_object_add_uint (node, "lcl_plen", mp->lcl_plen);
21179 vat_json_object_add_uint (node, "rmt_plen", mp->rmt_plen);
21180 vat_json_object_add_string_copy (node, "tag", mp->tag);
21183 clib_memcpy (&ip4, mp->lcl_ip, sizeof (ip4));
21184 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
21185 clib_memcpy (&ip4, mp->rmt_ip, sizeof (ip4));
21186 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
21190 clib_memcpy (&ip6, mp->lcl_ip, sizeof (ip6));
21191 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
21192 clib_memcpy (&ip6, mp->rmt_ip, sizeof (ip6));
21193 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
21198 api_session_rule_add_del (vat_main_t * vam)
21200 vl_api_session_rule_add_del_t *mp;
21201 unformat_input_t *i = vam->input;
21202 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
21203 u32 appns_index = 0, scope = 0;
21204 ip4_address_t lcl_ip4, rmt_ip4;
21205 ip6_address_t lcl_ip6, rmt_ip6;
21206 u8 is_ip4 = 1, conn_set = 0;
21207 u8 is_add = 1, *tag = 0;
21210 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21212 if (unformat (i, "del"))
21214 else if (unformat (i, "add"))
21216 else if (unformat (i, "proto tcp"))
21218 else if (unformat (i, "proto udp"))
21220 else if (unformat (i, "appns %d", &appns_index))
21222 else if (unformat (i, "scope %d", &scope))
21224 else if (unformat (i, "tag %_%v%_", &tag))
21228 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
21229 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
21237 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
21238 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
21244 else if (unformat (i, "action %d", &action))
21249 if (proto == ~0 || !conn_set || action == ~0)
21251 errmsg ("transport proto, connection and action must be set");
21257 errmsg ("scope should be 0-3");
21261 M (SESSION_RULE_ADD_DEL, mp);
21263 mp->is_ip4 = is_ip4;
21264 mp->transport_proto = proto;
21265 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
21266 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
21267 mp->lcl_plen = lcl_plen;
21268 mp->rmt_plen = rmt_plen;
21269 mp->action_index = clib_host_to_net_u32 (action);
21270 mp->appns_index = clib_host_to_net_u32 (appns_index);
21272 mp->is_add = is_add;
21275 clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
21276 clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
21280 clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
21281 clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
21285 clib_memcpy (mp->tag, tag, vec_len (tag));
21295 api_session_rules_dump (vat_main_t * vam)
21297 vl_api_session_rules_dump_t *mp;
21298 vl_api_control_ping_t *mp_ping;
21301 if (!vam->json_output)
21303 print (vam->ofp, "%=20s", "Session Rules");
21306 M (SESSION_RULES_DUMP, mp);
21310 /* Use a control ping for synchronization */
21311 MPING (CONTROL_PING, mp_ping);
21314 /* Wait for a reply... */
21320 api_ip_container_proxy_add_del (vat_main_t * vam)
21322 vl_api_ip_container_proxy_add_del_t *mp;
21323 unformat_input_t *i = vam->input;
21324 u32 sw_if_index = ~0;
21325 vl_api_prefix_t pfx = { };
21329 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21331 if (unformat (i, "del"))
21333 else if (unformat (i, "add"))
21335 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
21337 else if (unformat (i, "sw_if_index %u", &sw_if_index))
21342 if (sw_if_index == ~0 || pfx.len == 0)
21344 errmsg ("address and sw_if_index must be set");
21348 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
21350 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
21351 mp->is_add = is_add;
21352 clib_memcpy (&mp->pfx, &pfx, sizeof (pfx));
21360 api_qos_record_enable_disable (vat_main_t * vam)
21362 unformat_input_t *i = vam->input;
21363 vl_api_qos_record_enable_disable_t *mp;
21364 u32 sw_if_index, qs = 0xff;
21365 u8 sw_if_index_set = 0;
21369 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21371 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21372 sw_if_index_set = 1;
21373 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21374 sw_if_index_set = 1;
21375 else if (unformat (i, "%U", unformat_qos_source, &qs))
21377 else if (unformat (i, "disable"))
21381 clib_warning ("parse error '%U'", format_unformat_error, i);
21386 if (sw_if_index_set == 0)
21388 errmsg ("missing interface name or sw_if_index");
21393 errmsg ("input location must be specified");
21397 M (QOS_RECORD_ENABLE_DISABLE, mp);
21399 mp->record.sw_if_index = ntohl (sw_if_index);
21400 mp->record.input_source = qs;
21401 mp->enable = enable;
21410 q_or_quit (vat_main_t * vam)
21412 #if VPP_API_TEST_BUILTIN == 0
21413 longjmp (vam->jump_buf, 1);
21415 return 0; /* not so much */
21419 q (vat_main_t * vam)
21421 return q_or_quit (vam);
21425 quit (vat_main_t * vam)
21427 return q_or_quit (vam);
21431 comment (vat_main_t * vam)
21437 elog_save (vat_main_t * vam)
21439 #if VPP_API_TEST_BUILTIN == 0
21440 elog_main_t *em = &vam->elog_main;
21441 unformat_input_t *i = vam->input;
21442 char *file, *chroot_file;
21443 clib_error_t *error;
21445 if (!unformat (i, "%s", &file))
21447 errmsg ("expected file name, got `%U'", format_unformat_error, i);
21451 /* It's fairly hard to get "../oopsie" through unformat; just in case */
21452 if (strstr (file, "..") || index (file, '/'))
21454 errmsg ("illegal characters in filename '%s'", file);
21458 chroot_file = (char *) format (0, "/tmp/%s%c", file, 0);
21462 errmsg ("Saving %wd of %wd events to %s",
21463 elog_n_events_in_buffer (em),
21464 elog_buffer_capacity (em), chroot_file);
21466 error = elog_write_file (em, chroot_file, 1 /* flush ring */ );
21467 vec_free (chroot_file);
21470 clib_error_report (error);
21472 errmsg ("Use the vpp event loger...");
21479 elog_setup (vat_main_t * vam)
21481 #if VPP_API_TEST_BUILTIN == 0
21482 elog_main_t *em = &vam->elog_main;
21483 unformat_input_t *i = vam->input;
21484 u32 nevents = 128 << 10;
21486 (void) unformat (i, "nevents %d", &nevents);
21488 elog_init (em, nevents);
21489 vl_api_set_elog_main (em);
21490 vl_api_set_elog_trace_api_messages (1);
21491 errmsg ("Event logger initialized with %u events", nevents);
21493 errmsg ("Use the vpp event loger...");
21499 elog_enable (vat_main_t * vam)
21501 #if VPP_API_TEST_BUILTIN == 0
21502 elog_main_t *em = &vam->elog_main;
21504 elog_enable_disable (em, 1 /* enable */ );
21505 vl_api_set_elog_trace_api_messages (1);
21506 errmsg ("Event logger enabled...");
21508 errmsg ("Use the vpp event loger...");
21514 elog_disable (vat_main_t * vam)
21516 #if VPP_API_TEST_BUILTIN == 0
21517 elog_main_t *em = &vam->elog_main;
21519 elog_enable_disable (em, 0 /* enable */ );
21520 vl_api_set_elog_trace_api_messages (1);
21521 errmsg ("Event logger disabled...");
21523 errmsg ("Use the vpp event loger...");
21529 statseg (vat_main_t * vam)
21531 ssvm_private_t *ssvmp = &vam->stat_segment;
21532 ssvm_shared_header_t *shared_header = ssvmp->sh;
21533 vlib_counter_t **counters;
21534 u64 thread0_index1_packets;
21535 u64 thread0_index1_bytes;
21536 f64 vector_rate, input_rate;
21539 uword *counter_vector_by_name;
21540 if (vam->stat_segment_lockp == 0)
21542 errmsg ("Stat segment not mapped...");
21546 /* look up "/if/rx for sw_if_index 1 as a test */
21548 clib_spinlock_lock (vam->stat_segment_lockp);
21550 counter_vector_by_name = (uword *) shared_header->opaque[1];
21552 p = hash_get_mem (counter_vector_by_name, "/if/rx");
21555 clib_spinlock_unlock (vam->stat_segment_lockp);
21556 errmsg ("/if/tx not found?");
21560 /* Fish per-thread vector of combined counters from shared memory */
21561 counters = (vlib_counter_t **) p[0];
21563 if (vec_len (counters[0]) < 2)
21565 clib_spinlock_unlock (vam->stat_segment_lockp);
21566 errmsg ("/if/tx vector length %d", vec_len (counters[0]));
21570 /* Read thread 0 sw_if_index 1 counter */
21571 thread0_index1_packets = counters[0][1].packets;
21572 thread0_index1_bytes = counters[0][1].bytes;
21574 p = hash_get_mem (counter_vector_by_name, "vector_rate");
21577 clib_spinlock_unlock (vam->stat_segment_lockp);
21578 errmsg ("vector_rate not found?");
21582 vector_rate = *(f64 *) (p[0]);
21583 p = hash_get_mem (counter_vector_by_name, "input_rate");
21586 clib_spinlock_unlock (vam->stat_segment_lockp);
21587 errmsg ("input_rate not found?");
21590 input_rate = *(f64 *) (p[0]);
21592 clib_spinlock_unlock (vam->stat_segment_lockp);
21594 print (vam->ofp, "vector_rate %.2f input_rate %.2f",
21595 vector_rate, input_rate);
21596 print (vam->ofp, "thread 0 sw_if_index 1 rx pkts %lld, bytes %lld",
21597 thread0_index1_packets, thread0_index1_bytes);
21603 cmd_cmp (void *a1, void *a2)
21608 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
21612 help (vat_main_t * vam)
21617 unformat_input_t *i = vam->input;
21620 if (unformat (i, "%s", &name))
21624 vec_add1 (name, 0);
21626 hs = hash_get_mem (vam->help_by_name, name);
21628 print (vam->ofp, "usage: %s %s", name, hs[0]);
21630 print (vam->ofp, "No such msg / command '%s'", name);
21635 print (vam->ofp, "Help is available for the following:");
21638 hash_foreach_pair (p, vam->function_by_name,
21640 vec_add1 (cmds, (u8 *)(p->key));
21644 vec_sort_with_function (cmds, cmd_cmp);
21646 for (j = 0; j < vec_len (cmds); j++)
21647 print (vam->ofp, "%s", cmds[j]);
21654 set (vat_main_t * vam)
21656 u8 *name = 0, *value = 0;
21657 unformat_input_t *i = vam->input;
21659 if (unformat (i, "%s", &name))
21661 /* The input buffer is a vector, not a string. */
21662 value = vec_dup (i->buffer);
21663 vec_delete (value, i->index, 0);
21664 /* Almost certainly has a trailing newline */
21665 if (value[vec_len (value) - 1] == '\n')
21666 value[vec_len (value) - 1] = 0;
21667 /* Make sure it's a proper string, one way or the other */
21668 vec_add1 (value, 0);
21669 (void) clib_macro_set_value (&vam->macro_main,
21670 (char *) name, (char *) value);
21673 errmsg ("usage: set <name> <value>");
21681 unset (vat_main_t * vam)
21685 if (unformat (vam->input, "%s", &name))
21686 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
21687 errmsg ("unset: %s wasn't set", name);
21700 macro_sort_cmp (void *a1, void *a2)
21702 macro_sort_t *s1 = a1;
21703 macro_sort_t *s2 = a2;
21705 return strcmp ((char *) (s1->name), (char *) (s2->name));
21709 dump_macro_table (vat_main_t * vam)
21711 macro_sort_t *sort_me = 0, *sm;
21716 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
21718 vec_add2 (sort_me, sm, 1);
21719 sm->name = (u8 *)(p->key);
21720 sm->value = (u8 *) (p->value[0]);
21724 vec_sort_with_function (sort_me, macro_sort_cmp);
21726 if (vec_len (sort_me))
21727 print (vam->ofp, "%-15s%s", "Name", "Value");
21729 print (vam->ofp, "The macro table is empty...");
21731 for (i = 0; i < vec_len (sort_me); i++)
21732 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
21737 dump_node_table (vat_main_t * vam)
21740 vlib_node_t *node, *next_node;
21742 if (vec_len (vam->graph_nodes) == 0)
21744 print (vam->ofp, "Node table empty, issue get_node_graph...");
21748 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
21750 node = vam->graph_nodes[0][i];
21751 print (vam->ofp, "[%d] %s", i, node->name);
21752 for (j = 0; j < vec_len (node->next_nodes); j++)
21754 if (node->next_nodes[j] != ~0)
21756 next_node = vam->graph_nodes[0][node->next_nodes[j]];
21757 print (vam->ofp, " [%d] %s", j, next_node->name);
21765 value_sort_cmp (void *a1, void *a2)
21767 name_sort_t *n1 = a1;
21768 name_sort_t *n2 = a2;
21770 if (n1->value < n2->value)
21772 if (n1->value > n2->value)
21779 dump_msg_api_table (vat_main_t * vam)
21781 api_main_t *am = &api_main;
21782 name_sort_t *nses = 0, *ns;
21787 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
21789 vec_add2 (nses, ns, 1);
21790 ns->name = (u8 *)(hp->key);
21791 ns->value = (u32) hp->value[0];
21795 vec_sort_with_function (nses, value_sort_cmp);
21797 for (i = 0; i < vec_len (nses); i++)
21798 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
21804 get_msg_id (vat_main_t * vam)
21809 if (unformat (vam->input, "%s", &name_and_crc))
21811 message_index = vl_msg_api_get_msg_index (name_and_crc);
21812 if (message_index == ~0)
21814 print (vam->ofp, " '%s' not found", name_and_crc);
21817 print (vam->ofp, " '%s' has message index %d",
21818 name_and_crc, message_index);
21821 errmsg ("name_and_crc required...");
21826 search_node_table (vat_main_t * vam)
21828 unformat_input_t *line_input = vam->input;
21831 vlib_node_t *node, *next_node;
21834 if (vam->graph_node_index_by_name == 0)
21836 print (vam->ofp, "Node table empty, issue get_node_graph...");
21840 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21842 if (unformat (line_input, "%s", &node_to_find))
21844 vec_add1 (node_to_find, 0);
21845 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
21848 print (vam->ofp, "%s not found...", node_to_find);
21851 node = vam->graph_nodes[0][p[0]];
21852 print (vam->ofp, "[%d] %s", p[0], node->name);
21853 for (j = 0; j < vec_len (node->next_nodes); j++)
21855 if (node->next_nodes[j] != ~0)
21857 next_node = vam->graph_nodes[0][node->next_nodes[j]];
21858 print (vam->ofp, " [%d] %s", j, next_node->name);
21865 clib_warning ("parse error '%U'", format_unformat_error,
21871 vec_free (node_to_find);
21880 script (vat_main_t * vam)
21882 #if (VPP_API_TEST_BUILTIN==0)
21884 char *save_current_file;
21885 unformat_input_t save_input;
21886 jmp_buf save_jump_buf;
21887 u32 save_line_number;
21889 FILE *new_fp, *save_ifp;
21891 if (unformat (vam->input, "%s", &s))
21893 new_fp = fopen ((char *) s, "r");
21896 errmsg ("Couldn't open script file %s", s);
21903 errmsg ("Missing script name");
21907 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
21908 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
21909 save_ifp = vam->ifp;
21910 save_line_number = vam->input_line_number;
21911 save_current_file = (char *) vam->current_file;
21913 vam->input_line_number = 0;
21915 vam->current_file = s;
21918 clib_memcpy (&vam->input, &save_input, sizeof (save_input));
21919 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
21920 vam->ifp = save_ifp;
21921 vam->input_line_number = save_line_number;
21922 vam->current_file = (u8 *) save_current_file;
21927 clib_warning ("use the exec command...");
21933 echo (vat_main_t * vam)
21935 print (vam->ofp, "%v", vam->input->buffer);
21939 /* List of API message constructors, CLI names map to api_xxx */
21940 #define foreach_vpe_api_msg \
21941 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
21942 _(sw_interface_dump,"") \
21943 _(sw_interface_set_flags, \
21944 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
21945 _(sw_interface_add_del_address, \
21946 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
21947 _(sw_interface_set_rx_mode, \
21948 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
21949 _(sw_interface_set_rx_placement, \
21950 "<intfc> | sw_if_index <id> [queue <id>] [worker <id> | main]") \
21951 _(sw_interface_rx_placement_dump, \
21952 "[<intfc> | sw_if_index <id>]") \
21953 _(sw_interface_set_table, \
21954 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
21955 _(sw_interface_set_mpls_enable, \
21956 "<intfc> | sw_if_index [disable | dis]") \
21957 _(sw_interface_set_vpath, \
21958 "<intfc> | sw_if_index <id> enable | disable") \
21959 _(sw_interface_set_vxlan_bypass, \
21960 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
21961 _(sw_interface_set_geneve_bypass, \
21962 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
21963 _(sw_interface_set_l2_xconnect, \
21964 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
21965 "enable | disable") \
21966 _(sw_interface_set_l2_bridge, \
21967 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
21968 "[shg <split-horizon-group>] [bvi]\n" \
21969 "enable | disable") \
21970 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
21971 _(bridge_domain_add_del, \
21972 "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") \
21973 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
21975 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
21976 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
21977 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
21979 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
21981 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
21983 "id <num> [hw-addr <mac-addr>] [host-ns <name>] [rx-ring-size <num> [tx-ring-size <num>] [host-mtu-size <mtu>] [gso | no-gso]") \
21985 "<vpp-if-name> | sw_if_index <id>") \
21986 _(sw_interface_tap_v2_dump, "") \
21987 _(virtio_pci_create, \
21988 "pci-addr <pci-address> [use_random_mac | hw-addr <mac-addr>] [features <hex-value>] [gso-enabled]") \
21989 _(virtio_pci_delete, \
21990 "<vpp-if-name> | sw_if_index <id>") \
21991 _(sw_interface_virtio_pci_dump, "") \
21993 "[hw-addr <mac-addr>] {round-robin | active-backup | " \
21994 "broadcast | {lacp | xor} [load-balance { l2 | l23 | l34 }]} " \
21997 "<vpp-if-name> | sw_if_index <id>") \
21999 "sw_if_index <n> bond <sw_if_index> [is_passive] [is_long_timeout]") \
22000 _(bond_detach_slave, \
22001 "sw_if_index <n>") \
22002 _(sw_interface_bond_dump, "") \
22003 _(sw_interface_slave_dump, \
22004 "<vpp-if-name> | sw_if_index <id>") \
22005 _(ip_table_add_del, \
22006 "table <n> [ipv6] [add | del]\n") \
22007 _(ip_route_add_del, \
22008 "<addr>/<mask> via <<addr>|<intfc>|sw_if_index <id>|via-label <n>>\n" \
22009 "[table-id <n>] [<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n"\
22010 "[weight <n>] [drop] [local] [classify <n>] [out-label <n>]\n" \
22011 "[multipath] [count <n>] [del]") \
22012 _(ip_mroute_add_del, \
22013 "<src> <grp>/<mask> [table-id <n>]\n" \
22014 "[<intfc> | sw_if_index <id>] [local] [del]") \
22015 _(mpls_table_add_del, \
22016 "table <n> [add | del]\n") \
22017 _(mpls_route_add_del, \
22018 "<label> <eos> via <addr | next-hop-table <n> | via-label <n> |\n" \
22019 "lookup-ip4-table <n> | lookup-in-ip6-table <n> |\n" \
22020 "l2-input-on <intfc> | l2-input-on sw_if_index <id>>\n" \
22021 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>] [weight <n>]\n" \
22022 "[drop] [local] [classify <n>] [out-label <n>] [multipath]\n" \
22023 "[count <n>] [del]") \
22024 _(mpls_ip_bind_unbind, \
22025 "<label> <addr/len>") \
22026 _(mpls_tunnel_add_del, \
22027 "[add | del <intfc | sw_if_index <id>>] via <addr | via-label <n>>\n" \
22028 "[<intfc> | sw_if_index <id> | next-hop-table <id>]\n" \
22029 "[l2-only] [out-label <n>]") \
22030 _(sr_mpls_policy_add, \
22031 "bsid <id> [weight <n>] [spray] next <sid> [next <sid>]") \
22032 _(sr_mpls_policy_del, \
22034 _(bier_table_add_del, \
22035 "<label> <sub-domain> <set> <bsl> [del]") \
22036 _(bier_route_add_del, \
22037 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
22038 "[<intfc> | sw_if_index <id>]" \
22039 "[weight <n>] [del] [multipath]") \
22040 _(proxy_arp_add_del, \
22041 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
22042 _(proxy_arp_intfc_enable_disable, \
22043 "<intfc> | sw_if_index <id> enable | disable") \
22044 _(sw_interface_set_unnumbered, \
22045 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
22046 _(ip_neighbor_add_del, \
22047 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
22048 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
22049 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
22050 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
22051 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
22052 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
22053 "[outer_vlan_id_any][inner_vlan_id_any]") \
22054 _(reset_fib, "vrf <n> [ipv6]") \
22055 _(dhcp_proxy_config, \
22056 "svr <v46-address> src <v46-address>\n" \
22057 "rx_vrf_id <nn> server_vrf_id <nn> [del]") \
22058 _(dhcp_proxy_set_vss, \
22059 "tbl_id <n> [fib_id <n> oui <n> | vpn_ascii_id <text>] [ipv6] [del]") \
22060 _(dhcp_proxy_dump, "ip6") \
22061 _(dhcp_client_config, \
22062 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
22063 _(set_ip_flow_hash, \
22064 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
22065 _(sw_interface_ip6_enable_disable, \
22066 "<intfc> | sw_if_index <id> enable | disable") \
22067 _(ip6nd_proxy_add_del, \
22068 "<intfc> | sw_if_index <id> <ip6-address>") \
22069 _(ip6nd_proxy_dump, "") \
22070 _(sw_interface_ip6nd_ra_prefix, \
22071 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
22072 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
22073 "[nolink] [isno]") \
22074 _(sw_interface_ip6nd_ra_config, \
22075 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
22076 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
22077 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
22078 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
22079 _(l2_patch_add_del, \
22080 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
22081 "enable | disable") \
22082 _(sr_localsid_add_del, \
22083 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
22084 "fib-table <num> (end.psp) sw_if_index <num>") \
22085 _(classify_add_del_table, \
22086 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
22087 " [del] [del-chain] mask <mask-value>\n" \
22088 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
22089 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
22090 _(classify_add_del_session, \
22091 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
22092 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
22093 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
22094 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
22095 _(classify_set_interface_ip_table, \
22096 "<intfc> | sw_if_index <nn> table <nn>") \
22097 _(classify_set_interface_l2_tables, \
22098 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22099 " [other-table <nn>]") \
22100 _(get_node_index, "node <node-name") \
22101 _(add_node_next, "node <node-name> next <next-node-name>") \
22102 _(l2tpv3_create_tunnel, \
22103 "client_address <ip6-addr> our_address <ip6-addr>\n" \
22104 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
22105 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
22106 _(l2tpv3_set_tunnel_cookies, \
22107 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
22108 "[new_remote_cookie <nn>]\n") \
22109 _(l2tpv3_interface_enable_disable, \
22110 "<intfc> | sw_if_index <nn> enable | disable") \
22111 _(l2tpv3_set_lookup_key, \
22112 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
22113 _(sw_if_l2tpv3_tunnel_dump, "") \
22114 _(vxlan_offload_rx, \
22115 "hw { <interface name> | hw_if_index <nn>} " \
22116 "rx { <vxlan tunnel name> | sw_if_index <nn> } [del]") \
22117 _(vxlan_add_del_tunnel, \
22118 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
22119 "{ <intfc> | mcast_sw_if_index <nn> } [instance <id>]}\n" \
22120 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
22121 _(geneve_add_del_tunnel, \
22122 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
22123 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22124 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
22125 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22126 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22127 _(gre_tunnel_add_del, \
22128 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [instance <n>]\n" \
22129 "[teb | erspan <session-id>] [del]") \
22130 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22131 _(l2_fib_clear_table, "") \
22132 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
22133 _(l2_interface_vlan_tag_rewrite, \
22134 "<intfc> | sw_if_index <nn> \n" \
22135 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
22136 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
22137 _(create_vhost_user_if, \
22138 "socket <filename> [server] [renumber <dev_instance>] " \
22139 "[disable_mrg_rxbuf] [disable_indirect_desc] [gso] " \
22140 "[mac <mac_address>]") \
22141 _(modify_vhost_user_if, \
22142 "<intfc> | sw_if_index <nn> socket <filename>\n" \
22143 "[server] [renumber <dev_instance>] [gso]") \
22144 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
22145 _(sw_interface_vhost_user_dump, "") \
22146 _(show_version, "") \
22147 _(show_threads, "") \
22148 _(vxlan_gpe_add_del_tunnel, \
22149 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
22150 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22151 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
22152 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
22153 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22154 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
22155 _(interface_name_renumber, \
22156 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
22157 _(input_acl_set_interface, \
22158 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22159 " [l2-table <nn>] [del]") \
22160 _(ip_probe_neighbor, "(<intc> | sw_if_index <nn>) address <ip4|ip6-addr>") \
22161 _(ip_scan_neighbor_enable_disable, "[ip4|ip6|both|disable] [interval <n-min>]\n" \
22162 " [max-time <n-usec>] [max-update <n>] [delay <n-msec>] [stale <n-min>]") \
22163 _(want_ip4_arp_events, "address <ip4-address> [del]") \
22164 _(want_ip6_nd_events, "address <ip6-address> [del]") \
22165 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
22166 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
22167 _(ip_dump, "ipv4 | ipv6") \
22168 _(ipsec_spd_add_del, "spd_id <n> [del]") \
22169 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
22171 _(ipsec_sad_entry_add_del, "sad_id <n> spi <n> crypto_alg <alg>\n" \
22172 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
22173 " integ_alg <alg> integ_key <hex>") \
22174 _(ipsec_spd_entry_add_del, "spd_id <n> priority <n> action <action>\n" \
22175 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
22176 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
22177 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
22178 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
22179 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
22180 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
22181 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n" \
22182 " [instance <n>]") \
22183 _(ipsec_sa_dump, "[sa_id <n>]") \
22184 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
22185 _(delete_loopback,"sw_if_index <nn>") \
22186 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
22187 _(bd_ip_mac_flush, "bd_id <bridge-domain-id>") \
22188 _(bd_ip_mac_dump, "[bd_id] <bridge-domain-id>") \
22189 _(want_interface_events, "enable|disable") \
22190 _(get_first_msg_id, "client <name>") \
22191 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
22192 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
22193 "fib-id <nn> [ip4][ip6][default]") \
22194 _(get_node_graph, " ") \
22195 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
22196 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
22197 _(ioam_disable, "") \
22198 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
22199 " sw_if_index <sw_if_index> p <priority> " \
22200 "w <weight>] [del]") \
22201 _(one_add_del_locator, "locator-set <locator_name> " \
22202 "iface <intf> | sw_if_index <sw_if_index> " \
22203 "p <priority> w <weight> [del]") \
22204 _(one_add_del_local_eid,"vni <vni> eid " \
22205 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22206 "locator-set <locator_name> [del]" \
22207 "[key-id sha1|sha256 secret-key <secret-key>]")\
22208 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
22209 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
22210 _(one_enable_disable, "enable|disable") \
22211 _(one_map_register_enable_disable, "enable|disable") \
22212 _(one_map_register_fallback_threshold, "<value>") \
22213 _(one_rloc_probe_enable_disable, "enable|disable") \
22214 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22216 "rloc <locator> p <prio> " \
22217 "w <weight> [rloc <loc> ... ] " \
22218 "action <action> [del-all]") \
22219 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22221 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22222 _(one_use_petr, "ip-address> | disable") \
22223 _(one_map_request_mode, "src-dst|dst-only") \
22224 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22225 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22226 _(one_locator_set_dump, "[local | remote]") \
22227 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
22228 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22229 "[local] | [remote]") \
22230 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
22231 _(one_ndp_bd_get, "") \
22232 _(one_ndp_entries_get, "bd <bridge-domain>") \
22233 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
22234 _(one_l2_arp_bd_get, "") \
22235 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
22236 _(one_stats_enable_disable, "enable|disable") \
22237 _(show_one_stats_enable_disable, "") \
22238 _(one_eid_table_vni_dump, "") \
22239 _(one_eid_table_map_dump, "l2|l3") \
22240 _(one_map_resolver_dump, "") \
22241 _(one_map_server_dump, "") \
22242 _(one_adjacencies_get, "vni <vni>") \
22243 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
22244 _(show_one_rloc_probe_state, "") \
22245 _(show_one_map_register_state, "") \
22246 _(show_one_status, "") \
22247 _(one_stats_dump, "") \
22248 _(one_stats_flush, "") \
22249 _(one_get_map_request_itr_rlocs, "") \
22250 _(one_map_register_set_ttl, "<ttl>") \
22251 _(one_set_transport_protocol, "udp|api") \
22252 _(one_get_transport_protocol, "") \
22253 _(one_enable_disable_xtr_mode, "enable|disable") \
22254 _(one_show_xtr_mode, "") \
22255 _(one_enable_disable_pitr_mode, "enable|disable") \
22256 _(one_show_pitr_mode, "") \
22257 _(one_enable_disable_petr_mode, "enable|disable") \
22258 _(one_show_petr_mode, "") \
22259 _(show_one_nsh_mapping, "") \
22260 _(show_one_pitr, "") \
22261 _(show_one_use_petr, "") \
22262 _(show_one_map_request_mode, "") \
22263 _(show_one_map_register_ttl, "") \
22264 _(show_one_map_register_fallback_threshold, "") \
22265 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
22266 " sw_if_index <sw_if_index> p <priority> " \
22267 "w <weight>] [del]") \
22268 _(lisp_add_del_locator, "locator-set <locator_name> " \
22269 "iface <intf> | sw_if_index <sw_if_index> " \
22270 "p <priority> w <weight> [del]") \
22271 _(lisp_add_del_local_eid,"vni <vni> eid " \
22272 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22273 "locator-set <locator_name> [del]" \
22274 "[key-id sha1|sha256 secret-key <secret-key>]") \
22275 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
22276 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
22277 _(lisp_enable_disable, "enable|disable") \
22278 _(lisp_map_register_enable_disable, "enable|disable") \
22279 _(lisp_rloc_probe_enable_disable, "enable|disable") \
22280 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22282 "rloc <locator> p <prio> " \
22283 "w <weight> [rloc <loc> ... ] " \
22284 "action <action> [del-all]") \
22285 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22287 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22288 _(lisp_use_petr, "<ip-address> | disable") \
22289 _(lisp_map_request_mode, "src-dst|dst-only") \
22290 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22291 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22292 _(lisp_locator_set_dump, "[local | remote]") \
22293 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
22294 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22295 "[local] | [remote]") \
22296 _(lisp_eid_table_vni_dump, "") \
22297 _(lisp_eid_table_map_dump, "l2|l3") \
22298 _(lisp_map_resolver_dump, "") \
22299 _(lisp_map_server_dump, "") \
22300 _(lisp_adjacencies_get, "vni <vni>") \
22301 _(gpe_fwd_entry_vnis_get, "") \
22302 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
22303 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
22304 "[table <table-id>]") \
22305 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
22306 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
22307 _(gpe_set_encap_mode, "lisp|vxlan") \
22308 _(gpe_get_encap_mode, "") \
22309 _(lisp_gpe_add_del_iface, "up|down") \
22310 _(lisp_gpe_enable_disable, "enable|disable") \
22311 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
22312 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
22313 _(show_lisp_rloc_probe_state, "") \
22314 _(show_lisp_map_register_state, "") \
22315 _(show_lisp_status, "") \
22316 _(lisp_get_map_request_itr_rlocs, "") \
22317 _(show_lisp_pitr, "") \
22318 _(show_lisp_use_petr, "") \
22319 _(show_lisp_map_request_mode, "") \
22320 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
22321 _(af_packet_delete, "name <host interface name>") \
22322 _(af_packet_dump, "") \
22323 _(policer_add_del, "name <policer name> <params> [del]") \
22324 _(policer_dump, "[name <policer name>]") \
22325 _(policer_classify_set_interface, \
22326 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22327 " [l2-table <nn>] [del]") \
22328 _(policer_classify_dump, "type [ip4|ip6|l2]") \
22329 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
22330 "[master|slave]") \
22331 _(netmap_delete, "name <interface name>") \
22332 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
22333 _(mpls_table_dump, "") \
22334 _(mpls_route_dump, "table-id <ID>") \
22335 _(classify_table_ids, "") \
22336 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
22337 _(classify_table_info, "table_id <nn>") \
22338 _(classify_session_dump, "table_id <nn>") \
22339 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
22340 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
22341 "[template_interval <nn>] [udp_checksum]") \
22342 _(ipfix_exporter_dump, "") \
22343 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
22344 _(ipfix_classify_stream_dump, "") \
22345 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
22346 _(ipfix_classify_table_dump, "") \
22347 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
22348 _(sw_interface_span_dump, "[l2]") \
22349 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
22350 _(pg_create_interface, "if_id <nn> [gso-enabled gso-size <size>]") \
22351 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
22352 _(pg_enable_disable, "[stream <id>] disable") \
22353 _(ip_source_and_port_range_check_add_del, \
22354 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
22355 _(ip_source_and_port_range_check_interface_add_del, \
22356 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
22357 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
22358 _(delete_subif,"<intfc> | sw_if_index <nn>") \
22359 _(l2_interface_pbb_tag_rewrite, \
22360 "<intfc> | sw_if_index <nn> \n" \
22361 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
22362 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
22363 _(set_punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
22364 _(flow_classify_set_interface, \
22365 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
22366 _(flow_classify_dump, "type [ip4|ip6]") \
22367 _(ip_table_dump, "") \
22368 _(ip_route_dump, "table-id [ip4|ip6]") \
22369 _(ip_mtable_dump, "") \
22370 _(ip_mroute_dump, "table-id [ip4|ip6]") \
22371 _(feature_enable_disable, "arc_name <arc_name> " \
22372 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
22373 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
22375 _(l2_xconnect_dump, "") \
22376 _(hw_interface_set_mtu, "<intfc> | hw_if_index <nn> mtu <nn>") \
22377 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
22378 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
22379 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
22380 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
22381 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
22382 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
22383 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
22384 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
22385 _(sock_init_shm, "size <nnn>") \
22386 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
22387 _(dns_enable_disable, "[enable][disable]") \
22388 _(dns_name_server_add_del, "<ip-address> [del]") \
22389 _(dns_resolve_name, "<hostname>") \
22390 _(dns_resolve_ip, "<ip4|ip6>") \
22391 _(dns_name_server_add_del, "<ip-address> [del]") \
22392 _(dns_resolve_name, "<hostname>") \
22393 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
22394 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
22395 _(session_rules_dump, "") \
22396 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
22397 _(output_acl_set_interface, \
22398 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22399 " [l2-table <nn>] [del]") \
22400 _(qos_record_enable_disable, "<record-source> <intfc> | sw_if_index <id> [disable]")
22402 /* List of command functions, CLI names map directly to functions */
22403 #define foreach_cli_function \
22404 _(comment, "usage: comment <ignore-rest-of-line>") \
22405 _(dump_interface_table, "usage: dump_interface_table") \
22406 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
22407 _(dump_ipv4_table, "usage: dump_ipv4_table") \
22408 _(dump_ipv6_table, "usage: dump_ipv6_table") \
22409 _(dump_macro_table, "usage: dump_macro_table ") \
22410 _(dump_node_table, "usage: dump_node_table") \
22411 _(dump_msg_api_table, "usage: dump_msg_api_table") \
22412 _(elog_setup, "usage: elog_setup [nevents, default 128K]") \
22413 _(elog_disable, "usage: elog_disable") \
22414 _(elog_enable, "usage: elog_enable") \
22415 _(elog_save, "usage: elog_save <filename>") \
22416 _(get_msg_id, "usage: get_msg_id name_and_crc") \
22417 _(echo, "usage: echo <message>") \
22418 _(exec, "usage: exec <vpe-debug-CLI-command>") \
22419 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
22420 _(help, "usage: help") \
22421 _(q, "usage: quit") \
22422 _(quit, "usage: quit") \
22423 _(search_node_table, "usage: search_node_table <name>...") \
22424 _(set, "usage: set <variable-name> <value>") \
22425 _(script, "usage: script <file-name>") \
22426 _(statseg, "usage: statseg") \
22427 _(unset, "usage: unset <variable-name>")
22430 static void vl_api_##n##_t_handler_uni \
22431 (vl_api_##n##_t * mp) \
22433 vat_main_t * vam = &vat_main; \
22434 if (vam->json_output) { \
22435 vl_api_##n##_t_handler_json(mp); \
22437 vl_api_##n##_t_handler(mp); \
22440 foreach_vpe_api_reply_msg;
22441 #if VPP_API_TEST_BUILTIN == 0
22442 foreach_standalone_reply_msg;
22447 vat_api_hookup (vat_main_t * vam)
22450 vl_msg_api_set_handlers(VL_API_##N, #n, \
22451 vl_api_##n##_t_handler_uni, \
22453 vl_api_##n##_t_endian, \
22454 vl_api_##n##_t_print, \
22455 sizeof(vl_api_##n##_t), 1);
22456 foreach_vpe_api_reply_msg;
22457 #if VPP_API_TEST_BUILTIN == 0
22458 foreach_standalone_reply_msg;
22462 #if (VPP_API_TEST_BUILTIN==0)
22463 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
22465 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
22467 vam->function_by_name = hash_create_string (0, sizeof (uword));
22469 vam->help_by_name = hash_create_string (0, sizeof (uword));
22472 /* API messages we can send */
22473 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
22474 foreach_vpe_api_msg;
22478 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
22479 foreach_vpe_api_msg;
22482 /* CLI functions */
22483 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
22484 foreach_cli_function;
22488 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
22489 foreach_cli_function;
22493 #if VPP_API_TEST_BUILTIN
22494 static clib_error_t *
22495 vat_api_hookup_shim (vlib_main_t * vm)
22497 vat_api_hookup (&vat_main);
22501 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
22505 * fd.io coding-style-patch-verification: ON
22508 * eval: (c-set-style "gnu")