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 <vlib/pci/pci.h>
22 #include <vpp/api/types.h>
23 #include <vppinfra/socket.h>
24 #include <vlibapi/api.h>
25 #include <vlibmemory/api.h>
26 #include <vnet/ip/ip.h>
27 #include <vnet/ip-neighbor/ip_neighbor.h>
28 #include <vnet/ip/ip_types_api.h>
29 #include <vnet/l2/l2_input.h>
30 #include <vnet/l2tp/l2tp.h>
31 #include <vnet/vxlan/vxlan.h>
32 #include <vnet/geneve/geneve.h>
33 #include <vnet/gre/gre.h>
34 #include <vnet/vxlan-gpe/vxlan_gpe.h>
35 #include <vnet/lisp-gpe/lisp_gpe.h>
37 #include <vpp/api/vpe_msg_enum.h>
38 #include <vnet/l2/l2_classify.h>
39 #include <vnet/l2/l2_vtr.h>
40 #include <vnet/classify/in_out_acl.h>
41 #include <vnet/classify/policer_classify.h>
42 #include <vnet/classify/flow_classify.h>
43 #include <vnet/mpls/mpls.h>
44 #include <vnet/ipsec/ipsec.h>
46 #include <vnet/cop/cop.h>
47 #include <vnet/ip/ip6_hop_by_hop.h>
48 #include <vnet/ip/ip_source_and_port_range_check.h>
49 #include <vnet/policer/xlate.h>
50 #include <vnet/span/span.h>
51 #include <vnet/policer/policer.h>
52 #include <vnet/policer/police.h>
53 #include <vnet/mfib/mfib_types.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 #include <vnet/format_fns.h>
90 void vl_api_set_elog_main (elog_main_t * m);
91 int vl_api_set_elog_trace_api_messages (int enable);
93 #if VPP_API_TEST_BUILTIN == 0
103 vat_socket_connect (vat_main_t * vam)
106 api_main_t *am = vlibapi_get_main ();
107 vam->socket_client_main = &socket_client_main;
108 if ((rv = vl_socket_client_connect ((char *) vam->socket_name,
110 0 /* default socket rx, tx buffer */ )))
113 /* vpp expects the client index in network order */
114 vam->my_client_index = htonl (socket_client_main.client_index);
115 am->my_client_index = vam->my_client_index;
118 #else /* vpp built-in case, we don't do sockets... */
120 vat_socket_connect (vat_main_t * vam)
126 vl_socket_client_read (int wait)
132 vl_socket_client_write ()
138 vl_socket_client_msg_alloc (int nbytes)
146 vat_time_now (vat_main_t * vam)
148 #if VPP_API_TEST_BUILTIN
149 return vlib_time_now (vam->vlib_main);
151 return clib_time_now (&vam->clib_time);
156 errmsg (char *fmt, ...)
158 vat_main_t *vam = &vat_main;
163 s = va_format (0, fmt, &va);
168 #if VPP_API_TEST_BUILTIN
169 vlib_cli_output (vam->vlib_main, (char *) s);
172 if (vam->ifp != stdin)
173 fformat (vam->ofp, "%s(%d): \n", vam->current_file,
174 vam->input_line_number);
176 fformat (vam->ofp, "%s\n", (char *) s);
184 #if VPP_API_TEST_BUILTIN == 0
186 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
188 vat_main_t *vam = va_arg (*args, vat_main_t *);
189 u32 *result = va_arg (*args, u32 *);
193 if (!unformat (input, "%s", &if_name))
196 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
204 api_unformat_hw_if_index (unformat_input_t * input, va_list * args)
209 /* Parse an IP4 address %d.%d.%d.%d. */
211 unformat_ip4_address (unformat_input_t * input, va_list * args)
213 u8 *result = va_arg (*args, u8 *);
216 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
219 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
231 unformat_ethernet_address (unformat_input_t * input, va_list * args)
233 u8 *result = va_arg (*args, u8 *);
236 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
237 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
241 for (i = 0; i < 6; i++)
242 if (a[i] >= (1 << 8))
245 for (i = 0; i < 6; i++)
251 /* Returns ethernet type as an int in host byte order. */
253 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
256 u16 *result = va_arg (*args, u16 *);
260 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
262 if (type >= (1 << 16))
270 /* Parse an IP46 address. */
272 unformat_ip46_address (unformat_input_t * input, va_list * args)
274 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
275 ip46_type_t type = va_arg (*args, ip46_type_t);
276 if ((type != IP46_TYPE_IP6) &&
277 unformat (input, "%U", unformat_ip4_address, &ip46->ip4))
279 ip46_address_mask_ip4 (ip46);
282 else if ((type != IP46_TYPE_IP4) &&
283 unformat (input, "%U", unformat_ip6_address, &ip46->ip6))
290 /* Parse an IP6 address. */
292 unformat_ip6_address (unformat_input_t * input, va_list * args)
294 ip6_address_t *result = va_arg (*args, ip6_address_t *);
296 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
297 uword c, n_colon, double_colon_index;
299 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
300 double_colon_index = ARRAY_LEN (hex_quads);
301 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
304 if (c >= '0' && c <= '9')
306 else if (c >= 'a' && c <= 'f')
307 hex_digit = c + 10 - 'a';
308 else if (c >= 'A' && c <= 'F')
309 hex_digit = c + 10 - 'A';
310 else if (c == ':' && n_colon < 2)
314 unformat_put_input (input);
318 /* Too many hex quads. */
319 if (n_hex_quads >= ARRAY_LEN (hex_quads))
324 hex_quad = (hex_quad << 4) | hex_digit;
326 /* Hex quad must fit in 16 bits. */
327 if (n_hex_digits >= 4)
334 /* Save position of :: */
337 /* More than one :: ? */
338 if (double_colon_index < ARRAY_LEN (hex_quads))
340 double_colon_index = n_hex_quads;
343 if (n_colon > 0 && n_hex_digits > 0)
345 hex_quads[n_hex_quads++] = hex_quad;
351 if (n_hex_digits > 0)
352 hex_quads[n_hex_quads++] = hex_quad;
357 /* Expand :: to appropriate number of zero hex quads. */
358 if (double_colon_index < ARRAY_LEN (hex_quads))
360 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
362 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
363 hex_quads[n_zero + i] = hex_quads[i];
365 for (i = 0; i < n_zero; i++)
366 hex_quads[double_colon_index + i] = 0;
368 n_hex_quads = ARRAY_LEN (hex_quads);
371 /* Too few hex quads given. */
372 if (n_hex_quads < ARRAY_LEN (hex_quads))
375 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
376 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
383 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
385 u32 *r = va_arg (*args, u32 *);
388 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
389 foreach_ipsec_policy_action
397 format_ipsec_crypto_alg (u8 * s, va_list * args)
399 u32 i = va_arg (*args, u32);
404 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
405 foreach_ipsec_crypto_alg
408 return format (s, "unknown");
410 return format (s, "%s", t);
414 format_ipsec_integ_alg (u8 * s, va_list * args)
416 u32 i = va_arg (*args, u32);
421 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
422 foreach_ipsec_integ_alg
425 return format (s, "unknown");
427 return format (s, "%s", t);
430 #else /* VPP_API_TEST_BUILTIN == 1 */
432 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
434 vat_main_t *vam __clib_unused = va_arg (*args, vat_main_t *);
435 vnet_main_t *vnm = vnet_get_main ();
436 u32 *result = va_arg (*args, u32 *);
438 return unformat (input, "%U", unformat_vnet_sw_interface, vnm, result);
442 api_unformat_hw_if_index (unformat_input_t * input, va_list * args)
444 vat_main_t *vam __clib_unused = va_arg (*args, vat_main_t *);
445 vnet_main_t *vnm = vnet_get_main ();
446 u32 *result = va_arg (*args, u32 *);
448 return unformat (input, "%U", unformat_vnet_hw_interface, vnm, result);
451 #endif /* VPP_API_TEST_BUILTIN */
454 unformat_ipsec_api_crypto_alg (unformat_input_t * input, va_list * args)
456 u32 *r = va_arg (*args, u32 *);
459 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_API_CRYPTO_ALG_##f;
460 foreach_ipsec_crypto_alg
468 unformat_ipsec_api_integ_alg (unformat_input_t * input, va_list * args)
470 u32 *r = va_arg (*args, u32 *);
473 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_API_INTEG_ALG_##f;
474 foreach_ipsec_integ_alg
482 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
484 u8 *r = va_arg (*args, u8 *);
486 if (unformat (input, "kbps"))
487 *r = SSE2_QOS_RATE_KBPS;
488 else if (unformat (input, "pps"))
489 *r = SSE2_QOS_RATE_PPS;
496 unformat_policer_round_type (unformat_input_t * input, va_list * args)
498 u8 *r = va_arg (*args, u8 *);
500 if (unformat (input, "closest"))
501 *r = SSE2_QOS_ROUND_TO_CLOSEST;
502 else if (unformat (input, "up"))
503 *r = SSE2_QOS_ROUND_TO_UP;
504 else if (unformat (input, "down"))
505 *r = SSE2_QOS_ROUND_TO_DOWN;
512 unformat_policer_type (unformat_input_t * input, va_list * args)
514 u8 *r = va_arg (*args, u8 *);
516 if (unformat (input, "1r2c"))
517 *r = SSE2_QOS_POLICER_TYPE_1R2C;
518 else if (unformat (input, "1r3c"))
519 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
520 else if (unformat (input, "2r3c-2698"))
521 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
522 else if (unformat (input, "2r3c-4115"))
523 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
524 else if (unformat (input, "2r3c-mef5cf1"))
525 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
532 unformat_dscp (unformat_input_t * input, va_list * va)
534 u8 *r = va_arg (*va, u8 *);
537 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
546 unformat_policer_action_type (unformat_input_t * input, va_list * va)
548 sse2_qos_pol_action_params_st *a
549 = va_arg (*va, sse2_qos_pol_action_params_st *);
551 if (unformat (input, "drop"))
552 a->action_type = SSE2_QOS_ACTION_DROP;
553 else if (unformat (input, "transmit"))
554 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
555 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
556 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
563 unformat_policer_classify_table_type (unformat_input_t * input, va_list * va)
565 u32 *r = va_arg (*va, u32 *);
568 if (unformat (input, "ip4"))
569 tid = POLICER_CLASSIFY_TABLE_IP4;
570 else if (unformat (input, "ip6"))
571 tid = POLICER_CLASSIFY_TABLE_IP6;
572 else if (unformat (input, "l2"))
573 tid = POLICER_CLASSIFY_TABLE_L2;
582 unformat_flow_classify_table_type (unformat_input_t * input, va_list * va)
584 u32 *r = va_arg (*va, u32 *);
587 if (unformat (input, "ip4"))
588 tid = FLOW_CLASSIFY_TABLE_IP4;
589 else if (unformat (input, "ip6"))
590 tid = FLOW_CLASSIFY_TABLE_IP6;
598 #if (VPP_API_TEST_BUILTIN==0)
600 static const char *mfib_flag_names[] = MFIB_ENTRY_NAMES_SHORT;
601 static const char *mfib_flag_long_names[] = MFIB_ENTRY_NAMES_LONG;
602 static const char *mfib_itf_flag_long_names[] = MFIB_ITF_NAMES_LONG;
603 static const char *mfib_itf_flag_names[] = MFIB_ITF_NAMES_SHORT;
606 unformat_mfib_itf_flags (unformat_input_t * input, va_list * args)
608 mfib_itf_flags_t old, *iflags = va_arg (*args, mfib_itf_flags_t *);
609 mfib_itf_attribute_t attr;
612 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
614 if (unformat (input, mfib_itf_flag_long_names[attr]))
615 *iflags |= (1 << attr);
617 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
619 if (unformat (input, mfib_itf_flag_names[attr]))
620 *iflags |= (1 << attr);
623 return (old == *iflags ? 0 : 1);
627 unformat_mfib_entry_flags (unformat_input_t * input, va_list * args)
629 mfib_entry_flags_t old, *eflags = va_arg (*args, mfib_entry_flags_t *);
630 mfib_entry_attribute_t attr;
633 FOR_EACH_MFIB_ATTRIBUTE (attr)
635 if (unformat (input, mfib_flag_long_names[attr]))
636 *eflags |= (1 << attr);
638 FOR_EACH_MFIB_ATTRIBUTE (attr)
640 if (unformat (input, mfib_flag_names[attr]))
641 *eflags |= (1 << attr);
644 return (old == *eflags ? 0 : 1);
648 format_ip4_address (u8 * s, va_list * args)
650 u8 *a = va_arg (*args, u8 *);
651 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
655 format_ip6_address (u8 * s, va_list * args)
657 ip6_address_t *a = va_arg (*args, ip6_address_t *);
658 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
660 i_max_n_zero = ARRAY_LEN (a->as_u16);
662 i_first_zero = i_max_n_zero;
664 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
666 u32 is_zero = a->as_u16[i] == 0;
667 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
673 if ((!is_zero && n_zeros > max_n_zeros)
674 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
676 i_max_n_zero = i_first_zero;
677 max_n_zeros = n_zeros;
678 i_first_zero = ARRAY_LEN (a->as_u16);
683 last_double_colon = 0;
684 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
686 if (i == i_max_n_zero && max_n_zeros > 1)
688 s = format (s, "::");
689 i += max_n_zeros - 1;
690 last_double_colon = 1;
694 s = format (s, "%s%x",
695 (last_double_colon || i == 0) ? "" : ":",
696 clib_net_to_host_u16 (a->as_u16[i]));
697 last_double_colon = 0;
704 /* Format an IP46 address. */
706 format_ip46_address (u8 * s, va_list * args)
708 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
709 ip46_type_t type = va_arg (*args, ip46_type_t);
715 is_ip4 = ip46_address_is_ip4 (ip46);
726 format (s, "%U", format_ip4_address, &ip46->ip4) :
727 format (s, "%U", format_ip6_address, &ip46->ip6);
731 format_ethernet_address (u8 * s, va_list * args)
733 u8 *a = va_arg (*args, u8 *);
735 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
736 a[0], a[1], a[2], a[3], a[4], a[5]);
741 increment_v4_address (vl_api_ip4_address_t * i)
743 ip4_address_t *a = (ip4_address_t *) i;
746 v = ntohl (a->as_u32) + 1;
747 a->as_u32 = ntohl (v);
751 increment_v6_address (vl_api_ip6_address_t * i)
753 ip6_address_t *a = (ip6_address_t *) i;
756 v0 = clib_net_to_host_u64 (a->as_u64[0]);
757 v1 = clib_net_to_host_u64 (a->as_u64[1]);
762 a->as_u64[0] = clib_net_to_host_u64 (v0);
763 a->as_u64[1] = clib_net_to_host_u64 (v1);
767 increment_address (vl_api_address_t * a)
769 if (a->af == ADDRESS_IP4)
770 increment_v4_address (&a->un.ip4);
771 else if (a->af == ADDRESS_IP6)
772 increment_v6_address (&a->un.ip6);
776 set_ip4_address (vl_api_address_t * a, u32 v)
778 if (a->af == ADDRESS_IP4)
780 ip4_address_t *i = (ip4_address_t *) & a->un.ip4;
786 ip_set (ip46_address_t * dst, void *src, u8 is_ip4)
789 dst->ip4.as_u32 = ((ip4_address_t *) src)->as_u32;
791 clib_memcpy_fast (&dst->ip6, (ip6_address_t *) src,
792 sizeof (ip6_address_t));
796 increment_mac_address (u8 * mac)
798 u64 tmp = *((u64 *) mac);
799 tmp = clib_net_to_host_u64 (tmp);
800 tmp += 1 << 16; /* skip unused (least significant) octets */
801 tmp = clib_host_to_net_u64 (tmp);
803 clib_memcpy (mac, &tmp, 6);
807 vat_json_object_add_address (vat_json_node_t * node,
808 const char *str, const vl_api_address_t * addr)
810 if (ADDRESS_IP6 == addr->af)
814 clib_memcpy (&ip6, &addr->un.ip6, sizeof (ip6));
815 vat_json_object_add_ip6 (node, str, ip6);
821 clib_memcpy (&ip4, &addr->un.ip4, sizeof (ip4));
822 vat_json_object_add_ip4 (node, str, ip4);
827 vat_json_object_add_prefix (vat_json_node_t * node,
828 const vl_api_prefix_t * prefix)
830 vat_json_object_add_uint (node, "len", prefix->len);
831 vat_json_object_add_address (node, "address", &prefix->address);
834 static void vl_api_create_loopback_reply_t_handler
835 (vl_api_create_loopback_reply_t * mp)
837 vat_main_t *vam = &vat_main;
838 i32 retval = ntohl (mp->retval);
840 vam->retval = retval;
841 vam->regenerate_interface_table = 1;
842 vam->sw_if_index = ntohl (mp->sw_if_index);
843 vam->result_ready = 1;
846 static void vl_api_create_loopback_reply_t_handler_json
847 (vl_api_create_loopback_reply_t * mp)
849 vat_main_t *vam = &vat_main;
850 vat_json_node_t node;
852 vat_json_init_object (&node);
853 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
854 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
856 vat_json_print (vam->ofp, &node);
857 vat_json_free (&node);
858 vam->retval = ntohl (mp->retval);
859 vam->result_ready = 1;
862 static void vl_api_create_loopback_instance_reply_t_handler
863 (vl_api_create_loopback_instance_reply_t * mp)
865 vat_main_t *vam = &vat_main;
866 i32 retval = ntohl (mp->retval);
868 vam->retval = retval;
869 vam->regenerate_interface_table = 1;
870 vam->sw_if_index = ntohl (mp->sw_if_index);
871 vam->result_ready = 1;
874 static void vl_api_create_loopback_instance_reply_t_handler_json
875 (vl_api_create_loopback_instance_reply_t * mp)
877 vat_main_t *vam = &vat_main;
878 vat_json_node_t node;
880 vat_json_init_object (&node);
881 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
882 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
884 vat_json_print (vam->ofp, &node);
885 vat_json_free (&node);
886 vam->retval = ntohl (mp->retval);
887 vam->result_ready = 1;
890 static void vl_api_af_packet_create_reply_t_handler
891 (vl_api_af_packet_create_reply_t * mp)
893 vat_main_t *vam = &vat_main;
894 i32 retval = ntohl (mp->retval);
896 vam->retval = retval;
897 vam->regenerate_interface_table = 1;
898 vam->sw_if_index = ntohl (mp->sw_if_index);
899 vam->result_ready = 1;
902 static void vl_api_af_packet_create_reply_t_handler_json
903 (vl_api_af_packet_create_reply_t * mp)
905 vat_main_t *vam = &vat_main;
906 vat_json_node_t node;
908 vat_json_init_object (&node);
909 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
910 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
912 vat_json_print (vam->ofp, &node);
913 vat_json_free (&node);
915 vam->retval = ntohl (mp->retval);
916 vam->result_ready = 1;
919 static void vl_api_create_vlan_subif_reply_t_handler
920 (vl_api_create_vlan_subif_reply_t * mp)
922 vat_main_t *vam = &vat_main;
923 i32 retval = ntohl (mp->retval);
925 vam->retval = retval;
926 vam->regenerate_interface_table = 1;
927 vam->sw_if_index = ntohl (mp->sw_if_index);
928 vam->result_ready = 1;
931 static void vl_api_create_vlan_subif_reply_t_handler_json
932 (vl_api_create_vlan_subif_reply_t * mp)
934 vat_main_t *vam = &vat_main;
935 vat_json_node_t node;
937 vat_json_init_object (&node);
938 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
939 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
941 vat_json_print (vam->ofp, &node);
942 vat_json_free (&node);
944 vam->retval = ntohl (mp->retval);
945 vam->result_ready = 1;
948 static void vl_api_create_subif_reply_t_handler
949 (vl_api_create_subif_reply_t * mp)
951 vat_main_t *vam = &vat_main;
952 i32 retval = ntohl (mp->retval);
954 vam->retval = retval;
955 vam->regenerate_interface_table = 1;
956 vam->sw_if_index = ntohl (mp->sw_if_index);
957 vam->result_ready = 1;
960 static void vl_api_create_subif_reply_t_handler_json
961 (vl_api_create_subif_reply_t * mp)
963 vat_main_t *vam = &vat_main;
964 vat_json_node_t node;
966 vat_json_init_object (&node);
967 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
968 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
970 vat_json_print (vam->ofp, &node);
971 vat_json_free (&node);
973 vam->retval = ntohl (mp->retval);
974 vam->result_ready = 1;
977 static void vl_api_interface_name_renumber_reply_t_handler
978 (vl_api_interface_name_renumber_reply_t * mp)
980 vat_main_t *vam = &vat_main;
981 i32 retval = ntohl (mp->retval);
983 vam->retval = retval;
984 vam->regenerate_interface_table = 1;
985 vam->result_ready = 1;
988 static void vl_api_interface_name_renumber_reply_t_handler_json
989 (vl_api_interface_name_renumber_reply_t * mp)
991 vat_main_t *vam = &vat_main;
992 vat_json_node_t node;
994 vat_json_init_object (&node);
995 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
997 vat_json_print (vam->ofp, &node);
998 vat_json_free (&node);
1000 vam->retval = ntohl (mp->retval);
1001 vam->result_ready = 1;
1005 * Special-case: build the interface table, maintain
1006 * the next loopback sw_if_index vbl.
1008 static void vl_api_sw_interface_details_t_handler
1009 (vl_api_sw_interface_details_t * mp)
1011 vat_main_t *vam = &vat_main;
1012 u8 *s = format (0, "%s%c", mp->interface_name, 0);
1014 hash_set_mem (vam->sw_if_index_by_interface_name, s,
1015 ntohl (mp->sw_if_index));
1017 /* In sub interface case, fill the sub interface table entry */
1018 if (mp->sw_if_index != mp->sup_sw_if_index)
1020 sw_interface_subif_t *sub = NULL;
1022 vec_add2 (vam->sw_if_subif_table, sub, 1);
1024 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
1025 strncpy ((char *) sub->interface_name, (char *) s,
1026 vec_len (sub->interface_name));
1027 sub->sw_if_index = ntohl (mp->sw_if_index);
1028 sub->sub_id = ntohl (mp->sub_id);
1030 sub->raw_flags = ntohl (mp->sub_if_flags & SUB_IF_API_FLAG_MASK_VNET);
1032 sub->sub_number_of_tags = mp->sub_number_of_tags;
1033 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
1034 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
1036 /* vlan tag rewrite */
1037 sub->vtr_op = ntohl (mp->vtr_op);
1038 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
1039 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
1040 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
1044 static void vl_api_sw_interface_details_t_handler_json
1045 (vl_api_sw_interface_details_t * mp)
1047 vat_main_t *vam = &vat_main;
1048 vat_json_node_t *node = NULL;
1050 if (VAT_JSON_ARRAY != vam->json_tree.type)
1052 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1053 vat_json_init_array (&vam->json_tree);
1055 node = vat_json_array_add (&vam->json_tree);
1057 vat_json_init_object (node);
1058 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
1059 vat_json_object_add_uint (node, "sup_sw_if_index",
1060 ntohl (mp->sup_sw_if_index));
1061 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
1062 sizeof (mp->l2_address));
1063 vat_json_object_add_string_copy (node, "interface_name",
1064 mp->interface_name);
1065 vat_json_object_add_string_copy (node, "interface_dev_type",
1066 mp->interface_dev_type);
1067 vat_json_object_add_uint (node, "flags", mp->flags);
1068 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
1069 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
1070 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
1071 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
1072 vat_json_object_add_uint (node, "sub_number_of_tags",
1073 mp->sub_number_of_tags);
1074 vat_json_object_add_uint (node, "sub_outer_vlan_id",
1075 ntohs (mp->sub_outer_vlan_id));
1076 vat_json_object_add_uint (node, "sub_inner_vlan_id",
1077 ntohs (mp->sub_inner_vlan_id));
1078 vat_json_object_add_uint (node, "sub_if_flags", ntohl (mp->sub_if_flags));
1079 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
1080 vat_json_object_add_uint (node, "vtr_push_dot1q",
1081 ntohl (mp->vtr_push_dot1q));
1082 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
1083 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
1084 if (ntohl (mp->sub_if_flags) & SUB_IF_API_FLAG_DOT1AH)
1086 vat_json_object_add_string_copy (node, "pbb_vtr_dmac",
1088 format_ethernet_address,
1090 vat_json_object_add_string_copy (node, "pbb_vtr_smac",
1092 format_ethernet_address,
1094 vat_json_object_add_uint (node, "pbb_vtr_b_vlanid", mp->b_vlanid);
1095 vat_json_object_add_uint (node, "pbb_vtr_i_sid", mp->i_sid);
1099 #if VPP_API_TEST_BUILTIN == 0
1100 static void vl_api_sw_interface_event_t_handler
1101 (vl_api_sw_interface_event_t * mp)
1103 vat_main_t *vam = &vat_main;
1104 if (vam->interface_event_display)
1105 errmsg ("interface flags: sw_if_index %d %s %s",
1106 ntohl (mp->sw_if_index),
1107 ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_ADMIN_UP) ?
1108 "admin-up" : "admin-down",
1109 ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_LINK_UP) ?
1110 "link-up" : "link-down");
1114 __clib_unused static void
1115 vl_api_sw_interface_event_t_handler_json (vl_api_sw_interface_event_t * mp)
1117 /* JSON output not supported */
1121 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
1123 vat_main_t *vam = &vat_main;
1124 i32 retval = ntohl (mp->retval);
1126 vam->retval = retval;
1127 vam->shmem_result = uword_to_pointer (mp->reply_in_shmem, u8 *);
1128 vam->result_ready = 1;
1132 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
1134 vat_main_t *vam = &vat_main;
1135 vat_json_node_t node;
1139 vat_json_init_object (&node);
1140 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1141 vat_json_object_add_uint (&node, "reply_in_shmem",
1142 ntohl (mp->reply_in_shmem));
1143 /* Toss the shared-memory original... */
1144 oldheap = vl_msg_push_heap ();
1146 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
1149 vl_msg_pop_heap (oldheap);
1151 vat_json_print (vam->ofp, &node);
1152 vat_json_free (&node);
1154 vam->retval = ntohl (mp->retval);
1155 vam->result_ready = 1;
1159 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
1161 vat_main_t *vam = &vat_main;
1162 i32 retval = ntohl (mp->retval);
1164 vec_reset_length (vam->cmd_reply);
1166 vam->retval = retval;
1168 vam->cmd_reply = vl_api_from_api_to_new_vec (&mp->reply);
1169 vam->result_ready = 1;
1173 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
1175 vat_main_t *vam = &vat_main;
1176 vat_json_node_t node;
1177 u8 *reply = 0; /* reply vector */
1179 reply = vl_api_from_api_to_new_vec (&mp->reply);
1180 vec_reset_length (vam->cmd_reply);
1182 vat_json_init_object (&node);
1183 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1184 vat_json_object_add_string_copy (&node, "reply", reply);
1186 vat_json_print (vam->ofp, &node);
1187 vat_json_free (&node);
1190 vam->retval = ntohl (mp->retval);
1191 vam->result_ready = 1;
1194 static void vl_api_classify_add_del_table_reply_t_handler
1195 (vl_api_classify_add_del_table_reply_t * mp)
1197 vat_main_t *vam = &vat_main;
1198 i32 retval = ntohl (mp->retval);
1199 if (vam->async_mode)
1201 vam->async_errors += (retval < 0);
1205 vam->retval = retval;
1207 ((mp->new_table_index != 0xFFFFFFFF) ||
1208 (mp->skip_n_vectors != 0xFFFFFFFF) ||
1209 (mp->match_n_vectors != 0xFFFFFFFF)))
1211 * Note: this is just barely thread-safe, depends on
1212 * the main thread spinning waiting for an answer...
1214 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d",
1215 ntohl (mp->new_table_index),
1216 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
1217 vam->result_ready = 1;
1221 static void vl_api_classify_add_del_table_reply_t_handler_json
1222 (vl_api_classify_add_del_table_reply_t * mp)
1224 vat_main_t *vam = &vat_main;
1225 vat_json_node_t node;
1227 vat_json_init_object (&node);
1228 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1229 vat_json_object_add_uint (&node, "new_table_index",
1230 ntohl (mp->new_table_index));
1231 vat_json_object_add_uint (&node, "skip_n_vectors",
1232 ntohl (mp->skip_n_vectors));
1233 vat_json_object_add_uint (&node, "match_n_vectors",
1234 ntohl (mp->match_n_vectors));
1236 vat_json_print (vam->ofp, &node);
1237 vat_json_free (&node);
1239 vam->retval = ntohl (mp->retval);
1240 vam->result_ready = 1;
1243 static void vl_api_get_node_index_reply_t_handler
1244 (vl_api_get_node_index_reply_t * mp)
1246 vat_main_t *vam = &vat_main;
1247 i32 retval = ntohl (mp->retval);
1248 if (vam->async_mode)
1250 vam->async_errors += (retval < 0);
1254 vam->retval = retval;
1256 errmsg ("node index %d", ntohl (mp->node_index));
1257 vam->result_ready = 1;
1261 static void vl_api_get_node_index_reply_t_handler_json
1262 (vl_api_get_node_index_reply_t * mp)
1264 vat_main_t *vam = &vat_main;
1265 vat_json_node_t node;
1267 vat_json_init_object (&node);
1268 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1269 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1271 vat_json_print (vam->ofp, &node);
1272 vat_json_free (&node);
1274 vam->retval = ntohl (mp->retval);
1275 vam->result_ready = 1;
1278 static void vl_api_get_next_index_reply_t_handler
1279 (vl_api_get_next_index_reply_t * mp)
1281 vat_main_t *vam = &vat_main;
1282 i32 retval = ntohl (mp->retval);
1283 if (vam->async_mode)
1285 vam->async_errors += (retval < 0);
1289 vam->retval = retval;
1291 errmsg ("next node index %d", ntohl (mp->next_index));
1292 vam->result_ready = 1;
1296 static void vl_api_get_next_index_reply_t_handler_json
1297 (vl_api_get_next_index_reply_t * mp)
1299 vat_main_t *vam = &vat_main;
1300 vat_json_node_t node;
1302 vat_json_init_object (&node);
1303 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1304 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1306 vat_json_print (vam->ofp, &node);
1307 vat_json_free (&node);
1309 vam->retval = ntohl (mp->retval);
1310 vam->result_ready = 1;
1313 static void vl_api_add_node_next_reply_t_handler
1314 (vl_api_add_node_next_reply_t * mp)
1316 vat_main_t *vam = &vat_main;
1317 i32 retval = ntohl (mp->retval);
1318 if (vam->async_mode)
1320 vam->async_errors += (retval < 0);
1324 vam->retval = retval;
1326 errmsg ("next index %d", ntohl (mp->next_index));
1327 vam->result_ready = 1;
1331 static void vl_api_add_node_next_reply_t_handler_json
1332 (vl_api_add_node_next_reply_t * mp)
1334 vat_main_t *vam = &vat_main;
1335 vat_json_node_t node;
1337 vat_json_init_object (&node);
1338 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1339 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1341 vat_json_print (vam->ofp, &node);
1342 vat_json_free (&node);
1344 vam->retval = ntohl (mp->retval);
1345 vam->result_ready = 1;
1348 static void vl_api_show_version_reply_t_handler
1349 (vl_api_show_version_reply_t * mp)
1351 vat_main_t *vam = &vat_main;
1352 i32 retval = ntohl (mp->retval);
1356 errmsg (" program: %s", mp->program);
1357 errmsg (" version: %s", mp->version);
1358 errmsg (" build date: %s", mp->build_date);
1359 errmsg ("build directory: %s", mp->build_directory);
1361 vam->retval = retval;
1362 vam->result_ready = 1;
1365 static void vl_api_show_version_reply_t_handler_json
1366 (vl_api_show_version_reply_t * mp)
1368 vat_main_t *vam = &vat_main;
1369 vat_json_node_t node;
1371 vat_json_init_object (&node);
1372 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1373 vat_json_object_add_string_copy (&node, "program", mp->program);
1374 vat_json_object_add_string_copy (&node, "version", mp->version);
1375 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1376 vat_json_object_add_string_copy (&node, "build_directory",
1377 mp->build_directory);
1379 vat_json_print (vam->ofp, &node);
1380 vat_json_free (&node);
1382 vam->retval = ntohl (mp->retval);
1383 vam->result_ready = 1;
1386 static void vl_api_show_threads_reply_t_handler
1387 (vl_api_show_threads_reply_t * mp)
1389 vat_main_t *vam = &vat_main;
1390 i32 retval = ntohl (mp->retval);
1394 count = ntohl (mp->count);
1396 for (i = 0; i < count; i++)
1398 "\n%-2d %-11s %-11s %-5d %-6d %-4d %-6d",
1399 ntohl (mp->thread_data[i].id), mp->thread_data[i].name,
1400 mp->thread_data[i].type, ntohl (mp->thread_data[i].pid),
1401 ntohl (mp->thread_data[i].cpu_id), ntohl (mp->thread_data[i].core),
1402 ntohl (mp->thread_data[i].cpu_socket));
1404 vam->retval = retval;
1405 vam->result_ready = 1;
1408 static void vl_api_show_threads_reply_t_handler_json
1409 (vl_api_show_threads_reply_t * mp)
1411 vat_main_t *vam = &vat_main;
1412 vat_json_node_t node;
1413 vl_api_thread_data_t *td;
1414 i32 retval = ntohl (mp->retval);
1418 count = ntohl (mp->count);
1420 vat_json_init_object (&node);
1421 vat_json_object_add_int (&node, "retval", retval);
1422 vat_json_object_add_uint (&node, "count", count);
1424 for (i = 0; i < count; i++)
1426 td = &mp->thread_data[i];
1427 vat_json_object_add_uint (&node, "id", ntohl (td->id));
1428 vat_json_object_add_string_copy (&node, "name", td->name);
1429 vat_json_object_add_string_copy (&node, "type", td->type);
1430 vat_json_object_add_uint (&node, "pid", ntohl (td->pid));
1431 vat_json_object_add_int (&node, "cpu_id", ntohl (td->cpu_id));
1432 vat_json_object_add_int (&node, "core", ntohl (td->id));
1433 vat_json_object_add_int (&node, "cpu_socket", ntohl (td->cpu_socket));
1436 vat_json_print (vam->ofp, &node);
1437 vat_json_free (&node);
1439 vam->retval = retval;
1440 vam->result_ready = 1;
1444 api_show_threads (vat_main_t * vam)
1446 vl_api_show_threads_t *mp;
1450 "\n%-2s %-11s %-11s %-5s %-6s %-4s %-6s",
1451 "ID", "Name", "Type", "LWP", "cpu_id", "Core", "Socket");
1453 M (SHOW_THREADS, mp);
1461 vl_api_l2_macs_event_t_handler (vl_api_l2_macs_event_t * mp)
1463 u32 n_macs = ntohl (mp->n_macs);
1464 errmsg ("L2MAC event received with pid %d cl-idx %d for %d macs: \n",
1465 ntohl (mp->pid), mp->client_index, n_macs);
1467 for (i = 0; i < n_macs; i++)
1469 vl_api_mac_entry_t *mac = &mp->mac[i];
1470 errmsg (" [%d] sw_if_index %d mac_addr %U action %d \n",
1471 i + 1, ntohl (mac->sw_if_index),
1472 format_ethernet_address, mac->mac_addr, mac->action);
1479 vl_api_l2_macs_event_t_handler_json (vl_api_l2_macs_event_t * mp)
1481 /* JSON output not supported */
1484 #define vl_api_bridge_domain_details_t_endian vl_noop_handler
1485 #define vl_api_bridge_domain_details_t_print vl_noop_handler
1488 * Special-case: build the bridge domain table, maintain
1489 * the next bd id vbl.
1491 static void vl_api_bridge_domain_details_t_handler
1492 (vl_api_bridge_domain_details_t * mp)
1494 vat_main_t *vam = &vat_main;
1495 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1498 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-6s %-3s",
1499 " ID", "LRN", "FWD", "FLD", "BVI", "UU-FWD", "#IF");
1501 print (vam->ofp, "%3d %3d %3d %3d %3d %6d %3d",
1502 ntohl (mp->bd_id), mp->learn, mp->forward,
1503 mp->flood, ntohl (mp->bvi_sw_if_index),
1504 ntohl (mp->uu_fwd_sw_if_index), n_sw_ifs);
1508 vl_api_bridge_domain_sw_if_t *sw_ifs;
1509 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG",
1512 sw_ifs = mp->sw_if_details;
1513 for (i = 0; i < n_sw_ifs; i++)
1519 sw_if_index = ntohl (sw_ifs->sw_if_index);
1522 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1524 if ((u32) p->value[0] == sw_if_index)
1526 sw_if_name = (u8 *)(p->key);
1531 print (vam->ofp, "%7d %3d %s", sw_if_index,
1532 sw_ifs->shg, sw_if_name ? (char *) sw_if_name :
1533 "sw_if_index not found!");
1540 static void vl_api_bridge_domain_details_t_handler_json
1541 (vl_api_bridge_domain_details_t * mp)
1543 vat_main_t *vam = &vat_main;
1544 vat_json_node_t *node, *array = NULL;
1545 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1547 if (VAT_JSON_ARRAY != vam->json_tree.type)
1549 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1550 vat_json_init_array (&vam->json_tree);
1552 node = vat_json_array_add (&vam->json_tree);
1554 vat_json_init_object (node);
1555 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1556 vat_json_object_add_uint (node, "flood", mp->flood);
1557 vat_json_object_add_uint (node, "forward", mp->forward);
1558 vat_json_object_add_uint (node, "learn", mp->learn);
1559 vat_json_object_add_uint (node, "bvi_sw_if_index",
1560 ntohl (mp->bvi_sw_if_index));
1561 vat_json_object_add_uint (node, "n_sw_ifs", n_sw_ifs);
1562 array = vat_json_object_add (node, "sw_if");
1563 vat_json_init_array (array);
1569 vl_api_bridge_domain_sw_if_t *sw_ifs;
1572 sw_ifs = mp->sw_if_details;
1573 for (i = 0; i < n_sw_ifs; i++)
1575 node = vat_json_array_add (array);
1576 vat_json_init_object (node);
1577 vat_json_object_add_uint (node, "sw_if_index",
1578 ntohl (sw_ifs->sw_if_index));
1579 vat_json_object_add_uint (node, "shg", sw_ifs->shg);
1585 static void vl_api_control_ping_reply_t_handler
1586 (vl_api_control_ping_reply_t * mp)
1588 vat_main_t *vam = &vat_main;
1589 i32 retval = ntohl (mp->retval);
1590 if (vam->async_mode)
1592 vam->async_errors += (retval < 0);
1596 vam->retval = retval;
1597 vam->result_ready = 1;
1599 if (vam->socket_client_main)
1600 vam->socket_client_main->control_pings_outstanding--;
1603 static void vl_api_control_ping_reply_t_handler_json
1604 (vl_api_control_ping_reply_t * mp)
1606 vat_main_t *vam = &vat_main;
1607 i32 retval = ntohl (mp->retval);
1609 if (VAT_JSON_NONE != vam->json_tree.type)
1611 vat_json_print (vam->ofp, &vam->json_tree);
1612 vat_json_free (&vam->json_tree);
1613 vam->json_tree.type = VAT_JSON_NONE;
1618 vat_json_init_array (&vam->json_tree);
1619 vat_json_print (vam->ofp, &vam->json_tree);
1620 vam->json_tree.type = VAT_JSON_NONE;
1623 vam->retval = retval;
1624 vam->result_ready = 1;
1628 vl_api_bridge_domain_set_mac_age_reply_t_handler
1629 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1631 vat_main_t *vam = &vat_main;
1632 i32 retval = ntohl (mp->retval);
1633 if (vam->async_mode)
1635 vam->async_errors += (retval < 0);
1639 vam->retval = retval;
1640 vam->result_ready = 1;
1644 static void vl_api_bridge_domain_set_mac_age_reply_t_handler_json
1645 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1647 vat_main_t *vam = &vat_main;
1648 vat_json_node_t node;
1650 vat_json_init_object (&node);
1651 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1653 vat_json_print (vam->ofp, &node);
1654 vat_json_free (&node);
1656 vam->retval = ntohl (mp->retval);
1657 vam->result_ready = 1;
1661 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1663 vat_main_t *vam = &vat_main;
1664 i32 retval = ntohl (mp->retval);
1665 if (vam->async_mode)
1667 vam->async_errors += (retval < 0);
1671 vam->retval = retval;
1672 vam->result_ready = 1;
1676 static void vl_api_l2_flags_reply_t_handler_json
1677 (vl_api_l2_flags_reply_t * mp)
1679 vat_main_t *vam = &vat_main;
1680 vat_json_node_t node;
1682 vat_json_init_object (&node);
1683 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1684 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1685 ntohl (mp->resulting_feature_bitmap));
1687 vat_json_print (vam->ofp, &node);
1688 vat_json_free (&node);
1690 vam->retval = ntohl (mp->retval);
1691 vam->result_ready = 1;
1694 static void vl_api_bridge_flags_reply_t_handler
1695 (vl_api_bridge_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_bridge_flags_reply_t_handler_json
1711 (vl_api_bridge_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;
1729 vl_api_tap_create_v2_reply_t_handler (vl_api_tap_create_v2_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->sw_if_index = ntohl (mp->sw_if_index);
1741 vam->result_ready = 1;
1746 static void vl_api_tap_create_v2_reply_t_handler_json
1747 (vl_api_tap_create_v2_reply_t * mp)
1749 vat_main_t *vam = &vat_main;
1750 vat_json_node_t node;
1752 vat_json_init_object (&node);
1753 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1754 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1756 vat_json_print (vam->ofp, &node);
1757 vat_json_free (&node);
1759 vam->retval = ntohl (mp->retval);
1760 vam->result_ready = 1;
1765 vl_api_tap_delete_v2_reply_t_handler (vl_api_tap_delete_v2_reply_t * mp)
1767 vat_main_t *vam = &vat_main;
1768 i32 retval = ntohl (mp->retval);
1769 if (vam->async_mode)
1771 vam->async_errors += (retval < 0);
1775 vam->retval = retval;
1776 vam->result_ready = 1;
1780 static void vl_api_tap_delete_v2_reply_t_handler_json
1781 (vl_api_tap_delete_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));
1789 vat_json_print (vam->ofp, &node);
1790 vat_json_free (&node);
1792 vam->retval = ntohl (mp->retval);
1793 vam->result_ready = 1;
1797 vl_api_virtio_pci_create_reply_t_handler (vl_api_virtio_pci_create_reply_t *
1800 vat_main_t *vam = &vat_main;
1801 i32 retval = ntohl (mp->retval);
1802 if (vam->async_mode)
1804 vam->async_errors += (retval < 0);
1808 vam->retval = retval;
1809 vam->sw_if_index = ntohl (mp->sw_if_index);
1810 vam->result_ready = 1;
1814 static void vl_api_virtio_pci_create_reply_t_handler_json
1815 (vl_api_virtio_pci_create_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));
1822 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1824 vat_json_print (vam->ofp, &node);
1825 vat_json_free (&node);
1827 vam->retval = ntohl (mp->retval);
1828 vam->result_ready = 1;
1833 vl_api_virtio_pci_delete_reply_t_handler (vl_api_virtio_pci_delete_reply_t *
1836 vat_main_t *vam = &vat_main;
1837 i32 retval = ntohl (mp->retval);
1838 if (vam->async_mode)
1840 vam->async_errors += (retval < 0);
1844 vam->retval = retval;
1845 vam->result_ready = 1;
1849 static void vl_api_virtio_pci_delete_reply_t_handler_json
1850 (vl_api_virtio_pci_delete_reply_t * mp)
1852 vat_main_t *vam = &vat_main;
1853 vat_json_node_t node;
1855 vat_json_init_object (&node);
1856 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1858 vat_json_print (vam->ofp, &node);
1859 vat_json_free (&node);
1861 vam->retval = ntohl (mp->retval);
1862 vam->result_ready = 1;
1866 vl_api_bond_create_reply_t_handler (vl_api_bond_create_reply_t * mp)
1868 vat_main_t *vam = &vat_main;
1869 i32 retval = ntohl (mp->retval);
1871 if (vam->async_mode)
1873 vam->async_errors += (retval < 0);
1877 vam->retval = retval;
1878 vam->sw_if_index = ntohl (mp->sw_if_index);
1879 vam->result_ready = 1;
1883 static void vl_api_bond_create_reply_t_handler_json
1884 (vl_api_bond_create_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));
1891 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1893 vat_json_print (vam->ofp, &node);
1894 vat_json_free (&node);
1896 vam->retval = ntohl (mp->retval);
1897 vam->result_ready = 1;
1901 vl_api_bond_delete_reply_t_handler (vl_api_bond_delete_reply_t * mp)
1903 vat_main_t *vam = &vat_main;
1904 i32 retval = ntohl (mp->retval);
1906 if (vam->async_mode)
1908 vam->async_errors += (retval < 0);
1912 vam->retval = retval;
1913 vam->result_ready = 1;
1917 static void vl_api_bond_delete_reply_t_handler_json
1918 (vl_api_bond_delete_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));
1926 vat_json_print (vam->ofp, &node);
1927 vat_json_free (&node);
1929 vam->retval = ntohl (mp->retval);
1930 vam->result_ready = 1;
1934 vl_api_bond_enslave_reply_t_handler (vl_api_bond_enslave_reply_t * mp)
1936 vat_main_t *vam = &vat_main;
1937 i32 retval = ntohl (mp->retval);
1939 if (vam->async_mode)
1941 vam->async_errors += (retval < 0);
1945 vam->retval = retval;
1946 vam->result_ready = 1;
1950 static void vl_api_bond_enslave_reply_t_handler_json
1951 (vl_api_bond_enslave_reply_t * mp)
1953 vat_main_t *vam = &vat_main;
1954 vat_json_node_t node;
1956 vat_json_init_object (&node);
1957 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1959 vat_json_print (vam->ofp, &node);
1960 vat_json_free (&node);
1962 vam->retval = ntohl (mp->retval);
1963 vam->result_ready = 1;
1967 vl_api_bond_detach_slave_reply_t_handler (vl_api_bond_detach_slave_reply_t *
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_detach_slave_reply_t_handler_json
1985 (vl_api_bond_detach_slave_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 api_sw_interface_set_bond_weight (vat_main_t * vam)
2003 unformat_input_t *i = vam->input;
2004 vl_api_sw_interface_set_bond_weight_t *mp;
2005 u32 sw_if_index = ~0;
2007 u8 weight_enter = 0;
2010 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2012 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2014 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2016 else if (unformat (i, "weight %u", &weight))
2022 if (sw_if_index == ~0)
2024 errmsg ("missing interface name or sw_if_index");
2027 if (weight_enter == 0)
2029 errmsg ("missing valid weight");
2033 /* Construct the API message */
2034 M (SW_INTERFACE_SET_BOND_WEIGHT, mp);
2035 mp->sw_if_index = ntohl (sw_if_index);
2036 mp->weight = ntohl (weight);
2043 static void vl_api_sw_interface_bond_details_t_handler
2044 (vl_api_sw_interface_bond_details_t * mp)
2046 vat_main_t *vam = &vat_main;
2049 "%-16s %-12d %-12U %-13U %-14u %-14u",
2050 mp->interface_name, ntohl (mp->sw_if_index),
2051 format_bond_mode, ntohl (mp->mode), format_bond_load_balance,
2052 ntohl (mp->lb), ntohl (mp->active_slaves), ntohl (mp->slaves));
2055 static void vl_api_sw_interface_bond_details_t_handler_json
2056 (vl_api_sw_interface_bond_details_t * mp)
2058 vat_main_t *vam = &vat_main;
2059 vat_json_node_t *node = NULL;
2061 if (VAT_JSON_ARRAY != vam->json_tree.type)
2063 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2064 vat_json_init_array (&vam->json_tree);
2066 node = vat_json_array_add (&vam->json_tree);
2068 vat_json_init_object (node);
2069 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2070 vat_json_object_add_string_copy (node, "interface_name",
2071 mp->interface_name);
2072 vat_json_object_add_uint (node, "mode", ntohl (mp->mode));
2073 vat_json_object_add_uint (node, "load_balance", ntohl (mp->lb));
2074 vat_json_object_add_uint (node, "active_slaves", ntohl (mp->active_slaves));
2075 vat_json_object_add_uint (node, "slaves", ntohl (mp->slaves));
2079 api_sw_interface_bond_dump (vat_main_t * vam)
2081 vl_api_sw_interface_bond_dump_t *mp;
2082 vl_api_control_ping_t *mp_ping;
2086 "\n%-16s %-12s %-12s %-13s %-14s %-14s",
2087 "interface name", "sw_if_index", "mode", "load balance",
2088 "active slaves", "slaves");
2090 /* Get list of bond interfaces */
2091 M (SW_INTERFACE_BOND_DUMP, mp);
2094 /* Use a control ping for synchronization */
2095 MPING (CONTROL_PING, mp_ping);
2102 static void vl_api_sw_interface_slave_details_t_handler
2103 (vl_api_sw_interface_slave_details_t * mp)
2105 vat_main_t *vam = &vat_main;
2108 "%-25s %-12d %-7d %-12d %-10d %-10d", mp->interface_name,
2109 ntohl (mp->sw_if_index), mp->is_passive, mp->is_long_timeout,
2110 ntohl (mp->weight), mp->is_local_numa);
2113 static void vl_api_sw_interface_slave_details_t_handler_json
2114 (vl_api_sw_interface_slave_details_t * mp)
2116 vat_main_t *vam = &vat_main;
2117 vat_json_node_t *node = NULL;
2119 if (VAT_JSON_ARRAY != vam->json_tree.type)
2121 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2122 vat_json_init_array (&vam->json_tree);
2124 node = vat_json_array_add (&vam->json_tree);
2126 vat_json_init_object (node);
2127 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
2128 vat_json_object_add_string_copy (node, "interface_name",
2129 mp->interface_name);
2130 vat_json_object_add_uint (node, "passive", mp->is_passive);
2131 vat_json_object_add_uint (node, "long_timeout", mp->is_long_timeout);
2132 vat_json_object_add_uint (node, "weight", ntohl (mp->weight));
2133 vat_json_object_add_uint (node, "is_local_numa", mp->is_local_numa);
2137 api_sw_interface_slave_dump (vat_main_t * vam)
2139 unformat_input_t *i = vam->input;
2140 vl_api_sw_interface_slave_dump_t *mp;
2141 vl_api_control_ping_t *mp_ping;
2142 u32 sw_if_index = ~0;
2143 u8 sw_if_index_set = 0;
2146 /* Parse args required to build the message */
2147 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2149 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
2150 sw_if_index_set = 1;
2151 else if (unformat (i, "sw_if_index %d", &sw_if_index))
2152 sw_if_index_set = 1;
2157 if (sw_if_index_set == 0)
2159 errmsg ("missing vpp interface name. ");
2164 "\n%-25s %-12s %-7s %-12s %-10s %-10s",
2165 "slave interface name", "sw_if_index", "passive", "long_timeout",
2166 "weight", "local numa");
2168 /* Get list of bond interfaces */
2169 M (SW_INTERFACE_SLAVE_DUMP, mp);
2170 mp->sw_if_index = ntohl (sw_if_index);
2173 /* Use a control ping for synchronization */
2174 MPING (CONTROL_PING, mp_ping);
2181 static void vl_api_mpls_tunnel_add_del_reply_t_handler
2182 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2184 vat_main_t *vam = &vat_main;
2185 i32 retval = ntohl (mp->retval);
2186 if (vam->async_mode)
2188 vam->async_errors += (retval < 0);
2192 vam->retval = retval;
2193 vam->sw_if_index = ntohl (mp->sw_if_index);
2194 vam->result_ready = 1;
2196 vam->regenerate_interface_table = 1;
2199 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
2200 (vl_api_mpls_tunnel_add_del_reply_t * mp)
2202 vat_main_t *vam = &vat_main;
2203 vat_json_node_t node;
2205 vat_json_init_object (&node);
2206 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2207 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
2208 ntohl (mp->sw_if_index));
2210 vat_json_print (vam->ofp, &node);
2211 vat_json_free (&node);
2213 vam->retval = ntohl (mp->retval);
2214 vam->result_ready = 1;
2217 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
2218 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2220 vat_main_t *vam = &vat_main;
2221 i32 retval = ntohl (mp->retval);
2222 if (vam->async_mode)
2224 vam->async_errors += (retval < 0);
2228 vam->retval = retval;
2229 vam->sw_if_index = ntohl (mp->sw_if_index);
2230 vam->result_ready = 1;
2234 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
2235 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
2237 vat_main_t *vam = &vat_main;
2238 vat_json_node_t node;
2240 vat_json_init_object (&node);
2241 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2242 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2244 vat_json_print (vam->ofp, &node);
2245 vat_json_free (&node);
2247 vam->retval = ntohl (mp->retval);
2248 vam->result_ready = 1;
2251 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler
2252 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2254 vat_main_t *vam = &vat_main;
2255 i32 retval = ntohl (mp->retval);
2256 if (vam->async_mode)
2258 vam->async_errors += (retval < 0);
2262 vam->retval = retval;
2263 vam->result_ready = 1;
2267 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler_json
2268 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
2270 vat_main_t *vam = &vat_main;
2271 vat_json_node_t node;
2273 vat_json_init_object (&node);
2274 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2275 vat_json_object_add_uint (&node, "fwd_entry_index",
2276 clib_net_to_host_u32 (mp->fwd_entry_index));
2278 vat_json_print (vam->ofp, &node);
2279 vat_json_free (&node);
2281 vam->retval = ntohl (mp->retval);
2282 vam->result_ready = 1;
2286 format_lisp_transport_protocol (u8 * s, va_list * args)
2288 u32 proto = va_arg (*args, u32);
2293 return format (s, "udp");
2295 return format (s, "api");
2302 static void vl_api_one_get_transport_protocol_reply_t_handler
2303 (vl_api_one_get_transport_protocol_reply_t * mp)
2305 vat_main_t *vam = &vat_main;
2306 i32 retval = ntohl (mp->retval);
2307 if (vam->async_mode)
2309 vam->async_errors += (retval < 0);
2313 u32 proto = mp->protocol;
2314 print (vam->ofp, "Transport protocol: %U",
2315 format_lisp_transport_protocol, proto);
2316 vam->retval = retval;
2317 vam->result_ready = 1;
2321 static void vl_api_one_get_transport_protocol_reply_t_handler_json
2322 (vl_api_one_get_transport_protocol_reply_t * mp)
2324 vat_main_t *vam = &vat_main;
2325 vat_json_node_t node;
2328 s = format (0, "%U", format_lisp_transport_protocol, mp->protocol);
2331 vat_json_init_object (&node);
2332 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2333 vat_json_object_add_string_copy (&node, "transport-protocol", s);
2336 vat_json_print (vam->ofp, &node);
2337 vat_json_free (&node);
2339 vam->retval = ntohl (mp->retval);
2340 vam->result_ready = 1;
2343 static void vl_api_one_add_del_locator_set_reply_t_handler
2344 (vl_api_one_add_del_locator_set_reply_t * mp)
2346 vat_main_t *vam = &vat_main;
2347 i32 retval = ntohl (mp->retval);
2348 if (vam->async_mode)
2350 vam->async_errors += (retval < 0);
2354 vam->retval = retval;
2355 vam->result_ready = 1;
2359 static void vl_api_one_add_del_locator_set_reply_t_handler_json
2360 (vl_api_one_add_del_locator_set_reply_t * mp)
2362 vat_main_t *vam = &vat_main;
2363 vat_json_node_t node;
2365 vat_json_init_object (&node);
2366 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2367 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
2369 vat_json_print (vam->ofp, &node);
2370 vat_json_free (&node);
2372 vam->retval = ntohl (mp->retval);
2373 vam->result_ready = 1;
2376 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
2377 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2379 vat_main_t *vam = &vat_main;
2380 i32 retval = ntohl (mp->retval);
2381 if (vam->async_mode)
2383 vam->async_errors += (retval < 0);
2387 vam->retval = retval;
2388 vam->sw_if_index = ntohl (mp->sw_if_index);
2389 vam->result_ready = 1;
2391 vam->regenerate_interface_table = 1;
2394 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
2395 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
2397 vat_main_t *vam = &vat_main;
2398 vat_json_node_t node;
2400 vat_json_init_object (&node);
2401 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2402 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2404 vat_json_print (vam->ofp, &node);
2405 vat_json_free (&node);
2407 vam->retval = ntohl (mp->retval);
2408 vam->result_ready = 1;
2411 static void vl_api_vxlan_offload_rx_reply_t_handler
2412 (vl_api_vxlan_offload_rx_reply_t * mp)
2414 vat_main_t *vam = &vat_main;
2415 i32 retval = ntohl (mp->retval);
2416 if (vam->async_mode)
2418 vam->async_errors += (retval < 0);
2422 vam->retval = retval;
2423 vam->result_ready = 1;
2427 static void vl_api_vxlan_offload_rx_reply_t_handler_json
2428 (vl_api_vxlan_offload_rx_reply_t * mp)
2430 vat_main_t *vam = &vat_main;
2431 vat_json_node_t node;
2433 vat_json_init_object (&node);
2434 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2436 vat_json_print (vam->ofp, &node);
2437 vat_json_free (&node);
2439 vam->retval = ntohl (mp->retval);
2440 vam->result_ready = 1;
2443 static void vl_api_geneve_add_del_tunnel_reply_t_handler
2444 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2446 vat_main_t *vam = &vat_main;
2447 i32 retval = ntohl (mp->retval);
2448 if (vam->async_mode)
2450 vam->async_errors += (retval < 0);
2454 vam->retval = retval;
2455 vam->sw_if_index = ntohl (mp->sw_if_index);
2456 vam->result_ready = 1;
2460 static void vl_api_geneve_add_del_tunnel_reply_t_handler_json
2461 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2463 vat_main_t *vam = &vat_main;
2464 vat_json_node_t node;
2466 vat_json_init_object (&node);
2467 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2468 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2470 vat_json_print (vam->ofp, &node);
2471 vat_json_free (&node);
2473 vam->retval = ntohl (mp->retval);
2474 vam->result_ready = 1;
2477 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler
2478 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2480 vat_main_t *vam = &vat_main;
2481 i32 retval = ntohl (mp->retval);
2482 if (vam->async_mode)
2484 vam->async_errors += (retval < 0);
2488 vam->retval = retval;
2489 vam->sw_if_index = ntohl (mp->sw_if_index);
2490 vam->result_ready = 1;
2492 vam->regenerate_interface_table = 1;
2495 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler_json
2496 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2498 vat_main_t *vam = &vat_main;
2499 vat_json_node_t node;
2501 vat_json_init_object (&node);
2502 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2503 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2505 vat_json_print (vam->ofp, &node);
2506 vat_json_free (&node);
2508 vam->retval = ntohl (mp->retval);
2509 vam->result_ready = 1;
2512 static void vl_api_gre_tunnel_add_del_reply_t_handler
2513 (vl_api_gre_tunnel_add_del_reply_t * mp)
2515 vat_main_t *vam = &vat_main;
2516 i32 retval = ntohl (mp->retval);
2517 if (vam->async_mode)
2519 vam->async_errors += (retval < 0);
2523 vam->retval = retval;
2524 vam->sw_if_index = ntohl (mp->sw_if_index);
2525 vam->result_ready = 1;
2529 static void vl_api_gre_tunnel_add_del_reply_t_handler_json
2530 (vl_api_gre_tunnel_add_del_reply_t * mp)
2532 vat_main_t *vam = &vat_main;
2533 vat_json_node_t node;
2535 vat_json_init_object (&node);
2536 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2537 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2539 vat_json_print (vam->ofp, &node);
2540 vat_json_free (&node);
2542 vam->retval = ntohl (mp->retval);
2543 vam->result_ready = 1;
2546 static void vl_api_create_vhost_user_if_reply_t_handler
2547 (vl_api_create_vhost_user_if_reply_t * mp)
2549 vat_main_t *vam = &vat_main;
2550 i32 retval = ntohl (mp->retval);
2551 if (vam->async_mode)
2553 vam->async_errors += (retval < 0);
2557 vam->retval = retval;
2558 vam->sw_if_index = ntohl (mp->sw_if_index);
2559 vam->result_ready = 1;
2561 vam->regenerate_interface_table = 1;
2564 static void vl_api_create_vhost_user_if_reply_t_handler_json
2565 (vl_api_create_vhost_user_if_reply_t * mp)
2567 vat_main_t *vam = &vat_main;
2568 vat_json_node_t node;
2570 vat_json_init_object (&node);
2571 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2572 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2574 vat_json_print (vam->ofp, &node);
2575 vat_json_free (&node);
2577 vam->retval = ntohl (mp->retval);
2578 vam->result_ready = 1;
2581 static void vl_api_ip_address_details_t_handler
2582 (vl_api_ip_address_details_t * mp)
2584 vat_main_t *vam = &vat_main;
2585 static ip_address_details_t empty_ip_address_details = { {0} };
2586 ip_address_details_t *address = NULL;
2587 ip_details_t *current_ip_details = NULL;
2588 ip_details_t *details = NULL;
2590 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
2592 if (!details || vam->current_sw_if_index >= vec_len (details)
2593 || !details[vam->current_sw_if_index].present)
2595 errmsg ("ip address details arrived but not stored");
2596 errmsg ("ip_dump should be called first");
2600 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
2602 #define addresses (current_ip_details->addr)
2604 vec_validate_init_empty (addresses, vec_len (addresses),
2605 empty_ip_address_details);
2607 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
2609 clib_memcpy (&address->ip, &mp->prefix.address.un, sizeof (address->ip));
2610 address->prefix_length = mp->prefix.len;
2614 static void vl_api_ip_address_details_t_handler_json
2615 (vl_api_ip_address_details_t * mp)
2617 vat_main_t *vam = &vat_main;
2618 vat_json_node_t *node = NULL;
2620 if (VAT_JSON_ARRAY != vam->json_tree.type)
2622 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2623 vat_json_init_array (&vam->json_tree);
2625 node = vat_json_array_add (&vam->json_tree);
2627 vat_json_init_object (node);
2628 vat_json_object_add_prefix (node, &mp->prefix);
2632 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
2634 vat_main_t *vam = &vat_main;
2635 static ip_details_t empty_ip_details = { 0 };
2636 ip_details_t *ip = NULL;
2637 u32 sw_if_index = ~0;
2639 sw_if_index = ntohl (mp->sw_if_index);
2641 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2642 sw_if_index, empty_ip_details);
2644 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2651 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
2653 vat_main_t *vam = &vat_main;
2655 if (VAT_JSON_ARRAY != vam->json_tree.type)
2657 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2658 vat_json_init_array (&vam->json_tree);
2660 vat_json_array_add_uint (&vam->json_tree,
2661 clib_net_to_host_u32 (mp->sw_if_index));
2664 static void vl_api_get_first_msg_id_reply_t_handler
2665 (vl_api_get_first_msg_id_reply_t * mp)
2667 vat_main_t *vam = &vat_main;
2668 i32 retval = ntohl (mp->retval);
2670 if (vam->async_mode)
2672 vam->async_errors += (retval < 0);
2676 vam->retval = retval;
2677 vam->result_ready = 1;
2681 errmsg ("first message id %d", ntohs (mp->first_msg_id));
2685 static void vl_api_get_first_msg_id_reply_t_handler_json
2686 (vl_api_get_first_msg_id_reply_t * mp)
2688 vat_main_t *vam = &vat_main;
2689 vat_json_node_t node;
2691 vat_json_init_object (&node);
2692 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2693 vat_json_object_add_uint (&node, "first_msg_id",
2694 (uint) ntohs (mp->first_msg_id));
2696 vat_json_print (vam->ofp, &node);
2697 vat_json_free (&node);
2699 vam->retval = ntohl (mp->retval);
2700 vam->result_ready = 1;
2703 static void vl_api_get_node_graph_reply_t_handler
2704 (vl_api_get_node_graph_reply_t * mp)
2706 vat_main_t *vam = &vat_main;
2707 i32 retval = ntohl (mp->retval);
2708 u8 *pvt_copy, *reply;
2713 if (vam->async_mode)
2715 vam->async_errors += (retval < 0);
2719 vam->retval = retval;
2720 vam->result_ready = 1;
2723 /* "Should never happen..." */
2727 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2728 pvt_copy = vec_dup (reply);
2730 /* Toss the shared-memory original... */
2731 oldheap = vl_msg_push_heap ();
2735 vl_msg_pop_heap (oldheap);
2737 if (vam->graph_nodes)
2739 hash_free (vam->graph_node_index_by_name);
2741 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2743 node = vam->graph_nodes[0][i];
2744 vec_free (node->name);
2745 vec_free (node->next_nodes);
2748 vec_free (vam->graph_nodes[0]);
2749 vec_free (vam->graph_nodes);
2752 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2753 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2754 vec_free (pvt_copy);
2756 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
2758 node = vam->graph_nodes[0][i];
2759 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2763 static void vl_api_get_node_graph_reply_t_handler_json
2764 (vl_api_get_node_graph_reply_t * mp)
2766 vat_main_t *vam = &vat_main;
2768 vat_json_node_t node;
2771 /* $$$$ make this real? */
2772 vat_json_init_object (&node);
2773 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2774 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2776 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2778 /* Toss the shared-memory original... */
2779 oldheap = vl_msg_push_heap ();
2783 vl_msg_pop_heap (oldheap);
2785 vat_json_print (vam->ofp, &node);
2786 vat_json_free (&node);
2788 vam->retval = ntohl (mp->retval);
2789 vam->result_ready = 1;
2793 vl_api_one_locator_details_t_handler (vl_api_one_locator_details_t * mp)
2795 vat_main_t *vam = &vat_main;
2800 s = format (s, "%=16d%=16d%=16d",
2801 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2805 s = format (s, "%=16U%=16d%=16d",
2806 format_ip46_address,
2807 mp->ip_address, mp->priority, mp->weight);
2810 print (vam->ofp, "%v", s);
2815 vl_api_one_locator_details_t_handler_json (vl_api_one_locator_details_t * mp)
2817 vat_main_t *vam = &vat_main;
2818 vat_json_node_t *node = NULL;
2819 struct in6_addr ip6;
2822 if (VAT_JSON_ARRAY != vam->json_tree.type)
2824 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2825 vat_json_init_array (&vam->json_tree);
2827 node = vat_json_array_add (&vam->json_tree);
2828 vat_json_init_object (node);
2830 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2831 vat_json_object_add_uint (node, "priority", mp->priority);
2832 vat_json_object_add_uint (node, "weight", mp->weight);
2835 vat_json_object_add_uint (node, "sw_if_index",
2836 clib_net_to_host_u32 (mp->sw_if_index));
2839 if (mp->ip_address.af)
2841 clib_memcpy (&ip6, mp->ip_address.un.ip6, sizeof (ip6));
2842 vat_json_object_add_ip6 (node, "address", ip6);
2846 clib_memcpy (&ip4, mp->ip_address.un.ip4, sizeof (ip4));
2847 vat_json_object_add_ip4 (node, "address", ip4);
2853 vl_api_one_locator_set_details_t_handler (vl_api_one_locator_set_details_t *
2856 vat_main_t *vam = &vat_main;
2859 ls_name = format (0, "%s", mp->ls_name);
2861 print (vam->ofp, "%=10d%=15v", clib_net_to_host_u32 (mp->ls_index),
2867 vl_api_one_locator_set_details_t_handler_json
2868 (vl_api_one_locator_set_details_t * mp)
2870 vat_main_t *vam = &vat_main;
2871 vat_json_node_t *node = 0;
2874 ls_name = format (0, "%s", mp->ls_name);
2875 vec_add1 (ls_name, 0);
2877 if (VAT_JSON_ARRAY != vam->json_tree.type)
2879 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2880 vat_json_init_array (&vam->json_tree);
2882 node = vat_json_array_add (&vam->json_tree);
2884 vat_json_init_object (node);
2885 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2886 vat_json_object_add_uint (node, "ls_index",
2887 clib_net_to_host_u32 (mp->ls_index));
2895 } __attribute__ ((__packed__)) lisp_nsh_api_t;
2898 unformat_nsh_address (unformat_input_t * input, va_list * args)
2900 lisp_nsh_api_t *nsh = va_arg (*args, lisp_nsh_api_t *);
2901 return unformat (input, "SPI:%d SI:%d", &nsh->spi, &nsh->si);
2905 format_nsh_address_vat (u8 * s, va_list * args)
2907 nsh_t *a = va_arg (*args, nsh_t *);
2908 return format (s, "SPI:%d SI:%d", clib_net_to_host_u32 (a->spi), a->si);
2912 format_lisp_flat_eid (u8 * s, va_list * args)
2914 vl_api_eid_t *eid = va_arg (*args, vl_api_eid_t *);
2918 case EID_TYPE_API_PREFIX:
2919 if (eid->address.prefix.address.af)
2920 return format (s, "%U/%d", format_ip6_address,
2921 eid->address.prefix.address.un.ip6,
2922 eid->address.prefix.len);
2923 return format (s, "%U/%d", format_ip4_address,
2924 eid->address.prefix.address.un.ip4,
2925 eid->address.prefix.len);
2926 case EID_TYPE_API_MAC:
2927 return format (s, "%U", format_ethernet_address, eid->address.mac);
2928 case EID_TYPE_API_NSH:
2929 return format (s, "%U", format_nsh_address_vat, eid->address.nsh);
2935 format_lisp_eid_vat (u8 * s, va_list * args)
2937 vl_api_eid_t *deid = va_arg (*args, vl_api_eid_t *);
2938 vl_api_eid_t *seid = va_arg (*args, vl_api_eid_t *);
2939 u8 is_src_dst = (u8) va_arg (*args, int);
2942 s = format (s, "%U|", format_lisp_flat_eid, seid);
2944 s = format (s, "%U", format_lisp_flat_eid, deid);
2950 vl_api_one_eid_table_details_t_handler (vl_api_one_eid_table_details_t * mp)
2952 vat_main_t *vam = &vat_main;
2953 u8 *s = 0, *eid = 0;
2955 if (~0 == mp->locator_set_index)
2956 s = format (0, "action: %d", mp->action);
2958 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
2960 eid = format (0, "%U", format_lisp_eid_vat,
2961 mp->deid, mp->seid, mp->is_src_dst);
2964 print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
2965 clib_net_to_host_u32 (mp->vni),
2967 mp->is_local ? "local" : "remote",
2968 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
2969 clib_net_to_host_u16 (mp->key.id), mp->key.key);
2976 vl_api_one_eid_table_details_t_handler_json (vl_api_one_eid_table_details_t
2979 vat_main_t *vam = &vat_main;
2980 vat_json_node_t *node = 0;
2983 if (VAT_JSON_ARRAY != vam->json_tree.type)
2985 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2986 vat_json_init_array (&vam->json_tree);
2988 node = vat_json_array_add (&vam->json_tree);
2990 vat_json_init_object (node);
2991 if (~0 == mp->locator_set_index)
2992 vat_json_object_add_uint (node, "action", mp->action);
2994 vat_json_object_add_uint (node, "locator_set_index",
2995 clib_net_to_host_u32 (mp->locator_set_index));
2997 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
2998 if (mp->deid.type == 3)
3000 vat_json_node_t *nsh_json = vat_json_object_add (node, "eid");
3001 vat_json_init_object (nsh_json);
3002 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) & mp->deid.address.nsh;
3003 vat_json_object_add_uint (nsh_json, "spi",
3004 clib_net_to_host_u32 (nsh->spi));
3005 vat_json_object_add_uint (nsh_json, "si", nsh->si);
3009 eid = format (0, "%U", format_lisp_eid_vat,
3010 mp->deid, mp->seid, mp->is_src_dst);
3012 vat_json_object_add_string_copy (node, "eid", eid);
3015 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3016 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
3017 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
3021 vat_json_object_add_uint (node, "key_id",
3022 clib_net_to_host_u16 (mp->key.id));
3023 vat_json_object_add_string_copy (node, "key", mp->key.key);
3028 vl_api_one_stats_details_t_handler (vl_api_one_stats_details_t * mp)
3030 vat_main_t *vam = &vat_main;
3031 u8 *seid = 0, *deid = 0;
3032 ip46_address_t lloc, rloc;
3034 deid = format (0, "%U", format_lisp_eid_vat, mp->deid, 0);
3036 seid = format (0, "%U", format_lisp_eid_vat, mp->seid, 0);
3043 clib_memcpy (&lloc.ip6, mp->lloc.un.ip6, 16);
3044 clib_memcpy (&rloc.ip6, mp->rloc.un.ip6, 16);
3048 clib_memcpy (&lloc.ip4, mp->lloc.un.ip4, 4);
3049 clib_memcpy (&rloc.ip4, mp->rloc.un.ip4, 4);
3053 print (vam->ofp, "([%d] %s %s) (%U %U) %u %u",
3054 clib_net_to_host_u32 (mp->vni),
3056 format_ip46_address, lloc,
3057 format_ip46_address, rloc,
3058 clib_net_to_host_u32 (mp->pkt_count),
3059 clib_net_to_host_u32 (mp->bytes));
3066 vl_api_one_stats_details_t_handler_json (vl_api_one_stats_details_t * mp)
3068 struct in6_addr ip6;
3070 vat_main_t *vam = &vat_main;
3071 vat_json_node_t *node = 0;
3072 u8 *deid = 0, *seid = 0;
3074 if (VAT_JSON_ARRAY != vam->json_tree.type)
3076 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3077 vat_json_init_array (&vam->json_tree);
3079 node = vat_json_array_add (&vam->json_tree);
3081 vat_json_init_object (node);
3082 deid = format (0, "%U", format_lisp_eid_vat, mp->deid, 0);
3084 seid = format (0, "%U", format_lisp_eid_vat, mp->seid, 0);
3089 vat_json_object_add_string_copy (node, "seid", seid);
3090 vat_json_object_add_string_copy (node, "deid", deid);
3091 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3095 clib_memcpy (&ip6, mp->lloc.un.ip6, sizeof (ip6));
3096 vat_json_object_add_ip6 (node, "lloc", ip6);
3097 clib_memcpy (&ip6, mp->rloc.un.ip6, sizeof (ip6));
3098 vat_json_object_add_ip6 (node, "rloc", ip6);
3103 clib_memcpy (&ip4, mp->lloc.un.ip4, sizeof (ip4));
3104 vat_json_object_add_ip4 (node, "lloc", ip4);
3105 clib_memcpy (&ip4, mp->rloc.un.ip4, sizeof (ip4));
3106 vat_json_object_add_ip4 (node, "rloc", ip4);
3108 vat_json_object_add_uint (node, "pkt_count",
3109 clib_net_to_host_u32 (mp->pkt_count));
3110 vat_json_object_add_uint (node, "bytes", clib_net_to_host_u32 (mp->bytes));
3117 vl_api_one_eid_table_map_details_t_handler
3118 (vl_api_one_eid_table_map_details_t * mp)
3120 vat_main_t *vam = &vat_main;
3122 u8 *line = format (0, "%=10d%=10d",
3123 clib_net_to_host_u32 (mp->vni),
3124 clib_net_to_host_u32 (mp->dp_table));
3125 print (vam->ofp, "%v", line);
3130 vl_api_one_eid_table_map_details_t_handler_json
3131 (vl_api_one_eid_table_map_details_t * mp)
3133 vat_main_t *vam = &vat_main;
3134 vat_json_node_t *node = NULL;
3136 if (VAT_JSON_ARRAY != vam->json_tree.type)
3138 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3139 vat_json_init_array (&vam->json_tree);
3141 node = vat_json_array_add (&vam->json_tree);
3142 vat_json_init_object (node);
3143 vat_json_object_add_uint (node, "dp_table",
3144 clib_net_to_host_u32 (mp->dp_table));
3145 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3149 vl_api_one_eid_table_vni_details_t_handler
3150 (vl_api_one_eid_table_vni_details_t * mp)
3152 vat_main_t *vam = &vat_main;
3154 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
3155 print (vam->ofp, "%v", line);
3160 vl_api_one_eid_table_vni_details_t_handler_json
3161 (vl_api_one_eid_table_vni_details_t * mp)
3163 vat_main_t *vam = &vat_main;
3164 vat_json_node_t *node = NULL;
3166 if (VAT_JSON_ARRAY != vam->json_tree.type)
3168 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3169 vat_json_init_array (&vam->json_tree);
3171 node = vat_json_array_add (&vam->json_tree);
3172 vat_json_init_object (node);
3173 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3177 vl_api_show_one_map_register_fallback_threshold_reply_t_handler
3178 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3180 vat_main_t *vam = &vat_main;
3181 int retval = clib_net_to_host_u32 (mp->retval);
3183 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3184 print (vam->ofp, "fallback threshold value: %d", mp->value);
3186 vam->retval = retval;
3187 vam->result_ready = 1;
3191 vl_api_show_one_map_register_fallback_threshold_reply_t_handler_json
3192 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3194 vat_main_t *vam = &vat_main;
3195 vat_json_node_t _node, *node = &_node;
3196 int retval = clib_net_to_host_u32 (mp->retval);
3198 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3199 vat_json_init_object (node);
3200 vat_json_object_add_uint (node, "value", mp->value);
3202 vat_json_print (vam->ofp, node);
3203 vat_json_free (node);
3205 vam->retval = retval;
3206 vam->result_ready = 1;
3210 vl_api_show_one_map_register_state_reply_t_handler
3211 (vl_api_show_one_map_register_state_reply_t * mp)
3213 vat_main_t *vam = &vat_main;
3214 int retval = clib_net_to_host_u32 (mp->retval);
3216 print (vam->ofp, "%s", mp->is_enable ? "enabled" : "disabled");
3218 vam->retval = retval;
3219 vam->result_ready = 1;
3223 vl_api_show_one_map_register_state_reply_t_handler_json
3224 (vl_api_show_one_map_register_state_reply_t * mp)
3226 vat_main_t *vam = &vat_main;
3227 vat_json_node_t _node, *node = &_node;
3228 int retval = clib_net_to_host_u32 (mp->retval);
3230 u8 *s = format (0, "%s", mp->is_enable ? "enabled" : "disabled");
3232 vat_json_init_object (node);
3233 vat_json_object_add_string_copy (node, "state", s);
3235 vat_json_print (vam->ofp, node);
3236 vat_json_free (node);
3238 vam->retval = retval;
3239 vam->result_ready = 1;
3244 vl_api_show_one_rloc_probe_state_reply_t_handler
3245 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3247 vat_main_t *vam = &vat_main;
3248 int retval = clib_net_to_host_u32 (mp->retval);
3253 print (vam->ofp, "%s", mp->is_enable ? "enabled" : "disabled");
3255 vam->retval = retval;
3256 vam->result_ready = 1;
3260 vl_api_show_one_rloc_probe_state_reply_t_handler_json
3261 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3263 vat_main_t *vam = &vat_main;
3264 vat_json_node_t _node, *node = &_node;
3265 int retval = clib_net_to_host_u32 (mp->retval);
3267 u8 *s = format (0, "%s", mp->is_enable ? "enabled" : "disabled");
3268 vat_json_init_object (node);
3269 vat_json_object_add_string_copy (node, "state", s);
3271 vat_json_print (vam->ofp, node);
3272 vat_json_free (node);
3274 vam->retval = retval;
3275 vam->result_ready = 1;
3280 vl_api_show_one_stats_enable_disable_reply_t_handler
3281 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3283 vat_main_t *vam = &vat_main;
3284 int retval = clib_net_to_host_u32 (mp->retval);
3289 print (vam->ofp, "%s", mp->is_enable ? "enabled" : "disabled");
3291 vam->retval = retval;
3292 vam->result_ready = 1;
3296 vl_api_show_one_stats_enable_disable_reply_t_handler_json
3297 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3299 vat_main_t *vam = &vat_main;
3300 vat_json_node_t _node, *node = &_node;
3301 int retval = clib_net_to_host_u32 (mp->retval);
3303 u8 *s = format (0, "%s", mp->is_enable ? "enabled" : "disabled");
3304 vat_json_init_object (node);
3305 vat_json_object_add_string_copy (node, "state", s);
3307 vat_json_print (vam->ofp, node);
3308 vat_json_free (node);
3310 vam->retval = retval;
3311 vam->result_ready = 1;
3316 api_gpe_fwd_entry_net_to_host (vl_api_gpe_fwd_entry_t * e)
3318 e->dp_table = clib_net_to_host_u32 (e->dp_table);
3319 e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
3320 e->vni = clib_net_to_host_u32 (e->vni);
3324 gpe_fwd_entries_get_reply_t_net_to_host
3325 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3329 mp->count = clib_net_to_host_u32 (mp->count);
3330 for (i = 0; i < mp->count; i++)
3332 api_gpe_fwd_entry_net_to_host (&mp->entries[i]);
3337 format_gpe_encap_mode (u8 * s, va_list * args)
3339 u32 mode = va_arg (*args, u32);
3344 return format (s, "lisp");
3346 return format (s, "vxlan");
3352 vl_api_gpe_get_encap_mode_reply_t_handler
3353 (vl_api_gpe_get_encap_mode_reply_t * mp)
3355 vat_main_t *vam = &vat_main;
3357 print (vam->ofp, "gpe mode: %U", format_gpe_encap_mode, mp->encap_mode);
3358 vam->retval = ntohl (mp->retval);
3359 vam->result_ready = 1;
3363 vl_api_gpe_get_encap_mode_reply_t_handler_json
3364 (vl_api_gpe_get_encap_mode_reply_t * mp)
3366 vat_main_t *vam = &vat_main;
3367 vat_json_node_t node;
3369 u8 *encap_mode = format (0, "%U", format_gpe_encap_mode, mp->encap_mode);
3370 vec_add1 (encap_mode, 0);
3372 vat_json_init_object (&node);
3373 vat_json_object_add_string_copy (&node, "gpe_mode", encap_mode);
3375 vec_free (encap_mode);
3376 vat_json_print (vam->ofp, &node);
3377 vat_json_free (&node);
3379 vam->retval = ntohl (mp->retval);
3380 vam->result_ready = 1;
3384 vl_api_gpe_fwd_entry_path_details_t_handler
3385 (vl_api_gpe_fwd_entry_path_details_t * mp)
3387 vat_main_t *vam = &vat_main;
3388 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3390 if (mp->lcl_loc.addr.af)
3391 format_ip_address_fcn = format_ip6_address;
3393 format_ip_address_fcn = format_ip4_address;
3395 print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
3396 format_ip_address_fcn, &mp->lcl_loc.addr.un,
3397 format_ip_address_fcn, &mp->rmt_loc.addr.un);
3401 lisp_fill_locator_node (vat_json_node_t * n, vl_api_gpe_locator_t * loc)
3403 struct in6_addr ip6;
3408 clib_memcpy (&ip6, loc->addr.un.ip6, sizeof (ip6));
3409 vat_json_object_add_ip6 (n, "address", ip6);
3413 clib_memcpy (&ip4, loc->addr.un.ip4, sizeof (ip4));
3414 vat_json_object_add_ip4 (n, "address", ip4);
3416 vat_json_object_add_uint (n, "weight", loc->weight);
3420 vl_api_gpe_fwd_entry_path_details_t_handler_json
3421 (vl_api_gpe_fwd_entry_path_details_t * mp)
3423 vat_main_t *vam = &vat_main;
3424 vat_json_node_t *node = NULL;
3425 vat_json_node_t *loc_node;
3427 if (VAT_JSON_ARRAY != vam->json_tree.type)
3429 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3430 vat_json_init_array (&vam->json_tree);
3432 node = vat_json_array_add (&vam->json_tree);
3433 vat_json_init_object (node);
3435 loc_node = vat_json_object_add (node, "local_locator");
3436 vat_json_init_object (loc_node);
3437 lisp_fill_locator_node (loc_node, &mp->lcl_loc);
3439 loc_node = vat_json_object_add (node, "remote_locator");
3440 vat_json_init_object (loc_node);
3441 lisp_fill_locator_node (loc_node, &mp->rmt_loc);
3445 vl_api_gpe_fwd_entries_get_reply_t_handler
3446 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3448 vat_main_t *vam = &vat_main;
3450 int retval = clib_net_to_host_u32 (mp->retval);
3451 vl_api_gpe_fwd_entry_t *e;
3456 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3458 for (i = 0; i < mp->count; i++)
3460 e = &mp->entries[i];
3461 print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
3462 format_lisp_flat_eid, e->leid, format_lisp_flat_eid, e->reid);
3466 vam->retval = retval;
3467 vam->result_ready = 1;
3471 vl_api_gpe_fwd_entries_get_reply_t_handler_json
3472 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3475 vat_main_t *vam = &vat_main;
3476 vat_json_node_t *e = 0, root;
3478 int retval = clib_net_to_host_u32 (mp->retval);
3479 vl_api_gpe_fwd_entry_t *fwd;
3484 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3485 vat_json_init_array (&root);
3487 for (i = 0; i < mp->count; i++)
3489 e = vat_json_array_add (&root);
3490 fwd = &mp->entries[i];
3492 vat_json_init_object (e);
3493 vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
3494 vat_json_object_add_int (e, "dp_table", fwd->dp_table);
3495 vat_json_object_add_int (e, "vni", fwd->vni);
3496 vat_json_object_add_int (e, "action", fwd->action);
3498 s = format (0, "%U", format_lisp_flat_eid, fwd->leid);
3500 vat_json_object_add_string_copy (e, "leid", s);
3503 s = format (0, "%U", format_lisp_flat_eid, fwd->reid);
3505 vat_json_object_add_string_copy (e, "reid", s);
3509 vat_json_print (vam->ofp, &root);
3510 vat_json_free (&root);
3513 vam->retval = retval;
3514 vam->result_ready = 1;
3518 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler
3519 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3521 vat_main_t *vam = &vat_main;
3523 int retval = clib_net_to_host_u32 (mp->retval);
3524 vl_api_gpe_native_fwd_rpath_t *r;
3529 n = clib_net_to_host_u32 (mp->count);
3531 for (i = 0; i < n; i++)
3533 r = &mp->entries[i];
3534 print (vam->ofp, "fib_index: %d sw_if_index %d nh %U",
3535 clib_net_to_host_u32 (r->fib_index),
3536 clib_net_to_host_u32 (r->nh_sw_if_index),
3537 r->nh_addr.af ? format_ip6_address : format_ip4_address,
3542 vam->retval = retval;
3543 vam->result_ready = 1;
3547 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler_json
3548 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3550 vat_main_t *vam = &vat_main;
3551 vat_json_node_t root, *e;
3553 int retval = clib_net_to_host_u32 (mp->retval);
3554 vl_api_gpe_native_fwd_rpath_t *r;
3560 n = clib_net_to_host_u32 (mp->count);
3561 vat_json_init_array (&root);
3563 for (i = 0; i < n; i++)
3565 e = vat_json_array_add (&root);
3566 vat_json_init_object (e);
3567 r = &mp->entries[i];
3570 r->nh_addr.af ? format_ip6_address : format_ip4_address,
3573 vat_json_object_add_string_copy (e, "ip4", s);
3576 vat_json_object_add_uint (e, "fib_index",
3577 clib_net_to_host_u32 (r->fib_index));
3578 vat_json_object_add_uint (e, "nh_sw_if_index",
3579 clib_net_to_host_u32 (r->nh_sw_if_index));
3582 vat_json_print (vam->ofp, &root);
3583 vat_json_free (&root);
3586 vam->retval = retval;
3587 vam->result_ready = 1;
3591 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler
3592 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3594 vat_main_t *vam = &vat_main;
3596 int retval = clib_net_to_host_u32 (mp->retval);
3601 n = clib_net_to_host_u32 (mp->count);
3603 for (i = 0; i < n; i++)
3604 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->vnis[i]));
3607 vam->retval = retval;
3608 vam->result_ready = 1;
3612 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler_json
3613 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3615 vat_main_t *vam = &vat_main;
3616 vat_json_node_t root;
3618 int retval = clib_net_to_host_u32 (mp->retval);
3623 n = clib_net_to_host_u32 (mp->count);
3624 vat_json_init_array (&root);
3626 for (i = 0; i < n; i++)
3627 vat_json_array_add_uint (&root, clib_net_to_host_u32 (mp->vnis[i]));
3629 vat_json_print (vam->ofp, &root);
3630 vat_json_free (&root);
3633 vam->retval = retval;
3634 vam->result_ready = 1;
3638 vl_api_one_ndp_entries_get_reply_t_handler
3639 (vl_api_one_ndp_entries_get_reply_t * mp)
3641 vat_main_t *vam = &vat_main;
3643 int retval = clib_net_to_host_u32 (mp->retval);
3648 n = clib_net_to_host_u32 (mp->count);
3650 for (i = 0; i < n; i++)
3651 print (vam->ofp, "%U -> %U", format_ip6_address, &mp->entries[i].ip6,
3652 format_ethernet_address, mp->entries[i].mac);
3655 vam->retval = retval;
3656 vam->result_ready = 1;
3660 vl_api_one_ndp_entries_get_reply_t_handler_json
3661 (vl_api_one_ndp_entries_get_reply_t * mp)
3664 vat_main_t *vam = &vat_main;
3665 vat_json_node_t *e = 0, root;
3667 int retval = clib_net_to_host_u32 (mp->retval);
3668 vl_api_one_ndp_entry_t *arp_entry;
3673 n = clib_net_to_host_u32 (mp->count);
3674 vat_json_init_array (&root);
3676 for (i = 0; i < n; i++)
3678 e = vat_json_array_add (&root);
3679 arp_entry = &mp->entries[i];
3681 vat_json_init_object (e);
3682 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3685 vat_json_object_add_string_copy (e, "mac", s);
3688 s = format (0, "%U", format_ip6_address, &arp_entry->ip6);
3690 vat_json_object_add_string_copy (e, "ip6", s);
3694 vat_json_print (vam->ofp, &root);
3695 vat_json_free (&root);
3698 vam->retval = retval;
3699 vam->result_ready = 1;
3703 vl_api_one_l2_arp_entries_get_reply_t_handler
3704 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3706 vat_main_t *vam = &vat_main;
3708 int retval = clib_net_to_host_u32 (mp->retval);
3713 n = clib_net_to_host_u32 (mp->count);
3715 for (i = 0; i < n; i++)
3716 print (vam->ofp, "%U -> %U", format_ip4_address, &mp->entries[i].ip4,
3717 format_ethernet_address, mp->entries[i].mac);
3720 vam->retval = retval;
3721 vam->result_ready = 1;
3725 vl_api_one_l2_arp_entries_get_reply_t_handler_json
3726 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3729 vat_main_t *vam = &vat_main;
3730 vat_json_node_t *e = 0, root;
3732 int retval = clib_net_to_host_u32 (mp->retval);
3733 vl_api_one_l2_arp_entry_t *arp_entry;
3738 n = clib_net_to_host_u32 (mp->count);
3739 vat_json_init_array (&root);
3741 for (i = 0; i < n; i++)
3743 e = vat_json_array_add (&root);
3744 arp_entry = &mp->entries[i];
3746 vat_json_init_object (e);
3747 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3750 vat_json_object_add_string_copy (e, "mac", s);
3753 s = format (0, "%U", format_ip4_address, &arp_entry->ip4);
3755 vat_json_object_add_string_copy (e, "ip4", s);
3759 vat_json_print (vam->ofp, &root);
3760 vat_json_free (&root);
3763 vam->retval = retval;
3764 vam->result_ready = 1;
3768 vl_api_one_ndp_bd_get_reply_t_handler (vl_api_one_ndp_bd_get_reply_t * mp)
3770 vat_main_t *vam = &vat_main;
3772 int retval = clib_net_to_host_u32 (mp->retval);
3777 n = clib_net_to_host_u32 (mp->count);
3779 for (i = 0; i < n; i++)
3781 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3785 vam->retval = retval;
3786 vam->result_ready = 1;
3790 vl_api_one_ndp_bd_get_reply_t_handler_json
3791 (vl_api_one_ndp_bd_get_reply_t * mp)
3793 vat_main_t *vam = &vat_main;
3794 vat_json_node_t root;
3796 int retval = clib_net_to_host_u32 (mp->retval);
3801 n = clib_net_to_host_u32 (mp->count);
3802 vat_json_init_array (&root);
3804 for (i = 0; i < n; i++)
3806 vat_json_array_add_uint (&root,
3807 clib_net_to_host_u32 (mp->bridge_domains[i]));
3810 vat_json_print (vam->ofp, &root);
3811 vat_json_free (&root);
3814 vam->retval = retval;
3815 vam->result_ready = 1;
3819 vl_api_one_l2_arp_bd_get_reply_t_handler
3820 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3822 vat_main_t *vam = &vat_main;
3824 int retval = clib_net_to_host_u32 (mp->retval);
3829 n = clib_net_to_host_u32 (mp->count);
3831 for (i = 0; i < n; i++)
3833 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3837 vam->retval = retval;
3838 vam->result_ready = 1;
3842 vl_api_one_l2_arp_bd_get_reply_t_handler_json
3843 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3845 vat_main_t *vam = &vat_main;
3846 vat_json_node_t root;
3848 int retval = clib_net_to_host_u32 (mp->retval);
3853 n = clib_net_to_host_u32 (mp->count);
3854 vat_json_init_array (&root);
3856 for (i = 0; i < n; i++)
3858 vat_json_array_add_uint (&root,
3859 clib_net_to_host_u32 (mp->bridge_domains[i]));
3862 vat_json_print (vam->ofp, &root);
3863 vat_json_free (&root);
3866 vam->retval = retval;
3867 vam->result_ready = 1;
3871 vl_api_one_adjacencies_get_reply_t_handler
3872 (vl_api_one_adjacencies_get_reply_t * mp)
3874 vat_main_t *vam = &vat_main;
3876 int retval = clib_net_to_host_u32 (mp->retval);
3877 vl_api_one_adjacency_t *a;
3882 n = clib_net_to_host_u32 (mp->count);
3884 for (i = 0; i < n; i++)
3886 a = &mp->adjacencies[i];
3887 print (vam->ofp, "%U %40U",
3888 format_lisp_flat_eid, a->leid, format_lisp_flat_eid, a->reid);
3892 vam->retval = retval;
3893 vam->result_ready = 1;
3897 vl_api_one_adjacencies_get_reply_t_handler_json
3898 (vl_api_one_adjacencies_get_reply_t * mp)
3901 vat_main_t *vam = &vat_main;
3902 vat_json_node_t *e = 0, root;
3904 int retval = clib_net_to_host_u32 (mp->retval);
3905 vl_api_one_adjacency_t *a;
3910 n = clib_net_to_host_u32 (mp->count);
3911 vat_json_init_array (&root);
3913 for (i = 0; i < n; i++)
3915 e = vat_json_array_add (&root);
3916 a = &mp->adjacencies[i];
3918 vat_json_init_object (e);
3919 s = format (0, "%U", format_lisp_flat_eid, a->leid);
3921 vat_json_object_add_string_copy (e, "leid", s);
3924 s = format (0, "%U", format_lisp_flat_eid, a->reid);
3926 vat_json_object_add_string_copy (e, "reid", s);
3930 vat_json_print (vam->ofp, &root);
3931 vat_json_free (&root);
3934 vam->retval = retval;
3935 vam->result_ready = 1;
3939 vl_api_one_map_server_details_t_handler (vl_api_one_map_server_details_t * mp)
3941 vat_main_t *vam = &vat_main;
3943 print (vam->ofp, "%=20U",
3944 mp->ip_address.af ? format_ip6_address : format_ip4_address,
3949 vl_api_one_map_server_details_t_handler_json
3950 (vl_api_one_map_server_details_t * mp)
3952 vat_main_t *vam = &vat_main;
3953 vat_json_node_t *node = NULL;
3954 struct in6_addr ip6;
3957 if (VAT_JSON_ARRAY != vam->json_tree.type)
3959 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3960 vat_json_init_array (&vam->json_tree);
3962 node = vat_json_array_add (&vam->json_tree);
3964 vat_json_init_object (node);
3965 if (mp->ip_address.af)
3967 clib_memcpy (&ip6, mp->ip_address.un.ip6, sizeof (ip6));
3968 vat_json_object_add_ip6 (node, "map-server", ip6);
3972 clib_memcpy (&ip4, mp->ip_address.un.ip4, sizeof (ip4));
3973 vat_json_object_add_ip4 (node, "map-server", ip4);
3978 vl_api_one_map_resolver_details_t_handler (vl_api_one_map_resolver_details_t
3981 vat_main_t *vam = &vat_main;
3983 print (vam->ofp, "%=20U",
3984 mp->ip_address.af ? format_ip6_address : format_ip4_address,
3989 vl_api_one_map_resolver_details_t_handler_json
3990 (vl_api_one_map_resolver_details_t * mp)
3992 vat_main_t *vam = &vat_main;
3993 vat_json_node_t *node = NULL;
3994 struct in6_addr ip6;
3997 if (VAT_JSON_ARRAY != vam->json_tree.type)
3999 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4000 vat_json_init_array (&vam->json_tree);
4002 node = vat_json_array_add (&vam->json_tree);
4004 vat_json_init_object (node);
4005 if (mp->ip_address.af)
4007 clib_memcpy (&ip6, mp->ip_address.un.ip6, sizeof (ip6));
4008 vat_json_object_add_ip6 (node, "map resolver", ip6);
4012 clib_memcpy (&ip4, mp->ip_address.un.ip4, sizeof (ip4));
4013 vat_json_object_add_ip4 (node, "map resolver", ip4);
4018 vl_api_show_one_status_reply_t_handler (vl_api_show_one_status_reply_t * mp)
4020 vat_main_t *vam = &vat_main;
4021 i32 retval = ntohl (mp->retval);
4025 print (vam->ofp, "feature: %s\ngpe: %s",
4026 mp->feature_status ? "enabled" : "disabled",
4027 mp->gpe_status ? "enabled" : "disabled");
4030 vam->retval = retval;
4031 vam->result_ready = 1;
4035 vl_api_show_one_status_reply_t_handler_json
4036 (vl_api_show_one_status_reply_t * mp)
4038 vat_main_t *vam = &vat_main;
4039 vat_json_node_t node;
4040 u8 *gpe_status = NULL;
4041 u8 *feature_status = NULL;
4043 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
4044 feature_status = format (0, "%s",
4045 mp->feature_status ? "enabled" : "disabled");
4046 vec_add1 (gpe_status, 0);
4047 vec_add1 (feature_status, 0);
4049 vat_json_init_object (&node);
4050 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
4051 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
4053 vec_free (gpe_status);
4054 vec_free (feature_status);
4056 vat_json_print (vam->ofp, &node);
4057 vat_json_free (&node);
4059 vam->retval = ntohl (mp->retval);
4060 vam->result_ready = 1;
4064 vl_api_one_get_map_request_itr_rlocs_reply_t_handler
4065 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4067 vat_main_t *vam = &vat_main;
4068 i32 retval = ntohl (mp->retval);
4072 print (vam->ofp, "%=20s", mp->locator_set_name);
4075 vam->retval = retval;
4076 vam->result_ready = 1;
4080 vl_api_one_get_map_request_itr_rlocs_reply_t_handler_json
4081 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4083 vat_main_t *vam = &vat_main;
4084 vat_json_node_t *node = NULL;
4086 if (VAT_JSON_ARRAY != vam->json_tree.type)
4088 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4089 vat_json_init_array (&vam->json_tree);
4091 node = vat_json_array_add (&vam->json_tree);
4093 vat_json_init_object (node);
4094 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
4096 vat_json_print (vam->ofp, node);
4097 vat_json_free (node);
4099 vam->retval = ntohl (mp->retval);
4100 vam->result_ready = 1;
4104 format_lisp_map_request_mode (u8 * s, va_list * args)
4106 u32 mode = va_arg (*args, u32);
4111 return format (0, "dst-only");
4113 return format (0, "src-dst");
4119 vl_api_show_one_map_request_mode_reply_t_handler
4120 (vl_api_show_one_map_request_mode_reply_t * mp)
4122 vat_main_t *vam = &vat_main;
4123 i32 retval = ntohl (mp->retval);
4127 u32 mode = mp->mode;
4128 print (vam->ofp, "map_request_mode: %U",
4129 format_lisp_map_request_mode, mode);
4132 vam->retval = retval;
4133 vam->result_ready = 1;
4137 vl_api_show_one_map_request_mode_reply_t_handler_json
4138 (vl_api_show_one_map_request_mode_reply_t * mp)
4140 vat_main_t *vam = &vat_main;
4141 vat_json_node_t node;
4146 s = format (0, "%U", format_lisp_map_request_mode, mode);
4149 vat_json_init_object (&node);
4150 vat_json_object_add_string_copy (&node, "map_request_mode", s);
4151 vat_json_print (vam->ofp, &node);
4152 vat_json_free (&node);
4155 vam->retval = ntohl (mp->retval);
4156 vam->result_ready = 1;
4160 vl_api_one_show_xtr_mode_reply_t_handler
4161 (vl_api_one_show_xtr_mode_reply_t * mp)
4163 vat_main_t *vam = &vat_main;
4164 i32 retval = ntohl (mp->retval);
4168 print (vam->ofp, "%s\n", mp->is_enable ? "enabled" : "disabled");
4171 vam->retval = retval;
4172 vam->result_ready = 1;
4176 vl_api_one_show_xtr_mode_reply_t_handler_json
4177 (vl_api_one_show_xtr_mode_reply_t * mp)
4179 vat_main_t *vam = &vat_main;
4180 vat_json_node_t node;
4183 status = format (0, "%s", mp->is_enable ? "enabled" : "disabled");
4184 vec_add1 (status, 0);
4186 vat_json_init_object (&node);
4187 vat_json_object_add_string_copy (&node, "status", status);
4191 vat_json_print (vam->ofp, &node);
4192 vat_json_free (&node);
4194 vam->retval = ntohl (mp->retval);
4195 vam->result_ready = 1;
4199 vl_api_one_show_pitr_mode_reply_t_handler
4200 (vl_api_one_show_pitr_mode_reply_t * mp)
4202 vat_main_t *vam = &vat_main;
4203 i32 retval = ntohl (mp->retval);
4207 print (vam->ofp, "%s\n", mp->is_enable ? "enabled" : "disabled");
4210 vam->retval = retval;
4211 vam->result_ready = 1;
4215 vl_api_one_show_pitr_mode_reply_t_handler_json
4216 (vl_api_one_show_pitr_mode_reply_t * mp)
4218 vat_main_t *vam = &vat_main;
4219 vat_json_node_t node;
4222 status = format (0, "%s", mp->is_enable ? "enabled" : "disabled");
4223 vec_add1 (status, 0);
4225 vat_json_init_object (&node);
4226 vat_json_object_add_string_copy (&node, "status", status);
4230 vat_json_print (vam->ofp, &node);
4231 vat_json_free (&node);
4233 vam->retval = ntohl (mp->retval);
4234 vam->result_ready = 1;
4238 vl_api_one_show_petr_mode_reply_t_handler
4239 (vl_api_one_show_petr_mode_reply_t * mp)
4241 vat_main_t *vam = &vat_main;
4242 i32 retval = ntohl (mp->retval);
4246 print (vam->ofp, "%s\n", mp->is_enable ? "enabled" : "disabled");
4249 vam->retval = retval;
4250 vam->result_ready = 1;
4254 vl_api_one_show_petr_mode_reply_t_handler_json
4255 (vl_api_one_show_petr_mode_reply_t * mp)
4257 vat_main_t *vam = &vat_main;
4258 vat_json_node_t node;
4261 status = format (0, "%s", mp->is_enable ? "enabled" : "disabled");
4262 vec_add1 (status, 0);
4264 vat_json_init_object (&node);
4265 vat_json_object_add_string_copy (&node, "status", status);
4269 vat_json_print (vam->ofp, &node);
4270 vat_json_free (&node);
4272 vam->retval = ntohl (mp->retval);
4273 vam->result_ready = 1;
4277 vl_api_show_one_use_petr_reply_t_handler
4278 (vl_api_show_one_use_petr_reply_t * mp)
4280 vat_main_t *vam = &vat_main;
4281 i32 retval = ntohl (mp->retval);
4285 print (vam->ofp, "%s\n", mp->status ? "enabled" : "disabled");
4288 print (vam->ofp, "Proxy-ETR address; %U",
4289 mp->ip_address.af ? format_ip6_address : format_ip4_address,
4294 vam->retval = retval;
4295 vam->result_ready = 1;
4299 vl_api_show_one_use_petr_reply_t_handler_json
4300 (vl_api_show_one_use_petr_reply_t * mp)
4302 vat_main_t *vam = &vat_main;
4303 vat_json_node_t node;
4306 struct in6_addr ip6;
4308 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4309 vec_add1 (status, 0);
4311 vat_json_init_object (&node);
4312 vat_json_object_add_string_copy (&node, "status", status);
4315 if (mp->ip_address.af)
4317 clib_memcpy (&ip6, mp->ip_address.un.ip6, sizeof (ip6));
4318 vat_json_object_add_ip6 (&node, "address", ip6);
4322 clib_memcpy (&ip4, mp->ip_address.un.ip4, sizeof (ip4));
4323 vat_json_object_add_ip4 (&node, "address", ip4);
4329 vat_json_print (vam->ofp, &node);
4330 vat_json_free (&node);
4332 vam->retval = ntohl (mp->retval);
4333 vam->result_ready = 1;
4337 vl_api_show_one_nsh_mapping_reply_t_handler
4338 (vl_api_show_one_nsh_mapping_reply_t * mp)
4340 vat_main_t *vam = &vat_main;
4341 i32 retval = ntohl (mp->retval);
4345 print (vam->ofp, "%-20s%-16s",
4346 mp->is_set ? "set" : "not-set",
4347 mp->is_set ? (char *) mp->locator_set_name : "");
4350 vam->retval = retval;
4351 vam->result_ready = 1;
4355 vl_api_show_one_nsh_mapping_reply_t_handler_json
4356 (vl_api_show_one_nsh_mapping_reply_t * mp)
4358 vat_main_t *vam = &vat_main;
4359 vat_json_node_t node;
4362 status = format (0, "%s", mp->is_set ? "yes" : "no");
4363 vec_add1 (status, 0);
4365 vat_json_init_object (&node);
4366 vat_json_object_add_string_copy (&node, "is_set", status);
4369 vat_json_object_add_string_copy (&node, "locator_set",
4370 mp->locator_set_name);
4375 vat_json_print (vam->ofp, &node);
4376 vat_json_free (&node);
4378 vam->retval = ntohl (mp->retval);
4379 vam->result_ready = 1;
4383 vl_api_show_one_map_register_ttl_reply_t_handler
4384 (vl_api_show_one_map_register_ttl_reply_t * mp)
4386 vat_main_t *vam = &vat_main;
4387 i32 retval = ntohl (mp->retval);
4389 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4393 print (vam->ofp, "ttl: %u", mp->ttl);
4396 vam->retval = retval;
4397 vam->result_ready = 1;
4401 vl_api_show_one_map_register_ttl_reply_t_handler_json
4402 (vl_api_show_one_map_register_ttl_reply_t * mp)
4404 vat_main_t *vam = &vat_main;
4405 vat_json_node_t node;
4407 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4408 vat_json_init_object (&node);
4409 vat_json_object_add_uint (&node, "ttl", mp->ttl);
4411 vat_json_print (vam->ofp, &node);
4412 vat_json_free (&node);
4414 vam->retval = ntohl (mp->retval);
4415 vam->result_ready = 1;
4419 vl_api_show_one_pitr_reply_t_handler (vl_api_show_one_pitr_reply_t * mp)
4421 vat_main_t *vam = &vat_main;
4422 i32 retval = ntohl (mp->retval);
4426 print (vam->ofp, "%-20s%-16s",
4427 mp->status ? "enabled" : "disabled",
4428 mp->status ? (char *) mp->locator_set_name : "");
4431 vam->retval = retval;
4432 vam->result_ready = 1;
4436 vl_api_show_one_pitr_reply_t_handler_json (vl_api_show_one_pitr_reply_t * mp)
4438 vat_main_t *vam = &vat_main;
4439 vat_json_node_t node;
4442 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4443 vec_add1 (status, 0);
4445 vat_json_init_object (&node);
4446 vat_json_object_add_string_copy (&node, "status", status);
4449 vat_json_object_add_string_copy (&node, "locator_set",
4450 mp->locator_set_name);
4455 vat_json_print (vam->ofp, &node);
4456 vat_json_free (&node);
4458 vam->retval = ntohl (mp->retval);
4459 vam->result_ready = 1;
4463 format_policer_type (u8 * s, va_list * va)
4465 u32 i = va_arg (*va, u32);
4467 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
4468 s = format (s, "1r2c");
4469 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
4470 s = format (s, "1r3c");
4471 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
4472 s = format (s, "2r3c-2698");
4473 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
4474 s = format (s, "2r3c-4115");
4475 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
4476 s = format (s, "2r3c-mef5cf1");
4478 s = format (s, "ILLEGAL");
4483 format_policer_rate_type (u8 * s, va_list * va)
4485 u32 i = va_arg (*va, u32);
4487 if (i == SSE2_QOS_RATE_KBPS)
4488 s = format (s, "kbps");
4489 else if (i == SSE2_QOS_RATE_PPS)
4490 s = format (s, "pps");
4492 s = format (s, "ILLEGAL");
4497 format_policer_round_type (u8 * s, va_list * va)
4499 u32 i = va_arg (*va, u32);
4501 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
4502 s = format (s, "closest");
4503 else if (i == SSE2_QOS_ROUND_TO_UP)
4504 s = format (s, "up");
4505 else if (i == SSE2_QOS_ROUND_TO_DOWN)
4506 s = format (s, "down");
4508 s = format (s, "ILLEGAL");
4513 format_policer_action_type (u8 * s, va_list * va)
4515 u32 i = va_arg (*va, u32);
4517 if (i == SSE2_QOS_ACTION_DROP)
4518 s = format (s, "drop");
4519 else if (i == SSE2_QOS_ACTION_TRANSMIT)
4520 s = format (s, "transmit");
4521 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4522 s = format (s, "mark-and-transmit");
4524 s = format (s, "ILLEGAL");
4529 format_dscp (u8 * s, va_list * va)
4531 u32 i = va_arg (*va, u32);
4536 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
4540 return format (s, "ILLEGAL");
4542 s = format (s, "%s", t);
4547 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
4549 vat_main_t *vam = &vat_main;
4550 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
4552 if (mp->conform_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
4553 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_action.dscp);
4555 conform_dscp_str = format (0, "");
4557 if (mp->exceed_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
4558 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_action.dscp);
4560 exceed_dscp_str = format (0, "");
4562 if (mp->violate_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
4563 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_action.dscp);
4565 violate_dscp_str = format (0, "");
4567 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
4568 "rate type %U, round type %U, %s rate, %s color-aware, "
4569 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
4570 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
4571 "conform action %U%s, exceed action %U%s, violate action %U%s",
4573 format_policer_type, mp->type,
4576 clib_net_to_host_u64 (mp->cb),
4577 clib_net_to_host_u64 (mp->eb),
4578 format_policer_rate_type, mp->rate_type,
4579 format_policer_round_type, mp->round_type,
4580 mp->single_rate ? "single" : "dual",
4581 mp->color_aware ? "is" : "not",
4582 ntohl (mp->cir_tokens_per_period),
4583 ntohl (mp->pir_tokens_per_period),
4585 ntohl (mp->current_limit),
4586 ntohl (mp->current_bucket),
4587 ntohl (mp->extended_limit),
4588 ntohl (mp->extended_bucket),
4589 clib_net_to_host_u64 (mp->last_update_time),
4590 format_policer_action_type, mp->conform_action.type,
4592 format_policer_action_type, mp->exceed_action.type,
4594 format_policer_action_type, mp->violate_action.type,
4597 vec_free (conform_dscp_str);
4598 vec_free (exceed_dscp_str);
4599 vec_free (violate_dscp_str);
4602 static void vl_api_policer_details_t_handler_json
4603 (vl_api_policer_details_t * mp)
4605 vat_main_t *vam = &vat_main;
4606 vat_json_node_t *node;
4607 u8 *rate_type_str, *round_type_str, *type_str;
4608 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
4610 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
4612 format (0, "%U", format_policer_round_type, mp->round_type);
4613 type_str = format (0, "%U", format_policer_type, mp->type);
4614 conform_action_str = format (0, "%U", format_policer_action_type,
4615 mp->conform_action.type);
4616 exceed_action_str = format (0, "%U", format_policer_action_type,
4617 mp->exceed_action.type);
4618 violate_action_str = format (0, "%U", format_policer_action_type,
4619 mp->violate_action.type);
4621 if (VAT_JSON_ARRAY != vam->json_tree.type)
4623 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4624 vat_json_init_array (&vam->json_tree);
4626 node = vat_json_array_add (&vam->json_tree);
4628 vat_json_init_object (node);
4629 vat_json_object_add_string_copy (node, "name", mp->name);
4630 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
4631 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
4632 vat_json_object_add_uint (node, "cb", clib_net_to_host_u64 (mp->cb));
4633 vat_json_object_add_uint (node, "eb", clib_net_to_host_u64 (mp->eb));
4634 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
4635 vat_json_object_add_string_copy (node, "round_type", round_type_str);
4636 vat_json_object_add_string_copy (node, "type", type_str);
4637 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
4638 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
4639 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
4640 vat_json_object_add_uint (node, "cir_tokens_per_period",
4641 ntohl (mp->cir_tokens_per_period));
4642 vat_json_object_add_uint (node, "eir_tokens_per_period",
4643 ntohl (mp->pir_tokens_per_period));
4644 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
4645 vat_json_object_add_uint (node, "current_bucket",
4646 ntohl (mp->current_bucket));
4647 vat_json_object_add_uint (node, "extended_limit",
4648 ntohl (mp->extended_limit));
4649 vat_json_object_add_uint (node, "extended_bucket",
4650 ntohl (mp->extended_bucket));
4651 vat_json_object_add_uint (node, "last_update_time",
4652 ntohl (mp->last_update_time));
4653 vat_json_object_add_string_copy (node, "conform_action",
4654 conform_action_str);
4655 if (mp->conform_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
4657 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_action.dscp);
4658 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
4659 vec_free (dscp_str);
4661 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
4662 if (mp->exceed_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
4664 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_action.dscp);
4665 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
4666 vec_free (dscp_str);
4668 vat_json_object_add_string_copy (node, "violate_action",
4669 violate_action_str);
4670 if (mp->violate_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
4672 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_action.dscp);
4673 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
4674 vec_free (dscp_str);
4677 vec_free (rate_type_str);
4678 vec_free (round_type_str);
4679 vec_free (type_str);
4680 vec_free (conform_action_str);
4681 vec_free (exceed_action_str);
4682 vec_free (violate_action_str);
4686 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
4689 vat_main_t *vam = &vat_main;
4690 int i, count = ntohl (mp->count);
4693 print (vam->ofp, "classify table ids (%d) : ", count);
4694 for (i = 0; i < count; i++)
4696 print (vam->ofp, "%d", ntohl (mp->ids[i]));
4697 print (vam->ofp, (i < count - 1) ? "," : "");
4699 vam->retval = ntohl (mp->retval);
4700 vam->result_ready = 1;
4704 vl_api_classify_table_ids_reply_t_handler_json
4705 (vl_api_classify_table_ids_reply_t * mp)
4707 vat_main_t *vam = &vat_main;
4708 int i, count = ntohl (mp->count);
4712 vat_json_node_t node;
4714 vat_json_init_object (&node);
4715 for (i = 0; i < count; i++)
4717 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
4719 vat_json_print (vam->ofp, &node);
4720 vat_json_free (&node);
4722 vam->retval = ntohl (mp->retval);
4723 vam->result_ready = 1;
4727 vl_api_classify_table_by_interface_reply_t_handler
4728 (vl_api_classify_table_by_interface_reply_t * mp)
4730 vat_main_t *vam = &vat_main;
4733 table_id = ntohl (mp->l2_table_id);
4735 print (vam->ofp, "l2 table id : %d", table_id);
4737 print (vam->ofp, "l2 table id : No input ACL tables configured");
4738 table_id = ntohl (mp->ip4_table_id);
4740 print (vam->ofp, "ip4 table id : %d", table_id);
4742 print (vam->ofp, "ip4 table id : No input ACL tables configured");
4743 table_id = ntohl (mp->ip6_table_id);
4745 print (vam->ofp, "ip6 table id : %d", table_id);
4747 print (vam->ofp, "ip6 table id : No input ACL tables configured");
4748 vam->retval = ntohl (mp->retval);
4749 vam->result_ready = 1;
4753 vl_api_classify_table_by_interface_reply_t_handler_json
4754 (vl_api_classify_table_by_interface_reply_t * mp)
4756 vat_main_t *vam = &vat_main;
4757 vat_json_node_t node;
4759 vat_json_init_object (&node);
4761 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
4762 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
4763 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
4765 vat_json_print (vam->ofp, &node);
4766 vat_json_free (&node);
4768 vam->retval = ntohl (mp->retval);
4769 vam->result_ready = 1;
4772 static void vl_api_policer_add_del_reply_t_handler
4773 (vl_api_policer_add_del_reply_t * mp)
4775 vat_main_t *vam = &vat_main;
4776 i32 retval = ntohl (mp->retval);
4777 if (vam->async_mode)
4779 vam->async_errors += (retval < 0);
4783 vam->retval = retval;
4784 vam->result_ready = 1;
4785 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
4787 * Note: this is just barely thread-safe, depends on
4788 * the main thread spinning waiting for an answer...
4790 errmsg ("policer index %d", ntohl (mp->policer_index));
4794 static void vl_api_policer_add_del_reply_t_handler_json
4795 (vl_api_policer_add_del_reply_t * mp)
4797 vat_main_t *vam = &vat_main;
4798 vat_json_node_t node;
4800 vat_json_init_object (&node);
4801 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
4802 vat_json_object_add_uint (&node, "policer_index",
4803 ntohl (mp->policer_index));
4805 vat_json_print (vam->ofp, &node);
4806 vat_json_free (&node);
4808 vam->retval = ntohl (mp->retval);
4809 vam->result_ready = 1;
4812 /* Format hex dump. */
4814 format_hex_bytes (u8 * s, va_list * va)
4816 u8 *bytes = va_arg (*va, u8 *);
4817 int n_bytes = va_arg (*va, int);
4820 /* Print short or long form depending on byte count. */
4821 uword short_form = n_bytes <= 32;
4822 u32 indent = format_get_indent (s);
4827 for (i = 0; i < n_bytes; i++)
4829 if (!short_form && (i % 32) == 0)
4830 s = format (s, "%08x: ", i);
4831 s = format (s, "%02x", bytes[i]);
4832 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
4833 s = format (s, "\n%U", format_white_space, indent);
4840 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
4843 vat_main_t *vam = &vat_main;
4844 i32 retval = ntohl (mp->retval);
4847 print (vam->ofp, "classify table info :");
4848 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
4849 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
4850 ntohl (mp->miss_next_index));
4851 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
4852 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
4853 ntohl (mp->match_n_vectors));
4854 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
4855 ntohl (mp->mask_length));
4857 vam->retval = retval;
4858 vam->result_ready = 1;
4862 vl_api_classify_table_info_reply_t_handler_json
4863 (vl_api_classify_table_info_reply_t * mp)
4865 vat_main_t *vam = &vat_main;
4866 vat_json_node_t node;
4868 i32 retval = ntohl (mp->retval);
4871 vat_json_init_object (&node);
4873 vat_json_object_add_int (&node, "sessions",
4874 ntohl (mp->active_sessions));
4875 vat_json_object_add_int (&node, "nexttbl",
4876 ntohl (mp->next_table_index));
4877 vat_json_object_add_int (&node, "nextnode",
4878 ntohl (mp->miss_next_index));
4879 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
4880 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
4881 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
4882 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
4883 ntohl (mp->mask_length), 0);
4884 vat_json_object_add_string_copy (&node, "mask", s);
4886 vat_json_print (vam->ofp, &node);
4887 vat_json_free (&node);
4889 vam->retval = ntohl (mp->retval);
4890 vam->result_ready = 1;
4894 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
4897 vat_main_t *vam = &vat_main;
4899 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
4900 ntohl (mp->hit_next_index), ntohl (mp->advance),
4901 ntohl (mp->opaque_index));
4902 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
4903 ntohl (mp->match_length));
4907 vl_api_classify_session_details_t_handler_json
4908 (vl_api_classify_session_details_t * mp)
4910 vat_main_t *vam = &vat_main;
4911 vat_json_node_t *node = NULL;
4913 if (VAT_JSON_ARRAY != vam->json_tree.type)
4915 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4916 vat_json_init_array (&vam->json_tree);
4918 node = vat_json_array_add (&vam->json_tree);
4920 vat_json_init_object (node);
4921 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
4922 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
4923 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
4925 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
4927 vat_json_object_add_string_copy (node, "match", s);
4930 static void vl_api_pg_create_interface_reply_t_handler
4931 (vl_api_pg_create_interface_reply_t * mp)
4933 vat_main_t *vam = &vat_main;
4935 vam->retval = ntohl (mp->retval);
4936 vam->result_ready = 1;
4939 static void vl_api_pg_create_interface_reply_t_handler_json
4940 (vl_api_pg_create_interface_reply_t * mp)
4942 vat_main_t *vam = &vat_main;
4943 vat_json_node_t node;
4945 i32 retval = ntohl (mp->retval);
4948 vat_json_init_object (&node);
4950 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
4952 vat_json_print (vam->ofp, &node);
4953 vat_json_free (&node);
4955 vam->retval = ntohl (mp->retval);
4956 vam->result_ready = 1;
4959 static void vl_api_policer_classify_details_t_handler
4960 (vl_api_policer_classify_details_t * mp)
4962 vat_main_t *vam = &vat_main;
4964 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
4965 ntohl (mp->table_index));
4968 static void vl_api_policer_classify_details_t_handler_json
4969 (vl_api_policer_classify_details_t * mp)
4971 vat_main_t *vam = &vat_main;
4972 vat_json_node_t *node;
4974 if (VAT_JSON_ARRAY != vam->json_tree.type)
4976 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4977 vat_json_init_array (&vam->json_tree);
4979 node = vat_json_array_add (&vam->json_tree);
4981 vat_json_init_object (node);
4982 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
4983 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
4986 static void vl_api_flow_classify_details_t_handler
4987 (vl_api_flow_classify_details_t * mp)
4989 vat_main_t *vam = &vat_main;
4991 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
4992 ntohl (mp->table_index));
4995 static void vl_api_flow_classify_details_t_handler_json
4996 (vl_api_flow_classify_details_t * mp)
4998 vat_main_t *vam = &vat_main;
4999 vat_json_node_t *node;
5001 if (VAT_JSON_ARRAY != vam->json_tree.type)
5003 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5004 vat_json_init_array (&vam->json_tree);
5006 node = vat_json_array_add (&vam->json_tree);
5008 vat_json_init_object (node);
5009 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5010 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5013 #define vl_api_one_adjacencies_get_reply_t_endian vl_noop_handler
5014 #define vl_api_one_adjacencies_get_reply_t_print vl_noop_handler
5015 #define vl_api_one_l2_arp_bd_get_reply_t_print vl_noop_handler
5016 #define vl_api_one_l2_arp_entries_get_reply_t_endian vl_noop_handler
5017 #define vl_api_one_l2_arp_entries_get_reply_t_print vl_noop_handler
5018 #define vl_api_one_l2_arp_bd_get_reply_t_endian vl_noop_handler
5019 #define vl_api_one_ndp_bd_get_reply_t_endian vl_noop_handler
5020 #define vl_api_one_ndp_bd_get_reply_t_print vl_noop_handler
5021 #define vl_api_one_ndp_entries_get_reply_t_print vl_noop_handler
5022 #define vl_api_one_ndp_entries_get_reply_t_endian vl_noop_handler
5025 * Generate boilerplate reply handlers, which
5026 * dig the return value out of the xxx_reply_t API message,
5027 * stick it into vam->retval, and set vam->result_ready
5029 * Could also do this by pointing N message decode slots at
5030 * a single function, but that could break in subtle ways.
5033 #define foreach_standard_reply_retval_handler \
5034 _(sw_interface_set_flags_reply) \
5035 _(sw_interface_add_del_address_reply) \
5036 _(sw_interface_set_rx_mode_reply) \
5037 _(sw_interface_set_rx_placement_reply) \
5038 _(sw_interface_set_table_reply) \
5039 _(sw_interface_set_mpls_enable_reply) \
5040 _(sw_interface_set_vpath_reply) \
5041 _(sw_interface_set_vxlan_bypass_reply) \
5042 _(sw_interface_set_geneve_bypass_reply) \
5043 _(sw_interface_set_vxlan_gpe_bypass_reply) \
5044 _(sw_interface_set_l2_bridge_reply) \
5045 _(sw_interface_set_bond_weight_reply) \
5046 _(bridge_domain_add_del_reply) \
5047 _(sw_interface_set_l2_xconnect_reply) \
5048 _(l2fib_add_del_reply) \
5049 _(l2fib_flush_int_reply) \
5050 _(l2fib_flush_bd_reply) \
5051 _(ip_route_add_del_reply) \
5052 _(ip_table_add_del_reply) \
5053 _(ip_table_replace_begin_reply) \
5054 _(ip_table_flush_reply) \
5055 _(ip_table_replace_end_reply) \
5056 _(ip_mroute_add_del_reply) \
5057 _(mpls_route_add_del_reply) \
5058 _(mpls_table_add_del_reply) \
5059 _(mpls_ip_bind_unbind_reply) \
5060 _(bier_route_add_del_reply) \
5061 _(bier_table_add_del_reply) \
5062 _(sw_interface_set_unnumbered_reply) \
5063 _(set_ip_flow_hash_reply) \
5064 _(sw_interface_ip6_enable_disable_reply) \
5065 _(l2_patch_add_del_reply) \
5066 _(sr_mpls_policy_add_reply) \
5067 _(sr_mpls_policy_mod_reply) \
5068 _(sr_mpls_policy_del_reply) \
5069 _(sr_policy_add_reply) \
5070 _(sr_policy_mod_reply) \
5071 _(sr_policy_del_reply) \
5072 _(sr_localsid_add_del_reply) \
5073 _(sr_steering_add_del_reply) \
5074 _(classify_add_del_session_reply) \
5075 _(classify_set_interface_ip_table_reply) \
5076 _(classify_set_interface_l2_tables_reply) \
5077 _(l2tpv3_set_tunnel_cookies_reply) \
5078 _(l2tpv3_interface_enable_disable_reply) \
5079 _(l2tpv3_set_lookup_key_reply) \
5080 _(l2_fib_clear_table_reply) \
5081 _(l2_interface_efp_filter_reply) \
5082 _(l2_interface_vlan_tag_rewrite_reply) \
5083 _(modify_vhost_user_if_reply) \
5084 _(delete_vhost_user_if_reply) \
5085 _(want_l2_macs_events_reply) \
5086 _(input_acl_set_interface_reply) \
5087 _(ipsec_spd_add_del_reply) \
5088 _(ipsec_interface_add_del_spd_reply) \
5089 _(ipsec_spd_entry_add_del_reply) \
5090 _(ipsec_sad_entry_add_del_reply) \
5091 _(ipsec_tunnel_if_add_del_reply) \
5092 _(ipsec_tunnel_if_set_sa_reply) \
5093 _(delete_loopback_reply) \
5094 _(bd_ip_mac_add_del_reply) \
5095 _(bd_ip_mac_flush_reply) \
5096 _(want_interface_events_reply) \
5097 _(cop_interface_enable_disable_reply) \
5098 _(cop_whitelist_enable_disable_reply) \
5099 _(sw_interface_clear_stats_reply) \
5100 _(ioam_enable_reply) \
5101 _(ioam_disable_reply) \
5102 _(one_add_del_locator_reply) \
5103 _(one_add_del_local_eid_reply) \
5104 _(one_add_del_remote_mapping_reply) \
5105 _(one_add_del_adjacency_reply) \
5106 _(one_add_del_map_resolver_reply) \
5107 _(one_add_del_map_server_reply) \
5108 _(one_enable_disable_reply) \
5109 _(one_rloc_probe_enable_disable_reply) \
5110 _(one_map_register_enable_disable_reply) \
5111 _(one_map_register_set_ttl_reply) \
5112 _(one_set_transport_protocol_reply) \
5113 _(one_map_register_fallback_threshold_reply) \
5114 _(one_pitr_set_locator_set_reply) \
5115 _(one_map_request_mode_reply) \
5116 _(one_add_del_map_request_itr_rlocs_reply) \
5117 _(one_eid_table_add_del_map_reply) \
5118 _(one_use_petr_reply) \
5119 _(one_stats_enable_disable_reply) \
5120 _(one_add_del_l2_arp_entry_reply) \
5121 _(one_add_del_ndp_entry_reply) \
5122 _(one_stats_flush_reply) \
5123 _(one_enable_disable_xtr_mode_reply) \
5124 _(one_enable_disable_pitr_mode_reply) \
5125 _(one_enable_disable_petr_mode_reply) \
5126 _(gpe_enable_disable_reply) \
5127 _(gpe_set_encap_mode_reply) \
5128 _(gpe_add_del_iface_reply) \
5129 _(gpe_add_del_native_fwd_rpath_reply) \
5130 _(af_packet_delete_reply) \
5131 _(policer_classify_set_interface_reply) \
5132 _(set_ipfix_exporter_reply) \
5133 _(set_ipfix_classify_stream_reply) \
5134 _(ipfix_classify_table_add_del_reply) \
5135 _(flow_classify_set_interface_reply) \
5136 _(sw_interface_span_enable_disable_reply) \
5137 _(pg_capture_reply) \
5138 _(pg_enable_disable_reply) \
5139 _(ip_source_and_port_range_check_add_del_reply) \
5140 _(ip_source_and_port_range_check_interface_add_del_reply)\
5141 _(delete_subif_reply) \
5142 _(l2_interface_pbb_tag_rewrite_reply) \
5144 _(feature_enable_disable_reply) \
5145 _(feature_gso_enable_disable_reply) \
5146 _(sw_interface_tag_add_del_reply) \
5147 _(sw_interface_add_del_mac_address_reply) \
5148 _(hw_interface_set_mtu_reply) \
5149 _(p2p_ethernet_add_reply) \
5150 _(p2p_ethernet_del_reply) \
5151 _(lldp_config_reply) \
5152 _(sw_interface_set_lldp_reply) \
5153 _(tcp_configure_src_addresses_reply) \
5154 _(session_rule_add_del_reply) \
5155 _(ip_container_proxy_add_del_reply) \
5156 _(output_acl_set_interface_reply) \
5157 _(qos_record_enable_disable_reply)
5160 static void vl_api_##n##_t_handler \
5161 (vl_api_##n##_t * mp) \
5163 vat_main_t * vam = &vat_main; \
5164 i32 retval = ntohl(mp->retval); \
5165 if (vam->async_mode) { \
5166 vam->async_errors += (retval < 0); \
5168 vam->retval = retval; \
5169 vam->result_ready = 1; \
5172 foreach_standard_reply_retval_handler;
5176 static void vl_api_##n##_t_handler_json \
5177 (vl_api_##n##_t * mp) \
5179 vat_main_t * vam = &vat_main; \
5180 vat_json_node_t node; \
5181 vat_json_init_object(&node); \
5182 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
5183 vat_json_print(vam->ofp, &node); \
5184 vam->retval = ntohl(mp->retval); \
5185 vam->result_ready = 1; \
5187 foreach_standard_reply_retval_handler;
5191 * Table of message reply handlers, must include boilerplate handlers
5195 #define foreach_vpe_api_reply_msg \
5196 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
5197 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
5198 _(SW_INTERFACE_DETAILS, sw_interface_details) \
5199 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
5200 _(CONTROL_PING_REPLY, control_ping_reply) \
5201 _(CLI_REPLY, cli_reply) \
5202 _(CLI_INBAND_REPLY, cli_inband_reply) \
5203 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
5204 sw_interface_add_del_address_reply) \
5205 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
5206 _(SW_INTERFACE_SET_RX_PLACEMENT_REPLY, sw_interface_set_rx_placement_reply) \
5207 _(SW_INTERFACE_RX_PLACEMENT_DETAILS, sw_interface_rx_placement_details) \
5208 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
5209 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
5210 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
5211 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
5212 _(SW_INTERFACE_SET_GENEVE_BYPASS_REPLY, sw_interface_set_geneve_bypass_reply) \
5213 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
5214 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
5215 sw_interface_set_l2_xconnect_reply) \
5216 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
5217 sw_interface_set_l2_bridge_reply) \
5218 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
5219 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
5220 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
5221 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
5222 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
5223 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
5224 _(L2_FLAGS_REPLY, l2_flags_reply) \
5225 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
5226 _(TAP_CREATE_V2_REPLY, tap_create_v2_reply) \
5227 _(TAP_DELETE_V2_REPLY, tap_delete_v2_reply) \
5228 _(SW_INTERFACE_TAP_V2_DETAILS, sw_interface_tap_v2_details) \
5229 _(VIRTIO_PCI_CREATE_REPLY, virtio_pci_create_reply) \
5230 _(VIRTIO_PCI_DELETE_REPLY, virtio_pci_delete_reply) \
5231 _(SW_INTERFACE_VIRTIO_PCI_DETAILS, sw_interface_virtio_pci_details) \
5232 _(BOND_CREATE_REPLY, bond_create_reply) \
5233 _(BOND_DELETE_REPLY, bond_delete_reply) \
5234 _(BOND_ENSLAVE_REPLY, bond_enslave_reply) \
5235 _(BOND_DETACH_SLAVE_REPLY, bond_detach_slave_reply) \
5236 _(SW_INTERFACE_SET_BOND_WEIGHT_REPLY, sw_interface_set_bond_weight_reply) \
5237 _(SW_INTERFACE_BOND_DETAILS, sw_interface_bond_details) \
5238 _(SW_INTERFACE_SLAVE_DETAILS, sw_interface_slave_details) \
5239 _(IP_ROUTE_ADD_DEL_REPLY, ip_route_add_del_reply) \
5240 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
5241 _(IP_TABLE_REPLACE_BEGIN_REPLY, ip_table_replace_begin_reply) \
5242 _(IP_TABLE_FLUSH_REPLY, ip_table_flush_reply) \
5243 _(IP_TABLE_REPLACE_END_REPLY, ip_table_replace_end_reply) \
5244 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
5245 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
5246 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
5247 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
5248 _(BIER_ROUTE_ADD_DEL_REPLY, bier_route_add_del_reply) \
5249 _(BIER_TABLE_ADD_DEL_REPLY, bier_table_add_del_reply) \
5250 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
5251 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
5252 sw_interface_set_unnumbered_reply) \
5253 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
5254 _(CREATE_SUBIF_REPLY, create_subif_reply) \
5255 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
5256 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
5257 sw_interface_ip6_enable_disable_reply) \
5258 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
5259 _(SR_MPLS_POLICY_ADD_REPLY, sr_mpls_policy_add_reply) \
5260 _(SR_MPLS_POLICY_MOD_REPLY, sr_mpls_policy_mod_reply) \
5261 _(SR_MPLS_POLICY_DEL_REPLY, sr_mpls_policy_del_reply) \
5262 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
5263 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
5264 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
5265 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
5266 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
5267 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
5268 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
5269 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
5270 classify_set_interface_ip_table_reply) \
5271 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
5272 classify_set_interface_l2_tables_reply) \
5273 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
5274 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
5275 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
5276 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
5277 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
5278 l2tpv3_interface_enable_disable_reply) \
5279 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
5280 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
5281 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
5282 _(VXLAN_OFFLOAD_RX_REPLY, vxlan_offload_rx_reply) \
5283 _(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
5284 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
5285 _(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
5286 _(GRE_TUNNEL_ADD_DEL_REPLY, gre_tunnel_add_del_reply) \
5287 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
5288 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
5289 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
5290 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
5291 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
5292 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
5293 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
5294 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
5295 _(SHOW_VERSION_REPLY, show_version_reply) \
5296 _(SHOW_THREADS_REPLY, show_threads_reply) \
5297 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
5298 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
5299 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
5300 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
5301 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
5302 _(L2_MACS_EVENT, l2_macs_event) \
5303 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
5304 _(IP_ADDRESS_DETAILS, ip_address_details) \
5305 _(IP_DETAILS, ip_details) \
5306 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
5307 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
5308 _(IPSEC_SPD_ENTRY_ADD_DEL_REPLY, ipsec_spd_entry_add_del_reply) \
5309 _(IPSEC_SAD_ENTRY_ADD_DEL_REPLY, ipsec_sad_entry_add_del_reply) \
5310 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
5311 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
5312 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
5313 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
5314 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
5315 _(BD_IP_MAC_FLUSH_REPLY, bd_ip_mac_flush_reply) \
5316 _(BD_IP_MAC_DETAILS, bd_ip_mac_details) \
5317 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
5318 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
5319 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
5320 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
5321 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
5322 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
5323 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
5324 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
5325 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
5326 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
5327 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
5328 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
5329 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
5330 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
5331 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
5332 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
5333 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
5334 one_map_register_enable_disable_reply) \
5335 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
5336 _(ONE_SET_TRANSPORT_PROTOCOL_REPLY, one_set_transport_protocol_reply) \
5337 _(ONE_GET_TRANSPORT_PROTOCOL_REPLY, one_get_transport_protocol_reply) \
5338 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5339 one_map_register_fallback_threshold_reply) \
5340 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
5341 one_rloc_probe_enable_disable_reply) \
5342 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
5343 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
5344 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
5345 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
5346 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
5347 _(ONE_LOCATOR_DETAILS, one_locator_details) \
5348 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
5349 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
5350 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
5351 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
5352 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
5353 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
5354 _(ONE_STATS_DETAILS, one_stats_details) \
5355 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
5356 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
5357 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
5358 show_one_stats_enable_disable_reply) \
5359 _(ONE_ADD_DEL_NDP_ENTRY_REPLY, one_add_del_ndp_entry_reply) \
5360 _(ONE_NDP_BD_GET_REPLY, one_ndp_bd_get_reply) \
5361 _(ONE_NDP_ENTRIES_GET_REPLY, one_ndp_entries_get_reply) \
5362 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
5363 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
5364 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
5365 _(ONE_ENABLE_DISABLE_XTR_MODE_REPLY, one_enable_disable_xtr_mode_reply) \
5366 _(ONE_ENABLE_DISABLE_PITR_MODE_REPLY, \
5367 one_enable_disable_pitr_mode_reply) \
5368 _(ONE_ENABLE_DISABLE_PETR_MODE_REPLY, \
5369 one_enable_disable_petr_mode_reply) \
5370 _(ONE_SHOW_XTR_MODE_REPLY, one_show_xtr_mode_reply) \
5371 _(ONE_SHOW_PITR_MODE_REPLY, one_show_pitr_mode_reply) \
5372 _(ONE_SHOW_PETR_MODE_REPLY, one_show_petr_mode_reply) \
5373 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
5374 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
5375 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
5376 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
5377 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
5378 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
5379 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
5380 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
5381 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
5382 gpe_add_del_native_fwd_rpath_reply) \
5383 _(GPE_FWD_ENTRY_PATH_DETAILS, \
5384 gpe_fwd_entry_path_details) \
5385 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
5386 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
5387 one_add_del_map_request_itr_rlocs_reply) \
5388 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
5389 one_get_map_request_itr_rlocs_reply) \
5390 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
5391 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
5392 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
5393 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
5394 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
5395 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
5396 show_one_map_register_state_reply) \
5397 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
5398 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5399 show_one_map_register_fallback_threshold_reply) \
5400 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
5401 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
5402 _(AF_PACKET_DETAILS, af_packet_details) \
5403 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
5404 _(POLICER_DETAILS, policer_details) \
5405 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
5406 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
5407 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
5408 _(MPLS_TABLE_DETAILS, mpls_table_details) \
5409 _(MPLS_ROUTE_DETAILS, mpls_route_details) \
5410 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
5411 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
5412 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
5413 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
5414 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
5415 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
5416 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
5417 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5418 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5419 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5420 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5421 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5422 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5423 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5424 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5425 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5426 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5427 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5428 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5429 ip_source_and_port_range_check_add_del_reply) \
5430 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5431 ip_source_and_port_range_check_interface_add_del_reply) \
5432 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5433 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5434 _(SET_PUNT_REPLY, set_punt_reply) \
5435 _(IP_TABLE_DETAILS, ip_table_details) \
5436 _(IP_ROUTE_DETAILS, ip_route_details) \
5437 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5438 _(FEATURE_GSO_ENABLE_DISABLE_REPLY, feature_gso_enable_disable_reply) \
5439 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5440 _(SW_INTERFACE_ADD_DEL_MAC_ADDRESS_REPLY, sw_interface_add_del_mac_address_reply) \
5441 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5442 _(HW_INTERFACE_SET_MTU_REPLY, hw_interface_set_mtu_reply) \
5443 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5444 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5445 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5446 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5447 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply) \
5448 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
5449 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
5450 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
5451 _(SESSION_RULES_DETAILS, session_rules_details) \
5452 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
5453 _(OUTPUT_ACL_SET_INTERFACE_REPLY, output_acl_set_interface_reply) \
5454 _(QOS_RECORD_ENABLE_DISABLE_REPLY, qos_record_enable_disable_reply)
5456 #define foreach_standalone_reply_msg \
5457 _(SW_INTERFACE_EVENT, sw_interface_event)
5465 #define STR_VTR_OP_CASE(op) \
5466 case L2_VTR_ ## op: \
5470 str_vtr_op (u32 vtr_op)
5474 STR_VTR_OP_CASE (DISABLED);
5475 STR_VTR_OP_CASE (PUSH_1);
5476 STR_VTR_OP_CASE (PUSH_2);
5477 STR_VTR_OP_CASE (POP_1);
5478 STR_VTR_OP_CASE (POP_2);
5479 STR_VTR_OP_CASE (TRANSLATE_1_1);
5480 STR_VTR_OP_CASE (TRANSLATE_1_2);
5481 STR_VTR_OP_CASE (TRANSLATE_2_1);
5482 STR_VTR_OP_CASE (TRANSLATE_2_2);
5489 dump_sub_interface_table (vat_main_t * vam)
5491 const sw_interface_subif_t *sub = NULL;
5493 if (vam->json_output)
5496 ("JSON output supported only for VPE API calls and dump_stats_table");
5501 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5502 "Interface", "sw_if_index",
5503 "sub id", "dot1ad", "tags", "outer id",
5504 "inner id", "exact", "default", "outer any", "inner any");
5506 vec_foreach (sub, vam->sw_if_subif_table)
5509 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5510 sub->interface_name,
5512 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5513 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5514 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5515 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5516 if (sub->vtr_op != L2_VTR_DISABLED)
5519 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
5520 "tag1: %d tag2: %d ]",
5521 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
5522 sub->vtr_tag1, sub->vtr_tag2);
5530 name_sort_cmp (void *a1, void *a2)
5532 name_sort_t *n1 = a1;
5533 name_sort_t *n2 = a2;
5535 return strcmp ((char *) n1->name, (char *) n2->name);
5539 dump_interface_table (vat_main_t * vam)
5542 name_sort_t *nses = 0, *ns;
5544 if (vam->json_output)
5547 ("JSON output supported only for VPE API calls and dump_stats_table");
5552 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5554 vec_add2 (nses, ns, 1);
5555 ns->name = (u8 *)(p->key);
5556 ns->value = (u32) p->value[0];
5560 vec_sort_with_function (nses, name_sort_cmp);
5562 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
5563 vec_foreach (ns, nses)
5565 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
5572 dump_ip_table (vat_main_t * vam, int is_ipv6)
5574 const ip_details_t *det = NULL;
5575 const ip_address_details_t *address = NULL;
5578 print (vam->ofp, "%-12s", "sw_if_index");
5580 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
5587 print (vam->ofp, "%-12d", i);
5588 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
5593 vec_foreach (address, det->addr)
5597 is_ipv6 ? format_ip6_address : format_ip4_address,
5598 address->ip, address->prefix_length);
5606 dump_ipv4_table (vat_main_t * vam)
5608 if (vam->json_output)
5611 ("JSON output supported only for VPE API calls and dump_stats_table");
5615 return dump_ip_table (vam, 0);
5619 dump_ipv6_table (vat_main_t * vam)
5621 if (vam->json_output)
5624 ("JSON output supported only for VPE API calls and dump_stats_table");
5628 return dump_ip_table (vam, 1);
5632 * Pass CLI buffers directly in the CLI_INBAND API message,
5633 * instead of an additional shared memory area.
5636 exec_inband (vat_main_t * vam)
5638 vl_api_cli_inband_t *mp;
5639 unformat_input_t *i = vam->input;
5642 if (vec_len (i->buffer) == 0)
5645 if (vam->exec_mode == 0 && unformat (i, "mode"))
5650 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
5657 * In order for the CLI command to work, it
5658 * must be a vector ending in \n, not a C-string ending
5661 M2 (CLI_INBAND, mp, vec_len (vam->input->buffer));
5662 vl_api_vec_to_api_string (vam->input->buffer, &mp->cmd);
5666 /* json responses may or may not include a useful reply... */
5667 if (vec_len (vam->cmd_reply))
5668 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
5673 exec (vat_main_t * vam)
5675 return exec_inband (vam);
5679 api_create_loopback (vat_main_t * vam)
5681 unformat_input_t *i = vam->input;
5682 vl_api_create_loopback_t *mp;
5683 vl_api_create_loopback_instance_t *mp_lbi;
5686 u8 is_specified = 0;
5687 u32 user_instance = 0;
5690 clib_memset (mac_address, 0, sizeof (mac_address));
5692 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5694 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5696 if (unformat (i, "instance %d", &user_instance))
5704 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
5705 mp_lbi->is_specified = is_specified;
5707 mp_lbi->user_instance = htonl (user_instance);
5709 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
5714 /* Construct the API message */
5715 M (CREATE_LOOPBACK, mp);
5717 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
5726 api_delete_loopback (vat_main_t * vam)
5728 unformat_input_t *i = vam->input;
5729 vl_api_delete_loopback_t *mp;
5730 u32 sw_if_index = ~0;
5733 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5735 if (unformat (i, "sw_if_index %d", &sw_if_index))
5741 if (sw_if_index == ~0)
5743 errmsg ("missing sw_if_index");
5747 /* Construct the API message */
5748 M (DELETE_LOOPBACK, mp);
5749 mp->sw_if_index = ntohl (sw_if_index);
5757 api_want_interface_events (vat_main_t * vam)
5759 unformat_input_t *i = vam->input;
5760 vl_api_want_interface_events_t *mp;
5764 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5766 if (unformat (i, "enable"))
5768 else if (unformat (i, "disable"))
5776 errmsg ("missing enable|disable");
5780 M (WANT_INTERFACE_EVENTS, mp);
5781 mp->enable_disable = enable;
5783 vam->interface_event_display = enable;
5791 /* Note: non-static, called once to set up the initial intfc table */
5793 api_sw_interface_dump (vat_main_t * vam)
5795 vl_api_sw_interface_dump_t *mp;
5796 vl_api_control_ping_t *mp_ping;
5798 name_sort_t *nses = 0, *ns;
5799 sw_interface_subif_t *sub = NULL;
5802 /* Toss the old name table */
5804 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5806 vec_add2 (nses, ns, 1);
5807 ns->name = (u8 *)(p->key);
5808 ns->value = (u32) p->value[0];
5812 hash_free (vam->sw_if_index_by_interface_name);
5814 vec_foreach (ns, nses) vec_free (ns->name);
5818 vec_foreach (sub, vam->sw_if_subif_table)
5820 vec_free (sub->interface_name);
5822 vec_free (vam->sw_if_subif_table);
5824 /* recreate the interface name hash table */
5825 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
5828 * Ask for all interface names. Otherwise, the epic catalog of
5829 * name filters becomes ridiculously long, and vat ends up needing
5830 * to be taught about new interface types.
5832 M (SW_INTERFACE_DUMP, mp);
5835 /* Use a control ping for synchronization */
5836 MPING (CONTROL_PING, mp_ping);
5844 api_sw_interface_set_flags (vat_main_t * vam)
5846 unformat_input_t *i = vam->input;
5847 vl_api_sw_interface_set_flags_t *mp;
5849 u8 sw_if_index_set = 0;
5853 /* Parse args required to build the message */
5854 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5856 if (unformat (i, "admin-up"))
5858 else if (unformat (i, "admin-down"))
5861 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5862 sw_if_index_set = 1;
5863 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5864 sw_if_index_set = 1;
5869 if (sw_if_index_set == 0)
5871 errmsg ("missing interface name or sw_if_index");
5875 /* Construct the API message */
5876 M (SW_INTERFACE_SET_FLAGS, mp);
5877 mp->sw_if_index = ntohl (sw_if_index);
5878 mp->flags = ntohl ((admin_up) ? IF_STATUS_API_FLAG_ADMIN_UP : 0);
5883 /* Wait for a reply, return the good/bad news... */
5889 api_sw_interface_set_rx_mode (vat_main_t * vam)
5891 unformat_input_t *i = vam->input;
5892 vl_api_sw_interface_set_rx_mode_t *mp;
5894 u8 sw_if_index_set = 0;
5896 u8 queue_id_valid = 0;
5898 vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN;
5900 /* Parse args required to build the message */
5901 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5903 if (unformat (i, "queue %d", &queue_id))
5905 else if (unformat (i, "polling"))
5906 mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
5907 else if (unformat (i, "interrupt"))
5908 mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT;
5909 else if (unformat (i, "adaptive"))
5910 mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE;
5912 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5913 sw_if_index_set = 1;
5914 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5915 sw_if_index_set = 1;
5920 if (sw_if_index_set == 0)
5922 errmsg ("missing interface name or sw_if_index");
5925 if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
5927 errmsg ("missing rx-mode");
5931 /* Construct the API message */
5932 M (SW_INTERFACE_SET_RX_MODE, mp);
5933 mp->sw_if_index = ntohl (sw_if_index);
5934 mp->mode = (vl_api_rx_mode_t) mode;
5935 mp->queue_id_valid = queue_id_valid;
5936 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
5941 /* Wait for a reply, return the good/bad news... */
5947 api_sw_interface_set_rx_placement (vat_main_t * vam)
5949 unformat_input_t *i = vam->input;
5950 vl_api_sw_interface_set_rx_placement_t *mp;
5952 u8 sw_if_index_set = 0;
5955 u32 queue_id, thread_index;
5957 /* Parse args required to build the message */
5958 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5960 if (unformat (i, "queue %d", &queue_id))
5962 else if (unformat (i, "main"))
5964 else if (unformat (i, "worker %d", &thread_index))
5967 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5968 sw_if_index_set = 1;
5969 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5970 sw_if_index_set = 1;
5975 if (sw_if_index_set == 0)
5977 errmsg ("missing interface name or sw_if_index");
5983 /* Construct the API message */
5984 M (SW_INTERFACE_SET_RX_PLACEMENT, mp);
5985 mp->sw_if_index = ntohl (sw_if_index);
5986 mp->worker_id = ntohl (thread_index);
5987 mp->queue_id = ntohl (queue_id);
5988 mp->is_main = is_main;
5992 /* Wait for a reply, return the good/bad news... */
5997 static void vl_api_sw_interface_rx_placement_details_t_handler
5998 (vl_api_sw_interface_rx_placement_details_t * mp)
6000 vat_main_t *vam = &vat_main;
6001 u32 worker_id = ntohl (mp->worker_id);
6004 "\n%-11d %-11s %-6d %-5d %-9s",
6005 ntohl (mp->sw_if_index), (worker_id == 0) ? "main" : "worker",
6006 worker_id, ntohl (mp->queue_id),
6008 1) ? "polling" : ((mp->mode == 2) ? "interrupt" : "adaptive"));
6011 static void vl_api_sw_interface_rx_placement_details_t_handler_json
6012 (vl_api_sw_interface_rx_placement_details_t * mp)
6014 vat_main_t *vam = &vat_main;
6015 vat_json_node_t *node = NULL;
6017 if (VAT_JSON_ARRAY != vam->json_tree.type)
6019 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
6020 vat_json_init_array (&vam->json_tree);
6022 node = vat_json_array_add (&vam->json_tree);
6024 vat_json_init_object (node);
6025 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
6026 vat_json_object_add_uint (node, "worker_id", ntohl (mp->worker_id));
6027 vat_json_object_add_uint (node, "queue_id", ntohl (mp->queue_id));
6028 vat_json_object_add_uint (node, "mode", mp->mode);
6032 api_sw_interface_rx_placement_dump (vat_main_t * vam)
6034 unformat_input_t *i = vam->input;
6035 vl_api_sw_interface_rx_placement_dump_t *mp;
6036 vl_api_control_ping_t *mp_ping;
6039 u8 sw_if_index_set = 0;
6041 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6043 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6045 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6052 "\n%-11s %-11s %-6s %-5s %-4s",
6053 "sw_if_index", "main/worker", "thread", "queue", "mode");
6055 /* Dump Interface rx placement */
6056 M (SW_INTERFACE_RX_PLACEMENT_DUMP, mp);
6058 if (sw_if_index_set)
6059 mp->sw_if_index = htonl (sw_if_index);
6061 mp->sw_if_index = ~0;
6065 /* Use a control ping for synchronization */
6066 MPING (CONTROL_PING, mp_ping);
6074 api_sw_interface_clear_stats (vat_main_t * vam)
6076 unformat_input_t *i = vam->input;
6077 vl_api_sw_interface_clear_stats_t *mp;
6079 u8 sw_if_index_set = 0;
6082 /* Parse args required to build the message */
6083 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6085 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6086 sw_if_index_set = 1;
6087 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6088 sw_if_index_set = 1;
6093 /* Construct the API message */
6094 M (SW_INTERFACE_CLEAR_STATS, mp);
6096 if (sw_if_index_set == 1)
6097 mp->sw_if_index = ntohl (sw_if_index);
6099 mp->sw_if_index = ~0;
6104 /* Wait for a reply, return the good/bad news... */
6110 api_sw_interface_add_del_address (vat_main_t * vam)
6112 unformat_input_t *i = vam->input;
6113 vl_api_sw_interface_add_del_address_t *mp;
6115 u8 sw_if_index_set = 0;
6116 u8 is_add = 1, del_all = 0;
6117 u32 address_length = 0;
6118 u8 v4_address_set = 0;
6119 u8 v6_address_set = 0;
6120 ip4_address_t v4address;
6121 ip6_address_t v6address;
6124 /* Parse args required to build the message */
6125 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6127 if (unformat (i, "del-all"))
6129 else if (unformat (i, "del"))
6132 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6133 sw_if_index_set = 1;
6134 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6135 sw_if_index_set = 1;
6136 else if (unformat (i, "%U/%d",
6137 unformat_ip4_address, &v4address, &address_length))
6139 else if (unformat (i, "%U/%d",
6140 unformat_ip6_address, &v6address, &address_length))
6146 if (sw_if_index_set == 0)
6148 errmsg ("missing interface name or sw_if_index");
6151 if (v4_address_set && v6_address_set)
6153 errmsg ("both v4 and v6 addresses set");
6156 if (!v4_address_set && !v6_address_set && !del_all)
6158 errmsg ("no addresses set");
6162 /* Construct the API message */
6163 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
6165 mp->sw_if_index = ntohl (sw_if_index);
6166 mp->is_add = is_add;
6167 mp->del_all = del_all;
6170 mp->prefix.address.af = ADDRESS_IP6;
6171 clib_memcpy (mp->prefix.address.un.ip6, &v6address, sizeof (v6address));
6175 mp->prefix.address.af = ADDRESS_IP4;
6176 clib_memcpy (mp->prefix.address.un.ip4, &v4address, sizeof (v4address));
6178 mp->prefix.len = address_length;
6183 /* Wait for a reply, return good/bad news */
6189 api_sw_interface_set_mpls_enable (vat_main_t * vam)
6191 unformat_input_t *i = vam->input;
6192 vl_api_sw_interface_set_mpls_enable_t *mp;
6194 u8 sw_if_index_set = 0;
6198 /* Parse args required to build the message */
6199 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6201 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6202 sw_if_index_set = 1;
6203 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6204 sw_if_index_set = 1;
6205 else if (unformat (i, "disable"))
6207 else if (unformat (i, "dis"))
6213 if (sw_if_index_set == 0)
6215 errmsg ("missing interface name or sw_if_index");
6219 /* Construct the API message */
6220 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
6222 mp->sw_if_index = ntohl (sw_if_index);
6223 mp->enable = enable;
6228 /* Wait for a reply... */
6234 api_sw_interface_set_table (vat_main_t * vam)
6236 unformat_input_t *i = vam->input;
6237 vl_api_sw_interface_set_table_t *mp;
6238 u32 sw_if_index, vrf_id = 0;
6239 u8 sw_if_index_set = 0;
6243 /* Parse args required to build the message */
6244 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6246 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6247 sw_if_index_set = 1;
6248 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6249 sw_if_index_set = 1;
6250 else if (unformat (i, "vrf %d", &vrf_id))
6252 else if (unformat (i, "ipv6"))
6258 if (sw_if_index_set == 0)
6260 errmsg ("missing interface name or sw_if_index");
6264 /* Construct the API message */
6265 M (SW_INTERFACE_SET_TABLE, mp);
6267 mp->sw_if_index = ntohl (sw_if_index);
6268 mp->is_ipv6 = is_ipv6;
6269 mp->vrf_id = ntohl (vrf_id);
6274 /* Wait for a reply... */
6279 static void vl_api_sw_interface_get_table_reply_t_handler
6280 (vl_api_sw_interface_get_table_reply_t * mp)
6282 vat_main_t *vam = &vat_main;
6284 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6286 vam->retval = ntohl (mp->retval);
6287 vam->result_ready = 1;
6291 static void vl_api_sw_interface_get_table_reply_t_handler_json
6292 (vl_api_sw_interface_get_table_reply_t * mp)
6294 vat_main_t *vam = &vat_main;
6295 vat_json_node_t node;
6297 vat_json_init_object (&node);
6298 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6299 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6301 vat_json_print (vam->ofp, &node);
6302 vat_json_free (&node);
6304 vam->retval = ntohl (mp->retval);
6305 vam->result_ready = 1;
6309 api_sw_interface_get_table (vat_main_t * vam)
6311 unformat_input_t *i = vam->input;
6312 vl_api_sw_interface_get_table_t *mp;
6314 u8 sw_if_index_set = 0;
6318 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6320 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6321 sw_if_index_set = 1;
6322 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6323 sw_if_index_set = 1;
6324 else if (unformat (i, "ipv6"))
6330 if (sw_if_index_set == 0)
6332 errmsg ("missing interface name or sw_if_index");
6336 M (SW_INTERFACE_GET_TABLE, mp);
6337 mp->sw_if_index = htonl (sw_if_index);
6338 mp->is_ipv6 = is_ipv6;
6346 api_sw_interface_set_vpath (vat_main_t * vam)
6348 unformat_input_t *i = vam->input;
6349 vl_api_sw_interface_set_vpath_t *mp;
6350 u32 sw_if_index = 0;
6351 u8 sw_if_index_set = 0;
6355 /* Parse args required to build the message */
6356 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6358 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6359 sw_if_index_set = 1;
6360 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6361 sw_if_index_set = 1;
6362 else if (unformat (i, "enable"))
6364 else if (unformat (i, "disable"))
6370 if (sw_if_index_set == 0)
6372 errmsg ("missing interface name or sw_if_index");
6376 /* Construct the API message */
6377 M (SW_INTERFACE_SET_VPATH, mp);
6379 mp->sw_if_index = ntohl (sw_if_index);
6380 mp->enable = is_enable;
6385 /* Wait for a reply... */
6391 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
6393 unformat_input_t *i = vam->input;
6394 vl_api_sw_interface_set_vxlan_bypass_t *mp;
6395 u32 sw_if_index = 0;
6396 u8 sw_if_index_set = 0;
6401 /* Parse args required to build the message */
6402 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6404 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6405 sw_if_index_set = 1;
6406 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6407 sw_if_index_set = 1;
6408 else if (unformat (i, "enable"))
6410 else if (unformat (i, "disable"))
6412 else if (unformat (i, "ip4"))
6414 else if (unformat (i, "ip6"))
6420 if (sw_if_index_set == 0)
6422 errmsg ("missing interface name or sw_if_index");
6426 /* Construct the API message */
6427 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
6429 mp->sw_if_index = ntohl (sw_if_index);
6430 mp->enable = is_enable;
6431 mp->is_ipv6 = is_ipv6;
6436 /* Wait for a reply... */
6442 api_sw_interface_set_geneve_bypass (vat_main_t * vam)
6444 unformat_input_t *i = vam->input;
6445 vl_api_sw_interface_set_geneve_bypass_t *mp;
6446 u32 sw_if_index = 0;
6447 u8 sw_if_index_set = 0;
6452 /* Parse args required to build the message */
6453 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6455 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6456 sw_if_index_set = 1;
6457 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6458 sw_if_index_set = 1;
6459 else if (unformat (i, "enable"))
6461 else if (unformat (i, "disable"))
6463 else if (unformat (i, "ip4"))
6465 else if (unformat (i, "ip6"))
6471 if (sw_if_index_set == 0)
6473 errmsg ("missing interface name or sw_if_index");
6477 /* Construct the API message */
6478 M (SW_INTERFACE_SET_GENEVE_BYPASS, mp);
6480 mp->sw_if_index = ntohl (sw_if_index);
6481 mp->enable = is_enable;
6482 mp->is_ipv6 = is_ipv6;
6487 /* Wait for a reply... */
6493 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
6495 unformat_input_t *i = vam->input;
6496 vl_api_sw_interface_set_l2_xconnect_t *mp;
6498 u8 rx_sw_if_index_set = 0;
6500 u8 tx_sw_if_index_set = 0;
6504 /* Parse args required to build the message */
6505 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6507 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6508 rx_sw_if_index_set = 1;
6509 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6510 tx_sw_if_index_set = 1;
6511 else if (unformat (i, "rx"))
6513 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6515 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6517 rx_sw_if_index_set = 1;
6522 else if (unformat (i, "tx"))
6524 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6526 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6528 tx_sw_if_index_set = 1;
6533 else if (unformat (i, "enable"))
6535 else if (unformat (i, "disable"))
6541 if (rx_sw_if_index_set == 0)
6543 errmsg ("missing rx interface name or rx_sw_if_index");
6547 if (enable && (tx_sw_if_index_set == 0))
6549 errmsg ("missing tx interface name or tx_sw_if_index");
6553 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
6555 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6556 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6557 mp->enable = enable;
6565 api_sw_interface_set_l2_bridge (vat_main_t * vam)
6567 unformat_input_t *i = vam->input;
6568 vl_api_sw_interface_set_l2_bridge_t *mp;
6569 vl_api_l2_port_type_t port_type;
6571 u8 rx_sw_if_index_set = 0;
6578 port_type = L2_API_PORT_TYPE_NORMAL;
6580 /* Parse args required to build the message */
6581 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6583 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
6584 rx_sw_if_index_set = 1;
6585 else if (unformat (i, "bd_id %d", &bd_id))
6589 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
6590 rx_sw_if_index_set = 1;
6591 else if (unformat (i, "shg %d", &shg))
6593 else if (unformat (i, "bvi"))
6594 port_type = L2_API_PORT_TYPE_BVI;
6595 else if (unformat (i, "uu-fwd"))
6596 port_type = L2_API_PORT_TYPE_UU_FWD;
6597 else if (unformat (i, "enable"))
6599 else if (unformat (i, "disable"))
6605 if (rx_sw_if_index_set == 0)
6607 errmsg ("missing rx interface name or sw_if_index");
6611 if (enable && (bd_id_set == 0))
6613 errmsg ("missing bridge domain");
6617 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
6619 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6620 mp->bd_id = ntohl (bd_id);
6622 mp->port_type = ntohl (port_type);
6623 mp->enable = enable;
6631 api_bridge_domain_dump (vat_main_t * vam)
6633 unformat_input_t *i = vam->input;
6634 vl_api_bridge_domain_dump_t *mp;
6635 vl_api_control_ping_t *mp_ping;
6639 /* Parse args required to build the message */
6640 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6642 if (unformat (i, "bd_id %d", &bd_id))
6648 M (BRIDGE_DOMAIN_DUMP, mp);
6649 mp->bd_id = ntohl (bd_id);
6652 /* Use a control ping for synchronization */
6653 MPING (CONTROL_PING, mp_ping);
6661 api_bridge_domain_add_del (vat_main_t * vam)
6663 unformat_input_t *i = vam->input;
6664 vl_api_bridge_domain_add_del_t *mp;
6667 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
6672 /* Parse args required to build the message */
6673 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6675 if (unformat (i, "bd_id %d", &bd_id))
6677 else if (unformat (i, "flood %d", &flood))
6679 else if (unformat (i, "uu-flood %d", &uu_flood))
6681 else if (unformat (i, "forward %d", &forward))
6683 else if (unformat (i, "learn %d", &learn))
6685 else if (unformat (i, "arp-term %d", &arp_term))
6687 else if (unformat (i, "mac-age %d", &mac_age))
6689 else if (unformat (i, "bd-tag %s", &bd_tag))
6691 else if (unformat (i, "del"))
6694 flood = uu_flood = forward = learn = 0;
6702 errmsg ("missing bridge domain");
6709 errmsg ("mac age must be less than 256 ");
6714 if ((bd_tag) && (vec_len (bd_tag) > 63))
6716 errmsg ("bd-tag cannot be longer than 63");
6721 M (BRIDGE_DOMAIN_ADD_DEL, mp);
6723 mp->bd_id = ntohl (bd_id);
6725 mp->uu_flood = uu_flood;
6726 mp->forward = forward;
6728 mp->arp_term = arp_term;
6729 mp->is_add = is_add;
6730 mp->mac_age = (u8) mac_age;
6733 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
6734 mp->bd_tag[vec_len (bd_tag)] = 0;
6745 api_l2fib_flush_bd (vat_main_t * vam)
6747 unformat_input_t *i = vam->input;
6748 vl_api_l2fib_flush_bd_t *mp;
6752 /* Parse args required to build the message */
6753 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6755 if (unformat (i, "bd_id %d", &bd_id));
6762 errmsg ("missing bridge domain");
6766 M (L2FIB_FLUSH_BD, mp);
6768 mp->bd_id = htonl (bd_id);
6776 api_l2fib_flush_int (vat_main_t * vam)
6778 unformat_input_t *i = vam->input;
6779 vl_api_l2fib_flush_int_t *mp;
6780 u32 sw_if_index = ~0;
6783 /* Parse args required to build the message */
6784 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6786 if (unformat (i, "sw_if_index %d", &sw_if_index));
6788 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
6793 if (sw_if_index == ~0)
6795 errmsg ("missing interface name or sw_if_index");
6799 M (L2FIB_FLUSH_INT, mp);
6801 mp->sw_if_index = ntohl (sw_if_index);
6809 api_l2fib_add_del (vat_main_t * vam)
6811 unformat_input_t *i = vam->input;
6812 vl_api_l2fib_add_del_t *mp;
6818 u32 sw_if_index = 0;
6819 u8 sw_if_index_set = 0;
6828 /* Parse args required to build the message */
6829 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6831 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
6833 else if (unformat (i, "bd_id %d", &bd_id))
6835 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6836 sw_if_index_set = 1;
6837 else if (unformat (i, "sw_if"))
6839 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6842 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6843 sw_if_index_set = 1;
6848 else if (unformat (i, "static"))
6850 else if (unformat (i, "filter"))
6855 else if (unformat (i, "bvi"))
6860 else if (unformat (i, "del"))
6862 else if (unformat (i, "count %d", &count))
6870 errmsg ("missing mac address");
6876 errmsg ("missing bridge domain");
6880 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
6882 errmsg ("missing interface name or sw_if_index");
6888 /* Turn on async mode */
6889 vam->async_mode = 1;
6890 vam->async_errors = 0;
6891 before = vat_time_now (vam);
6894 for (j = 0; j < count; j++)
6896 M (L2FIB_ADD_DEL, mp);
6898 clib_memcpy (mp->mac, mac, 6);
6899 mp->bd_id = ntohl (bd_id);
6900 mp->is_add = is_add;
6901 mp->sw_if_index = ntohl (sw_if_index);
6905 mp->static_mac = static_mac;
6906 mp->filter_mac = filter_mac;
6907 mp->bvi_mac = bvi_mac;
6909 increment_mac_address (mac);
6916 vl_api_control_ping_t *mp_ping;
6919 /* Shut off async mode */
6920 vam->async_mode = 0;
6922 MPING (CONTROL_PING, mp_ping);
6925 timeout = vat_time_now (vam) + 1.0;
6926 while (vat_time_now (vam) < timeout)
6927 if (vam->result_ready == 1)
6932 if (vam->retval == -99)
6935 if (vam->async_errors > 0)
6937 errmsg ("%d asynchronous errors", vam->async_errors);
6940 vam->async_errors = 0;
6941 after = vat_time_now (vam);
6943 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6944 count, after - before, count / (after - before));
6950 /* Wait for a reply... */
6954 /* Return the good/bad news */
6955 return (vam->retval);
6959 api_bridge_domain_set_mac_age (vat_main_t * vam)
6961 unformat_input_t *i = vam->input;
6962 vl_api_bridge_domain_set_mac_age_t *mp;
6967 /* Parse args required to build the message */
6968 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6970 if (unformat (i, "bd_id %d", &bd_id));
6971 else if (unformat (i, "mac-age %d", &mac_age));
6978 errmsg ("missing bridge domain");
6984 errmsg ("mac age must be less than 256 ");
6988 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
6990 mp->bd_id = htonl (bd_id);
6991 mp->mac_age = (u8) mac_age;
6999 api_l2_flags (vat_main_t * vam)
7001 unformat_input_t *i = vam->input;
7002 vl_api_l2_flags_t *mp;
7005 u8 sw_if_index_set = 0;
7009 /* Parse args required to build the message */
7010 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7012 if (unformat (i, "sw_if_index %d", &sw_if_index))
7013 sw_if_index_set = 1;
7014 else if (unformat (i, "sw_if"))
7016 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7019 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7020 sw_if_index_set = 1;
7025 else if (unformat (i, "learn"))
7027 else if (unformat (i, "forward"))
7029 else if (unformat (i, "flood"))
7031 else if (unformat (i, "uu-flood"))
7032 flags |= L2_UU_FLOOD;
7033 else if (unformat (i, "arp-term"))
7034 flags |= L2_ARP_TERM;
7035 else if (unformat (i, "off"))
7037 else if (unformat (i, "disable"))
7043 if (sw_if_index_set == 0)
7045 errmsg ("missing interface name or sw_if_index");
7051 mp->sw_if_index = ntohl (sw_if_index);
7052 mp->feature_bitmap = ntohl (flags);
7053 mp->is_set = is_set;
7061 api_bridge_flags (vat_main_t * vam)
7063 unformat_input_t *i = vam->input;
7064 vl_api_bridge_flags_t *mp;
7068 bd_flags_t flags = 0;
7071 /* Parse args required to build the message */
7072 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7074 if (unformat (i, "bd_id %d", &bd_id))
7076 else if (unformat (i, "learn"))
7077 flags |= BRIDGE_API_FLAG_LEARN;
7078 else if (unformat (i, "forward"))
7079 flags |= BRIDGE_API_FLAG_FWD;
7080 else if (unformat (i, "flood"))
7081 flags |= BRIDGE_API_FLAG_FLOOD;
7082 else if (unformat (i, "uu-flood"))
7083 flags |= BRIDGE_API_FLAG_UU_FLOOD;
7084 else if (unformat (i, "arp-term"))
7085 flags |= BRIDGE_API_FLAG_ARP_TERM;
7086 else if (unformat (i, "off"))
7088 else if (unformat (i, "disable"))
7096 errmsg ("missing bridge domain");
7100 M (BRIDGE_FLAGS, mp);
7102 mp->bd_id = ntohl (bd_id);
7103 mp->flags = ntohl (flags);
7104 mp->is_set = is_set;
7112 api_bd_ip_mac_add_del (vat_main_t * vam)
7114 vl_api_address_t ip = VL_API_ZERO_ADDRESS;
7115 vl_api_mac_address_t mac = { 0 };
7116 unformat_input_t *i = vam->input;
7117 vl_api_bd_ip_mac_add_del_t *mp;
7126 /* Parse args required to build the message */
7127 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7129 if (unformat (i, "bd_id %d", &bd_id))
7133 else if (unformat (i, "%U", unformat_vl_api_address, &ip))
7137 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
7141 else if (unformat (i, "del"))
7149 errmsg ("missing bridge domain");
7152 else if (ip_set == 0)
7154 errmsg ("missing IP address");
7157 else if (mac_set == 0)
7159 errmsg ("missing MAC address");
7163 M (BD_IP_MAC_ADD_DEL, mp);
7165 mp->entry.bd_id = ntohl (bd_id);
7166 mp->is_add = is_add;
7168 clib_memcpy (&mp->entry.ip, &ip, sizeof (ip));
7169 clib_memcpy (&mp->entry.mac, &mac, sizeof (mac));
7177 api_bd_ip_mac_flush (vat_main_t * vam)
7179 unformat_input_t *i = vam->input;
7180 vl_api_bd_ip_mac_flush_t *mp;
7185 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7187 if (unformat (i, "bd_id %d", &bd_id))
7197 errmsg ("missing bridge domain");
7201 M (BD_IP_MAC_FLUSH, mp);
7203 mp->bd_id = ntohl (bd_id);
7210 static void vl_api_bd_ip_mac_details_t_handler
7211 (vl_api_bd_ip_mac_details_t * mp)
7213 vat_main_t *vam = &vat_main;
7217 ntohl (mp->entry.bd_id),
7218 format_vl_api_mac_address, mp->entry.mac,
7219 format_vl_api_address, &mp->entry.ip);
7222 static void vl_api_bd_ip_mac_details_t_handler_json
7223 (vl_api_bd_ip_mac_details_t * mp)
7225 vat_main_t *vam = &vat_main;
7226 vat_json_node_t *node = NULL;
7228 if (VAT_JSON_ARRAY != vam->json_tree.type)
7230 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7231 vat_json_init_array (&vam->json_tree);
7233 node = vat_json_array_add (&vam->json_tree);
7235 vat_json_init_object (node);
7236 vat_json_object_add_uint (node, "bd_id", ntohl (mp->entry.bd_id));
7237 vat_json_object_add_string_copy (node, "mac_address",
7238 format (0, "%U", format_vl_api_mac_address,
7242 ip = format (0, "%U", format_vl_api_address, &mp->entry.ip);
7243 vat_json_object_add_string_copy (node, "ip_address", ip);
7248 api_bd_ip_mac_dump (vat_main_t * vam)
7250 unformat_input_t *i = vam->input;
7251 vl_api_bd_ip_mac_dump_t *mp;
7252 vl_api_control_ping_t *mp_ping;
7257 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7259 if (unformat (i, "bd_id %d", &bd_id))
7268 "\n%-5s %-7s %-20s %-30s",
7269 "bd_id", "is_ipv6", "mac_address", "ip_address");
7271 /* Dump Bridge Domain Ip to Mac entries */
7272 M (BD_IP_MAC_DUMP, mp);
7275 mp->bd_id = htonl (bd_id);
7281 /* Use a control ping for synchronization */
7282 MPING (CONTROL_PING, mp_ping);
7290 api_tap_create_v2 (vat_main_t * vam)
7292 unformat_input_t *i = vam->input;
7293 vl_api_tap_create_v2_t *mp;
7297 u32 num_rx_queues = 0;
7298 u8 *host_if_name = 0;
7299 u8 host_if_name_set = 0;
7302 u8 host_mac_addr[6];
7303 u8 host_mac_addr_set = 0;
7304 u8 *host_bridge = 0;
7305 u8 host_bridge_set = 0;
7306 u8 host_ip4_prefix_set = 0;
7307 u8 host_ip6_prefix_set = 0;
7308 ip4_address_t host_ip4_addr;
7309 ip4_address_t host_ip4_gw;
7310 u8 host_ip4_gw_set = 0;
7311 u32 host_ip4_prefix_len = 0;
7312 ip6_address_t host_ip6_addr;
7313 ip6_address_t host_ip6_gw;
7314 u8 host_ip6_gw_set = 0;
7315 u32 host_ip6_prefix_len = 0;
7316 u32 host_mtu_size = 0;
7317 u8 host_mtu_set = 0;
7320 u32 rx_ring_sz = 0, tx_ring_sz = 0;
7322 clib_memset (mac_address, 0, sizeof (mac_address));
7324 /* Parse args required to build the message */
7325 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7327 if (unformat (i, "id %u", &id))
7331 (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7333 else if (unformat (i, "host-if-name %s", &host_if_name))
7334 host_if_name_set = 1;
7335 else if (unformat (i, "num-rx-queues %u", &num_rx_queues))
7337 else if (unformat (i, "host-ns %s", &host_ns))
7339 else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
7341 host_mac_addr_set = 1;
7342 else if (unformat (i, "host-bridge %s", &host_bridge))
7343 host_bridge_set = 1;
7344 else if (unformat (i, "host-ip4-addr %U/%u", unformat_ip4_address,
7345 &host_ip4_addr, &host_ip4_prefix_len))
7346 host_ip4_prefix_set = 1;
7347 else if (unformat (i, "host-ip6-addr %U/%u", unformat_ip6_address,
7348 &host_ip6_addr, &host_ip6_prefix_len))
7349 host_ip6_prefix_set = 1;
7350 else if (unformat (i, "host-ip4-gw %U", unformat_ip4_address,
7352 host_ip4_gw_set = 1;
7353 else if (unformat (i, "host-ip6-gw %U", unformat_ip6_address,
7355 host_ip6_gw_set = 1;
7356 else if (unformat (i, "rx-ring-size %u", &rx_ring_sz))
7358 else if (unformat (i, "tx-ring-size %u", &tx_ring_sz))
7360 else if (unformat (i, "host-mtu-size %u", &host_mtu_size))
7362 else if (unformat (i, "no-gso"))
7363 tap_flags &= ~TAP_FLAG_GSO;
7364 else if (unformat (i, "gso"))
7365 tap_flags |= TAP_FLAG_GSO;
7366 else if (unformat (i, "csum-offload"))
7367 tap_flags |= TAP_FLAG_CSUM_OFFLOAD;
7368 else if (unformat (i, "persist"))
7369 tap_flags |= TAP_FLAG_PERSIST;
7370 else if (unformat (i, "attach"))
7371 tap_flags |= TAP_FLAG_ATTACH;
7376 if (vec_len (host_if_name) > 63)
7378 errmsg ("tap name too long. ");
7381 if (vec_len (host_ns) > 63)
7383 errmsg ("host name space too long. ");
7386 if (vec_len (host_bridge) > 63)
7388 errmsg ("host bridge name too long. ");
7391 if (host_ip4_prefix_len > 32)
7393 errmsg ("host ip4 prefix length not valid. ");
7396 if (host_ip6_prefix_len > 128)
7398 errmsg ("host ip6 prefix length not valid. ");
7401 if (!is_pow2 (rx_ring_sz))
7403 errmsg ("rx ring size must be power of 2. ");
7406 if (rx_ring_sz > 32768)
7408 errmsg ("rx ring size must be 32768 or lower. ");
7411 if (!is_pow2 (tx_ring_sz))
7413 errmsg ("tx ring size must be power of 2. ");
7416 if (tx_ring_sz > 32768)
7418 errmsg ("tx ring size must be 32768 or lower. ");
7421 if (host_mtu_set && (host_mtu_size < 64 || host_mtu_size > 65355))
7423 errmsg ("host MTU size must be in between 64 and 65355. ");
7427 /* Construct the API message */
7428 M (TAP_CREATE_V2, mp);
7430 mp->id = ntohl (id);
7431 mp->use_random_mac = random_mac;
7432 mp->num_rx_queues = (u8) num_rx_queues;
7433 mp->tx_ring_sz = ntohs (tx_ring_sz);
7434 mp->rx_ring_sz = ntohs (rx_ring_sz);
7435 mp->host_mtu_set = host_mtu_set;
7436 mp->host_mtu_size = ntohl (host_mtu_size);
7437 mp->host_mac_addr_set = host_mac_addr_set;
7438 mp->host_ip4_prefix_set = host_ip4_prefix_set;
7439 mp->host_ip6_prefix_set = host_ip6_prefix_set;
7440 mp->host_ip4_gw_set = host_ip4_gw_set;
7441 mp->host_ip6_gw_set = host_ip6_gw_set;
7442 mp->tap_flags = ntohl (tap_flags);
7443 mp->host_namespace_set = host_ns_set;
7444 mp->host_if_name_set = host_if_name_set;
7445 mp->host_bridge_set = host_bridge_set;
7447 if (random_mac == 0)
7448 clib_memcpy (mp->mac_address, mac_address, 6);
7449 if (host_mac_addr_set)
7450 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
7451 if (host_if_name_set)
7452 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
7454 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
7455 if (host_bridge_set)
7456 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
7457 if (host_ip4_prefix_set)
7459 clib_memcpy (mp->host_ip4_prefix.address, &host_ip4_addr, 4);
7460 mp->host_ip4_prefix.len = (u8) host_ip4_prefix_len;
7462 if (host_ip6_prefix_set)
7464 clib_memcpy (mp->host_ip6_prefix.address, &host_ip6_addr, 16);
7465 mp->host_ip6_prefix.len = (u8) host_ip6_prefix_len;
7467 if (host_ip4_gw_set)
7468 clib_memcpy (mp->host_ip4_gw, &host_ip4_gw, 4);
7469 if (host_ip6_gw_set)
7470 clib_memcpy (mp->host_ip6_gw, &host_ip6_gw, 16);
7473 vec_free (host_if_name);
7474 vec_free (host_bridge);
7479 /* Wait for a reply... */
7485 api_tap_delete_v2 (vat_main_t * vam)
7487 unformat_input_t *i = vam->input;
7488 vl_api_tap_delete_v2_t *mp;
7489 u32 sw_if_index = ~0;
7490 u8 sw_if_index_set = 0;
7493 /* Parse args required to build the message */
7494 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7496 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7497 sw_if_index_set = 1;
7498 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7499 sw_if_index_set = 1;
7504 if (sw_if_index_set == 0)
7506 errmsg ("missing vpp interface name. ");
7510 /* Construct the API message */
7511 M (TAP_DELETE_V2, mp);
7513 mp->sw_if_index = ntohl (sw_if_index);
7518 /* Wait for a reply... */
7524 unformat_vlib_pci_addr (unformat_input_t * input, va_list * args)
7526 vlib_pci_addr_t *addr = va_arg (*args, vlib_pci_addr_t *);
7529 if (!unformat (input, "%x:%x:%x.%x", &x[0], &x[1], &x[2], &x[3]))
7532 addr->domain = x[0];
7535 addr->function = x[3];
7541 api_virtio_pci_create (vat_main_t * vam)
7543 unformat_input_t *i = vam->input;
7544 vl_api_virtio_pci_create_t *mp;
7548 u8 checksum_offload_enabled = 0;
7550 u64 features = (u64) ~ (0ULL);
7553 clib_memset (mac_address, 0, sizeof (mac_address));
7555 /* Parse args required to build the message */
7556 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7558 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7562 else if (unformat (i, "pci-addr %U", unformat_vlib_pci_addr, &pci_addr))
7564 else if (unformat (i, "features 0x%llx", &features))
7566 else if (unformat (i, "gso-enabled"))
7568 else if (unformat (i, "csum-offload-enabled"))
7569 checksum_offload_enabled = 1;
7576 errmsg ("pci address must be non zero. ");
7580 /* Construct the API message */
7581 M (VIRTIO_PCI_CREATE, mp);
7583 mp->use_random_mac = random_mac;
7585 mp->pci_addr.domain = htons (((vlib_pci_addr_t) pci_addr).domain);
7586 mp->pci_addr.bus = ((vlib_pci_addr_t) pci_addr).bus;
7587 mp->pci_addr.slot = ((vlib_pci_addr_t) pci_addr).slot;
7588 mp->pci_addr.function = ((vlib_pci_addr_t) pci_addr).function;
7590 mp->features = clib_host_to_net_u64 (features);
7591 mp->gso_enabled = gso_enabled;
7592 mp->checksum_offload_enabled = checksum_offload_enabled;
7594 if (random_mac == 0)
7595 clib_memcpy (mp->mac_address, mac_address, 6);
7600 /* Wait for a reply... */
7606 api_virtio_pci_delete (vat_main_t * vam)
7608 unformat_input_t *i = vam->input;
7609 vl_api_virtio_pci_delete_t *mp;
7610 u32 sw_if_index = ~0;
7611 u8 sw_if_index_set = 0;
7614 /* Parse args required to build the message */
7615 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7617 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7618 sw_if_index_set = 1;
7619 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7620 sw_if_index_set = 1;
7625 if (sw_if_index_set == 0)
7627 errmsg ("missing vpp interface name. ");
7631 /* Construct the API message */
7632 M (VIRTIO_PCI_DELETE, mp);
7634 mp->sw_if_index = htonl (sw_if_index);
7639 /* Wait for a reply... */
7645 api_bond_create (vat_main_t * vam)
7647 unformat_input_t *i = vam->input;
7648 vl_api_bond_create_t *mp;
7658 clib_memset (mac_address, 0, sizeof (mac_address));
7661 /* Parse args required to build the message */
7662 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7664 if (unformat (i, "mode %U", unformat_bond_mode, &mode))
7666 else if (((mode == BOND_MODE_LACP) || (mode == BOND_MODE_XOR))
7667 && unformat (i, "lb %U", unformat_bond_load_balance, &lb))
7669 else if (unformat (i, "hw-addr %U", unformat_ethernet_address,
7672 else if (unformat (i, "numa-only"))
7674 else if (unformat (i, "id %u", &id))
7680 if (mode_is_set == 0)
7682 errmsg ("Missing bond mode. ");
7686 /* Construct the API message */
7687 M (BOND_CREATE, mp);
7689 mp->use_custom_mac = custom_mac;
7691 mp->mode = htonl (mode);
7692 mp->lb = htonl (lb);
7693 mp->id = htonl (id);
7694 mp->numa_only = numa_only;
7697 clib_memcpy (mp->mac_address, mac_address, 6);
7702 /* Wait for a reply... */
7708 api_bond_delete (vat_main_t * vam)
7710 unformat_input_t *i = vam->input;
7711 vl_api_bond_delete_t *mp;
7712 u32 sw_if_index = ~0;
7713 u8 sw_if_index_set = 0;
7716 /* Parse args required to build the message */
7717 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7719 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7720 sw_if_index_set = 1;
7721 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7722 sw_if_index_set = 1;
7727 if (sw_if_index_set == 0)
7729 errmsg ("missing vpp interface name. ");
7733 /* Construct the API message */
7734 M (BOND_DELETE, mp);
7736 mp->sw_if_index = ntohl (sw_if_index);
7741 /* Wait for a reply... */
7747 api_bond_enslave (vat_main_t * vam)
7749 unformat_input_t *i = vam->input;
7750 vl_api_bond_enslave_t *mp;
7751 u32 bond_sw_if_index;
7755 u32 bond_sw_if_index_is_set = 0;
7757 u8 sw_if_index_is_set = 0;
7759 /* Parse args required to build the message */
7760 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7762 if (unformat (i, "sw_if_index %d", &sw_if_index))
7763 sw_if_index_is_set = 1;
7764 else if (unformat (i, "bond %u", &bond_sw_if_index))
7765 bond_sw_if_index_is_set = 1;
7766 else if (unformat (i, "passive %d", &is_passive))
7768 else if (unformat (i, "long-timeout %d", &is_long_timeout))
7774 if (bond_sw_if_index_is_set == 0)
7776 errmsg ("Missing bond sw_if_index. ");
7779 if (sw_if_index_is_set == 0)
7781 errmsg ("Missing slave sw_if_index. ");
7785 /* Construct the API message */
7786 M (BOND_ENSLAVE, mp);
7788 mp->bond_sw_if_index = ntohl (bond_sw_if_index);
7789 mp->sw_if_index = ntohl (sw_if_index);
7790 mp->is_long_timeout = is_long_timeout;
7791 mp->is_passive = is_passive;
7796 /* Wait for a reply... */
7802 api_bond_detach_slave (vat_main_t * vam)
7804 unformat_input_t *i = vam->input;
7805 vl_api_bond_detach_slave_t *mp;
7806 u32 sw_if_index = ~0;
7807 u8 sw_if_index_set = 0;
7810 /* Parse args required to build the message */
7811 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7813 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7814 sw_if_index_set = 1;
7815 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7816 sw_if_index_set = 1;
7821 if (sw_if_index_set == 0)
7823 errmsg ("missing vpp interface name. ");
7827 /* Construct the API message */
7828 M (BOND_DETACH_SLAVE, mp);
7830 mp->sw_if_index = ntohl (sw_if_index);
7835 /* Wait for a reply... */
7841 api_ip_table_add_del (vat_main_t * vam)
7843 unformat_input_t *i = vam->input;
7844 vl_api_ip_table_add_del_t *mp;
7850 /* Parse args required to build the message */
7851 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7853 if (unformat (i, "ipv6"))
7855 else if (unformat (i, "del"))
7857 else if (unformat (i, "add"))
7859 else if (unformat (i, "table %d", &table_id))
7863 clib_warning ("parse error '%U'", format_unformat_error, i);
7870 errmsg ("missing table-ID");
7874 /* Construct the API message */
7875 M (IP_TABLE_ADD_DEL, mp);
7877 mp->table.table_id = ntohl (table_id);
7878 mp->table.is_ip6 = is_ipv6;
7879 mp->is_add = is_add;
7884 /* Wait for a reply... */
7891 unformat_fib_path (unformat_input_t * input, va_list * args)
7893 vat_main_t *vam = va_arg (*args, vat_main_t *);
7894 vl_api_fib_path_t *path = va_arg (*args, vl_api_fib_path_t *);
7895 u32 weight, preference;
7896 mpls_label_t out_label;
7898 clib_memset (path, 0, sizeof (*path));
7900 path->sw_if_index = ~0;
7904 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7906 if (unformat (input, "%U %U",
7907 unformat_vl_api_ip4_address,
7908 &path->nh.address.ip4,
7909 api_unformat_sw_if_index, vam, &path->sw_if_index))
7911 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7913 else if (unformat (input, "%U %U",
7914 unformat_vl_api_ip6_address,
7915 &path->nh.address.ip6,
7916 api_unformat_sw_if_index, vam, &path->sw_if_index))
7918 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7920 else if (unformat (input, "weight %u", &weight))
7922 path->weight = weight;
7924 else if (unformat (input, "preference %u", &preference))
7926 path->preference = preference;
7928 else if (unformat (input, "%U next-hop-table %d",
7929 unformat_vl_api_ip4_address,
7930 &path->nh.address.ip4, &path->table_id))
7932 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7934 else if (unformat (input, "%U next-hop-table %d",
7935 unformat_vl_api_ip6_address,
7936 &path->nh.address.ip6, &path->table_id))
7938 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7940 else if (unformat (input, "%U",
7941 unformat_vl_api_ip4_address, &path->nh.address.ip4))
7944 * the recursive next-hops are by default in the default table
7947 path->sw_if_index = ~0;
7948 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7950 else if (unformat (input, "%U",
7951 unformat_vl_api_ip6_address, &path->nh.address.ip6))
7954 * the recursive next-hops are by default in the default table
7957 path->sw_if_index = ~0;
7958 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7960 else if (unformat (input, "resolve-via-host"))
7962 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_HOST;
7964 else if (unformat (input, "resolve-via-attached"))
7966 path->flags |= FIB_API_PATH_FLAG_RESOLVE_VIA_ATTACHED;
7968 else if (unformat (input, "ip4-lookup-in-table %d", &path->table_id))
7970 path->type = FIB_API_PATH_TYPE_LOCAL;
7971 path->sw_if_index = ~0;
7972 path->proto = FIB_API_PATH_NH_PROTO_IP4;
7974 else if (unformat (input, "ip6-lookup-in-table %d", &path->table_id))
7976 path->type = FIB_API_PATH_TYPE_LOCAL;
7977 path->sw_if_index = ~0;
7978 path->proto = FIB_API_PATH_NH_PROTO_IP6;
7980 else if (unformat (input, "sw_if_index %d", &path->sw_if_index))
7982 else if (unformat (input, "via-label %d", &path->nh.via_label))
7984 path->proto = FIB_API_PATH_NH_PROTO_MPLS;
7985 path->sw_if_index = ~0;
7987 else if (unformat (input, "l2-input-on %d", &path->sw_if_index))
7989 path->proto = FIB_API_PATH_NH_PROTO_ETHERNET;
7990 path->type = FIB_API_PATH_TYPE_INTERFACE_RX;
7992 else if (unformat (input, "local"))
7994 path->type = FIB_API_PATH_TYPE_LOCAL;
7996 else if (unformat (input, "out-labels"))
7998 while (unformat (input, "%d", &out_label))
8000 path->label_stack[path->n_labels].label = out_label;
8001 path->label_stack[path->n_labels].is_uniform = 0;
8002 path->label_stack[path->n_labels].ttl = 64;
8006 else if (unformat (input, "via"))
8008 /* new path, back up and return */
8009 unformat_put_input (input);
8010 unformat_put_input (input);
8011 unformat_put_input (input);
8012 unformat_put_input (input);
8021 path->proto = ntohl (path->proto);
8022 path->type = ntohl (path->type);
8023 path->flags = ntohl (path->flags);
8024 path->table_id = ntohl (path->table_id);
8025 path->sw_if_index = ntohl (path->sw_if_index);
8031 api_ip_route_add_del (vat_main_t * vam)
8033 unformat_input_t *i = vam->input;
8034 vl_api_ip_route_add_del_t *mp;
8037 u8 is_multipath = 0;
8040 vl_api_prefix_t pfx = { };
8041 vl_api_fib_path_t paths[8];
8045 u32 random_add_del = 0;
8046 u32 *random_vector = 0;
8047 u32 random_seed = 0xdeaddabe;
8049 /* Parse args required to build the message */
8050 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8052 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8054 else if (unformat (i, "del"))
8056 else if (unformat (i, "add"))
8058 else if (unformat (i, "vrf %d", &vrf_id))
8060 else if (unformat (i, "count %d", &count))
8062 else if (unformat (i, "random"))
8064 else if (unformat (i, "multipath"))
8066 else if (unformat (i, "seed %d", &random_seed))
8070 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8073 if (8 == path_count)
8075 errmsg ("max 8 paths");
8081 clib_warning ("parse error '%U'", format_unformat_error, i);
8088 errmsg ("specify a path; via ...");
8091 if (prefix_set == 0)
8093 errmsg ("missing prefix");
8097 /* Generate a pile of unique, random routes */
8100 ip4_address_t *i = (ip4_address_t *) & paths[0].nh.address.ip4;
8101 u32 this_random_address;
8104 random_hash = hash_create (count, sizeof (uword));
8106 hash_set (random_hash, i->as_u32, 1);
8107 for (j = 0; j <= count; j++)
8111 this_random_address = random_u32 (&random_seed);
8112 this_random_address =
8113 clib_host_to_net_u32 (this_random_address);
8115 while (hash_get (random_hash, this_random_address));
8116 vec_add1 (random_vector, this_random_address);
8117 hash_set (random_hash, this_random_address, 1);
8119 hash_free (random_hash);
8120 set_ip4_address (&pfx.address, random_vector[0]);
8125 /* Turn on async mode */
8126 vam->async_mode = 1;
8127 vam->async_errors = 0;
8128 before = vat_time_now (vam);
8131 for (j = 0; j < count; j++)
8133 /* Construct the API message */
8134 M2 (IP_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8136 mp->is_add = is_add;
8137 mp->is_multipath = is_multipath;
8139 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8140 mp->route.table_id = ntohl (vrf_id);
8141 mp->route.n_paths = path_count;
8143 clib_memcpy (&mp->route.paths, &paths, sizeof (paths[0]) * path_count);
8146 set_ip4_address (&pfx.address, random_vector[j + 1]);
8148 increment_address (&pfx.address);
8151 /* If we receive SIGTERM, stop now... */
8156 /* When testing multiple add/del ops, use a control-ping to sync */
8159 vl_api_control_ping_t *mp_ping;
8163 /* Shut off async mode */
8164 vam->async_mode = 0;
8166 MPING (CONTROL_PING, mp_ping);
8169 timeout = vat_time_now (vam) + 1.0;
8170 while (vat_time_now (vam) < timeout)
8171 if (vam->result_ready == 1)
8176 if (vam->retval == -99)
8179 if (vam->async_errors > 0)
8181 errmsg ("%d asynchronous errors", vam->async_errors);
8184 vam->async_errors = 0;
8185 after = vat_time_now (vam);
8187 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8191 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8192 count, after - before, count / (after - before));
8198 /* Wait for a reply... */
8203 /* Return the good/bad news */
8204 return (vam->retval);
8208 api_ip_mroute_add_del (vat_main_t * vam)
8210 unformat_input_t *i = vam->input;
8211 u8 path_set = 0, prefix_set = 0, is_add = 1;
8212 vl_api_ip_mroute_add_del_t *mp;
8213 mfib_entry_flags_t eflags = 0;
8214 vl_api_mfib_path_t path;
8215 vl_api_mprefix_t pfx = { };
8219 /* Parse args required to build the message */
8220 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8222 if (unformat (i, "%U", unformat_vl_api_mprefix, &pfx))
8225 pfx.grp_address_length = htons (pfx.grp_address_length);
8227 else if (unformat (i, "del"))
8229 else if (unformat (i, "add"))
8231 else if (unformat (i, "vrf %d", &vrf_id))
8233 else if (unformat (i, "%U", unformat_mfib_itf_flags, &path.itf_flags))
8234 path.itf_flags = htonl (path.itf_flags);
8235 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8237 else if (unformat (i, "via %U", unformat_fib_path, vam, &path.path))
8241 clib_warning ("parse error '%U'", format_unformat_error, i);
8246 if (prefix_set == 0)
8248 errmsg ("missing addresses\n");
8253 errmsg ("missing path\n");
8257 /* Construct the API message */
8258 M (IP_MROUTE_ADD_DEL, mp);
8260 mp->is_add = is_add;
8261 mp->is_multipath = 1;
8263 clib_memcpy (&mp->route.prefix, &pfx, sizeof (pfx));
8264 mp->route.table_id = htonl (vrf_id);
8265 mp->route.n_paths = 1;
8266 mp->route.entry_flags = htonl (eflags);
8268 clib_memcpy (&mp->route.paths, &path, sizeof (path));
8272 /* Wait for a reply... */
8278 api_mpls_table_add_del (vat_main_t * vam)
8280 unformat_input_t *i = vam->input;
8281 vl_api_mpls_table_add_del_t *mp;
8286 /* Parse args required to build the message */
8287 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8289 if (unformat (i, "table %d", &table_id))
8291 else if (unformat (i, "del"))
8293 else if (unformat (i, "add"))
8297 clib_warning ("parse error '%U'", format_unformat_error, i);
8304 errmsg ("missing table-ID");
8308 /* Construct the API message */
8309 M (MPLS_TABLE_ADD_DEL, mp);
8311 mp->mt_table.mt_table_id = ntohl (table_id);
8312 mp->mt_is_add = is_add;
8317 /* Wait for a reply... */
8324 api_mpls_route_add_del (vat_main_t * vam)
8326 u8 is_add = 1, path_count = 0, is_multipath = 0, is_eos = 0;
8327 mpls_label_t local_label = MPLS_LABEL_INVALID;
8328 unformat_input_t *i = vam->input;
8329 vl_api_mpls_route_add_del_t *mp;
8330 vl_api_fib_path_t paths[8];
8334 /* Parse args required to build the message */
8335 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8337 if (unformat (i, "%d", &local_label))
8339 else if (unformat (i, "eos"))
8341 else if (unformat (i, "non-eos"))
8343 else if (unformat (i, "del"))
8345 else if (unformat (i, "add"))
8347 else if (unformat (i, "multipath"))
8349 else if (unformat (i, "count %d", &count))
8353 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8356 if (8 == path_count)
8358 errmsg ("max 8 paths");
8364 clib_warning ("parse error '%U'", format_unformat_error, i);
8371 errmsg ("specify a path; via ...");
8375 if (MPLS_LABEL_INVALID == local_label)
8377 errmsg ("missing label");
8383 /* Turn on async mode */
8384 vam->async_mode = 1;
8385 vam->async_errors = 0;
8386 before = vat_time_now (vam);
8389 for (j = 0; j < count; j++)
8391 /* Construct the API message */
8392 M2 (MPLS_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8394 mp->mr_is_add = is_add;
8395 mp->mr_is_multipath = is_multipath;
8397 mp->mr_route.mr_label = local_label;
8398 mp->mr_route.mr_eos = is_eos;
8399 mp->mr_route.mr_table_id = 0;
8400 mp->mr_route.mr_n_paths = path_count;
8402 clib_memcpy (&mp->mr_route.mr_paths, paths,
8403 sizeof (paths[0]) * path_count);
8409 /* If we receive SIGTERM, stop now... */
8414 /* When testing multiple add/del ops, use a control-ping to sync */
8417 vl_api_control_ping_t *mp_ping;
8421 /* Shut off async mode */
8422 vam->async_mode = 0;
8424 MPING (CONTROL_PING, mp_ping);
8427 timeout = vat_time_now (vam) + 1.0;
8428 while (vat_time_now (vam) < timeout)
8429 if (vam->result_ready == 1)
8434 if (vam->retval == -99)
8437 if (vam->async_errors > 0)
8439 errmsg ("%d asynchronous errors", vam->async_errors);
8442 vam->async_errors = 0;
8443 after = vat_time_now (vam);
8445 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8449 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8450 count, after - before, count / (after - before));
8456 /* Wait for a reply... */
8461 /* Return the good/bad news */
8462 return (vam->retval);
8467 api_mpls_ip_bind_unbind (vat_main_t * vam)
8469 unformat_input_t *i = vam->input;
8470 vl_api_mpls_ip_bind_unbind_t *mp;
8471 u32 ip_table_id = 0;
8473 vl_api_prefix_t pfx;
8475 mpls_label_t local_label = MPLS_LABEL_INVALID;
8478 /* Parse args required to build the message */
8479 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8481 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
8483 else if (unformat (i, "%d", &local_label))
8485 else if (unformat (i, "table-id %d", &ip_table_id))
8487 else if (unformat (i, "unbind"))
8489 else if (unformat (i, "bind"))
8493 clib_warning ("parse error '%U'", format_unformat_error, i);
8500 errmsg ("IP prefix not set");
8504 if (MPLS_LABEL_INVALID == local_label)
8506 errmsg ("missing label");
8510 /* Construct the API message */
8511 M (MPLS_IP_BIND_UNBIND, mp);
8513 mp->mb_is_bind = is_bind;
8514 mp->mb_ip_table_id = ntohl (ip_table_id);
8515 mp->mb_mpls_table_id = 0;
8516 mp->mb_label = ntohl (local_label);
8517 clib_memcpy (&mp->mb_prefix, &pfx, sizeof (pfx));
8522 /* Wait for a reply... */
8529 api_sr_mpls_policy_add (vat_main_t * vam)
8531 unformat_input_t *i = vam->input;
8532 vl_api_sr_mpls_policy_add_t *mp;
8538 u32 *segments = NULL;
8541 /* Parse args required to build the message */
8542 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8544 if (unformat (i, "bsid %d", &bsid))
8546 else if (unformat (i, "weight %d", &weight))
8548 else if (unformat (i, "spray"))
8550 else if (unformat (i, "next %d", &sid))
8553 vec_add1 (segments, htonl (sid));
8557 clib_warning ("parse error '%U'", format_unformat_error, i);
8564 errmsg ("bsid not set");
8568 if (n_segments == 0)
8570 errmsg ("no sid in segment stack");
8574 /* Construct the API message */
8575 M2 (SR_MPLS_POLICY_ADD, mp, sizeof (u32) * n_segments);
8577 mp->bsid = htonl (bsid);
8578 mp->weight = htonl (weight);
8579 mp->is_spray = type;
8580 mp->n_segments = n_segments;
8581 memcpy (mp->segments, segments, sizeof (u32) * n_segments);
8582 vec_free (segments);
8587 /* Wait for a reply... */
8593 api_sr_mpls_policy_del (vat_main_t * vam)
8595 unformat_input_t *i = vam->input;
8596 vl_api_sr_mpls_policy_del_t *mp;
8600 /* Parse args required to build the message */
8601 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8603 if (unformat (i, "bsid %d", &bsid))
8607 clib_warning ("parse error '%U'", format_unformat_error, i);
8614 errmsg ("bsid not set");
8618 /* Construct the API message */
8619 M (SR_MPLS_POLICY_DEL, mp);
8621 mp->bsid = htonl (bsid);
8626 /* Wait for a reply... */
8632 api_bier_table_add_del (vat_main_t * vam)
8634 unformat_input_t *i = vam->input;
8635 vl_api_bier_table_add_del_t *mp;
8637 u32 set = 0, sub_domain = 0, hdr_len = 3;
8638 mpls_label_t local_label = MPLS_LABEL_INVALID;
8641 /* Parse args required to build the message */
8642 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8644 if (unformat (i, "sub-domain %d", &sub_domain))
8646 else if (unformat (i, "set %d", &set))
8648 else if (unformat (i, "label %d", &local_label))
8650 else if (unformat (i, "hdr-len %d", &hdr_len))
8652 else if (unformat (i, "add"))
8654 else if (unformat (i, "del"))
8658 clib_warning ("parse error '%U'", format_unformat_error, i);
8663 if (MPLS_LABEL_INVALID == local_label)
8665 errmsg ("missing label\n");
8669 /* Construct the API message */
8670 M (BIER_TABLE_ADD_DEL, mp);
8672 mp->bt_is_add = is_add;
8673 mp->bt_label = ntohl (local_label);
8674 mp->bt_tbl_id.bt_set = set;
8675 mp->bt_tbl_id.bt_sub_domain = sub_domain;
8676 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
8681 /* Wait for a reply... */
8688 api_bier_route_add_del (vat_main_t * vam)
8690 unformat_input_t *i = vam->input;
8691 vl_api_bier_route_add_del_t *mp;
8693 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
8694 ip4_address_t v4_next_hop_address;
8695 ip6_address_t v6_next_hop_address;
8696 u8 next_hop_set = 0;
8697 u8 next_hop_proto_is_ip4 = 1;
8698 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8701 /* Parse args required to build the message */
8702 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8704 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
8706 next_hop_proto_is_ip4 = 1;
8709 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
8711 next_hop_proto_is_ip4 = 0;
8714 if (unformat (i, "sub-domain %d", &sub_domain))
8716 else if (unformat (i, "set %d", &set))
8718 else if (unformat (i, "hdr-len %d", &hdr_len))
8720 else if (unformat (i, "bp %d", &bp))
8722 else if (unformat (i, "add"))
8724 else if (unformat (i, "del"))
8726 else if (unformat (i, "out-label %d", &next_hop_out_label))
8730 clib_warning ("parse error '%U'", format_unformat_error, i);
8735 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
8737 errmsg ("next hop / label set\n");
8742 errmsg ("bit=position not set\n");
8746 /* Construct the API message */
8747 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path_t));
8749 mp->br_is_add = is_add;
8750 mp->br_route.br_tbl_id.bt_set = set;
8751 mp->br_route.br_tbl_id.bt_sub_domain = sub_domain;
8752 mp->br_route.br_tbl_id.bt_hdr_len_id = hdr_len;
8753 mp->br_route.br_bp = ntohs (bp);
8754 mp->br_route.br_n_paths = 1;
8755 mp->br_route.br_paths[0].n_labels = 1;
8756 mp->br_route.br_paths[0].label_stack[0].label = ntohl (next_hop_out_label);
8757 mp->br_route.br_paths[0].proto = (next_hop_proto_is_ip4 ?
8758 FIB_API_PATH_NH_PROTO_IP4 :
8759 FIB_API_PATH_NH_PROTO_IP6);
8761 if (next_hop_proto_is_ip4)
8763 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip4,
8764 &v4_next_hop_address, sizeof (v4_next_hop_address));
8768 clib_memcpy (&mp->br_route.br_paths[0].nh.address.ip6,
8769 &v6_next_hop_address, sizeof (v6_next_hop_address));
8775 /* Wait for a reply... */
8782 api_mpls_tunnel_add_del (vat_main_t * vam)
8784 unformat_input_t *i = vam->input;
8785 vl_api_mpls_tunnel_add_del_t *mp;
8787 vl_api_fib_path_t paths[8];
8788 u32 sw_if_index = ~0;
8794 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8796 if (unformat (i, "add"))
8800 (i, "del %U", api_unformat_sw_if_index, vam, &sw_if_index))
8802 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
8804 else if (unformat (i, "l2-only"))
8808 (i, "via %U", unformat_fib_path, vam, &paths[path_count]))
8811 if (8 == path_count)
8813 errmsg ("max 8 paths");
8819 clib_warning ("parse error '%U'", format_unformat_error, i);
8824 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (vl_api_fib_path_t) * path_count);
8826 mp->mt_is_add = is_add;
8827 mp->mt_tunnel.mt_sw_if_index = ntohl (sw_if_index);
8828 mp->mt_tunnel.mt_l2_only = l2_only;
8829 mp->mt_tunnel.mt_is_multicast = 0;
8830 mp->mt_tunnel.mt_n_paths = path_count;
8832 clib_memcpy (&mp->mt_tunnel.mt_paths, &paths,
8833 sizeof (paths[0]) * path_count);
8841 api_sw_interface_set_unnumbered (vat_main_t * vam)
8843 unformat_input_t *i = vam->input;
8844 vl_api_sw_interface_set_unnumbered_t *mp;
8846 u32 unnum_sw_index = ~0;
8848 u8 sw_if_index_set = 0;
8851 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8853 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8854 sw_if_index_set = 1;
8855 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8856 sw_if_index_set = 1;
8857 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
8859 else if (unformat (i, "del"))
8863 clib_warning ("parse error '%U'", format_unformat_error, i);
8868 if (sw_if_index_set == 0)
8870 errmsg ("missing interface name or sw_if_index");
8874 M (SW_INTERFACE_SET_UNNUMBERED, mp);
8876 mp->sw_if_index = ntohl (sw_if_index);
8877 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
8878 mp->is_add = is_add;
8887 api_create_vlan_subif (vat_main_t * vam)
8889 unformat_input_t *i = vam->input;
8890 vl_api_create_vlan_subif_t *mp;
8892 u8 sw_if_index_set = 0;
8897 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8899 if (unformat (i, "sw_if_index %d", &sw_if_index))
8900 sw_if_index_set = 1;
8902 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8903 sw_if_index_set = 1;
8904 else if (unformat (i, "vlan %d", &vlan_id))
8908 clib_warning ("parse error '%U'", format_unformat_error, i);
8913 if (sw_if_index_set == 0)
8915 errmsg ("missing interface name or sw_if_index");
8919 if (vlan_id_set == 0)
8921 errmsg ("missing vlan_id");
8924 M (CREATE_VLAN_SUBIF, mp);
8926 mp->sw_if_index = ntohl (sw_if_index);
8927 mp->vlan_id = ntohl (vlan_id);
8934 #define foreach_create_subif_bit \
8941 _(outer_vlan_id_any) \
8942 _(inner_vlan_id_any)
8944 #define foreach_create_subif_flag \
8949 _(4, "exact_match") \
8950 _(5, "default_sub") \
8951 _(6, "outer_vlan_id_any") \
8952 _(7, "inner_vlan_id_any")
8955 api_create_subif (vat_main_t * vam)
8957 unformat_input_t *i = vam->input;
8958 vl_api_create_subif_t *mp;
8960 u8 sw_if_index_set = 0;
8963 u32 __attribute__ ((unused)) no_tags = 0;
8964 u32 __attribute__ ((unused)) one_tag = 0;
8965 u32 __attribute__ ((unused)) two_tags = 0;
8966 u32 __attribute__ ((unused)) dot1ad = 0;
8967 u32 __attribute__ ((unused)) exact_match = 0;
8968 u32 __attribute__ ((unused)) default_sub = 0;
8969 u32 __attribute__ ((unused)) outer_vlan_id_any = 0;
8970 u32 __attribute__ ((unused)) inner_vlan_id_any = 0;
8972 u16 outer_vlan_id = 0;
8973 u16 inner_vlan_id = 0;
8976 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8978 if (unformat (i, "sw_if_index %d", &sw_if_index))
8979 sw_if_index_set = 1;
8981 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8982 sw_if_index_set = 1;
8983 else if (unformat (i, "sub_id %d", &sub_id))
8985 else if (unformat (i, "outer_vlan_id %d", &tmp))
8986 outer_vlan_id = tmp;
8987 else if (unformat (i, "inner_vlan_id %d", &tmp))
8988 inner_vlan_id = tmp;
8990 #define _(a) else if (unformat (i, #a)) a = 1 ;
8991 foreach_create_subif_bit
8995 clib_warning ("parse error '%U'", format_unformat_error, i);
9000 if (sw_if_index_set == 0)
9002 errmsg ("missing interface name or sw_if_index");
9006 if (sub_id_set == 0)
9008 errmsg ("missing sub_id");
9011 M (CREATE_SUBIF, mp);
9013 mp->sw_if_index = ntohl (sw_if_index);
9014 mp->sub_id = ntohl (sub_id);
9016 #define _(a,b) mp->sub_if_flags |= (1 << a);
9017 foreach_create_subif_flag;
9020 mp->outer_vlan_id = ntohs (outer_vlan_id);
9021 mp->inner_vlan_id = ntohs (inner_vlan_id);
9029 api_ip_table_replace_begin (vat_main_t * vam)
9031 unformat_input_t *i = vam->input;
9032 vl_api_ip_table_replace_begin_t *mp;
9037 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9039 if (unformat (i, "table %d", &table_id))
9041 else if (unformat (i, "ipv6"))
9045 clib_warning ("parse error '%U'", format_unformat_error, i);
9050 M (IP_TABLE_REPLACE_BEGIN, mp);
9052 mp->table.table_id = ntohl (table_id);
9053 mp->table.is_ip6 = is_ipv6;
9061 api_ip_table_flush (vat_main_t * vam)
9063 unformat_input_t *i = vam->input;
9064 vl_api_ip_table_flush_t *mp;
9069 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9071 if (unformat (i, "table %d", &table_id))
9073 else if (unformat (i, "ipv6"))
9077 clib_warning ("parse error '%U'", format_unformat_error, i);
9082 M (IP_TABLE_FLUSH, mp);
9084 mp->table.table_id = ntohl (table_id);
9085 mp->table.is_ip6 = is_ipv6;
9093 api_ip_table_replace_end (vat_main_t * vam)
9095 unformat_input_t *i = vam->input;
9096 vl_api_ip_table_replace_end_t *mp;
9101 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9103 if (unformat (i, "table %d", &table_id))
9105 else if (unformat (i, "ipv6"))
9109 clib_warning ("parse error '%U'", format_unformat_error, i);
9114 M (IP_TABLE_REPLACE_END, mp);
9116 mp->table.table_id = ntohl (table_id);
9117 mp->table.is_ip6 = is_ipv6;
9125 api_set_ip_flow_hash (vat_main_t * vam)
9127 unformat_input_t *i = vam->input;
9128 vl_api_set_ip_flow_hash_t *mp;
9140 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9142 if (unformat (i, "vrf %d", &vrf_id))
9144 else if (unformat (i, "ipv6"))
9146 else if (unformat (i, "src"))
9148 else if (unformat (i, "dst"))
9150 else if (unformat (i, "sport"))
9152 else if (unformat (i, "dport"))
9154 else if (unformat (i, "proto"))
9156 else if (unformat (i, "reverse"))
9161 clib_warning ("parse error '%U'", format_unformat_error, i);
9166 if (vrf_id_set == 0)
9168 errmsg ("missing vrf id");
9172 M (SET_IP_FLOW_HASH, mp);
9178 mp->reverse = reverse;
9179 mp->vrf_id = ntohl (vrf_id);
9180 mp->is_ipv6 = is_ipv6;
9188 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
9190 unformat_input_t *i = vam->input;
9191 vl_api_sw_interface_ip6_enable_disable_t *mp;
9193 u8 sw_if_index_set = 0;
9197 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9199 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9200 sw_if_index_set = 1;
9201 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9202 sw_if_index_set = 1;
9203 else if (unformat (i, "enable"))
9205 else if (unformat (i, "disable"))
9209 clib_warning ("parse error '%U'", format_unformat_error, i);
9214 if (sw_if_index_set == 0)
9216 errmsg ("missing interface name or sw_if_index");
9220 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
9222 mp->sw_if_index = ntohl (sw_if_index);
9223 mp->enable = enable;
9232 api_l2_patch_add_del (vat_main_t * vam)
9234 unformat_input_t *i = vam->input;
9235 vl_api_l2_patch_add_del_t *mp;
9237 u8 rx_sw_if_index_set = 0;
9239 u8 tx_sw_if_index_set = 0;
9243 /* Parse args required to build the message */
9244 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9246 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
9247 rx_sw_if_index_set = 1;
9248 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
9249 tx_sw_if_index_set = 1;
9250 else if (unformat (i, "rx"))
9252 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9254 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9256 rx_sw_if_index_set = 1;
9261 else if (unformat (i, "tx"))
9263 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9265 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
9267 tx_sw_if_index_set = 1;
9272 else if (unformat (i, "del"))
9278 if (rx_sw_if_index_set == 0)
9280 errmsg ("missing rx interface name or rx_sw_if_index");
9284 if (tx_sw_if_index_set == 0)
9286 errmsg ("missing tx interface name or tx_sw_if_index");
9290 M (L2_PATCH_ADD_DEL, mp);
9292 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
9293 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
9294 mp->is_add = is_add;
9302 u8 localsid_addr[16];
9311 api_sr_localsid_add_del (vat_main_t * vam)
9313 unformat_input_t *i = vam->input;
9314 vl_api_sr_localsid_add_del_t *mp;
9317 ip6_address_t localsid;
9321 u32 fib_table = ~(u32) 0;
9322 ip46_address_t nh_addr;
9323 clib_memset (&nh_addr, 0, sizeof (ip46_address_t));
9325 bool nexthop_set = 0;
9329 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9331 if (unformat (i, "del"))
9333 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
9334 else if (unformat (i, "next-hop %U", unformat_ip46_address, &nh_addr))
9336 else if (unformat (i, "behavior %u", &behavior));
9337 else if (unformat (i, "sw_if_index %u", &sw_if_index));
9338 else if (unformat (i, "fib-table %u", &fib_table));
9339 else if (unformat (i, "end.psp %u", &behavior));
9344 M (SR_LOCALSID_ADD_DEL, mp);
9346 clib_memcpy (mp->localsid, &localsid, sizeof (mp->localsid));
9350 clib_memcpy (&mp->nh_addr.un, &nh_addr, sizeof (mp->nh_addr.un));
9352 mp->behavior = behavior;
9353 mp->sw_if_index = ntohl (sw_if_index);
9354 mp->fib_table = ntohl (fib_table);
9355 mp->end_psp = end_psp;
9356 mp->is_del = is_del;
9364 api_ioam_enable (vat_main_t * vam)
9366 unformat_input_t *input = vam->input;
9367 vl_api_ioam_enable_t *mp;
9369 int has_trace_option = 0;
9370 int has_pot_option = 0;
9371 int has_seqno_option = 0;
9372 int has_analyse_option = 0;
9375 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9377 if (unformat (input, "trace"))
9378 has_trace_option = 1;
9379 else if (unformat (input, "pot"))
9381 else if (unformat (input, "seqno"))
9382 has_seqno_option = 1;
9383 else if (unformat (input, "analyse"))
9384 has_analyse_option = 1;
9388 M (IOAM_ENABLE, mp);
9389 mp->id = htons (id);
9390 mp->seqno = has_seqno_option;
9391 mp->analyse = has_analyse_option;
9392 mp->pot_enable = has_pot_option;
9393 mp->trace_enable = has_trace_option;
9402 api_ioam_disable (vat_main_t * vam)
9404 vl_api_ioam_disable_t *mp;
9407 M (IOAM_DISABLE, mp);
9413 #define foreach_tcp_proto_field \
9417 #define foreach_udp_proto_field \
9421 #define foreach_ip4_proto_field \
9433 u16 src_port, dst_port;
9436 #if VPP_API_TEST_BUILTIN == 0
9438 unformat_tcp_mask (unformat_input_t * input, va_list * args)
9440 u8 **maskp = va_arg (*args, u8 **);
9442 u8 found_something = 0;
9445 #define _(a) u8 a=0;
9446 foreach_tcp_proto_field;
9449 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9452 #define _(a) else if (unformat (input, #a)) a=1;
9453 foreach_tcp_proto_field
9459 #define _(a) found_something += a;
9460 foreach_tcp_proto_field;
9463 if (found_something == 0)
9466 vec_validate (mask, sizeof (*tcp) - 1);
9468 tcp = (tcp_header_t *) mask;
9470 #define _(a) if (a) clib_memset (&tcp->a, 0xff, sizeof (tcp->a));
9471 foreach_tcp_proto_field;
9479 unformat_udp_mask (unformat_input_t * input, va_list * args)
9481 u8 **maskp = va_arg (*args, u8 **);
9483 u8 found_something = 0;
9486 #define _(a) u8 a=0;
9487 foreach_udp_proto_field;
9490 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9493 #define _(a) else if (unformat (input, #a)) a=1;
9494 foreach_udp_proto_field
9500 #define _(a) found_something += a;
9501 foreach_udp_proto_field;
9504 if (found_something == 0)
9507 vec_validate (mask, sizeof (*udp) - 1);
9509 udp = (udp_header_t *) mask;
9511 #define _(a) if (a) clib_memset (&udp->a, 0xff, sizeof (udp->a));
9512 foreach_udp_proto_field;
9520 unformat_l4_mask (unformat_input_t * input, va_list * args)
9522 u8 **maskp = va_arg (*args, u8 **);
9523 u16 src_port = 0, dst_port = 0;
9524 tcpudp_header_t *tcpudp;
9526 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9528 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
9530 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
9532 else if (unformat (input, "src_port"))
9534 else if (unformat (input, "dst_port"))
9540 if (!src_port && !dst_port)
9544 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
9546 tcpudp = (tcpudp_header_t *) mask;
9547 tcpudp->src_port = src_port;
9548 tcpudp->dst_port = dst_port;
9556 unformat_ip4_mask (unformat_input_t * input, va_list * args)
9558 u8 **maskp = va_arg (*args, u8 **);
9560 u8 found_something = 0;
9563 #define _(a) u8 a=0;
9564 foreach_ip4_proto_field;
9570 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9572 if (unformat (input, "version"))
9574 else if (unformat (input, "hdr_length"))
9576 else if (unformat (input, "src"))
9578 else if (unformat (input, "dst"))
9580 else if (unformat (input, "proto"))
9583 #define _(a) else if (unformat (input, #a)) a=1;
9584 foreach_ip4_proto_field
9590 #define _(a) found_something += a;
9591 foreach_ip4_proto_field;
9594 if (found_something == 0)
9597 vec_validate (mask, sizeof (*ip) - 1);
9599 ip = (ip4_header_t *) mask;
9601 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
9602 foreach_ip4_proto_field;
9605 ip->ip_version_and_header_length = 0;
9608 ip->ip_version_and_header_length |= 0xF0;
9611 ip->ip_version_and_header_length |= 0x0F;
9617 #define foreach_ip6_proto_field \
9625 unformat_ip6_mask (unformat_input_t * input, va_list * args)
9627 u8 **maskp = va_arg (*args, u8 **);
9629 u8 found_something = 0;
9631 u32 ip_version_traffic_class_and_flow_label;
9633 #define _(a) u8 a=0;
9634 foreach_ip6_proto_field;
9637 u8 traffic_class = 0;
9640 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9642 if (unformat (input, "version"))
9644 else if (unformat (input, "traffic-class"))
9646 else if (unformat (input, "flow-label"))
9648 else if (unformat (input, "src"))
9650 else if (unformat (input, "dst"))
9652 else if (unformat (input, "proto"))
9655 #define _(a) else if (unformat (input, #a)) a=1;
9656 foreach_ip6_proto_field
9662 #define _(a) found_something += a;
9663 foreach_ip6_proto_field;
9666 if (found_something == 0)
9669 vec_validate (mask, sizeof (*ip) - 1);
9671 ip = (ip6_header_t *) mask;
9673 #define _(a) if (a) clib_memset (&ip->a, 0xff, sizeof (ip->a));
9674 foreach_ip6_proto_field;
9677 ip_version_traffic_class_and_flow_label = 0;
9680 ip_version_traffic_class_and_flow_label |= 0xF0000000;
9683 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
9686 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
9688 ip->ip_version_traffic_class_and_flow_label =
9689 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9696 unformat_l3_mask (unformat_input_t * input, va_list * args)
9698 u8 **maskp = va_arg (*args, u8 **);
9700 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9702 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
9704 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
9713 unformat_l2_mask (unformat_input_t * input, va_list * args)
9715 u8 **maskp = va_arg (*args, u8 **);
9730 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9732 if (unformat (input, "src"))
9734 else if (unformat (input, "dst"))
9736 else if (unformat (input, "proto"))
9738 else if (unformat (input, "tag1"))
9740 else if (unformat (input, "tag2"))
9742 else if (unformat (input, "ignore-tag1"))
9744 else if (unformat (input, "ignore-tag2"))
9746 else if (unformat (input, "cos1"))
9748 else if (unformat (input, "cos2"))
9750 else if (unformat (input, "dot1q"))
9752 else if (unformat (input, "dot1ad"))
9757 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
9758 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9761 if (tag1 || ignore_tag1 || cos1 || dot1q)
9763 if (tag2 || ignore_tag2 || cos2 || dot1ad)
9766 vec_validate (mask, len - 1);
9769 clib_memset (mask, 0xff, 6);
9772 clib_memset (mask + 6, 0xff, 6);
9776 /* inner vlan tag */
9785 mask[21] = mask[20] = 0xff;
9806 mask[16] = mask[17] = 0xff;
9816 mask[12] = mask[13] = 0xff;
9823 unformat_classify_mask (unformat_input_t * input, va_list * args)
9825 u8 **maskp = va_arg (*args, u8 **);
9826 u32 *skipp = va_arg (*args, u32 *);
9827 u32 *matchp = va_arg (*args, u32 *);
9835 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9837 if (unformat (input, "hex %U", unformat_hex_string, &mask))
9839 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
9841 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
9843 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
9857 if (mask || l2 || l3 || l4)
9861 /* "With a free Ethernet header in every package" */
9863 vec_validate (l2, 13);
9867 vec_append (mask, l3);
9872 vec_append (mask, l4);
9877 /* Scan forward looking for the first significant mask octet */
9878 for (i = 0; i < vec_len (mask); i++)
9882 /* compute (skip, match) params */
9883 *skipp = i / sizeof (u32x4);
9884 vec_delete (mask, *skipp * sizeof (u32x4), 0);
9886 /* Pad mask to an even multiple of the vector size */
9887 while (vec_len (mask) % sizeof (u32x4))
9890 match = vec_len (mask) / sizeof (u32x4);
9892 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
9894 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
9895 if (*tmp || *(tmp + 1))
9900 clib_warning ("BUG: match 0");
9902 _vec_len (mask) = match * sizeof (u32x4);
9912 #endif /* VPP_API_TEST_BUILTIN */
9914 #define foreach_l2_next \
9916 _(ethernet, ETHERNET_INPUT) \
9921 unformat_l2_next_index (unformat_input_t * input, va_list * args)
9923 u32 *miss_next_indexp = va_arg (*args, u32 *);
9928 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
9932 if (unformat (input, "%d", &tmp))
9941 *miss_next_indexp = next_index;
9945 #define foreach_ip_next \
9951 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
9953 u32 *miss_next_indexp = va_arg (*args, u32 *);
9958 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
9962 if (unformat (input, "%d", &tmp))
9971 *miss_next_indexp = next_index;
9975 #define foreach_acl_next \
9979 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
9981 u32 *miss_next_indexp = va_arg (*args, u32 *);
9986 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
9990 if (unformat (input, "permit"))
9995 else if (unformat (input, "%d", &tmp))
10004 *miss_next_indexp = next_index;
10009 unformat_policer_precolor (unformat_input_t * input, va_list * args)
10011 u32 *r = va_arg (*args, u32 *);
10013 if (unformat (input, "conform-color"))
10014 *r = POLICE_CONFORM;
10015 else if (unformat (input, "exceed-color"))
10016 *r = POLICE_EXCEED;
10024 api_classify_add_del_table (vat_main_t * vam)
10026 unformat_input_t *i = vam->input;
10027 vl_api_classify_add_del_table_t *mp;
10034 u32 table_index = ~0;
10035 u32 next_table_index = ~0;
10036 u32 miss_next_index = ~0;
10037 u32 memory_size = 32 << 20;
10039 u32 current_data_flag = 0;
10040 int current_data_offset = 0;
10043 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10045 if (unformat (i, "del"))
10047 else if (unformat (i, "del-chain"))
10052 else if (unformat (i, "buckets %d", &nbuckets))
10054 else if (unformat (i, "memory_size %d", &memory_size))
10056 else if (unformat (i, "skip %d", &skip))
10058 else if (unformat (i, "match %d", &match))
10060 else if (unformat (i, "table %d", &table_index))
10062 else if (unformat (i, "mask %U", unformat_classify_mask,
10063 &mask, &skip, &match))
10065 else if (unformat (i, "next-table %d", &next_table_index))
10067 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
10070 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
10073 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
10076 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
10078 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
10084 if (is_add && mask == 0)
10086 errmsg ("Mask required");
10090 if (is_add && skip == ~0)
10092 errmsg ("skip count required");
10096 if (is_add && match == ~0)
10098 errmsg ("match count required");
10102 if (!is_add && table_index == ~0)
10104 errmsg ("table index required for delete");
10108 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
10110 mp->is_add = is_add;
10111 mp->del_chain = del_chain;
10112 mp->table_index = ntohl (table_index);
10113 mp->nbuckets = ntohl (nbuckets);
10114 mp->memory_size = ntohl (memory_size);
10115 mp->skip_n_vectors = ntohl (skip);
10116 mp->match_n_vectors = ntohl (match);
10117 mp->next_table_index = ntohl (next_table_index);
10118 mp->miss_next_index = ntohl (miss_next_index);
10119 mp->current_data_flag = ntohl (current_data_flag);
10120 mp->current_data_offset = ntohl (current_data_offset);
10121 mp->mask_len = ntohl (vec_len (mask));
10122 clib_memcpy (mp->mask, mask, vec_len (mask));
10131 #if VPP_API_TEST_BUILTIN == 0
10133 unformat_l4_match (unformat_input_t * input, va_list * args)
10135 u8 **matchp = va_arg (*args, u8 **);
10137 u8 *proto_header = 0;
10143 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10145 if (unformat (input, "src_port %d", &src_port))
10147 else if (unformat (input, "dst_port %d", &dst_port))
10153 h.src_port = clib_host_to_net_u16 (src_port);
10154 h.dst_port = clib_host_to_net_u16 (dst_port);
10155 vec_validate (proto_header, sizeof (h) - 1);
10156 memcpy (proto_header, &h, sizeof (h));
10158 *matchp = proto_header;
10164 unformat_ip4_match (unformat_input_t * input, va_list * args)
10166 u8 **matchp = va_arg (*args, u8 **);
10171 int hdr_length = 0;
10172 u32 hdr_length_val;
10173 int src = 0, dst = 0;
10174 ip4_address_t src_val, dst_val;
10181 int fragment_id = 0;
10182 u32 fragment_id_val;
10188 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10190 if (unformat (input, "version %d", &version_val))
10192 else if (unformat (input, "hdr_length %d", &hdr_length_val))
10194 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
10196 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
10198 else if (unformat (input, "proto %d", &proto_val))
10200 else if (unformat (input, "tos %d", &tos_val))
10202 else if (unformat (input, "length %d", &length_val))
10204 else if (unformat (input, "fragment_id %d", &fragment_id_val))
10206 else if (unformat (input, "ttl %d", &ttl_val))
10208 else if (unformat (input, "checksum %d", &checksum_val))
10214 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
10215 + ttl + checksum == 0)
10219 * Aligned because we use the real comparison functions
10221 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10223 ip = (ip4_header_t *) match;
10225 /* These are realistically matched in practice */
10227 ip->src_address.as_u32 = src_val.as_u32;
10230 ip->dst_address.as_u32 = dst_val.as_u32;
10233 ip->protocol = proto_val;
10236 /* These are not, but they're included for completeness */
10238 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
10241 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
10247 ip->length = clib_host_to_net_u16 (length_val);
10253 ip->checksum = clib_host_to_net_u16 (checksum_val);
10260 unformat_ip6_match (unformat_input_t * input, va_list * args)
10262 u8 **matchp = va_arg (*args, u8 **);
10267 u8 traffic_class = 0;
10268 u32 traffic_class_val = 0;
10271 int src = 0, dst = 0;
10272 ip6_address_t src_val, dst_val;
10275 int payload_length = 0;
10276 u32 payload_length_val;
10279 u32 ip_version_traffic_class_and_flow_label;
10281 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10283 if (unformat (input, "version %d", &version_val))
10285 else if (unformat (input, "traffic_class %d", &traffic_class_val))
10287 else if (unformat (input, "flow_label %d", &flow_label_val))
10289 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
10291 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
10293 else if (unformat (input, "proto %d", &proto_val))
10295 else if (unformat (input, "payload_length %d", &payload_length_val))
10296 payload_length = 1;
10297 else if (unformat (input, "hop_limit %d", &hop_limit_val))
10303 if (version + traffic_class + flow_label + src + dst + proto +
10304 payload_length + hop_limit == 0)
10308 * Aligned because we use the real comparison functions
10310 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
10312 ip = (ip6_header_t *) match;
10315 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
10318 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
10321 ip->protocol = proto_val;
10323 ip_version_traffic_class_and_flow_label = 0;
10326 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
10329 ip_version_traffic_class_and_flow_label |=
10330 (traffic_class_val & 0xFF) << 20;
10333 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
10335 ip->ip_version_traffic_class_and_flow_label =
10336 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10338 if (payload_length)
10339 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
10342 ip->hop_limit = hop_limit_val;
10349 unformat_l3_match (unformat_input_t * input, va_list * args)
10351 u8 **matchp = va_arg (*args, u8 **);
10353 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10355 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
10357 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
10366 unformat_vlan_tag (unformat_input_t * input, va_list * args)
10368 u8 *tagp = va_arg (*args, u8 *);
10371 if (unformat (input, "%d", &tag))
10373 tagp[0] = (tag >> 8) & 0x0F;
10374 tagp[1] = tag & 0xFF;
10382 unformat_l2_match (unformat_input_t * input, va_list * args)
10384 u8 **matchp = va_arg (*args, u8 **);
10397 u8 ignore_tag1 = 0;
10398 u8 ignore_tag2 = 0;
10404 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10406 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
10409 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
10411 else if (unformat (input, "proto %U",
10412 unformat_ethernet_type_host_byte_order, &proto_val))
10414 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
10416 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
10418 else if (unformat (input, "ignore-tag1"))
10420 else if (unformat (input, "ignore-tag2"))
10422 else if (unformat (input, "cos1 %d", &cos1_val))
10424 else if (unformat (input, "cos2 %d", &cos2_val))
10429 if ((src + dst + proto + tag1 + tag2 +
10430 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10433 if (tag1 || ignore_tag1 || cos1)
10435 if (tag2 || ignore_tag2 || cos2)
10438 vec_validate_aligned (match, len - 1, sizeof (u32x4));
10441 clib_memcpy (match, dst_val, 6);
10444 clib_memcpy (match + 6, src_val, 6);
10448 /* inner vlan tag */
10449 match[19] = tag2_val[1];
10450 match[18] = tag2_val[0];
10452 match[18] |= (cos2_val & 0x7) << 5;
10455 match[21] = proto_val & 0xff;
10456 match[20] = proto_val >> 8;
10460 match[15] = tag1_val[1];
10461 match[14] = tag1_val[0];
10464 match[14] |= (cos1_val & 0x7) << 5;
10470 match[15] = tag1_val[1];
10471 match[14] = tag1_val[0];
10474 match[17] = proto_val & 0xff;
10475 match[16] = proto_val >> 8;
10478 match[14] |= (cos1_val & 0x7) << 5;
10484 match[18] |= (cos2_val & 0x7) << 5;
10486 match[14] |= (cos1_val & 0x7) << 5;
10489 match[13] = proto_val & 0xff;
10490 match[12] = proto_val >> 8;
10498 unformat_qos_source (unformat_input_t * input, va_list * args)
10500 int *qs = va_arg (*args, int *);
10502 if (unformat (input, "ip"))
10503 *qs = QOS_SOURCE_IP;
10504 else if (unformat (input, "mpls"))
10505 *qs = QOS_SOURCE_MPLS;
10506 else if (unformat (input, "ext"))
10507 *qs = QOS_SOURCE_EXT;
10508 else if (unformat (input, "vlan"))
10509 *qs = QOS_SOURCE_VLAN;
10518 api_unformat_classify_match (unformat_input_t * input, va_list * args)
10520 u8 **matchp = va_arg (*args, u8 **);
10521 u32 skip_n_vectors = va_arg (*args, u32);
10522 u32 match_n_vectors = va_arg (*args, u32);
10529 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10531 if (unformat (input, "hex %U", unformat_hex_string, &match))
10533 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
10535 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
10537 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
10551 if (match || l2 || l3 || l4)
10553 if (l2 || l3 || l4)
10555 /* "Win a free Ethernet header in every packet" */
10557 vec_validate_aligned (l2, 13, sizeof (u32x4));
10561 vec_append_aligned (match, l3, sizeof (u32x4));
10566 vec_append_aligned (match, l4, sizeof (u32x4));
10571 /* Make sure the vector is big enough even if key is all 0's */
10572 vec_validate_aligned
10573 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
10576 /* Set size, include skipped vectors */
10577 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
10588 api_classify_add_del_session (vat_main_t * vam)
10590 unformat_input_t *i = vam->input;
10591 vl_api_classify_add_del_session_t *mp;
10593 u32 table_index = ~0;
10594 u32 hit_next_index = ~0;
10595 u32 opaque_index = ~0;
10598 u32 skip_n_vectors = 0;
10599 u32 match_n_vectors = 0;
10605 * Warning: you have to supply skip_n and match_n
10606 * because the API client cant simply look at the classify
10610 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10612 if (unformat (i, "del"))
10614 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
10617 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
10620 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
10623 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
10625 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
10627 else if (unformat (i, "opaque-index %d", &opaque_index))
10629 else if (unformat (i, "skip_n %d", &skip_n_vectors))
10631 else if (unformat (i, "match_n %d", &match_n_vectors))
10633 else if (unformat (i, "match %U", api_unformat_classify_match,
10634 &match, skip_n_vectors, match_n_vectors))
10636 else if (unformat (i, "advance %d", &advance))
10638 else if (unformat (i, "table-index %d", &table_index))
10640 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
10642 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
10644 else if (unformat (i, "action %d", &action))
10646 else if (unformat (i, "metadata %d", &metadata))
10652 if (table_index == ~0)
10654 errmsg ("Table index required");
10658 if (is_add && match == 0)
10660 errmsg ("Match value required");
10664 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
10666 mp->is_add = is_add;
10667 mp->table_index = ntohl (table_index);
10668 mp->hit_next_index = ntohl (hit_next_index);
10669 mp->opaque_index = ntohl (opaque_index);
10670 mp->advance = ntohl (advance);
10671 mp->action = action;
10672 mp->metadata = ntohl (metadata);
10673 mp->match_len = ntohl (vec_len (match));
10674 clib_memcpy (mp->match, match, vec_len (match));
10683 api_classify_set_interface_ip_table (vat_main_t * vam)
10685 unformat_input_t *i = vam->input;
10686 vl_api_classify_set_interface_ip_table_t *mp;
10688 int sw_if_index_set;
10689 u32 table_index = ~0;
10693 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10695 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10696 sw_if_index_set = 1;
10697 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10698 sw_if_index_set = 1;
10699 else if (unformat (i, "table %d", &table_index))
10703 clib_warning ("parse error '%U'", format_unformat_error, i);
10708 if (sw_if_index_set == 0)
10710 errmsg ("missing interface name or sw_if_index");
10715 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
10717 mp->sw_if_index = ntohl (sw_if_index);
10718 mp->table_index = ntohl (table_index);
10719 mp->is_ipv6 = is_ipv6;
10727 api_classify_set_interface_l2_tables (vat_main_t * vam)
10729 unformat_input_t *i = vam->input;
10730 vl_api_classify_set_interface_l2_tables_t *mp;
10732 int sw_if_index_set;
10733 u32 ip4_table_index = ~0;
10734 u32 ip6_table_index = ~0;
10735 u32 other_table_index = ~0;
10739 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10741 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10742 sw_if_index_set = 1;
10743 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10744 sw_if_index_set = 1;
10745 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10747 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10749 else if (unformat (i, "other-table %d", &other_table_index))
10751 else if (unformat (i, "is-input %d", &is_input))
10755 clib_warning ("parse error '%U'", format_unformat_error, i);
10760 if (sw_if_index_set == 0)
10762 errmsg ("missing interface name or sw_if_index");
10767 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
10769 mp->sw_if_index = ntohl (sw_if_index);
10770 mp->ip4_table_index = ntohl (ip4_table_index);
10771 mp->ip6_table_index = ntohl (ip6_table_index);
10772 mp->other_table_index = ntohl (other_table_index);
10773 mp->is_input = (u8) is_input;
10781 api_set_ipfix_exporter (vat_main_t * vam)
10783 unformat_input_t *i = vam->input;
10784 vl_api_set_ipfix_exporter_t *mp;
10785 ip4_address_t collector_address;
10786 u8 collector_address_set = 0;
10787 u32 collector_port = ~0;
10788 ip4_address_t src_address;
10789 u8 src_address_set = 0;
10792 u32 template_interval = ~0;
10793 u8 udp_checksum = 0;
10796 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10798 if (unformat (i, "collector_address %U", unformat_ip4_address,
10799 &collector_address))
10800 collector_address_set = 1;
10801 else if (unformat (i, "collector_port %d", &collector_port))
10803 else if (unformat (i, "src_address %U", unformat_ip4_address,
10805 src_address_set = 1;
10806 else if (unformat (i, "vrf_id %d", &vrf_id))
10808 else if (unformat (i, "path_mtu %d", &path_mtu))
10810 else if (unformat (i, "template_interval %d", &template_interval))
10812 else if (unformat (i, "udp_checksum"))
10818 if (collector_address_set == 0)
10820 errmsg ("collector_address required");
10824 if (src_address_set == 0)
10826 errmsg ("src_address required");
10830 M (SET_IPFIX_EXPORTER, mp);
10832 memcpy (mp->collector_address.un.ip4, collector_address.data,
10833 sizeof (collector_address.data));
10834 mp->collector_port = htons ((u16) collector_port);
10835 memcpy (mp->src_address.un.ip4, src_address.data,
10836 sizeof (src_address.data));
10837 mp->vrf_id = htonl (vrf_id);
10838 mp->path_mtu = htonl (path_mtu);
10839 mp->template_interval = htonl (template_interval);
10840 mp->udp_checksum = udp_checksum;
10848 api_set_ipfix_classify_stream (vat_main_t * vam)
10850 unformat_input_t *i = vam->input;
10851 vl_api_set_ipfix_classify_stream_t *mp;
10853 u32 src_port = UDP_DST_PORT_ipfix;
10856 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10858 if (unformat (i, "domain %d", &domain_id))
10860 else if (unformat (i, "src_port %d", &src_port))
10864 errmsg ("unknown input `%U'", format_unformat_error, i);
10869 M (SET_IPFIX_CLASSIFY_STREAM, mp);
10871 mp->domain_id = htonl (domain_id);
10872 mp->src_port = htons ((u16) src_port);
10880 api_ipfix_classify_table_add_del (vat_main_t * vam)
10882 unformat_input_t *i = vam->input;
10883 vl_api_ipfix_classify_table_add_del_t *mp;
10885 u32 classify_table_index = ~0;
10887 u8 transport_protocol = 255;
10890 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10892 if (unformat (i, "add"))
10894 else if (unformat (i, "del"))
10896 else if (unformat (i, "table %d", &classify_table_index))
10898 else if (unformat (i, "ip4"))
10900 else if (unformat (i, "ip6"))
10902 else if (unformat (i, "tcp"))
10903 transport_protocol = 6;
10904 else if (unformat (i, "udp"))
10905 transport_protocol = 17;
10908 errmsg ("unknown input `%U'", format_unformat_error, i);
10915 errmsg ("expecting: add|del");
10918 if (classify_table_index == ~0)
10920 errmsg ("classifier table not specified");
10923 if (ip_version == 0)
10925 errmsg ("IP version not specified");
10929 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
10931 mp->is_add = is_add;
10932 mp->table_id = htonl (classify_table_index);
10933 mp->ip_version = ip_version;
10934 mp->transport_protocol = transport_protocol;
10942 api_get_node_index (vat_main_t * vam)
10944 unformat_input_t *i = vam->input;
10945 vl_api_get_node_index_t *mp;
10949 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10951 if (unformat (i, "node %s", &name))
10958 errmsg ("node name required");
10961 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10963 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10967 M (GET_NODE_INDEX, mp);
10968 clib_memcpy (mp->node_name, name, vec_len (name));
10977 api_get_next_index (vat_main_t * vam)
10979 unformat_input_t *i = vam->input;
10980 vl_api_get_next_index_t *mp;
10981 u8 *node_name = 0, *next_node_name = 0;
10984 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10986 if (unformat (i, "node-name %s", &node_name))
10988 else if (unformat (i, "next-node-name %s", &next_node_name))
10992 if (node_name == 0)
10994 errmsg ("node name required");
10997 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
10999 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11003 if (next_node_name == 0)
11005 errmsg ("next node name required");
11008 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
11010 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
11014 M (GET_NEXT_INDEX, mp);
11015 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
11016 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
11017 vec_free (node_name);
11018 vec_free (next_node_name);
11026 api_add_node_next (vat_main_t * vam)
11028 unformat_input_t *i = vam->input;
11029 vl_api_add_node_next_t *mp;
11034 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11036 if (unformat (i, "node %s", &name))
11038 else if (unformat (i, "next %s", &next))
11045 errmsg ("node name required");
11048 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11050 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11055 errmsg ("next node required");
11058 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
11060 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
11064 M (ADD_NODE_NEXT, mp);
11065 clib_memcpy (mp->node_name, name, vec_len (name));
11066 clib_memcpy (mp->next_name, next, vec_len (next));
11076 api_l2tpv3_create_tunnel (vat_main_t * vam)
11078 unformat_input_t *i = vam->input;
11079 ip6_address_t client_address, our_address;
11080 int client_address_set = 0;
11081 int our_address_set = 0;
11082 u32 local_session_id = 0;
11083 u32 remote_session_id = 0;
11084 u64 local_cookie = 0;
11085 u64 remote_cookie = 0;
11086 u8 l2_sublayer_present = 0;
11087 vl_api_l2tpv3_create_tunnel_t *mp;
11090 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11092 if (unformat (i, "client_address %U", unformat_ip6_address,
11094 client_address_set = 1;
11095 else if (unformat (i, "our_address %U", unformat_ip6_address,
11097 our_address_set = 1;
11098 else if (unformat (i, "local_session_id %d", &local_session_id))
11100 else if (unformat (i, "remote_session_id %d", &remote_session_id))
11102 else if (unformat (i, "local_cookie %lld", &local_cookie))
11104 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
11106 else if (unformat (i, "l2-sublayer-present"))
11107 l2_sublayer_present = 1;
11112 if (client_address_set == 0)
11114 errmsg ("client_address required");
11118 if (our_address_set == 0)
11120 errmsg ("our_address required");
11124 M (L2TPV3_CREATE_TUNNEL, mp);
11126 clib_memcpy (mp->client_address.un.ip6, client_address.as_u8,
11127 sizeof (ip6_address_t));
11129 clib_memcpy (mp->our_address.un.ip6, our_address.as_u8,
11130 sizeof (ip6_address_t));
11132 mp->local_session_id = ntohl (local_session_id);
11133 mp->remote_session_id = ntohl (remote_session_id);
11134 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
11135 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
11136 mp->l2_sublayer_present = l2_sublayer_present;
11144 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
11146 unformat_input_t *i = vam->input;
11148 u8 sw_if_index_set = 0;
11149 u64 new_local_cookie = 0;
11150 u64 new_remote_cookie = 0;
11151 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
11154 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11156 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11157 sw_if_index_set = 1;
11158 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11159 sw_if_index_set = 1;
11160 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
11162 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
11168 if (sw_if_index_set == 0)
11170 errmsg ("missing interface name or sw_if_index");
11174 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
11176 mp->sw_if_index = ntohl (sw_if_index);
11177 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
11178 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
11186 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
11188 unformat_input_t *i = vam->input;
11189 vl_api_l2tpv3_interface_enable_disable_t *mp;
11191 u8 sw_if_index_set = 0;
11192 u8 enable_disable = 1;
11195 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11197 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11198 sw_if_index_set = 1;
11199 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11200 sw_if_index_set = 1;
11201 else if (unformat (i, "enable"))
11202 enable_disable = 1;
11203 else if (unformat (i, "disable"))
11204 enable_disable = 0;
11209 if (sw_if_index_set == 0)
11211 errmsg ("missing interface name or sw_if_index");
11215 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
11217 mp->sw_if_index = ntohl (sw_if_index);
11218 mp->enable_disable = enable_disable;
11226 api_l2tpv3_set_lookup_key (vat_main_t * vam)
11228 unformat_input_t *i = vam->input;
11229 vl_api_l2tpv3_set_lookup_key_t *mp;
11233 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11235 if (unformat (i, "lookup_v6_src"))
11236 key = L2T_LOOKUP_SRC_ADDRESS;
11237 else if (unformat (i, "lookup_v6_dst"))
11238 key = L2T_LOOKUP_DST_ADDRESS;
11239 else if (unformat (i, "lookup_session_id"))
11240 key = L2T_LOOKUP_SESSION_ID;
11245 if (key == (u8) ~ 0)
11247 errmsg ("l2tp session lookup key unset");
11251 M (L2TPV3_SET_LOOKUP_KEY, mp);
11260 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
11261 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11263 vat_main_t *vam = &vat_main;
11265 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
11266 format_ip6_address, mp->our_address,
11267 format_ip6_address, mp->client_address,
11268 clib_net_to_host_u32 (mp->sw_if_index));
11271 " local cookies %016llx %016llx remote cookie %016llx",
11272 clib_net_to_host_u64 (mp->local_cookie[0]),
11273 clib_net_to_host_u64 (mp->local_cookie[1]),
11274 clib_net_to_host_u64 (mp->remote_cookie));
11276 print (vam->ofp, " local session-id %d remote session-id %d",
11277 clib_net_to_host_u32 (mp->local_session_id),
11278 clib_net_to_host_u32 (mp->remote_session_id));
11280 print (vam->ofp, " l2 specific sublayer %s\n",
11281 mp->l2_sublayer_present ? "preset" : "absent");
11285 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
11286 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
11288 vat_main_t *vam = &vat_main;
11289 vat_json_node_t *node = NULL;
11290 struct in6_addr addr;
11292 if (VAT_JSON_ARRAY != vam->json_tree.type)
11294 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11295 vat_json_init_array (&vam->json_tree);
11297 node = vat_json_array_add (&vam->json_tree);
11299 vat_json_init_object (node);
11301 clib_memcpy (&addr, mp->our_address.un.ip6, sizeof (addr));
11302 vat_json_object_add_ip6 (node, "our_address", addr);
11303 clib_memcpy (&addr, mp->client_address.un.ip6, sizeof (addr));
11304 vat_json_object_add_ip6 (node, "client_address", addr);
11306 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
11307 vat_json_init_array (lc);
11308 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
11309 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
11310 vat_json_object_add_uint (node, "remote_cookie",
11311 clib_net_to_host_u64 (mp->remote_cookie));
11313 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
11314 vat_json_object_add_uint (node, "local_session_id",
11315 clib_net_to_host_u32 (mp->local_session_id));
11316 vat_json_object_add_uint (node, "remote_session_id",
11317 clib_net_to_host_u32 (mp->remote_session_id));
11318 vat_json_object_add_string_copy (node, "l2_sublayer",
11319 mp->l2_sublayer_present ? (u8 *) "present"
11320 : (u8 *) "absent");
11324 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
11326 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
11327 vl_api_control_ping_t *mp_ping;
11330 /* Get list of l2tpv3-tunnel interfaces */
11331 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
11334 /* Use a control ping for synchronization */
11335 MPING (CONTROL_PING, mp_ping);
11343 static void vl_api_sw_interface_tap_v2_details_t_handler
11344 (vl_api_sw_interface_tap_v2_details_t * mp)
11346 vat_main_t *vam = &vat_main;
11349 format (0, "%U/%d", format_ip4_address, mp->host_ip4_prefix.address,
11350 mp->host_ip4_prefix.len);
11352 format (0, "%U/%d", format_ip6_address, mp->host_ip6_prefix.address,
11353 mp->host_ip6_prefix.len);
11356 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s 0x%-08x",
11357 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
11358 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
11359 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
11360 mp->host_bridge, ip4, ip6, ntohl (mp->tap_flags));
11366 static void vl_api_sw_interface_tap_v2_details_t_handler_json
11367 (vl_api_sw_interface_tap_v2_details_t * mp)
11369 vat_main_t *vam = &vat_main;
11370 vat_json_node_t *node = NULL;
11372 if (VAT_JSON_ARRAY != vam->json_tree.type)
11374 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11375 vat_json_init_array (&vam->json_tree);
11377 node = vat_json_array_add (&vam->json_tree);
11379 vat_json_init_object (node);
11380 vat_json_object_add_uint (node, "id", ntohl (mp->id));
11381 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11382 vat_json_object_add_uint (node, "tap_flags", ntohl (mp->tap_flags));
11383 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
11384 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
11385 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
11386 vat_json_object_add_string_copy (node, "host_mac_addr",
11387 format (0, "%U", format_ethernet_address,
11388 &mp->host_mac_addr));
11389 vat_json_object_add_string_copy (node, "host_namespace",
11390 mp->host_namespace);
11391 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
11392 vat_json_object_add_string_copy (node, "host_ip4_addr",
11393 format (0, "%U/%d", format_ip4_address,
11394 mp->host_ip4_prefix.address,
11395 mp->host_ip4_prefix.len));
11396 vat_json_object_add_string_copy (node, "host_ip6_prefix",
11397 format (0, "%U/%d", format_ip6_address,
11398 mp->host_ip6_prefix.address,
11399 mp->host_ip6_prefix.len));
11404 api_sw_interface_tap_v2_dump (vat_main_t * vam)
11406 vl_api_sw_interface_tap_v2_dump_t *mp;
11407 vl_api_control_ping_t *mp_ping;
11411 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
11412 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
11413 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
11416 /* Get list of tap interfaces */
11417 M (SW_INTERFACE_TAP_V2_DUMP, mp);
11420 /* Use a control ping for synchronization */
11421 MPING (CONTROL_PING, mp_ping);
11428 static void vl_api_sw_interface_virtio_pci_details_t_handler
11429 (vl_api_sw_interface_virtio_pci_details_t * mp)
11431 vat_main_t *vam = &vat_main;
11446 addr.domain = ntohs (mp->pci_addr.domain);
11447 addr.bus = mp->pci_addr.bus;
11448 addr.slot = mp->pci_addr.slot;
11449 addr.function = mp->pci_addr.function;
11451 u8 *pci_addr = format (0, "%04x:%02x:%02x.%x", addr.domain, addr.bus,
11452 addr.slot, addr.function);
11455 "\n%-12s %-12d %-12d %-12d %-17U 0x%-08llx",
11456 pci_addr, ntohl (mp->sw_if_index),
11457 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
11458 format_ethernet_address, mp->mac_addr,
11459 clib_net_to_host_u64 (mp->features));
11460 vec_free (pci_addr);
11463 static void vl_api_sw_interface_virtio_pci_details_t_handler_json
11464 (vl_api_sw_interface_virtio_pci_details_t * mp)
11466 vat_main_t *vam = &vat_main;
11467 vat_json_node_t *node = NULL;
11468 vlib_pci_addr_t pci_addr;
11470 if (VAT_JSON_ARRAY != vam->json_tree.type)
11472 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11473 vat_json_init_array (&vam->json_tree);
11475 node = vat_json_array_add (&vam->json_tree);
11477 pci_addr.domain = ntohs (mp->pci_addr.domain);
11478 pci_addr.bus = mp->pci_addr.bus;
11479 pci_addr.slot = mp->pci_addr.slot;
11480 pci_addr.function = mp->pci_addr.function;
11482 vat_json_init_object (node);
11483 vat_json_object_add_uint (node, "pci-addr", pci_addr.as_u32);
11484 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11485 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
11486 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
11487 vat_json_object_add_uint (node, "features",
11488 clib_net_to_host_u64 (mp->features));
11489 vat_json_object_add_string_copy (node, "mac_addr",
11490 format (0, "%U", format_ethernet_address,
11495 api_sw_interface_virtio_pci_dump (vat_main_t * vam)
11497 vl_api_sw_interface_virtio_pci_dump_t *mp;
11498 vl_api_control_ping_t *mp_ping;
11502 "\n%-12s %-12s %-12s %-12s %-17s %-08s",
11503 "pci_addr", "sw_if_index", "rx_ring_sz", "tx_ring_sz",
11504 "mac_addr", "features");
11506 /* Get list of tap interfaces */
11507 M (SW_INTERFACE_VIRTIO_PCI_DUMP, mp);
11510 /* Use a control ping for synchronization */
11511 MPING (CONTROL_PING, mp_ping);
11519 api_vxlan_offload_rx (vat_main_t * vam)
11521 unformat_input_t *line_input = vam->input;
11522 vl_api_vxlan_offload_rx_t *mp;
11523 u32 hw_if_index = ~0, rx_if_index = ~0;
11527 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11529 if (unformat (line_input, "del"))
11531 else if (unformat (line_input, "hw %U", api_unformat_hw_if_index, vam,
11534 else if (unformat (line_input, "hw hw_if_index %u", &hw_if_index))
11536 else if (unformat (line_input, "rx %U", api_unformat_sw_if_index, vam,
11539 else if (unformat (line_input, "rx sw_if_index %u", &rx_if_index))
11543 errmsg ("parse error '%U'", format_unformat_error, line_input);
11548 if (hw_if_index == ~0)
11550 errmsg ("no hw interface");
11554 if (rx_if_index == ~0)
11556 errmsg ("no rx tunnel");
11560 M (VXLAN_OFFLOAD_RX, mp);
11562 mp->hw_if_index = ntohl (hw_if_index);
11563 mp->sw_if_index = ntohl (rx_if_index);
11564 mp->enable = is_add;
11571 static uword unformat_vxlan_decap_next
11572 (unformat_input_t * input, va_list * args)
11574 u32 *result = va_arg (*args, u32 *);
11577 if (unformat (input, "l2"))
11578 *result = VXLAN_INPUT_NEXT_L2_INPUT;
11579 else if (unformat (input, "%d", &tmp))
11587 api_vxlan_add_del_tunnel (vat_main_t * vam)
11589 unformat_input_t *line_input = vam->input;
11590 vl_api_vxlan_add_del_tunnel_t *mp;
11591 ip46_address_t src, dst;
11593 u8 ipv4_set = 0, ipv6_set = 0;
11598 u32 mcast_sw_if_index = ~0;
11599 u32 encap_vrf_id = 0;
11600 u32 decap_next_index = ~0;
11604 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
11605 clib_memset (&src, 0, sizeof src);
11606 clib_memset (&dst, 0, sizeof dst);
11608 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11610 if (unformat (line_input, "del"))
11612 else if (unformat (line_input, "instance %d", &instance))
11615 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
11621 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
11627 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
11633 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
11638 else if (unformat (line_input, "group %U %U",
11639 unformat_ip4_address, &dst.ip4,
11640 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11642 grp_set = dst_set = 1;
11645 else if (unformat (line_input, "group %U",
11646 unformat_ip4_address, &dst.ip4))
11648 grp_set = dst_set = 1;
11651 else if (unformat (line_input, "group %U %U",
11652 unformat_ip6_address, &dst.ip6,
11653 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11655 grp_set = dst_set = 1;
11658 else if (unformat (line_input, "group %U",
11659 unformat_ip6_address, &dst.ip6))
11661 grp_set = dst_set = 1;
11665 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
11667 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11669 else if (unformat (line_input, "decap-next %U",
11670 unformat_vxlan_decap_next, &decap_next_index))
11672 else if (unformat (line_input, "vni %d", &vni))
11676 errmsg ("parse error '%U'", format_unformat_error, line_input);
11683 errmsg ("tunnel src address not specified");
11688 errmsg ("tunnel dst address not specified");
11692 if (grp_set && !ip46_address_is_multicast (&dst))
11694 errmsg ("tunnel group address not multicast");
11697 if (grp_set && mcast_sw_if_index == ~0)
11699 errmsg ("tunnel nonexistent multicast device");
11702 if (grp_set == 0 && ip46_address_is_multicast (&dst))
11704 errmsg ("tunnel dst address must be unicast");
11709 if (ipv4_set && ipv6_set)
11711 errmsg ("both IPv4 and IPv6 addresses specified");
11715 if ((vni == 0) || (vni >> 24))
11717 errmsg ("vni not specified or out of range");
11721 M (VXLAN_ADD_DEL_TUNNEL, mp);
11725 clib_memcpy (mp->src_address.un.ip6, &src.ip6, sizeof (src.ip6));
11726 clib_memcpy (mp->dst_address.un.ip6, &dst.ip6, sizeof (dst.ip6));
11730 clib_memcpy (mp->src_address.un.ip4, &src.ip4, sizeof (src.ip4));
11731 clib_memcpy (mp->dst_address.un.ip4, &dst.ip4, sizeof (dst.ip4));
11733 mp->src_address.af = ipv6_set;
11734 mp->dst_address.af = ipv6_set;
11736 mp->instance = htonl (instance);
11737 mp->encap_vrf_id = ntohl (encap_vrf_id);
11738 mp->decap_next_index = ntohl (decap_next_index);
11739 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
11740 mp->vni = ntohl (vni);
11741 mp->is_add = is_add;
11748 static void vl_api_vxlan_tunnel_details_t_handler
11749 (vl_api_vxlan_tunnel_details_t * mp)
11751 vat_main_t *vam = &vat_main;
11752 ip46_address_t src =
11753 to_ip46 (mp->dst_address.af, (u8 *) & mp->dst_address.un);
11754 ip46_address_t dst =
11755 to_ip46 (mp->dst_address.af, (u8 *) & mp->src_address.un);
11757 print (vam->ofp, "%11d%11d%24U%24U%14d%18d%13d%19d",
11758 ntohl (mp->sw_if_index),
11759 ntohl (mp->instance),
11760 format_ip46_address, &src, IP46_TYPE_ANY,
11761 format_ip46_address, &dst, IP46_TYPE_ANY,
11762 ntohl (mp->encap_vrf_id),
11763 ntohl (mp->decap_next_index), ntohl (mp->vni),
11764 ntohl (mp->mcast_sw_if_index));
11767 static void vl_api_vxlan_tunnel_details_t_handler_json
11768 (vl_api_vxlan_tunnel_details_t * mp)
11770 vat_main_t *vam = &vat_main;
11771 vat_json_node_t *node = NULL;
11773 if (VAT_JSON_ARRAY != vam->json_tree.type)
11775 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11776 vat_json_init_array (&vam->json_tree);
11778 node = vat_json_array_add (&vam->json_tree);
11780 vat_json_init_object (node);
11781 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11783 vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
11785 if (mp->src_address.af)
11787 struct in6_addr ip6;
11789 clib_memcpy (&ip6, mp->src_address.un.ip6, sizeof (ip6));
11790 vat_json_object_add_ip6 (node, "src_address", ip6);
11791 clib_memcpy (&ip6, mp->dst_address.un.ip6, sizeof (ip6));
11792 vat_json_object_add_ip6 (node, "dst_address", ip6);
11796 struct in_addr ip4;
11798 clib_memcpy (&ip4, mp->src_address.un.ip4, sizeof (ip4));
11799 vat_json_object_add_ip4 (node, "src_address", ip4);
11800 clib_memcpy (&ip4, mp->dst_address.un.ip4, sizeof (ip4));
11801 vat_json_object_add_ip4 (node, "dst_address", ip4);
11803 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
11804 vat_json_object_add_uint (node, "decap_next_index",
11805 ntohl (mp->decap_next_index));
11806 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
11807 vat_json_object_add_uint (node, "mcast_sw_if_index",
11808 ntohl (mp->mcast_sw_if_index));
11812 api_vxlan_tunnel_dump (vat_main_t * vam)
11814 unformat_input_t *i = vam->input;
11815 vl_api_vxlan_tunnel_dump_t *mp;
11816 vl_api_control_ping_t *mp_ping;
11818 u8 sw_if_index_set = 0;
11821 /* Parse args required to build the message */
11822 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11824 if (unformat (i, "sw_if_index %d", &sw_if_index))
11825 sw_if_index_set = 1;
11830 if (sw_if_index_set == 0)
11835 if (!vam->json_output)
11837 print (vam->ofp, "%11s%11s%24s%24s%14s%18s%13s%19s",
11838 "sw_if_index", "instance", "src_address", "dst_address",
11839 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
11842 /* Get list of vxlan-tunnel interfaces */
11843 M (VXLAN_TUNNEL_DUMP, mp);
11845 mp->sw_if_index = htonl (sw_if_index);
11849 /* Use a control ping for synchronization */
11850 MPING (CONTROL_PING, mp_ping);
11857 static uword unformat_geneve_decap_next
11858 (unformat_input_t * input, va_list * args)
11860 u32 *result = va_arg (*args, u32 *);
11863 if (unformat (input, "l2"))
11864 *result = GENEVE_INPUT_NEXT_L2_INPUT;
11865 else if (unformat (input, "%d", &tmp))
11873 api_geneve_add_del_tunnel (vat_main_t * vam)
11875 unformat_input_t *line_input = vam->input;
11876 vl_api_geneve_add_del_tunnel_t *mp;
11877 ip46_address_t src, dst;
11879 u8 ipv4_set = 0, ipv6_set = 0;
11883 u32 mcast_sw_if_index = ~0;
11884 u32 encap_vrf_id = 0;
11885 u32 decap_next_index = ~0;
11889 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
11890 clib_memset (&src, 0, sizeof src);
11891 clib_memset (&dst, 0, sizeof dst);
11893 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11895 if (unformat (line_input, "del"))
11898 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
11904 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
11910 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
11916 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
11921 else if (unformat (line_input, "group %U %U",
11922 unformat_ip4_address, &dst.ip4,
11923 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11925 grp_set = dst_set = 1;
11928 else if (unformat (line_input, "group %U",
11929 unformat_ip4_address, &dst.ip4))
11931 grp_set = dst_set = 1;
11934 else if (unformat (line_input, "group %U %U",
11935 unformat_ip6_address, &dst.ip6,
11936 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
11938 grp_set = dst_set = 1;
11941 else if (unformat (line_input, "group %U",
11942 unformat_ip6_address, &dst.ip6))
11944 grp_set = dst_set = 1;
11948 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
11950 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11952 else if (unformat (line_input, "decap-next %U",
11953 unformat_geneve_decap_next, &decap_next_index))
11955 else if (unformat (line_input, "vni %d", &vni))
11959 errmsg ("parse error '%U'", format_unformat_error, line_input);
11966 errmsg ("tunnel src address not specified");
11971 errmsg ("tunnel dst address not specified");
11975 if (grp_set && !ip46_address_is_multicast (&dst))
11977 errmsg ("tunnel group address not multicast");
11980 if (grp_set && mcast_sw_if_index == ~0)
11982 errmsg ("tunnel nonexistent multicast device");
11985 if (grp_set == 0 && ip46_address_is_multicast (&dst))
11987 errmsg ("tunnel dst address must be unicast");
11992 if (ipv4_set && ipv6_set)
11994 errmsg ("both IPv4 and IPv6 addresses specified");
11998 if ((vni == 0) || (vni >> 24))
12000 errmsg ("vni not specified or out of range");
12004 M (GENEVE_ADD_DEL_TUNNEL, mp);
12008 clib_memcpy (&mp->local_address.un.ip6, &src.ip6, sizeof (src.ip6));
12009 clib_memcpy (&mp->remote_address.un.ip6, &dst.ip6, sizeof (dst.ip6));
12013 clib_memcpy (&mp->local_address.un.ip4, &src.ip4, sizeof (src.ip4));
12014 clib_memcpy (&mp->remote_address.un.ip4, &dst.ip4, sizeof (dst.ip4));
12016 mp->encap_vrf_id = ntohl (encap_vrf_id);
12017 mp->decap_next_index = ntohl (decap_next_index);
12018 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12019 mp->vni = ntohl (vni);
12020 mp->is_add = is_add;
12027 static void vl_api_geneve_tunnel_details_t_handler
12028 (vl_api_geneve_tunnel_details_t * mp)
12030 vat_main_t *vam = &vat_main;
12031 ip46_address_t src = {.as_u64[0] = 0,.as_u64[1] = 0 };
12032 ip46_address_t dst = {.as_u64[0] = 0,.as_u64[1] = 0 };
12034 if (mp->src_address.af == ADDRESS_IP6)
12036 clib_memcpy (&src.ip6, &mp->src_address.un.ip6, sizeof (ip6_address_t));
12037 clib_memcpy (&dst.ip6, &mp->dst_address.un.ip6, sizeof (ip6_address_t));
12041 clib_memcpy (&src.ip4, &mp->src_address.un.ip4, sizeof (ip4_address_t));
12042 clib_memcpy (&dst.ip4, &mp->dst_address.un.ip4, sizeof (ip4_address_t));
12045 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12046 ntohl (mp->sw_if_index),
12047 format_ip46_address, &src, IP46_TYPE_ANY,
12048 format_ip46_address, &dst, IP46_TYPE_ANY,
12049 ntohl (mp->encap_vrf_id),
12050 ntohl (mp->decap_next_index), ntohl (mp->vni),
12051 ntohl (mp->mcast_sw_if_index));
12054 static void vl_api_geneve_tunnel_details_t_handler_json
12055 (vl_api_geneve_tunnel_details_t * mp)
12057 vat_main_t *vam = &vat_main;
12058 vat_json_node_t *node = NULL;
12061 if (VAT_JSON_ARRAY != vam->json_tree.type)
12063 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12064 vat_json_init_array (&vam->json_tree);
12066 node = vat_json_array_add (&vam->json_tree);
12068 vat_json_init_object (node);
12069 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12070 is_ipv6 = mp->src_address.af == ADDRESS_IP6;
12073 struct in6_addr ip6;
12075 clib_memcpy (&ip6, &mp->src_address.un.ip6, sizeof (ip6));
12076 vat_json_object_add_ip6 (node, "src_address", ip6);
12077 clib_memcpy (&ip6, &mp->dst_address.un.ip6, sizeof (ip6));
12078 vat_json_object_add_ip6 (node, "dst_address", ip6);
12082 struct in_addr ip4;
12084 clib_memcpy (&ip4, &mp->src_address.un.ip4, sizeof (ip4));
12085 vat_json_object_add_ip4 (node, "src_address", ip4);
12086 clib_memcpy (&ip4, &mp->dst_address.un.ip4, sizeof (ip4));
12087 vat_json_object_add_ip4 (node, "dst_address", ip4);
12089 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12090 vat_json_object_add_uint (node, "decap_next_index",
12091 ntohl (mp->decap_next_index));
12092 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12093 vat_json_object_add_uint (node, "mcast_sw_if_index",
12094 ntohl (mp->mcast_sw_if_index));
12098 api_geneve_tunnel_dump (vat_main_t * vam)
12100 unformat_input_t *i = vam->input;
12101 vl_api_geneve_tunnel_dump_t *mp;
12102 vl_api_control_ping_t *mp_ping;
12104 u8 sw_if_index_set = 0;
12107 /* Parse args required to build the message */
12108 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12110 if (unformat (i, "sw_if_index %d", &sw_if_index))
12111 sw_if_index_set = 1;
12116 if (sw_if_index_set == 0)
12121 if (!vam->json_output)
12123 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12124 "sw_if_index", "local_address", "remote_address",
12125 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12128 /* Get list of geneve-tunnel interfaces */
12129 M (GENEVE_TUNNEL_DUMP, mp);
12131 mp->sw_if_index = htonl (sw_if_index);
12135 /* Use a control ping for synchronization */
12136 M (CONTROL_PING, mp_ping);
12144 api_gre_tunnel_add_del (vat_main_t * vam)
12146 unformat_input_t *line_input = vam->input;
12147 vl_api_address_t src = { }, dst =
12150 vl_api_gre_tunnel_add_del_t *mp;
12151 vl_api_gre_tunnel_type_t t_type;
12155 u32 outer_table_id = 0;
12156 u32 session_id = 0;
12160 t_type = GRE_API_TUNNEL_TYPE_L3;
12162 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12164 if (unformat (line_input, "del"))
12166 else if (unformat (line_input, "instance %d", &instance))
12168 else if (unformat (line_input, "src %U", unformat_vl_api_address, &src))
12172 else if (unformat (line_input, "dst %U", unformat_vl_api_address, &dst))
12176 else if (unformat (line_input, "outer-table-id %d", &outer_table_id))
12178 else if (unformat (line_input, "teb"))
12179 t_type = GRE_API_TUNNEL_TYPE_TEB;
12180 else if (unformat (line_input, "erspan %d", &session_id))
12181 t_type = GRE_API_TUNNEL_TYPE_ERSPAN;
12184 errmsg ("parse error '%U'", format_unformat_error, line_input);
12191 errmsg ("tunnel src address not specified");
12196 errmsg ("tunnel dst address not specified");
12200 M (GRE_TUNNEL_ADD_DEL, mp);
12202 clib_memcpy (&mp->tunnel.src, &src, sizeof (mp->tunnel.src));
12203 clib_memcpy (&mp->tunnel.dst, &dst, sizeof (mp->tunnel.dst));
12205 mp->tunnel.instance = htonl (instance);
12206 mp->tunnel.outer_table_id = htonl (outer_table_id);
12207 mp->is_add = is_add;
12208 mp->tunnel.session_id = htons ((u16) session_id);
12209 mp->tunnel.type = htonl (t_type);
12216 static void vl_api_gre_tunnel_details_t_handler
12217 (vl_api_gre_tunnel_details_t * mp)
12219 vat_main_t *vam = &vat_main;
12221 print (vam->ofp, "%11d%11d%24U%24U%13d%14d%12d",
12222 ntohl (mp->tunnel.sw_if_index),
12223 ntohl (mp->tunnel.instance),
12224 format_vl_api_address, &mp->tunnel.src,
12225 format_vl_api_address, &mp->tunnel.dst,
12226 mp->tunnel.type, ntohl (mp->tunnel.outer_table_id),
12227 ntohl (mp->tunnel.session_id));
12230 static void vl_api_gre_tunnel_details_t_handler_json
12231 (vl_api_gre_tunnel_details_t * mp)
12233 vat_main_t *vam = &vat_main;
12234 vat_json_node_t *node = NULL;
12236 if (VAT_JSON_ARRAY != vam->json_tree.type)
12238 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12239 vat_json_init_array (&vam->json_tree);
12241 node = vat_json_array_add (&vam->json_tree);
12243 vat_json_init_object (node);
12244 vat_json_object_add_uint (node, "sw_if_index",
12245 ntohl (mp->tunnel.sw_if_index));
12246 vat_json_object_add_uint (node, "instance", ntohl (mp->tunnel.instance));
12248 vat_json_object_add_address (node, "src", &mp->tunnel.src);
12249 vat_json_object_add_address (node, "dst", &mp->tunnel.dst);
12250 vat_json_object_add_uint (node, "tunnel_type", mp->tunnel.type);
12251 vat_json_object_add_uint (node, "outer_table_id",
12252 ntohl (mp->tunnel.outer_table_id));
12253 vat_json_object_add_uint (node, "session_id", mp->tunnel.session_id);
12257 api_gre_tunnel_dump (vat_main_t * vam)
12259 unformat_input_t *i = vam->input;
12260 vl_api_gre_tunnel_dump_t *mp;
12261 vl_api_control_ping_t *mp_ping;
12263 u8 sw_if_index_set = 0;
12266 /* Parse args required to build the message */
12267 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12269 if (unformat (i, "sw_if_index %d", &sw_if_index))
12270 sw_if_index_set = 1;
12275 if (sw_if_index_set == 0)
12280 if (!vam->json_output)
12282 print (vam->ofp, "%11s%11s%24s%24s%13s%14s%12s",
12283 "sw_if_index", "instance", "src_address", "dst_address",
12284 "tunnel_type", "outer_fib_id", "session_id");
12287 /* Get list of gre-tunnel interfaces */
12288 M (GRE_TUNNEL_DUMP, mp);
12290 mp->sw_if_index = htonl (sw_if_index);
12294 /* Use a control ping for synchronization */
12295 MPING (CONTROL_PING, mp_ping);
12303 api_l2_fib_clear_table (vat_main_t * vam)
12305 // unformat_input_t * i = vam->input;
12306 vl_api_l2_fib_clear_table_t *mp;
12309 M (L2_FIB_CLEAR_TABLE, mp);
12317 api_l2_interface_efp_filter (vat_main_t * vam)
12319 unformat_input_t *i = vam->input;
12320 vl_api_l2_interface_efp_filter_t *mp;
12323 u8 sw_if_index_set = 0;
12326 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12328 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12329 sw_if_index_set = 1;
12330 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12331 sw_if_index_set = 1;
12332 else if (unformat (i, "enable"))
12334 else if (unformat (i, "disable"))
12338 clib_warning ("parse error '%U'", format_unformat_error, i);
12343 if (sw_if_index_set == 0)
12345 errmsg ("missing sw_if_index");
12349 M (L2_INTERFACE_EFP_FILTER, mp);
12351 mp->sw_if_index = ntohl (sw_if_index);
12352 mp->enable_disable = enable;
12359 #define foreach_vtr_op \
12360 _("disable", L2_VTR_DISABLED) \
12361 _("push-1", L2_VTR_PUSH_1) \
12362 _("push-2", L2_VTR_PUSH_2) \
12363 _("pop-1", L2_VTR_POP_1) \
12364 _("pop-2", L2_VTR_POP_2) \
12365 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
12366 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
12367 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
12368 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
12371 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
12373 unformat_input_t *i = vam->input;
12374 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
12376 u8 sw_if_index_set = 0;
12379 u32 push_dot1q = 1;
12384 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12386 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12387 sw_if_index_set = 1;
12388 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12389 sw_if_index_set = 1;
12390 else if (unformat (i, "vtr_op %d", &vtr_op))
12392 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
12395 else if (unformat (i, "push_dot1q %d", &push_dot1q))
12397 else if (unformat (i, "tag1 %d", &tag1))
12399 else if (unformat (i, "tag2 %d", &tag2))
12403 clib_warning ("parse error '%U'", format_unformat_error, i);
12408 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
12410 errmsg ("missing vtr operation or sw_if_index");
12414 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
12415 mp->sw_if_index = ntohl (sw_if_index);
12416 mp->vtr_op = ntohl (vtr_op);
12417 mp->push_dot1q = ntohl (push_dot1q);
12418 mp->tag1 = ntohl (tag1);
12419 mp->tag2 = ntohl (tag2);
12427 api_create_vhost_user_if (vat_main_t * vam)
12429 unformat_input_t *i = vam->input;
12430 vl_api_create_vhost_user_if_t *mp;
12433 u8 file_name_set = 0;
12434 u32 custom_dev_instance = ~0;
12436 u8 use_custom_mac = 0;
12437 u8 disable_mrg_rxbuf = 0;
12438 u8 disable_indirect_desc = 0;
12441 u8 enable_packed = 0;
12444 /* Shut up coverity */
12445 clib_memset (hwaddr, 0, sizeof (hwaddr));
12447 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12449 if (unformat (i, "socket %s", &file_name))
12453 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
12455 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
12456 use_custom_mac = 1;
12457 else if (unformat (i, "server"))
12459 else if (unformat (i, "disable_mrg_rxbuf"))
12460 disable_mrg_rxbuf = 1;
12461 else if (unformat (i, "disable_indirect_desc"))
12462 disable_indirect_desc = 1;
12463 else if (unformat (i, "gso"))
12465 else if (unformat (i, "packed"))
12467 else if (unformat (i, "tag %s", &tag))
12473 if (file_name_set == 0)
12475 errmsg ("missing socket file name");
12479 if (vec_len (file_name) > 255)
12481 errmsg ("socket file name too long");
12484 vec_add1 (file_name, 0);
12486 M (CREATE_VHOST_USER_IF, mp);
12488 mp->is_server = is_server;
12489 mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
12490 mp->disable_indirect_desc = disable_indirect_desc;
12491 mp->enable_gso = enable_gso;
12492 mp->enable_packed = enable_packed;
12493 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12494 vec_free (file_name);
12495 if (custom_dev_instance != ~0)
12498 mp->custom_dev_instance = ntohl (custom_dev_instance);
12501 mp->use_custom_mac = use_custom_mac;
12502 clib_memcpy (mp->mac_address, hwaddr, 6);
12504 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
12513 api_modify_vhost_user_if (vat_main_t * vam)
12515 unformat_input_t *i = vam->input;
12516 vl_api_modify_vhost_user_if_t *mp;
12519 u8 file_name_set = 0;
12520 u32 custom_dev_instance = ~0;
12521 u8 sw_if_index_set = 0;
12522 u32 sw_if_index = (u32) ~ 0;
12524 u8 enable_packed = 0;
12527 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12529 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12530 sw_if_index_set = 1;
12531 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12532 sw_if_index_set = 1;
12533 else if (unformat (i, "socket %s", &file_name))
12537 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
12539 else if (unformat (i, "server"))
12541 else if (unformat (i, "gso"))
12543 else if (unformat (i, "packed"))
12549 if (sw_if_index_set == 0)
12551 errmsg ("missing sw_if_index or interface name");
12555 if (file_name_set == 0)
12557 errmsg ("missing socket file name");
12561 if (vec_len (file_name) > 255)
12563 errmsg ("socket file name too long");
12566 vec_add1 (file_name, 0);
12568 M (MODIFY_VHOST_USER_IF, mp);
12570 mp->sw_if_index = ntohl (sw_if_index);
12571 mp->is_server = is_server;
12572 mp->enable_gso = enable_gso;
12573 mp->enable_packed = enable_packed;
12574 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
12575 vec_free (file_name);
12576 if (custom_dev_instance != ~0)
12579 mp->custom_dev_instance = ntohl (custom_dev_instance);
12588 api_delete_vhost_user_if (vat_main_t * vam)
12590 unformat_input_t *i = vam->input;
12591 vl_api_delete_vhost_user_if_t *mp;
12592 u32 sw_if_index = ~0;
12593 u8 sw_if_index_set = 0;
12596 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12598 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12599 sw_if_index_set = 1;
12600 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12601 sw_if_index_set = 1;
12606 if (sw_if_index_set == 0)
12608 errmsg ("missing sw_if_index or interface name");
12613 M (DELETE_VHOST_USER_IF, mp);
12615 mp->sw_if_index = ntohl (sw_if_index);
12622 static void vl_api_sw_interface_vhost_user_details_t_handler
12623 (vl_api_sw_interface_vhost_user_details_t * mp)
12625 vat_main_t *vam = &vat_main;
12629 clib_net_to_host_u32 (mp->features_first_32) | ((u64)
12630 clib_net_to_host_u32
12631 (mp->features_last_32) <<
12634 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
12635 (char *) mp->interface_name,
12636 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
12637 features, mp->is_server,
12638 ntohl (mp->num_regions), (char *) mp->sock_filename);
12639 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
12642 static void vl_api_sw_interface_vhost_user_details_t_handler_json
12643 (vl_api_sw_interface_vhost_user_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));
12657 vat_json_object_add_string_copy (node, "interface_name",
12658 mp->interface_name);
12659 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
12660 ntohl (mp->virtio_net_hdr_sz));
12661 vat_json_object_add_uint (node, "features_first_32",
12662 clib_net_to_host_u32 (mp->features_first_32));
12663 vat_json_object_add_uint (node, "features_last_32",
12664 clib_net_to_host_u32 (mp->features_last_32));
12665 vat_json_object_add_uint (node, "is_server", mp->is_server);
12666 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
12667 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
12668 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
12672 api_sw_interface_vhost_user_dump (vat_main_t * vam)
12674 vl_api_sw_interface_vhost_user_dump_t *mp;
12675 vl_api_control_ping_t *mp_ping;
12678 "Interface name idx hdr_sz features server regions filename");
12680 /* Get list of vhost-user interfaces */
12681 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
12682 mp->sw_if_index = ntohl (~0);
12685 /* Use a control ping for synchronization */
12686 MPING (CONTROL_PING, mp_ping);
12694 api_show_version (vat_main_t * vam)
12696 vl_api_show_version_t *mp;
12699 M (SHOW_VERSION, mp);
12708 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
12710 unformat_input_t *line_input = vam->input;
12711 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
12712 ip46_address_t local, remote;
12717 u32 mcast_sw_if_index = ~0;
12718 u32 encap_vrf_id = 0;
12719 u32 decap_vrf_id = 0;
12725 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12727 if (unformat (line_input, "del"))
12729 else if (unformat (line_input, "local %U",
12730 unformat_ip46_address, &local))
12734 else if (unformat (line_input, "remote %U",
12735 unformat_ip46_address, &remote))
12739 else if (unformat (line_input, "group %U %U",
12740 unformat_ip46_address, &remote,
12741 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12743 grp_set = remote_set = 1;
12745 else if (unformat (line_input, "group %U",
12746 unformat_ip46_address, &remote))
12748 grp_set = remote_set = 1;
12751 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12753 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12755 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
12757 else if (unformat (line_input, "vni %d", &vni))
12759 else if (unformat (line_input, "next-ip4"))
12761 else if (unformat (line_input, "next-ip6"))
12763 else if (unformat (line_input, "next-ethernet"))
12765 else if (unformat (line_input, "next-nsh"))
12769 errmsg ("parse error '%U'", format_unformat_error, line_input);
12774 if (local_set == 0)
12776 errmsg ("tunnel local address not specified");
12779 if (remote_set == 0)
12781 errmsg ("tunnel remote address not specified");
12784 if (grp_set && mcast_sw_if_index == ~0)
12786 errmsg ("tunnel nonexistent multicast device");
12789 if (ip46_address_is_ip4 (&local) != ip46_address_is_ip4 (&remote))
12791 errmsg ("both IPv4 and IPv6 addresses specified");
12797 errmsg ("vni not specified");
12801 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
12803 ip_address_encode (&local,
12804 ip46_address_is_ip4 (&local) ? IP46_TYPE_IP4 :
12805 IP46_TYPE_IP6, &mp->local);
12806 ip_address_encode (&remote,
12807 ip46_address_is_ip4 (&remote) ? IP46_TYPE_IP4 :
12808 IP46_TYPE_IP6, &mp->remote);
12810 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12811 mp->encap_vrf_id = ntohl (encap_vrf_id);
12812 mp->decap_vrf_id = ntohl (decap_vrf_id);
12813 mp->protocol = protocol;
12814 mp->vni = ntohl (vni);
12815 mp->is_add = is_add;
12822 static void vl_api_vxlan_gpe_tunnel_details_t_handler
12823 (vl_api_vxlan_gpe_tunnel_details_t * mp)
12825 vat_main_t *vam = &vat_main;
12826 ip46_address_t local, remote;
12828 ip_address_decode (&mp->local, &local);
12829 ip_address_decode (&mp->remote, &remote);
12831 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
12832 ntohl (mp->sw_if_index),
12833 format_ip46_address, &local, IP46_TYPE_ANY,
12834 format_ip46_address, &remote, IP46_TYPE_ANY,
12835 ntohl (mp->vni), mp->protocol,
12836 ntohl (mp->mcast_sw_if_index),
12837 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
12841 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
12842 (vl_api_vxlan_gpe_tunnel_details_t * mp)
12844 vat_main_t *vam = &vat_main;
12845 vat_json_node_t *node = NULL;
12846 struct in_addr ip4;
12847 struct in6_addr ip6;
12848 ip46_address_t local, remote;
12850 ip_address_decode (&mp->local, &local);
12851 ip_address_decode (&mp->remote, &remote);
12853 if (VAT_JSON_ARRAY != vam->json_tree.type)
12855 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12856 vat_json_init_array (&vam->json_tree);
12858 node = vat_json_array_add (&vam->json_tree);
12860 vat_json_init_object (node);
12861 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12862 if (ip46_address_is_ip4 (&local))
12864 clib_memcpy (&ip4, &local.ip4, sizeof (ip4));
12865 vat_json_object_add_ip4 (node, "local", ip4);
12866 clib_memcpy (&ip4, &remote.ip4, sizeof (ip4));
12867 vat_json_object_add_ip4 (node, "remote", ip4);
12871 clib_memcpy (&ip6, &local.ip6, sizeof (ip6));
12872 vat_json_object_add_ip6 (node, "local", ip6);
12873 clib_memcpy (&ip6, &remote.ip6, sizeof (ip6));
12874 vat_json_object_add_ip6 (node, "remote", ip6);
12876 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12877 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
12878 vat_json_object_add_uint (node, "mcast_sw_if_index",
12879 ntohl (mp->mcast_sw_if_index));
12880 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12881 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
12882 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12886 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
12888 unformat_input_t *i = vam->input;
12889 vl_api_vxlan_gpe_tunnel_dump_t *mp;
12890 vl_api_control_ping_t *mp_ping;
12892 u8 sw_if_index_set = 0;
12895 /* Parse args required to build the message */
12896 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12898 if (unformat (i, "sw_if_index %d", &sw_if_index))
12899 sw_if_index_set = 1;
12904 if (sw_if_index_set == 0)
12909 if (!vam->json_output)
12911 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
12912 "sw_if_index", "local", "remote", "vni",
12913 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
12916 /* Get list of vxlan-tunnel interfaces */
12917 M (VXLAN_GPE_TUNNEL_DUMP, mp);
12919 mp->sw_if_index = htonl (sw_if_index);
12923 /* Use a control ping for synchronization */
12924 MPING (CONTROL_PING, mp_ping);
12931 static void vl_api_l2_fib_table_details_t_handler
12932 (vl_api_l2_fib_table_details_t * mp)
12934 vat_main_t *vam = &vat_main;
12936 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
12938 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
12939 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
12943 static void vl_api_l2_fib_table_details_t_handler_json
12944 (vl_api_l2_fib_table_details_t * mp)
12946 vat_main_t *vam = &vat_main;
12947 vat_json_node_t *node = NULL;
12949 if (VAT_JSON_ARRAY != vam->json_tree.type)
12951 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12952 vat_json_init_array (&vam->json_tree);
12954 node = vat_json_array_add (&vam->json_tree);
12956 vat_json_init_object (node);
12957 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
12958 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
12959 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12960 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
12961 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
12962 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
12966 api_l2_fib_table_dump (vat_main_t * vam)
12968 unformat_input_t *i = vam->input;
12969 vl_api_l2_fib_table_dump_t *mp;
12970 vl_api_control_ping_t *mp_ping;
12975 /* Parse args required to build the message */
12976 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12978 if (unformat (i, "bd_id %d", &bd_id))
12984 if (bd_id_set == 0)
12986 errmsg ("missing bridge domain");
12990 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
12992 /* Get list of l2 fib entries */
12993 M (L2_FIB_TABLE_DUMP, mp);
12995 mp->bd_id = ntohl (bd_id);
12998 /* Use a control ping for synchronization */
12999 MPING (CONTROL_PING, mp_ping);
13008 api_interface_name_renumber (vat_main_t * vam)
13010 unformat_input_t *line_input = vam->input;
13011 vl_api_interface_name_renumber_t *mp;
13012 u32 sw_if_index = ~0;
13013 u32 new_show_dev_instance = ~0;
13016 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13018 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
13021 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13023 else if (unformat (line_input, "new_show_dev_instance %d",
13024 &new_show_dev_instance))
13030 if (sw_if_index == ~0)
13032 errmsg ("missing interface name or sw_if_index");
13036 if (new_show_dev_instance == ~0)
13038 errmsg ("missing new_show_dev_instance");
13042 M (INTERFACE_NAME_RENUMBER, mp);
13044 mp->sw_if_index = ntohl (sw_if_index);
13045 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
13053 api_want_l2_macs_events (vat_main_t * vam)
13055 unformat_input_t *line_input = vam->input;
13056 vl_api_want_l2_macs_events_t *mp;
13057 u8 enable_disable = 1;
13058 u32 scan_delay = 0;
13059 u32 max_macs_in_event = 0;
13060 u32 learn_limit = 0;
13063 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13065 if (unformat (line_input, "learn-limit %d", &learn_limit))
13067 else if (unformat (line_input, "scan-delay %d", &scan_delay))
13069 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
13071 else if (unformat (line_input, "disable"))
13072 enable_disable = 0;
13077 M (WANT_L2_MACS_EVENTS, mp);
13078 mp->enable_disable = enable_disable;
13079 mp->pid = htonl (getpid ());
13080 mp->learn_limit = htonl (learn_limit);
13081 mp->scan_delay = (u8) scan_delay;
13082 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
13089 api_input_acl_set_interface (vat_main_t * vam)
13091 unformat_input_t *i = vam->input;
13092 vl_api_input_acl_set_interface_t *mp;
13094 int sw_if_index_set;
13095 u32 ip4_table_index = ~0;
13096 u32 ip6_table_index = ~0;
13097 u32 l2_table_index = ~0;
13101 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13103 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13104 sw_if_index_set = 1;
13105 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13106 sw_if_index_set = 1;
13107 else if (unformat (i, "del"))
13109 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13111 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13113 else if (unformat (i, "l2-table %d", &l2_table_index))
13117 clib_warning ("parse error '%U'", format_unformat_error, i);
13122 if (sw_if_index_set == 0)
13124 errmsg ("missing interface name or sw_if_index");
13128 M (INPUT_ACL_SET_INTERFACE, mp);
13130 mp->sw_if_index = ntohl (sw_if_index);
13131 mp->ip4_table_index = ntohl (ip4_table_index);
13132 mp->ip6_table_index = ntohl (ip6_table_index);
13133 mp->l2_table_index = ntohl (l2_table_index);
13134 mp->is_add = is_add;
13142 api_output_acl_set_interface (vat_main_t * vam)
13144 unformat_input_t *i = vam->input;
13145 vl_api_output_acl_set_interface_t *mp;
13147 int sw_if_index_set;
13148 u32 ip4_table_index = ~0;
13149 u32 ip6_table_index = ~0;
13150 u32 l2_table_index = ~0;
13154 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13156 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13157 sw_if_index_set = 1;
13158 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13159 sw_if_index_set = 1;
13160 else if (unformat (i, "del"))
13162 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13164 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13166 else if (unformat (i, "l2-table %d", &l2_table_index))
13170 clib_warning ("parse error '%U'", format_unformat_error, i);
13175 if (sw_if_index_set == 0)
13177 errmsg ("missing interface name or sw_if_index");
13181 M (OUTPUT_ACL_SET_INTERFACE, mp);
13183 mp->sw_if_index = ntohl (sw_if_index);
13184 mp->ip4_table_index = ntohl (ip4_table_index);
13185 mp->ip6_table_index = ntohl (ip6_table_index);
13186 mp->l2_table_index = ntohl (l2_table_index);
13187 mp->is_add = is_add;
13195 api_ip_address_dump (vat_main_t * vam)
13197 unformat_input_t *i = vam->input;
13198 vl_api_ip_address_dump_t *mp;
13199 vl_api_control_ping_t *mp_ping;
13200 u32 sw_if_index = ~0;
13201 u8 sw_if_index_set = 0;
13206 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13208 if (unformat (i, "sw_if_index %d", &sw_if_index))
13209 sw_if_index_set = 1;
13211 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13212 sw_if_index_set = 1;
13213 else if (unformat (i, "ipv4"))
13215 else if (unformat (i, "ipv6"))
13221 if (ipv4_set && ipv6_set)
13223 errmsg ("ipv4 and ipv6 flags cannot be both set");
13227 if ((!ipv4_set) && (!ipv6_set))
13229 errmsg ("no ipv4 nor ipv6 flag set");
13233 if (sw_if_index_set == 0)
13235 errmsg ("missing interface name or sw_if_index");
13239 vam->current_sw_if_index = sw_if_index;
13240 vam->is_ipv6 = ipv6_set;
13242 M (IP_ADDRESS_DUMP, mp);
13243 mp->sw_if_index = ntohl (sw_if_index);
13244 mp->is_ipv6 = ipv6_set;
13247 /* Use a control ping for synchronization */
13248 MPING (CONTROL_PING, mp_ping);
13256 api_ip_dump (vat_main_t * vam)
13258 vl_api_ip_dump_t *mp;
13259 vl_api_control_ping_t *mp_ping;
13260 unformat_input_t *in = vam->input;
13267 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
13269 if (unformat (in, "ipv4"))
13271 else if (unformat (in, "ipv6"))
13277 if (ipv4_set && ipv6_set)
13279 errmsg ("ipv4 and ipv6 flags cannot be both set");
13283 if ((!ipv4_set) && (!ipv6_set))
13285 errmsg ("no ipv4 nor ipv6 flag set");
13289 is_ipv6 = ipv6_set;
13290 vam->is_ipv6 = is_ipv6;
13292 /* free old data */
13293 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
13295 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
13297 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
13300 mp->is_ipv6 = ipv6_set;
13303 /* Use a control ping for synchronization */
13304 MPING (CONTROL_PING, mp_ping);
13312 api_ipsec_spd_add_del (vat_main_t * vam)
13314 unformat_input_t *i = vam->input;
13315 vl_api_ipsec_spd_add_del_t *mp;
13320 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13322 if (unformat (i, "spd_id %d", &spd_id))
13324 else if (unformat (i, "del"))
13328 clib_warning ("parse error '%U'", format_unformat_error, i);
13334 errmsg ("spd_id must be set");
13338 M (IPSEC_SPD_ADD_DEL, mp);
13340 mp->spd_id = ntohl (spd_id);
13341 mp->is_add = is_add;
13349 api_ipsec_interface_add_del_spd (vat_main_t * vam)
13351 unformat_input_t *i = vam->input;
13352 vl_api_ipsec_interface_add_del_spd_t *mp;
13354 u8 sw_if_index_set = 0;
13355 u32 spd_id = (u32) ~ 0;
13359 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13361 if (unformat (i, "del"))
13363 else if (unformat (i, "spd_id %d", &spd_id))
13366 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13367 sw_if_index_set = 1;
13368 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13369 sw_if_index_set = 1;
13372 clib_warning ("parse error '%U'", format_unformat_error, i);
13378 if (spd_id == (u32) ~ 0)
13380 errmsg ("spd_id must be set");
13384 if (sw_if_index_set == 0)
13386 errmsg ("missing interface name or sw_if_index");
13390 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
13392 mp->spd_id = ntohl (spd_id);
13393 mp->sw_if_index = ntohl (sw_if_index);
13394 mp->is_add = is_add;
13402 api_ipsec_spd_entry_add_del (vat_main_t * vam)
13404 unformat_input_t *i = vam->input;
13405 vl_api_ipsec_spd_entry_add_del_t *mp;
13406 u8 is_add = 1, is_outbound = 0;
13407 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
13409 u32 rport_start = 0, rport_stop = (u32) ~ 0;
13410 u32 lport_start = 0, lport_stop = (u32) ~ 0;
13411 vl_api_address_t laddr_start = { }, laddr_stop =
13420 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13422 if (unformat (i, "del"))
13424 if (unformat (i, "outbound"))
13426 if (unformat (i, "inbound"))
13428 else if (unformat (i, "spd_id %d", &spd_id))
13430 else if (unformat (i, "sa_id %d", &sa_id))
13432 else if (unformat (i, "priority %d", &priority))
13434 else if (unformat (i, "protocol %d", &protocol))
13436 else if (unformat (i, "lport_start %d", &lport_start))
13438 else if (unformat (i, "lport_stop %d", &lport_stop))
13440 else if (unformat (i, "rport_start %d", &rport_start))
13442 else if (unformat (i, "rport_stop %d", &rport_stop))
13444 else if (unformat (i, "laddr_start %U",
13445 unformat_vl_api_address, &laddr_start))
13447 else if (unformat (i, "laddr_stop %U", unformat_vl_api_address,
13450 else if (unformat (i, "raddr_start %U", unformat_vl_api_address,
13453 else if (unformat (i, "raddr_stop %U", unformat_vl_api_address,
13457 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
13459 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
13461 clib_warning ("unsupported action: 'resolve'");
13467 clib_warning ("parse error '%U'", format_unformat_error, i);
13473 M (IPSEC_SPD_ENTRY_ADD_DEL, mp);
13475 mp->is_add = is_add;
13477 mp->entry.spd_id = ntohl (spd_id);
13478 mp->entry.priority = ntohl (priority);
13479 mp->entry.is_outbound = is_outbound;
13481 clib_memcpy (&mp->entry.remote_address_start, &raddr_start,
13482 sizeof (vl_api_address_t));
13483 clib_memcpy (&mp->entry.remote_address_stop, &raddr_stop,
13484 sizeof (vl_api_address_t));
13485 clib_memcpy (&mp->entry.local_address_start, &laddr_start,
13486 sizeof (vl_api_address_t));
13487 clib_memcpy (&mp->entry.local_address_stop, &laddr_stop,
13488 sizeof (vl_api_address_t));
13490 mp->entry.protocol = (u8) protocol;
13491 mp->entry.local_port_start = ntohs ((u16) lport_start);
13492 mp->entry.local_port_stop = ntohs ((u16) lport_stop);
13493 mp->entry.remote_port_start = ntohs ((u16) rport_start);
13494 mp->entry.remote_port_stop = ntohs ((u16) rport_stop);
13495 mp->entry.policy = (u8) policy;
13496 mp->entry.sa_id = ntohl (sa_id);
13504 api_ipsec_sad_entry_add_del (vat_main_t * vam)
13506 unformat_input_t *i = vam->input;
13507 vl_api_ipsec_sad_entry_add_del_t *mp;
13508 u32 sad_id = 0, spi = 0;
13509 u8 *ck = 0, *ik = 0;
13512 vl_api_ipsec_crypto_alg_t crypto_alg = IPSEC_API_CRYPTO_ALG_NONE;
13513 vl_api_ipsec_integ_alg_t integ_alg = IPSEC_API_INTEG_ALG_NONE;
13514 vl_api_ipsec_sad_flags_t flags = IPSEC_API_SAD_FLAG_NONE;
13515 vl_api_ipsec_proto_t protocol = IPSEC_API_PROTO_AH;
13516 vl_api_address_t tun_src, tun_dst;
13519 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13521 if (unformat (i, "del"))
13523 else if (unformat (i, "sad_id %d", &sad_id))
13525 else if (unformat (i, "spi %d", &spi))
13527 else if (unformat (i, "esp"))
13528 protocol = IPSEC_API_PROTO_ESP;
13530 if (unformat (i, "tunnel_src %U", unformat_vl_api_address, &tun_src))
13532 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
13533 if (ADDRESS_IP6 == tun_src.af)
13534 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
13537 if (unformat (i, "tunnel_dst %U", unformat_vl_api_address, &tun_dst))
13539 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL;
13540 if (ADDRESS_IP6 == tun_src.af)
13541 flags |= IPSEC_API_SAD_FLAG_IS_TUNNEL_V6;
13544 if (unformat (i, "crypto_alg %U",
13545 unformat_ipsec_api_crypto_alg, &crypto_alg))
13547 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
13549 else if (unformat (i, "integ_alg %U",
13550 unformat_ipsec_api_integ_alg, &integ_alg))
13552 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
13556 clib_warning ("parse error '%U'", format_unformat_error, i);
13562 M (IPSEC_SAD_ENTRY_ADD_DEL, mp);
13564 mp->is_add = is_add;
13565 mp->entry.sad_id = ntohl (sad_id);
13566 mp->entry.protocol = protocol;
13567 mp->entry.spi = ntohl (spi);
13568 mp->entry.flags = flags;
13570 mp->entry.crypto_algorithm = crypto_alg;
13571 mp->entry.integrity_algorithm = integ_alg;
13572 mp->entry.crypto_key.length = vec_len (ck);
13573 mp->entry.integrity_key.length = vec_len (ik);
13575 if (mp->entry.crypto_key.length > sizeof (mp->entry.crypto_key.data))
13576 mp->entry.crypto_key.length = sizeof (mp->entry.crypto_key.data);
13578 if (mp->entry.integrity_key.length > sizeof (mp->entry.integrity_key.data))
13579 mp->entry.integrity_key.length = sizeof (mp->entry.integrity_key.data);
13582 clib_memcpy (mp->entry.crypto_key.data, ck, mp->entry.crypto_key.length);
13584 clib_memcpy (mp->entry.integrity_key.data, ik,
13585 mp->entry.integrity_key.length);
13587 if (flags & IPSEC_API_SAD_FLAG_IS_TUNNEL)
13589 clib_memcpy (&mp->entry.tunnel_src, &tun_src,
13590 sizeof (mp->entry.tunnel_src));
13591 clib_memcpy (&mp->entry.tunnel_dst, &tun_dst,
13592 sizeof (mp->entry.tunnel_dst));
13601 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
13603 unformat_input_t *i = vam->input;
13604 vl_api_ipsec_tunnel_if_add_del_t *mp;
13605 u32 local_spi = 0, remote_spi = 0;
13606 u32 crypto_alg = 0, integ_alg = 0;
13607 u8 *lck = NULL, *rck = NULL;
13608 u8 *lik = NULL, *rik = NULL;
13609 vl_api_address_t local_ip = { 0 };
13610 vl_api_address_t remote_ip = { 0 };
13614 u8 anti_replay = 0;
13620 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13622 if (unformat (i, "del"))
13624 else if (unformat (i, "esn"))
13626 else if (unformat (i, "anti-replay"))
13628 else if (unformat (i, "count %d", &count))
13630 else if (unformat (i, "local_spi %d", &local_spi))
13632 else if (unformat (i, "remote_spi %d", &remote_spi))
13635 if (unformat (i, "local_ip %U", unformat_vl_api_address, &local_ip))
13638 if (unformat (i, "remote_ip %U", unformat_vl_api_address, &remote_ip))
13640 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
13643 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
13645 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
13647 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
13651 (i, "crypto_alg %U", unformat_ipsec_api_crypto_alg, &crypto_alg))
13653 if (crypto_alg >= IPSEC_CRYPTO_N_ALG)
13655 errmsg ("unsupported crypto-alg: '%U'\n",
13656 format_ipsec_crypto_alg, crypto_alg);
13662 (i, "integ_alg %U", unformat_ipsec_api_integ_alg, &integ_alg))
13664 if (integ_alg >= IPSEC_INTEG_N_ALG)
13666 errmsg ("unsupported integ-alg: '%U'\n",
13667 format_ipsec_integ_alg, integ_alg);
13671 else if (unformat (i, "instance %u", &instance))
13675 errmsg ("parse error '%U'\n", format_unformat_error, i);
13682 /* Turn on async mode */
13683 vam->async_mode = 1;
13684 vam->async_errors = 0;
13685 before = vat_time_now (vam);
13688 for (jj = 0; jj < count; jj++)
13690 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
13692 mp->is_add = is_add;
13694 mp->anti_replay = anti_replay;
13697 increment_address (&remote_ip);
13699 clib_memcpy (&mp->local_ip, &local_ip, sizeof (local_ip));
13700 clib_memcpy (&mp->remote_ip, &remote_ip, sizeof (remote_ip));
13702 mp->local_spi = htonl (local_spi + jj);
13703 mp->remote_spi = htonl (remote_spi + jj);
13704 mp->crypto_alg = (u8) crypto_alg;
13706 mp->local_crypto_key_len = 0;
13709 mp->local_crypto_key_len = vec_len (lck);
13710 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
13711 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
13712 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
13715 mp->remote_crypto_key_len = 0;
13718 mp->remote_crypto_key_len = vec_len (rck);
13719 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
13720 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
13721 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
13724 mp->integ_alg = (u8) integ_alg;
13726 mp->local_integ_key_len = 0;
13729 mp->local_integ_key_len = vec_len (lik);
13730 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
13731 mp->local_integ_key_len = sizeof (mp->local_integ_key);
13732 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
13735 mp->remote_integ_key_len = 0;
13738 mp->remote_integ_key_len = vec_len (rik);
13739 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
13740 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
13741 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
13746 mp->renumber = renumber;
13747 mp->show_instance = ntohl (instance);
13752 /* When testing multiple add/del ops, use a control-ping to sync */
13755 vl_api_control_ping_t *mp_ping;
13759 /* Shut off async mode */
13760 vam->async_mode = 0;
13762 MPING (CONTROL_PING, mp_ping);
13765 timeout = vat_time_now (vam) + 1.0;
13766 while (vat_time_now (vam) < timeout)
13767 if (vam->result_ready == 1)
13772 if (vam->retval == -99)
13773 errmsg ("timeout");
13775 if (vam->async_errors > 0)
13777 errmsg ("%d asynchronous errors", vam->async_errors);
13780 vam->async_errors = 0;
13781 after = vat_time_now (vam);
13783 /* slim chance, but we might have eaten SIGTERM on the first iteration */
13787 print (vam->ofp, "%d tunnels in %.6f secs, %.2f tunnels/sec",
13788 count, after - before, count / (after - before));
13792 /* Wait for a reply... */
13801 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
13803 vat_main_t *vam = &vat_main;
13805 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
13806 "crypto_key %U integ_alg %u integ_key %U flags %x "
13807 "tunnel_src_addr %U tunnel_dst_addr %U "
13808 "salt %u seq_outbound %lu last_seq_inbound %lu "
13809 "replay_window %lu stat_index %u\n",
13810 ntohl (mp->entry.sad_id),
13811 ntohl (mp->sw_if_index),
13812 ntohl (mp->entry.spi),
13813 ntohl (mp->entry.protocol),
13814 ntohl (mp->entry.crypto_algorithm),
13815 format_hex_bytes, mp->entry.crypto_key.data,
13816 mp->entry.crypto_key.length, ntohl (mp->entry.integrity_algorithm),
13817 format_hex_bytes, mp->entry.integrity_key.data,
13818 mp->entry.integrity_key.length, ntohl (mp->entry.flags),
13819 format_vl_api_address, &mp->entry.tunnel_src, format_vl_api_address,
13820 &mp->entry.tunnel_dst, ntohl (mp->salt),
13821 clib_net_to_host_u64 (mp->seq_outbound),
13822 clib_net_to_host_u64 (mp->last_seq_inbound),
13823 clib_net_to_host_u64 (mp->replay_window), ntohl (mp->stat_index));
13826 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
13827 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
13829 static void vl_api_ipsec_sa_details_t_handler_json
13830 (vl_api_ipsec_sa_details_t * mp)
13832 vat_main_t *vam = &vat_main;
13833 vat_json_node_t *node = NULL;
13834 vl_api_ipsec_sad_flags_t flags;
13836 if (VAT_JSON_ARRAY != vam->json_tree.type)
13838 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13839 vat_json_init_array (&vam->json_tree);
13841 node = vat_json_array_add (&vam->json_tree);
13843 vat_json_init_object (node);
13844 vat_json_object_add_uint (node, "sa_id", ntohl (mp->entry.sad_id));
13845 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13846 vat_json_object_add_uint (node, "spi", ntohl (mp->entry.spi));
13847 vat_json_object_add_uint (node, "proto", ntohl (mp->entry.protocol));
13848 vat_json_object_add_uint (node, "crypto_alg",
13849 ntohl (mp->entry.crypto_algorithm));
13850 vat_json_object_add_uint (node, "integ_alg",
13851 ntohl (mp->entry.integrity_algorithm));
13852 flags = ntohl (mp->entry.flags);
13853 vat_json_object_add_uint (node, "use_esn",
13854 ! !(flags & IPSEC_API_SAD_FLAG_USE_ESN));
13855 vat_json_object_add_uint (node, "use_anti_replay",
13856 ! !(flags & IPSEC_API_SAD_FLAG_USE_ANTI_REPLAY));
13857 vat_json_object_add_uint (node, "is_tunnel",
13858 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL));
13859 vat_json_object_add_uint (node, "is_tunnel_ip6",
13860 ! !(flags & IPSEC_API_SAD_FLAG_IS_TUNNEL_V6));
13861 vat_json_object_add_uint (node, "udp_encap",
13862 ! !(flags & IPSEC_API_SAD_FLAG_UDP_ENCAP));
13863 vat_json_object_add_bytes (node, "crypto_key", mp->entry.crypto_key.data,
13864 mp->entry.crypto_key.length);
13865 vat_json_object_add_bytes (node, "integ_key", mp->entry.integrity_key.data,
13866 mp->entry.integrity_key.length);
13867 vat_json_object_add_address (node, "src", &mp->entry.tunnel_src);
13868 vat_json_object_add_address (node, "dst", &mp->entry.tunnel_dst);
13869 vat_json_object_add_uint (node, "replay_window",
13870 clib_net_to_host_u64 (mp->replay_window));
13871 vat_json_object_add_uint (node, "stat_index", ntohl (mp->stat_index));
13875 api_ipsec_sa_dump (vat_main_t * vam)
13877 unformat_input_t *i = vam->input;
13878 vl_api_ipsec_sa_dump_t *mp;
13879 vl_api_control_ping_t *mp_ping;
13883 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13885 if (unformat (i, "sa_id %d", &sa_id))
13889 clib_warning ("parse error '%U'", format_unformat_error, i);
13894 M (IPSEC_SA_DUMP, mp);
13896 mp->sa_id = ntohl (sa_id);
13900 /* Use a control ping for synchronization */
13901 M (CONTROL_PING, mp_ping);
13909 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
13911 unformat_input_t *i = vam->input;
13912 vl_api_ipsec_tunnel_if_set_sa_t *mp;
13913 u32 sw_if_index = ~0;
13915 u8 is_outbound = (u8) ~ 0;
13918 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13920 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13922 else if (unformat (i, "sa_id %d", &sa_id))
13924 else if (unformat (i, "outbound"))
13926 else if (unformat (i, "inbound"))
13930 clib_warning ("parse error '%U'", format_unformat_error, i);
13935 if (sw_if_index == ~0)
13937 errmsg ("interface must be specified");
13943 errmsg ("SA ID must be specified");
13947 M (IPSEC_TUNNEL_IF_SET_SA, mp);
13949 mp->sw_if_index = htonl (sw_if_index);
13950 mp->sa_id = htonl (sa_id);
13951 mp->is_outbound = is_outbound;
13960 api_get_first_msg_id (vat_main_t * vam)
13962 vl_api_get_first_msg_id_t *mp;
13963 unformat_input_t *i = vam->input;
13968 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13970 if (unformat (i, "client %s", &name))
13978 errmsg ("missing client name");
13981 vec_add1 (name, 0);
13983 if (vec_len (name) > 63)
13985 errmsg ("client name too long");
13989 M (GET_FIRST_MSG_ID, mp);
13990 clib_memcpy (mp->name, name, vec_len (name));
13997 api_cop_interface_enable_disable (vat_main_t * vam)
13999 unformat_input_t *line_input = vam->input;
14000 vl_api_cop_interface_enable_disable_t *mp;
14001 u32 sw_if_index = ~0;
14002 u8 enable_disable = 1;
14005 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14007 if (unformat (line_input, "disable"))
14008 enable_disable = 0;
14009 if (unformat (line_input, "enable"))
14010 enable_disable = 1;
14011 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14012 vam, &sw_if_index))
14014 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14020 if (sw_if_index == ~0)
14022 errmsg ("missing interface name or sw_if_index");
14026 /* Construct the API message */
14027 M (COP_INTERFACE_ENABLE_DISABLE, mp);
14028 mp->sw_if_index = ntohl (sw_if_index);
14029 mp->enable_disable = enable_disable;
14033 /* Wait for the reply */
14039 api_cop_whitelist_enable_disable (vat_main_t * vam)
14041 unformat_input_t *line_input = vam->input;
14042 vl_api_cop_whitelist_enable_disable_t *mp;
14043 u32 sw_if_index = ~0;
14044 u8 ip4 = 0, ip6 = 0, default_cop = 0;
14048 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14050 if (unformat (line_input, "ip4"))
14052 else if (unformat (line_input, "ip6"))
14054 else if (unformat (line_input, "default"))
14056 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
14057 vam, &sw_if_index))
14059 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
14061 else if (unformat (line_input, "fib-id %d", &fib_id))
14067 if (sw_if_index == ~0)
14069 errmsg ("missing interface name or sw_if_index");
14073 /* Construct the API message */
14074 M (COP_WHITELIST_ENABLE_DISABLE, mp);
14075 mp->sw_if_index = ntohl (sw_if_index);
14076 mp->fib_id = ntohl (fib_id);
14079 mp->default_cop = default_cop;
14083 /* Wait for the reply */
14089 api_get_node_graph (vat_main_t * vam)
14091 vl_api_get_node_graph_t *mp;
14094 M (GET_NODE_GRAPH, mp);
14098 /* Wait for the reply */
14104 /** Used for parsing LISP eids */
14105 typedef CLIB_PACKED(struct{
14109 lisp_nsh_api_t nsh;
14111 u32 len; /**< prefix length if IP */
14112 u8 type; /**< type of eid */
14117 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
14119 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
14121 clib_memset (a, 0, sizeof (a[0]));
14123 if (unformat (input, "%U/%d", unformat_ip46_address, a->addr.ip, &a->len))
14125 a->type = 0; /* ip prefix type */
14127 else if (unformat (input, "%U", unformat_ethernet_address, a->addr.mac))
14129 a->type = 1; /* mac type */
14131 else if (unformat (input, "%U", unformat_nsh_address, a->addr.nsh))
14133 a->type = 2; /* NSH type */
14134 a->addr.nsh.spi = clib_host_to_net_u32 (a->addr.nsh.spi);
14143 if (ip46_address_is_ip4 (&a->addr.ip))
14144 return a->len > 32 ? 1 : 0;
14146 return a->len > 128 ? 1 : 0;
14153 lisp_eid_put_vat (vl_api_eid_t * eid, const lisp_eid_vat_t * vat_eid)
14155 eid->type = vat_eid->type;
14158 case EID_TYPE_API_PREFIX:
14159 if (ip46_address_is_ip4 (&vat_eid->addr.ip))
14161 clib_memcpy (&eid->address.prefix.address.un.ip4,
14162 &vat_eid->addr.ip.ip4, 4);
14163 eid->address.prefix.address.af = ADDRESS_IP4;
14164 eid->address.prefix.len = vat_eid->len;
14168 clib_memcpy (&eid->address.prefix.address.un.ip6,
14169 &vat_eid->addr.ip.ip6, 16);
14170 eid->address.prefix.address.af = ADDRESS_IP6;
14171 eid->address.prefix.len = vat_eid->len;
14174 case EID_TYPE_API_MAC:
14175 clib_memcpy (&eid->address.mac, &vat_eid->addr.mac,
14176 sizeof (eid->address.mac));
14178 case EID_TYPE_API_NSH:
14179 clib_memcpy (&eid->address.nsh, &vat_eid->addr.nsh,
14180 sizeof (eid->address.nsh));
14189 api_one_add_del_locator_set (vat_main_t * vam)
14191 unformat_input_t *input = vam->input;
14192 vl_api_one_add_del_locator_set_t *mp;
14194 u8 *locator_set_name = NULL;
14195 u8 locator_set_name_set = 0;
14196 vl_api_local_locator_t locator, *locators = 0;
14197 u32 sw_if_index, priority, weight;
14201 /* Parse args required to build the message */
14202 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14204 if (unformat (input, "del"))
14208 else if (unformat (input, "locator-set %s", &locator_set_name))
14210 locator_set_name_set = 1;
14212 else if (unformat (input, "sw_if_index %u p %u w %u",
14213 &sw_if_index, &priority, &weight))
14215 locator.sw_if_index = htonl (sw_if_index);
14216 locator.priority = priority;
14217 locator.weight = weight;
14218 vec_add1 (locators, locator);
14222 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
14223 &sw_if_index, &priority, &weight))
14225 locator.sw_if_index = htonl (sw_if_index);
14226 locator.priority = priority;
14227 locator.weight = weight;
14228 vec_add1 (locators, locator);
14234 if (locator_set_name_set == 0)
14236 errmsg ("missing locator-set name");
14237 vec_free (locators);
14241 if (vec_len (locator_set_name) > 64)
14243 errmsg ("locator-set name too long");
14244 vec_free (locator_set_name);
14245 vec_free (locators);
14248 vec_add1 (locator_set_name, 0);
14250 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
14252 /* Construct the API message */
14253 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
14255 mp->is_add = is_add;
14256 clib_memcpy (mp->locator_set_name, locator_set_name,
14257 vec_len (locator_set_name));
14258 vec_free (locator_set_name);
14260 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
14262 clib_memcpy (mp->locators, locators, data_len);
14263 vec_free (locators);
14268 /* Wait for a reply... */
14273 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
14276 api_one_add_del_locator (vat_main_t * vam)
14278 unformat_input_t *input = vam->input;
14279 vl_api_one_add_del_locator_t *mp;
14280 u32 tmp_if_index = ~0;
14281 u32 sw_if_index = ~0;
14282 u8 sw_if_index_set = 0;
14283 u8 sw_if_index_if_name_set = 0;
14285 u8 priority_set = 0;
14289 u8 *locator_set_name = NULL;
14290 u8 locator_set_name_set = 0;
14293 /* Parse args required to build the message */
14294 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14296 if (unformat (input, "del"))
14300 else if (unformat (input, "locator-set %s", &locator_set_name))
14302 locator_set_name_set = 1;
14304 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
14307 sw_if_index_if_name_set = 1;
14308 sw_if_index = tmp_if_index;
14310 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
14312 sw_if_index_set = 1;
14313 sw_if_index = tmp_if_index;
14315 else if (unformat (input, "p %d", &priority))
14319 else if (unformat (input, "w %d", &weight))
14327 if (locator_set_name_set == 0)
14329 errmsg ("missing locator-set name");
14333 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
14335 errmsg ("missing sw_if_index");
14336 vec_free (locator_set_name);
14340 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
14342 errmsg ("cannot use both params interface name and sw_if_index");
14343 vec_free (locator_set_name);
14347 if (priority_set == 0)
14349 errmsg ("missing locator-set priority");
14350 vec_free (locator_set_name);
14354 if (weight_set == 0)
14356 errmsg ("missing locator-set weight");
14357 vec_free (locator_set_name);
14361 if (vec_len (locator_set_name) > 64)
14363 errmsg ("locator-set name too long");
14364 vec_free (locator_set_name);
14367 vec_add1 (locator_set_name, 0);
14369 /* Construct the API message */
14370 M (ONE_ADD_DEL_LOCATOR, mp);
14372 mp->is_add = is_add;
14373 mp->sw_if_index = ntohl (sw_if_index);
14374 mp->priority = priority;
14375 mp->weight = weight;
14376 clib_memcpy (mp->locator_set_name, locator_set_name,
14377 vec_len (locator_set_name));
14378 vec_free (locator_set_name);
14383 /* Wait for a reply... */
14388 #define api_lisp_add_del_locator api_one_add_del_locator
14391 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
14393 u32 *key_id = va_arg (*args, u32 *);
14396 if (unformat (input, "%s", &s))
14398 if (!strcmp ((char *) s, "sha1"))
14399 key_id[0] = HMAC_SHA_1_96;
14400 else if (!strcmp ((char *) s, "sha256"))
14401 key_id[0] = HMAC_SHA_256_128;
14404 clib_warning ("invalid key_id: '%s'", s);
14405 key_id[0] = HMAC_NO_KEY;
14416 api_one_add_del_local_eid (vat_main_t * vam)
14418 unformat_input_t *input = vam->input;
14419 vl_api_one_add_del_local_eid_t *mp;
14422 lisp_eid_vat_t _eid, *eid = &_eid;
14423 u8 *locator_set_name = 0;
14424 u8 locator_set_name_set = 0;
14430 /* Parse args required to build the message */
14431 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14433 if (unformat (input, "del"))
14437 else if (unformat (input, "vni %d", &vni))
14441 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
14445 else if (unformat (input, "locator-set %s", &locator_set_name))
14447 locator_set_name_set = 1;
14449 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
14451 else if (unformat (input, "secret-key %_%v%_", &key))
14457 if (locator_set_name_set == 0)
14459 errmsg ("missing locator-set name");
14465 errmsg ("EID address not set!");
14466 vec_free (locator_set_name);
14470 if (key && (0 == key_id))
14472 errmsg ("invalid key_id!");
14476 if (vec_len (key) > 64)
14478 errmsg ("key too long");
14483 if (vec_len (locator_set_name) > 64)
14485 errmsg ("locator-set name too long");
14486 vec_free (locator_set_name);
14489 vec_add1 (locator_set_name, 0);
14491 /* Construct the API message */
14492 M (ONE_ADD_DEL_LOCAL_EID, mp);
14494 mp->is_add = is_add;
14495 lisp_eid_put_vat (&mp->eid, eid);
14496 mp->vni = clib_host_to_net_u32 (vni);
14497 mp->key.id = key_id;
14498 clib_memcpy (mp->locator_set_name, locator_set_name,
14499 vec_len (locator_set_name));
14500 clib_memcpy (mp->key.key, key, vec_len (key));
14502 vec_free (locator_set_name);
14508 /* Wait for a reply... */
14513 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
14516 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
14518 u32 dp_table = 0, vni = 0;;
14519 unformat_input_t *input = vam->input;
14520 vl_api_gpe_add_del_fwd_entry_t *mp;
14522 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
14523 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
14524 u8 rmt_eid_set = 0, lcl_eid_set = 0;
14525 u32 action = ~0, w;
14526 ip4_address_t rmt_rloc4, lcl_rloc4;
14527 ip6_address_t rmt_rloc6, lcl_rloc6;
14528 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
14531 clib_memset (&rloc, 0, sizeof (rloc));
14533 /* Parse args required to build the message */
14534 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14536 if (unformat (input, "del"))
14538 else if (unformat (input, "add"))
14540 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
14544 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
14548 else if (unformat (input, "vrf %d", &dp_table))
14550 else if (unformat (input, "bd %d", &dp_table))
14552 else if (unformat (input, "vni %d", &vni))
14554 else if (unformat (input, "w %d", &w))
14558 errmsg ("No RLOC configured for setting priority/weight!");
14561 curr_rloc->weight = w;
14563 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
14564 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
14567 clib_memcpy (&rloc.addr.un.ip4, &lcl_rloc4, sizeof (lcl_rloc4));
14569 vec_add1 (lcl_locs, rloc);
14571 clib_memcpy (&rloc.addr.un.ip4, &rmt_rloc4, sizeof (rmt_rloc4));
14572 vec_add1 (rmt_locs, rloc);
14573 /* weight saved in rmt loc */
14574 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14576 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
14577 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
14580 clib_memcpy (&rloc.addr.un.ip6, &lcl_rloc6, sizeof (lcl_rloc6));
14582 vec_add1 (lcl_locs, rloc);
14584 clib_memcpy (&rloc.addr.un.ip6, &rmt_rloc6, sizeof (rmt_rloc6));
14585 vec_add1 (rmt_locs, rloc);
14586 /* weight saved in rmt loc */
14587 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
14589 else if (unformat (input, "action %d", &action))
14595 clib_warning ("parse error '%U'", format_unformat_error, input);
14602 errmsg ("remote eid addresses not set");
14606 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
14608 errmsg ("eid types don't match");
14612 if (0 == rmt_locs && (u32) ~ 0 == action)
14614 errmsg ("action not set for negative mapping");
14618 /* Construct the API message */
14619 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
14620 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
14622 mp->is_add = is_add;
14623 lisp_eid_put_vat (&mp->rmt_eid, rmt_eid);
14624 lisp_eid_put_vat (&mp->lcl_eid, lcl_eid);
14625 mp->dp_table = clib_host_to_net_u32 (dp_table);
14626 mp->vni = clib_host_to_net_u32 (vni);
14627 mp->action = action;
14629 if (0 != rmt_locs && 0 != lcl_locs)
14631 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
14632 clib_memcpy (mp->locs, lcl_locs,
14633 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
14635 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
14636 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
14637 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
14639 vec_free (lcl_locs);
14640 vec_free (rmt_locs);
14645 /* Wait for a reply... */
14651 api_one_add_del_map_server (vat_main_t * vam)
14653 unformat_input_t *input = vam->input;
14654 vl_api_one_add_del_map_server_t *mp;
14658 ip4_address_t ipv4;
14659 ip6_address_t ipv6;
14662 /* Parse args required to build the message */
14663 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14665 if (unformat (input, "del"))
14669 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14673 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14681 if (ipv4_set && ipv6_set)
14683 errmsg ("both eid v4 and v6 addresses set");
14687 if (!ipv4_set && !ipv6_set)
14689 errmsg ("eid addresses not set");
14693 /* Construct the API message */
14694 M (ONE_ADD_DEL_MAP_SERVER, mp);
14696 mp->is_add = is_add;
14699 mp->ip_address.af = 1;
14700 clib_memcpy (mp->ip_address.un.ip6, &ipv6, sizeof (ipv6));
14704 mp->ip_address.af = 0;
14705 clib_memcpy (mp->ip_address.un.ip4, &ipv4, sizeof (ipv4));
14711 /* Wait for a reply... */
14716 #define api_lisp_add_del_map_server api_one_add_del_map_server
14719 api_one_add_del_map_resolver (vat_main_t * vam)
14721 unformat_input_t *input = vam->input;
14722 vl_api_one_add_del_map_resolver_t *mp;
14726 ip4_address_t ipv4;
14727 ip6_address_t ipv6;
14730 /* Parse args required to build the message */
14731 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14733 if (unformat (input, "del"))
14737 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14741 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14749 if (ipv4_set && ipv6_set)
14751 errmsg ("both eid v4 and v6 addresses set");
14755 if (!ipv4_set && !ipv6_set)
14757 errmsg ("eid addresses not set");
14761 /* Construct the API message */
14762 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
14764 mp->is_add = is_add;
14767 mp->ip_address.af = 1;
14768 clib_memcpy (mp->ip_address.un.ip6, &ipv6, sizeof (ipv6));
14772 mp->ip_address.af = 0;
14773 clib_memcpy (mp->ip_address.un.ip6, &ipv4, sizeof (ipv4));
14779 /* Wait for a reply... */
14784 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
14787 api_lisp_gpe_enable_disable (vat_main_t * vam)
14789 unformat_input_t *input = vam->input;
14790 vl_api_gpe_enable_disable_t *mp;
14795 /* Parse args required to build the message */
14796 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14798 if (unformat (input, "enable"))
14803 else if (unformat (input, "disable"))
14814 errmsg ("Value not set");
14818 /* Construct the API message */
14819 M (GPE_ENABLE_DISABLE, mp);
14821 mp->is_enable = is_enable;
14826 /* Wait for a reply... */
14832 api_one_rloc_probe_enable_disable (vat_main_t * vam)
14834 unformat_input_t *input = vam->input;
14835 vl_api_one_rloc_probe_enable_disable_t *mp;
14840 /* Parse args required to build the message */
14841 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14843 if (unformat (input, "enable"))
14848 else if (unformat (input, "disable"))
14856 errmsg ("Value not set");
14860 /* Construct the API message */
14861 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
14863 mp->is_enable = is_enable;
14868 /* Wait for a reply... */
14873 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
14876 api_one_map_register_enable_disable (vat_main_t * vam)
14878 unformat_input_t *input = vam->input;
14879 vl_api_one_map_register_enable_disable_t *mp;
14884 /* Parse args required to build the message */
14885 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14887 if (unformat (input, "enable"))
14892 else if (unformat (input, "disable"))
14900 errmsg ("Value not set");
14904 /* Construct the API message */
14905 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
14907 mp->is_enable = is_enable;
14912 /* Wait for a reply... */
14917 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
14920 api_one_enable_disable (vat_main_t * vam)
14922 unformat_input_t *input = vam->input;
14923 vl_api_one_enable_disable_t *mp;
14928 /* Parse args required to build the message */
14929 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14931 if (unformat (input, "enable"))
14936 else if (unformat (input, "disable"))
14946 errmsg ("Value not set");
14950 /* Construct the API message */
14951 M (ONE_ENABLE_DISABLE, mp);
14953 mp->is_enable = is_enable;
14958 /* Wait for a reply... */
14963 #define api_lisp_enable_disable api_one_enable_disable
14966 api_one_enable_disable_xtr_mode (vat_main_t * vam)
14968 unformat_input_t *input = vam->input;
14969 vl_api_one_enable_disable_xtr_mode_t *mp;
14974 /* Parse args required to build the message */
14975 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14977 if (unformat (input, "enable"))
14982 else if (unformat (input, "disable"))
14992 errmsg ("Value not set");
14996 /* Construct the API message */
14997 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
14999 mp->is_enable = is_enable;
15004 /* Wait for a reply... */
15010 api_one_show_xtr_mode (vat_main_t * vam)
15012 vl_api_one_show_xtr_mode_t *mp;
15015 /* Construct the API message */
15016 M (ONE_SHOW_XTR_MODE, mp);
15021 /* Wait for a reply... */
15027 api_one_enable_disable_pitr_mode (vat_main_t * vam)
15029 unformat_input_t *input = vam->input;
15030 vl_api_one_enable_disable_pitr_mode_t *mp;
15035 /* Parse args required to build the message */
15036 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15038 if (unformat (input, "enable"))
15043 else if (unformat (input, "disable"))
15053 errmsg ("Value not set");
15057 /* Construct the API message */
15058 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
15060 mp->is_enable = is_enable;
15065 /* Wait for a reply... */
15071 api_one_show_pitr_mode (vat_main_t * vam)
15073 vl_api_one_show_pitr_mode_t *mp;
15076 /* Construct the API message */
15077 M (ONE_SHOW_PITR_MODE, mp);
15082 /* Wait for a reply... */
15088 api_one_enable_disable_petr_mode (vat_main_t * vam)
15090 unformat_input_t *input = vam->input;
15091 vl_api_one_enable_disable_petr_mode_t *mp;
15096 /* Parse args required to build the message */
15097 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15099 if (unformat (input, "enable"))
15104 else if (unformat (input, "disable"))
15114 errmsg ("Value not set");
15118 /* Construct the API message */
15119 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
15121 mp->is_enable = is_enable;
15126 /* Wait for a reply... */
15132 api_one_show_petr_mode (vat_main_t * vam)
15134 vl_api_one_show_petr_mode_t *mp;
15137 /* Construct the API message */
15138 M (ONE_SHOW_PETR_MODE, mp);
15143 /* Wait for a reply... */
15149 api_show_one_map_register_state (vat_main_t * vam)
15151 vl_api_show_one_map_register_state_t *mp;
15154 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
15159 /* wait for reply */
15164 #define api_show_lisp_map_register_state api_show_one_map_register_state
15167 api_show_one_rloc_probe_state (vat_main_t * vam)
15169 vl_api_show_one_rloc_probe_state_t *mp;
15172 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
15177 /* wait for reply */
15182 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
15185 api_one_add_del_ndp_entry (vat_main_t * vam)
15187 vl_api_one_add_del_ndp_entry_t *mp;
15188 unformat_input_t *input = vam->input;
15193 u8 mac[6] = { 0, };
15194 u8 ip6[16] = { 0, };
15198 /* Parse args required to build the message */
15199 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15201 if (unformat (input, "del"))
15203 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
15205 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
15207 else if (unformat (input, "bd %d", &bd))
15211 errmsg ("parse error '%U'", format_unformat_error, input);
15216 if (!bd_set || !ip_set || (!mac_set && is_add))
15218 errmsg ("Missing BD, IP or MAC!");
15222 M (ONE_ADD_DEL_NDP_ENTRY, mp);
15223 mp->is_add = is_add;
15224 clib_memcpy (&mp->entry.mac, mac, 6);
15225 mp->bd = clib_host_to_net_u32 (bd);
15226 clib_memcpy (&mp->entry.ip6, ip6, sizeof (mp->entry.ip6));
15231 /* wait for reply */
15237 api_one_add_del_l2_arp_entry (vat_main_t * vam)
15239 vl_api_one_add_del_l2_arp_entry_t *mp;
15240 unformat_input_t *input = vam->input;
15245 u8 mac[6] = { 0, };
15246 u32 ip4 = 0, bd = ~0;
15249 /* Parse args required to build the message */
15250 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15252 if (unformat (input, "del"))
15254 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
15256 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
15258 else if (unformat (input, "bd %d", &bd))
15262 errmsg ("parse error '%U'", format_unformat_error, input);
15267 if (!bd_set || !ip_set || (!mac_set && is_add))
15269 errmsg ("Missing BD, IP or MAC!");
15273 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
15274 mp->is_add = is_add;
15275 clib_memcpy (&mp->entry.mac, mac, 6);
15276 mp->bd = clib_host_to_net_u32 (bd);
15277 clib_memcpy (mp->entry.ip4, &ip4, sizeof (mp->entry.ip4));
15282 /* wait for reply */
15288 api_one_ndp_bd_get (vat_main_t * vam)
15290 vl_api_one_ndp_bd_get_t *mp;
15293 M (ONE_NDP_BD_GET, mp);
15298 /* wait for reply */
15304 api_one_ndp_entries_get (vat_main_t * vam)
15306 vl_api_one_ndp_entries_get_t *mp;
15307 unformat_input_t *input = vam->input;
15312 /* Parse args required to build the message */
15313 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15315 if (unformat (input, "bd %d", &bd))
15319 errmsg ("parse error '%U'", format_unformat_error, input);
15326 errmsg ("Expected bridge domain!");
15330 M (ONE_NDP_ENTRIES_GET, mp);
15331 mp->bd = clib_host_to_net_u32 (bd);
15336 /* wait for reply */
15342 api_one_l2_arp_bd_get (vat_main_t * vam)
15344 vl_api_one_l2_arp_bd_get_t *mp;
15347 M (ONE_L2_ARP_BD_GET, mp);
15352 /* wait for reply */
15358 api_one_l2_arp_entries_get (vat_main_t * vam)
15360 vl_api_one_l2_arp_entries_get_t *mp;
15361 unformat_input_t *input = vam->input;
15366 /* Parse args required to build the message */
15367 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15369 if (unformat (input, "bd %d", &bd))
15373 errmsg ("parse error '%U'", format_unformat_error, input);
15380 errmsg ("Expected bridge domain!");
15384 M (ONE_L2_ARP_ENTRIES_GET, mp);
15385 mp->bd = clib_host_to_net_u32 (bd);
15390 /* wait for reply */
15396 api_one_stats_enable_disable (vat_main_t * vam)
15398 vl_api_one_stats_enable_disable_t *mp;
15399 unformat_input_t *input = vam->input;
15404 /* Parse args required to build the message */
15405 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15407 if (unformat (input, "enable"))
15412 else if (unformat (input, "disable"))
15422 errmsg ("Value not set");
15426 M (ONE_STATS_ENABLE_DISABLE, mp);
15427 mp->is_enable = is_enable;
15432 /* wait for reply */
15438 api_show_one_stats_enable_disable (vat_main_t * vam)
15440 vl_api_show_one_stats_enable_disable_t *mp;
15443 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
15448 /* wait for reply */
15454 api_show_one_map_request_mode (vat_main_t * vam)
15456 vl_api_show_one_map_request_mode_t *mp;
15459 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
15464 /* wait for reply */
15469 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
15472 api_one_map_request_mode (vat_main_t * vam)
15474 unformat_input_t *input = vam->input;
15475 vl_api_one_map_request_mode_t *mp;
15479 /* Parse args required to build the message */
15480 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15482 if (unformat (input, "dst-only"))
15484 else if (unformat (input, "src-dst"))
15488 errmsg ("parse error '%U'", format_unformat_error, input);
15493 M (ONE_MAP_REQUEST_MODE, mp);
15500 /* wait for reply */
15505 #define api_lisp_map_request_mode api_one_map_request_mode
15508 * Enable/disable ONE proxy ITR.
15510 * @param vam vpp API test context
15511 * @return return code
15514 api_one_pitr_set_locator_set (vat_main_t * vam)
15516 u8 ls_name_set = 0;
15517 unformat_input_t *input = vam->input;
15518 vl_api_one_pitr_set_locator_set_t *mp;
15523 /* Parse args required to build the message */
15524 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15526 if (unformat (input, "del"))
15528 else if (unformat (input, "locator-set %s", &ls_name))
15532 errmsg ("parse error '%U'", format_unformat_error, input);
15539 errmsg ("locator-set name not set!");
15543 M (ONE_PITR_SET_LOCATOR_SET, mp);
15545 mp->is_add = is_add;
15546 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
15547 vec_free (ls_name);
15552 /* wait for reply */
15557 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
15560 api_one_nsh_set_locator_set (vat_main_t * vam)
15562 u8 ls_name_set = 0;
15563 unformat_input_t *input = vam->input;
15564 vl_api_one_nsh_set_locator_set_t *mp;
15569 /* Parse args required to build the message */
15570 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15572 if (unformat (input, "del"))
15574 else if (unformat (input, "ls %s", &ls_name))
15578 errmsg ("parse error '%U'", format_unformat_error, input);
15583 if (!ls_name_set && is_add)
15585 errmsg ("locator-set name not set!");
15589 M (ONE_NSH_SET_LOCATOR_SET, mp);
15591 mp->is_add = is_add;
15592 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
15593 vec_free (ls_name);
15598 /* wait for reply */
15604 api_show_one_pitr (vat_main_t * vam)
15606 vl_api_show_one_pitr_t *mp;
15609 if (!vam->json_output)
15611 print (vam->ofp, "%=20s", "lisp status:");
15614 M (SHOW_ONE_PITR, mp);
15618 /* Wait for a reply... */
15623 #define api_show_lisp_pitr api_show_one_pitr
15626 api_one_use_petr (vat_main_t * vam)
15628 unformat_input_t *input = vam->input;
15629 vl_api_one_use_petr_t *mp;
15634 clib_memset (&ip, 0, sizeof (ip));
15636 /* Parse args required to build the message */
15637 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15639 if (unformat (input, "disable"))
15642 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
15645 ip_addr_version (&ip) = AF_IP4;
15648 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
15651 ip_addr_version (&ip) = AF_IP6;
15655 errmsg ("parse error '%U'", format_unformat_error, input);
15660 M (ONE_USE_PETR, mp);
15662 mp->is_add = is_add;
15665 mp->ip_address.af = ip_addr_version (&ip) == AF_IP4 ? 0 : 1;
15666 if (mp->ip_address.af)
15667 clib_memcpy (mp->ip_address.un.ip6, &ip, 16);
15669 clib_memcpy (mp->ip_address.un.ip4, &ip, 4);
15675 /* wait for reply */
15680 #define api_lisp_use_petr api_one_use_petr
15683 api_show_one_nsh_mapping (vat_main_t * vam)
15685 vl_api_show_one_use_petr_t *mp;
15688 if (!vam->json_output)
15690 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
15693 M (SHOW_ONE_NSH_MAPPING, mp);
15697 /* Wait for a reply... */
15703 api_show_one_use_petr (vat_main_t * vam)
15705 vl_api_show_one_use_petr_t *mp;
15708 if (!vam->json_output)
15710 print (vam->ofp, "%=20s", "Proxy-ETR status:");
15713 M (SHOW_ONE_USE_PETR, mp);
15717 /* Wait for a reply... */
15722 #define api_show_lisp_use_petr api_show_one_use_petr
15725 * Add/delete mapping between vni and vrf
15728 api_one_eid_table_add_del_map (vat_main_t * vam)
15730 unformat_input_t *input = vam->input;
15731 vl_api_one_eid_table_add_del_map_t *mp;
15732 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
15733 u32 vni, vrf, bd_index;
15736 /* Parse args required to build the message */
15737 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15739 if (unformat (input, "del"))
15741 else if (unformat (input, "vrf %d", &vrf))
15743 else if (unformat (input, "bd_index %d", &bd_index))
15745 else if (unformat (input, "vni %d", &vni))
15751 if (!vni_set || (!vrf_set && !bd_index_set))
15753 errmsg ("missing arguments!");
15757 if (vrf_set && bd_index_set)
15759 errmsg ("error: both vrf and bd entered!");
15763 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
15765 mp->is_add = is_add;
15766 mp->vni = htonl (vni);
15767 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
15768 mp->is_l2 = bd_index_set;
15773 /* wait for reply */
15778 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
15781 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
15783 u32 *action = va_arg (*args, u32 *);
15786 if (unformat (input, "%s", &s))
15788 if (!strcmp ((char *) s, "no-action"))
15790 else if (!strcmp ((char *) s, "natively-forward"))
15792 else if (!strcmp ((char *) s, "send-map-request"))
15794 else if (!strcmp ((char *) s, "drop"))
15798 clib_warning ("invalid action: '%s'", s);
15810 * Add/del remote mapping to/from ONE control plane
15812 * @param vam vpp API test context
15813 * @return return code
15816 api_one_add_del_remote_mapping (vat_main_t * vam)
15818 unformat_input_t *input = vam->input;
15819 vl_api_one_add_del_remote_mapping_t *mp;
15821 lisp_eid_vat_t _eid, *eid = &_eid;
15822 lisp_eid_vat_t _seid, *seid = &_seid;
15823 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
15824 u32 action = ~0, p, w, data_len;
15825 ip4_address_t rloc4;
15826 ip6_address_t rloc6;
15827 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
15830 clib_memset (&rloc, 0, sizeof (rloc));
15832 /* Parse args required to build the message */
15833 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15835 if (unformat (input, "del-all"))
15839 else if (unformat (input, "del"))
15843 else if (unformat (input, "add"))
15847 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
15851 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
15855 else if (unformat (input, "vni %d", &vni))
15859 else if (unformat (input, "p %d w %d", &p, &w))
15863 errmsg ("No RLOC configured for setting priority/weight!");
15866 curr_rloc->priority = p;
15867 curr_rloc->weight = w;
15869 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
15871 rloc.ip_address.af = 0;
15872 clib_memcpy (&rloc.ip_address.un.ip6, &rloc6, sizeof (rloc6));
15873 vec_add1 (rlocs, rloc);
15874 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15876 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
15878 rloc.ip_address.af = 1;
15879 clib_memcpy (&rloc.ip_address.un.ip4, &rloc4, sizeof (rloc4));
15880 vec_add1 (rlocs, rloc);
15881 curr_rloc = &rlocs[vec_len (rlocs) - 1];
15883 else if (unformat (input, "action %U",
15884 unformat_negative_mapping_action, &action))
15890 clib_warning ("parse error '%U'", format_unformat_error, input);
15897 errmsg ("missing params!");
15901 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
15903 errmsg ("no action set for negative map-reply!");
15907 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
15909 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
15910 mp->is_add = is_add;
15911 mp->vni = htonl (vni);
15912 mp->action = (u8) action;
15913 mp->is_src_dst = seid_set;
15914 mp->del_all = del_all;
15915 lisp_eid_put_vat (&mp->deid, eid);
15916 lisp_eid_put_vat (&mp->seid, seid);
15918 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
15919 clib_memcpy (mp->rlocs, rlocs, data_len);
15925 /* Wait for a reply... */
15930 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
15933 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
15934 * forwarding entries in data-plane accordingly.
15936 * @param vam vpp API test context
15937 * @return return code
15940 api_one_add_del_adjacency (vat_main_t * vam)
15942 unformat_input_t *input = vam->input;
15943 vl_api_one_add_del_adjacency_t *mp;
15947 lisp_eid_vat_t leid, reid;
15949 leid.type = reid.type = (u8) ~ 0;
15951 /* Parse args required to build the message */
15952 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15954 if (unformat (input, "del"))
15958 else if (unformat (input, "add"))
15962 else if (unformat (input, "reid %U/%d", unformat_ip46_address,
15963 &reid.addr.ip, &reid.len))
15965 reid.type = 0; /* ipv4 */
15967 else if (unformat (input, "reid %U", unformat_ethernet_address,
15970 reid.type = 1; /* mac */
15972 else if (unformat (input, "leid %U/%d", unformat_ip46_address,
15973 &leid.addr.ip, &leid.len))
15975 leid.type = 0; /* ipv4 */
15977 else if (unformat (input, "leid %U", unformat_ethernet_address,
15980 leid.type = 1; /* mac */
15982 else if (unformat (input, "vni %d", &vni))
15988 errmsg ("parse error '%U'", format_unformat_error, input);
15993 if ((u8) ~ 0 == reid.type)
15995 errmsg ("missing params!");
15999 if (leid.type != reid.type)
16001 errmsg ("remote and local EIDs are of different types!");
16005 M (ONE_ADD_DEL_ADJACENCY, mp);
16006 mp->is_add = is_add;
16007 mp->vni = htonl (vni);
16008 lisp_eid_put_vat (&mp->leid, &leid);
16009 lisp_eid_put_vat (&mp->reid, &reid);
16014 /* Wait for a reply... */
16019 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
16022 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
16024 u32 *mode = va_arg (*args, u32 *);
16026 if (unformat (input, "lisp"))
16028 else if (unformat (input, "vxlan"))
16037 api_gpe_get_encap_mode (vat_main_t * vam)
16039 vl_api_gpe_get_encap_mode_t *mp;
16042 /* Construct the API message */
16043 M (GPE_GET_ENCAP_MODE, mp);
16048 /* Wait for a reply... */
16054 api_gpe_set_encap_mode (vat_main_t * vam)
16056 unformat_input_t *input = vam->input;
16057 vl_api_gpe_set_encap_mode_t *mp;
16061 /* Parse args required to build the message */
16062 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16064 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
16070 /* Construct the API message */
16071 M (GPE_SET_ENCAP_MODE, mp);
16073 mp->is_vxlan = mode;
16078 /* Wait for a reply... */
16084 api_lisp_gpe_add_del_iface (vat_main_t * vam)
16086 unformat_input_t *input = vam->input;
16087 vl_api_gpe_add_del_iface_t *mp;
16088 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
16089 u32 dp_table = 0, vni = 0;
16092 /* Parse args required to build the message */
16093 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16095 if (unformat (input, "up"))
16100 else if (unformat (input, "down"))
16105 else if (unformat (input, "table_id %d", &dp_table))
16109 else if (unformat (input, "bd_id %d", &dp_table))
16114 else if (unformat (input, "vni %d", &vni))
16122 if (action_set == 0)
16124 errmsg ("Action not set");
16127 if (dp_table_set == 0 || vni_set == 0)
16129 errmsg ("vni and dp_table must be set");
16133 /* Construct the API message */
16134 M (GPE_ADD_DEL_IFACE, mp);
16136 mp->is_add = is_add;
16137 mp->dp_table = clib_host_to_net_u32 (dp_table);
16139 mp->vni = clib_host_to_net_u32 (vni);
16144 /* Wait for a reply... */
16150 api_one_map_register_fallback_threshold (vat_main_t * vam)
16152 unformat_input_t *input = vam->input;
16153 vl_api_one_map_register_fallback_threshold_t *mp;
16158 /* Parse args required to build the message */
16159 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16161 if (unformat (input, "%u", &value))
16165 clib_warning ("parse error '%U'", format_unformat_error, input);
16172 errmsg ("fallback threshold value is missing!");
16176 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
16177 mp->value = clib_host_to_net_u32 (value);
16182 /* Wait for a reply... */
16188 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
16190 vl_api_show_one_map_register_fallback_threshold_t *mp;
16193 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
16198 /* Wait for a reply... */
16204 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
16206 u32 *proto = va_arg (*args, u32 *);
16208 if (unformat (input, "udp"))
16210 else if (unformat (input, "api"))
16219 api_one_set_transport_protocol (vat_main_t * vam)
16221 unformat_input_t *input = vam->input;
16222 vl_api_one_set_transport_protocol_t *mp;
16227 /* Parse args required to build the message */
16228 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16230 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
16234 clib_warning ("parse error '%U'", format_unformat_error, input);
16241 errmsg ("Transport protocol missing!");
16245 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
16246 mp->protocol = (u8) protocol;
16251 /* Wait for a reply... */
16257 api_one_get_transport_protocol (vat_main_t * vam)
16259 vl_api_one_get_transport_protocol_t *mp;
16262 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
16267 /* Wait for a reply... */
16273 api_one_map_register_set_ttl (vat_main_t * vam)
16275 unformat_input_t *input = vam->input;
16276 vl_api_one_map_register_set_ttl_t *mp;
16281 /* Parse args required to build the message */
16282 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16284 if (unformat (input, "%u", &ttl))
16288 clib_warning ("parse error '%U'", format_unformat_error, input);
16295 errmsg ("TTL value missing!");
16299 M (ONE_MAP_REGISTER_SET_TTL, mp);
16300 mp->ttl = clib_host_to_net_u32 (ttl);
16305 /* Wait for a reply... */
16311 api_show_one_map_register_ttl (vat_main_t * vam)
16313 vl_api_show_one_map_register_ttl_t *mp;
16316 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
16321 /* Wait for a reply... */
16327 * Add/del map request itr rlocs from ONE control plane and updates
16329 * @param vam vpp API test context
16330 * @return return code
16333 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
16335 unformat_input_t *input = vam->input;
16336 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
16337 u8 *locator_set_name = 0;
16338 u8 locator_set_name_set = 0;
16342 /* Parse args required to build the message */
16343 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16345 if (unformat (input, "del"))
16349 else if (unformat (input, "%_%v%_", &locator_set_name))
16351 locator_set_name_set = 1;
16355 clib_warning ("parse error '%U'", format_unformat_error, input);
16360 if (is_add && !locator_set_name_set)
16362 errmsg ("itr-rloc is not set!");
16366 if (is_add && vec_len (locator_set_name) > 64)
16368 errmsg ("itr-rloc locator-set name too long");
16369 vec_free (locator_set_name);
16373 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
16374 mp->is_add = is_add;
16377 clib_memcpy (mp->locator_set_name, locator_set_name,
16378 vec_len (locator_set_name));
16382 clib_memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
16384 vec_free (locator_set_name);
16389 /* Wait for a reply... */
16394 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
16397 api_one_locator_dump (vat_main_t * vam)
16399 unformat_input_t *input = vam->input;
16400 vl_api_one_locator_dump_t *mp;
16401 vl_api_control_ping_t *mp_ping;
16402 u8 is_index_set = 0, is_name_set = 0;
16407 /* Parse args required to build the message */
16408 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16410 if (unformat (input, "ls_name %_%v%_", &ls_name))
16414 else if (unformat (input, "ls_index %d", &ls_index))
16420 errmsg ("parse error '%U'", format_unformat_error, input);
16425 if (!is_index_set && !is_name_set)
16427 errmsg ("error: expected one of index or name!");
16431 if (is_index_set && is_name_set)
16433 errmsg ("error: only one param expected!");
16437 if (vec_len (ls_name) > 62)
16439 errmsg ("error: locator set name too long!");
16443 if (!vam->json_output)
16445 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
16448 M (ONE_LOCATOR_DUMP, mp);
16449 mp->is_index_set = is_index_set;
16452 mp->ls_index = clib_host_to_net_u32 (ls_index);
16455 vec_add1 (ls_name, 0);
16456 strncpy ((char *) mp->ls_name, (char *) ls_name,
16457 sizeof (mp->ls_name) - 1);
16463 /* Use a control ping for synchronization */
16464 MPING (CONTROL_PING, mp_ping);
16467 /* Wait for a reply... */
16472 #define api_lisp_locator_dump api_one_locator_dump
16475 api_one_locator_set_dump (vat_main_t * vam)
16477 vl_api_one_locator_set_dump_t *mp;
16478 vl_api_control_ping_t *mp_ping;
16479 unformat_input_t *input = vam->input;
16483 /* Parse args required to build the message */
16484 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16486 if (unformat (input, "local"))
16490 else if (unformat (input, "remote"))
16496 errmsg ("parse error '%U'", format_unformat_error, input);
16501 if (!vam->json_output)
16503 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
16506 M (ONE_LOCATOR_SET_DUMP, mp);
16508 mp->filter = filter;
16513 /* Use a control ping for synchronization */
16514 MPING (CONTROL_PING, mp_ping);
16517 /* Wait for a reply... */
16522 #define api_lisp_locator_set_dump api_one_locator_set_dump
16525 api_one_eid_table_map_dump (vat_main_t * vam)
16529 unformat_input_t *input = vam->input;
16530 vl_api_one_eid_table_map_dump_t *mp;
16531 vl_api_control_ping_t *mp_ping;
16534 /* Parse args required to build the message */
16535 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16537 if (unformat (input, "l2"))
16542 else if (unformat (input, "l3"))
16549 errmsg ("parse error '%U'", format_unformat_error, input);
16556 errmsg ("expected one of 'l2' or 'l3' parameter!");
16560 if (!vam->json_output)
16562 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
16565 M (ONE_EID_TABLE_MAP_DUMP, mp);
16571 /* Use a control ping for synchronization */
16572 MPING (CONTROL_PING, mp_ping);
16575 /* Wait for a reply... */
16580 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
16583 api_one_eid_table_vni_dump (vat_main_t * vam)
16585 vl_api_one_eid_table_vni_dump_t *mp;
16586 vl_api_control_ping_t *mp_ping;
16589 if (!vam->json_output)
16591 print (vam->ofp, "VNI");
16594 M (ONE_EID_TABLE_VNI_DUMP, mp);
16599 /* Use a control ping for synchronization */
16600 MPING (CONTROL_PING, mp_ping);
16603 /* Wait for a reply... */
16608 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
16611 api_one_eid_table_dump (vat_main_t * vam)
16613 unformat_input_t *i = vam->input;
16614 vl_api_one_eid_table_dump_t *mp;
16615 vl_api_control_ping_t *mp_ping;
16619 lisp_eid_vat_t eid;
16622 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16625 (i, "eid %U/%d", unformat_ip46_address, &eid.addr.ip, &eid.len))
16631 if (unformat (i, "eid %U", unformat_ethernet_address, &eid.addr.mac))
16636 else if (unformat (i, "eid %U", unformat_nsh_address, &eid.addr.nsh))
16641 else if (unformat (i, "vni %d", &t))
16645 else if (unformat (i, "local"))
16649 else if (unformat (i, "remote"))
16655 errmsg ("parse error '%U'", format_unformat_error, i);
16660 if (!vam->json_output)
16662 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
16663 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
16666 M (ONE_EID_TABLE_DUMP, mp);
16668 mp->filter = filter;
16672 mp->vni = htonl (vni);
16673 lisp_eid_put_vat (&mp->eid, &eid);
16679 /* Use a control ping for synchronization */
16680 MPING (CONTROL_PING, mp_ping);
16683 /* Wait for a reply... */
16688 #define api_lisp_eid_table_dump api_one_eid_table_dump
16691 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
16693 unformat_input_t *i = vam->input;
16694 vl_api_gpe_fwd_entries_get_t *mp;
16699 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16701 if (unformat (i, "vni %d", &vni))
16707 errmsg ("parse error '%U'", format_unformat_error, i);
16714 errmsg ("vni not set!");
16718 if (!vam->json_output)
16720 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
16724 M (GPE_FWD_ENTRIES_GET, mp);
16725 mp->vni = clib_host_to_net_u32 (vni);
16730 /* Wait for a reply... */
16735 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
16736 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
16737 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
16738 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
16739 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
16740 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
16741 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
16742 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
16745 api_one_adjacencies_get (vat_main_t * vam)
16747 unformat_input_t *i = vam->input;
16748 vl_api_one_adjacencies_get_t *mp;
16753 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16755 if (unformat (i, "vni %d", &vni))
16761 errmsg ("parse error '%U'", format_unformat_error, i);
16768 errmsg ("vni not set!");
16772 if (!vam->json_output)
16774 print (vam->ofp, "%s %40s", "leid", "reid");
16777 M (ONE_ADJACENCIES_GET, mp);
16778 mp->vni = clib_host_to_net_u32 (vni);
16783 /* Wait for a reply... */
16788 #define api_lisp_adjacencies_get api_one_adjacencies_get
16791 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
16793 unformat_input_t *i = vam->input;
16794 vl_api_gpe_native_fwd_rpaths_get_t *mp;
16796 u8 ip_family_set = 0, is_ip4 = 1;
16798 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16800 if (unformat (i, "ip4"))
16805 else if (unformat (i, "ip6"))
16812 errmsg ("parse error '%U'", format_unformat_error, i);
16817 if (!ip_family_set)
16819 errmsg ("ip family not set!");
16823 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
16824 mp->is_ip4 = is_ip4;
16829 /* Wait for a reply... */
16835 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
16837 vl_api_gpe_fwd_entry_vnis_get_t *mp;
16840 if (!vam->json_output)
16842 print (vam->ofp, "VNIs");
16845 M (GPE_FWD_ENTRY_VNIS_GET, mp);
16850 /* Wait for a reply... */
16856 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
16858 unformat_input_t *i = vam->input;
16859 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
16861 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
16862 struct in_addr ip4;
16863 struct in6_addr ip6;
16864 u32 table_id = 0, nh_sw_if_index = ~0;
16866 clib_memset (&ip4, 0, sizeof (ip4));
16867 clib_memset (&ip6, 0, sizeof (ip6));
16869 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16871 if (unformat (i, "del"))
16873 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
16874 api_unformat_sw_if_index, vam, &nh_sw_if_index))
16879 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
16880 api_unformat_sw_if_index, vam, &nh_sw_if_index))
16885 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
16889 nh_sw_if_index = ~0;
16891 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
16895 nh_sw_if_index = ~0;
16897 else if (unformat (i, "table %d", &table_id))
16901 errmsg ("parse error '%U'", format_unformat_error, i);
16908 errmsg ("nh addr not set!");
16912 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
16913 mp->is_add = is_add;
16914 mp->table_id = clib_host_to_net_u32 (table_id);
16915 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
16916 mp->nh_addr.af = is_ip4 ? 0 : 1;
16918 clib_memcpy (mp->nh_addr.un.ip4, &ip4, sizeof (ip4));
16920 clib_memcpy (mp->nh_addr.un.ip6, &ip6, sizeof (ip6));
16925 /* Wait for a reply... */
16931 api_one_map_server_dump (vat_main_t * vam)
16933 vl_api_one_map_server_dump_t *mp;
16934 vl_api_control_ping_t *mp_ping;
16937 if (!vam->json_output)
16939 print (vam->ofp, "%=20s", "Map server");
16942 M (ONE_MAP_SERVER_DUMP, mp);
16946 /* Use a control ping for synchronization */
16947 MPING (CONTROL_PING, mp_ping);
16950 /* Wait for a reply... */
16955 #define api_lisp_map_server_dump api_one_map_server_dump
16958 api_one_map_resolver_dump (vat_main_t * vam)
16960 vl_api_one_map_resolver_dump_t *mp;
16961 vl_api_control_ping_t *mp_ping;
16964 if (!vam->json_output)
16966 print (vam->ofp, "%=20s", "Map resolver");
16969 M (ONE_MAP_RESOLVER_DUMP, mp);
16973 /* Use a control ping for synchronization */
16974 MPING (CONTROL_PING, mp_ping);
16977 /* Wait for a reply... */
16982 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
16985 api_one_stats_flush (vat_main_t * vam)
16987 vl_api_one_stats_flush_t *mp;
16990 M (ONE_STATS_FLUSH, mp);
16997 api_one_stats_dump (vat_main_t * vam)
16999 vl_api_one_stats_dump_t *mp;
17000 vl_api_control_ping_t *mp_ping;
17003 M (ONE_STATS_DUMP, mp);
17007 /* Use a control ping for synchronization */
17008 MPING (CONTROL_PING, mp_ping);
17011 /* Wait for a reply... */
17017 api_show_one_status (vat_main_t * vam)
17019 vl_api_show_one_status_t *mp;
17022 if (!vam->json_output)
17024 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
17027 M (SHOW_ONE_STATUS, mp);
17030 /* Wait for a reply... */
17035 #define api_show_lisp_status api_show_one_status
17038 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
17040 vl_api_gpe_fwd_entry_path_dump_t *mp;
17041 vl_api_control_ping_t *mp_ping;
17042 unformat_input_t *i = vam->input;
17043 u32 fwd_entry_index = ~0;
17046 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17048 if (unformat (i, "index %d", &fwd_entry_index))
17054 if (~0 == fwd_entry_index)
17056 errmsg ("no index specified!");
17060 if (!vam->json_output)
17062 print (vam->ofp, "first line");
17065 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
17069 /* Use a control ping for synchronization */
17070 MPING (CONTROL_PING, mp_ping);
17073 /* Wait for a reply... */
17079 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
17081 vl_api_one_get_map_request_itr_rlocs_t *mp;
17084 if (!vam->json_output)
17086 print (vam->ofp, "%=20s", "itr-rlocs:");
17089 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
17092 /* Wait for a reply... */
17097 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
17100 api_af_packet_create (vat_main_t * vam)
17102 unformat_input_t *i = vam->input;
17103 vl_api_af_packet_create_t *mp;
17104 u8 *host_if_name = 0;
17106 u8 random_hw_addr = 1;
17109 clib_memset (hw_addr, 0, sizeof (hw_addr));
17111 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17113 if (unformat (i, "name %s", &host_if_name))
17114 vec_add1 (host_if_name, 0);
17115 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
17116 random_hw_addr = 0;
17121 if (!vec_len (host_if_name))
17123 errmsg ("host-interface name must be specified");
17127 if (vec_len (host_if_name) > 64)
17129 errmsg ("host-interface name too long");
17133 M (AF_PACKET_CREATE, mp);
17135 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
17136 clib_memcpy (mp->hw_addr, hw_addr, 6);
17137 mp->use_random_hw_addr = random_hw_addr;
17138 vec_free (host_if_name);
17146 fprintf (vam->ofp ? vam->ofp : stderr,
17147 " new sw_if_index = %d\n", vam->sw_if_index);
17154 api_af_packet_delete (vat_main_t * vam)
17156 unformat_input_t *i = vam->input;
17157 vl_api_af_packet_delete_t *mp;
17158 u8 *host_if_name = 0;
17161 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17163 if (unformat (i, "name %s", &host_if_name))
17164 vec_add1 (host_if_name, 0);
17169 if (!vec_len (host_if_name))
17171 errmsg ("host-interface name must be specified");
17175 if (vec_len (host_if_name) > 64)
17177 errmsg ("host-interface name too long");
17181 M (AF_PACKET_DELETE, mp);
17183 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
17184 vec_free (host_if_name);
17191 static void vl_api_af_packet_details_t_handler
17192 (vl_api_af_packet_details_t * mp)
17194 vat_main_t *vam = &vat_main;
17196 print (vam->ofp, "%-16s %d",
17197 mp->host_if_name, clib_net_to_host_u32 (mp->sw_if_index));
17200 static void vl_api_af_packet_details_t_handler_json
17201 (vl_api_af_packet_details_t * mp)
17203 vat_main_t *vam = &vat_main;
17204 vat_json_node_t *node = NULL;
17206 if (VAT_JSON_ARRAY != vam->json_tree.type)
17208 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17209 vat_json_init_array (&vam->json_tree);
17211 node = vat_json_array_add (&vam->json_tree);
17213 vat_json_init_object (node);
17214 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
17215 vat_json_object_add_string_copy (node, "dev_name", mp->host_if_name);
17219 api_af_packet_dump (vat_main_t * vam)
17221 vl_api_af_packet_dump_t *mp;
17222 vl_api_control_ping_t *mp_ping;
17225 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
17226 /* Get list of tap interfaces */
17227 M (AF_PACKET_DUMP, mp);
17230 /* Use a control ping for synchronization */
17231 MPING (CONTROL_PING, mp_ping);
17239 api_policer_add_del (vat_main_t * vam)
17241 unformat_input_t *i = vam->input;
17242 vl_api_policer_add_del_t *mp;
17252 u8 color_aware = 0;
17253 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
17256 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
17257 conform_action.dscp = 0;
17258 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
17259 exceed_action.dscp = 0;
17260 violate_action.action_type = SSE2_QOS_ACTION_DROP;
17261 violate_action.dscp = 0;
17263 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17265 if (unformat (i, "del"))
17267 else if (unformat (i, "name %s", &name))
17268 vec_add1 (name, 0);
17269 else if (unformat (i, "cir %u", &cir))
17271 else if (unformat (i, "eir %u", &eir))
17273 else if (unformat (i, "cb %u", &cb))
17275 else if (unformat (i, "eb %u", &eb))
17277 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
17280 else if (unformat (i, "round_type %U", unformat_policer_round_type,
17283 else if (unformat (i, "type %U", unformat_policer_type, &type))
17285 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
17288 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
17291 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
17294 else if (unformat (i, "color-aware"))
17300 if (!vec_len (name))
17302 errmsg ("policer name must be specified");
17306 if (vec_len (name) > 64)
17308 errmsg ("policer name too long");
17312 M (POLICER_ADD_DEL, mp);
17314 clib_memcpy (mp->name, name, vec_len (name));
17316 mp->is_add = is_add;
17317 mp->cir = ntohl (cir);
17318 mp->eir = ntohl (eir);
17319 mp->cb = clib_net_to_host_u64 (cb);
17320 mp->eb = clib_net_to_host_u64 (eb);
17321 mp->rate_type = rate_type;
17322 mp->round_type = round_type;
17324 mp->conform_action.type = conform_action.action_type;
17325 mp->conform_action.dscp = conform_action.dscp;
17326 mp->exceed_action.type = exceed_action.action_type;
17327 mp->exceed_action.dscp = exceed_action.dscp;
17328 mp->violate_action.type = violate_action.action_type;
17329 mp->violate_action.dscp = violate_action.dscp;
17330 mp->color_aware = color_aware;
17338 api_policer_dump (vat_main_t * vam)
17340 unformat_input_t *i = vam->input;
17341 vl_api_policer_dump_t *mp;
17342 vl_api_control_ping_t *mp_ping;
17343 u8 *match_name = 0;
17344 u8 match_name_valid = 0;
17347 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17349 if (unformat (i, "name %s", &match_name))
17351 vec_add1 (match_name, 0);
17352 match_name_valid = 1;
17358 M (POLICER_DUMP, mp);
17359 mp->match_name_valid = match_name_valid;
17360 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
17361 vec_free (match_name);
17365 /* Use a control ping for synchronization */
17366 MPING (CONTROL_PING, mp_ping);
17369 /* Wait for a reply... */
17375 api_policer_classify_set_interface (vat_main_t * vam)
17377 unformat_input_t *i = vam->input;
17378 vl_api_policer_classify_set_interface_t *mp;
17380 int sw_if_index_set;
17381 u32 ip4_table_index = ~0;
17382 u32 ip6_table_index = ~0;
17383 u32 l2_table_index = ~0;
17387 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17389 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17390 sw_if_index_set = 1;
17391 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17392 sw_if_index_set = 1;
17393 else if (unformat (i, "del"))
17395 else if (unformat (i, "ip4-table %d", &ip4_table_index))
17397 else if (unformat (i, "ip6-table %d", &ip6_table_index))
17399 else if (unformat (i, "l2-table %d", &l2_table_index))
17403 clib_warning ("parse error '%U'", format_unformat_error, i);
17408 if (sw_if_index_set == 0)
17410 errmsg ("missing interface name or sw_if_index");
17414 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
17416 mp->sw_if_index = ntohl (sw_if_index);
17417 mp->ip4_table_index = ntohl (ip4_table_index);
17418 mp->ip6_table_index = ntohl (ip6_table_index);
17419 mp->l2_table_index = ntohl (l2_table_index);
17420 mp->is_add = is_add;
17428 api_policer_classify_dump (vat_main_t * vam)
17430 unformat_input_t *i = vam->input;
17431 vl_api_policer_classify_dump_t *mp;
17432 vl_api_control_ping_t *mp_ping;
17433 u8 type = POLICER_CLASSIFY_N_TABLES;
17436 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
17440 errmsg ("classify table type must be specified");
17444 if (!vam->json_output)
17446 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
17449 M (POLICER_CLASSIFY_DUMP, mp);
17454 /* Use a control ping for synchronization */
17455 MPING (CONTROL_PING, mp_ping);
17458 /* Wait for a reply... */
17464 format_fib_api_path_nh_proto (u8 * s, va_list * args)
17466 vl_api_fib_path_nh_proto_t proto =
17467 va_arg (*args, vl_api_fib_path_nh_proto_t);
17471 case FIB_API_PATH_NH_PROTO_IP4:
17472 s = format (s, "ip4");
17474 case FIB_API_PATH_NH_PROTO_IP6:
17475 s = format (s, "ip6");
17477 case FIB_API_PATH_NH_PROTO_MPLS:
17478 s = format (s, "mpls");
17480 case FIB_API_PATH_NH_PROTO_BIER:
17481 s = format (s, "bier");
17483 case FIB_API_PATH_NH_PROTO_ETHERNET:
17484 s = format (s, "ethernet");
17492 format_vl_api_ip_address_union (u8 * s, va_list * args)
17494 vl_api_address_family_t af = va_arg (*args, int);
17495 const vl_api_address_union_t *u = va_arg (*args, vl_api_address_union_t *);
17500 s = format (s, "%U", format_ip4_address, u->ip4);
17503 s = format (s, "%U", format_ip6_address, u->ip6);
17510 format_vl_api_fib_path_type (u8 * s, va_list * args)
17512 vl_api_fib_path_type_t t = va_arg (*args, vl_api_fib_path_type_t);
17516 case FIB_API_PATH_TYPE_NORMAL:
17517 s = format (s, "normal");
17519 case FIB_API_PATH_TYPE_LOCAL:
17520 s = format (s, "local");
17522 case FIB_API_PATH_TYPE_DROP:
17523 s = format (s, "drop");
17525 case FIB_API_PATH_TYPE_UDP_ENCAP:
17526 s = format (s, "udp-encap");
17528 case FIB_API_PATH_TYPE_BIER_IMP:
17529 s = format (s, "bier-imp");
17531 case FIB_API_PATH_TYPE_ICMP_UNREACH:
17532 s = format (s, "unreach");
17534 case FIB_API_PATH_TYPE_ICMP_PROHIBIT:
17535 s = format (s, "prohibit");
17537 case FIB_API_PATH_TYPE_SOURCE_LOOKUP:
17538 s = format (s, "src-lookup");
17540 case FIB_API_PATH_TYPE_DVR:
17541 s = format (s, "dvr");
17543 case FIB_API_PATH_TYPE_INTERFACE_RX:
17544 s = format (s, "interface-rx");
17546 case FIB_API_PATH_TYPE_CLASSIFY:
17547 s = format (s, "classify");
17555 vl_api_fib_path_print (vat_main_t * vam, vl_api_fib_path_t * fp)
17558 " weight %d, sw_if_index %d, type %U, afi %U, next_hop %U",
17559 ntohl (fp->weight), ntohl (fp->sw_if_index),
17560 format_vl_api_fib_path_type, fp->type,
17561 format_fib_api_path_nh_proto, fp->proto,
17562 format_vl_api_ip_address_union, &fp->nh.address);
17566 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
17567 vl_api_fib_path_t * fp)
17569 struct in_addr ip4;
17570 struct in6_addr ip6;
17572 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
17573 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
17574 vat_json_object_add_uint (node, "type", fp->type);
17575 vat_json_object_add_uint (node, "next_hop_proto", fp->proto);
17576 if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
17578 clib_memcpy (&ip4, &fp->nh.address.ip4, sizeof (ip4));
17579 vat_json_object_add_ip4 (node, "next_hop", ip4);
17581 else if (fp->proto == FIB_API_PATH_NH_PROTO_IP6)
17583 clib_memcpy (&ip6, &fp->nh.address.ip6, sizeof (ip6));
17584 vat_json_object_add_ip6 (node, "next_hop", ip6);
17589 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
17591 vat_main_t *vam = &vat_main;
17592 int count = ntohl (mp->mt_tunnel.mt_n_paths);
17593 vl_api_fib_path_t *fp;
17596 print (vam->ofp, "sw_if_index %d via:",
17597 ntohl (mp->mt_tunnel.mt_sw_if_index));
17598 fp = mp->mt_tunnel.mt_paths;
17599 for (i = 0; i < count; i++)
17601 vl_api_fib_path_print (vam, fp);
17605 print (vam->ofp, "");
17608 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
17609 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
17612 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
17614 vat_main_t *vam = &vat_main;
17615 vat_json_node_t *node = NULL;
17616 int count = ntohl (mp->mt_tunnel.mt_n_paths);
17617 vl_api_fib_path_t *fp;
17620 if (VAT_JSON_ARRAY != vam->json_tree.type)
17622 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17623 vat_json_init_array (&vam->json_tree);
17625 node = vat_json_array_add (&vam->json_tree);
17627 vat_json_init_object (node);
17628 vat_json_object_add_uint (node, "sw_if_index",
17629 ntohl (mp->mt_tunnel.mt_sw_if_index));
17631 vat_json_object_add_uint (node, "l2_only", mp->mt_tunnel.mt_l2_only);
17633 fp = mp->mt_tunnel.mt_paths;
17634 for (i = 0; i < count; i++)
17636 vl_api_mpls_fib_path_json_print (node, fp);
17642 api_mpls_tunnel_dump (vat_main_t * vam)
17644 vl_api_mpls_tunnel_dump_t *mp;
17645 vl_api_control_ping_t *mp_ping;
17648 M (MPLS_TUNNEL_DUMP, mp);
17652 /* Use a control ping for synchronization */
17653 MPING (CONTROL_PING, mp_ping);
17660 #define vl_api_mpls_table_details_t_endian vl_noop_handler
17661 #define vl_api_mpls_table_details_t_print vl_noop_handler
17665 vl_api_mpls_table_details_t_handler (vl_api_mpls_table_details_t * mp)
17667 vat_main_t *vam = &vat_main;
17669 print (vam->ofp, "table-id %d,", ntohl (mp->mt_table.mt_table_id));
17672 static void vl_api_mpls_table_details_t_handler_json
17673 (vl_api_mpls_table_details_t * mp)
17675 vat_main_t *vam = &vat_main;
17676 vat_json_node_t *node = NULL;
17678 if (VAT_JSON_ARRAY != vam->json_tree.type)
17680 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17681 vat_json_init_array (&vam->json_tree);
17683 node = vat_json_array_add (&vam->json_tree);
17685 vat_json_init_object (node);
17686 vat_json_object_add_uint (node, "table", ntohl (mp->mt_table.mt_table_id));
17690 api_mpls_table_dump (vat_main_t * vam)
17692 vl_api_mpls_table_dump_t *mp;
17693 vl_api_control_ping_t *mp_ping;
17696 M (MPLS_TABLE_DUMP, mp);
17699 /* Use a control ping for synchronization */
17700 MPING (CONTROL_PING, mp_ping);
17707 #define vl_api_mpls_route_details_t_endian vl_noop_handler
17708 #define vl_api_mpls_route_details_t_print vl_noop_handler
17711 vl_api_mpls_route_details_t_handler (vl_api_mpls_route_details_t * mp)
17713 vat_main_t *vam = &vat_main;
17714 int count = (int) clib_net_to_host_u32 (mp->mr_route.mr_n_paths);
17715 vl_api_fib_path_t *fp;
17719 "table-id %d, label %u, ess_bit %u",
17720 ntohl (mp->mr_route.mr_table_id),
17721 ntohl (mp->mr_route.mr_label), mp->mr_route.mr_eos);
17722 fp = mp->mr_route.mr_paths;
17723 for (i = 0; i < count; i++)
17725 vl_api_fib_path_print (vam, fp);
17730 static void vl_api_mpls_route_details_t_handler_json
17731 (vl_api_mpls_route_details_t * mp)
17733 vat_main_t *vam = &vat_main;
17734 int count = (int) clib_host_to_net_u32 (mp->mr_route.mr_n_paths);
17735 vat_json_node_t *node = NULL;
17736 vl_api_fib_path_t *fp;
17739 if (VAT_JSON_ARRAY != vam->json_tree.type)
17741 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17742 vat_json_init_array (&vam->json_tree);
17744 node = vat_json_array_add (&vam->json_tree);
17746 vat_json_init_object (node);
17747 vat_json_object_add_uint (node, "table", ntohl (mp->mr_route.mr_table_id));
17748 vat_json_object_add_uint (node, "s_bit", mp->mr_route.mr_eos);
17749 vat_json_object_add_uint (node, "label", ntohl (mp->mr_route.mr_label));
17750 vat_json_object_add_uint (node, "path_count", count);
17751 fp = mp->mr_route.mr_paths;
17752 for (i = 0; i < count; i++)
17754 vl_api_mpls_fib_path_json_print (node, fp);
17760 api_mpls_route_dump (vat_main_t * vam)
17762 unformat_input_t *input = vam->input;
17763 vl_api_mpls_route_dump_t *mp;
17764 vl_api_control_ping_t *mp_ping;
17768 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17770 if (unformat (input, "table_id %d", &table_id))
17775 if (table_id == ~0)
17777 errmsg ("missing table id");
17781 M (MPLS_ROUTE_DUMP, mp);
17783 mp->table.mt_table_id = ntohl (table_id);
17786 /* Use a control ping for synchronization */
17787 MPING (CONTROL_PING, mp_ping);
17794 #define vl_api_ip_table_details_t_endian vl_noop_handler
17795 #define vl_api_ip_table_details_t_print vl_noop_handler
17798 vl_api_ip_table_details_t_handler (vl_api_ip_table_details_t * mp)
17800 vat_main_t *vam = &vat_main;
17803 "%s; table-id %d, prefix %U/%d",
17804 mp->table.name, ntohl (mp->table.table_id));
17808 static void vl_api_ip_table_details_t_handler_json
17809 (vl_api_ip_table_details_t * mp)
17811 vat_main_t *vam = &vat_main;
17812 vat_json_node_t *node = NULL;
17814 if (VAT_JSON_ARRAY != vam->json_tree.type)
17816 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17817 vat_json_init_array (&vam->json_tree);
17819 node = vat_json_array_add (&vam->json_tree);
17821 vat_json_init_object (node);
17822 vat_json_object_add_uint (node, "table", ntohl (mp->table.table_id));
17826 api_ip_table_dump (vat_main_t * vam)
17828 vl_api_ip_table_dump_t *mp;
17829 vl_api_control_ping_t *mp_ping;
17832 M (IP_TABLE_DUMP, mp);
17835 /* Use a control ping for synchronization */
17836 MPING (CONTROL_PING, mp_ping);
17844 api_ip_mtable_dump (vat_main_t * vam)
17846 vl_api_ip_mtable_dump_t *mp;
17847 vl_api_control_ping_t *mp_ping;
17850 M (IP_MTABLE_DUMP, mp);
17853 /* Use a control ping for synchronization */
17854 MPING (CONTROL_PING, mp_ping);
17862 api_ip_mroute_dump (vat_main_t * vam)
17864 unformat_input_t *input = vam->input;
17865 vl_api_control_ping_t *mp_ping;
17866 vl_api_ip_mroute_dump_t *mp;
17871 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17873 if (unformat (input, "table_id %d", &table_id))
17875 else if (unformat (input, "ip6"))
17877 else if (unformat (input, "ip4"))
17882 if (table_id == ~0)
17884 errmsg ("missing table id");
17888 M (IP_MROUTE_DUMP, mp);
17889 mp->table.table_id = table_id;
17890 mp->table.is_ip6 = is_ip6;
17893 /* Use a control ping for synchronization */
17894 MPING (CONTROL_PING, mp_ping);
17901 #define vl_api_ip_route_details_t_endian vl_noop_handler
17902 #define vl_api_ip_route_details_t_print vl_noop_handler
17905 vl_api_ip_route_details_t_handler (vl_api_ip_route_details_t * mp)
17907 vat_main_t *vam = &vat_main;
17908 u8 count = mp->route.n_paths;
17909 vl_api_fib_path_t *fp;
17913 "table-id %d, prefix %U/%d",
17914 ntohl (mp->route.table_id),
17915 format_ip46_address, mp->route.prefix.address, mp->route.prefix.len);
17916 for (i = 0; i < count; i++)
17918 fp = &mp->route.paths[i];
17920 vl_api_fib_path_print (vam, fp);
17925 static void vl_api_ip_route_details_t_handler_json
17926 (vl_api_ip_route_details_t * mp)
17928 vat_main_t *vam = &vat_main;
17929 u8 count = mp->route.n_paths;
17930 vat_json_node_t *node = NULL;
17931 struct in_addr ip4;
17932 struct in6_addr ip6;
17933 vl_api_fib_path_t *fp;
17936 if (VAT_JSON_ARRAY != vam->json_tree.type)
17938 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17939 vat_json_init_array (&vam->json_tree);
17941 node = vat_json_array_add (&vam->json_tree);
17943 vat_json_init_object (node);
17944 vat_json_object_add_uint (node, "table", ntohl (mp->route.table_id));
17945 if (ADDRESS_IP6 == mp->route.prefix.address.af)
17947 clib_memcpy (&ip6, &mp->route.prefix.address.un.ip6, sizeof (ip6));
17948 vat_json_object_add_ip6 (node, "prefix", ip6);
17952 clib_memcpy (&ip4, &mp->route.prefix.address.un.ip4, sizeof (ip4));
17953 vat_json_object_add_ip4 (node, "prefix", ip4);
17955 vat_json_object_add_uint (node, "mask_length", mp->route.prefix.len);
17956 vat_json_object_add_uint (node, "path_count", count);
17957 for (i = 0; i < count; i++)
17959 fp = &mp->route.paths[i];
17960 vl_api_mpls_fib_path_json_print (node, fp);
17965 api_ip_route_dump (vat_main_t * vam)
17967 unformat_input_t *input = vam->input;
17968 vl_api_ip_route_dump_t *mp;
17969 vl_api_control_ping_t *mp_ping;
17975 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17977 if (unformat (input, "table_id %d", &table_id))
17979 else if (unformat (input, "ip6"))
17981 else if (unformat (input, "ip4"))
17986 if (table_id == ~0)
17988 errmsg ("missing table id");
17992 M (IP_ROUTE_DUMP, mp);
17994 mp->table.table_id = table_id;
17995 mp->table.is_ip6 = is_ip6;
17999 /* Use a control ping for synchronization */
18000 MPING (CONTROL_PING, mp_ping);
18008 api_classify_table_ids (vat_main_t * vam)
18010 vl_api_classify_table_ids_t *mp;
18013 /* Construct the API message */
18014 M (CLASSIFY_TABLE_IDS, mp);
18023 api_classify_table_by_interface (vat_main_t * vam)
18025 unformat_input_t *input = vam->input;
18026 vl_api_classify_table_by_interface_t *mp;
18028 u32 sw_if_index = ~0;
18030 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18032 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18034 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18039 if (sw_if_index == ~0)
18041 errmsg ("missing interface name or sw_if_index");
18045 /* Construct the API message */
18046 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
18048 mp->sw_if_index = ntohl (sw_if_index);
18056 api_classify_table_info (vat_main_t * vam)
18058 unformat_input_t *input = vam->input;
18059 vl_api_classify_table_info_t *mp;
18063 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18065 if (unformat (input, "table_id %d", &table_id))
18070 if (table_id == ~0)
18072 errmsg ("missing table id");
18076 /* Construct the API message */
18077 M (CLASSIFY_TABLE_INFO, mp);
18079 mp->table_id = ntohl (table_id);
18087 api_classify_session_dump (vat_main_t * vam)
18089 unformat_input_t *input = vam->input;
18090 vl_api_classify_session_dump_t *mp;
18091 vl_api_control_ping_t *mp_ping;
18095 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18097 if (unformat (input, "table_id %d", &table_id))
18102 if (table_id == ~0)
18104 errmsg ("missing table id");
18108 /* Construct the API message */
18109 M (CLASSIFY_SESSION_DUMP, mp);
18111 mp->table_id = ntohl (table_id);
18114 /* Use a control ping for synchronization */
18115 MPING (CONTROL_PING, mp_ping);
18123 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
18125 vat_main_t *vam = &vat_main;
18127 print (vam->ofp, "collector_address %U, collector_port %d, "
18128 "src_address %U, vrf_id %d, path_mtu %u, "
18129 "template_interval %u, udp_checksum %d",
18130 format_ip4_address, mp->collector_address,
18131 ntohs (mp->collector_port),
18132 format_ip4_address, mp->src_address,
18133 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
18134 ntohl (mp->template_interval), mp->udp_checksum);
18137 vam->result_ready = 1;
18141 vl_api_ipfix_exporter_details_t_handler_json
18142 (vl_api_ipfix_exporter_details_t * mp)
18144 vat_main_t *vam = &vat_main;
18145 vat_json_node_t node;
18146 struct in_addr collector_address;
18147 struct in_addr src_address;
18149 vat_json_init_object (&node);
18150 clib_memcpy (&collector_address, &mp->collector_address,
18151 sizeof (collector_address));
18152 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
18153 vat_json_object_add_uint (&node, "collector_port",
18154 ntohs (mp->collector_port));
18155 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
18156 vat_json_object_add_ip4 (&node, "src_address", src_address);
18157 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
18158 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
18159 vat_json_object_add_uint (&node, "template_interval",
18160 ntohl (mp->template_interval));
18161 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
18163 vat_json_print (vam->ofp, &node);
18164 vat_json_free (&node);
18166 vam->result_ready = 1;
18170 api_ipfix_exporter_dump (vat_main_t * vam)
18172 vl_api_ipfix_exporter_dump_t *mp;
18175 /* Construct the API message */
18176 M (IPFIX_EXPORTER_DUMP, mp);
18185 api_ipfix_classify_stream_dump (vat_main_t * vam)
18187 vl_api_ipfix_classify_stream_dump_t *mp;
18190 /* Construct the API message */
18191 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
18202 vl_api_ipfix_classify_stream_details_t_handler
18203 (vl_api_ipfix_classify_stream_details_t * mp)
18205 vat_main_t *vam = &vat_main;
18206 print (vam->ofp, "domain_id %d, src_port %d",
18207 ntohl (mp->domain_id), ntohs (mp->src_port));
18209 vam->result_ready = 1;
18213 vl_api_ipfix_classify_stream_details_t_handler_json
18214 (vl_api_ipfix_classify_stream_details_t * mp)
18216 vat_main_t *vam = &vat_main;
18217 vat_json_node_t node;
18219 vat_json_init_object (&node);
18220 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
18221 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
18223 vat_json_print (vam->ofp, &node);
18224 vat_json_free (&node);
18226 vam->result_ready = 1;
18230 api_ipfix_classify_table_dump (vat_main_t * vam)
18232 vl_api_ipfix_classify_table_dump_t *mp;
18233 vl_api_control_ping_t *mp_ping;
18236 if (!vam->json_output)
18238 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
18239 "transport_protocol");
18242 /* Construct the API message */
18243 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
18248 /* Use a control ping for synchronization */
18249 MPING (CONTROL_PING, mp_ping);
18257 vl_api_ipfix_classify_table_details_t_handler
18258 (vl_api_ipfix_classify_table_details_t * mp)
18260 vat_main_t *vam = &vat_main;
18261 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
18262 mp->transport_protocol);
18266 vl_api_ipfix_classify_table_details_t_handler_json
18267 (vl_api_ipfix_classify_table_details_t * mp)
18269 vat_json_node_t *node = NULL;
18270 vat_main_t *vam = &vat_main;
18272 if (VAT_JSON_ARRAY != vam->json_tree.type)
18274 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18275 vat_json_init_array (&vam->json_tree);
18278 node = vat_json_array_add (&vam->json_tree);
18279 vat_json_init_object (node);
18281 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
18282 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
18283 vat_json_object_add_uint (node, "transport_protocol",
18284 mp->transport_protocol);
18288 api_sw_interface_span_enable_disable (vat_main_t * vam)
18290 unformat_input_t *i = vam->input;
18291 vl_api_sw_interface_span_enable_disable_t *mp;
18292 u32 src_sw_if_index = ~0;
18293 u32 dst_sw_if_index = ~0;
18298 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18301 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
18303 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
18307 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
18309 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
18311 else if (unformat (i, "disable"))
18313 else if (unformat (i, "rx"))
18315 else if (unformat (i, "tx"))
18317 else if (unformat (i, "both"))
18319 else if (unformat (i, "l2"))
18325 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
18327 mp->sw_if_index_from = htonl (src_sw_if_index);
18328 mp->sw_if_index_to = htonl (dst_sw_if_index);
18338 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
18341 vat_main_t *vam = &vat_main;
18342 u8 *sw_if_from_name = 0;
18343 u8 *sw_if_to_name = 0;
18344 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
18345 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
18346 char *states[] = { "none", "rx", "tx", "both" };
18350 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
18352 if ((u32) p->value[0] == sw_if_index_from)
18354 sw_if_from_name = (u8 *)(p->key);
18358 if ((u32) p->value[0] == sw_if_index_to)
18360 sw_if_to_name = (u8 *)(p->key);
18361 if (sw_if_from_name)
18366 print (vam->ofp, "%20s => %20s (%s) %s",
18367 sw_if_from_name, sw_if_to_name, states[mp->state],
18368 mp->is_l2 ? "l2" : "device");
18372 vl_api_sw_interface_span_details_t_handler_json
18373 (vl_api_sw_interface_span_details_t * mp)
18375 vat_main_t *vam = &vat_main;
18376 vat_json_node_t *node = NULL;
18377 u8 *sw_if_from_name = 0;
18378 u8 *sw_if_to_name = 0;
18379 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
18380 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
18384 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
18386 if ((u32) p->value[0] == sw_if_index_from)
18388 sw_if_from_name = (u8 *)(p->key);
18392 if ((u32) p->value[0] == sw_if_index_to)
18394 sw_if_to_name = (u8 *)(p->key);
18395 if (sw_if_from_name)
18401 if (VAT_JSON_ARRAY != vam->json_tree.type)
18403 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
18404 vat_json_init_array (&vam->json_tree);
18406 node = vat_json_array_add (&vam->json_tree);
18408 vat_json_init_object (node);
18409 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
18410 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
18411 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
18412 if (0 != sw_if_to_name)
18414 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
18416 vat_json_object_add_uint (node, "state", mp->state);
18417 vat_json_object_add_uint (node, "is-l2", mp->is_l2);
18421 api_sw_interface_span_dump (vat_main_t * vam)
18423 unformat_input_t *input = vam->input;
18424 vl_api_sw_interface_span_dump_t *mp;
18425 vl_api_control_ping_t *mp_ping;
18429 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18431 if (unformat (input, "l2"))
18437 M (SW_INTERFACE_SPAN_DUMP, mp);
18441 /* Use a control ping for synchronization */
18442 MPING (CONTROL_PING, mp_ping);
18450 api_pg_create_interface (vat_main_t * vam)
18452 unformat_input_t *input = vam->input;
18453 vl_api_pg_create_interface_t *mp;
18455 u32 if_id = ~0, gso_size = 0;
18456 u8 gso_enabled = 0;
18458 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18460 if (unformat (input, "if_id %d", &if_id))
18462 else if (unformat (input, "gso-enabled"))
18465 if (unformat (input, "gso-size %u", &gso_size))
18469 errmsg ("missing gso-size");
18478 errmsg ("missing pg interface index");
18482 /* Construct the API message */
18483 M (PG_CREATE_INTERFACE, mp);
18485 mp->interface_id = ntohl (if_id);
18486 mp->gso_enabled = gso_enabled;
18494 api_pg_capture (vat_main_t * vam)
18496 unformat_input_t *input = vam->input;
18497 vl_api_pg_capture_t *mp;
18502 u8 pcap_file_set = 0;
18505 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18507 if (unformat (input, "if_id %d", &if_id))
18509 else if (unformat (input, "pcap %s", &pcap_file))
18511 else if (unformat (input, "count %d", &count))
18513 else if (unformat (input, "disable"))
18520 errmsg ("missing pg interface index");
18523 if (pcap_file_set > 0)
18525 if (vec_len (pcap_file) > 255)
18527 errmsg ("pcap file name is too long");
18532 /* Construct the API message */
18533 M (PG_CAPTURE, mp);
18535 mp->interface_id = ntohl (if_id);
18536 mp->is_enabled = enable;
18537 mp->count = ntohl (count);
18538 if (pcap_file_set != 0)
18540 vl_api_vec_to_api_string (pcap_file, &mp->pcap_file_name);
18542 vec_free (pcap_file);
18550 api_pg_enable_disable (vat_main_t * vam)
18552 unformat_input_t *input = vam->input;
18553 vl_api_pg_enable_disable_t *mp;
18556 u8 stream_name_set = 0;
18557 u8 *stream_name = 0;
18559 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18561 if (unformat (input, "stream %s", &stream_name))
18562 stream_name_set = 1;
18563 else if (unformat (input, "disable"))
18569 if (stream_name_set > 0)
18571 if (vec_len (stream_name) > 255)
18573 errmsg ("stream name too long");
18578 /* Construct the API message */
18579 M (PG_ENABLE_DISABLE, mp);
18581 mp->is_enabled = enable;
18582 if (stream_name_set != 0)
18584 vl_api_vec_to_api_string (stream_name, &mp->stream_name);
18586 vec_free (stream_name);
18594 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
18596 unformat_input_t *input = vam->input;
18597 vl_api_ip_source_and_port_range_check_add_del_t *mp;
18599 u16 *low_ports = 0;
18600 u16 *high_ports = 0;
18603 vl_api_prefix_t prefix;
18610 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18612 if (unformat (input, "%U", unformat_vl_api_prefix, &prefix))
18614 else if (unformat (input, "vrf %d", &vrf_id))
18616 else if (unformat (input, "del"))
18618 else if (unformat (input, "port %d", &tmp))
18620 if (tmp == 0 || tmp > 65535)
18622 errmsg ("port %d out of range", tmp);
18626 this_hi = this_low + 1;
18627 vec_add1 (low_ports, this_low);
18628 vec_add1 (high_ports, this_hi);
18630 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
18632 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
18634 errmsg ("incorrect range parameters");
18638 /* Note: in debug CLI +1 is added to high before
18639 passing to real fn that does "the work"
18640 (ip_source_and_port_range_check_add_del).
18641 This fn is a wrapper around the binary API fn a
18642 control plane will call, which expects this increment
18643 to have occurred. Hence letting the binary API control
18644 plane fn do the increment for consistency between VAT
18645 and other control planes.
18648 vec_add1 (low_ports, this_low);
18649 vec_add1 (high_ports, this_hi);
18655 if (prefix_set == 0)
18657 errmsg ("<address>/<mask> not specified");
18663 errmsg ("VRF ID required, not specified");
18670 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
18674 if (vec_len (low_ports) == 0)
18676 errmsg ("At least one port or port range required");
18680 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
18682 mp->is_add = is_add;
18684 clib_memcpy (&mp->prefix, &prefix, sizeof (prefix));
18686 mp->number_of_ranges = vec_len (low_ports);
18688 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
18689 vec_free (low_ports);
18691 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
18692 vec_free (high_ports);
18694 mp->vrf_id = ntohl (vrf_id);
18702 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
18704 unformat_input_t *input = vam->input;
18705 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
18706 u32 sw_if_index = ~0;
18708 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
18709 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
18713 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18715 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18717 else if (unformat (input, "sw_if_index %d", &sw_if_index))
18719 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
18721 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
18723 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
18725 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
18727 else if (unformat (input, "del"))
18733 if (sw_if_index == ~0)
18735 errmsg ("Interface required but not specified");
18741 errmsg ("VRF ID required but not specified");
18745 if (tcp_out_vrf_id == 0
18746 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
18749 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
18753 /* Construct the API message */
18754 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
18756 mp->sw_if_index = ntohl (sw_if_index);
18757 mp->is_add = is_add;
18758 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
18759 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
18760 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
18761 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
18766 /* Wait for a reply... */
18772 api_set_punt (vat_main_t * vam)
18774 unformat_input_t *i = vam->input;
18775 vl_api_address_family_t af;
18776 vl_api_set_punt_t *mp;
18782 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18784 if (unformat (i, "%U", unformat_vl_api_address_family, &af))
18786 else if (unformat (i, "protocol %d", &protocol))
18788 else if (unformat (i, "port %d", &port))
18790 else if (unformat (i, "del"))
18794 clib_warning ("parse error '%U'", format_unformat_error, i);
18801 mp->is_add = (u8) is_add;
18802 mp->punt.type = PUNT_API_TYPE_L4;
18803 mp->punt.punt.l4.af = af;
18804 mp->punt.punt.l4.protocol = (u8) protocol;
18805 mp->punt.punt.l4.port = htons ((u16) port);
18813 api_delete_subif (vat_main_t * vam)
18815 unformat_input_t *i = vam->input;
18816 vl_api_delete_subif_t *mp;
18817 u32 sw_if_index = ~0;
18820 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18822 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18824 if (unformat (i, "sw_if_index %d", &sw_if_index))
18830 if (sw_if_index == ~0)
18832 errmsg ("missing sw_if_index");
18836 /* Construct the API message */
18837 M (DELETE_SUBIF, mp);
18838 mp->sw_if_index = ntohl (sw_if_index);
18845 #define foreach_pbb_vtr_op \
18846 _("disable", L2_VTR_DISABLED) \
18847 _("pop", L2_VTR_POP_2) \
18848 _("push", L2_VTR_PUSH_2)
18851 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
18853 unformat_input_t *i = vam->input;
18854 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
18855 u32 sw_if_index = ~0, vtr_op = ~0;
18856 u16 outer_tag = ~0;
18857 u8 dmac[6], smac[6];
18858 u8 dmac_set = 0, smac_set = 0;
18864 /* Shut up coverity */
18865 clib_memset (dmac, 0, sizeof (dmac));
18866 clib_memset (smac, 0, sizeof (smac));
18868 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18870 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18872 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18874 else if (unformat (i, "vtr_op %d", &vtr_op))
18876 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
18879 else if (unformat (i, "translate_pbb_stag"))
18881 if (unformat (i, "%d", &tmp))
18883 vtr_op = L2_VTR_TRANSLATE_2_1;
18889 ("translate_pbb_stag operation requires outer tag definition");
18893 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
18895 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
18897 else if (unformat (i, "sid %d", &sid))
18899 else if (unformat (i, "vlanid %d", &tmp))
18903 clib_warning ("parse error '%U'", format_unformat_error, i);
18908 if ((sw_if_index == ~0) || (vtr_op == ~0))
18910 errmsg ("missing sw_if_index or vtr operation");
18913 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
18914 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
18917 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
18921 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
18922 mp->sw_if_index = ntohl (sw_if_index);
18923 mp->vtr_op = ntohl (vtr_op);
18924 mp->outer_tag = ntohs (outer_tag);
18925 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
18926 clib_memcpy (mp->b_smac, smac, sizeof (smac));
18927 mp->b_vlanid = ntohs (vlanid);
18928 mp->i_sid = ntohl (sid);
18936 api_flow_classify_set_interface (vat_main_t * vam)
18938 unformat_input_t *i = vam->input;
18939 vl_api_flow_classify_set_interface_t *mp;
18941 int sw_if_index_set;
18942 u32 ip4_table_index = ~0;
18943 u32 ip6_table_index = ~0;
18947 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18949 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
18950 sw_if_index_set = 1;
18951 else if (unformat (i, "sw_if_index %d", &sw_if_index))
18952 sw_if_index_set = 1;
18953 else if (unformat (i, "del"))
18955 else if (unformat (i, "ip4-table %d", &ip4_table_index))
18957 else if (unformat (i, "ip6-table %d", &ip6_table_index))
18961 clib_warning ("parse error '%U'", format_unformat_error, i);
18966 if (sw_if_index_set == 0)
18968 errmsg ("missing interface name or sw_if_index");
18972 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
18974 mp->sw_if_index = ntohl (sw_if_index);
18975 mp->ip4_table_index = ntohl (ip4_table_index);
18976 mp->ip6_table_index = ntohl (ip6_table_index);
18977 mp->is_add = is_add;
18985 api_flow_classify_dump (vat_main_t * vam)
18987 unformat_input_t *i = vam->input;
18988 vl_api_flow_classify_dump_t *mp;
18989 vl_api_control_ping_t *mp_ping;
18990 u8 type = FLOW_CLASSIFY_N_TABLES;
18993 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
18997 errmsg ("classify table type must be specified");
19001 if (!vam->json_output)
19003 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
19006 M (FLOW_CLASSIFY_DUMP, mp);
19011 /* Use a control ping for synchronization */
19012 MPING (CONTROL_PING, mp_ping);
19015 /* Wait for a reply... */
19021 api_feature_enable_disable (vat_main_t * vam)
19023 unformat_input_t *i = vam->input;
19024 vl_api_feature_enable_disable_t *mp;
19026 u8 *feature_name = 0;
19027 u32 sw_if_index = ~0;
19031 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19033 if (unformat (i, "arc_name %s", &arc_name))
19035 else if (unformat (i, "feature_name %s", &feature_name))
19038 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19040 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19042 else if (unformat (i, "disable"))
19050 errmsg ("missing arc name");
19053 if (vec_len (arc_name) > 63)
19055 errmsg ("arc name too long");
19058 if (feature_name == 0)
19060 errmsg ("missing feature name");
19063 if (vec_len (feature_name) > 63)
19065 errmsg ("feature name too long");
19068 if (sw_if_index == ~0)
19070 errmsg ("missing interface name or sw_if_index");
19074 /* Construct the API message */
19075 M (FEATURE_ENABLE_DISABLE, mp);
19076 mp->sw_if_index = ntohl (sw_if_index);
19077 mp->enable = enable;
19078 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
19079 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
19080 vec_free (arc_name);
19081 vec_free (feature_name);
19089 api_feature_gso_enable_disable (vat_main_t * vam)
19091 unformat_input_t *i = vam->input;
19092 vl_api_feature_gso_enable_disable_t *mp;
19093 u32 sw_if_index = ~0;
19097 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19099 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19101 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19103 else if (unformat (i, "enable"))
19105 else if (unformat (i, "disable"))
19111 if (sw_if_index == ~0)
19113 errmsg ("missing interface name or sw_if_index");
19117 /* Construct the API message */
19118 M (FEATURE_GSO_ENABLE_DISABLE, mp);
19119 mp->sw_if_index = ntohl (sw_if_index);
19120 mp->enable_disable = enable;
19128 api_sw_interface_tag_add_del (vat_main_t * vam)
19130 unformat_input_t *i = vam->input;
19131 vl_api_sw_interface_tag_add_del_t *mp;
19132 u32 sw_if_index = ~0;
19137 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19139 if (unformat (i, "tag %s", &tag))
19141 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19143 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19145 else if (unformat (i, "del"))
19151 if (sw_if_index == ~0)
19153 errmsg ("missing interface name or sw_if_index");
19157 if (enable && (tag == 0))
19159 errmsg ("no tag specified");
19163 /* Construct the API message */
19164 M (SW_INTERFACE_TAG_ADD_DEL, mp);
19165 mp->sw_if_index = ntohl (sw_if_index);
19166 mp->is_add = enable;
19168 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
19177 api_sw_interface_add_del_mac_address (vat_main_t * vam)
19179 unformat_input_t *i = vam->input;
19180 vl_api_mac_address_t mac = { 0 };
19181 vl_api_sw_interface_add_del_mac_address_t *mp;
19182 u32 sw_if_index = ~0;
19187 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19189 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19191 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19193 else if (unformat (i, "%U", unformat_vl_api_mac_address, &mac))
19195 else if (unformat (i, "del"))
19201 if (sw_if_index == ~0)
19203 errmsg ("missing interface name or sw_if_index");
19209 errmsg ("missing MAC address");
19213 /* Construct the API message */
19214 M (SW_INTERFACE_ADD_DEL_MAC_ADDRESS, mp);
19215 mp->sw_if_index = ntohl (sw_if_index);
19216 mp->is_add = is_add;
19217 clib_memcpy (&mp->addr, &mac, sizeof (mac));
19224 static void vl_api_l2_xconnect_details_t_handler
19225 (vl_api_l2_xconnect_details_t * mp)
19227 vat_main_t *vam = &vat_main;
19229 print (vam->ofp, "%15d%15d",
19230 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
19233 static void vl_api_l2_xconnect_details_t_handler_json
19234 (vl_api_l2_xconnect_details_t * mp)
19236 vat_main_t *vam = &vat_main;
19237 vat_json_node_t *node = NULL;
19239 if (VAT_JSON_ARRAY != vam->json_tree.type)
19241 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19242 vat_json_init_array (&vam->json_tree);
19244 node = vat_json_array_add (&vam->json_tree);
19246 vat_json_init_object (node);
19247 vat_json_object_add_uint (node, "rx_sw_if_index",
19248 ntohl (mp->rx_sw_if_index));
19249 vat_json_object_add_uint (node, "tx_sw_if_index",
19250 ntohl (mp->tx_sw_if_index));
19254 api_l2_xconnect_dump (vat_main_t * vam)
19256 vl_api_l2_xconnect_dump_t *mp;
19257 vl_api_control_ping_t *mp_ping;
19260 if (!vam->json_output)
19262 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
19265 M (L2_XCONNECT_DUMP, mp);
19269 /* Use a control ping for synchronization */
19270 MPING (CONTROL_PING, mp_ping);
19278 api_hw_interface_set_mtu (vat_main_t * vam)
19280 unformat_input_t *i = vam->input;
19281 vl_api_hw_interface_set_mtu_t *mp;
19282 u32 sw_if_index = ~0;
19286 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19288 if (unformat (i, "mtu %d", &mtu))
19290 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19292 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19298 if (sw_if_index == ~0)
19300 errmsg ("missing interface name or sw_if_index");
19306 errmsg ("no mtu specified");
19310 /* Construct the API message */
19311 M (HW_INTERFACE_SET_MTU, mp);
19312 mp->sw_if_index = ntohl (sw_if_index);
19313 mp->mtu = ntohs ((u16) mtu);
19321 api_p2p_ethernet_add (vat_main_t * vam)
19323 unformat_input_t *i = vam->input;
19324 vl_api_p2p_ethernet_add_t *mp;
19325 u32 parent_if_index = ~0;
19331 clib_memset (remote_mac, 0, sizeof (remote_mac));
19332 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19334 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
19336 else if (unformat (i, "sw_if_index %d", &parent_if_index))
19340 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
19342 else if (unformat (i, "sub_id %d", &sub_id))
19346 clib_warning ("parse error '%U'", format_unformat_error, i);
19351 if (parent_if_index == ~0)
19353 errmsg ("missing interface name or sw_if_index");
19358 errmsg ("missing remote mac address");
19363 errmsg ("missing sub-interface id");
19367 M (P2P_ETHERNET_ADD, mp);
19368 mp->parent_if_index = ntohl (parent_if_index);
19369 mp->subif_id = ntohl (sub_id);
19370 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
19378 api_p2p_ethernet_del (vat_main_t * vam)
19380 unformat_input_t *i = vam->input;
19381 vl_api_p2p_ethernet_del_t *mp;
19382 u32 parent_if_index = ~0;
19387 clib_memset (remote_mac, 0, sizeof (remote_mac));
19388 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19390 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
19392 else if (unformat (i, "sw_if_index %d", &parent_if_index))
19396 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
19400 clib_warning ("parse error '%U'", format_unformat_error, i);
19405 if (parent_if_index == ~0)
19407 errmsg ("missing interface name or sw_if_index");
19412 errmsg ("missing remote mac address");
19416 M (P2P_ETHERNET_DEL, mp);
19417 mp->parent_if_index = ntohl (parent_if_index);
19418 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
19426 api_lldp_config (vat_main_t * vam)
19428 unformat_input_t *i = vam->input;
19429 vl_api_lldp_config_t *mp;
19431 int tx_interval = 0;
19432 u8 *sys_name = NULL;
19435 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19437 if (unformat (i, "system-name %s", &sys_name))
19439 else if (unformat (i, "tx-hold %d", &tx_hold))
19441 else if (unformat (i, "tx-interval %d", &tx_interval))
19445 clib_warning ("parse error '%U'", format_unformat_error, i);
19450 vec_add1 (sys_name, 0);
19452 M (LLDP_CONFIG, mp);
19453 mp->tx_hold = htonl (tx_hold);
19454 mp->tx_interval = htonl (tx_interval);
19455 vl_api_vec_to_api_string (sys_name, &mp->system_name);
19456 vec_free (sys_name);
19464 api_sw_interface_set_lldp (vat_main_t * vam)
19466 unformat_input_t *i = vam->input;
19467 vl_api_sw_interface_set_lldp_t *mp;
19468 u32 sw_if_index = ~0;
19470 u8 *port_desc = NULL, *mgmt_oid = NULL;
19471 ip4_address_t ip4_addr;
19472 ip6_address_t ip6_addr;
19475 clib_memset (&ip4_addr, 0, sizeof (ip4_addr));
19476 clib_memset (&ip6_addr, 0, sizeof (ip6_addr));
19478 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19480 if (unformat (i, "disable"))
19483 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19485 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19487 else if (unformat (i, "port-desc %s", &port_desc))
19489 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
19491 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
19493 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
19499 if (sw_if_index == ~0)
19501 errmsg ("missing interface name or sw_if_index");
19505 /* Construct the API message */
19506 vec_add1 (port_desc, 0);
19507 vec_add1 (mgmt_oid, 0);
19508 M (SW_INTERFACE_SET_LLDP, mp);
19509 mp->sw_if_index = ntohl (sw_if_index);
19510 mp->enable = enable;
19511 vl_api_vec_to_api_string (port_desc, &mp->port_desc);
19512 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
19513 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
19514 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
19515 vec_free (port_desc);
19516 vec_free (mgmt_oid);
19524 api_tcp_configure_src_addresses (vat_main_t * vam)
19526 vl_api_tcp_configure_src_addresses_t *mp;
19527 unformat_input_t *i = vam->input;
19528 vl_api_address_t first, last;
19533 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19535 if (unformat (i, "%U - %U",
19536 unformat_vl_api_address, &first,
19537 unformat_vl_api_address, &last))
19541 errmsg ("one range per message (range already set)");
19546 else if (unformat (i, "vrf %d", &vrf_id))
19552 if (range_set == 0)
19554 errmsg ("address range not set");
19558 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
19560 mp->vrf_id = ntohl (vrf_id);
19561 clib_memcpy (&mp->first_address, &first, sizeof (first));
19562 clib_memcpy (&mp->last_address, &last, sizeof (last));
19569 static void vl_api_app_namespace_add_del_reply_t_handler
19570 (vl_api_app_namespace_add_del_reply_t * mp)
19572 vat_main_t *vam = &vat_main;
19573 i32 retval = ntohl (mp->retval);
19574 if (vam->async_mode)
19576 vam->async_errors += (retval < 0);
19580 vam->retval = retval;
19582 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
19583 vam->result_ready = 1;
19587 static void vl_api_app_namespace_add_del_reply_t_handler_json
19588 (vl_api_app_namespace_add_del_reply_t * mp)
19590 vat_main_t *vam = &vat_main;
19591 vat_json_node_t node;
19593 vat_json_init_object (&node);
19594 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
19595 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
19597 vat_json_print (vam->ofp, &node);
19598 vat_json_free (&node);
19600 vam->retval = ntohl (mp->retval);
19601 vam->result_ready = 1;
19605 api_app_namespace_add_del (vat_main_t * vam)
19607 vl_api_app_namespace_add_del_t *mp;
19608 unformat_input_t *i = vam->input;
19609 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
19610 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
19614 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19616 if (unformat (i, "id %_%v%_", &ns_id))
19618 else if (unformat (i, "secret %lu", &secret))
19620 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19621 sw_if_index_set = 1;
19622 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
19624 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
19629 if (!ns_id || !secret_set || !sw_if_index_set)
19631 errmsg ("namespace id, secret and sw_if_index must be set");
19634 if (vec_len (ns_id) > 64)
19636 errmsg ("namespace id too long");
19639 M (APP_NAMESPACE_ADD_DEL, mp);
19641 vl_api_vec_to_api_string (ns_id, &mp->namespace_id);
19642 mp->secret = clib_host_to_net_u64 (secret);
19643 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
19644 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
19645 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
19653 api_sock_init_shm (vat_main_t * vam)
19655 #if VPP_API_TEST_BUILTIN == 0
19656 unformat_input_t *i = vam->input;
19657 vl_api_shm_elem_config_t *config = 0;
19658 u64 size = 64 << 20;
19661 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19663 if (unformat (i, "size %U", unformat_memory_size, &size))
19670 * Canned custom ring allocator config.
19671 * Should probably parse all of this
19673 vec_validate (config, 6);
19674 config[0].type = VL_API_VLIB_RING;
19675 config[0].size = 256;
19676 config[0].count = 32;
19678 config[1].type = VL_API_VLIB_RING;
19679 config[1].size = 1024;
19680 config[1].count = 16;
19682 config[2].type = VL_API_VLIB_RING;
19683 config[2].size = 4096;
19684 config[2].count = 2;
19686 config[3].type = VL_API_CLIENT_RING;
19687 config[3].size = 256;
19688 config[3].count = 32;
19690 config[4].type = VL_API_CLIENT_RING;
19691 config[4].size = 1024;
19692 config[4].count = 16;
19694 config[5].type = VL_API_CLIENT_RING;
19695 config[5].size = 4096;
19696 config[5].count = 2;
19698 config[6].type = VL_API_QUEUE;
19699 config[6].count = 128;
19700 config[6].size = sizeof (uword);
19702 rv = vl_socket_client_init_shm (config, 1 /* want_pthread */ );
19704 vam->client_index_invalid = 1;
19712 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
19714 vat_main_t *vam = &vat_main;
19715 fib_prefix_t lcl, rmt;
19717 ip_prefix_decode (&mp->lcl, &lcl);
19718 ip_prefix_decode (&mp->rmt, &rmt);
19720 if (lcl.fp_proto == FIB_PROTOCOL_IP4)
19723 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
19724 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
19725 mp->scope, format_ip4_address, &lcl.fp_addr.ip4, lcl.fp_len,
19726 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
19727 &rmt.fp_addr.ip4, rmt.fp_len,
19728 clib_net_to_host_u16 (mp->rmt_port),
19729 clib_net_to_host_u32 (mp->action_index), mp->tag);
19734 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
19735 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
19736 mp->scope, format_ip6_address, &lcl.fp_addr.ip6, lcl.fp_len,
19737 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
19738 &rmt.fp_addr.ip6, rmt.fp_len,
19739 clib_net_to_host_u16 (mp->rmt_port),
19740 clib_net_to_host_u32 (mp->action_index), mp->tag);
19745 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
19748 vat_main_t *vam = &vat_main;
19749 vat_json_node_t *node = NULL;
19750 struct in6_addr ip6;
19751 struct in_addr ip4;
19753 fib_prefix_t lcl, rmt;
19755 ip_prefix_decode (&mp->lcl, &lcl);
19756 ip_prefix_decode (&mp->rmt, &rmt);
19758 if (VAT_JSON_ARRAY != vam->json_tree.type)
19760 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19761 vat_json_init_array (&vam->json_tree);
19763 node = vat_json_array_add (&vam->json_tree);
19764 vat_json_init_object (node);
19766 vat_json_object_add_uint (node, "appns_index",
19767 clib_net_to_host_u32 (mp->appns_index));
19768 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
19769 vat_json_object_add_uint (node, "scope", mp->scope);
19770 vat_json_object_add_uint (node, "action_index",
19771 clib_net_to_host_u32 (mp->action_index));
19772 vat_json_object_add_uint (node, "lcl_port",
19773 clib_net_to_host_u16 (mp->lcl_port));
19774 vat_json_object_add_uint (node, "rmt_port",
19775 clib_net_to_host_u16 (mp->rmt_port));
19776 vat_json_object_add_uint (node, "lcl_plen", lcl.fp_len);
19777 vat_json_object_add_uint (node, "rmt_plen", rmt.fp_len);
19778 vat_json_object_add_string_copy (node, "tag", mp->tag);
19779 if (lcl.fp_proto == FIB_PROTOCOL_IP4)
19781 clib_memcpy (&ip4, &lcl.fp_addr.ip4, sizeof (ip4));
19782 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
19783 clib_memcpy (&ip4, &rmt.fp_addr.ip4, sizeof (ip4));
19784 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
19788 clib_memcpy (&ip6, &lcl.fp_addr.ip6, sizeof (ip6));
19789 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
19790 clib_memcpy (&ip6, &rmt.fp_addr.ip6, sizeof (ip6));
19791 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
19796 api_session_rule_add_del (vat_main_t * vam)
19798 vl_api_session_rule_add_del_t *mp;
19799 unformat_input_t *i = vam->input;
19800 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
19801 u32 appns_index = 0, scope = 0;
19802 ip4_address_t lcl_ip4, rmt_ip4;
19803 ip6_address_t lcl_ip6, rmt_ip6;
19804 u8 is_ip4 = 1, conn_set = 0;
19805 u8 is_add = 1, *tag = 0;
19807 fib_prefix_t lcl, rmt;
19809 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19811 if (unformat (i, "del"))
19813 else if (unformat (i, "add"))
19815 else if (unformat (i, "proto tcp"))
19817 else if (unformat (i, "proto udp"))
19819 else if (unformat (i, "appns %d", &appns_index))
19821 else if (unformat (i, "scope %d", &scope))
19823 else if (unformat (i, "tag %_%v%_", &tag))
19827 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
19828 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
19836 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
19837 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
19843 else if (unformat (i, "action %d", &action))
19848 if (proto == ~0 || !conn_set || action == ~0)
19850 errmsg ("transport proto, connection and action must be set");
19856 errmsg ("scope should be 0-3");
19860 M (SESSION_RULE_ADD_DEL, mp);
19862 clib_memset (&lcl, 0, sizeof (lcl));
19863 clib_memset (&rmt, 0, sizeof (rmt));
19866 ip_set (&lcl.fp_addr, &lcl_ip4, 1);
19867 ip_set (&rmt.fp_addr, &rmt_ip4, 1);
19868 lcl.fp_len = lcl_plen;
19869 rmt.fp_len = rmt_plen;
19873 ip_set (&lcl.fp_addr, &lcl_ip6, 0);
19874 ip_set (&rmt.fp_addr, &rmt_ip6, 0);
19875 lcl.fp_len = lcl_plen;
19876 rmt.fp_len = rmt_plen;
19880 ip_prefix_encode (&lcl, &mp->lcl);
19881 ip_prefix_encode (&rmt, &mp->rmt);
19882 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
19883 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
19884 mp->transport_proto =
19885 proto ? TRANSPORT_PROTO_API_UDP : TRANSPORT_PROTO_API_TCP;
19886 mp->action_index = clib_host_to_net_u32 (action);
19887 mp->appns_index = clib_host_to_net_u32 (appns_index);
19889 mp->is_add = is_add;
19892 clib_memcpy (mp->tag, tag, vec_len (tag));
19902 api_session_rules_dump (vat_main_t * vam)
19904 vl_api_session_rules_dump_t *mp;
19905 vl_api_control_ping_t *mp_ping;
19908 if (!vam->json_output)
19910 print (vam->ofp, "%=20s", "Session Rules");
19913 M (SESSION_RULES_DUMP, mp);
19917 /* Use a control ping for synchronization */
19918 MPING (CONTROL_PING, mp_ping);
19921 /* Wait for a reply... */
19927 api_ip_container_proxy_add_del (vat_main_t * vam)
19929 vl_api_ip_container_proxy_add_del_t *mp;
19930 unformat_input_t *i = vam->input;
19931 u32 sw_if_index = ~0;
19932 vl_api_prefix_t pfx = { };
19936 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19938 if (unformat (i, "del"))
19940 else if (unformat (i, "add"))
19942 if (unformat (i, "%U", unformat_vl_api_prefix, &pfx))
19944 else if (unformat (i, "sw_if_index %u", &sw_if_index))
19949 if (sw_if_index == ~0 || pfx.len == 0)
19951 errmsg ("address and sw_if_index must be set");
19955 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
19957 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
19958 mp->is_add = is_add;
19959 clib_memcpy (&mp->pfx, &pfx, sizeof (pfx));
19967 api_qos_record_enable_disable (vat_main_t * vam)
19969 unformat_input_t *i = vam->input;
19970 vl_api_qos_record_enable_disable_t *mp;
19971 u32 sw_if_index, qs = 0xff;
19972 u8 sw_if_index_set = 0;
19976 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19978 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19979 sw_if_index_set = 1;
19980 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19981 sw_if_index_set = 1;
19982 else if (unformat (i, "%U", unformat_qos_source, &qs))
19984 else if (unformat (i, "disable"))
19988 clib_warning ("parse error '%U'", format_unformat_error, i);
19993 if (sw_if_index_set == 0)
19995 errmsg ("missing interface name or sw_if_index");
20000 errmsg ("input location must be specified");
20004 M (QOS_RECORD_ENABLE_DISABLE, mp);
20006 mp->record.sw_if_index = ntohl (sw_if_index);
20007 mp->record.input_source = qs;
20008 mp->enable = enable;
20017 q_or_quit (vat_main_t * vam)
20019 #if VPP_API_TEST_BUILTIN == 0
20020 longjmp (vam->jump_buf, 1);
20022 return 0; /* not so much */
20026 q (vat_main_t * vam)
20028 return q_or_quit (vam);
20032 quit (vat_main_t * vam)
20034 return q_or_quit (vam);
20038 comment (vat_main_t * vam)
20044 elog_save (vat_main_t * vam)
20046 #if VPP_API_TEST_BUILTIN == 0
20047 elog_main_t *em = &vam->elog_main;
20048 unformat_input_t *i = vam->input;
20049 char *file, *chroot_file;
20050 clib_error_t *error;
20052 if (!unformat (i, "%s", &file))
20054 errmsg ("expected file name, got `%U'", format_unformat_error, i);
20058 /* It's fairly hard to get "../oopsie" through unformat; just in case */
20059 if (strstr (file, "..") || index (file, '/'))
20061 errmsg ("illegal characters in filename '%s'", file);
20065 chroot_file = (char *) format (0, "/tmp/%s%c", file, 0);
20069 errmsg ("Saving %wd of %wd events to %s",
20070 elog_n_events_in_buffer (em),
20071 elog_buffer_capacity (em), chroot_file);
20073 error = elog_write_file (em, chroot_file, 1 /* flush ring */ );
20074 vec_free (chroot_file);
20077 clib_error_report (error);
20079 errmsg ("Use the vpp event loger...");
20086 elog_setup (vat_main_t * vam)
20088 #if VPP_API_TEST_BUILTIN == 0
20089 elog_main_t *em = &vam->elog_main;
20090 unformat_input_t *i = vam->input;
20091 u32 nevents = 128 << 10;
20093 (void) unformat (i, "nevents %d", &nevents);
20095 elog_init (em, nevents);
20096 vl_api_set_elog_main (em);
20097 vl_api_set_elog_trace_api_messages (1);
20098 errmsg ("Event logger initialized with %u events", nevents);
20100 errmsg ("Use the vpp event loger...");
20106 elog_enable (vat_main_t * vam)
20108 #if VPP_API_TEST_BUILTIN == 0
20109 elog_main_t *em = &vam->elog_main;
20111 elog_enable_disable (em, 1 /* enable */ );
20112 vl_api_set_elog_trace_api_messages (1);
20113 errmsg ("Event logger enabled...");
20115 errmsg ("Use the vpp event loger...");
20121 elog_disable (vat_main_t * vam)
20123 #if VPP_API_TEST_BUILTIN == 0
20124 elog_main_t *em = &vam->elog_main;
20126 elog_enable_disable (em, 0 /* enable */ );
20127 vl_api_set_elog_trace_api_messages (1);
20128 errmsg ("Event logger disabled...");
20130 errmsg ("Use the vpp event loger...");
20136 statseg (vat_main_t * vam)
20138 ssvm_private_t *ssvmp = &vam->stat_segment;
20139 ssvm_shared_header_t *shared_header = ssvmp->sh;
20140 vlib_counter_t **counters;
20141 u64 thread0_index1_packets;
20142 u64 thread0_index1_bytes;
20143 f64 vector_rate, input_rate;
20146 uword *counter_vector_by_name;
20147 if (vam->stat_segment_lockp == 0)
20149 errmsg ("Stat segment not mapped...");
20153 /* look up "/if/rx for sw_if_index 1 as a test */
20155 clib_spinlock_lock (vam->stat_segment_lockp);
20157 counter_vector_by_name = (uword *) shared_header->opaque[1];
20159 p = hash_get_mem (counter_vector_by_name, "/if/rx");
20162 clib_spinlock_unlock (vam->stat_segment_lockp);
20163 errmsg ("/if/tx not found?");
20167 /* Fish per-thread vector of combined counters from shared memory */
20168 counters = (vlib_counter_t **) p[0];
20170 if (vec_len (counters[0]) < 2)
20172 clib_spinlock_unlock (vam->stat_segment_lockp);
20173 errmsg ("/if/tx vector length %d", vec_len (counters[0]));
20177 /* Read thread 0 sw_if_index 1 counter */
20178 thread0_index1_packets = counters[0][1].packets;
20179 thread0_index1_bytes = counters[0][1].bytes;
20181 p = hash_get_mem (counter_vector_by_name, "vector_rate");
20184 clib_spinlock_unlock (vam->stat_segment_lockp);
20185 errmsg ("vector_rate not found?");
20189 vector_rate = *(f64 *) (p[0]);
20190 p = hash_get_mem (counter_vector_by_name, "input_rate");
20193 clib_spinlock_unlock (vam->stat_segment_lockp);
20194 errmsg ("input_rate not found?");
20197 input_rate = *(f64 *) (p[0]);
20199 clib_spinlock_unlock (vam->stat_segment_lockp);
20201 print (vam->ofp, "vector_rate %.2f input_rate %.2f",
20202 vector_rate, input_rate);
20203 print (vam->ofp, "thread 0 sw_if_index 1 rx pkts %lld, bytes %lld",
20204 thread0_index1_packets, thread0_index1_bytes);
20210 cmd_cmp (void *a1, void *a2)
20215 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
20219 help (vat_main_t * vam)
20224 unformat_input_t *i = vam->input;
20227 if (unformat (i, "%s", &name))
20231 vec_add1 (name, 0);
20233 hs = hash_get_mem (vam->help_by_name, name);
20235 print (vam->ofp, "usage: %s %s", name, hs[0]);
20237 print (vam->ofp, "No such msg / command '%s'", name);
20242 print (vam->ofp, "Help is available for the following:");
20245 hash_foreach_pair (p, vam->function_by_name,
20247 vec_add1 (cmds, (u8 *)(p->key));
20251 vec_sort_with_function (cmds, cmd_cmp);
20253 for (j = 0; j < vec_len (cmds); j++)
20254 print (vam->ofp, "%s", cmds[j]);
20261 set (vat_main_t * vam)
20263 u8 *name = 0, *value = 0;
20264 unformat_input_t *i = vam->input;
20266 if (unformat (i, "%s", &name))
20268 /* The input buffer is a vector, not a string. */
20269 value = vec_dup (i->buffer);
20270 vec_delete (value, i->index, 0);
20271 /* Almost certainly has a trailing newline */
20272 if (value[vec_len (value) - 1] == '\n')
20273 value[vec_len (value) - 1] = 0;
20274 /* Make sure it's a proper string, one way or the other */
20275 vec_add1 (value, 0);
20276 (void) clib_macro_set_value (&vam->macro_main,
20277 (char *) name, (char *) value);
20280 errmsg ("usage: set <name> <value>");
20288 unset (vat_main_t * vam)
20292 if (unformat (vam->input, "%s", &name))
20293 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
20294 errmsg ("unset: %s wasn't set", name);
20307 macro_sort_cmp (void *a1, void *a2)
20309 macro_sort_t *s1 = a1;
20310 macro_sort_t *s2 = a2;
20312 return strcmp ((char *) (s1->name), (char *) (s2->name));
20316 dump_macro_table (vat_main_t * vam)
20318 macro_sort_t *sort_me = 0, *sm;
20323 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
20325 vec_add2 (sort_me, sm, 1);
20326 sm->name = (u8 *)(p->key);
20327 sm->value = (u8 *) (p->value[0]);
20331 vec_sort_with_function (sort_me, macro_sort_cmp);
20333 if (vec_len (sort_me))
20334 print (vam->ofp, "%-15s%s", "Name", "Value");
20336 print (vam->ofp, "The macro table is empty...");
20338 for (i = 0; i < vec_len (sort_me); i++)
20339 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
20344 dump_node_table (vat_main_t * vam)
20347 vlib_node_t *node, *next_node;
20349 if (vec_len (vam->graph_nodes) == 0)
20351 print (vam->ofp, "Node table empty, issue get_node_graph...");
20355 for (i = 0; i < vec_len (vam->graph_nodes[0]); i++)
20357 node = vam->graph_nodes[0][i];
20358 print (vam->ofp, "[%d] %s", i, node->name);
20359 for (j = 0; j < vec_len (node->next_nodes); j++)
20361 if (node->next_nodes[j] != ~0)
20363 next_node = vam->graph_nodes[0][node->next_nodes[j]];
20364 print (vam->ofp, " [%d] %s", j, next_node->name);
20372 value_sort_cmp (void *a1, void *a2)
20374 name_sort_t *n1 = a1;
20375 name_sort_t *n2 = a2;
20377 if (n1->value < n2->value)
20379 if (n1->value > n2->value)
20386 dump_msg_api_table (vat_main_t * vam)
20388 api_main_t *am = vlibapi_get_main ();
20389 name_sort_t *nses = 0, *ns;
20394 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
20396 vec_add2 (nses, ns, 1);
20397 ns->name = (u8 *)(hp->key);
20398 ns->value = (u32) hp->value[0];
20402 vec_sort_with_function (nses, value_sort_cmp);
20404 for (i = 0; i < vec_len (nses); i++)
20405 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
20411 get_msg_id (vat_main_t * vam)
20416 if (unformat (vam->input, "%s", &name_and_crc))
20418 message_index = vl_msg_api_get_msg_index (name_and_crc);
20419 if (message_index == ~0)
20421 print (vam->ofp, " '%s' not found", name_and_crc);
20424 print (vam->ofp, " '%s' has message index %d",
20425 name_and_crc, message_index);
20428 errmsg ("name_and_crc required...");
20433 search_node_table (vat_main_t * vam)
20435 unformat_input_t *line_input = vam->input;
20438 vlib_node_t *node, *next_node;
20441 if (vam->graph_node_index_by_name == 0)
20443 print (vam->ofp, "Node table empty, issue get_node_graph...");
20447 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
20449 if (unformat (line_input, "%s", &node_to_find))
20451 vec_add1 (node_to_find, 0);
20452 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
20455 print (vam->ofp, "%s not found...", node_to_find);
20458 node = vam->graph_nodes[0][p[0]];
20459 print (vam->ofp, "[%d] %s", p[0], node->name);
20460 for (j = 0; j < vec_len (node->next_nodes); j++)
20462 if (node->next_nodes[j] != ~0)
20464 next_node = vam->graph_nodes[0][node->next_nodes[j]];
20465 print (vam->ofp, " [%d] %s", j, next_node->name);
20472 clib_warning ("parse error '%U'", format_unformat_error,
20478 vec_free (node_to_find);
20487 script (vat_main_t * vam)
20489 #if (VPP_API_TEST_BUILTIN==0)
20491 char *save_current_file;
20492 unformat_input_t save_input;
20493 jmp_buf save_jump_buf;
20494 u32 save_line_number;
20496 FILE *new_fp, *save_ifp;
20498 if (unformat (vam->input, "%s", &s))
20500 new_fp = fopen ((char *) s, "r");
20503 errmsg ("Couldn't open script file %s", s);
20510 errmsg ("Missing script name");
20514 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
20515 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
20516 save_ifp = vam->ifp;
20517 save_line_number = vam->input_line_number;
20518 save_current_file = (char *) vam->current_file;
20520 vam->input_line_number = 0;
20522 vam->current_file = s;
20525 clib_memcpy (&vam->input, &save_input, sizeof (save_input));
20526 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
20527 vam->ifp = save_ifp;
20528 vam->input_line_number = save_line_number;
20529 vam->current_file = (u8 *) save_current_file;
20534 clib_warning ("use the exec command...");
20540 echo (vat_main_t * vam)
20542 print (vam->ofp, "%v", vam->input->buffer);
20546 /* List of API message constructors, CLI names map to api_xxx */
20547 #define foreach_vpe_api_msg \
20548 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
20549 _(sw_interface_dump,"") \
20550 _(sw_interface_set_flags, \
20551 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
20552 _(sw_interface_add_del_address, \
20553 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
20554 _(sw_interface_set_rx_mode, \
20555 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
20556 _(sw_interface_set_rx_placement, \
20557 "<intfc> | sw_if_index <id> [queue <id>] [worker <id> | main]") \
20558 _(sw_interface_rx_placement_dump, \
20559 "[<intfc> | sw_if_index <id>]") \
20560 _(sw_interface_set_table, \
20561 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
20562 _(sw_interface_set_mpls_enable, \
20563 "<intfc> | sw_if_index [disable | dis]") \
20564 _(sw_interface_set_vpath, \
20565 "<intfc> | sw_if_index <id> enable | disable") \
20566 _(sw_interface_set_vxlan_bypass, \
20567 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
20568 _(sw_interface_set_geneve_bypass, \
20569 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
20570 _(sw_interface_set_l2_xconnect, \
20571 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
20572 "enable | disable") \
20573 _(sw_interface_set_l2_bridge, \
20574 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
20575 "[shg <split-horizon-group>] [bvi]\n" \
20576 "enable | disable") \
20577 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
20578 _(bridge_domain_add_del, \
20579 "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") \
20580 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
20582 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
20583 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
20584 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
20586 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
20588 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
20590 "id <num> [hw-addr <mac-addr>] [host-if-name <name>] [host-ns <name>] [num-rx-queues <num>] [rx-ring-size <num>] [tx-ring-size <num>] [host-bridge <name>] [host-mac-addr <mac-addr>] [host-ip4-addr <ip4addr/mask>] [host-ip6-addr <ip6addr/mask>] [host-mtu-size <mtu>] [gso | no-gso | csum-offload] [persist] [attach]") \
20592 "<vpp-if-name> | sw_if_index <id>") \
20593 _(sw_interface_tap_v2_dump, "") \
20594 _(virtio_pci_create, \
20595 "pci-addr <pci-address> [use_random_mac | hw-addr <mac-addr>] [features <hex-value>] [gso-enabled | csum-offload-enabled]") \
20596 _(virtio_pci_delete, \
20597 "<vpp-if-name> | sw_if_index <id>") \
20598 _(sw_interface_virtio_pci_dump, "") \
20600 "[hw-addr <mac-addr>] {round-robin | active-backup | " \
20601 "broadcast | {lacp | xor} [load-balance { l2 | l23 | l34 }]} " \
20604 "<vpp-if-name> | sw_if_index <id>") \
20606 "sw_if_index <n> bond <sw_if_index> [is_passive] [is_long_timeout]") \
20607 _(bond_detach_slave, \
20608 "sw_if_index <n>") \
20609 _(sw_interface_set_bond_weight, "<intfc> | sw_if_index <nn> weight <value>") \
20610 _(sw_interface_bond_dump, "") \
20611 _(sw_interface_slave_dump, \
20612 "<vpp-if-name> | sw_if_index <id>") \
20613 _(ip_table_add_del, \
20614 "table <n> [ipv6] [add | del]\n") \
20615 _(ip_route_add_del, \
20616 "<addr>/<mask> via <<addr>|<intfc>|sw_if_index <id>|via-label <n>>\n" \
20617 "[table-id <n>] [<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n"\
20618 "[weight <n>] [drop] [local] [classify <n>] [out-label <n>]\n" \
20619 "[multipath] [count <n>] [del]") \
20620 _(ip_mroute_add_del, \
20621 "<src> <grp>/<mask> [table-id <n>]\n" \
20622 "[<intfc> | sw_if_index <id>] [local] [del]") \
20623 _(mpls_table_add_del, \
20624 "table <n> [add | del]\n") \
20625 _(mpls_route_add_del, \
20626 "<label> <eos> via <addr | next-hop-table <n> | via-label <n> |\n" \
20627 "lookup-ip4-table <n> | lookup-in-ip6-table <n> |\n" \
20628 "l2-input-on <intfc> | l2-input-on sw_if_index <id>>\n" \
20629 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>] [weight <n>]\n" \
20630 "[drop] [local] [classify <n>] [out-label <n>] [multipath]\n" \
20631 "[count <n>] [del]") \
20632 _(mpls_ip_bind_unbind, \
20633 "<label> <addr/len>") \
20634 _(mpls_tunnel_add_del, \
20635 "[add | del <intfc | sw_if_index <id>>] via <addr | via-label <n>>\n" \
20636 "[<intfc> | sw_if_index <id> | next-hop-table <id>]\n" \
20637 "[l2-only] [out-label <n>]") \
20638 _(sr_mpls_policy_add, \
20639 "bsid <id> [weight <n>] [spray] next <sid> [next <sid>]") \
20640 _(sr_mpls_policy_del, \
20642 _(bier_table_add_del, \
20643 "<label> <sub-domain> <set> <bsl> [del]") \
20644 _(bier_route_add_del, \
20645 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
20646 "[<intfc> | sw_if_index <id>]" \
20647 "[weight <n>] [del] [multipath]") \
20648 _(sw_interface_set_unnumbered, \
20649 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
20650 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
20651 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
20652 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
20653 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
20654 "[outer_vlan_id_any][inner_vlan_id_any]") \
20655 _(ip_table_replace_begin, "table <n> [ipv6]") \
20656 _(ip_table_flush, "table <n> [ipv6]") \
20657 _(ip_table_replace_end, "table <n> [ipv6]") \
20658 _(set_ip_flow_hash, \
20659 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
20660 _(sw_interface_ip6_enable_disable, \
20661 "<intfc> | sw_if_index <id> enable | disable") \
20662 _(l2_patch_add_del, \
20663 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
20664 "enable | disable") \
20665 _(sr_localsid_add_del, \
20666 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
20667 "fib-table <num> (end.psp) sw_if_index <num>") \
20668 _(classify_add_del_table, \
20669 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
20670 " [del] [del-chain] mask <mask-value>\n" \
20671 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
20672 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
20673 _(classify_add_del_session, \
20674 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
20675 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
20676 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
20677 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
20678 _(classify_set_interface_ip_table, \
20679 "<intfc> | sw_if_index <nn> table <nn>") \
20680 _(classify_set_interface_l2_tables, \
20681 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20682 " [other-table <nn>]") \
20683 _(get_node_index, "node <node-name") \
20684 _(add_node_next, "node <node-name> next <next-node-name>") \
20685 _(l2tpv3_create_tunnel, \
20686 "client_address <ip6-addr> our_address <ip6-addr>\n" \
20687 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
20688 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
20689 _(l2tpv3_set_tunnel_cookies, \
20690 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
20691 "[new_remote_cookie <nn>]\n") \
20692 _(l2tpv3_interface_enable_disable, \
20693 "<intfc> | sw_if_index <nn> enable | disable") \
20694 _(l2tpv3_set_lookup_key, \
20695 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
20696 _(sw_if_l2tpv3_tunnel_dump, "") \
20697 _(vxlan_offload_rx, \
20698 "hw { <interface name> | hw_if_index <nn>} " \
20699 "rx { <vxlan tunnel name> | sw_if_index <nn> } [del]") \
20700 _(vxlan_add_del_tunnel, \
20701 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
20702 "{ <intfc> | mcast_sw_if_index <nn> } [instance <id>]}\n" \
20703 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
20704 _(geneve_add_del_tunnel, \
20705 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
20706 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
20707 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
20708 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20709 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20710 _(gre_tunnel_add_del, \
20711 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [instance <n>]\n" \
20712 "[teb | erspan <session-id>] [del]") \
20713 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20714 _(l2_fib_clear_table, "") \
20715 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
20716 _(l2_interface_vlan_tag_rewrite, \
20717 "<intfc> | sw_if_index <nn> \n" \
20718 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
20719 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
20720 _(create_vhost_user_if, \
20721 "socket <filename> [server] [renumber <dev_instance>] " \
20722 "[disable_mrg_rxbuf] [disable_indirect_desc] [gso] " \
20723 "[mac <mac_address>] [packed]") \
20724 _(modify_vhost_user_if, \
20725 "<intfc> | sw_if_index <nn> socket <filename>\n" \
20726 "[server] [renumber <dev_instance>] [gso] [packed]") \
20727 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
20728 _(sw_interface_vhost_user_dump, "") \
20729 _(show_version, "") \
20730 _(show_threads, "") \
20731 _(vxlan_gpe_add_del_tunnel, \
20732 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
20733 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
20734 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
20735 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
20736 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
20737 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
20738 _(interface_name_renumber, \
20739 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
20740 _(input_acl_set_interface, \
20741 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20742 " [l2-table <nn>] [del]") \
20743 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
20744 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
20745 _(ip_dump, "ipv4 | ipv6") \
20746 _(ipsec_spd_add_del, "spd_id <n> [del]") \
20747 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
20749 _(ipsec_sad_entry_add_del, "sad_id <n> spi <n> crypto_alg <alg>\n" \
20750 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
20751 " integ_alg <alg> integ_key <hex>") \
20752 _(ipsec_spd_entry_add_del, "spd_id <n> priority <n> action <action>\n" \
20753 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
20754 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
20755 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
20756 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
20757 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
20758 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
20759 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n" \
20760 " [instance <n>]") \
20761 _(ipsec_sa_dump, "[sa_id <n>]") \
20762 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
20763 _(delete_loopback,"sw_if_index <nn>") \
20764 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
20765 _(bd_ip_mac_flush, "bd_id <bridge-domain-id>") \
20766 _(bd_ip_mac_dump, "[bd_id] <bridge-domain-id>") \
20767 _(want_interface_events, "enable|disable") \
20768 _(get_first_msg_id, "client <name>") \
20769 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
20770 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
20771 "fib-id <nn> [ip4][ip6][default]") \
20772 _(get_node_graph, " ") \
20773 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
20774 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
20775 _(ioam_disable, "") \
20776 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
20777 " sw_if_index <sw_if_index> p <priority> " \
20778 "w <weight>] [del]") \
20779 _(one_add_del_locator, "locator-set <locator_name> " \
20780 "iface <intf> | sw_if_index <sw_if_index> " \
20781 "p <priority> w <weight> [del]") \
20782 _(one_add_del_local_eid,"vni <vni> eid " \
20783 "<ipv4|ipv6>/<prefix> | <L2 address> " \
20784 "locator-set <locator_name> [del]" \
20785 "[key-id sha1|sha256 secret-key <secret-key>]")\
20786 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
20787 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
20788 _(one_enable_disable, "enable|disable") \
20789 _(one_map_register_enable_disable, "enable|disable") \
20790 _(one_map_register_fallback_threshold, "<value>") \
20791 _(one_rloc_probe_enable_disable, "enable|disable") \
20792 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
20794 "rloc <locator> p <prio> " \
20795 "w <weight> [rloc <loc> ... ] " \
20796 "action <action> [del-all]") \
20797 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
20799 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
20800 _(one_use_petr, "ip-address> | disable") \
20801 _(one_map_request_mode, "src-dst|dst-only") \
20802 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
20803 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
20804 _(one_locator_set_dump, "[local | remote]") \
20805 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
20806 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
20807 "[local] | [remote]") \
20808 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
20809 _(one_ndp_bd_get, "") \
20810 _(one_ndp_entries_get, "bd <bridge-domain>") \
20811 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
20812 _(one_l2_arp_bd_get, "") \
20813 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
20814 _(one_stats_enable_disable, "enable|disable") \
20815 _(show_one_stats_enable_disable, "") \
20816 _(one_eid_table_vni_dump, "") \
20817 _(one_eid_table_map_dump, "l2|l3") \
20818 _(one_map_resolver_dump, "") \
20819 _(one_map_server_dump, "") \
20820 _(one_adjacencies_get, "vni <vni>") \
20821 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
20822 _(show_one_rloc_probe_state, "") \
20823 _(show_one_map_register_state, "") \
20824 _(show_one_status, "") \
20825 _(one_stats_dump, "") \
20826 _(one_stats_flush, "") \
20827 _(one_get_map_request_itr_rlocs, "") \
20828 _(one_map_register_set_ttl, "<ttl>") \
20829 _(one_set_transport_protocol, "udp|api") \
20830 _(one_get_transport_protocol, "") \
20831 _(one_enable_disable_xtr_mode, "enable|disable") \
20832 _(one_show_xtr_mode, "") \
20833 _(one_enable_disable_pitr_mode, "enable|disable") \
20834 _(one_show_pitr_mode, "") \
20835 _(one_enable_disable_petr_mode, "enable|disable") \
20836 _(one_show_petr_mode, "") \
20837 _(show_one_nsh_mapping, "") \
20838 _(show_one_pitr, "") \
20839 _(show_one_use_petr, "") \
20840 _(show_one_map_request_mode, "") \
20841 _(show_one_map_register_ttl, "") \
20842 _(show_one_map_register_fallback_threshold, "") \
20843 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
20844 " sw_if_index <sw_if_index> p <priority> " \
20845 "w <weight>] [del]") \
20846 _(lisp_add_del_locator, "locator-set <locator_name> " \
20847 "iface <intf> | sw_if_index <sw_if_index> " \
20848 "p <priority> w <weight> [del]") \
20849 _(lisp_add_del_local_eid,"vni <vni> eid " \
20850 "<ipv4|ipv6>/<prefix> | <L2 address> " \
20851 "locator-set <locator_name> [del]" \
20852 "[key-id sha1|sha256 secret-key <secret-key>]") \
20853 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
20854 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
20855 _(lisp_enable_disable, "enable|disable") \
20856 _(lisp_map_register_enable_disable, "enable|disable") \
20857 _(lisp_rloc_probe_enable_disable, "enable|disable") \
20858 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
20860 "rloc <locator> p <prio> " \
20861 "w <weight> [rloc <loc> ... ] " \
20862 "action <action> [del-all]") \
20863 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
20865 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
20866 _(lisp_use_petr, "<ip-address> | disable") \
20867 _(lisp_map_request_mode, "src-dst|dst-only") \
20868 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
20869 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
20870 _(lisp_locator_set_dump, "[local | remote]") \
20871 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
20872 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
20873 "[local] | [remote]") \
20874 _(lisp_eid_table_vni_dump, "") \
20875 _(lisp_eid_table_map_dump, "l2|l3") \
20876 _(lisp_map_resolver_dump, "") \
20877 _(lisp_map_server_dump, "") \
20878 _(lisp_adjacencies_get, "vni <vni>") \
20879 _(gpe_fwd_entry_vnis_get, "") \
20880 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
20881 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
20882 "[table <table-id>]") \
20883 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
20884 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
20885 _(gpe_set_encap_mode, "lisp|vxlan") \
20886 _(gpe_get_encap_mode, "") \
20887 _(lisp_gpe_add_del_iface, "up|down") \
20888 _(lisp_gpe_enable_disable, "enable|disable") \
20889 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
20890 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
20891 _(show_lisp_rloc_probe_state, "") \
20892 _(show_lisp_map_register_state, "") \
20893 _(show_lisp_status, "") \
20894 _(lisp_get_map_request_itr_rlocs, "") \
20895 _(show_lisp_pitr, "") \
20896 _(show_lisp_use_petr, "") \
20897 _(show_lisp_map_request_mode, "") \
20898 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
20899 _(af_packet_delete, "name <host interface name>") \
20900 _(af_packet_dump, "") \
20901 _(policer_add_del, "name <policer name> <params> [del]") \
20902 _(policer_dump, "[name <policer name>]") \
20903 _(policer_classify_set_interface, \
20904 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20905 " [l2-table <nn>] [del]") \
20906 _(policer_classify_dump, "type [ip4|ip6|l2]") \
20907 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
20908 _(mpls_table_dump, "") \
20909 _(mpls_route_dump, "table-id <ID>") \
20910 _(classify_table_ids, "") \
20911 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
20912 _(classify_table_info, "table_id <nn>") \
20913 _(classify_session_dump, "table_id <nn>") \
20914 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
20915 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
20916 "[template_interval <nn>] [udp_checksum]") \
20917 _(ipfix_exporter_dump, "") \
20918 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
20919 _(ipfix_classify_stream_dump, "") \
20920 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
20921 _(ipfix_classify_table_dump, "") \
20922 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
20923 _(sw_interface_span_dump, "[l2]") \
20924 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
20925 _(pg_create_interface, "if_id <nn> [gso-enabled gso-size <size>]") \
20926 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
20927 _(pg_enable_disable, "[stream <id>] disable") \
20928 _(ip_source_and_port_range_check_add_del, \
20929 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
20930 _(ip_source_and_port_range_check_interface_add_del, \
20931 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
20932 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
20933 _(delete_subif,"<intfc> | sw_if_index <nn>") \
20934 _(l2_interface_pbb_tag_rewrite, \
20935 "<intfc> | sw_if_index <nn> \n" \
20936 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
20937 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
20938 _(set_punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
20939 _(flow_classify_set_interface, \
20940 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
20941 _(flow_classify_dump, "type [ip4|ip6]") \
20942 _(ip_table_dump, "") \
20943 _(ip_route_dump, "table-id [ip4|ip6]") \
20944 _(ip_mtable_dump, "") \
20945 _(ip_mroute_dump, "table-id [ip4|ip6]") \
20946 _(feature_enable_disable, "arc_name <arc_name> " \
20947 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
20948 _(feature_gso_enable_disable, "<intfc> | sw_if_index <nn> " \
20949 "[enable | disable] ") \
20950 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
20952 _(sw_interface_add_del_mac_address, "<intfc> | sw_if_index <nn> " \
20953 "mac <mac-address> [del]") \
20954 _(l2_xconnect_dump, "") \
20955 _(hw_interface_set_mtu, "<intfc> | hw_if_index <nn> mtu <nn>") \
20956 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
20957 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
20958 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
20959 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
20960 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
20961 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
20962 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
20963 _(sock_init_shm, "size <nnn>") \
20964 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
20965 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
20966 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
20967 _(session_rules_dump, "") \
20968 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
20969 _(output_acl_set_interface, \
20970 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
20971 " [l2-table <nn>] [del]") \
20972 _(qos_record_enable_disable, "<record-source> <intfc> | sw_if_index <id> [disable]")
20974 /* List of command functions, CLI names map directly to functions */
20975 #define foreach_cli_function \
20976 _(comment, "usage: comment <ignore-rest-of-line>") \
20977 _(dump_interface_table, "usage: dump_interface_table") \
20978 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
20979 _(dump_ipv4_table, "usage: dump_ipv4_table") \
20980 _(dump_ipv6_table, "usage: dump_ipv6_table") \
20981 _(dump_macro_table, "usage: dump_macro_table ") \
20982 _(dump_node_table, "usage: dump_node_table") \
20983 _(dump_msg_api_table, "usage: dump_msg_api_table") \
20984 _(elog_setup, "usage: elog_setup [nevents, default 128K]") \
20985 _(elog_disable, "usage: elog_disable") \
20986 _(elog_enable, "usage: elog_enable") \
20987 _(elog_save, "usage: elog_save <filename>") \
20988 _(get_msg_id, "usage: get_msg_id name_and_crc") \
20989 _(echo, "usage: echo <message>") \
20990 _(exec, "usage: exec <vpe-debug-CLI-command>") \
20991 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
20992 _(help, "usage: help") \
20993 _(q, "usage: quit") \
20994 _(quit, "usage: quit") \
20995 _(search_node_table, "usage: search_node_table <name>...") \
20996 _(set, "usage: set <variable-name> <value>") \
20997 _(script, "usage: script <file-name>") \
20998 _(statseg, "usage: statseg") \
20999 _(unset, "usage: unset <variable-name>")
21002 static void vl_api_##n##_t_handler_uni \
21003 (vl_api_##n##_t * mp) \
21005 vat_main_t * vam = &vat_main; \
21006 if (vam->json_output) { \
21007 vl_api_##n##_t_handler_json(mp); \
21009 vl_api_##n##_t_handler(mp); \
21012 foreach_vpe_api_reply_msg;
21013 #if VPP_API_TEST_BUILTIN == 0
21014 foreach_standalone_reply_msg;
21019 vat_api_hookup (vat_main_t * vam)
21022 vl_msg_api_set_handlers(VL_API_##N, #n, \
21023 vl_api_##n##_t_handler_uni, \
21025 vl_api_##n##_t_endian, \
21026 vl_api_##n##_t_print, \
21027 sizeof(vl_api_##n##_t), 1);
21028 foreach_vpe_api_reply_msg;
21029 #if VPP_API_TEST_BUILTIN == 0
21030 foreach_standalone_reply_msg;
21034 #if (VPP_API_TEST_BUILTIN==0)
21035 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
21037 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
21039 vam->function_by_name = hash_create_string (0, sizeof (uword));
21041 vam->help_by_name = hash_create_string (0, sizeof (uword));
21044 /* API messages we can send */
21045 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
21046 foreach_vpe_api_msg;
21050 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
21051 foreach_vpe_api_msg;
21054 /* CLI functions */
21055 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
21056 foreach_cli_function;
21060 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
21061 foreach_cli_function;
21065 #if VPP_API_TEST_BUILTIN
21066 static clib_error_t *
21067 vat_api_hookup_shim (vlib_main_t * vm)
21069 vat_api_hookup (&vat_main);
21073 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
21077 * fd.io coding-style-patch-verification: ON
21080 * eval: (c-set-style "gnu")