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 <vppinfra/socket.h>
22 #include <svm/memfd.h>
23 #include <vlibapi/api.h>
24 #include <vlibmemory/api.h>
25 #include <vnet/ip/ip.h>
26 #include <vnet/l2/l2_input.h>
27 #include <vnet/l2tp/l2tp.h>
28 #include <vnet/vxlan/vxlan.h>
29 #include <vnet/geneve/geneve.h>
30 #include <vnet/gre/gre.h>
31 #include <vnet/vxlan-gpe/vxlan_gpe.h>
32 #include <vnet/lisp-gpe/lisp_gpe.h>
34 #include <vpp/api/vpe_msg_enum.h>
35 #include <vnet/l2/l2_classify.h>
36 #include <vnet/l2/l2_vtr.h>
37 #include <vnet/classify/input_acl.h>
38 #include <vnet/classify/policer_classify.h>
39 #include <vnet/classify/flow_classify.h>
40 #include <vnet/mpls/mpls.h>
41 #include <vnet/ipsec/ipsec.h>
42 #include <vnet/ipsec/ikev2.h>
44 #include <vnet/map/map.h>
45 #include <vnet/cop/cop.h>
46 #include <vnet/ip/ip6_hop_by_hop.h>
47 #include <vnet/ip/ip_source_and_port_range_check.h>
48 #include <vnet/policer/xlate.h>
49 #include <vnet/span/span.h>
50 #include <vnet/policer/policer.h>
51 #include <vnet/policer/police.h>
52 #include <vnet/mfib/mfib_types.h>
53 #include <vnet/dhcp/dhcp_proxy.h>
55 #include "vat/json_format.h"
60 #define vl_typedefs /* define message structures */
61 #include <vpp/api/vpe_all_api_h.h>
64 /* declare message handlers for each api */
66 #define vl_endianfun /* define message structures */
67 #include <vpp/api/vpe_all_api_h.h>
70 /* instantiate all the print functions we know about */
71 #define vl_print(handle, ...)
73 #include <vpp/api/vpe_all_api_h.h>
76 #define __plugin_msg_base 0
77 #include <vlibapi/vat_helper_macros.h>
79 #if VPP_API_TEST_BUILTIN == 0
89 vat_socket_connect (vat_main_t * vam)
91 return vl_socket_client_connect
92 (&vam->socket_client_main, (char *) vam->socket_name,
93 "vpp_api_test(s)", 0 /* default socket rx, tx buffer */ );
95 #else /* vpp built-in case, we don't do sockets... */
97 vat_socket_connect (vat_main_t * vam)
103 vl_socket_client_read_reply (socket_client_main_t * scm)
110 vat_time_now (vat_main_t * vam)
112 #if VPP_API_TEST_BUILTIN
113 return vlib_time_now (vam->vlib_main);
115 return clib_time_now (&vam->clib_time);
120 errmsg (char *fmt, ...)
122 vat_main_t *vam = &vat_main;
127 s = va_format (0, fmt, &va);
132 #if VPP_API_TEST_BUILTIN
133 vlib_cli_output (vam->vlib_main, (char *) s);
136 if (vam->ifp != stdin)
137 fformat (vam->ofp, "%s(%d): \n", vam->current_file,
138 vam->input_line_number);
139 fformat (vam->ofp, (char *) s);
147 #if VPP_API_TEST_BUILTIN == 0
149 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
151 vat_main_t *vam = va_arg (*args, vat_main_t *);
152 u32 *result = va_arg (*args, u32 *);
156 if (!unformat (input, "%s", &if_name))
159 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
166 /* Parse an IP4 address %d.%d.%d.%d. */
168 unformat_ip4_address (unformat_input_t * input, va_list * args)
170 u8 *result = va_arg (*args, u8 *);
173 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
176 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
188 unformat_ethernet_address (unformat_input_t * input, va_list * args)
190 u8 *result = va_arg (*args, u8 *);
193 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
194 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
198 for (i = 0; i < 6; i++)
199 if (a[i] >= (1 << 8))
202 for (i = 0; i < 6; i++)
208 /* Returns ethernet type as an int in host byte order. */
210 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
213 u16 *result = va_arg (*args, u16 *);
217 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
219 if (type >= (1 << 16))
227 /* Parse an IP6 address. */
229 unformat_ip6_address (unformat_input_t * input, va_list * args)
231 ip6_address_t *result = va_arg (*args, ip6_address_t *);
233 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
234 uword c, n_colon, double_colon_index;
236 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
237 double_colon_index = ARRAY_LEN (hex_quads);
238 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
241 if (c >= '0' && c <= '9')
243 else if (c >= 'a' && c <= 'f')
244 hex_digit = c + 10 - 'a';
245 else if (c >= 'A' && c <= 'F')
246 hex_digit = c + 10 - 'A';
247 else if (c == ':' && n_colon < 2)
251 unformat_put_input (input);
255 /* Too many hex quads. */
256 if (n_hex_quads >= ARRAY_LEN (hex_quads))
261 hex_quad = (hex_quad << 4) | hex_digit;
263 /* Hex quad must fit in 16 bits. */
264 if (n_hex_digits >= 4)
271 /* Save position of :: */
274 /* More than one :: ? */
275 if (double_colon_index < ARRAY_LEN (hex_quads))
277 double_colon_index = n_hex_quads;
280 if (n_colon > 0 && n_hex_digits > 0)
282 hex_quads[n_hex_quads++] = hex_quad;
288 if (n_hex_digits > 0)
289 hex_quads[n_hex_quads++] = hex_quad;
294 /* Expand :: to appropriate number of zero hex quads. */
295 if (double_colon_index < ARRAY_LEN (hex_quads))
297 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
299 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
300 hex_quads[n_zero + i] = hex_quads[i];
302 for (i = 0; i < n_zero; i++)
303 hex_quads[double_colon_index + i] = 0;
305 n_hex_quads = ARRAY_LEN (hex_quads);
308 /* Too few hex quads given. */
309 if (n_hex_quads < ARRAY_LEN (hex_quads))
312 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
313 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
320 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
322 u32 *r = va_arg (*args, u32 *);
325 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
326 foreach_ipsec_policy_action
334 unformat_ipsec_crypto_alg (unformat_input_t * input, va_list * args)
336 u32 *r = va_arg (*args, u32 *);
339 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_CRYPTO_ALG_##f;
340 foreach_ipsec_crypto_alg
348 format_ipsec_crypto_alg (u8 * s, va_list * args)
350 u32 i = va_arg (*args, u32);
355 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
356 foreach_ipsec_crypto_alg
359 return format (s, "unknown");
361 return format (s, "%s", t);
365 unformat_ipsec_integ_alg (unformat_input_t * input, va_list * args)
367 u32 *r = va_arg (*args, u32 *);
370 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_INTEG_ALG_##f;
371 foreach_ipsec_integ_alg
379 format_ipsec_integ_alg (u8 * s, va_list * args)
381 u32 i = va_arg (*args, u32);
386 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
387 foreach_ipsec_integ_alg
390 return format (s, "unknown");
392 return format (s, "%s", t);
396 unformat_ikev2_auth_method (unformat_input_t * input, va_list * args)
398 u32 *r = va_arg (*args, u32 *);
401 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_AUTH_METHOD_##f;
402 foreach_ikev2_auth_method
410 unformat_ikev2_id_type (unformat_input_t * input, va_list * args)
412 u32 *r = va_arg (*args, u32 *);
415 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_ID_TYPE_##f;
416 foreach_ikev2_id_type
422 #else /* VPP_API_TEST_BUILTIN == 1 */
424 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
426 vat_main_t *vam __attribute__ ((unused)) = va_arg (*args, vat_main_t *);
427 vnet_main_t *vnm = vnet_get_main ();
428 u32 *result = va_arg (*args, u32 *);
431 if (!unformat (input, "%U", unformat_vnet_sw_interface, vnm, &sw_if_index))
434 *result = sw_if_index;
437 #endif /* VPP_API_TEST_BUILTIN */
440 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
442 u8 *r = va_arg (*args, u8 *);
444 if (unformat (input, "kbps"))
445 *r = SSE2_QOS_RATE_KBPS;
446 else if (unformat (input, "pps"))
447 *r = SSE2_QOS_RATE_PPS;
454 unformat_policer_round_type (unformat_input_t * input, va_list * args)
456 u8 *r = va_arg (*args, u8 *);
458 if (unformat (input, "closest"))
459 *r = SSE2_QOS_ROUND_TO_CLOSEST;
460 else if (unformat (input, "up"))
461 *r = SSE2_QOS_ROUND_TO_UP;
462 else if (unformat (input, "down"))
463 *r = SSE2_QOS_ROUND_TO_DOWN;
470 unformat_policer_type (unformat_input_t * input, va_list * args)
472 u8 *r = va_arg (*args, u8 *);
474 if (unformat (input, "1r2c"))
475 *r = SSE2_QOS_POLICER_TYPE_1R2C;
476 else if (unformat (input, "1r3c"))
477 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
478 else if (unformat (input, "2r3c-2698"))
479 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
480 else if (unformat (input, "2r3c-4115"))
481 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
482 else if (unformat (input, "2r3c-mef5cf1"))
483 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
490 unformat_dscp (unformat_input_t * input, va_list * va)
492 u8 *r = va_arg (*va, u8 *);
495 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
504 unformat_policer_action_type (unformat_input_t * input, va_list * va)
506 sse2_qos_pol_action_params_st *a
507 = va_arg (*va, sse2_qos_pol_action_params_st *);
509 if (unformat (input, "drop"))
510 a->action_type = SSE2_QOS_ACTION_DROP;
511 else if (unformat (input, "transmit"))
512 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
513 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
514 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
521 unformat_policer_classify_table_type (unformat_input_t * input, va_list * va)
523 u32 *r = va_arg (*va, u32 *);
526 if (unformat (input, "ip4"))
527 tid = POLICER_CLASSIFY_TABLE_IP4;
528 else if (unformat (input, "ip6"))
529 tid = POLICER_CLASSIFY_TABLE_IP6;
530 else if (unformat (input, "l2"))
531 tid = POLICER_CLASSIFY_TABLE_L2;
540 unformat_flow_classify_table_type (unformat_input_t * input, va_list * va)
542 u32 *r = va_arg (*va, u32 *);
545 if (unformat (input, "ip4"))
546 tid = FLOW_CLASSIFY_TABLE_IP4;
547 else if (unformat (input, "ip6"))
548 tid = FLOW_CLASSIFY_TABLE_IP6;
556 static const char *mfib_flag_names[] = MFIB_ENTRY_NAMES_SHORT;
557 static const char *mfib_flag_long_names[] = MFIB_ENTRY_NAMES_LONG;
558 static const char *mfib_itf_flag_long_names[] = MFIB_ITF_NAMES_LONG;
559 static const char *mfib_itf_flag_names[] = MFIB_ITF_NAMES_SHORT;
561 #if (VPP_API_TEST_BUILTIN==0)
563 unformat_mfib_itf_flags (unformat_input_t * input, va_list * args)
565 mfib_itf_flags_t old, *iflags = va_arg (*args, mfib_itf_flags_t *);
566 mfib_itf_attribute_t attr;
569 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
571 if (unformat (input, mfib_itf_flag_long_names[attr]))
572 *iflags |= (1 << attr);
574 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
576 if (unformat (input, mfib_itf_flag_names[attr]))
577 *iflags |= (1 << attr);
580 return (old == *iflags ? 0 : 1);
584 unformat_mfib_entry_flags (unformat_input_t * input, va_list * args)
586 mfib_entry_flags_t old, *eflags = va_arg (*args, mfib_entry_flags_t *);
587 mfib_entry_attribute_t attr;
590 FOR_EACH_MFIB_ATTRIBUTE (attr)
592 if (unformat (input, mfib_flag_long_names[attr]))
593 *eflags |= (1 << attr);
595 FOR_EACH_MFIB_ATTRIBUTE (attr)
597 if (unformat (input, mfib_flag_names[attr]))
598 *eflags |= (1 << attr);
601 return (old == *eflags ? 0 : 1);
605 format_ip4_address (u8 * s, va_list * args)
607 u8 *a = va_arg (*args, u8 *);
608 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
612 format_ip6_address (u8 * s, va_list * args)
614 ip6_address_t *a = va_arg (*args, ip6_address_t *);
615 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
617 i_max_n_zero = ARRAY_LEN (a->as_u16);
619 i_first_zero = i_max_n_zero;
621 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
623 u32 is_zero = a->as_u16[i] == 0;
624 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
630 if ((!is_zero && n_zeros > max_n_zeros)
631 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
633 i_max_n_zero = i_first_zero;
634 max_n_zeros = n_zeros;
635 i_first_zero = ARRAY_LEN (a->as_u16);
640 last_double_colon = 0;
641 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
643 if (i == i_max_n_zero && max_n_zeros > 1)
645 s = format (s, "::");
646 i += max_n_zeros - 1;
647 last_double_colon = 1;
651 s = format (s, "%s%x",
652 (last_double_colon || i == 0) ? "" : ":",
653 clib_net_to_host_u16 (a->as_u16[i]));
654 last_double_colon = 0;
661 /* Format an IP46 address. */
663 format_ip46_address (u8 * s, va_list * args)
665 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
666 ip46_type_t type = va_arg (*args, ip46_type_t);
672 is_ip4 = ip46_address_is_ip4 (ip46);
683 format (s, "%U", format_ip4_address, &ip46->ip4) :
684 format (s, "%U", format_ip6_address, &ip46->ip6);
688 format_ethernet_address (u8 * s, va_list * args)
690 u8 *a = va_arg (*args, u8 *);
692 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
693 a[0], a[1], a[2], a[3], a[4], a[5]);
698 increment_v4_address (ip4_address_t * a)
702 v = ntohl (a->as_u32) + 1;
703 a->as_u32 = ntohl (v);
707 increment_v6_address (ip6_address_t * a)
711 v0 = clib_net_to_host_u64 (a->as_u64[0]);
712 v1 = clib_net_to_host_u64 (a->as_u64[1]);
717 a->as_u64[0] = clib_net_to_host_u64 (v0);
718 a->as_u64[1] = clib_net_to_host_u64 (v1);
722 increment_mac_address (u8 * mac)
724 u64 tmp = *((u64 *) mac);
725 tmp = clib_net_to_host_u64 (tmp);
726 tmp += 1 << 16; /* skip unused (least significant) octets */
727 tmp = clib_host_to_net_u64 (tmp);
729 clib_memcpy (mac, &tmp, 6);
732 static void vl_api_create_loopback_reply_t_handler
733 (vl_api_create_loopback_reply_t * mp)
735 vat_main_t *vam = &vat_main;
736 i32 retval = ntohl (mp->retval);
738 vam->retval = retval;
739 vam->regenerate_interface_table = 1;
740 vam->sw_if_index = ntohl (mp->sw_if_index);
741 vam->result_ready = 1;
744 static void vl_api_create_loopback_reply_t_handler_json
745 (vl_api_create_loopback_reply_t * mp)
747 vat_main_t *vam = &vat_main;
748 vat_json_node_t node;
750 vat_json_init_object (&node);
751 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
752 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
754 vat_json_print (vam->ofp, &node);
755 vat_json_free (&node);
756 vam->retval = ntohl (mp->retval);
757 vam->result_ready = 1;
760 static void vl_api_create_loopback_instance_reply_t_handler
761 (vl_api_create_loopback_instance_reply_t * mp)
763 vat_main_t *vam = &vat_main;
764 i32 retval = ntohl (mp->retval);
766 vam->retval = retval;
767 vam->regenerate_interface_table = 1;
768 vam->sw_if_index = ntohl (mp->sw_if_index);
769 vam->result_ready = 1;
772 static void vl_api_create_loopback_instance_reply_t_handler_json
773 (vl_api_create_loopback_instance_reply_t * mp)
775 vat_main_t *vam = &vat_main;
776 vat_json_node_t node;
778 vat_json_init_object (&node);
779 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
780 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
782 vat_json_print (vam->ofp, &node);
783 vat_json_free (&node);
784 vam->retval = ntohl (mp->retval);
785 vam->result_ready = 1;
788 static void vl_api_af_packet_create_reply_t_handler
789 (vl_api_af_packet_create_reply_t * mp)
791 vat_main_t *vam = &vat_main;
792 i32 retval = ntohl (mp->retval);
794 vam->retval = retval;
795 vam->regenerate_interface_table = 1;
796 vam->sw_if_index = ntohl (mp->sw_if_index);
797 vam->result_ready = 1;
800 static void vl_api_af_packet_create_reply_t_handler_json
801 (vl_api_af_packet_create_reply_t * mp)
803 vat_main_t *vam = &vat_main;
804 vat_json_node_t node;
806 vat_json_init_object (&node);
807 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
808 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
810 vat_json_print (vam->ofp, &node);
811 vat_json_free (&node);
813 vam->retval = ntohl (mp->retval);
814 vam->result_ready = 1;
817 static void vl_api_create_vlan_subif_reply_t_handler
818 (vl_api_create_vlan_subif_reply_t * mp)
820 vat_main_t *vam = &vat_main;
821 i32 retval = ntohl (mp->retval);
823 vam->retval = retval;
824 vam->regenerate_interface_table = 1;
825 vam->sw_if_index = ntohl (mp->sw_if_index);
826 vam->result_ready = 1;
829 static void vl_api_create_vlan_subif_reply_t_handler_json
830 (vl_api_create_vlan_subif_reply_t * mp)
832 vat_main_t *vam = &vat_main;
833 vat_json_node_t node;
835 vat_json_init_object (&node);
836 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
837 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
839 vat_json_print (vam->ofp, &node);
840 vat_json_free (&node);
842 vam->retval = ntohl (mp->retval);
843 vam->result_ready = 1;
846 static void vl_api_create_subif_reply_t_handler
847 (vl_api_create_subif_reply_t * mp)
849 vat_main_t *vam = &vat_main;
850 i32 retval = ntohl (mp->retval);
852 vam->retval = retval;
853 vam->regenerate_interface_table = 1;
854 vam->sw_if_index = ntohl (mp->sw_if_index);
855 vam->result_ready = 1;
858 static void vl_api_create_subif_reply_t_handler_json
859 (vl_api_create_subif_reply_t * mp)
861 vat_main_t *vam = &vat_main;
862 vat_json_node_t node;
864 vat_json_init_object (&node);
865 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
866 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
868 vat_json_print (vam->ofp, &node);
869 vat_json_free (&node);
871 vam->retval = ntohl (mp->retval);
872 vam->result_ready = 1;
875 static void vl_api_interface_name_renumber_reply_t_handler
876 (vl_api_interface_name_renumber_reply_t * mp)
878 vat_main_t *vam = &vat_main;
879 i32 retval = ntohl (mp->retval);
881 vam->retval = retval;
882 vam->regenerate_interface_table = 1;
883 vam->result_ready = 1;
886 static void vl_api_interface_name_renumber_reply_t_handler_json
887 (vl_api_interface_name_renumber_reply_t * mp)
889 vat_main_t *vam = &vat_main;
890 vat_json_node_t node;
892 vat_json_init_object (&node);
893 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
895 vat_json_print (vam->ofp, &node);
896 vat_json_free (&node);
898 vam->retval = ntohl (mp->retval);
899 vam->result_ready = 1;
903 * Special-case: build the interface table, maintain
904 * the next loopback sw_if_index vbl.
906 static void vl_api_sw_interface_details_t_handler
907 (vl_api_sw_interface_details_t * mp)
909 vat_main_t *vam = &vat_main;
910 u8 *s = format (0, "%s%c", mp->interface_name, 0);
912 hash_set_mem (vam->sw_if_index_by_interface_name, s,
913 ntohl (mp->sw_if_index));
915 /* In sub interface case, fill the sub interface table entry */
916 if (mp->sw_if_index != mp->sup_sw_if_index)
918 sw_interface_subif_t *sub = NULL;
920 vec_add2 (vam->sw_if_subif_table, sub, 1);
922 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
923 strncpy ((char *) sub->interface_name, (char *) s,
924 vec_len (sub->interface_name));
925 sub->sw_if_index = ntohl (mp->sw_if_index);
926 sub->sub_id = ntohl (mp->sub_id);
928 sub->sub_dot1ad = mp->sub_dot1ad;
929 sub->sub_number_of_tags = mp->sub_number_of_tags;
930 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
931 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
932 sub->sub_exact_match = mp->sub_exact_match;
933 sub->sub_default = mp->sub_default;
934 sub->sub_outer_vlan_id_any = mp->sub_outer_vlan_id_any;
935 sub->sub_inner_vlan_id_any = mp->sub_inner_vlan_id_any;
937 /* vlan tag rewrite */
938 sub->vtr_op = ntohl (mp->vtr_op);
939 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
940 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
941 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
945 static void vl_api_sw_interface_details_t_handler_json
946 (vl_api_sw_interface_details_t * mp)
948 vat_main_t *vam = &vat_main;
949 vat_json_node_t *node = NULL;
951 if (VAT_JSON_ARRAY != vam->json_tree.type)
953 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
954 vat_json_init_array (&vam->json_tree);
956 node = vat_json_array_add (&vam->json_tree);
958 vat_json_init_object (node);
959 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
960 vat_json_object_add_uint (node, "sup_sw_if_index",
961 ntohl (mp->sup_sw_if_index));
962 vat_json_object_add_uint (node, "l2_address_length",
963 ntohl (mp->l2_address_length));
964 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
965 sizeof (mp->l2_address));
966 vat_json_object_add_string_copy (node, "interface_name",
968 vat_json_object_add_uint (node, "admin_up_down", mp->admin_up_down);
969 vat_json_object_add_uint (node, "link_up_down", mp->link_up_down);
970 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
971 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
972 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
973 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
974 vat_json_object_add_uint (node, "sub_dot1ad", mp->sub_dot1ad);
975 vat_json_object_add_uint (node, "sub_number_of_tags",
976 mp->sub_number_of_tags);
977 vat_json_object_add_uint (node, "sub_outer_vlan_id",
978 ntohs (mp->sub_outer_vlan_id));
979 vat_json_object_add_uint (node, "sub_inner_vlan_id",
980 ntohs (mp->sub_inner_vlan_id));
981 vat_json_object_add_uint (node, "sub_exact_match", mp->sub_exact_match);
982 vat_json_object_add_uint (node, "sub_default", mp->sub_default);
983 vat_json_object_add_uint (node, "sub_outer_vlan_id_any",
984 mp->sub_outer_vlan_id_any);
985 vat_json_object_add_uint (node, "sub_inner_vlan_id_any",
986 mp->sub_inner_vlan_id_any);
987 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
988 vat_json_object_add_uint (node, "vtr_push_dot1q",
989 ntohl (mp->vtr_push_dot1q));
990 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
991 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
994 vat_json_object_add_string_copy (node, "pbb_vtr_dmac",
996 format_ethernet_address,
998 vat_json_object_add_string_copy (node, "pbb_vtr_smac",
1000 format_ethernet_address,
1002 vat_json_object_add_uint (node, "pbb_vtr_b_vlanid", mp->b_vlanid);
1003 vat_json_object_add_uint (node, "pbb_vtr_i_sid", mp->i_sid);
1007 #if VPP_API_TEST_BUILTIN == 0
1008 static void vl_api_sw_interface_event_t_handler
1009 (vl_api_sw_interface_event_t * mp)
1011 vat_main_t *vam = &vat_main;
1012 if (vam->interface_event_display)
1013 errmsg ("interface flags: sw_if_index %d %s %s",
1014 ntohl (mp->sw_if_index),
1015 mp->admin_up_down ? "admin-up" : "admin-down",
1016 mp->link_up_down ? "link-up" : "link-down");
1020 static void vl_api_sw_interface_event_t_handler_json
1021 (vl_api_sw_interface_event_t * mp)
1023 /* JSON output not supported */
1027 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
1029 vat_main_t *vam = &vat_main;
1030 i32 retval = ntohl (mp->retval);
1032 vam->retval = retval;
1033 vam->shmem_result = uword_to_pointer (mp->reply_in_shmem, u8 *);
1034 vam->result_ready = 1;
1038 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
1040 vat_main_t *vam = &vat_main;
1041 vat_json_node_t node;
1042 api_main_t *am = &api_main;
1046 vat_json_init_object (&node);
1047 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1048 vat_json_object_add_uint (&node, "reply_in_shmem",
1049 ntohl (mp->reply_in_shmem));
1050 /* Toss the shared-memory original... */
1051 pthread_mutex_lock (&am->vlib_rp->mutex);
1052 oldheap = svm_push_data_heap (am->vlib_rp);
1054 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
1057 svm_pop_heap (oldheap);
1058 pthread_mutex_unlock (&am->vlib_rp->mutex);
1060 vat_json_print (vam->ofp, &node);
1061 vat_json_free (&node);
1063 vam->retval = ntohl (mp->retval);
1064 vam->result_ready = 1;
1068 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
1070 vat_main_t *vam = &vat_main;
1071 i32 retval = ntohl (mp->retval);
1072 u32 length = ntohl (mp->length);
1074 vec_reset_length (vam->cmd_reply);
1076 vam->retval = retval;
1079 vec_validate (vam->cmd_reply, length);
1080 clib_memcpy ((char *) (vam->cmd_reply), mp->reply, length);
1081 vam->cmd_reply[length] = 0;
1083 vam->result_ready = 1;
1087 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
1089 vat_main_t *vam = &vat_main;
1090 vat_json_node_t node;
1092 vec_reset_length (vam->cmd_reply);
1094 vat_json_init_object (&node);
1095 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1096 vat_json_object_add_string_copy (&node, "reply", mp->reply);
1098 vat_json_print (vam->ofp, &node);
1099 vat_json_free (&node);
1101 vam->retval = ntohl (mp->retval);
1102 vam->result_ready = 1;
1105 static void vl_api_classify_add_del_table_reply_t_handler
1106 (vl_api_classify_add_del_table_reply_t * mp)
1108 vat_main_t *vam = &vat_main;
1109 i32 retval = ntohl (mp->retval);
1110 if (vam->async_mode)
1112 vam->async_errors += (retval < 0);
1116 vam->retval = retval;
1118 ((mp->new_table_index != 0xFFFFFFFF) ||
1119 (mp->skip_n_vectors != 0xFFFFFFFF) ||
1120 (mp->match_n_vectors != 0xFFFFFFFF)))
1122 * Note: this is just barely thread-safe, depends on
1123 * the main thread spinning waiting for an answer...
1125 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d",
1126 ntohl (mp->new_table_index),
1127 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
1128 vam->result_ready = 1;
1132 static void vl_api_classify_add_del_table_reply_t_handler_json
1133 (vl_api_classify_add_del_table_reply_t * mp)
1135 vat_main_t *vam = &vat_main;
1136 vat_json_node_t node;
1138 vat_json_init_object (&node);
1139 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1140 vat_json_object_add_uint (&node, "new_table_index",
1141 ntohl (mp->new_table_index));
1142 vat_json_object_add_uint (&node, "skip_n_vectors",
1143 ntohl (mp->skip_n_vectors));
1144 vat_json_object_add_uint (&node, "match_n_vectors",
1145 ntohl (mp->match_n_vectors));
1147 vat_json_print (vam->ofp, &node);
1148 vat_json_free (&node);
1150 vam->retval = ntohl (mp->retval);
1151 vam->result_ready = 1;
1154 static void vl_api_get_node_index_reply_t_handler
1155 (vl_api_get_node_index_reply_t * mp)
1157 vat_main_t *vam = &vat_main;
1158 i32 retval = ntohl (mp->retval);
1159 if (vam->async_mode)
1161 vam->async_errors += (retval < 0);
1165 vam->retval = retval;
1167 errmsg ("node index %d", ntohl (mp->node_index));
1168 vam->result_ready = 1;
1172 static void vl_api_get_node_index_reply_t_handler_json
1173 (vl_api_get_node_index_reply_t * mp)
1175 vat_main_t *vam = &vat_main;
1176 vat_json_node_t node;
1178 vat_json_init_object (&node);
1179 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1180 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1182 vat_json_print (vam->ofp, &node);
1183 vat_json_free (&node);
1185 vam->retval = ntohl (mp->retval);
1186 vam->result_ready = 1;
1189 static void vl_api_get_next_index_reply_t_handler
1190 (vl_api_get_next_index_reply_t * mp)
1192 vat_main_t *vam = &vat_main;
1193 i32 retval = ntohl (mp->retval);
1194 if (vam->async_mode)
1196 vam->async_errors += (retval < 0);
1200 vam->retval = retval;
1202 errmsg ("next node index %d", ntohl (mp->next_index));
1203 vam->result_ready = 1;
1207 static void vl_api_get_next_index_reply_t_handler_json
1208 (vl_api_get_next_index_reply_t * mp)
1210 vat_main_t *vam = &vat_main;
1211 vat_json_node_t node;
1213 vat_json_init_object (&node);
1214 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1215 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1217 vat_json_print (vam->ofp, &node);
1218 vat_json_free (&node);
1220 vam->retval = ntohl (mp->retval);
1221 vam->result_ready = 1;
1224 static void vl_api_add_node_next_reply_t_handler
1225 (vl_api_add_node_next_reply_t * mp)
1227 vat_main_t *vam = &vat_main;
1228 i32 retval = ntohl (mp->retval);
1229 if (vam->async_mode)
1231 vam->async_errors += (retval < 0);
1235 vam->retval = retval;
1237 errmsg ("next index %d", ntohl (mp->next_index));
1238 vam->result_ready = 1;
1242 static void vl_api_add_node_next_reply_t_handler_json
1243 (vl_api_add_node_next_reply_t * mp)
1245 vat_main_t *vam = &vat_main;
1246 vat_json_node_t node;
1248 vat_json_init_object (&node);
1249 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1250 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1252 vat_json_print (vam->ofp, &node);
1253 vat_json_free (&node);
1255 vam->retval = ntohl (mp->retval);
1256 vam->result_ready = 1;
1259 static void vl_api_show_version_reply_t_handler
1260 (vl_api_show_version_reply_t * mp)
1262 vat_main_t *vam = &vat_main;
1263 i32 retval = ntohl (mp->retval);
1267 errmsg (" program: %s", mp->program);
1268 errmsg (" version: %s", mp->version);
1269 errmsg (" build date: %s", mp->build_date);
1270 errmsg ("build directory: %s", mp->build_directory);
1272 vam->retval = retval;
1273 vam->result_ready = 1;
1276 static void vl_api_show_version_reply_t_handler_json
1277 (vl_api_show_version_reply_t * mp)
1279 vat_main_t *vam = &vat_main;
1280 vat_json_node_t node;
1282 vat_json_init_object (&node);
1283 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1284 vat_json_object_add_string_copy (&node, "program", mp->program);
1285 vat_json_object_add_string_copy (&node, "version", mp->version);
1286 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1287 vat_json_object_add_string_copy (&node, "build_directory",
1288 mp->build_directory);
1290 vat_json_print (vam->ofp, &node);
1291 vat_json_free (&node);
1293 vam->retval = ntohl (mp->retval);
1294 vam->result_ready = 1;
1298 vl_api_ip4_arp_event_t_handler (vl_api_ip4_arp_event_t * mp)
1300 u32 sw_if_index = ntohl (mp->sw_if_index);
1301 errmsg ("arp %s event: pid %d address %U new mac %U sw_if_index %d\n",
1302 mp->mac_ip ? "mac/ip binding" : "address resolution",
1303 ntohl (mp->pid), format_ip4_address, &mp->address,
1304 format_ethernet_address, mp->new_mac, sw_if_index);
1308 vl_api_ip4_arp_event_t_handler_json (vl_api_ip4_arp_event_t * mp)
1310 /* JSON output not supported */
1314 vl_api_ip6_nd_event_t_handler (vl_api_ip6_nd_event_t * mp)
1316 u32 sw_if_index = ntohl (mp->sw_if_index);
1317 errmsg ("ip6 nd %s event: pid %d address %U new mac %U sw_if_index %d\n",
1318 mp->mac_ip ? "mac/ip binding" : "address resolution",
1319 ntohl (mp->pid), format_ip6_address, mp->address,
1320 format_ethernet_address, mp->new_mac, sw_if_index);
1324 vl_api_ip6_nd_event_t_handler_json (vl_api_ip6_nd_event_t * mp)
1326 /* JSON output not supported */
1330 vl_api_l2_macs_event_t_handler (vl_api_l2_macs_event_t * mp)
1332 u32 n_macs = ntohl (mp->n_macs);
1333 errmsg ("L2MAC event recived with pid %d cl-idx %d for %d macs: \n",
1334 ntohl (mp->pid), mp->client_index, n_macs);
1336 for (i = 0; i < n_macs; i++)
1338 vl_api_mac_entry_t *mac = &mp->mac[i];
1339 errmsg (" [%d] sw_if_index %d mac_addr %U is_del %d \n",
1340 i + 1, ntohl (mac->sw_if_index),
1341 format_ethernet_address, mac->mac_addr, mac->is_del);
1348 vl_api_l2_macs_event_t_handler_json (vl_api_l2_macs_event_t * mp)
1350 /* JSON output not supported */
1353 #define vl_api_bridge_domain_details_t_endian vl_noop_handler
1354 #define vl_api_bridge_domain_details_t_print vl_noop_handler
1357 * Special-case: build the bridge domain table, maintain
1358 * the next bd id vbl.
1360 static void vl_api_bridge_domain_details_t_handler
1361 (vl_api_bridge_domain_details_t * mp)
1363 vat_main_t *vam = &vat_main;
1364 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1367 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-3s",
1368 " ID", "LRN", "FWD", "FLD", "BVI", "#IF");
1370 print (vam->ofp, "%3d %3d %3d %3d %3d %3d",
1371 ntohl (mp->bd_id), mp->learn, mp->forward,
1372 mp->flood, ntohl (mp->bvi_sw_if_index), n_sw_ifs);
1376 vl_api_bridge_domain_sw_if_t *sw_ifs;
1377 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG",
1380 sw_ifs = mp->sw_if_details;
1381 for (i = 0; i < n_sw_ifs; i++)
1387 sw_if_index = ntohl (sw_ifs->sw_if_index);
1390 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1392 if ((u32) p->value[0] == sw_if_index)
1394 sw_if_name = (u8 *)(p->key);
1399 print (vam->ofp, "%7d %3d %s", sw_if_index,
1400 sw_ifs->shg, sw_if_name ? (char *) sw_if_name :
1401 "sw_if_index not found!");
1408 static void vl_api_bridge_domain_details_t_handler_json
1409 (vl_api_bridge_domain_details_t * mp)
1411 vat_main_t *vam = &vat_main;
1412 vat_json_node_t *node, *array = NULL;
1413 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1415 if (VAT_JSON_ARRAY != vam->json_tree.type)
1417 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1418 vat_json_init_array (&vam->json_tree);
1420 node = vat_json_array_add (&vam->json_tree);
1422 vat_json_init_object (node);
1423 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1424 vat_json_object_add_uint (node, "flood", mp->flood);
1425 vat_json_object_add_uint (node, "forward", mp->forward);
1426 vat_json_object_add_uint (node, "learn", mp->learn);
1427 vat_json_object_add_uint (node, "bvi_sw_if_index",
1428 ntohl (mp->bvi_sw_if_index));
1429 vat_json_object_add_uint (node, "n_sw_ifs", n_sw_ifs);
1430 array = vat_json_object_add (node, "sw_if");
1431 vat_json_init_array (array);
1437 vl_api_bridge_domain_sw_if_t *sw_ifs;
1440 sw_ifs = mp->sw_if_details;
1441 for (i = 0; i < n_sw_ifs; i++)
1443 node = vat_json_array_add (array);
1444 vat_json_init_object (node);
1445 vat_json_object_add_uint (node, "sw_if_index",
1446 ntohl (sw_ifs->sw_if_index));
1447 vat_json_object_add_uint (node, "shg", sw_ifs->shg);
1453 static void vl_api_control_ping_reply_t_handler
1454 (vl_api_control_ping_reply_t * mp)
1456 vat_main_t *vam = &vat_main;
1457 i32 retval = ntohl (mp->retval);
1458 if (vam->async_mode)
1460 vam->async_errors += (retval < 0);
1464 vam->retval = retval;
1465 vam->result_ready = 1;
1467 vam->socket_client_main.control_pings_outstanding--;
1470 static void vl_api_control_ping_reply_t_handler_json
1471 (vl_api_control_ping_reply_t * mp)
1473 vat_main_t *vam = &vat_main;
1474 i32 retval = ntohl (mp->retval);
1476 if (VAT_JSON_NONE != vam->json_tree.type)
1478 vat_json_print (vam->ofp, &vam->json_tree);
1479 vat_json_free (&vam->json_tree);
1480 vam->json_tree.type = VAT_JSON_NONE;
1485 vat_json_init_array (&vam->json_tree);
1486 vat_json_print (vam->ofp, &vam->json_tree);
1487 vam->json_tree.type = VAT_JSON_NONE;
1490 vam->retval = retval;
1491 vam->result_ready = 1;
1495 vl_api_bridge_domain_set_mac_age_reply_t_handler
1496 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1498 vat_main_t *vam = &vat_main;
1499 i32 retval = ntohl (mp->retval);
1500 if (vam->async_mode)
1502 vam->async_errors += (retval < 0);
1506 vam->retval = retval;
1507 vam->result_ready = 1;
1511 static void vl_api_bridge_domain_set_mac_age_reply_t_handler_json
1512 (vl_api_bridge_domain_set_mac_age_reply_t * mp)
1514 vat_main_t *vam = &vat_main;
1515 vat_json_node_t node;
1517 vat_json_init_object (&node);
1518 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1520 vat_json_print (vam->ofp, &node);
1521 vat_json_free (&node);
1523 vam->retval = ntohl (mp->retval);
1524 vam->result_ready = 1;
1528 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1530 vat_main_t *vam = &vat_main;
1531 i32 retval = ntohl (mp->retval);
1532 if (vam->async_mode)
1534 vam->async_errors += (retval < 0);
1538 vam->retval = retval;
1539 vam->result_ready = 1;
1543 static void vl_api_l2_flags_reply_t_handler_json
1544 (vl_api_l2_flags_reply_t * mp)
1546 vat_main_t *vam = &vat_main;
1547 vat_json_node_t node;
1549 vat_json_init_object (&node);
1550 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1551 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1552 ntohl (mp->resulting_feature_bitmap));
1554 vat_json_print (vam->ofp, &node);
1555 vat_json_free (&node);
1557 vam->retval = ntohl (mp->retval);
1558 vam->result_ready = 1;
1561 static void vl_api_bridge_flags_reply_t_handler
1562 (vl_api_bridge_flags_reply_t * mp)
1564 vat_main_t *vam = &vat_main;
1565 i32 retval = ntohl (mp->retval);
1566 if (vam->async_mode)
1568 vam->async_errors += (retval < 0);
1572 vam->retval = retval;
1573 vam->result_ready = 1;
1577 static void vl_api_bridge_flags_reply_t_handler_json
1578 (vl_api_bridge_flags_reply_t * mp)
1580 vat_main_t *vam = &vat_main;
1581 vat_json_node_t node;
1583 vat_json_init_object (&node);
1584 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1585 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1586 ntohl (mp->resulting_feature_bitmap));
1588 vat_json_print (vam->ofp, &node);
1589 vat_json_free (&node);
1591 vam->retval = ntohl (mp->retval);
1592 vam->result_ready = 1;
1595 static void vl_api_tap_connect_reply_t_handler
1596 (vl_api_tap_connect_reply_t * mp)
1598 vat_main_t *vam = &vat_main;
1599 i32 retval = ntohl (mp->retval);
1600 if (vam->async_mode)
1602 vam->async_errors += (retval < 0);
1606 vam->retval = retval;
1607 vam->sw_if_index = ntohl (mp->sw_if_index);
1608 vam->result_ready = 1;
1613 static void vl_api_tap_connect_reply_t_handler_json
1614 (vl_api_tap_connect_reply_t * mp)
1616 vat_main_t *vam = &vat_main;
1617 vat_json_node_t node;
1619 vat_json_init_object (&node);
1620 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1621 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1623 vat_json_print (vam->ofp, &node);
1624 vat_json_free (&node);
1626 vam->retval = ntohl (mp->retval);
1627 vam->result_ready = 1;
1632 vl_api_tap_modify_reply_t_handler (vl_api_tap_modify_reply_t * mp)
1634 vat_main_t *vam = &vat_main;
1635 i32 retval = ntohl (mp->retval);
1636 if (vam->async_mode)
1638 vam->async_errors += (retval < 0);
1642 vam->retval = retval;
1643 vam->sw_if_index = ntohl (mp->sw_if_index);
1644 vam->result_ready = 1;
1648 static void vl_api_tap_modify_reply_t_handler_json
1649 (vl_api_tap_modify_reply_t * mp)
1651 vat_main_t *vam = &vat_main;
1652 vat_json_node_t node;
1654 vat_json_init_object (&node);
1655 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1656 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1658 vat_json_print (vam->ofp, &node);
1659 vat_json_free (&node);
1661 vam->retval = ntohl (mp->retval);
1662 vam->result_ready = 1;
1666 vl_api_tap_delete_reply_t_handler (vl_api_tap_delete_reply_t * mp)
1668 vat_main_t *vam = &vat_main;
1669 i32 retval = ntohl (mp->retval);
1670 if (vam->async_mode)
1672 vam->async_errors += (retval < 0);
1676 vam->retval = retval;
1677 vam->result_ready = 1;
1681 static void vl_api_tap_delete_reply_t_handler_json
1682 (vl_api_tap_delete_reply_t * mp)
1684 vat_main_t *vam = &vat_main;
1685 vat_json_node_t node;
1687 vat_json_init_object (&node);
1688 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1690 vat_json_print (vam->ofp, &node);
1691 vat_json_free (&node);
1693 vam->retval = ntohl (mp->retval);
1694 vam->result_ready = 1;
1698 vl_api_tap_create_v2_reply_t_handler (vl_api_tap_create_v2_reply_t * mp)
1700 vat_main_t *vam = &vat_main;
1701 i32 retval = ntohl (mp->retval);
1702 if (vam->async_mode)
1704 vam->async_errors += (retval < 0);
1708 vam->retval = retval;
1709 vam->sw_if_index = ntohl (mp->sw_if_index);
1710 vam->result_ready = 1;
1715 static void vl_api_tap_create_v2_reply_t_handler_json
1716 (vl_api_tap_create_v2_reply_t * mp)
1718 vat_main_t *vam = &vat_main;
1719 vat_json_node_t node;
1721 vat_json_init_object (&node);
1722 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1723 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1725 vat_json_print (vam->ofp, &node);
1726 vat_json_free (&node);
1728 vam->retval = ntohl (mp->retval);
1729 vam->result_ready = 1;
1734 vl_api_tap_delete_v2_reply_t_handler (vl_api_tap_delete_v2_reply_t * mp)
1736 vat_main_t *vam = &vat_main;
1737 i32 retval = ntohl (mp->retval);
1738 if (vam->async_mode)
1740 vam->async_errors += (retval < 0);
1744 vam->retval = retval;
1745 vam->result_ready = 1;
1749 static void vl_api_tap_delete_v2_reply_t_handler_json
1750 (vl_api_tap_delete_v2_reply_t * mp)
1752 vat_main_t *vam = &vat_main;
1753 vat_json_node_t node;
1755 vat_json_init_object (&node);
1756 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1758 vat_json_print (vam->ofp, &node);
1759 vat_json_free (&node);
1761 vam->retval = ntohl (mp->retval);
1762 vam->result_ready = 1;
1765 static void vl_api_mpls_tunnel_add_del_reply_t_handler
1766 (vl_api_mpls_tunnel_add_del_reply_t * mp)
1768 vat_main_t *vam = &vat_main;
1769 i32 retval = ntohl (mp->retval);
1770 if (vam->async_mode)
1772 vam->async_errors += (retval < 0);
1776 vam->retval = retval;
1777 vam->result_ready = 1;
1781 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
1782 (vl_api_mpls_tunnel_add_del_reply_t * mp)
1784 vat_main_t *vam = &vat_main;
1785 vat_json_node_t node;
1787 vat_json_init_object (&node);
1788 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1789 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
1790 ntohl (mp->sw_if_index));
1792 vat_json_print (vam->ofp, &node);
1793 vat_json_free (&node);
1795 vam->retval = ntohl (mp->retval);
1796 vam->result_ready = 1;
1799 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
1800 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1802 vat_main_t *vam = &vat_main;
1803 i32 retval = ntohl (mp->retval);
1804 if (vam->async_mode)
1806 vam->async_errors += (retval < 0);
1810 vam->retval = retval;
1811 vam->sw_if_index = ntohl (mp->sw_if_index);
1812 vam->result_ready = 1;
1816 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
1817 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1819 vat_main_t *vam = &vat_main;
1820 vat_json_node_t node;
1822 vat_json_init_object (&node);
1823 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1824 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1826 vat_json_print (vam->ofp, &node);
1827 vat_json_free (&node);
1829 vam->retval = ntohl (mp->retval);
1830 vam->result_ready = 1;
1833 static void vl_api_gpe_add_del_fwd_entry_reply_t_handler
1834 (vl_api_gpe_add_del_fwd_entry_reply_t * mp)
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_gpe_add_del_fwd_entry_reply_t_handler_json
1850 (vl_api_gpe_add_del_fwd_entry_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));
1857 vat_json_object_add_uint (&node, "fwd_entry_index",
1858 clib_net_to_host_u32 (mp->fwd_entry_index));
1860 vat_json_print (vam->ofp, &node);
1861 vat_json_free (&node);
1863 vam->retval = ntohl (mp->retval);
1864 vam->result_ready = 1;
1868 format_lisp_transport_protocol (u8 * s, va_list * args)
1870 u32 proto = va_arg (*args, u32);
1875 return format (s, "udp");
1877 return format (s, "api");
1884 static void vl_api_one_get_transport_protocol_reply_t_handler
1885 (vl_api_one_get_transport_protocol_reply_t * mp)
1887 vat_main_t *vam = &vat_main;
1888 i32 retval = ntohl (mp->retval);
1889 if (vam->async_mode)
1891 vam->async_errors += (retval < 0);
1895 u32 proto = mp->protocol;
1896 print (vam->ofp, "Transport protocol: %U",
1897 format_lisp_transport_protocol, proto);
1898 vam->retval = retval;
1899 vam->result_ready = 1;
1903 static void vl_api_one_get_transport_protocol_reply_t_handler_json
1904 (vl_api_one_get_transport_protocol_reply_t * mp)
1906 vat_main_t *vam = &vat_main;
1907 vat_json_node_t node;
1910 s = format (0, "%U", format_lisp_transport_protocol, mp->protocol);
1913 vat_json_init_object (&node);
1914 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1915 vat_json_object_add_string_copy (&node, "transport-protocol", s);
1918 vat_json_print (vam->ofp, &node);
1919 vat_json_free (&node);
1921 vam->retval = ntohl (mp->retval);
1922 vam->result_ready = 1;
1925 static void vl_api_one_add_del_locator_set_reply_t_handler
1926 (vl_api_one_add_del_locator_set_reply_t * mp)
1928 vat_main_t *vam = &vat_main;
1929 i32 retval = ntohl (mp->retval);
1930 if (vam->async_mode)
1932 vam->async_errors += (retval < 0);
1936 vam->retval = retval;
1937 vam->result_ready = 1;
1941 static void vl_api_one_add_del_locator_set_reply_t_handler_json
1942 (vl_api_one_add_del_locator_set_reply_t * mp)
1944 vat_main_t *vam = &vat_main;
1945 vat_json_node_t node;
1947 vat_json_init_object (&node);
1948 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1949 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
1951 vat_json_print (vam->ofp, &node);
1952 vat_json_free (&node);
1954 vam->retval = ntohl (mp->retval);
1955 vam->result_ready = 1;
1958 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
1959 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1961 vat_main_t *vam = &vat_main;
1962 i32 retval = ntohl (mp->retval);
1963 if (vam->async_mode)
1965 vam->async_errors += (retval < 0);
1969 vam->retval = retval;
1970 vam->sw_if_index = ntohl (mp->sw_if_index);
1971 vam->result_ready = 1;
1975 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
1976 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1978 vat_main_t *vam = &vat_main;
1979 vat_json_node_t node;
1981 vat_json_init_object (&node);
1982 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1983 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1985 vat_json_print (vam->ofp, &node);
1986 vat_json_free (&node);
1988 vam->retval = ntohl (mp->retval);
1989 vam->result_ready = 1;
1992 static void vl_api_geneve_add_del_tunnel_reply_t_handler
1993 (vl_api_geneve_add_del_tunnel_reply_t * mp)
1995 vat_main_t *vam = &vat_main;
1996 i32 retval = ntohl (mp->retval);
1997 if (vam->async_mode)
1999 vam->async_errors += (retval < 0);
2003 vam->retval = retval;
2004 vam->sw_if_index = ntohl (mp->sw_if_index);
2005 vam->result_ready = 1;
2009 static void vl_api_geneve_add_del_tunnel_reply_t_handler_json
2010 (vl_api_geneve_add_del_tunnel_reply_t * mp)
2012 vat_main_t *vam = &vat_main;
2013 vat_json_node_t node;
2015 vat_json_init_object (&node);
2016 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2017 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2019 vat_json_print (vam->ofp, &node);
2020 vat_json_free (&node);
2022 vam->retval = ntohl (mp->retval);
2023 vam->result_ready = 1;
2026 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler
2027 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2029 vat_main_t *vam = &vat_main;
2030 i32 retval = ntohl (mp->retval);
2031 if (vam->async_mode)
2033 vam->async_errors += (retval < 0);
2037 vam->retval = retval;
2038 vam->sw_if_index = ntohl (mp->sw_if_index);
2039 vam->result_ready = 1;
2043 static void vl_api_vxlan_gpe_add_del_tunnel_reply_t_handler_json
2044 (vl_api_vxlan_gpe_add_del_tunnel_reply_t * mp)
2046 vat_main_t *vam = &vat_main;
2047 vat_json_node_t node;
2049 vat_json_init_object (&node);
2050 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2051 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2053 vat_json_print (vam->ofp, &node);
2054 vat_json_free (&node);
2056 vam->retval = ntohl (mp->retval);
2057 vam->result_ready = 1;
2060 static void vl_api_gre_add_del_tunnel_reply_t_handler
2061 (vl_api_gre_add_del_tunnel_reply_t * mp)
2063 vat_main_t *vam = &vat_main;
2064 i32 retval = ntohl (mp->retval);
2065 if (vam->async_mode)
2067 vam->async_errors += (retval < 0);
2071 vam->retval = retval;
2072 vam->sw_if_index = ntohl (mp->sw_if_index);
2073 vam->result_ready = 1;
2077 static void vl_api_gre_add_del_tunnel_reply_t_handler_json
2078 (vl_api_gre_add_del_tunnel_reply_t * mp)
2080 vat_main_t *vam = &vat_main;
2081 vat_json_node_t node;
2083 vat_json_init_object (&node);
2084 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2085 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2087 vat_json_print (vam->ofp, &node);
2088 vat_json_free (&node);
2090 vam->retval = ntohl (mp->retval);
2091 vam->result_ready = 1;
2094 static void vl_api_create_vhost_user_if_reply_t_handler
2095 (vl_api_create_vhost_user_if_reply_t * mp)
2097 vat_main_t *vam = &vat_main;
2098 i32 retval = ntohl (mp->retval);
2099 if (vam->async_mode)
2101 vam->async_errors += (retval < 0);
2105 vam->retval = retval;
2106 vam->sw_if_index = ntohl (mp->sw_if_index);
2107 vam->result_ready = 1;
2111 static void vl_api_create_vhost_user_if_reply_t_handler_json
2112 (vl_api_create_vhost_user_if_reply_t * mp)
2114 vat_main_t *vam = &vat_main;
2115 vat_json_node_t node;
2117 vat_json_init_object (&node);
2118 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2119 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
2121 vat_json_print (vam->ofp, &node);
2122 vat_json_free (&node);
2124 vam->retval = ntohl (mp->retval);
2125 vam->result_ready = 1;
2128 static clib_error_t *
2129 receive_fd_msg (int socket_fd, int *my_fd)
2132 char ctl[CMSG_SPACE (sizeof (int)) + CMSG_SPACE (sizeof (struct ucred))];
2133 struct msghdr mh = { 0 };
2134 struct iovec iov[1];
2136 struct ucred *cr = 0;
2137 struct cmsghdr *cmsg;
2138 pid_t pid __attribute__ ((unused));
2139 uid_t uid __attribute__ ((unused));
2140 gid_t gid __attribute__ ((unused));
2142 iov[0].iov_base = msgbuf;
2146 mh.msg_control = ctl;
2147 mh.msg_controllen = sizeof (ctl);
2149 memset (ctl, 0, sizeof (ctl));
2151 /* receive the incoming message */
2152 size = recvmsg (socket_fd, &mh, 0);
2155 return (size == 0) ? clib_error_return (0, "disconnected") :
2156 clib_error_return_unix (0, "recvmsg: malformed message (fd %d)",
2160 cmsg = CMSG_FIRSTHDR (&mh);
2163 if (cmsg->cmsg_level == SOL_SOCKET)
2165 if (cmsg->cmsg_type == SCM_CREDENTIALS)
2167 cr = (struct ucred *) CMSG_DATA (cmsg);
2172 else if (cmsg->cmsg_type == SCM_RIGHTS)
2174 clib_memcpy (my_fd, CMSG_DATA (cmsg), sizeof (int));
2177 cmsg = CMSG_NXTHDR (&mh, cmsg);
2182 static void vl_api_memfd_segment_create_reply_t_handler
2183 (vl_api_memfd_segment_create_reply_t * mp)
2185 /* Dont bother in the builtin version */
2186 #if VPP_API_TEST_BUILTIN == 0
2187 vat_main_t *vam = &vat_main;
2188 api_main_t *am = &api_main;
2189 socket_client_main_t *scm = &vam->socket_client_main;
2191 clib_error_t *error;
2192 memfd_private_t memfd;
2193 i32 retval = ntohl (mp->retval);
2197 error = receive_fd_msg (scm->socket_fd, &my_fd);
2204 memset (&memfd, 0, sizeof (memfd));
2207 vam->client_index_invalid = 1;
2209 /* Note: this closes memfd.fd */
2210 retval = memfd_slave_init (&memfd);
2212 clib_warning ("WARNING: segment map returned %d", retval);
2214 /* Pivot to the memory client segment that vpp just created */
2216 am->vlib_rp = (void *) (memfd.requested_va + MMAP_PAGESIZE);
2218 am->shmem_hdr = (void *) am->vlib_rp->user_ctx;
2220 vl_client_install_client_message_handlers ();
2222 vl_client_connect_to_vlib_no_map ("pvt",
2224 32 /* input_queue_length */ );
2225 vam->vl_input_queue = am->shmem_hdr->vl_input_queue;
2227 vl_socket_client_enable_disable (&vam->socket_client_main,
2228 0 /* disable socket */ );
2232 if (vam->async_mode)
2234 vam->async_errors += (retval < 0);
2238 vam->retval = retval;
2239 vam->result_ready = 1;
2244 static void vl_api_memfd_segment_create_reply_t_handler_json
2245 (vl_api_memfd_segment_create_reply_t * mp)
2247 clib_warning ("no");
2250 static void vl_api_dns_resolve_name_reply_t_handler
2251 (vl_api_dns_resolve_name_reply_t * mp)
2253 vat_main_t *vam = &vat_main;
2254 i32 retval = ntohl (mp->retval);
2255 if (vam->async_mode)
2257 vam->async_errors += (retval < 0);
2261 vam->retval = retval;
2262 vam->result_ready = 1;
2267 clib_warning ("ip4 address %U", format_ip4_address,
2268 (ip4_address_t *) mp->ip4_address);
2270 clib_warning ("ip6 address %U", format_ip6_address,
2271 (ip6_address_t *) mp->ip6_address);
2274 clib_warning ("retval %d", retval);
2278 static void vl_api_dns_resolve_name_reply_t_handler_json
2279 (vl_api_dns_resolve_name_reply_t * mp)
2281 clib_warning ("not implemented");
2284 static void vl_api_dns_resolve_ip_reply_t_handler
2285 (vl_api_dns_resolve_ip_reply_t * mp)
2287 vat_main_t *vam = &vat_main;
2288 i32 retval = ntohl (mp->retval);
2289 if (vam->async_mode)
2291 vam->async_errors += (retval < 0);
2295 vam->retval = retval;
2296 vam->result_ready = 1;
2300 clib_warning ("canonical name %s", mp->name);
2303 clib_warning ("retval %d", retval);
2307 static void vl_api_dns_resolve_ip_reply_t_handler_json
2308 (vl_api_dns_resolve_ip_reply_t * mp)
2310 clib_warning ("not implemented");
2314 static void vl_api_ip_address_details_t_handler
2315 (vl_api_ip_address_details_t * mp)
2317 vat_main_t *vam = &vat_main;
2318 static ip_address_details_t empty_ip_address_details = { {0} };
2319 ip_address_details_t *address = NULL;
2320 ip_details_t *current_ip_details = NULL;
2321 ip_details_t *details = NULL;
2323 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
2325 if (!details || vam->current_sw_if_index >= vec_len (details)
2326 || !details[vam->current_sw_if_index].present)
2328 errmsg ("ip address details arrived but not stored");
2329 errmsg ("ip_dump should be called first");
2333 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
2335 #define addresses (current_ip_details->addr)
2337 vec_validate_init_empty (addresses, vec_len (addresses),
2338 empty_ip_address_details);
2340 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
2342 clib_memcpy (&address->ip, &mp->ip, sizeof (address->ip));
2343 address->prefix_length = mp->prefix_length;
2347 static void vl_api_ip_address_details_t_handler_json
2348 (vl_api_ip_address_details_t * mp)
2350 vat_main_t *vam = &vat_main;
2351 vat_json_node_t *node = NULL;
2352 struct in6_addr ip6;
2355 if (VAT_JSON_ARRAY != vam->json_tree.type)
2357 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2358 vat_json_init_array (&vam->json_tree);
2360 node = vat_json_array_add (&vam->json_tree);
2362 vat_json_init_object (node);
2365 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
2366 vat_json_object_add_ip6 (node, "ip", ip6);
2370 clib_memcpy (&ip4, mp->ip, sizeof (ip4));
2371 vat_json_object_add_ip4 (node, "ip", ip4);
2373 vat_json_object_add_uint (node, "prefix_length", mp->prefix_length);
2377 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
2379 vat_main_t *vam = &vat_main;
2380 static ip_details_t empty_ip_details = { 0 };
2381 ip_details_t *ip = NULL;
2382 u32 sw_if_index = ~0;
2384 sw_if_index = ntohl (mp->sw_if_index);
2386 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2387 sw_if_index, empty_ip_details);
2389 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
2396 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
2398 vat_main_t *vam = &vat_main;
2400 if (VAT_JSON_ARRAY != vam->json_tree.type)
2402 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2403 vat_json_init_array (&vam->json_tree);
2405 vat_json_array_add_uint (&vam->json_tree,
2406 clib_net_to_host_u32 (mp->sw_if_index));
2409 static void vl_api_map_domain_details_t_handler_json
2410 (vl_api_map_domain_details_t * mp)
2412 vat_json_node_t *node = NULL;
2413 vat_main_t *vam = &vat_main;
2414 struct in6_addr ip6;
2417 if (VAT_JSON_ARRAY != vam->json_tree.type)
2419 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2420 vat_json_init_array (&vam->json_tree);
2423 node = vat_json_array_add (&vam->json_tree);
2424 vat_json_init_object (node);
2426 vat_json_object_add_uint (node, "domain_index",
2427 clib_net_to_host_u32 (mp->domain_index));
2428 clib_memcpy (&ip6, mp->ip6_prefix, sizeof (ip6));
2429 vat_json_object_add_ip6 (node, "ip6_prefix", ip6);
2430 clib_memcpy (&ip4, mp->ip4_prefix, sizeof (ip4));
2431 vat_json_object_add_ip4 (node, "ip4_prefix", ip4);
2432 clib_memcpy (&ip6, mp->ip6_src, sizeof (ip6));
2433 vat_json_object_add_ip6 (node, "ip6_src", ip6);
2434 vat_json_object_add_int (node, "ip6_prefix_len", mp->ip6_prefix_len);
2435 vat_json_object_add_int (node, "ip4_prefix_len", mp->ip4_prefix_len);
2436 vat_json_object_add_int (node, "ip6_src_len", mp->ip6_src_len);
2437 vat_json_object_add_int (node, "ea_bits_len", mp->ea_bits_len);
2438 vat_json_object_add_int (node, "psid_offset", mp->psid_offset);
2439 vat_json_object_add_int (node, "psid_length", mp->psid_length);
2440 vat_json_object_add_uint (node, "flags", mp->flags);
2441 vat_json_object_add_uint (node, "mtu", clib_net_to_host_u16 (mp->mtu));
2442 vat_json_object_add_int (node, "is_translation", mp->is_translation);
2445 static void vl_api_map_domain_details_t_handler
2446 (vl_api_map_domain_details_t * mp)
2448 vat_main_t *vam = &vat_main;
2450 if (mp->is_translation)
2453 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U/%d (ip6-src) index: %u",
2454 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
2455 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
2456 format_ip6_address, mp->ip6_src, mp->ip6_src_len,
2457 clib_net_to_host_u32 (mp->domain_index));
2462 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U (ip6-src) index: %u",
2463 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
2464 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
2465 format_ip6_address, mp->ip6_src,
2466 clib_net_to_host_u32 (mp->domain_index));
2468 print (vam->ofp, " ea-len %d psid-offset %d psid-len %d mtu %d %s",
2469 mp->ea_bits_len, mp->psid_offset, mp->psid_length, mp->mtu,
2470 mp->is_translation ? "map-t" : "");
2473 static void vl_api_map_rule_details_t_handler_json
2474 (vl_api_map_rule_details_t * mp)
2476 struct in6_addr ip6;
2477 vat_json_node_t *node = NULL;
2478 vat_main_t *vam = &vat_main;
2480 if (VAT_JSON_ARRAY != vam->json_tree.type)
2482 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2483 vat_json_init_array (&vam->json_tree);
2486 node = vat_json_array_add (&vam->json_tree);
2487 vat_json_init_object (node);
2489 vat_json_object_add_uint (node, "psid", clib_net_to_host_u16 (mp->psid));
2490 clib_memcpy (&ip6, mp->ip6_dst, sizeof (ip6));
2491 vat_json_object_add_ip6 (node, "ip6_dst", ip6);
2495 vl_api_map_rule_details_t_handler (vl_api_map_rule_details_t * mp)
2497 vat_main_t *vam = &vat_main;
2498 print (vam->ofp, " %d (psid) %U (ip6-dst)",
2499 clib_net_to_host_u16 (mp->psid), format_ip6_address, mp->ip6_dst);
2503 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
2505 errmsg ("DHCP compl event: pid %d %s hostname %s host_addr %U "
2506 "router_addr %U host_mac %U",
2507 ntohl (mp->pid), mp->is_ipv6 ? "ipv6" : "ipv4", mp->hostname,
2508 format_ip4_address, &mp->host_address,
2509 format_ip4_address, &mp->router_address,
2510 format_ethernet_address, mp->host_mac);
2513 static void vl_api_dhcp_compl_event_t_handler_json
2514 (vl_api_dhcp_compl_event_t * mp)
2516 /* JSON output not supported */
2520 set_simple_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
2523 vat_main_t *vam = &vat_main;
2524 static u64 default_counter = 0;
2526 vec_validate_init_empty (vam->simple_interface_counters, vnet_counter_type,
2528 vec_validate_init_empty (vam->simple_interface_counters[vnet_counter_type],
2529 sw_if_index, default_counter);
2530 vam->simple_interface_counters[vnet_counter_type][sw_if_index] = counter;
2534 set_combined_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
2535 interface_counter_t counter)
2537 vat_main_t *vam = &vat_main;
2538 static interface_counter_t default_counter = { 0, };
2540 vec_validate_init_empty (vam->combined_interface_counters,
2541 vnet_counter_type, NULL);
2542 vec_validate_init_empty (vam->combined_interface_counters
2543 [vnet_counter_type], sw_if_index, default_counter);
2544 vam->combined_interface_counters[vnet_counter_type][sw_if_index] = counter;
2547 static void vl_api_vnet_interface_simple_counters_t_handler
2548 (vl_api_vnet_interface_simple_counters_t * mp)
2553 static void vl_api_vnet_interface_combined_counters_t_handler
2554 (vl_api_vnet_interface_combined_counters_t * mp)
2559 static void vl_api_vnet_interface_simple_counters_t_handler_json
2560 (vl_api_vnet_interface_simple_counters_t * mp)
2565 u32 first_sw_if_index;
2568 count = ntohl (mp->count);
2569 first_sw_if_index = ntohl (mp->first_sw_if_index);
2571 v_packets = (u64 *) & mp->data;
2572 for (i = 0; i < count; i++)
2574 packets = clib_net_to_host_u64 (clib_mem_unaligned (v_packets, u64));
2575 set_simple_interface_counter (mp->vnet_counter_type,
2576 first_sw_if_index + i, packets);
2581 static void vl_api_vnet_interface_combined_counters_t_handler_json
2582 (vl_api_vnet_interface_combined_counters_t * mp)
2584 interface_counter_t counter;
2586 u32 first_sw_if_index;
2590 count = ntohl (mp->count);
2591 first_sw_if_index = ntohl (mp->first_sw_if_index);
2593 v = (vlib_counter_t *) & mp->data;
2594 for (i = 0; i < count; i++)
2597 clib_net_to_host_u64 (clib_mem_unaligned (&v->packets, u64));
2599 clib_net_to_host_u64 (clib_mem_unaligned (&v->bytes, u64));
2600 set_combined_interface_counter (mp->vnet_counter_type,
2601 first_sw_if_index + i, counter);
2607 ip4_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
2609 vat_main_t *vam = &vat_main;
2612 for (i = 0; i < vec_len (vam->ip4_fib_counters_vrf_id_by_index); i++)
2614 if (vam->ip4_fib_counters_vrf_id_by_index[i] == vrf_id)
2623 ip6_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
2625 vat_main_t *vam = &vat_main;
2628 for (i = 0; i < vec_len (vam->ip6_fib_counters_vrf_id_by_index); i++)
2630 if (vam->ip6_fib_counters_vrf_id_by_index[i] == vrf_id)
2638 static void vl_api_vnet_ip4_fib_counters_t_handler
2639 (vl_api_vnet_ip4_fib_counters_t * mp)
2644 static void vl_api_vnet_ip4_fib_counters_t_handler_json
2645 (vl_api_vnet_ip4_fib_counters_t * mp)
2647 vat_main_t *vam = &vat_main;
2648 vl_api_ip4_fib_counter_t *v;
2649 ip4_fib_counter_t *counter;
2656 vrf_id = ntohl (mp->vrf_id);
2657 vrf_index = ip4_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2658 if (~0 == vrf_index)
2660 vrf_index = vec_len (vam->ip4_fib_counters_vrf_id_by_index);
2661 vec_validate (vam->ip4_fib_counters_vrf_id_by_index, vrf_index);
2662 vam->ip4_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2663 vec_validate (vam->ip4_fib_counters, vrf_index);
2664 vam->ip4_fib_counters[vrf_index] = NULL;
2667 vec_free (vam->ip4_fib_counters[vrf_index]);
2668 v = (vl_api_ip4_fib_counter_t *) & mp->c;
2669 count = ntohl (mp->count);
2670 for (i = 0; i < count; i++)
2672 vec_validate (vam->ip4_fib_counters[vrf_index], i);
2673 counter = &vam->ip4_fib_counters[vrf_index][i];
2674 clib_memcpy (&ip4, &v->address, sizeof (ip4));
2675 counter->address = ip4;
2676 counter->address_length = v->address_length;
2677 counter->packets = clib_net_to_host_u64 (v->packets);
2678 counter->bytes = clib_net_to_host_u64 (v->bytes);
2683 static void vl_api_vnet_ip4_nbr_counters_t_handler
2684 (vl_api_vnet_ip4_nbr_counters_t * mp)
2689 static void vl_api_vnet_ip4_nbr_counters_t_handler_json
2690 (vl_api_vnet_ip4_nbr_counters_t * mp)
2692 vat_main_t *vam = &vat_main;
2693 vl_api_ip4_nbr_counter_t *v;
2694 ip4_nbr_counter_t *counter;
2699 sw_if_index = ntohl (mp->sw_if_index);
2700 count = ntohl (mp->count);
2701 vec_validate (vam->ip4_nbr_counters, sw_if_index);
2704 vec_free (vam->ip4_nbr_counters[sw_if_index]);
2706 v = (vl_api_ip4_nbr_counter_t *) & mp->c;
2707 for (i = 0; i < count; i++)
2709 vec_validate (vam->ip4_nbr_counters[sw_if_index], i);
2710 counter = &vam->ip4_nbr_counters[sw_if_index][i];
2711 counter->address.s_addr = v->address;
2712 counter->packets = clib_net_to_host_u64 (v->packets);
2713 counter->bytes = clib_net_to_host_u64 (v->bytes);
2714 counter->linkt = v->link_type;
2719 static void vl_api_vnet_ip6_fib_counters_t_handler
2720 (vl_api_vnet_ip6_fib_counters_t * mp)
2725 static void vl_api_vnet_ip6_fib_counters_t_handler_json
2726 (vl_api_vnet_ip6_fib_counters_t * mp)
2728 vat_main_t *vam = &vat_main;
2729 vl_api_ip6_fib_counter_t *v;
2730 ip6_fib_counter_t *counter;
2731 struct in6_addr ip6;
2737 vrf_id = ntohl (mp->vrf_id);
2738 vrf_index = ip6_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2739 if (~0 == vrf_index)
2741 vrf_index = vec_len (vam->ip6_fib_counters_vrf_id_by_index);
2742 vec_validate (vam->ip6_fib_counters_vrf_id_by_index, vrf_index);
2743 vam->ip6_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2744 vec_validate (vam->ip6_fib_counters, vrf_index);
2745 vam->ip6_fib_counters[vrf_index] = NULL;
2748 vec_free (vam->ip6_fib_counters[vrf_index]);
2749 v = (vl_api_ip6_fib_counter_t *) & mp->c;
2750 count = ntohl (mp->count);
2751 for (i = 0; i < count; i++)
2753 vec_validate (vam->ip6_fib_counters[vrf_index], i);
2754 counter = &vam->ip6_fib_counters[vrf_index][i];
2755 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2756 counter->address = ip6;
2757 counter->address_length = v->address_length;
2758 counter->packets = clib_net_to_host_u64 (v->packets);
2759 counter->bytes = clib_net_to_host_u64 (v->bytes);
2764 static void vl_api_vnet_ip6_nbr_counters_t_handler
2765 (vl_api_vnet_ip6_nbr_counters_t * mp)
2770 static void vl_api_vnet_ip6_nbr_counters_t_handler_json
2771 (vl_api_vnet_ip6_nbr_counters_t * mp)
2773 vat_main_t *vam = &vat_main;
2774 vl_api_ip6_nbr_counter_t *v;
2775 ip6_nbr_counter_t *counter;
2776 struct in6_addr ip6;
2781 sw_if_index = ntohl (mp->sw_if_index);
2782 count = ntohl (mp->count);
2783 vec_validate (vam->ip6_nbr_counters, sw_if_index);
2786 vec_free (vam->ip6_nbr_counters[sw_if_index]);
2788 v = (vl_api_ip6_nbr_counter_t *) & mp->c;
2789 for (i = 0; i < count; i++)
2791 vec_validate (vam->ip6_nbr_counters[sw_if_index], i);
2792 counter = &vam->ip6_nbr_counters[sw_if_index][i];
2793 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2794 counter->address = ip6;
2795 counter->packets = clib_net_to_host_u64 (v->packets);
2796 counter->bytes = clib_net_to_host_u64 (v->bytes);
2801 static void vl_api_get_first_msg_id_reply_t_handler
2802 (vl_api_get_first_msg_id_reply_t * mp)
2804 vat_main_t *vam = &vat_main;
2805 i32 retval = ntohl (mp->retval);
2807 if (vam->async_mode)
2809 vam->async_errors += (retval < 0);
2813 vam->retval = retval;
2814 vam->result_ready = 1;
2818 errmsg ("first message id %d", ntohs (mp->first_msg_id));
2822 static void vl_api_get_first_msg_id_reply_t_handler_json
2823 (vl_api_get_first_msg_id_reply_t * mp)
2825 vat_main_t *vam = &vat_main;
2826 vat_json_node_t node;
2828 vat_json_init_object (&node);
2829 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2830 vat_json_object_add_uint (&node, "first_msg_id",
2831 (uint) ntohs (mp->first_msg_id));
2833 vat_json_print (vam->ofp, &node);
2834 vat_json_free (&node);
2836 vam->retval = ntohl (mp->retval);
2837 vam->result_ready = 1;
2840 static void vl_api_get_node_graph_reply_t_handler
2841 (vl_api_get_node_graph_reply_t * mp)
2843 vat_main_t *vam = &vat_main;
2844 api_main_t *am = &api_main;
2845 i32 retval = ntohl (mp->retval);
2846 u8 *pvt_copy, *reply;
2851 if (vam->async_mode)
2853 vam->async_errors += (retval < 0);
2857 vam->retval = retval;
2858 vam->result_ready = 1;
2861 /* "Should never happen..." */
2865 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2866 pvt_copy = vec_dup (reply);
2868 /* Toss the shared-memory original... */
2869 pthread_mutex_lock (&am->vlib_rp->mutex);
2870 oldheap = svm_push_data_heap (am->vlib_rp);
2874 svm_pop_heap (oldheap);
2875 pthread_mutex_unlock (&am->vlib_rp->mutex);
2877 if (vam->graph_nodes)
2879 hash_free (vam->graph_node_index_by_name);
2881 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2883 node = vam->graph_nodes[i];
2884 vec_free (node->name);
2885 vec_free (node->next_nodes);
2888 vec_free (vam->graph_nodes);
2891 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2892 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2893 vec_free (pvt_copy);
2895 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2897 node = vam->graph_nodes[i];
2898 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2902 static void vl_api_get_node_graph_reply_t_handler_json
2903 (vl_api_get_node_graph_reply_t * mp)
2905 vat_main_t *vam = &vat_main;
2906 api_main_t *am = &api_main;
2908 vat_json_node_t node;
2911 /* $$$$ make this real? */
2912 vat_json_init_object (&node);
2913 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2914 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2916 reply = uword_to_pointer (mp->reply_in_shmem, u8 *);
2918 /* Toss the shared-memory original... */
2919 pthread_mutex_lock (&am->vlib_rp->mutex);
2920 oldheap = svm_push_data_heap (am->vlib_rp);
2924 svm_pop_heap (oldheap);
2925 pthread_mutex_unlock (&am->vlib_rp->mutex);
2927 vat_json_print (vam->ofp, &node);
2928 vat_json_free (&node);
2930 vam->retval = ntohl (mp->retval);
2931 vam->result_ready = 1;
2935 vl_api_one_locator_details_t_handler (vl_api_one_locator_details_t * mp)
2937 vat_main_t *vam = &vat_main;
2942 s = format (s, "%=16d%=16d%=16d",
2943 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2947 s = format (s, "%=16U%=16d%=16d",
2948 mp->is_ipv6 ? format_ip6_address :
2950 mp->ip_address, mp->priority, mp->weight);
2953 print (vam->ofp, "%v", s);
2958 vl_api_one_locator_details_t_handler_json (vl_api_one_locator_details_t * mp)
2960 vat_main_t *vam = &vat_main;
2961 vat_json_node_t *node = NULL;
2962 struct in6_addr ip6;
2965 if (VAT_JSON_ARRAY != vam->json_tree.type)
2967 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2968 vat_json_init_array (&vam->json_tree);
2970 node = vat_json_array_add (&vam->json_tree);
2971 vat_json_init_object (node);
2973 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2974 vat_json_object_add_uint (node, "priority", mp->priority);
2975 vat_json_object_add_uint (node, "weight", mp->weight);
2978 vat_json_object_add_uint (node, "sw_if_index",
2979 clib_net_to_host_u32 (mp->sw_if_index));
2984 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2985 vat_json_object_add_ip6 (node, "address", ip6);
2989 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2990 vat_json_object_add_ip4 (node, "address", ip4);
2996 vl_api_one_locator_set_details_t_handler (vl_api_one_locator_set_details_t *
2999 vat_main_t *vam = &vat_main;
3002 ls_name = format (0, "%s", mp->ls_name);
3004 print (vam->ofp, "%=10d%=15v", clib_net_to_host_u32 (mp->ls_index),
3010 vl_api_one_locator_set_details_t_handler_json
3011 (vl_api_one_locator_set_details_t * mp)
3013 vat_main_t *vam = &vat_main;
3014 vat_json_node_t *node = 0;
3017 ls_name = format (0, "%s", mp->ls_name);
3018 vec_add1 (ls_name, 0);
3020 if (VAT_JSON_ARRAY != vam->json_tree.type)
3022 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3023 vat_json_init_array (&vam->json_tree);
3025 node = vat_json_array_add (&vam->json_tree);
3027 vat_json_init_object (node);
3028 vat_json_object_add_string_copy (node, "ls_name", ls_name);
3029 vat_json_object_add_uint (node, "ls_index",
3030 clib_net_to_host_u32 (mp->ls_index));
3038 } __attribute__ ((__packed__)) lisp_nsh_api_t;
3041 unformat_nsh_address (unformat_input_t * input, va_list * args)
3043 lisp_nsh_api_t *nsh = va_arg (*args, lisp_nsh_api_t *);
3044 return unformat (input, "SPI:%d SI:%d", &nsh->spi, &nsh->si);
3048 format_nsh_address_vat (u8 * s, va_list * args)
3050 nsh_t *a = va_arg (*args, nsh_t *);
3051 return format (s, "SPI:%d SI:%d", clib_net_to_host_u32 (a->spi), a->si);
3055 format_lisp_flat_eid (u8 * s, va_list * args)
3057 u32 type = va_arg (*args, u32);
3058 u8 *eid = va_arg (*args, u8 *);
3059 u32 eid_len = va_arg (*args, u32);
3064 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
3066 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
3068 return format (s, "%U", format_ethernet_address, eid);
3070 return format (s, "%U", format_nsh_address_vat, eid);
3076 format_lisp_eid_vat (u8 * s, va_list * args)
3078 u32 type = va_arg (*args, u32);
3079 u8 *eid = va_arg (*args, u8 *);
3080 u32 eid_len = va_arg (*args, u32);
3081 u8 *seid = va_arg (*args, u8 *);
3082 u32 seid_len = va_arg (*args, u32);
3083 u32 is_src_dst = va_arg (*args, u32);
3086 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
3088 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
3094 vl_api_one_eid_table_details_t_handler (vl_api_one_eid_table_details_t * mp)
3096 vat_main_t *vam = &vat_main;
3097 u8 *s = 0, *eid = 0;
3099 if (~0 == mp->locator_set_index)
3100 s = format (0, "action: %d", mp->action);
3102 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
3104 eid = format (0, "%U", format_lisp_eid_vat,
3108 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
3111 print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
3112 clib_net_to_host_u32 (mp->vni),
3114 mp->is_local ? "local" : "remote",
3115 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
3116 clib_net_to_host_u16 (mp->key_id), mp->key);
3123 vl_api_one_eid_table_details_t_handler_json (vl_api_one_eid_table_details_t
3126 vat_main_t *vam = &vat_main;
3127 vat_json_node_t *node = 0;
3130 if (VAT_JSON_ARRAY != vam->json_tree.type)
3132 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3133 vat_json_init_array (&vam->json_tree);
3135 node = vat_json_array_add (&vam->json_tree);
3137 vat_json_init_object (node);
3138 if (~0 == mp->locator_set_index)
3139 vat_json_object_add_uint (node, "action", mp->action);
3141 vat_json_object_add_uint (node, "locator_set_index",
3142 clib_net_to_host_u32 (mp->locator_set_index));
3144 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
3145 if (mp->eid_type == 3)
3147 vat_json_node_t *nsh_json = vat_json_object_add (node, "eid");
3148 vat_json_init_object (nsh_json);
3149 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) mp->eid;
3150 vat_json_object_add_uint (nsh_json, "spi",
3151 clib_net_to_host_u32 (nsh->spi));
3152 vat_json_object_add_uint (nsh_json, "si", nsh->si);
3156 eid = format (0, "%U", format_lisp_eid_vat,
3160 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
3162 vat_json_object_add_string_copy (node, "eid", eid);
3165 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3166 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
3167 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
3171 vat_json_object_add_uint (node, "key_id",
3172 clib_net_to_host_u16 (mp->key_id));
3173 vat_json_object_add_string_copy (node, "key", mp->key);
3178 vl_api_one_stats_details_t_handler (vl_api_one_stats_details_t * mp)
3180 vat_main_t *vam = &vat_main;
3181 u8 *seid = 0, *deid = 0;
3182 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3184 deid = format (0, "%U", format_lisp_eid_vat,
3185 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3187 seid = format (0, "%U", format_lisp_eid_vat,
3188 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3194 format_ip_address_fcn = format_ip4_address;
3196 format_ip_address_fcn = format_ip6_address;
3199 print (vam->ofp, "([%d] %s %s) (%U %U) %u %u",
3200 clib_net_to_host_u32 (mp->vni),
3202 format_ip_address_fcn, mp->lloc,
3203 format_ip_address_fcn, mp->rloc,
3204 clib_net_to_host_u32 (mp->pkt_count),
3205 clib_net_to_host_u32 (mp->bytes));
3212 vl_api_one_stats_details_t_handler_json (vl_api_one_stats_details_t * mp)
3214 struct in6_addr ip6;
3216 vat_main_t *vam = &vat_main;
3217 vat_json_node_t *node = 0;
3218 u8 *deid = 0, *seid = 0;
3220 if (VAT_JSON_ARRAY != vam->json_tree.type)
3222 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3223 vat_json_init_array (&vam->json_tree);
3225 node = vat_json_array_add (&vam->json_tree);
3227 vat_json_init_object (node);
3228 deid = format (0, "%U", format_lisp_eid_vat,
3229 mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
3231 seid = format (0, "%U", format_lisp_eid_vat,
3232 mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
3237 vat_json_object_add_string_copy (node, "seid", seid);
3238 vat_json_object_add_string_copy (node, "deid", deid);
3239 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3243 clib_memcpy (&ip4, mp->lloc, sizeof (ip4));
3244 vat_json_object_add_ip4 (node, "lloc", ip4);
3245 clib_memcpy (&ip4, mp->rloc, sizeof (ip4));
3246 vat_json_object_add_ip4 (node, "rloc", ip4);
3250 clib_memcpy (&ip6, mp->lloc, sizeof (ip6));
3251 vat_json_object_add_ip6 (node, "lloc", ip6);
3252 clib_memcpy (&ip6, mp->rloc, sizeof (ip6));
3253 vat_json_object_add_ip6 (node, "rloc", ip6);
3255 vat_json_object_add_uint (node, "pkt_count",
3256 clib_net_to_host_u32 (mp->pkt_count));
3257 vat_json_object_add_uint (node, "bytes", clib_net_to_host_u32 (mp->bytes));
3264 vl_api_one_eid_table_map_details_t_handler
3265 (vl_api_one_eid_table_map_details_t * mp)
3267 vat_main_t *vam = &vat_main;
3269 u8 *line = format (0, "%=10d%=10d",
3270 clib_net_to_host_u32 (mp->vni),
3271 clib_net_to_host_u32 (mp->dp_table));
3272 print (vam->ofp, "%v", line);
3277 vl_api_one_eid_table_map_details_t_handler_json
3278 (vl_api_one_eid_table_map_details_t * mp)
3280 vat_main_t *vam = &vat_main;
3281 vat_json_node_t *node = NULL;
3283 if (VAT_JSON_ARRAY != vam->json_tree.type)
3285 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3286 vat_json_init_array (&vam->json_tree);
3288 node = vat_json_array_add (&vam->json_tree);
3289 vat_json_init_object (node);
3290 vat_json_object_add_uint (node, "dp_table",
3291 clib_net_to_host_u32 (mp->dp_table));
3292 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3296 vl_api_one_eid_table_vni_details_t_handler
3297 (vl_api_one_eid_table_vni_details_t * mp)
3299 vat_main_t *vam = &vat_main;
3301 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
3302 print (vam->ofp, "%v", line);
3307 vl_api_one_eid_table_vni_details_t_handler_json
3308 (vl_api_one_eid_table_vni_details_t * mp)
3310 vat_main_t *vam = &vat_main;
3311 vat_json_node_t *node = NULL;
3313 if (VAT_JSON_ARRAY != vam->json_tree.type)
3315 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3316 vat_json_init_array (&vam->json_tree);
3318 node = vat_json_array_add (&vam->json_tree);
3319 vat_json_init_object (node);
3320 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
3324 vl_api_show_one_map_register_fallback_threshold_reply_t_handler
3325 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3327 vat_main_t *vam = &vat_main;
3328 int retval = clib_net_to_host_u32 (mp->retval);
3330 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3331 print (vam->ofp, "fallback threshold value: %d", mp->value);
3333 vam->retval = retval;
3334 vam->result_ready = 1;
3338 vl_api_show_one_map_register_fallback_threshold_reply_t_handler_json
3339 (vl_api_show_one_map_register_fallback_threshold_reply_t * mp)
3341 vat_main_t *vam = &vat_main;
3342 vat_json_node_t _node, *node = &_node;
3343 int retval = clib_net_to_host_u32 (mp->retval);
3345 vl_api_show_one_map_register_fallback_threshold_reply_t_endian (mp);
3346 vat_json_init_object (node);
3347 vat_json_object_add_uint (node, "value", mp->value);
3349 vat_json_print (vam->ofp, node);
3350 vat_json_free (node);
3352 vam->retval = retval;
3353 vam->result_ready = 1;
3357 vl_api_show_one_map_register_state_reply_t_handler
3358 (vl_api_show_one_map_register_state_reply_t * mp)
3360 vat_main_t *vam = &vat_main;
3361 int retval = clib_net_to_host_u32 (mp->retval);
3363 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3365 vam->retval = retval;
3366 vam->result_ready = 1;
3370 vl_api_show_one_map_register_state_reply_t_handler_json
3371 (vl_api_show_one_map_register_state_reply_t * mp)
3373 vat_main_t *vam = &vat_main;
3374 vat_json_node_t _node, *node = &_node;
3375 int retval = clib_net_to_host_u32 (mp->retval);
3377 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3379 vat_json_init_object (node);
3380 vat_json_object_add_string_copy (node, "state", s);
3382 vat_json_print (vam->ofp, node);
3383 vat_json_free (node);
3385 vam->retval = retval;
3386 vam->result_ready = 1;
3391 vl_api_show_one_rloc_probe_state_reply_t_handler
3392 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3394 vat_main_t *vam = &vat_main;
3395 int retval = clib_net_to_host_u32 (mp->retval);
3400 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
3402 vam->retval = retval;
3403 vam->result_ready = 1;
3407 vl_api_show_one_rloc_probe_state_reply_t_handler_json
3408 (vl_api_show_one_rloc_probe_state_reply_t * mp)
3410 vat_main_t *vam = &vat_main;
3411 vat_json_node_t _node, *node = &_node;
3412 int retval = clib_net_to_host_u32 (mp->retval);
3414 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
3415 vat_json_init_object (node);
3416 vat_json_object_add_string_copy (node, "state", s);
3418 vat_json_print (vam->ofp, node);
3419 vat_json_free (node);
3421 vam->retval = retval;
3422 vam->result_ready = 1;
3427 vl_api_show_one_stats_enable_disable_reply_t_handler
3428 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3430 vat_main_t *vam = &vat_main;
3431 int retval = clib_net_to_host_u32 (mp->retval);
3436 print (vam->ofp, "%s", mp->is_en ? "enabled" : "disabled");
3438 vam->retval = retval;
3439 vam->result_ready = 1;
3443 vl_api_show_one_stats_enable_disable_reply_t_handler_json
3444 (vl_api_show_one_stats_enable_disable_reply_t * mp)
3446 vat_main_t *vam = &vat_main;
3447 vat_json_node_t _node, *node = &_node;
3448 int retval = clib_net_to_host_u32 (mp->retval);
3450 u8 *s = format (0, "%s", mp->is_en ? "enabled" : "disabled");
3451 vat_json_init_object (node);
3452 vat_json_object_add_string_copy (node, "state", s);
3454 vat_json_print (vam->ofp, node);
3455 vat_json_free (node);
3457 vam->retval = retval;
3458 vam->result_ready = 1;
3463 api_gpe_fwd_entry_net_to_host (vl_api_gpe_fwd_entry_t * e)
3465 e->dp_table = clib_net_to_host_u32 (e->dp_table);
3466 e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
3467 e->vni = clib_net_to_host_u32 (e->vni);
3471 gpe_fwd_entries_get_reply_t_net_to_host
3472 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3476 mp->count = clib_net_to_host_u32 (mp->count);
3477 for (i = 0; i < mp->count; i++)
3479 api_gpe_fwd_entry_net_to_host (&mp->entries[i]);
3484 format_gpe_encap_mode (u8 * s, va_list * args)
3486 u32 mode = va_arg (*args, u32);
3491 return format (s, "lisp");
3493 return format (s, "vxlan");
3499 vl_api_gpe_get_encap_mode_reply_t_handler
3500 (vl_api_gpe_get_encap_mode_reply_t * mp)
3502 vat_main_t *vam = &vat_main;
3504 print (vam->ofp, "gpe mode: %U", format_gpe_encap_mode, mp->encap_mode);
3505 vam->retval = ntohl (mp->retval);
3506 vam->result_ready = 1;
3510 vl_api_gpe_get_encap_mode_reply_t_handler_json
3511 (vl_api_gpe_get_encap_mode_reply_t * mp)
3513 vat_main_t *vam = &vat_main;
3514 vat_json_node_t node;
3516 u8 *encap_mode = format (0, "%U", format_gpe_encap_mode, mp->encap_mode);
3517 vec_add1 (encap_mode, 0);
3519 vat_json_init_object (&node);
3520 vat_json_object_add_string_copy (&node, "gpe_mode", encap_mode);
3522 vec_free (encap_mode);
3523 vat_json_print (vam->ofp, &node);
3524 vat_json_free (&node);
3526 vam->retval = ntohl (mp->retval);
3527 vam->result_ready = 1;
3531 vl_api_gpe_fwd_entry_path_details_t_handler
3532 (vl_api_gpe_fwd_entry_path_details_t * mp)
3534 vat_main_t *vam = &vat_main;
3535 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
3537 if (mp->lcl_loc.is_ip4)
3538 format_ip_address_fcn = format_ip4_address;
3540 format_ip_address_fcn = format_ip6_address;
3542 print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
3543 format_ip_address_fcn, &mp->lcl_loc,
3544 format_ip_address_fcn, &mp->rmt_loc);
3548 lisp_fill_locator_node (vat_json_node_t * n, vl_api_gpe_locator_t * loc)
3550 struct in6_addr ip6;
3555 clib_memcpy (&ip4, loc->addr, sizeof (ip4));
3556 vat_json_object_add_ip4 (n, "address", ip4);
3560 clib_memcpy (&ip6, loc->addr, sizeof (ip6));
3561 vat_json_object_add_ip6 (n, "address", ip6);
3563 vat_json_object_add_uint (n, "weight", loc->weight);
3567 vl_api_gpe_fwd_entry_path_details_t_handler_json
3568 (vl_api_gpe_fwd_entry_path_details_t * mp)
3570 vat_main_t *vam = &vat_main;
3571 vat_json_node_t *node = NULL;
3572 vat_json_node_t *loc_node;
3574 if (VAT_JSON_ARRAY != vam->json_tree.type)
3576 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3577 vat_json_init_array (&vam->json_tree);
3579 node = vat_json_array_add (&vam->json_tree);
3580 vat_json_init_object (node);
3582 loc_node = vat_json_object_add (node, "local_locator");
3583 vat_json_init_object (loc_node);
3584 lisp_fill_locator_node (loc_node, &mp->lcl_loc);
3586 loc_node = vat_json_object_add (node, "remote_locator");
3587 vat_json_init_object (loc_node);
3588 lisp_fill_locator_node (loc_node, &mp->rmt_loc);
3592 vl_api_gpe_fwd_entries_get_reply_t_handler
3593 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3595 vat_main_t *vam = &vat_main;
3597 int retval = clib_net_to_host_u32 (mp->retval);
3598 vl_api_gpe_fwd_entry_t *e;
3603 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3605 for (i = 0; i < mp->count; i++)
3607 e = &mp->entries[i];
3608 print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
3609 format_lisp_flat_eid, e->eid_type, e->leid, e->leid_prefix_len,
3610 format_lisp_flat_eid, e->eid_type, e->reid, e->reid_prefix_len);
3614 vam->retval = retval;
3615 vam->result_ready = 1;
3619 vl_api_gpe_fwd_entries_get_reply_t_handler_json
3620 (vl_api_gpe_fwd_entries_get_reply_t * mp)
3623 vat_main_t *vam = &vat_main;
3624 vat_json_node_t *e = 0, root;
3626 int retval = clib_net_to_host_u32 (mp->retval);
3627 vl_api_gpe_fwd_entry_t *fwd;
3632 gpe_fwd_entries_get_reply_t_net_to_host (mp);
3633 vat_json_init_array (&root);
3635 for (i = 0; i < mp->count; i++)
3637 e = vat_json_array_add (&root);
3638 fwd = &mp->entries[i];
3640 vat_json_init_object (e);
3641 vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
3642 vat_json_object_add_int (e, "dp_table", fwd->dp_table);
3643 vat_json_object_add_int (e, "vni", fwd->vni);
3644 vat_json_object_add_int (e, "action", fwd->action);
3646 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->leid,
3647 fwd->leid_prefix_len);
3649 vat_json_object_add_string_copy (e, "leid", s);
3652 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->reid,
3653 fwd->reid_prefix_len);
3655 vat_json_object_add_string_copy (e, "reid", s);
3659 vat_json_print (vam->ofp, &root);
3660 vat_json_free (&root);
3663 vam->retval = retval;
3664 vam->result_ready = 1;
3668 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler
3669 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3671 vat_main_t *vam = &vat_main;
3673 int retval = clib_net_to_host_u32 (mp->retval);
3674 vl_api_gpe_native_fwd_rpath_t *r;
3679 n = clib_net_to_host_u32 (mp->count);
3681 for (i = 0; i < n; i++)
3683 r = &mp->entries[i];
3684 print (vam->ofp, "fib_index: %d sw_if_index %d nh %U",
3685 clib_net_to_host_u32 (r->fib_index),
3686 clib_net_to_host_u32 (r->nh_sw_if_index),
3687 r->is_ip4 ? format_ip4_address : format_ip6_address, r->nh_addr);
3691 vam->retval = retval;
3692 vam->result_ready = 1;
3696 vl_api_gpe_native_fwd_rpaths_get_reply_t_handler_json
3697 (vl_api_gpe_native_fwd_rpaths_get_reply_t * mp)
3699 vat_main_t *vam = &vat_main;
3700 vat_json_node_t root, *e;
3702 int retval = clib_net_to_host_u32 (mp->retval);
3703 vl_api_gpe_native_fwd_rpath_t *r;
3709 n = clib_net_to_host_u32 (mp->count);
3710 vat_json_init_array (&root);
3712 for (i = 0; i < n; i++)
3714 e = vat_json_array_add (&root);
3715 vat_json_init_object (e);
3716 r = &mp->entries[i];
3718 format (0, "%U", r->is_ip4 ? format_ip4_address : format_ip6_address,
3721 vat_json_object_add_string_copy (e, "ip4", s);
3724 vat_json_object_add_uint (e, "fib_index",
3725 clib_net_to_host_u32 (r->fib_index));
3726 vat_json_object_add_uint (e, "nh_sw_if_index",
3727 clib_net_to_host_u32 (r->nh_sw_if_index));
3730 vat_json_print (vam->ofp, &root);
3731 vat_json_free (&root);
3734 vam->retval = retval;
3735 vam->result_ready = 1;
3739 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler
3740 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3742 vat_main_t *vam = &vat_main;
3744 int retval = clib_net_to_host_u32 (mp->retval);
3749 n = clib_net_to_host_u32 (mp->count);
3751 for (i = 0; i < n; i++)
3752 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->vnis[i]));
3755 vam->retval = retval;
3756 vam->result_ready = 1;
3760 vl_api_gpe_fwd_entry_vnis_get_reply_t_handler_json
3761 (vl_api_gpe_fwd_entry_vnis_get_reply_t * mp)
3763 vat_main_t *vam = &vat_main;
3764 vat_json_node_t root;
3766 int retval = clib_net_to_host_u32 (mp->retval);
3771 n = clib_net_to_host_u32 (mp->count);
3772 vat_json_init_array (&root);
3774 for (i = 0; i < n; i++)
3775 vat_json_array_add_uint (&root, clib_net_to_host_u32 (mp->vnis[i]));
3777 vat_json_print (vam->ofp, &root);
3778 vat_json_free (&root);
3781 vam->retval = retval;
3782 vam->result_ready = 1;
3786 vl_api_one_ndp_entries_get_reply_t_handler
3787 (vl_api_one_ndp_entries_get_reply_t * mp)
3789 vat_main_t *vam = &vat_main;
3791 int retval = clib_net_to_host_u32 (mp->retval);
3796 n = clib_net_to_host_u32 (mp->count);
3798 for (i = 0; i < n; i++)
3799 print (vam->ofp, "%U -> %U", format_ip6_address, &mp->entries[i].ip6,
3800 format_ethernet_address, mp->entries[i].mac);
3803 vam->retval = retval;
3804 vam->result_ready = 1;
3808 vl_api_one_ndp_entries_get_reply_t_handler_json
3809 (vl_api_one_ndp_entries_get_reply_t * mp)
3812 vat_main_t *vam = &vat_main;
3813 vat_json_node_t *e = 0, root;
3815 int retval = clib_net_to_host_u32 (mp->retval);
3816 vl_api_one_ndp_entry_t *arp_entry;
3821 n = clib_net_to_host_u32 (mp->count);
3822 vat_json_init_array (&root);
3824 for (i = 0; i < n; i++)
3826 e = vat_json_array_add (&root);
3827 arp_entry = &mp->entries[i];
3829 vat_json_init_object (e);
3830 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3833 vat_json_object_add_string_copy (e, "mac", s);
3836 s = format (0, "%U", format_ip6_address, &arp_entry->ip6);
3838 vat_json_object_add_string_copy (e, "ip6", s);
3842 vat_json_print (vam->ofp, &root);
3843 vat_json_free (&root);
3846 vam->retval = retval;
3847 vam->result_ready = 1;
3851 vl_api_one_l2_arp_entries_get_reply_t_handler
3852 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3854 vat_main_t *vam = &vat_main;
3856 int retval = clib_net_to_host_u32 (mp->retval);
3861 n = clib_net_to_host_u32 (mp->count);
3863 for (i = 0; i < n; i++)
3864 print (vam->ofp, "%U -> %U", format_ip4_address, &mp->entries[i].ip4,
3865 format_ethernet_address, mp->entries[i].mac);
3868 vam->retval = retval;
3869 vam->result_ready = 1;
3873 vl_api_one_l2_arp_entries_get_reply_t_handler_json
3874 (vl_api_one_l2_arp_entries_get_reply_t * mp)
3877 vat_main_t *vam = &vat_main;
3878 vat_json_node_t *e = 0, root;
3880 int retval = clib_net_to_host_u32 (mp->retval);
3881 vl_api_one_l2_arp_entry_t *arp_entry;
3886 n = clib_net_to_host_u32 (mp->count);
3887 vat_json_init_array (&root);
3889 for (i = 0; i < n; i++)
3891 e = vat_json_array_add (&root);
3892 arp_entry = &mp->entries[i];
3894 vat_json_init_object (e);
3895 s = format (0, "%U", format_ethernet_address, arp_entry->mac);
3898 vat_json_object_add_string_copy (e, "mac", s);
3901 s = format (0, "%U", format_ip4_address, &arp_entry->ip4);
3903 vat_json_object_add_string_copy (e, "ip4", s);
3907 vat_json_print (vam->ofp, &root);
3908 vat_json_free (&root);
3911 vam->retval = retval;
3912 vam->result_ready = 1;
3916 vl_api_one_ndp_bd_get_reply_t_handler (vl_api_one_ndp_bd_get_reply_t * mp)
3918 vat_main_t *vam = &vat_main;
3920 int retval = clib_net_to_host_u32 (mp->retval);
3925 n = clib_net_to_host_u32 (mp->count);
3927 for (i = 0; i < n; i++)
3929 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3933 vam->retval = retval;
3934 vam->result_ready = 1;
3938 vl_api_one_ndp_bd_get_reply_t_handler_json
3939 (vl_api_one_ndp_bd_get_reply_t * mp)
3941 vat_main_t *vam = &vat_main;
3942 vat_json_node_t root;
3944 int retval = clib_net_to_host_u32 (mp->retval);
3949 n = clib_net_to_host_u32 (mp->count);
3950 vat_json_init_array (&root);
3952 for (i = 0; i < n; i++)
3954 vat_json_array_add_uint (&root,
3955 clib_net_to_host_u32 (mp->bridge_domains[i]));
3958 vat_json_print (vam->ofp, &root);
3959 vat_json_free (&root);
3962 vam->retval = retval;
3963 vam->result_ready = 1;
3967 vl_api_one_l2_arp_bd_get_reply_t_handler
3968 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3970 vat_main_t *vam = &vat_main;
3972 int retval = clib_net_to_host_u32 (mp->retval);
3977 n = clib_net_to_host_u32 (mp->count);
3979 for (i = 0; i < n; i++)
3981 print (vam->ofp, "%d", clib_net_to_host_u32 (mp->bridge_domains[i]));
3985 vam->retval = retval;
3986 vam->result_ready = 1;
3990 vl_api_one_l2_arp_bd_get_reply_t_handler_json
3991 (vl_api_one_l2_arp_bd_get_reply_t * mp)
3993 vat_main_t *vam = &vat_main;
3994 vat_json_node_t root;
3996 int retval = clib_net_to_host_u32 (mp->retval);
4001 n = clib_net_to_host_u32 (mp->count);
4002 vat_json_init_array (&root);
4004 for (i = 0; i < n; i++)
4006 vat_json_array_add_uint (&root,
4007 clib_net_to_host_u32 (mp->bridge_domains[i]));
4010 vat_json_print (vam->ofp, &root);
4011 vat_json_free (&root);
4014 vam->retval = retval;
4015 vam->result_ready = 1;
4019 vl_api_one_adjacencies_get_reply_t_handler
4020 (vl_api_one_adjacencies_get_reply_t * mp)
4022 vat_main_t *vam = &vat_main;
4024 int retval = clib_net_to_host_u32 (mp->retval);
4025 vl_api_one_adjacency_t *a;
4030 n = clib_net_to_host_u32 (mp->count);
4032 for (i = 0; i < n; i++)
4034 a = &mp->adjacencies[i];
4035 print (vam->ofp, "%U %40U",
4036 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
4037 format_lisp_flat_eid, a->eid_type, a->reid, a->reid_prefix_len);
4041 vam->retval = retval;
4042 vam->result_ready = 1;
4046 vl_api_one_adjacencies_get_reply_t_handler_json
4047 (vl_api_one_adjacencies_get_reply_t * mp)
4050 vat_main_t *vam = &vat_main;
4051 vat_json_node_t *e = 0, root;
4053 int retval = clib_net_to_host_u32 (mp->retval);
4054 vl_api_one_adjacency_t *a;
4059 n = clib_net_to_host_u32 (mp->count);
4060 vat_json_init_array (&root);
4062 for (i = 0; i < n; i++)
4064 e = vat_json_array_add (&root);
4065 a = &mp->adjacencies[i];
4067 vat_json_init_object (e);
4068 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
4069 a->leid_prefix_len);
4071 vat_json_object_add_string_copy (e, "leid", s);
4074 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
4075 a->reid_prefix_len);
4077 vat_json_object_add_string_copy (e, "reid", s);
4081 vat_json_print (vam->ofp, &root);
4082 vat_json_free (&root);
4085 vam->retval = retval;
4086 vam->result_ready = 1;
4090 vl_api_one_map_server_details_t_handler (vl_api_one_map_server_details_t * mp)
4092 vat_main_t *vam = &vat_main;
4094 print (vam->ofp, "%=20U",
4095 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
4100 vl_api_one_map_server_details_t_handler_json
4101 (vl_api_one_map_server_details_t * mp)
4103 vat_main_t *vam = &vat_main;
4104 vat_json_node_t *node = NULL;
4105 struct in6_addr ip6;
4108 if (VAT_JSON_ARRAY != vam->json_tree.type)
4110 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4111 vat_json_init_array (&vam->json_tree);
4113 node = vat_json_array_add (&vam->json_tree);
4115 vat_json_init_object (node);
4118 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
4119 vat_json_object_add_ip6 (node, "map-server", ip6);
4123 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
4124 vat_json_object_add_ip4 (node, "map-server", ip4);
4129 vl_api_one_map_resolver_details_t_handler (vl_api_one_map_resolver_details_t
4132 vat_main_t *vam = &vat_main;
4134 print (vam->ofp, "%=20U",
4135 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
4140 vl_api_one_map_resolver_details_t_handler_json
4141 (vl_api_one_map_resolver_details_t * mp)
4143 vat_main_t *vam = &vat_main;
4144 vat_json_node_t *node = NULL;
4145 struct in6_addr ip6;
4148 if (VAT_JSON_ARRAY != vam->json_tree.type)
4150 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4151 vat_json_init_array (&vam->json_tree);
4153 node = vat_json_array_add (&vam->json_tree);
4155 vat_json_init_object (node);
4158 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
4159 vat_json_object_add_ip6 (node, "map resolver", ip6);
4163 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
4164 vat_json_object_add_ip4 (node, "map resolver", ip4);
4169 vl_api_show_one_status_reply_t_handler (vl_api_show_one_status_reply_t * mp)
4171 vat_main_t *vam = &vat_main;
4172 i32 retval = ntohl (mp->retval);
4176 print (vam->ofp, "feature: %s\ngpe: %s",
4177 mp->feature_status ? "enabled" : "disabled",
4178 mp->gpe_status ? "enabled" : "disabled");
4181 vam->retval = retval;
4182 vam->result_ready = 1;
4186 vl_api_show_one_status_reply_t_handler_json
4187 (vl_api_show_one_status_reply_t * mp)
4189 vat_main_t *vam = &vat_main;
4190 vat_json_node_t node;
4191 u8 *gpe_status = NULL;
4192 u8 *feature_status = NULL;
4194 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
4195 feature_status = format (0, "%s",
4196 mp->feature_status ? "enabled" : "disabled");
4197 vec_add1 (gpe_status, 0);
4198 vec_add1 (feature_status, 0);
4200 vat_json_init_object (&node);
4201 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
4202 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
4204 vec_free (gpe_status);
4205 vec_free (feature_status);
4207 vat_json_print (vam->ofp, &node);
4208 vat_json_free (&node);
4210 vam->retval = ntohl (mp->retval);
4211 vam->result_ready = 1;
4215 vl_api_one_get_map_request_itr_rlocs_reply_t_handler
4216 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4218 vat_main_t *vam = &vat_main;
4219 i32 retval = ntohl (mp->retval);
4223 print (vam->ofp, "%=20s", mp->locator_set_name);
4226 vam->retval = retval;
4227 vam->result_ready = 1;
4231 vl_api_one_get_map_request_itr_rlocs_reply_t_handler_json
4232 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
4234 vat_main_t *vam = &vat_main;
4235 vat_json_node_t *node = NULL;
4237 if (VAT_JSON_ARRAY != vam->json_tree.type)
4239 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4240 vat_json_init_array (&vam->json_tree);
4242 node = vat_json_array_add (&vam->json_tree);
4244 vat_json_init_object (node);
4245 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
4247 vat_json_print (vam->ofp, node);
4248 vat_json_free (node);
4250 vam->retval = ntohl (mp->retval);
4251 vam->result_ready = 1;
4255 format_lisp_map_request_mode (u8 * s, va_list * args)
4257 u32 mode = va_arg (*args, u32);
4262 return format (0, "dst-only");
4264 return format (0, "src-dst");
4270 vl_api_show_one_map_request_mode_reply_t_handler
4271 (vl_api_show_one_map_request_mode_reply_t * mp)
4273 vat_main_t *vam = &vat_main;
4274 i32 retval = ntohl (mp->retval);
4278 u32 mode = mp->mode;
4279 print (vam->ofp, "map_request_mode: %U",
4280 format_lisp_map_request_mode, mode);
4283 vam->retval = retval;
4284 vam->result_ready = 1;
4288 vl_api_show_one_map_request_mode_reply_t_handler_json
4289 (vl_api_show_one_map_request_mode_reply_t * mp)
4291 vat_main_t *vam = &vat_main;
4292 vat_json_node_t node;
4297 s = format (0, "%U", format_lisp_map_request_mode, mode);
4300 vat_json_init_object (&node);
4301 vat_json_object_add_string_copy (&node, "map_request_mode", s);
4302 vat_json_print (vam->ofp, &node);
4303 vat_json_free (&node);
4306 vam->retval = ntohl (mp->retval);
4307 vam->result_ready = 1;
4311 vl_api_one_show_xtr_mode_reply_t_handler
4312 (vl_api_one_show_xtr_mode_reply_t * mp)
4314 vat_main_t *vam = &vat_main;
4315 i32 retval = ntohl (mp->retval);
4319 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4322 vam->retval = retval;
4323 vam->result_ready = 1;
4327 vl_api_one_show_xtr_mode_reply_t_handler_json
4328 (vl_api_one_show_xtr_mode_reply_t * mp)
4330 vat_main_t *vam = &vat_main;
4331 vat_json_node_t node;
4334 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4335 vec_add1 (status, 0);
4337 vat_json_init_object (&node);
4338 vat_json_object_add_string_copy (&node, "status", status);
4342 vat_json_print (vam->ofp, &node);
4343 vat_json_free (&node);
4345 vam->retval = ntohl (mp->retval);
4346 vam->result_ready = 1;
4350 vl_api_one_show_pitr_mode_reply_t_handler
4351 (vl_api_one_show_pitr_mode_reply_t * mp)
4353 vat_main_t *vam = &vat_main;
4354 i32 retval = ntohl (mp->retval);
4358 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4361 vam->retval = retval;
4362 vam->result_ready = 1;
4366 vl_api_one_show_pitr_mode_reply_t_handler_json
4367 (vl_api_one_show_pitr_mode_reply_t * mp)
4369 vat_main_t *vam = &vat_main;
4370 vat_json_node_t node;
4373 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4374 vec_add1 (status, 0);
4376 vat_json_init_object (&node);
4377 vat_json_object_add_string_copy (&node, "status", status);
4381 vat_json_print (vam->ofp, &node);
4382 vat_json_free (&node);
4384 vam->retval = ntohl (mp->retval);
4385 vam->result_ready = 1;
4389 vl_api_one_show_petr_mode_reply_t_handler
4390 (vl_api_one_show_petr_mode_reply_t * mp)
4392 vat_main_t *vam = &vat_main;
4393 i32 retval = ntohl (mp->retval);
4397 print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
4400 vam->retval = retval;
4401 vam->result_ready = 1;
4405 vl_api_one_show_petr_mode_reply_t_handler_json
4406 (vl_api_one_show_petr_mode_reply_t * mp)
4408 vat_main_t *vam = &vat_main;
4409 vat_json_node_t node;
4412 status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
4413 vec_add1 (status, 0);
4415 vat_json_init_object (&node);
4416 vat_json_object_add_string_copy (&node, "status", status);
4420 vat_json_print (vam->ofp, &node);
4421 vat_json_free (&node);
4423 vam->retval = ntohl (mp->retval);
4424 vam->result_ready = 1;
4428 vl_api_show_one_use_petr_reply_t_handler
4429 (vl_api_show_one_use_petr_reply_t * mp)
4431 vat_main_t *vam = &vat_main;
4432 i32 retval = ntohl (mp->retval);
4436 print (vam->ofp, "%s\n", mp->status ? "enabled" : "disabled");
4439 print (vam->ofp, "Proxy-ETR address; %U",
4440 mp->is_ip4 ? format_ip4_address : format_ip6_address,
4445 vam->retval = retval;
4446 vam->result_ready = 1;
4450 vl_api_show_one_use_petr_reply_t_handler_json
4451 (vl_api_show_one_use_petr_reply_t * mp)
4453 vat_main_t *vam = &vat_main;
4454 vat_json_node_t node;
4457 struct in6_addr ip6;
4459 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4460 vec_add1 (status, 0);
4462 vat_json_init_object (&node);
4463 vat_json_object_add_string_copy (&node, "status", status);
4468 clib_memcpy (&ip6, mp->address, sizeof (ip6));
4469 vat_json_object_add_ip6 (&node, "address", ip6);
4473 clib_memcpy (&ip4, mp->address, sizeof (ip4));
4474 vat_json_object_add_ip4 (&node, "address", ip4);
4480 vat_json_print (vam->ofp, &node);
4481 vat_json_free (&node);
4483 vam->retval = ntohl (mp->retval);
4484 vam->result_ready = 1;
4488 vl_api_show_one_nsh_mapping_reply_t_handler
4489 (vl_api_show_one_nsh_mapping_reply_t * mp)
4491 vat_main_t *vam = &vat_main;
4492 i32 retval = ntohl (mp->retval);
4496 print (vam->ofp, "%-20s%-16s",
4497 mp->is_set ? "set" : "not-set",
4498 mp->is_set ? (char *) mp->locator_set_name : "");
4501 vam->retval = retval;
4502 vam->result_ready = 1;
4506 vl_api_show_one_nsh_mapping_reply_t_handler_json
4507 (vl_api_show_one_nsh_mapping_reply_t * mp)
4509 vat_main_t *vam = &vat_main;
4510 vat_json_node_t node;
4513 status = format (0, "%s", mp->is_set ? "yes" : "no");
4514 vec_add1 (status, 0);
4516 vat_json_init_object (&node);
4517 vat_json_object_add_string_copy (&node, "is_set", status);
4520 vat_json_object_add_string_copy (&node, "locator_set",
4521 mp->locator_set_name);
4526 vat_json_print (vam->ofp, &node);
4527 vat_json_free (&node);
4529 vam->retval = ntohl (mp->retval);
4530 vam->result_ready = 1;
4534 vl_api_show_one_map_register_ttl_reply_t_handler
4535 (vl_api_show_one_map_register_ttl_reply_t * mp)
4537 vat_main_t *vam = &vat_main;
4538 i32 retval = ntohl (mp->retval);
4540 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4544 print (vam->ofp, "ttl: %u", mp->ttl);
4547 vam->retval = retval;
4548 vam->result_ready = 1;
4552 vl_api_show_one_map_register_ttl_reply_t_handler_json
4553 (vl_api_show_one_map_register_ttl_reply_t * mp)
4555 vat_main_t *vam = &vat_main;
4556 vat_json_node_t node;
4558 vl_api_show_one_map_register_ttl_reply_t_endian (mp);
4559 vat_json_init_object (&node);
4560 vat_json_object_add_uint (&node, "ttl", mp->ttl);
4562 vat_json_print (vam->ofp, &node);
4563 vat_json_free (&node);
4565 vam->retval = ntohl (mp->retval);
4566 vam->result_ready = 1;
4570 vl_api_show_one_pitr_reply_t_handler (vl_api_show_one_pitr_reply_t * mp)
4572 vat_main_t *vam = &vat_main;
4573 i32 retval = ntohl (mp->retval);
4577 print (vam->ofp, "%-20s%-16s",
4578 mp->status ? "enabled" : "disabled",
4579 mp->status ? (char *) mp->locator_set_name : "");
4582 vam->retval = retval;
4583 vam->result_ready = 1;
4587 vl_api_show_one_pitr_reply_t_handler_json (vl_api_show_one_pitr_reply_t * mp)
4589 vat_main_t *vam = &vat_main;
4590 vat_json_node_t node;
4593 status = format (0, "%s", mp->status ? "enabled" : "disabled");
4594 vec_add1 (status, 0);
4596 vat_json_init_object (&node);
4597 vat_json_object_add_string_copy (&node, "status", status);
4600 vat_json_object_add_string_copy (&node, "locator_set",
4601 mp->locator_set_name);
4606 vat_json_print (vam->ofp, &node);
4607 vat_json_free (&node);
4609 vam->retval = ntohl (mp->retval);
4610 vam->result_ready = 1;
4614 format_policer_type (u8 * s, va_list * va)
4616 u32 i = va_arg (*va, u32);
4618 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
4619 s = format (s, "1r2c");
4620 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
4621 s = format (s, "1r3c");
4622 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
4623 s = format (s, "2r3c-2698");
4624 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
4625 s = format (s, "2r3c-4115");
4626 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
4627 s = format (s, "2r3c-mef5cf1");
4629 s = format (s, "ILLEGAL");
4634 format_policer_rate_type (u8 * s, va_list * va)
4636 u32 i = va_arg (*va, u32);
4638 if (i == SSE2_QOS_RATE_KBPS)
4639 s = format (s, "kbps");
4640 else if (i == SSE2_QOS_RATE_PPS)
4641 s = format (s, "pps");
4643 s = format (s, "ILLEGAL");
4648 format_policer_round_type (u8 * s, va_list * va)
4650 u32 i = va_arg (*va, u32);
4652 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
4653 s = format (s, "closest");
4654 else if (i == SSE2_QOS_ROUND_TO_UP)
4655 s = format (s, "up");
4656 else if (i == SSE2_QOS_ROUND_TO_DOWN)
4657 s = format (s, "down");
4659 s = format (s, "ILLEGAL");
4664 format_policer_action_type (u8 * s, va_list * va)
4666 u32 i = va_arg (*va, u32);
4668 if (i == SSE2_QOS_ACTION_DROP)
4669 s = format (s, "drop");
4670 else if (i == SSE2_QOS_ACTION_TRANSMIT)
4671 s = format (s, "transmit");
4672 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4673 s = format (s, "mark-and-transmit");
4675 s = format (s, "ILLEGAL");
4680 format_dscp (u8 * s, va_list * va)
4682 u32 i = va_arg (*va, u32);
4687 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
4691 return format (s, "ILLEGAL");
4693 s = format (s, "%s", t);
4698 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
4700 vat_main_t *vam = &vat_main;
4701 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
4703 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4704 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4706 conform_dscp_str = format (0, "");
4708 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4709 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4711 exceed_dscp_str = format (0, "");
4713 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4714 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4716 violate_dscp_str = format (0, "");
4718 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
4719 "rate type %U, round type %U, %s rate, %s color-aware, "
4720 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
4721 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
4722 "conform action %U%s, exceed action %U%s, violate action %U%s",
4724 format_policer_type, mp->type,
4727 clib_net_to_host_u64 (mp->cb),
4728 clib_net_to_host_u64 (mp->eb),
4729 format_policer_rate_type, mp->rate_type,
4730 format_policer_round_type, mp->round_type,
4731 mp->single_rate ? "single" : "dual",
4732 mp->color_aware ? "is" : "not",
4733 ntohl (mp->cir_tokens_per_period),
4734 ntohl (mp->pir_tokens_per_period),
4736 ntohl (mp->current_limit),
4737 ntohl (mp->current_bucket),
4738 ntohl (mp->extended_limit),
4739 ntohl (mp->extended_bucket),
4740 clib_net_to_host_u64 (mp->last_update_time),
4741 format_policer_action_type, mp->conform_action_type,
4743 format_policer_action_type, mp->exceed_action_type,
4745 format_policer_action_type, mp->violate_action_type,
4748 vec_free (conform_dscp_str);
4749 vec_free (exceed_dscp_str);
4750 vec_free (violate_dscp_str);
4753 static void vl_api_policer_details_t_handler_json
4754 (vl_api_policer_details_t * mp)
4756 vat_main_t *vam = &vat_main;
4757 vat_json_node_t *node;
4758 u8 *rate_type_str, *round_type_str, *type_str;
4759 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
4761 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
4763 format (0, "%U", format_policer_round_type, mp->round_type);
4764 type_str = format (0, "%U", format_policer_type, mp->type);
4765 conform_action_str = format (0, "%U", format_policer_action_type,
4766 mp->conform_action_type);
4767 exceed_action_str = format (0, "%U", format_policer_action_type,
4768 mp->exceed_action_type);
4769 violate_action_str = format (0, "%U", format_policer_action_type,
4770 mp->violate_action_type);
4772 if (VAT_JSON_ARRAY != vam->json_tree.type)
4774 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
4775 vat_json_init_array (&vam->json_tree);
4777 node = vat_json_array_add (&vam->json_tree);
4779 vat_json_init_object (node);
4780 vat_json_object_add_string_copy (node, "name", mp->name);
4781 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
4782 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
4783 vat_json_object_add_uint (node, "cb", clib_net_to_host_u64 (mp->cb));
4784 vat_json_object_add_uint (node, "eb", clib_net_to_host_u64 (mp->eb));
4785 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
4786 vat_json_object_add_string_copy (node, "round_type", round_type_str);
4787 vat_json_object_add_string_copy (node, "type", type_str);
4788 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
4789 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
4790 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
4791 vat_json_object_add_uint (node, "cir_tokens_per_period",
4792 ntohl (mp->cir_tokens_per_period));
4793 vat_json_object_add_uint (node, "eir_tokens_per_period",
4794 ntohl (mp->pir_tokens_per_period));
4795 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
4796 vat_json_object_add_uint (node, "current_bucket",
4797 ntohl (mp->current_bucket));
4798 vat_json_object_add_uint (node, "extended_limit",
4799 ntohl (mp->extended_limit));
4800 vat_json_object_add_uint (node, "extended_bucket",
4801 ntohl (mp->extended_bucket));
4802 vat_json_object_add_uint (node, "last_update_time",
4803 ntohl (mp->last_update_time));
4804 vat_json_object_add_string_copy (node, "conform_action",
4805 conform_action_str);
4806 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4808 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
4809 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
4810 vec_free (dscp_str);
4812 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
4813 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4815 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
4816 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
4817 vec_free (dscp_str);
4819 vat_json_object_add_string_copy (node, "violate_action",
4820 violate_action_str);
4821 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
4823 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
4824 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
4825 vec_free (dscp_str);
4828 vec_free (rate_type_str);
4829 vec_free (round_type_str);
4830 vec_free (type_str);
4831 vec_free (conform_action_str);
4832 vec_free (exceed_action_str);
4833 vec_free (violate_action_str);
4837 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
4840 vat_main_t *vam = &vat_main;
4841 int i, count = ntohl (mp->count);
4844 print (vam->ofp, "classify table ids (%d) : ", count);
4845 for (i = 0; i < count; i++)
4847 print (vam->ofp, "%d", ntohl (mp->ids[i]));
4848 print (vam->ofp, (i < count - 1) ? "," : "");
4850 vam->retval = ntohl (mp->retval);
4851 vam->result_ready = 1;
4855 vl_api_classify_table_ids_reply_t_handler_json
4856 (vl_api_classify_table_ids_reply_t * mp)
4858 vat_main_t *vam = &vat_main;
4859 int i, count = ntohl (mp->count);
4863 vat_json_node_t node;
4865 vat_json_init_object (&node);
4866 for (i = 0; i < count; i++)
4868 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
4870 vat_json_print (vam->ofp, &node);
4871 vat_json_free (&node);
4873 vam->retval = ntohl (mp->retval);
4874 vam->result_ready = 1;
4878 vl_api_classify_table_by_interface_reply_t_handler
4879 (vl_api_classify_table_by_interface_reply_t * mp)
4881 vat_main_t *vam = &vat_main;
4884 table_id = ntohl (mp->l2_table_id);
4886 print (vam->ofp, "l2 table id : %d", table_id);
4888 print (vam->ofp, "l2 table id : No input ACL tables configured");
4889 table_id = ntohl (mp->ip4_table_id);
4891 print (vam->ofp, "ip4 table id : %d", table_id);
4893 print (vam->ofp, "ip4 table id : No input ACL tables configured");
4894 table_id = ntohl (mp->ip6_table_id);
4896 print (vam->ofp, "ip6 table id : %d", table_id);
4898 print (vam->ofp, "ip6 table id : No input ACL tables configured");
4899 vam->retval = ntohl (mp->retval);
4900 vam->result_ready = 1;
4904 vl_api_classify_table_by_interface_reply_t_handler_json
4905 (vl_api_classify_table_by_interface_reply_t * mp)
4907 vat_main_t *vam = &vat_main;
4908 vat_json_node_t node;
4910 vat_json_init_object (&node);
4912 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
4913 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
4914 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
4916 vat_json_print (vam->ofp, &node);
4917 vat_json_free (&node);
4919 vam->retval = ntohl (mp->retval);
4920 vam->result_ready = 1;
4923 static void vl_api_policer_add_del_reply_t_handler
4924 (vl_api_policer_add_del_reply_t * mp)
4926 vat_main_t *vam = &vat_main;
4927 i32 retval = ntohl (mp->retval);
4928 if (vam->async_mode)
4930 vam->async_errors += (retval < 0);
4934 vam->retval = retval;
4935 vam->result_ready = 1;
4936 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
4938 * Note: this is just barely thread-safe, depends on
4939 * the main thread spinning waiting for an answer...
4941 errmsg ("policer index %d", ntohl (mp->policer_index));
4945 static void vl_api_policer_add_del_reply_t_handler_json
4946 (vl_api_policer_add_del_reply_t * mp)
4948 vat_main_t *vam = &vat_main;
4949 vat_json_node_t node;
4951 vat_json_init_object (&node);
4952 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
4953 vat_json_object_add_uint (&node, "policer_index",
4954 ntohl (mp->policer_index));
4956 vat_json_print (vam->ofp, &node);
4957 vat_json_free (&node);
4959 vam->retval = ntohl (mp->retval);
4960 vam->result_ready = 1;
4963 /* Format hex dump. */
4965 format_hex_bytes (u8 * s, va_list * va)
4967 u8 *bytes = va_arg (*va, u8 *);
4968 int n_bytes = va_arg (*va, int);
4971 /* Print short or long form depending on byte count. */
4972 uword short_form = n_bytes <= 32;
4973 u32 indent = format_get_indent (s);
4978 for (i = 0; i < n_bytes; i++)
4980 if (!short_form && (i % 32) == 0)
4981 s = format (s, "%08x: ", i);
4982 s = format (s, "%02x", bytes[i]);
4983 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
4984 s = format (s, "\n%U", format_white_space, indent);
4991 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
4994 vat_main_t *vam = &vat_main;
4995 i32 retval = ntohl (mp->retval);
4998 print (vam->ofp, "classify table info :");
4999 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
5000 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
5001 ntohl (mp->miss_next_index));
5002 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
5003 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
5004 ntohl (mp->match_n_vectors));
5005 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
5006 ntohl (mp->mask_length));
5008 vam->retval = retval;
5009 vam->result_ready = 1;
5013 vl_api_classify_table_info_reply_t_handler_json
5014 (vl_api_classify_table_info_reply_t * mp)
5016 vat_main_t *vam = &vat_main;
5017 vat_json_node_t node;
5019 i32 retval = ntohl (mp->retval);
5022 vat_json_init_object (&node);
5024 vat_json_object_add_int (&node, "sessions",
5025 ntohl (mp->active_sessions));
5026 vat_json_object_add_int (&node, "nexttbl",
5027 ntohl (mp->next_table_index));
5028 vat_json_object_add_int (&node, "nextnode",
5029 ntohl (mp->miss_next_index));
5030 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
5031 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
5032 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
5033 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
5034 ntohl (mp->mask_length), 0);
5035 vat_json_object_add_string_copy (&node, "mask", s);
5037 vat_json_print (vam->ofp, &node);
5038 vat_json_free (&node);
5040 vam->retval = ntohl (mp->retval);
5041 vam->result_ready = 1;
5045 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
5048 vat_main_t *vam = &vat_main;
5050 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
5051 ntohl (mp->hit_next_index), ntohl (mp->advance),
5052 ntohl (mp->opaque_index));
5053 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
5054 ntohl (mp->match_length));
5058 vl_api_classify_session_details_t_handler_json
5059 (vl_api_classify_session_details_t * mp)
5061 vat_main_t *vam = &vat_main;
5062 vat_json_node_t *node = NULL;
5064 if (VAT_JSON_ARRAY != vam->json_tree.type)
5066 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5067 vat_json_init_array (&vam->json_tree);
5069 node = vat_json_array_add (&vam->json_tree);
5071 vat_json_init_object (node);
5072 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
5073 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
5074 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
5076 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
5078 vat_json_object_add_string_copy (node, "match", s);
5081 static void vl_api_pg_create_interface_reply_t_handler
5082 (vl_api_pg_create_interface_reply_t * mp)
5084 vat_main_t *vam = &vat_main;
5086 vam->retval = ntohl (mp->retval);
5087 vam->result_ready = 1;
5090 static void vl_api_pg_create_interface_reply_t_handler_json
5091 (vl_api_pg_create_interface_reply_t * mp)
5093 vat_main_t *vam = &vat_main;
5094 vat_json_node_t node;
5096 i32 retval = ntohl (mp->retval);
5099 vat_json_init_object (&node);
5101 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
5103 vat_json_print (vam->ofp, &node);
5104 vat_json_free (&node);
5106 vam->retval = ntohl (mp->retval);
5107 vam->result_ready = 1;
5110 static void vl_api_policer_classify_details_t_handler
5111 (vl_api_policer_classify_details_t * mp)
5113 vat_main_t *vam = &vat_main;
5115 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
5116 ntohl (mp->table_index));
5119 static void vl_api_policer_classify_details_t_handler_json
5120 (vl_api_policer_classify_details_t * mp)
5122 vat_main_t *vam = &vat_main;
5123 vat_json_node_t *node;
5125 if (VAT_JSON_ARRAY != vam->json_tree.type)
5127 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5128 vat_json_init_array (&vam->json_tree);
5130 node = vat_json_array_add (&vam->json_tree);
5132 vat_json_init_object (node);
5133 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5134 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5137 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler
5138 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
5140 vat_main_t *vam = &vat_main;
5141 i32 retval = ntohl (mp->retval);
5142 if (vam->async_mode)
5144 vam->async_errors += (retval < 0);
5148 vam->retval = retval;
5149 vam->sw_if_index = ntohl (mp->sw_if_index);
5150 vam->result_ready = 1;
5154 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler_json
5155 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
5157 vat_main_t *vam = &vat_main;
5158 vat_json_node_t node;
5160 vat_json_init_object (&node);
5161 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
5162 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
5164 vat_json_print (vam->ofp, &node);
5165 vat_json_free (&node);
5167 vam->retval = ntohl (mp->retval);
5168 vam->result_ready = 1;
5171 static void vl_api_flow_classify_details_t_handler
5172 (vl_api_flow_classify_details_t * mp)
5174 vat_main_t *vam = &vat_main;
5176 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
5177 ntohl (mp->table_index));
5180 static void vl_api_flow_classify_details_t_handler_json
5181 (vl_api_flow_classify_details_t * mp)
5183 vat_main_t *vam = &vat_main;
5184 vat_json_node_t *node;
5186 if (VAT_JSON_ARRAY != vam->json_tree.type)
5188 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
5189 vat_json_init_array (&vam->json_tree);
5191 node = vat_json_array_add (&vam->json_tree);
5193 vat_json_init_object (node);
5194 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
5195 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
5198 #define vl_api_vnet_interface_simple_counters_t_endian vl_noop_handler
5199 #define vl_api_vnet_interface_simple_counters_t_print vl_noop_handler
5200 #define vl_api_vnet_interface_combined_counters_t_endian vl_noop_handler
5201 #define vl_api_vnet_interface_combined_counters_t_print vl_noop_handler
5202 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
5203 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
5204 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
5205 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
5206 #define vl_api_vnet_ip4_nbr_counters_t_endian vl_noop_handler
5207 #define vl_api_vnet_ip4_nbr_counters_t_print vl_noop_handler
5208 #define vl_api_vnet_ip6_nbr_counters_t_endian vl_noop_handler
5209 #define vl_api_vnet_ip6_nbr_counters_t_print vl_noop_handler
5210 #define vl_api_one_adjacencies_get_reply_t_endian vl_noop_handler
5211 #define vl_api_one_adjacencies_get_reply_t_print vl_noop_handler
5212 #define vl_api_one_l2_arp_bd_get_reply_t_print vl_noop_handler
5213 #define vl_api_one_l2_arp_entries_get_reply_t_endian vl_noop_handler
5214 #define vl_api_one_l2_arp_entries_get_reply_t_print vl_noop_handler
5215 #define vl_api_one_l2_arp_bd_get_reply_t_endian vl_noop_handler
5216 #define vl_api_one_ndp_bd_get_reply_t_endian vl_noop_handler
5217 #define vl_api_one_ndp_bd_get_reply_t_print vl_noop_handler
5218 #define vl_api_one_ndp_entries_get_reply_t_print vl_noop_handler
5219 #define vl_api_one_ndp_entries_get_reply_t_endian vl_noop_handler
5222 * Generate boilerplate reply handlers, which
5223 * dig the return value out of the xxx_reply_t API message,
5224 * stick it into vam->retval, and set vam->result_ready
5226 * Could also do this by pointing N message decode slots at
5227 * a single function, but that could break in subtle ways.
5230 #define foreach_standard_reply_retval_handler \
5231 _(sw_interface_set_flags_reply) \
5232 _(sw_interface_add_del_address_reply) \
5233 _(sw_interface_set_rx_mode_reply) \
5234 _(sw_interface_set_table_reply) \
5235 _(sw_interface_set_mpls_enable_reply) \
5236 _(sw_interface_set_vpath_reply) \
5237 _(sw_interface_set_vxlan_bypass_reply) \
5238 _(sw_interface_set_geneve_bypass_reply) \
5239 _(sw_interface_set_vxlan_gpe_bypass_reply) \
5240 _(sw_interface_set_l2_bridge_reply) \
5241 _(bridge_domain_add_del_reply) \
5242 _(sw_interface_set_l2_xconnect_reply) \
5243 _(l2fib_add_del_reply) \
5244 _(l2fib_flush_int_reply) \
5245 _(l2fib_flush_bd_reply) \
5246 _(ip_add_del_route_reply) \
5247 _(ip_table_add_del_reply) \
5248 _(ip_mroute_add_del_reply) \
5249 _(mpls_route_add_del_reply) \
5250 _(mpls_table_add_del_reply) \
5251 _(mpls_ip_bind_unbind_reply) \
5252 _(bier_route_add_del_reply) \
5253 _(bier_table_add_del_reply) \
5254 _(proxy_arp_add_del_reply) \
5255 _(proxy_arp_intfc_enable_disable_reply) \
5256 _(sw_interface_set_unnumbered_reply) \
5257 _(ip_neighbor_add_del_reply) \
5258 _(oam_add_del_reply) \
5259 _(reset_fib_reply) \
5260 _(dhcp_proxy_config_reply) \
5261 _(dhcp_proxy_set_vss_reply) \
5262 _(dhcp_client_config_reply) \
5263 _(set_ip_flow_hash_reply) \
5264 _(sw_interface_ip6_enable_disable_reply) \
5265 _(sw_interface_ip6_set_link_local_address_reply) \
5266 _(ip6nd_proxy_add_del_reply) \
5267 _(sw_interface_ip6nd_ra_prefix_reply) \
5268 _(sw_interface_ip6nd_ra_config_reply) \
5269 _(set_arp_neighbor_limit_reply) \
5270 _(l2_patch_add_del_reply) \
5271 _(sr_policy_add_reply) \
5272 _(sr_policy_mod_reply) \
5273 _(sr_policy_del_reply) \
5274 _(sr_localsid_add_del_reply) \
5275 _(sr_steering_add_del_reply) \
5276 _(classify_add_del_session_reply) \
5277 _(classify_set_interface_ip_table_reply) \
5278 _(classify_set_interface_l2_tables_reply) \
5279 _(l2tpv3_set_tunnel_cookies_reply) \
5280 _(l2tpv3_interface_enable_disable_reply) \
5281 _(l2tpv3_set_lookup_key_reply) \
5282 _(l2_fib_clear_table_reply) \
5283 _(l2_interface_efp_filter_reply) \
5284 _(l2_interface_vlan_tag_rewrite_reply) \
5285 _(modify_vhost_user_if_reply) \
5286 _(delete_vhost_user_if_reply) \
5287 _(want_ip4_arp_events_reply) \
5288 _(want_ip6_nd_events_reply) \
5289 _(want_l2_macs_events_reply) \
5290 _(input_acl_set_interface_reply) \
5291 _(ipsec_spd_add_del_reply) \
5292 _(ipsec_interface_add_del_spd_reply) \
5293 _(ipsec_spd_add_del_entry_reply) \
5294 _(ipsec_sad_add_del_entry_reply) \
5295 _(ipsec_sa_set_key_reply) \
5296 _(ipsec_tunnel_if_add_del_reply) \
5297 _(ipsec_tunnel_if_set_key_reply) \
5298 _(ipsec_tunnel_if_set_sa_reply) \
5299 _(ikev2_profile_add_del_reply) \
5300 _(ikev2_profile_set_auth_reply) \
5301 _(ikev2_profile_set_id_reply) \
5302 _(ikev2_profile_set_ts_reply) \
5303 _(ikev2_set_local_key_reply) \
5304 _(ikev2_set_responder_reply) \
5305 _(ikev2_set_ike_transforms_reply) \
5306 _(ikev2_set_esp_transforms_reply) \
5307 _(ikev2_set_sa_lifetime_reply) \
5308 _(ikev2_initiate_sa_init_reply) \
5309 _(ikev2_initiate_del_ike_sa_reply) \
5310 _(ikev2_initiate_del_child_sa_reply) \
5311 _(ikev2_initiate_rekey_child_sa_reply) \
5312 _(delete_loopback_reply) \
5313 _(bd_ip_mac_add_del_reply) \
5314 _(map_del_domain_reply) \
5315 _(map_add_del_rule_reply) \
5316 _(want_interface_events_reply) \
5317 _(want_stats_reply) \
5318 _(cop_interface_enable_disable_reply) \
5319 _(cop_whitelist_enable_disable_reply) \
5320 _(sw_interface_clear_stats_reply) \
5321 _(ioam_enable_reply) \
5322 _(ioam_disable_reply) \
5323 _(one_add_del_locator_reply) \
5324 _(one_add_del_local_eid_reply) \
5325 _(one_add_del_remote_mapping_reply) \
5326 _(one_add_del_adjacency_reply) \
5327 _(one_add_del_map_resolver_reply) \
5328 _(one_add_del_map_server_reply) \
5329 _(one_enable_disable_reply) \
5330 _(one_rloc_probe_enable_disable_reply) \
5331 _(one_map_register_enable_disable_reply) \
5332 _(one_map_register_set_ttl_reply) \
5333 _(one_set_transport_protocol_reply) \
5334 _(one_map_register_fallback_threshold_reply) \
5335 _(one_pitr_set_locator_set_reply) \
5336 _(one_map_request_mode_reply) \
5337 _(one_add_del_map_request_itr_rlocs_reply) \
5338 _(one_eid_table_add_del_map_reply) \
5339 _(one_use_petr_reply) \
5340 _(one_stats_enable_disable_reply) \
5341 _(one_add_del_l2_arp_entry_reply) \
5342 _(one_add_del_ndp_entry_reply) \
5343 _(one_stats_flush_reply) \
5344 _(one_enable_disable_xtr_mode_reply) \
5345 _(one_enable_disable_pitr_mode_reply) \
5346 _(one_enable_disable_petr_mode_reply) \
5347 _(gpe_enable_disable_reply) \
5348 _(gpe_set_encap_mode_reply) \
5349 _(gpe_add_del_iface_reply) \
5350 _(gpe_add_del_native_fwd_rpath_reply) \
5351 _(af_packet_delete_reply) \
5352 _(policer_classify_set_interface_reply) \
5353 _(netmap_create_reply) \
5354 _(netmap_delete_reply) \
5355 _(set_ipfix_exporter_reply) \
5356 _(set_ipfix_classify_stream_reply) \
5357 _(ipfix_classify_table_add_del_reply) \
5358 _(flow_classify_set_interface_reply) \
5359 _(sw_interface_span_enable_disable_reply) \
5360 _(pg_capture_reply) \
5361 _(pg_enable_disable_reply) \
5362 _(ip_source_and_port_range_check_add_del_reply) \
5363 _(ip_source_and_port_range_check_interface_add_del_reply)\
5364 _(delete_subif_reply) \
5365 _(l2_interface_pbb_tag_rewrite_reply) \
5367 _(feature_enable_disable_reply) \
5368 _(sw_interface_tag_add_del_reply) \
5369 _(sw_interface_set_mtu_reply) \
5370 _(p2p_ethernet_add_reply) \
5371 _(p2p_ethernet_del_reply) \
5372 _(lldp_config_reply) \
5373 _(sw_interface_set_lldp_reply) \
5374 _(tcp_configure_src_addresses_reply) \
5375 _(dns_enable_disable_reply) \
5376 _(dns_name_server_add_del_reply) \
5377 _(session_rule_add_del_reply) \
5378 _(ip_container_proxy_add_del_reply)
5381 static void vl_api_##n##_t_handler \
5382 (vl_api_##n##_t * mp) \
5384 vat_main_t * vam = &vat_main; \
5385 i32 retval = ntohl(mp->retval); \
5386 if (vam->async_mode) { \
5387 vam->async_errors += (retval < 0); \
5389 vam->retval = retval; \
5390 vam->result_ready = 1; \
5393 foreach_standard_reply_retval_handler;
5397 static void vl_api_##n##_t_handler_json \
5398 (vl_api_##n##_t * mp) \
5400 vat_main_t * vam = &vat_main; \
5401 vat_json_node_t node; \
5402 vat_json_init_object(&node); \
5403 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
5404 vat_json_print(vam->ofp, &node); \
5405 vam->retval = ntohl(mp->retval); \
5406 vam->result_ready = 1; \
5408 foreach_standard_reply_retval_handler;
5412 * Table of message reply handlers, must include boilerplate handlers
5416 #define foreach_vpe_api_reply_msg \
5417 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
5418 _(CREATE_LOOPBACK_INSTANCE_REPLY, create_loopback_instance_reply) \
5419 _(SW_INTERFACE_DETAILS, sw_interface_details) \
5420 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
5421 _(CONTROL_PING_REPLY, control_ping_reply) \
5422 _(CLI_REPLY, cli_reply) \
5423 _(CLI_INBAND_REPLY, cli_inband_reply) \
5424 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
5425 sw_interface_add_del_address_reply) \
5426 _(SW_INTERFACE_SET_RX_MODE_REPLY, sw_interface_set_rx_mode_reply) \
5427 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
5428 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
5429 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
5430 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
5431 _(SW_INTERFACE_SET_GENEVE_BYPASS_REPLY, sw_interface_set_geneve_bypass_reply) \
5432 _(SW_INTERFACE_SET_VXLAN_GPE_BYPASS_REPLY, sw_interface_set_vxlan_gpe_bypass_reply) \
5433 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
5434 sw_interface_set_l2_xconnect_reply) \
5435 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
5436 sw_interface_set_l2_bridge_reply) \
5437 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
5438 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
5439 _(BRIDGE_DOMAIN_SET_MAC_AGE_REPLY, bridge_domain_set_mac_age_reply) \
5440 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
5441 _(L2FIB_FLUSH_INT_REPLY, l2fib_flush_int_reply) \
5442 _(L2FIB_FLUSH_BD_REPLY, l2fib_flush_bd_reply) \
5443 _(L2_FLAGS_REPLY, l2_flags_reply) \
5444 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
5445 _(TAP_CONNECT_REPLY, tap_connect_reply) \
5446 _(TAP_MODIFY_REPLY, tap_modify_reply) \
5447 _(TAP_DELETE_REPLY, tap_delete_reply) \
5448 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
5449 _(TAP_CREATE_V2_REPLY, tap_create_v2_reply) \
5450 _(TAP_DELETE_V2_REPLY, tap_delete_v2_reply) \
5451 _(SW_INTERFACE_TAP_V2_DETAILS, sw_interface_tap_v2_details) \
5452 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
5453 _(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
5454 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
5455 _(MPLS_TABLE_ADD_DEL_REPLY, mpls_table_add_del_reply) \
5456 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
5457 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
5458 _(BIER_ROUTE_ADD_DEL_REPLY, bier_route_add_del_reply) \
5459 _(BIER_TABLE_ADD_DEL_REPLY, bier_table_add_del_reply) \
5460 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
5461 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
5462 proxy_arp_intfc_enable_disable_reply) \
5463 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
5464 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
5465 sw_interface_set_unnumbered_reply) \
5466 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
5467 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
5468 _(CREATE_SUBIF_REPLY, create_subif_reply) \
5469 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
5470 _(RESET_FIB_REPLY, reset_fib_reply) \
5471 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
5472 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
5473 _(DHCP_PROXY_DETAILS, dhcp_proxy_details) \
5474 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
5475 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
5476 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
5477 sw_interface_ip6_enable_disable_reply) \
5478 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
5479 sw_interface_ip6_set_link_local_address_reply) \
5480 _(IP6ND_PROXY_ADD_DEL_REPLY, ip6nd_proxy_add_del_reply) \
5481 _(IP6ND_PROXY_DETAILS, ip6nd_proxy_details) \
5482 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
5483 sw_interface_ip6nd_ra_prefix_reply) \
5484 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
5485 sw_interface_ip6nd_ra_config_reply) \
5486 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
5487 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
5488 _(SR_POLICY_ADD_REPLY, sr_policy_add_reply) \
5489 _(SR_POLICY_MOD_REPLY, sr_policy_mod_reply) \
5490 _(SR_POLICY_DEL_REPLY, sr_policy_del_reply) \
5491 _(SR_LOCALSID_ADD_DEL_REPLY, sr_localsid_add_del_reply) \
5492 _(SR_STEERING_ADD_DEL_REPLY, sr_steering_add_del_reply) \
5493 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
5494 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
5495 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
5496 classify_set_interface_ip_table_reply) \
5497 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
5498 classify_set_interface_l2_tables_reply) \
5499 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
5500 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
5501 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
5502 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
5503 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
5504 l2tpv3_interface_enable_disable_reply) \
5505 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
5506 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
5507 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
5508 _(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
5509 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
5510 _(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
5511 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
5512 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
5513 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
5514 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
5515 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
5516 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
5517 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
5518 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
5519 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
5520 _(SHOW_VERSION_REPLY, show_version_reply) \
5521 _(L2_FIB_TABLE_DETAILS, l2_fib_table_details) \
5522 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
5523 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
5524 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
5525 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
5526 _(IP4_ARP_EVENT, ip4_arp_event) \
5527 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
5528 _(IP6_ND_EVENT, ip6_nd_event) \
5529 _(WANT_L2_MACS_EVENTS_REPLY, want_l2_macs_events_reply) \
5530 _(L2_MACS_EVENT, l2_macs_event) \
5531 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
5532 _(IP_ADDRESS_DETAILS, ip_address_details) \
5533 _(IP_DETAILS, ip_details) \
5534 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
5535 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
5536 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
5537 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
5538 _(IPSEC_SA_DETAILS, ipsec_sa_details) \
5539 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
5540 _(IPSEC_TUNNEL_IF_ADD_DEL_REPLY, ipsec_tunnel_if_add_del_reply) \
5541 _(IPSEC_TUNNEL_IF_SET_KEY_REPLY, ipsec_tunnel_if_set_key_reply) \
5542 _(IPSEC_TUNNEL_IF_SET_SA_REPLY, ipsec_tunnel_if_set_sa_reply) \
5543 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
5544 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
5545 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
5546 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
5547 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
5548 _(IKEV2_SET_RESPONDER_REPLY, ikev2_set_responder_reply) \
5549 _(IKEV2_SET_IKE_TRANSFORMS_REPLY, ikev2_set_ike_transforms_reply) \
5550 _(IKEV2_SET_ESP_TRANSFORMS_REPLY, ikev2_set_esp_transforms_reply) \
5551 _(IKEV2_SET_SA_LIFETIME_REPLY, ikev2_set_sa_lifetime_reply) \
5552 _(IKEV2_INITIATE_SA_INIT_REPLY, ikev2_initiate_sa_init_reply) \
5553 _(IKEV2_INITIATE_DEL_IKE_SA_REPLY, ikev2_initiate_del_ike_sa_reply) \
5554 _(IKEV2_INITIATE_DEL_CHILD_SA_REPLY, ikev2_initiate_del_child_sa_reply) \
5555 _(IKEV2_INITIATE_REKEY_CHILD_SA_REPLY, ikev2_initiate_rekey_child_sa_reply) \
5556 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
5557 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
5558 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
5559 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
5560 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
5561 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
5562 _(MAP_DOMAIN_DETAILS, map_domain_details) \
5563 _(MAP_RULE_DETAILS, map_rule_details) \
5564 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
5565 _(WANT_STATS_REPLY, want_stats_reply) \
5566 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
5567 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
5568 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
5569 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
5570 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
5571 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
5572 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
5573 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
5574 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
5575 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
5576 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
5577 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
5578 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
5579 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
5580 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
5581 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
5582 one_map_register_enable_disable_reply) \
5583 _(ONE_MAP_REGISTER_SET_TTL_REPLY, one_map_register_set_ttl_reply) \
5584 _(ONE_SET_TRANSPORT_PROTOCOL_REPLY, one_set_transport_protocol_reply) \
5585 _(ONE_GET_TRANSPORT_PROTOCOL_REPLY, one_get_transport_protocol_reply) \
5586 _(ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5587 one_map_register_fallback_threshold_reply) \
5588 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
5589 one_rloc_probe_enable_disable_reply) \
5590 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
5591 _(ONE_USE_PETR_REPLY, one_use_petr_reply) \
5592 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
5593 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
5594 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
5595 _(ONE_LOCATOR_DETAILS, one_locator_details) \
5596 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
5597 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
5598 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
5599 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
5600 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
5601 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
5602 _(ONE_STATS_DETAILS, one_stats_details) \
5603 _(ONE_STATS_FLUSH_REPLY, one_stats_flush_reply) \
5604 _(ONE_STATS_ENABLE_DISABLE_REPLY, one_stats_enable_disable_reply) \
5605 _(SHOW_ONE_STATS_ENABLE_DISABLE_REPLY, \
5606 show_one_stats_enable_disable_reply) \
5607 _(ONE_ADD_DEL_NDP_ENTRY_REPLY, one_add_del_ndp_entry_reply) \
5608 _(ONE_NDP_BD_GET_REPLY, one_ndp_bd_get_reply) \
5609 _(ONE_NDP_ENTRIES_GET_REPLY, one_ndp_entries_get_reply) \
5610 _(ONE_ADD_DEL_L2_ARP_ENTRY_REPLY, one_add_del_l2_arp_entry_reply) \
5611 _(ONE_L2_ARP_BD_GET_REPLY, one_l2_arp_bd_get_reply) \
5612 _(ONE_L2_ARP_ENTRIES_GET_REPLY, one_l2_arp_entries_get_reply) \
5613 _(ONE_ENABLE_DISABLE_XTR_MODE_REPLY, one_enable_disable_xtr_mode_reply) \
5614 _(ONE_ENABLE_DISABLE_PITR_MODE_REPLY, \
5615 one_enable_disable_pitr_mode_reply) \
5616 _(ONE_ENABLE_DISABLE_PETR_MODE_REPLY, \
5617 one_enable_disable_petr_mode_reply) \
5618 _(ONE_SHOW_XTR_MODE_REPLY, one_show_xtr_mode_reply) \
5619 _(ONE_SHOW_PITR_MODE_REPLY, one_show_pitr_mode_reply) \
5620 _(ONE_SHOW_PETR_MODE_REPLY, one_show_petr_mode_reply) \
5621 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
5622 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
5623 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
5624 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
5625 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
5626 _(GPE_FWD_ENTRY_VNIS_GET_REPLY, gpe_fwd_entry_vnis_get_reply) \
5627 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
5628 _(GPE_NATIVE_FWD_RPATHS_GET_REPLY, gpe_native_fwd_rpaths_get_reply) \
5629 _(GPE_ADD_DEL_NATIVE_FWD_RPATH_REPLY, \
5630 gpe_add_del_native_fwd_rpath_reply) \
5631 _(GPE_FWD_ENTRY_PATH_DETAILS, \
5632 gpe_fwd_entry_path_details) \
5633 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
5634 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
5635 one_add_del_map_request_itr_rlocs_reply) \
5636 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
5637 one_get_map_request_itr_rlocs_reply) \
5638 _(SHOW_ONE_NSH_MAPPING_REPLY, show_one_nsh_mapping_reply) \
5639 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
5640 _(SHOW_ONE_USE_PETR_REPLY, show_one_use_petr_reply) \
5641 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
5642 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
5643 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
5644 show_one_map_register_state_reply) \
5645 _(SHOW_ONE_MAP_REGISTER_TTL_REPLY, show_one_map_register_ttl_reply) \
5646 _(SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD_REPLY, \
5647 show_one_map_register_fallback_threshold_reply) \
5648 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
5649 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
5650 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
5651 _(POLICER_DETAILS, policer_details) \
5652 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
5653 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
5654 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
5655 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
5656 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
5657 _(MPLS_FIB_DETAILS, mpls_fib_details) \
5658 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
5659 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
5660 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
5661 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
5662 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
5663 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
5664 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
5665 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
5666 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
5667 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
5668 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
5669 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
5670 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
5671 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
5672 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
5673 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
5674 _(PG_CAPTURE_REPLY, pg_capture_reply) \
5675 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
5676 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
5677 ip_source_and_port_range_check_add_del_reply) \
5678 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
5679 ip_source_and_port_range_check_interface_add_del_reply) \
5680 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
5681 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
5682 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
5683 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
5684 _(PUNT_REPLY, punt_reply) \
5685 _(IP_FIB_DETAILS, ip_fib_details) \
5686 _(IP6_FIB_DETAILS, ip6_fib_details) \
5687 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
5688 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
5689 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
5690 _(SW_INTERFACE_SET_MTU_REPLY, sw_interface_set_mtu_reply) \
5691 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
5692 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply) \
5693 _(P2P_ETHERNET_ADD_REPLY, p2p_ethernet_add_reply) \
5694 _(P2P_ETHERNET_DEL_REPLY, p2p_ethernet_del_reply) \
5695 _(LLDP_CONFIG_REPLY, lldp_config_reply) \
5696 _(SW_INTERFACE_SET_LLDP_REPLY, sw_interface_set_lldp_reply) \
5697 _(TCP_CONFIGURE_SRC_ADDRESSES_REPLY, tcp_configure_src_addresses_reply) \
5698 _(APP_NAMESPACE_ADD_DEL_REPLY, app_namespace_add_del_reply) \
5699 _(DNS_ENABLE_DISABLE_REPLY, dns_enable_disable_reply) \
5700 _(DNS_NAME_SERVER_ADD_DEL_REPLY, dns_name_server_add_del_reply) \
5701 _(DNS_RESOLVE_NAME_REPLY, dns_resolve_name_reply) \
5702 _(DNS_RESOLVE_IP_REPLY, dns_resolve_ip_reply) \
5703 _(SESSION_RULE_ADD_DEL_REPLY, session_rule_add_del_reply) \
5704 _(SESSION_RULES_DETAILS, session_rules_details) \
5705 _(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
5707 #define foreach_standalone_reply_msg \
5708 _(SW_INTERFACE_EVENT, sw_interface_event) \
5709 _(VNET_INTERFACE_SIMPLE_COUNTERS, vnet_interface_simple_counters) \
5710 _(VNET_INTERFACE_COMBINED_COUNTERS, vnet_interface_combined_counters) \
5711 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
5712 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
5713 _(VNET_IP4_NBR_COUNTERS, vnet_ip4_nbr_counters) \
5714 _(VNET_IP6_NBR_COUNTERS, vnet_ip6_nbr_counters) \
5715 _(MEMFD_SEGMENT_CREATE_REPLY, memfd_segment_create_reply) \
5724 #define STR_VTR_OP_CASE(op) \
5725 case L2_VTR_ ## op: \
5729 str_vtr_op (u32 vtr_op)
5733 STR_VTR_OP_CASE (DISABLED);
5734 STR_VTR_OP_CASE (PUSH_1);
5735 STR_VTR_OP_CASE (PUSH_2);
5736 STR_VTR_OP_CASE (POP_1);
5737 STR_VTR_OP_CASE (POP_2);
5738 STR_VTR_OP_CASE (TRANSLATE_1_1);
5739 STR_VTR_OP_CASE (TRANSLATE_1_2);
5740 STR_VTR_OP_CASE (TRANSLATE_2_1);
5741 STR_VTR_OP_CASE (TRANSLATE_2_2);
5748 dump_sub_interface_table (vat_main_t * vam)
5750 const sw_interface_subif_t *sub = NULL;
5752 if (vam->json_output)
5755 ("JSON output supported only for VPE API calls and dump_stats_table");
5760 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
5761 "Interface", "sw_if_index",
5762 "sub id", "dot1ad", "tags", "outer id",
5763 "inner id", "exact", "default", "outer any", "inner any");
5765 vec_foreach (sub, vam->sw_if_subif_table)
5768 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
5769 sub->interface_name,
5771 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
5772 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
5773 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
5774 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
5775 if (sub->vtr_op != L2_VTR_DISABLED)
5778 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
5779 "tag1: %d tag2: %d ]",
5780 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
5781 sub->vtr_tag1, sub->vtr_tag2);
5789 name_sort_cmp (void *a1, void *a2)
5791 name_sort_t *n1 = a1;
5792 name_sort_t *n2 = a2;
5794 return strcmp ((char *) n1->name, (char *) n2->name);
5798 dump_interface_table (vat_main_t * vam)
5801 name_sort_t *nses = 0, *ns;
5803 if (vam->json_output)
5806 ("JSON output supported only for VPE API calls and dump_stats_table");
5811 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
5813 vec_add2 (nses, ns, 1);
5814 ns->name = (u8 *)(p->key);
5815 ns->value = (u32) p->value[0];
5819 vec_sort_with_function (nses, name_sort_cmp);
5821 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
5822 vec_foreach (ns, nses)
5824 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
5831 dump_ip_table (vat_main_t * vam, int is_ipv6)
5833 const ip_details_t *det = NULL;
5834 const ip_address_details_t *address = NULL;
5837 print (vam->ofp, "%-12s", "sw_if_index");
5839 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
5846 print (vam->ofp, "%-12d", i);
5847 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
5852 vec_foreach (address, det->addr)
5856 is_ipv6 ? format_ip6_address : format_ip4_address,
5857 address->ip, address->prefix_length);
5865 dump_ipv4_table (vat_main_t * vam)
5867 if (vam->json_output)
5870 ("JSON output supported only for VPE API calls and dump_stats_table");
5874 return dump_ip_table (vam, 0);
5878 dump_ipv6_table (vat_main_t * vam)
5880 if (vam->json_output)
5883 ("JSON output supported only for VPE API calls and dump_stats_table");
5887 return dump_ip_table (vam, 1);
5891 counter_type_to_str (u8 counter_type, u8 is_combined)
5895 switch (counter_type)
5897 case VNET_INTERFACE_COUNTER_DROP:
5899 case VNET_INTERFACE_COUNTER_PUNT:
5901 case VNET_INTERFACE_COUNTER_IP4:
5903 case VNET_INTERFACE_COUNTER_IP6:
5905 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
5907 case VNET_INTERFACE_COUNTER_RX_MISS:
5909 case VNET_INTERFACE_COUNTER_RX_ERROR:
5911 case VNET_INTERFACE_COUNTER_TX_ERROR:
5914 return "INVALID-COUNTER-TYPE";
5919 switch (counter_type)
5921 case VNET_INTERFACE_COUNTER_RX:
5923 case VNET_INTERFACE_COUNTER_TX:
5926 return "INVALID-COUNTER-TYPE";
5932 dump_stats_table (vat_main_t * vam)
5934 vat_json_node_t node;
5935 vat_json_node_t *msg_array;
5936 vat_json_node_t *msg;
5937 vat_json_node_t *counter_array;
5938 vat_json_node_t *counter;
5939 interface_counter_t c;
5941 ip4_fib_counter_t *c4;
5942 ip6_fib_counter_t *c6;
5943 ip4_nbr_counter_t *n4;
5944 ip6_nbr_counter_t *n6;
5947 if (!vam->json_output)
5949 clib_warning ("dump_stats_table supported only in JSON format");
5953 vat_json_init_object (&node);
5955 /* interface counters */
5956 msg_array = vat_json_object_add (&node, "interface_counters");
5957 vat_json_init_array (msg_array);
5958 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
5960 msg = vat_json_array_add (msg_array);
5961 vat_json_init_object (msg);
5962 vat_json_object_add_string_copy (msg, "vnet_counter_type",
5963 (u8 *) counter_type_to_str (i, 0));
5964 vat_json_object_add_int (msg, "is_combined", 0);
5965 counter_array = vat_json_object_add (msg, "data");
5966 vat_json_init_array (counter_array);
5967 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
5969 packets = vam->simple_interface_counters[i][j];
5970 vat_json_array_add_uint (counter_array, packets);
5973 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
5975 msg = vat_json_array_add (msg_array);
5976 vat_json_init_object (msg);
5977 vat_json_object_add_string_copy (msg, "vnet_counter_type",
5978 (u8 *) counter_type_to_str (i, 1));
5979 vat_json_object_add_int (msg, "is_combined", 1);
5980 counter_array = vat_json_object_add (msg, "data");
5981 vat_json_init_array (counter_array);
5982 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
5984 c = vam->combined_interface_counters[i][j];
5985 counter = vat_json_array_add (counter_array);
5986 vat_json_init_object (counter);
5987 vat_json_object_add_uint (counter, "packets", c.packets);
5988 vat_json_object_add_uint (counter, "bytes", c.bytes);
5992 /* ip4 fib counters */
5993 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
5994 vat_json_init_array (msg_array);
5995 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
5997 msg = vat_json_array_add (msg_array);
5998 vat_json_init_object (msg);
5999 vat_json_object_add_uint (msg, "vrf_id",
6000 vam->ip4_fib_counters_vrf_id_by_index[i]);
6001 counter_array = vat_json_object_add (msg, "c");
6002 vat_json_init_array (counter_array);
6003 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
6005 counter = vat_json_array_add (counter_array);
6006 vat_json_init_object (counter);
6007 c4 = &vam->ip4_fib_counters[i][j];
6008 vat_json_object_add_ip4 (counter, "address", c4->address);
6009 vat_json_object_add_uint (counter, "address_length",
6010 c4->address_length);
6011 vat_json_object_add_uint (counter, "packets", c4->packets);
6012 vat_json_object_add_uint (counter, "bytes", c4->bytes);
6016 /* ip6 fib counters */
6017 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
6018 vat_json_init_array (msg_array);
6019 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
6021 msg = vat_json_array_add (msg_array);
6022 vat_json_init_object (msg);
6023 vat_json_object_add_uint (msg, "vrf_id",
6024 vam->ip6_fib_counters_vrf_id_by_index[i]);
6025 counter_array = vat_json_object_add (msg, "c");
6026 vat_json_init_array (counter_array);
6027 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
6029 counter = vat_json_array_add (counter_array);
6030 vat_json_init_object (counter);
6031 c6 = &vam->ip6_fib_counters[i][j];
6032 vat_json_object_add_ip6 (counter, "address", c6->address);
6033 vat_json_object_add_uint (counter, "address_length",
6034 c6->address_length);
6035 vat_json_object_add_uint (counter, "packets", c6->packets);
6036 vat_json_object_add_uint (counter, "bytes", c6->bytes);
6040 /* ip4 nbr counters */
6041 msg_array = vat_json_object_add (&node, "ip4_nbr_counters");
6042 vat_json_init_array (msg_array);
6043 for (i = 0; i < vec_len (vam->ip4_nbr_counters); i++)
6045 msg = vat_json_array_add (msg_array);
6046 vat_json_init_object (msg);
6047 vat_json_object_add_uint (msg, "sw_if_index", i);
6048 counter_array = vat_json_object_add (msg, "c");
6049 vat_json_init_array (counter_array);
6050 for (j = 0; j < vec_len (vam->ip4_nbr_counters[i]); j++)
6052 counter = vat_json_array_add (counter_array);
6053 vat_json_init_object (counter);
6054 n4 = &vam->ip4_nbr_counters[i][j];
6055 vat_json_object_add_ip4 (counter, "address", n4->address);
6056 vat_json_object_add_uint (counter, "link-type", n4->linkt);
6057 vat_json_object_add_uint (counter, "packets", n4->packets);
6058 vat_json_object_add_uint (counter, "bytes", n4->bytes);
6062 /* ip6 nbr counters */
6063 msg_array = vat_json_object_add (&node, "ip6_nbr_counters");
6064 vat_json_init_array (msg_array);
6065 for (i = 0; i < vec_len (vam->ip6_nbr_counters); i++)
6067 msg = vat_json_array_add (msg_array);
6068 vat_json_init_object (msg);
6069 vat_json_object_add_uint (msg, "sw_if_index", i);
6070 counter_array = vat_json_object_add (msg, "c");
6071 vat_json_init_array (counter_array);
6072 for (j = 0; j < vec_len (vam->ip6_nbr_counters[i]); j++)
6074 counter = vat_json_array_add (counter_array);
6075 vat_json_init_object (counter);
6076 n6 = &vam->ip6_nbr_counters[i][j];
6077 vat_json_object_add_ip6 (counter, "address", n6->address);
6078 vat_json_object_add_uint (counter, "packets", n6->packets);
6079 vat_json_object_add_uint (counter, "bytes", n6->bytes);
6083 vat_json_print (vam->ofp, &node);
6084 vat_json_free (&node);
6090 * Pass CLI buffers directly in the CLI_INBAND API message,
6091 * instead of an additional shared memory area.
6094 exec_inband (vat_main_t * vam)
6096 vl_api_cli_inband_t *mp;
6097 unformat_input_t *i = vam->input;
6100 if (vec_len (i->buffer) == 0)
6103 if (vam->exec_mode == 0 && unformat (i, "mode"))
6108 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
6115 * In order for the CLI command to work, it
6116 * must be a vector ending in \n, not a C-string ending
6119 u32 len = vec_len (vam->input->buffer);
6120 M2 (CLI_INBAND, mp, len);
6121 clib_memcpy (mp->cmd, vam->input->buffer, len);
6122 mp->length = htonl (len);
6126 /* json responses may or may not include a useful reply... */
6127 if (vec_len (vam->cmd_reply))
6128 print (vam->ofp, "%v", (char *) (vam->cmd_reply));
6133 exec (vat_main_t * vam)
6135 return exec_inband (vam);
6139 api_create_loopback (vat_main_t * vam)
6141 unformat_input_t *i = vam->input;
6142 vl_api_create_loopback_t *mp;
6143 vl_api_create_loopback_instance_t *mp_lbi;
6146 u8 is_specified = 0;
6147 u32 user_instance = 0;
6150 memset (mac_address, 0, sizeof (mac_address));
6152 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6154 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6156 if (unformat (i, "instance %d", &user_instance))
6164 M (CREATE_LOOPBACK_INSTANCE, mp_lbi);
6165 mp_lbi->is_specified = is_specified;
6167 mp_lbi->user_instance = htonl (user_instance);
6169 clib_memcpy (mp_lbi->mac_address, mac_address, sizeof (mac_address));
6174 /* Construct the API message */
6175 M (CREATE_LOOPBACK, mp);
6177 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
6186 api_delete_loopback (vat_main_t * vam)
6188 unformat_input_t *i = vam->input;
6189 vl_api_delete_loopback_t *mp;
6190 u32 sw_if_index = ~0;
6193 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6195 if (unformat (i, "sw_if_index %d", &sw_if_index))
6201 if (sw_if_index == ~0)
6203 errmsg ("missing sw_if_index");
6207 /* Construct the API message */
6208 M (DELETE_LOOPBACK, mp);
6209 mp->sw_if_index = ntohl (sw_if_index);
6217 api_want_stats (vat_main_t * vam)
6219 unformat_input_t *i = vam->input;
6220 vl_api_want_stats_t *mp;
6224 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6226 if (unformat (i, "enable"))
6228 else if (unformat (i, "disable"))
6236 errmsg ("missing enable|disable");
6241 mp->enable_disable = enable;
6249 api_want_interface_events (vat_main_t * vam)
6251 unformat_input_t *i = vam->input;
6252 vl_api_want_interface_events_t *mp;
6256 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6258 if (unformat (i, "enable"))
6260 else if (unformat (i, "disable"))
6268 errmsg ("missing enable|disable");
6272 M (WANT_INTERFACE_EVENTS, mp);
6273 mp->enable_disable = enable;
6275 vam->interface_event_display = enable;
6283 /* Note: non-static, called once to set up the initial intfc table */
6285 api_sw_interface_dump (vat_main_t * vam)
6287 vl_api_sw_interface_dump_t *mp;
6288 vl_api_control_ping_t *mp_ping;
6290 name_sort_t *nses = 0, *ns;
6291 sw_interface_subif_t *sub = NULL;
6294 /* Toss the old name table */
6296 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
6298 vec_add2 (nses, ns, 1);
6299 ns->name = (u8 *)(p->key);
6300 ns->value = (u32) p->value[0];
6304 hash_free (vam->sw_if_index_by_interface_name);
6306 vec_foreach (ns, nses) vec_free (ns->name);
6310 vec_foreach (sub, vam->sw_if_subif_table)
6312 vec_free (sub->interface_name);
6314 vec_free (vam->sw_if_subif_table);
6316 /* recreate the interface name hash table */
6317 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
6319 /* Get list of ethernets */
6320 M (SW_INTERFACE_DUMP, mp);
6321 mp->name_filter_valid = 1;
6322 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
6325 /* and local / loopback interfaces */
6326 M (SW_INTERFACE_DUMP, mp);
6327 mp->name_filter_valid = 1;
6328 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
6331 /* and packet-generator interfaces */
6332 M (SW_INTERFACE_DUMP, mp);
6333 mp->name_filter_valid = 1;
6334 strncpy ((char *) mp->name_filter, "pg", sizeof (mp->name_filter) - 1);
6337 /* and vxlan-gpe tunnel interfaces */
6338 M (SW_INTERFACE_DUMP, mp);
6339 mp->name_filter_valid = 1;
6340 strncpy ((char *) mp->name_filter, "vxlan_gpe",
6341 sizeof (mp->name_filter) - 1);
6344 /* and vxlan tunnel interfaces */
6345 M (SW_INTERFACE_DUMP, mp);
6346 mp->name_filter_valid = 1;
6347 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
6350 /* and geneve tunnel interfaces */
6351 M (SW_INTERFACE_DUMP, mp);
6352 mp->name_filter_valid = 1;
6353 strncpy ((char *) mp->name_filter, "geneve", sizeof (mp->name_filter) - 1);
6356 /* and host (af_packet) interfaces */
6357 M (SW_INTERFACE_DUMP, mp);
6358 mp->name_filter_valid = 1;
6359 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
6362 /* and l2tpv3 tunnel interfaces */
6363 M (SW_INTERFACE_DUMP, mp);
6364 mp->name_filter_valid = 1;
6365 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
6366 sizeof (mp->name_filter) - 1);
6369 /* and GRE tunnel interfaces */
6370 M (SW_INTERFACE_DUMP, mp);
6371 mp->name_filter_valid = 1;
6372 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
6375 /* and LISP-GPE interfaces */
6376 M (SW_INTERFACE_DUMP, mp);
6377 mp->name_filter_valid = 1;
6378 strncpy ((char *) mp->name_filter, "lisp_gpe",
6379 sizeof (mp->name_filter) - 1);
6382 /* and IPSEC tunnel interfaces */
6383 M (SW_INTERFACE_DUMP, mp);
6384 mp->name_filter_valid = 1;
6385 strncpy ((char *) mp->name_filter, "ipsec", sizeof (mp->name_filter) - 1);
6388 /* Use a control ping for synchronization */
6389 MPING (CONTROL_PING, mp_ping);
6397 api_sw_interface_set_flags (vat_main_t * vam)
6399 unformat_input_t *i = vam->input;
6400 vl_api_sw_interface_set_flags_t *mp;
6402 u8 sw_if_index_set = 0;
6406 /* Parse args required to build the message */
6407 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6409 if (unformat (i, "admin-up"))
6411 else if (unformat (i, "admin-down"))
6414 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6415 sw_if_index_set = 1;
6416 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6417 sw_if_index_set = 1;
6422 if (sw_if_index_set == 0)
6424 errmsg ("missing interface name or sw_if_index");
6428 /* Construct the API message */
6429 M (SW_INTERFACE_SET_FLAGS, mp);
6430 mp->sw_if_index = ntohl (sw_if_index);
6431 mp->admin_up_down = admin_up;
6436 /* Wait for a reply, return the good/bad news... */
6442 api_sw_interface_set_rx_mode (vat_main_t * vam)
6444 unformat_input_t *i = vam->input;
6445 vl_api_sw_interface_set_rx_mode_t *mp;
6447 u8 sw_if_index_set = 0;
6449 u8 queue_id_valid = 0;
6451 vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN;
6453 /* Parse args required to build the message */
6454 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6456 if (unformat (i, "queue %d", &queue_id))
6458 else if (unformat (i, "polling"))
6459 mode = VNET_HW_INTERFACE_RX_MODE_POLLING;
6460 else if (unformat (i, "interrupt"))
6461 mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT;
6462 else if (unformat (i, "adaptive"))
6463 mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE;
6465 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6466 sw_if_index_set = 1;
6467 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6468 sw_if_index_set = 1;
6473 if (sw_if_index_set == 0)
6475 errmsg ("missing interface name or sw_if_index");
6478 if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN)
6480 errmsg ("missing rx-mode");
6484 /* Construct the API message */
6485 M (SW_INTERFACE_SET_RX_MODE, mp);
6486 mp->sw_if_index = ntohl (sw_if_index);
6488 mp->queue_id_valid = queue_id_valid;
6489 mp->queue_id = queue_id_valid ? ntohl (queue_id) : ~0;
6494 /* Wait for a reply, return the good/bad news... */
6500 api_sw_interface_clear_stats (vat_main_t * vam)
6502 unformat_input_t *i = vam->input;
6503 vl_api_sw_interface_clear_stats_t *mp;
6505 u8 sw_if_index_set = 0;
6508 /* Parse args required to build the message */
6509 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6511 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6512 sw_if_index_set = 1;
6513 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6514 sw_if_index_set = 1;
6519 /* Construct the API message */
6520 M (SW_INTERFACE_CLEAR_STATS, mp);
6522 if (sw_if_index_set == 1)
6523 mp->sw_if_index = ntohl (sw_if_index);
6525 mp->sw_if_index = ~0;
6530 /* Wait for a reply, return the good/bad news... */
6536 api_sw_interface_add_del_address (vat_main_t * vam)
6538 unformat_input_t *i = vam->input;
6539 vl_api_sw_interface_add_del_address_t *mp;
6541 u8 sw_if_index_set = 0;
6542 u8 is_add = 1, del_all = 0;
6543 u32 address_length = 0;
6544 u8 v4_address_set = 0;
6545 u8 v6_address_set = 0;
6546 ip4_address_t v4address;
6547 ip6_address_t v6address;
6550 /* Parse args required to build the message */
6551 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6553 if (unformat (i, "del-all"))
6555 else if (unformat (i, "del"))
6558 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6559 sw_if_index_set = 1;
6560 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6561 sw_if_index_set = 1;
6562 else if (unformat (i, "%U/%d",
6563 unformat_ip4_address, &v4address, &address_length))
6565 else if (unformat (i, "%U/%d",
6566 unformat_ip6_address, &v6address, &address_length))
6572 if (sw_if_index_set == 0)
6574 errmsg ("missing interface name or sw_if_index");
6577 if (v4_address_set && v6_address_set)
6579 errmsg ("both v4 and v6 addresses set");
6582 if (!v4_address_set && !v6_address_set && !del_all)
6584 errmsg ("no addresses set");
6588 /* Construct the API message */
6589 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
6591 mp->sw_if_index = ntohl (sw_if_index);
6592 mp->is_add = is_add;
6593 mp->del_all = del_all;
6597 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6601 clib_memcpy (mp->address, &v4address, sizeof (v4address));
6603 mp->address_length = address_length;
6608 /* Wait for a reply, return good/bad news */
6614 api_sw_interface_set_mpls_enable (vat_main_t * vam)
6616 unformat_input_t *i = vam->input;
6617 vl_api_sw_interface_set_mpls_enable_t *mp;
6619 u8 sw_if_index_set = 0;
6623 /* Parse args required to build the message */
6624 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6626 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6627 sw_if_index_set = 1;
6628 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6629 sw_if_index_set = 1;
6630 else if (unformat (i, "disable"))
6632 else if (unformat (i, "dis"))
6638 if (sw_if_index_set == 0)
6640 errmsg ("missing interface name or sw_if_index");
6644 /* Construct the API message */
6645 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
6647 mp->sw_if_index = ntohl (sw_if_index);
6648 mp->enable = enable;
6653 /* Wait for a reply... */
6659 api_sw_interface_set_table (vat_main_t * vam)
6661 unformat_input_t *i = vam->input;
6662 vl_api_sw_interface_set_table_t *mp;
6663 u32 sw_if_index, vrf_id = 0;
6664 u8 sw_if_index_set = 0;
6668 /* Parse args required to build the message */
6669 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6671 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6672 sw_if_index_set = 1;
6673 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6674 sw_if_index_set = 1;
6675 else if (unformat (i, "vrf %d", &vrf_id))
6677 else if (unformat (i, "ipv6"))
6683 if (sw_if_index_set == 0)
6685 errmsg ("missing interface name or sw_if_index");
6689 /* Construct the API message */
6690 M (SW_INTERFACE_SET_TABLE, mp);
6692 mp->sw_if_index = ntohl (sw_if_index);
6693 mp->is_ipv6 = is_ipv6;
6694 mp->vrf_id = ntohl (vrf_id);
6699 /* Wait for a reply... */
6704 static void vl_api_sw_interface_get_table_reply_t_handler
6705 (vl_api_sw_interface_get_table_reply_t * mp)
6707 vat_main_t *vam = &vat_main;
6709 print (vam->ofp, "%d", ntohl (mp->vrf_id));
6711 vam->retval = ntohl (mp->retval);
6712 vam->result_ready = 1;
6716 static void vl_api_sw_interface_get_table_reply_t_handler_json
6717 (vl_api_sw_interface_get_table_reply_t * mp)
6719 vat_main_t *vam = &vat_main;
6720 vat_json_node_t node;
6722 vat_json_init_object (&node);
6723 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
6724 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
6726 vat_json_print (vam->ofp, &node);
6727 vat_json_free (&node);
6729 vam->retval = ntohl (mp->retval);
6730 vam->result_ready = 1;
6734 api_sw_interface_get_table (vat_main_t * vam)
6736 unformat_input_t *i = vam->input;
6737 vl_api_sw_interface_get_table_t *mp;
6739 u8 sw_if_index_set = 0;
6743 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6745 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6746 sw_if_index_set = 1;
6747 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6748 sw_if_index_set = 1;
6749 else if (unformat (i, "ipv6"))
6755 if (sw_if_index_set == 0)
6757 errmsg ("missing interface name or sw_if_index");
6761 M (SW_INTERFACE_GET_TABLE, mp);
6762 mp->sw_if_index = htonl (sw_if_index);
6763 mp->is_ipv6 = is_ipv6;
6771 api_sw_interface_set_vpath (vat_main_t * vam)
6773 unformat_input_t *i = vam->input;
6774 vl_api_sw_interface_set_vpath_t *mp;
6775 u32 sw_if_index = 0;
6776 u8 sw_if_index_set = 0;
6780 /* Parse args required to build the message */
6781 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6783 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6784 sw_if_index_set = 1;
6785 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6786 sw_if_index_set = 1;
6787 else if (unformat (i, "enable"))
6789 else if (unformat (i, "disable"))
6795 if (sw_if_index_set == 0)
6797 errmsg ("missing interface name or sw_if_index");
6801 /* Construct the API message */
6802 M (SW_INTERFACE_SET_VPATH, mp);
6804 mp->sw_if_index = ntohl (sw_if_index);
6805 mp->enable = is_enable;
6810 /* Wait for a reply... */
6816 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
6818 unformat_input_t *i = vam->input;
6819 vl_api_sw_interface_set_vxlan_bypass_t *mp;
6820 u32 sw_if_index = 0;
6821 u8 sw_if_index_set = 0;
6826 /* Parse args required to build the message */
6827 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6829 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6830 sw_if_index_set = 1;
6831 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6832 sw_if_index_set = 1;
6833 else if (unformat (i, "enable"))
6835 else if (unformat (i, "disable"))
6837 else if (unformat (i, "ip4"))
6839 else if (unformat (i, "ip6"))
6845 if (sw_if_index_set == 0)
6847 errmsg ("missing interface name or sw_if_index");
6851 /* Construct the API message */
6852 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
6854 mp->sw_if_index = ntohl (sw_if_index);
6855 mp->enable = is_enable;
6856 mp->is_ipv6 = is_ipv6;
6861 /* Wait for a reply... */
6867 api_sw_interface_set_geneve_bypass (vat_main_t * vam)
6869 unformat_input_t *i = vam->input;
6870 vl_api_sw_interface_set_geneve_bypass_t *mp;
6871 u32 sw_if_index = 0;
6872 u8 sw_if_index_set = 0;
6877 /* Parse args required to build the message */
6878 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6880 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6881 sw_if_index_set = 1;
6882 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6883 sw_if_index_set = 1;
6884 else if (unformat (i, "enable"))
6886 else if (unformat (i, "disable"))
6888 else if (unformat (i, "ip4"))
6890 else if (unformat (i, "ip6"))
6896 if (sw_if_index_set == 0)
6898 errmsg ("missing interface name or sw_if_index");
6902 /* Construct the API message */
6903 M (SW_INTERFACE_SET_GENEVE_BYPASS, mp);
6905 mp->sw_if_index = ntohl (sw_if_index);
6906 mp->enable = is_enable;
6907 mp->is_ipv6 = is_ipv6;
6912 /* Wait for a reply... */
6918 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
6920 unformat_input_t *i = vam->input;
6921 vl_api_sw_interface_set_l2_xconnect_t *mp;
6923 u8 rx_sw_if_index_set = 0;
6925 u8 tx_sw_if_index_set = 0;
6929 /* Parse args required to build the message */
6930 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6932 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6933 rx_sw_if_index_set = 1;
6934 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6935 tx_sw_if_index_set = 1;
6936 else if (unformat (i, "rx"))
6938 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6940 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6942 rx_sw_if_index_set = 1;
6947 else if (unformat (i, "tx"))
6949 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6951 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
6953 tx_sw_if_index_set = 1;
6958 else if (unformat (i, "enable"))
6960 else if (unformat (i, "disable"))
6966 if (rx_sw_if_index_set == 0)
6968 errmsg ("missing rx interface name or rx_sw_if_index");
6972 if (enable && (tx_sw_if_index_set == 0))
6974 errmsg ("missing tx interface name or tx_sw_if_index");
6978 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
6980 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6981 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6982 mp->enable = enable;
6990 api_sw_interface_set_l2_bridge (vat_main_t * vam)
6992 unformat_input_t *i = vam->input;
6993 vl_api_sw_interface_set_l2_bridge_t *mp;
6995 u8 rx_sw_if_index_set = 0;
7003 /* Parse args required to build the message */
7004 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7006 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
7007 rx_sw_if_index_set = 1;
7008 else if (unformat (i, "bd_id %d", &bd_id))
7012 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
7013 rx_sw_if_index_set = 1;
7014 else if (unformat (i, "shg %d", &shg))
7016 else if (unformat (i, "bvi"))
7018 else if (unformat (i, "enable"))
7020 else if (unformat (i, "disable"))
7026 if (rx_sw_if_index_set == 0)
7028 errmsg ("missing rx interface name or sw_if_index");
7032 if (enable && (bd_id_set == 0))
7034 errmsg ("missing bridge domain");
7038 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
7040 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
7041 mp->bd_id = ntohl (bd_id);
7044 mp->enable = enable;
7052 api_bridge_domain_dump (vat_main_t * vam)
7054 unformat_input_t *i = vam->input;
7055 vl_api_bridge_domain_dump_t *mp;
7056 vl_api_control_ping_t *mp_ping;
7060 /* Parse args required to build the message */
7061 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7063 if (unformat (i, "bd_id %d", &bd_id))
7069 M (BRIDGE_DOMAIN_DUMP, mp);
7070 mp->bd_id = ntohl (bd_id);
7073 /* Use a control ping for synchronization */
7074 MPING (CONTROL_PING, mp_ping);
7082 api_bridge_domain_add_del (vat_main_t * vam)
7084 unformat_input_t *i = vam->input;
7085 vl_api_bridge_domain_add_del_t *mp;
7088 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
7093 /* Parse args required to build the message */
7094 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7096 if (unformat (i, "bd_id %d", &bd_id))
7098 else if (unformat (i, "flood %d", &flood))
7100 else if (unformat (i, "uu-flood %d", &uu_flood))
7102 else if (unformat (i, "forward %d", &forward))
7104 else if (unformat (i, "learn %d", &learn))
7106 else if (unformat (i, "arp-term %d", &arp_term))
7108 else if (unformat (i, "mac-age %d", &mac_age))
7110 else if (unformat (i, "bd-tag %s", &bd_tag))
7112 else if (unformat (i, "del"))
7115 flood = uu_flood = forward = learn = 0;
7123 errmsg ("missing bridge domain");
7130 errmsg ("mac age must be less than 256 ");
7135 if ((bd_tag) && (vec_len (bd_tag) > 63))
7137 errmsg ("bd-tag cannot be longer than 63");
7142 M (BRIDGE_DOMAIN_ADD_DEL, mp);
7144 mp->bd_id = ntohl (bd_id);
7146 mp->uu_flood = uu_flood;
7147 mp->forward = forward;
7149 mp->arp_term = arp_term;
7150 mp->is_add = is_add;
7151 mp->mac_age = (u8) mac_age;
7154 clib_memcpy (mp->bd_tag, bd_tag, vec_len (bd_tag));
7155 mp->bd_tag[vec_len (bd_tag)] = 0;
7166 api_l2fib_flush_bd (vat_main_t * vam)
7168 unformat_input_t *i = vam->input;
7169 vl_api_l2fib_flush_bd_t *mp;
7173 /* Parse args required to build the message */
7174 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7176 if (unformat (i, "bd_id %d", &bd_id));
7183 errmsg ("missing bridge domain");
7187 M (L2FIB_FLUSH_BD, mp);
7189 mp->bd_id = htonl (bd_id);
7197 api_l2fib_flush_int (vat_main_t * vam)
7199 unformat_input_t *i = vam->input;
7200 vl_api_l2fib_flush_int_t *mp;
7201 u32 sw_if_index = ~0;
7204 /* Parse args required to build the message */
7205 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7207 if (unformat (i, "sw_if_index %d", &sw_if_index));
7209 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index));
7214 if (sw_if_index == ~0)
7216 errmsg ("missing interface name or sw_if_index");
7220 M (L2FIB_FLUSH_INT, mp);
7222 mp->sw_if_index = ntohl (sw_if_index);
7230 api_l2fib_add_del (vat_main_t * vam)
7232 unformat_input_t *i = vam->input;
7233 vl_api_l2fib_add_del_t *mp;
7239 u32 sw_if_index = ~0;
7240 u8 sw_if_index_set = 0;
7249 /* Parse args required to build the message */
7250 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7252 if (unformat (i, "mac %U", unformat_ethernet_address, mac))
7254 else if (unformat (i, "bd_id %d", &bd_id))
7256 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7257 sw_if_index_set = 1;
7258 else if (unformat (i, "sw_if"))
7260 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7263 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7264 sw_if_index_set = 1;
7269 else if (unformat (i, "static"))
7271 else if (unformat (i, "filter"))
7276 else if (unformat (i, "bvi"))
7281 else if (unformat (i, "del"))
7283 else if (unformat (i, "count %d", &count))
7291 errmsg ("missing mac address");
7297 errmsg ("missing bridge domain");
7301 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
7303 errmsg ("missing interface name or sw_if_index");
7309 /* Turn on async mode */
7310 vam->async_mode = 1;
7311 vam->async_errors = 0;
7312 before = vat_time_now (vam);
7315 for (j = 0; j < count; j++)
7317 M (L2FIB_ADD_DEL, mp);
7319 clib_memcpy (mp->mac, mac, 6);
7320 mp->bd_id = ntohl (bd_id);
7321 mp->is_add = is_add;
7325 mp->sw_if_index = ntohl (sw_if_index);
7326 mp->static_mac = static_mac;
7327 mp->filter_mac = filter_mac;
7328 mp->bvi_mac = bvi_mac;
7330 increment_mac_address (mac);
7337 vl_api_control_ping_t *mp_ping;
7340 /* Shut off async mode */
7341 vam->async_mode = 0;
7343 MPING (CONTROL_PING, mp_ping);
7346 timeout = vat_time_now (vam) + 1.0;
7347 while (vat_time_now (vam) < timeout)
7348 if (vam->result_ready == 1)
7353 if (vam->retval == -99)
7356 if (vam->async_errors > 0)
7358 errmsg ("%d asynchronous errors", vam->async_errors);
7361 vam->async_errors = 0;
7362 after = vat_time_now (vam);
7364 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
7365 count, after - before, count / (after - before));
7371 /* Wait for a reply... */
7375 /* Return the good/bad news */
7376 return (vam->retval);
7380 api_bridge_domain_set_mac_age (vat_main_t * vam)
7382 unformat_input_t *i = vam->input;
7383 vl_api_bridge_domain_set_mac_age_t *mp;
7388 /* Parse args required to build the message */
7389 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7391 if (unformat (i, "bd_id %d", &bd_id));
7392 else if (unformat (i, "mac-age %d", &mac_age));
7399 errmsg ("missing bridge domain");
7405 errmsg ("mac age must be less than 256 ");
7409 M (BRIDGE_DOMAIN_SET_MAC_AGE, mp);
7411 mp->bd_id = htonl (bd_id);
7412 mp->mac_age = (u8) mac_age;
7420 api_l2_flags (vat_main_t * vam)
7422 unformat_input_t *i = vam->input;
7423 vl_api_l2_flags_t *mp;
7426 u8 sw_if_index_set = 0;
7430 /* Parse args required to build the message */
7431 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7433 if (unformat (i, "sw_if_index %d", &sw_if_index))
7434 sw_if_index_set = 1;
7435 else if (unformat (i, "sw_if"))
7437 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7440 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7441 sw_if_index_set = 1;
7446 else if (unformat (i, "learn"))
7448 else if (unformat (i, "forward"))
7450 else if (unformat (i, "flood"))
7452 else if (unformat (i, "uu-flood"))
7453 flags |= L2_UU_FLOOD;
7454 else if (unformat (i, "arp-term"))
7455 flags |= L2_ARP_TERM;
7456 else if (unformat (i, "off"))
7458 else if (unformat (i, "disable"))
7464 if (sw_if_index_set == 0)
7466 errmsg ("missing interface name or sw_if_index");
7472 mp->sw_if_index = ntohl (sw_if_index);
7473 mp->feature_bitmap = ntohl (flags);
7474 mp->is_set = is_set;
7482 api_bridge_flags (vat_main_t * vam)
7484 unformat_input_t *i = vam->input;
7485 vl_api_bridge_flags_t *mp;
7492 /* Parse args required to build the message */
7493 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7495 if (unformat (i, "bd_id %d", &bd_id))
7497 else if (unformat (i, "learn"))
7499 else if (unformat (i, "forward"))
7501 else if (unformat (i, "flood"))
7503 else if (unformat (i, "uu-flood"))
7504 flags |= L2_UU_FLOOD;
7505 else if (unformat (i, "arp-term"))
7506 flags |= L2_ARP_TERM;
7507 else if (unformat (i, "off"))
7509 else if (unformat (i, "disable"))
7517 errmsg ("missing bridge domain");
7521 M (BRIDGE_FLAGS, mp);
7523 mp->bd_id = ntohl (bd_id);
7524 mp->feature_bitmap = ntohl (flags);
7525 mp->is_set = is_set;
7533 api_bd_ip_mac_add_del (vat_main_t * vam)
7535 unformat_input_t *i = vam->input;
7536 vl_api_bd_ip_mac_add_del_t *mp;
7543 ip4_address_t v4addr;
7544 ip6_address_t v6addr;
7549 /* Parse args required to build the message */
7550 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7552 if (unformat (i, "bd_id %d", &bd_id))
7556 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
7560 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
7565 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
7569 else if (unformat (i, "del"))
7577 errmsg ("missing bridge domain");
7580 else if (ip_set == 0)
7582 errmsg ("missing IP address");
7585 else if (mac_set == 0)
7587 errmsg ("missing MAC address");
7591 M (BD_IP_MAC_ADD_DEL, mp);
7593 mp->bd_id = ntohl (bd_id);
7594 mp->is_ipv6 = is_ipv6;
7595 mp->is_add = is_add;
7597 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
7599 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
7600 clib_memcpy (mp->mac_address, macaddr, 6);
7607 api_tap_connect (vat_main_t * vam)
7609 unformat_input_t *i = vam->input;
7610 vl_api_tap_connect_t *mp;
7616 ip4_address_t ip4_address;
7618 int ip4_address_set = 0;
7619 ip6_address_t ip6_address;
7621 int ip6_address_set = 0;
7624 memset (mac_address, 0, sizeof (mac_address));
7626 /* Parse args required to build the message */
7627 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7629 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
7633 else if (unformat (i, "random-mac"))
7635 else if (unformat (i, "tapname %s", &tap_name))
7637 else if (unformat (i, "tag %s", &tag))
7639 else if (unformat (i, "address %U/%d",
7640 unformat_ip4_address, &ip4_address, &ip4_mask_width))
7641 ip4_address_set = 1;
7642 else if (unformat (i, "address %U/%d",
7643 unformat_ip6_address, &ip6_address, &ip6_mask_width))
7644 ip6_address_set = 1;
7651 errmsg ("missing tap name");
7654 if (vec_len (tap_name) > 63)
7656 errmsg ("tap name too long");
7659 vec_add1 (tap_name, 0);
7661 if (vec_len (tag) > 63)
7663 errmsg ("tag too long");
7667 /* Construct the API message */
7668 M (TAP_CONNECT, mp);
7670 mp->use_random_mac = random_mac;
7671 clib_memcpy (mp->mac_address, mac_address, 6);
7672 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
7674 clib_memcpy (mp->tag, tag, vec_len (tag));
7676 if (ip4_address_set)
7678 mp->ip4_address_set = 1;
7679 clib_memcpy (mp->ip4_address, &ip4_address, sizeof (mp->ip4_address));
7680 mp->ip4_mask_width = ip4_mask_width;
7682 if (ip6_address_set)
7684 mp->ip6_address_set = 1;
7685 clib_memcpy (mp->ip6_address, &ip6_address, sizeof (mp->ip6_address));
7686 mp->ip6_mask_width = ip6_mask_width;
7689 vec_free (tap_name);
7695 /* Wait for a reply... */
7701 api_tap_modify (vat_main_t * vam)
7703 unformat_input_t *i = vam->input;
7704 vl_api_tap_modify_t *mp;
7709 u32 sw_if_index = ~0;
7710 u8 sw_if_index_set = 0;
7713 memset (mac_address, 0, sizeof (mac_address));
7715 /* Parse args required to build the message */
7716 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7718 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7719 sw_if_index_set = 1;
7720 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7721 sw_if_index_set = 1;
7722 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
7726 else if (unformat (i, "random-mac"))
7728 else if (unformat (i, "tapname %s", &tap_name))
7734 if (sw_if_index_set == 0)
7736 errmsg ("missing vpp interface name");
7741 errmsg ("missing tap name");
7744 if (vec_len (tap_name) > 63)
7746 errmsg ("tap name too long");
7748 vec_add1 (tap_name, 0);
7750 /* Construct the API message */
7753 mp->use_random_mac = random_mac;
7754 mp->sw_if_index = ntohl (sw_if_index);
7755 clib_memcpy (mp->mac_address, mac_address, 6);
7756 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
7757 vec_free (tap_name);
7762 /* Wait for a reply... */
7768 api_tap_delete (vat_main_t * vam)
7770 unformat_input_t *i = vam->input;
7771 vl_api_tap_delete_t *mp;
7772 u32 sw_if_index = ~0;
7773 u8 sw_if_index_set = 0;
7776 /* Parse args required to build the message */
7777 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7779 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7780 sw_if_index_set = 1;
7781 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7782 sw_if_index_set = 1;
7787 if (sw_if_index_set == 0)
7789 errmsg ("missing vpp interface name");
7793 /* Construct the API message */
7796 mp->sw_if_index = ntohl (sw_if_index);
7801 /* Wait for a reply... */
7807 api_tap_create_v2 (vat_main_t * vam)
7809 unformat_input_t *i = vam->input;
7810 vl_api_tap_create_v2_t *mp;
7814 u8 *host_if_name = 0;
7816 u8 host_mac_addr[6];
7817 u8 host_mac_addr_set = 0;
7818 u8 *host_bridge = 0;
7819 ip4_address_t host_ip4_addr;
7820 u32 host_ip4_prefix_len = 0;
7821 ip6_address_t host_ip6_addr;
7822 u32 host_ip6_prefix_len = 0;
7824 int rx_ring_sz = 0, tx_ring_sz = 0;
7826 memset (mac_address, 0, sizeof (mac_address));
7828 /* Parse args required to build the message */
7829 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7831 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7835 else if (unformat (i, "id %s", &id))
7837 else if (unformat (i, "host-if-name %s", &host_if_name))
7839 else if (unformat (i, "host-ns %s", &host_ns))
7841 else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
7843 host_mac_addr_set = 1;
7844 else if (unformat (i, "host-bridge %s", &host_bridge))
7846 else if (unformat (i, "host-ip4-addr %U/%d", unformat_ip4_address,
7847 &host_ip4_addr, &host_ip4_prefix_len))
7849 else if (unformat (i, "host-ip6-addr %U/%d", unformat_ip6_address,
7850 &host_ip6_addr, &host_ip6_prefix_len))
7852 else if (unformat (i, "rx-ring-size %d", &rx_ring_sz))
7854 else if (unformat (i, "tx-ring-size %d", &tx_ring_sz))
7860 if (vec_len (host_if_name) > 63)
7862 errmsg ("tap name too long. ");
7865 if (vec_len (host_ns) > 63)
7867 errmsg ("host name space too long. ");
7870 if (vec_len (host_bridge) > 63)
7872 errmsg ("host bridge name too long. ");
7875 if (host_ip4_prefix_len > 32)
7877 errmsg ("host ip4 prefix length not valid. ");
7880 if (host_ip6_prefix_len > 128)
7882 errmsg ("host ip6 prefix length not valid. ");
7885 if (!is_pow2 (rx_ring_sz))
7887 errmsg ("rx ring size must be power of 2. ");
7890 if (rx_ring_sz > 32768)
7892 errmsg ("rx ring size must be 32768 or lower. ");
7895 if (!is_pow2 (tx_ring_sz))
7897 errmsg ("tx ring size must be power of 2. ");
7900 if (tx_ring_sz > 32768)
7902 errmsg ("tx ring size must be 32768 or lower. ");
7906 /* Construct the API message */
7907 M (TAP_CREATE_V2, mp);
7909 mp->use_random_mac = random_mac;
7912 mp->host_namespace_set = host_ns != 0;
7913 mp->host_bridge_set = host_bridge != 0;
7914 mp->host_ip4_addr_set = host_ip4_prefix_len != 0;
7915 mp->host_ip6_addr_set = host_ip6_prefix_len != 0;
7916 mp->rx_ring_sz = rx_ring_sz;
7917 mp->tx_ring_sz = tx_ring_sz;
7920 clib_memcpy (mp->mac_address, mac_address, 6);
7921 if (host_mac_addr_set)
7922 clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
7924 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
7926 clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
7928 clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
7929 if (host_ip4_prefix_len)
7930 clib_memcpy (mp->host_ip4_addr, &host_ip4_addr, 4);
7931 if (host_ip4_prefix_len)
7932 clib_memcpy (mp->host_ip6_addr, &host_ip6_addr, 16);
7936 vec_free (host_if_name);
7937 vec_free (host_bridge);
7942 /* Wait for a reply... */
7948 api_tap_delete_v2 (vat_main_t * vam)
7950 unformat_input_t *i = vam->input;
7951 vl_api_tap_delete_v2_t *mp;
7952 u32 sw_if_index = ~0;
7953 u8 sw_if_index_set = 0;
7956 /* Parse args required to build the message */
7957 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7959 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7960 sw_if_index_set = 1;
7961 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7962 sw_if_index_set = 1;
7967 if (sw_if_index_set == 0)
7969 errmsg ("missing vpp interface name. ");
7973 /* Construct the API message */
7974 M (TAP_DELETE_V2, mp);
7976 mp->sw_if_index = ntohl (sw_if_index);
7981 /* Wait for a reply... */
7987 api_ip_table_add_del (vat_main_t * vam)
7989 unformat_input_t *i = vam->input;
7990 vl_api_ip_table_add_del_t *mp;
7996 /* Parse args required to build the message */
7997 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7999 if (unformat (i, "ipv6"))
8001 else if (unformat (i, "del"))
8003 else if (unformat (i, "add"))
8005 else if (unformat (i, "table %d", &table_id))
8009 clib_warning ("parse error '%U'", format_unformat_error, i);
8016 errmsg ("missing table-ID");
8020 /* Construct the API message */
8021 M (IP_TABLE_ADD_DEL, mp);
8023 mp->table_id = ntohl (table_id);
8024 mp->is_ipv6 = is_ipv6;
8025 mp->is_add = is_add;
8030 /* Wait for a reply... */
8037 api_ip_add_del_route (vat_main_t * vam)
8039 unformat_input_t *i = vam->input;
8040 vl_api_ip_add_del_route_t *mp;
8041 u32 sw_if_index = ~0, vrf_id = 0;
8043 u8 is_local = 0, is_drop = 0;
8044 u8 is_unreach = 0, is_prohibit = 0;
8046 u32 next_hop_weight = 1;
8047 u8 is_multipath = 0;
8049 u8 address_length_set = 0;
8050 u32 next_hop_table_id = 0;
8051 u32 resolve_attempts = 0;
8052 u32 dst_address_length = 0;
8053 u8 next_hop_set = 0;
8054 ip4_address_t v4_dst_address, v4_next_hop_address;
8055 ip6_address_t v6_dst_address, v6_next_hop_address;
8059 u32 random_add_del = 0;
8060 u32 *random_vector = 0;
8062 u32 random_seed = 0xdeaddabe;
8063 u32 classify_table_index = ~0;
8065 u8 resolve_host = 0, resolve_attached = 0;
8066 mpls_label_t *next_hop_out_label_stack = NULL;
8067 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8068 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
8070 /* Parse args required to build the message */
8071 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8073 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8075 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8077 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
8082 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
8087 else if (unformat (i, "/%d", &dst_address_length))
8089 address_length_set = 1;
8092 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
8093 &v4_next_hop_address))
8097 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
8098 &v6_next_hop_address))
8102 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
8104 else if (unformat (i, "weight %d", &next_hop_weight))
8106 else if (unformat (i, "drop"))
8110 else if (unformat (i, "null-send-unreach"))
8114 else if (unformat (i, "null-send-prohibit"))
8118 else if (unformat (i, "local"))
8122 else if (unformat (i, "classify %d", &classify_table_index))
8126 else if (unformat (i, "del"))
8128 else if (unformat (i, "add"))
8130 else if (unformat (i, "resolve-via-host"))
8132 else if (unformat (i, "resolve-via-attached"))
8133 resolve_attached = 1;
8134 else if (unformat (i, "multipath"))
8136 else if (unformat (i, "vrf %d", &vrf_id))
8138 else if (unformat (i, "count %d", &count))
8140 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
8142 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
8144 else if (unformat (i, "out-label %d", &next_hop_out_label))
8145 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
8146 else if (unformat (i, "via-label %d", &next_hop_via_label))
8148 else if (unformat (i, "random"))
8150 else if (unformat (i, "seed %d", &random_seed))
8154 clib_warning ("parse error '%U'", format_unformat_error, i);
8159 if (!next_hop_set && !is_drop && !is_local &&
8160 !is_classify && !is_unreach && !is_prohibit &&
8161 MPLS_LABEL_INVALID == next_hop_via_label)
8164 ("next hop / local / drop / unreach / prohibit / classify not set");
8168 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
8170 errmsg ("next hop and next-hop via label set");
8173 if (address_set == 0)
8175 errmsg ("missing addresses");
8179 if (address_length_set == 0)
8181 errmsg ("missing address length");
8185 /* Generate a pile of unique, random routes */
8188 u32 this_random_address;
8189 random_hash = hash_create (count, sizeof (uword));
8191 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
8192 for (j = 0; j <= count; j++)
8196 this_random_address = random_u32 (&random_seed);
8197 this_random_address =
8198 clib_host_to_net_u32 (this_random_address);
8200 while (hash_get (random_hash, this_random_address));
8201 vec_add1 (random_vector, this_random_address);
8202 hash_set (random_hash, this_random_address, 1);
8204 hash_free (random_hash);
8205 v4_dst_address.as_u32 = random_vector[0];
8210 /* Turn on async mode */
8211 vam->async_mode = 1;
8212 vam->async_errors = 0;
8213 before = vat_time_now (vam);
8216 for (j = 0; j < count; j++)
8218 /* Construct the API message */
8219 M2 (IP_ADD_DEL_ROUTE, mp,
8220 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
8222 mp->next_hop_sw_if_index = ntohl (sw_if_index);
8223 mp->table_id = ntohl (vrf_id);
8225 mp->is_add = is_add;
8226 mp->is_drop = is_drop;
8227 mp->is_unreach = is_unreach;
8228 mp->is_prohibit = is_prohibit;
8229 mp->is_ipv6 = is_ipv6;
8230 mp->is_local = is_local;
8231 mp->is_classify = is_classify;
8232 mp->is_multipath = is_multipath;
8233 mp->is_resolve_host = resolve_host;
8234 mp->is_resolve_attached = resolve_attached;
8235 mp->next_hop_weight = next_hop_weight;
8236 mp->dst_address_length = dst_address_length;
8237 mp->next_hop_table_id = ntohl (next_hop_table_id);
8238 mp->classify_table_index = ntohl (classify_table_index);
8239 mp->next_hop_via_label = ntohl (next_hop_via_label);
8240 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
8241 if (0 != mp->next_hop_n_out_labels)
8243 memcpy (mp->next_hop_out_label_stack,
8244 next_hop_out_label_stack,
8245 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
8246 vec_free (next_hop_out_label_stack);
8251 clib_memcpy (mp->dst_address, &v6_dst_address,
8252 sizeof (v6_dst_address));
8254 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
8255 sizeof (v6_next_hop_address));
8256 increment_v6_address (&v6_dst_address);
8260 clib_memcpy (mp->dst_address, &v4_dst_address,
8261 sizeof (v4_dst_address));
8263 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
8264 sizeof (v4_next_hop_address));
8266 v4_dst_address.as_u32 = random_vector[j + 1];
8268 increment_v4_address (&v4_dst_address);
8272 /* If we receive SIGTERM, stop now... */
8277 /* When testing multiple add/del ops, use a control-ping to sync */
8280 vl_api_control_ping_t *mp_ping;
8284 /* Shut off async mode */
8285 vam->async_mode = 0;
8287 MPING (CONTROL_PING, mp_ping);
8290 timeout = vat_time_now (vam) + 1.0;
8291 while (vat_time_now (vam) < timeout)
8292 if (vam->result_ready == 1)
8297 if (vam->retval == -99)
8300 if (vam->async_errors > 0)
8302 errmsg ("%d asynchronous errors", vam->async_errors);
8305 vam->async_errors = 0;
8306 after = vat_time_now (vam);
8308 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8312 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8313 count, after - before, count / (after - before));
8319 /* Wait for a reply... */
8324 /* Return the good/bad news */
8325 return (vam->retval);
8329 api_ip_mroute_add_del (vat_main_t * vam)
8331 unformat_input_t *i = vam->input;
8332 vl_api_ip_mroute_add_del_t *mp;
8333 u32 sw_if_index = ~0, vrf_id = 0;
8338 u32 grp_address_length = 0;
8339 ip4_address_t v4_grp_address, v4_src_address;
8340 ip6_address_t v6_grp_address, v6_src_address;
8341 mfib_itf_flags_t iflags = 0;
8342 mfib_entry_flags_t eflags = 0;
8345 /* Parse args required to build the message */
8346 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8348 if (unformat (i, "sw_if_index %d", &sw_if_index))
8350 else if (unformat (i, "%U %U",
8351 unformat_ip4_address, &v4_src_address,
8352 unformat_ip4_address, &v4_grp_address))
8354 grp_address_length = 64;
8358 else if (unformat (i, "%U %U",
8359 unformat_ip6_address, &v6_src_address,
8360 unformat_ip6_address, &v6_grp_address))
8362 grp_address_length = 256;
8366 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
8368 memset (&v4_src_address, 0, sizeof (v4_src_address));
8369 grp_address_length = 32;
8373 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
8375 memset (&v6_src_address, 0, sizeof (v6_src_address));
8376 grp_address_length = 128;
8380 else if (unformat (i, "/%d", &grp_address_length))
8382 else if (unformat (i, "local"))
8386 else if (unformat (i, "del"))
8388 else if (unformat (i, "add"))
8390 else if (unformat (i, "vrf %d", &vrf_id))
8392 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
8394 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8398 clib_warning ("parse error '%U'", format_unformat_error, i);
8403 if (address_set == 0)
8405 errmsg ("missing addresses\n");
8409 /* Construct the API message */
8410 M (IP_MROUTE_ADD_DEL, mp);
8412 mp->next_hop_sw_if_index = ntohl (sw_if_index);
8413 mp->table_id = ntohl (vrf_id);
8415 mp->is_add = is_add;
8416 mp->is_ipv6 = is_ipv6;
8417 mp->is_local = is_local;
8418 mp->itf_flags = ntohl (iflags);
8419 mp->entry_flags = ntohl (eflags);
8420 mp->grp_address_length = grp_address_length;
8421 mp->grp_address_length = ntohs (mp->grp_address_length);
8425 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
8426 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
8430 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
8431 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
8437 /* Wait for a reply... */
8443 api_mpls_table_add_del (vat_main_t * vam)
8445 unformat_input_t *i = vam->input;
8446 vl_api_mpls_table_add_del_t *mp;
8451 /* Parse args required to build the message */
8452 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8454 if (unformat (i, "table %d", &table_id))
8456 else if (unformat (i, "del"))
8458 else if (unformat (i, "add"))
8462 clib_warning ("parse error '%U'", format_unformat_error, i);
8469 errmsg ("missing table-ID");
8473 /* Construct the API message */
8474 M (MPLS_TABLE_ADD_DEL, mp);
8476 mp->mt_table_id = ntohl (table_id);
8477 mp->mt_is_add = is_add;
8482 /* Wait for a reply... */
8489 api_mpls_route_add_del (vat_main_t * vam)
8491 unformat_input_t *i = vam->input;
8492 vl_api_mpls_route_add_del_t *mp;
8493 u32 sw_if_index = ~0, table_id = 0;
8495 u32 next_hop_weight = 1;
8496 u8 is_multipath = 0;
8497 u32 next_hop_table_id = 0;
8498 u8 next_hop_set = 0;
8499 ip4_address_t v4_next_hop_address = {
8502 ip6_address_t v6_next_hop_address = { {0} };
8506 u32 classify_table_index = ~0;
8508 u8 resolve_host = 0, resolve_attached = 0;
8509 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
8510 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8511 mpls_label_t *next_hop_out_label_stack = NULL;
8512 mpls_label_t local_label = MPLS_LABEL_INVALID;
8514 dpo_proto_t next_hop_proto = DPO_PROTO_IP4;
8516 /* Parse args required to build the message */
8517 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8519 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8521 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8523 else if (unformat (i, "%d", &local_label))
8525 else if (unformat (i, "eos"))
8527 else if (unformat (i, "non-eos"))
8529 else if (unformat (i, "via %U", unformat_ip4_address,
8530 &v4_next_hop_address))
8533 next_hop_proto = DPO_PROTO_IP4;
8535 else if (unformat (i, "via %U", unformat_ip6_address,
8536 &v6_next_hop_address))
8539 next_hop_proto = DPO_PROTO_IP6;
8541 else if (unformat (i, "weight %d", &next_hop_weight))
8543 else if (unformat (i, "classify %d", &classify_table_index))
8547 else if (unformat (i, "del"))
8549 else if (unformat (i, "add"))
8551 else if (unformat (i, "resolve-via-host"))
8553 else if (unformat (i, "resolve-via-attached"))
8554 resolve_attached = 1;
8555 else if (unformat (i, "multipath"))
8557 else if (unformat (i, "count %d", &count))
8559 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
8562 next_hop_proto = DPO_PROTO_IP4;
8564 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
8567 next_hop_proto = DPO_PROTO_IP6;
8569 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
8571 else if (unformat (i, "via-label %d", &next_hop_via_label))
8573 else if (unformat (i, "out-label %d", &next_hop_out_label))
8574 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
8577 clib_warning ("parse error '%U'", format_unformat_error, i);
8582 if (!next_hop_set && !is_classify)
8584 errmsg ("next hop / classify not set");
8588 if (MPLS_LABEL_INVALID == local_label)
8590 errmsg ("missing label");
8596 /* Turn on async mode */
8597 vam->async_mode = 1;
8598 vam->async_errors = 0;
8599 before = vat_time_now (vam);
8602 for (j = 0; j < count; j++)
8604 /* Construct the API message */
8605 M2 (MPLS_ROUTE_ADD_DEL, mp,
8606 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
8608 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
8609 mp->mr_table_id = ntohl (table_id);
8611 mp->mr_is_add = is_add;
8612 mp->mr_next_hop_proto = next_hop_proto;
8613 mp->mr_is_classify = is_classify;
8614 mp->mr_is_multipath = is_multipath;
8615 mp->mr_is_resolve_host = resolve_host;
8616 mp->mr_is_resolve_attached = resolve_attached;
8617 mp->mr_next_hop_weight = next_hop_weight;
8618 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
8619 mp->mr_classify_table_index = ntohl (classify_table_index);
8620 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
8621 mp->mr_label = ntohl (local_label);
8622 mp->mr_eos = is_eos;
8624 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
8625 if (0 != mp->mr_next_hop_n_out_labels)
8627 memcpy (mp->mr_next_hop_out_label_stack,
8628 next_hop_out_label_stack,
8629 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
8630 vec_free (next_hop_out_label_stack);
8635 if (DPO_PROTO_IP4 == next_hop_proto)
8637 clib_memcpy (mp->mr_next_hop,
8638 &v4_next_hop_address,
8639 sizeof (v4_next_hop_address));
8641 else if (DPO_PROTO_IP6 == next_hop_proto)
8644 clib_memcpy (mp->mr_next_hop,
8645 &v6_next_hop_address,
8646 sizeof (v6_next_hop_address));
8653 /* If we receive SIGTERM, stop now... */
8658 /* When testing multiple add/del ops, use a control-ping to sync */
8661 vl_api_control_ping_t *mp_ping;
8665 /* Shut off async mode */
8666 vam->async_mode = 0;
8668 MPING (CONTROL_PING, mp_ping);
8671 timeout = vat_time_now (vam) + 1.0;
8672 while (vat_time_now (vam) < timeout)
8673 if (vam->result_ready == 1)
8678 if (vam->retval == -99)
8681 if (vam->async_errors > 0)
8683 errmsg ("%d asynchronous errors", vam->async_errors);
8686 vam->async_errors = 0;
8687 after = vat_time_now (vam);
8689 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8693 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8694 count, after - before, count / (after - before));
8700 /* Wait for a reply... */
8705 /* Return the good/bad news */
8706 return (vam->retval);
8710 api_mpls_ip_bind_unbind (vat_main_t * vam)
8712 unformat_input_t *i = vam->input;
8713 vl_api_mpls_ip_bind_unbind_t *mp;
8714 u32 ip_table_id = 0;
8717 ip4_address_t v4_address;
8718 ip6_address_t v6_address;
8721 mpls_label_t local_label = MPLS_LABEL_INVALID;
8724 /* Parse args required to build the message */
8725 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8727 if (unformat (i, "%U/%d", unformat_ip4_address,
8728 &v4_address, &address_length))
8733 else if (unformat (i, "%U/%d", unformat_ip6_address,
8734 &v6_address, &address_length))
8739 else if (unformat (i, "%d", &local_label))
8741 else if (unformat (i, "table-id %d", &ip_table_id))
8743 else if (unformat (i, "unbind"))
8745 else if (unformat (i, "bind"))
8749 clib_warning ("parse error '%U'", format_unformat_error, i);
8756 errmsg ("IP addres not set");
8760 if (MPLS_LABEL_INVALID == local_label)
8762 errmsg ("missing label");
8766 /* Construct the API message */
8767 M (MPLS_IP_BIND_UNBIND, mp);
8769 mp->mb_is_bind = is_bind;
8770 mp->mb_is_ip4 = is_ip4;
8771 mp->mb_ip_table_id = ntohl (ip_table_id);
8772 mp->mb_mpls_table_id = 0;
8773 mp->mb_label = ntohl (local_label);
8774 mp->mb_address_length = address_length;
8777 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
8779 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
8784 /* Wait for a reply... */
8790 api_bier_table_add_del (vat_main_t * vam)
8792 unformat_input_t *i = vam->input;
8793 vl_api_bier_table_add_del_t *mp;
8795 u32 set = 0, sub_domain = 0, hdr_len = 3;
8796 mpls_label_t local_label = MPLS_LABEL_INVALID;
8799 /* Parse args required to build the message */
8800 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8802 if (unformat (i, "sub-domain %d", &sub_domain))
8804 else if (unformat (i, "set %d", &set))
8806 else if (unformat (i, "label %d", &local_label))
8808 else if (unformat (i, "hdr-len %d", &hdr_len))
8810 else if (unformat (i, "add"))
8812 else if (unformat (i, "del"))
8816 clib_warning ("parse error '%U'", format_unformat_error, i);
8821 if (MPLS_LABEL_INVALID == local_label)
8823 errmsg ("missing label\n");
8827 /* Construct the API message */
8828 M (BIER_TABLE_ADD_DEL, mp);
8830 mp->bt_is_add = is_add;
8831 mp->bt_label = ntohl (local_label);
8832 mp->bt_tbl_id.bt_set = set;
8833 mp->bt_tbl_id.bt_sub_domain = sub_domain;
8834 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
8839 /* Wait for a reply... */
8846 api_bier_route_add_del (vat_main_t * vam)
8848 unformat_input_t *i = vam->input;
8849 vl_api_bier_route_add_del_t *mp;
8851 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
8852 ip4_address_t v4_next_hop_address;
8853 ip6_address_t v6_next_hop_address;
8854 u8 next_hop_set = 0;
8855 u8 next_hop_proto_is_ip4 = 1;
8856 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8859 /* Parse args required to build the message */
8860 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8862 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
8864 next_hop_proto_is_ip4 = 1;
8867 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
8869 next_hop_proto_is_ip4 = 0;
8872 if (unformat (i, "sub-domain %d", &sub_domain))
8874 else if (unformat (i, "set %d", &set))
8876 else if (unformat (i, "hdr-len %d", &hdr_len))
8878 else if (unformat (i, "bp %d", &bp))
8880 else if (unformat (i, "add"))
8882 else if (unformat (i, "del"))
8884 else if (unformat (i, "out-label %d", &next_hop_out_label))
8888 clib_warning ("parse error '%U'", format_unformat_error, i);
8893 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
8895 errmsg ("next hop / label set\n");
8900 errmsg ("bit=position not set\n");
8904 /* Construct the API message */
8905 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path3_t));
8907 mp->br_is_add = is_add;
8908 mp->br_tbl_id.bt_set = set;
8909 mp->br_tbl_id.bt_sub_domain = sub_domain;
8910 mp->br_tbl_id.bt_hdr_len_id = hdr_len;
8911 mp->br_bp = ntohs (bp);
8913 mp->br_paths[0].n_labels = 1;
8914 mp->br_paths[0].label_stack[0] = ntohl (next_hop_out_label);
8915 mp->br_paths[0].afi = (next_hop_proto_is_ip4 ? 0 : 1);
8917 if (next_hop_proto_is_ip4)
8919 clib_memcpy (mp->br_paths[0].next_hop,
8920 &v4_next_hop_address, sizeof (v4_next_hop_address));
8924 clib_memcpy (mp->br_paths[0].next_hop,
8925 &v6_next_hop_address, sizeof (v6_next_hop_address));
8931 /* Wait for a reply... */
8938 api_proxy_arp_add_del (vat_main_t * vam)
8940 unformat_input_t *i = vam->input;
8941 vl_api_proxy_arp_add_del_t *mp;
8944 ip4_address_t lo, hi;
8948 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8950 if (unformat (i, "vrf %d", &vrf_id))
8952 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
8953 unformat_ip4_address, &hi))
8955 else if (unformat (i, "del"))
8959 clib_warning ("parse error '%U'", format_unformat_error, i);
8966 errmsg ("address range not set");
8970 M (PROXY_ARP_ADD_DEL, mp);
8972 mp->vrf_id = ntohl (vrf_id);
8973 mp->is_add = is_add;
8974 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
8975 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
8983 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
8985 unformat_input_t *i = vam->input;
8986 vl_api_proxy_arp_intfc_enable_disable_t *mp;
8989 u8 sw_if_index_set = 0;
8992 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8994 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8995 sw_if_index_set = 1;
8996 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8997 sw_if_index_set = 1;
8998 else if (unformat (i, "enable"))
9000 else if (unformat (i, "disable"))
9004 clib_warning ("parse error '%U'", format_unformat_error, i);
9009 if (sw_if_index_set == 0)
9011 errmsg ("missing interface name or sw_if_index");
9015 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
9017 mp->sw_if_index = ntohl (sw_if_index);
9018 mp->enable_disable = enable;
9026 api_mpls_tunnel_add_del (vat_main_t * vam)
9028 unformat_input_t *i = vam->input;
9029 vl_api_mpls_tunnel_add_del_t *mp;
9033 u32 sw_if_index = ~0;
9034 u32 next_hop_sw_if_index = ~0;
9035 u32 next_hop_proto_is_ip4 = 1;
9037 u32 next_hop_table_id = 0;
9038 ip4_address_t v4_next_hop_address = {
9041 ip6_address_t v6_next_hop_address = { {0} };
9042 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID, *labels = NULL;
9045 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9047 if (unformat (i, "add"))
9049 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
9051 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
9053 else if (unformat (i, "via %U",
9054 unformat_ip4_address, &v4_next_hop_address))
9056 next_hop_proto_is_ip4 = 1;
9058 else if (unformat (i, "via %U",
9059 unformat_ip6_address, &v6_next_hop_address))
9061 next_hop_proto_is_ip4 = 0;
9063 else if (unformat (i, "l2-only"))
9065 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
9067 else if (unformat (i, "out-label %d", &next_hop_out_label))
9068 vec_add1 (labels, ntohl (next_hop_out_label));
9071 clib_warning ("parse error '%U'", format_unformat_error, i);
9076 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (mpls_label_t) * vec_len (labels));
9078 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
9079 mp->mt_sw_if_index = ntohl (sw_if_index);
9080 mp->mt_is_add = is_add;
9081 mp->mt_l2_only = l2_only;
9082 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
9083 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
9085 mp->mt_next_hop_n_out_labels = vec_len (labels);
9087 if (0 != mp->mt_next_hop_n_out_labels)
9089 clib_memcpy (mp->mt_next_hop_out_label_stack, labels,
9090 sizeof (mpls_label_t) * mp->mt_next_hop_n_out_labels);
9094 if (next_hop_proto_is_ip4)
9096 clib_memcpy (mp->mt_next_hop,
9097 &v4_next_hop_address, sizeof (v4_next_hop_address));
9101 clib_memcpy (mp->mt_next_hop,
9102 &v6_next_hop_address, sizeof (v6_next_hop_address));
9111 api_sw_interface_set_unnumbered (vat_main_t * vam)
9113 unformat_input_t *i = vam->input;
9114 vl_api_sw_interface_set_unnumbered_t *mp;
9116 u32 unnum_sw_index = ~0;
9118 u8 sw_if_index_set = 0;
9121 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9123 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9124 sw_if_index_set = 1;
9125 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9126 sw_if_index_set = 1;
9127 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
9129 else if (unformat (i, "del"))
9133 clib_warning ("parse error '%U'", format_unformat_error, i);
9138 if (sw_if_index_set == 0)
9140 errmsg ("missing interface name or sw_if_index");
9144 M (SW_INTERFACE_SET_UNNUMBERED, mp);
9146 mp->sw_if_index = ntohl (sw_if_index);
9147 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
9148 mp->is_add = is_add;
9156 api_ip_neighbor_add_del (vat_main_t * vam)
9158 unformat_input_t *i = vam->input;
9159 vl_api_ip_neighbor_add_del_t *mp;
9161 u8 sw_if_index_set = 0;
9164 u8 is_no_fib_entry = 0;
9167 u8 v4_address_set = 0;
9168 u8 v6_address_set = 0;
9169 ip4_address_t v4address;
9170 ip6_address_t v6address;
9173 memset (mac_address, 0, sizeof (mac_address));
9175 /* Parse args required to build the message */
9176 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9178 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
9182 else if (unformat (i, "del"))
9185 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9186 sw_if_index_set = 1;
9187 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9188 sw_if_index_set = 1;
9189 else if (unformat (i, "is_static"))
9191 else if (unformat (i, "no-fib-entry"))
9192 is_no_fib_entry = 1;
9193 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
9195 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
9199 clib_warning ("parse error '%U'", format_unformat_error, i);
9204 if (sw_if_index_set == 0)
9206 errmsg ("missing interface name or sw_if_index");
9209 if (v4_address_set && v6_address_set)
9211 errmsg ("both v4 and v6 addresses set");
9214 if (!v4_address_set && !v6_address_set)
9216 errmsg ("no address set");
9220 /* Construct the API message */
9221 M (IP_NEIGHBOR_ADD_DEL, mp);
9223 mp->sw_if_index = ntohl (sw_if_index);
9224 mp->is_add = is_add;
9225 mp->is_static = is_static;
9226 mp->is_no_adj_fib = is_no_fib_entry;
9228 clib_memcpy (mp->mac_address, mac_address, 6);
9232 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
9236 /* mp->is_ipv6 = 0; via memset in M macro above */
9237 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
9243 /* Wait for a reply, return good/bad news */
9249 api_create_vlan_subif (vat_main_t * vam)
9251 unformat_input_t *i = vam->input;
9252 vl_api_create_vlan_subif_t *mp;
9254 u8 sw_if_index_set = 0;
9259 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9261 if (unformat (i, "sw_if_index %d", &sw_if_index))
9262 sw_if_index_set = 1;
9264 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9265 sw_if_index_set = 1;
9266 else if (unformat (i, "vlan %d", &vlan_id))
9270 clib_warning ("parse error '%U'", format_unformat_error, i);
9275 if (sw_if_index_set == 0)
9277 errmsg ("missing interface name or sw_if_index");
9281 if (vlan_id_set == 0)
9283 errmsg ("missing vlan_id");
9286 M (CREATE_VLAN_SUBIF, mp);
9288 mp->sw_if_index = ntohl (sw_if_index);
9289 mp->vlan_id = ntohl (vlan_id);
9296 #define foreach_create_subif_bit \
9303 _(outer_vlan_id_any) \
9304 _(inner_vlan_id_any)
9307 api_create_subif (vat_main_t * vam)
9309 unformat_input_t *i = vam->input;
9310 vl_api_create_subif_t *mp;
9312 u8 sw_if_index_set = 0;
9319 u32 exact_match = 0;
9320 u32 default_sub = 0;
9321 u32 outer_vlan_id_any = 0;
9322 u32 inner_vlan_id_any = 0;
9324 u16 outer_vlan_id = 0;
9325 u16 inner_vlan_id = 0;
9328 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9330 if (unformat (i, "sw_if_index %d", &sw_if_index))
9331 sw_if_index_set = 1;
9333 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9334 sw_if_index_set = 1;
9335 else if (unformat (i, "sub_id %d", &sub_id))
9337 else if (unformat (i, "outer_vlan_id %d", &tmp))
9338 outer_vlan_id = tmp;
9339 else if (unformat (i, "inner_vlan_id %d", &tmp))
9340 inner_vlan_id = tmp;
9342 #define _(a) else if (unformat (i, #a)) a = 1 ;
9343 foreach_create_subif_bit
9347 clib_warning ("parse error '%U'", format_unformat_error, i);
9352 if (sw_if_index_set == 0)
9354 errmsg ("missing interface name or sw_if_index");
9358 if (sub_id_set == 0)
9360 errmsg ("missing sub_id");
9363 M (CREATE_SUBIF, mp);
9365 mp->sw_if_index = ntohl (sw_if_index);
9366 mp->sub_id = ntohl (sub_id);
9368 #define _(a) mp->a = a;
9369 foreach_create_subif_bit;
9372 mp->outer_vlan_id = ntohs (outer_vlan_id);
9373 mp->inner_vlan_id = ntohs (inner_vlan_id);
9381 api_oam_add_del (vat_main_t * vam)
9383 unformat_input_t *i = vam->input;
9384 vl_api_oam_add_del_t *mp;
9387 ip4_address_t src, dst;
9392 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9394 if (unformat (i, "vrf %d", &vrf_id))
9396 else if (unformat (i, "src %U", unformat_ip4_address, &src))
9398 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
9400 else if (unformat (i, "del"))
9404 clib_warning ("parse error '%U'", format_unformat_error, i);
9411 errmsg ("missing src addr");
9417 errmsg ("missing dst addr");
9421 M (OAM_ADD_DEL, mp);
9423 mp->vrf_id = ntohl (vrf_id);
9424 mp->is_add = is_add;
9425 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
9426 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
9434 api_reset_fib (vat_main_t * vam)
9436 unformat_input_t *i = vam->input;
9437 vl_api_reset_fib_t *mp;
9443 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9445 if (unformat (i, "vrf %d", &vrf_id))
9447 else if (unformat (i, "ipv6"))
9451 clib_warning ("parse error '%U'", format_unformat_error, i);
9456 if (vrf_id_set == 0)
9458 errmsg ("missing vrf id");
9464 mp->vrf_id = ntohl (vrf_id);
9465 mp->is_ipv6 = is_ipv6;
9473 api_dhcp_proxy_config (vat_main_t * vam)
9475 unformat_input_t *i = vam->input;
9476 vl_api_dhcp_proxy_config_t *mp;
9478 u32 server_vrf_id = 0;
9480 u8 v4_address_set = 0;
9481 u8 v6_address_set = 0;
9482 ip4_address_t v4address;
9483 ip6_address_t v6address;
9484 u8 v4_src_address_set = 0;
9485 u8 v6_src_address_set = 0;
9486 ip4_address_t v4srcaddress;
9487 ip6_address_t v6srcaddress;
9490 /* Parse args required to build the message */
9491 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9493 if (unformat (i, "del"))
9495 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
9497 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
9499 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
9501 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
9503 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
9504 v4_src_address_set = 1;
9505 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
9506 v6_src_address_set = 1;
9511 if (v4_address_set && v6_address_set)
9513 errmsg ("both v4 and v6 server addresses set");
9516 if (!v4_address_set && !v6_address_set)
9518 errmsg ("no server addresses set");
9522 if (v4_src_address_set && v6_src_address_set)
9524 errmsg ("both v4 and v6 src addresses set");
9527 if (!v4_src_address_set && !v6_src_address_set)
9529 errmsg ("no src addresses set");
9533 if (!(v4_src_address_set && v4_address_set) &&
9534 !(v6_src_address_set && v6_address_set))
9536 errmsg ("no matching server and src addresses set");
9540 /* Construct the API message */
9541 M (DHCP_PROXY_CONFIG, mp);
9543 mp->is_add = is_add;
9544 mp->rx_vrf_id = ntohl (rx_vrf_id);
9545 mp->server_vrf_id = ntohl (server_vrf_id);
9549 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
9550 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
9554 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
9555 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
9561 /* Wait for a reply, return good/bad news */
9566 #define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
9567 #define vl_api_dhcp_proxy_details_t_print vl_noop_handler
9570 vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
9572 vat_main_t *vam = &vat_main;
9573 u32 i, count = mp->count;
9574 vl_api_dhcp_server_t *s;
9578 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9579 "VSS VPN-ID '%s', VSS FIB-ID %d, VSS OUI %d",
9580 ntohl (mp->rx_vrf_id),
9581 format_ip6_address, mp->dhcp_src_address,
9582 mp->vss_type, mp->vss_vpn_ascii_id,
9583 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9586 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9587 "VSS VPN-ID '%s', VSS FIB-ID %d, VSS OUI %d",
9588 ntohl (mp->rx_vrf_id),
9589 format_ip4_address, mp->dhcp_src_address,
9590 mp->vss_type, mp->vss_vpn_ascii_id,
9591 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9593 for (i = 0; i < count; i++)
9595 s = &mp->servers[i];
9599 " Server Table-ID %d, Server Address %U",
9600 ntohl (s->server_vrf_id), format_ip6_address, s->dhcp_server);
9603 " Server Table-ID %d, Server Address %U",
9604 ntohl (s->server_vrf_id), format_ip4_address, s->dhcp_server);
9608 static void vl_api_dhcp_proxy_details_t_handler_json
9609 (vl_api_dhcp_proxy_details_t * mp)
9611 vat_main_t *vam = &vat_main;
9612 vat_json_node_t *node = NULL;
9613 u32 i, count = mp->count;
9615 struct in6_addr ip6;
9616 vl_api_dhcp_server_t *s;
9618 if (VAT_JSON_ARRAY != vam->json_tree.type)
9620 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9621 vat_json_init_array (&vam->json_tree);
9623 node = vat_json_array_add (&vam->json_tree);
9625 vat_json_init_object (node);
9626 vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
9627 vat_json_object_add_bytes (node, "vss-type", &mp->vss_type,
9628 sizeof (mp->vss_type));
9629 vat_json_object_add_string_copy (node, "vss-vpn-ascii-id",
9630 mp->vss_vpn_ascii_id);
9631 vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
9632 vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
9636 clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
9637 vat_json_object_add_ip6 (node, "src_address", ip6);
9641 clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
9642 vat_json_object_add_ip4 (node, "src_address", ip4);
9645 for (i = 0; i < count; i++)
9647 s = &mp->servers[i];
9649 vat_json_object_add_uint (node, "server-table-id",
9650 ntohl (s->server_vrf_id));
9654 clib_memcpy (&ip4, &s->dhcp_server, sizeof (ip4));
9655 vat_json_object_add_ip4 (node, "src_address", ip4);
9659 clib_memcpy (&ip6, &s->dhcp_server, sizeof (ip6));
9660 vat_json_object_add_ip6 (node, "server_address", ip6);
9666 api_dhcp_proxy_dump (vat_main_t * vam)
9668 unformat_input_t *i = vam->input;
9669 vl_api_control_ping_t *mp_ping;
9670 vl_api_dhcp_proxy_dump_t *mp;
9674 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9676 if (unformat (i, "ipv6"))
9680 clib_warning ("parse error '%U'", format_unformat_error, i);
9685 M (DHCP_PROXY_DUMP, mp);
9687 mp->is_ip6 = is_ipv6;
9690 /* Use a control ping for synchronization */
9691 MPING (CONTROL_PING, mp_ping);
9699 api_dhcp_proxy_set_vss (vat_main_t * vam)
9701 unformat_input_t *i = vam->input;
9702 vl_api_dhcp_proxy_set_vss_t *mp;
9706 u8 vss_type = VSS_TYPE_DEFAULT;
9707 u8 *vpn_ascii_id = 0;
9712 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9714 if (unformat (i, "tbl_id %d", &tbl_id))
9716 else if (unformat (i, "vpn_ascii_id %s", &vpn_ascii_id))
9717 vss_type = VSS_TYPE_ASCII;
9718 else if (unformat (i, "fib_id %d", &fib_id))
9719 vss_type = VSS_TYPE_VPN_ID;
9720 else if (unformat (i, "oui %d", &oui))
9721 vss_type = VSS_TYPE_VPN_ID;
9722 else if (unformat (i, "ipv6"))
9724 else if (unformat (i, "del"))
9732 errmsg ("missing tbl_id ");
9733 vec_free (vpn_ascii_id);
9737 if ((vpn_ascii_id) && (vec_len (vpn_ascii_id) > 128))
9739 errmsg ("vpn_ascii_id cannot be longer than 128 ");
9740 vec_free (vpn_ascii_id);
9744 M (DHCP_PROXY_SET_VSS, mp);
9745 mp->tbl_id = ntohl (tbl_id);
9746 mp->vss_type = vss_type;
9749 clib_memcpy (mp->vpn_ascii_id, vpn_ascii_id, vec_len (vpn_ascii_id));
9750 mp->vpn_ascii_id[vec_len (vpn_ascii_id)] = 0;
9752 mp->vpn_index = ntohl (fib_id);
9753 mp->oui = ntohl (oui);
9754 mp->is_ipv6 = is_ipv6;
9755 mp->is_add = is_add;
9760 vec_free (vpn_ascii_id);
9765 api_dhcp_client_config (vat_main_t * vam)
9767 unformat_input_t *i = vam->input;
9768 vl_api_dhcp_client_config_t *mp;
9770 u8 sw_if_index_set = 0;
9773 u8 disable_event = 0;
9776 /* Parse args required to build the message */
9777 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9779 if (unformat (i, "del"))
9782 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9783 sw_if_index_set = 1;
9784 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9785 sw_if_index_set = 1;
9786 else if (unformat (i, "hostname %s", &hostname))
9788 else if (unformat (i, "disable_event"))
9794 if (sw_if_index_set == 0)
9796 errmsg ("missing interface name or sw_if_index");
9800 if (vec_len (hostname) > 63)
9802 errmsg ("hostname too long");
9804 vec_add1 (hostname, 0);
9806 /* Construct the API message */
9807 M (DHCP_CLIENT_CONFIG, mp);
9809 mp->sw_if_index = htonl (sw_if_index);
9810 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
9811 vec_free (hostname);
9812 mp->is_add = is_add;
9813 mp->want_dhcp_event = disable_event ? 0 : 1;
9814 mp->pid = htonl (getpid ());
9819 /* Wait for a reply, return good/bad news */
9825 api_set_ip_flow_hash (vat_main_t * vam)
9827 unformat_input_t *i = vam->input;
9828 vl_api_set_ip_flow_hash_t *mp;
9840 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9842 if (unformat (i, "vrf %d", &vrf_id))
9844 else if (unformat (i, "ipv6"))
9846 else if (unformat (i, "src"))
9848 else if (unformat (i, "dst"))
9850 else if (unformat (i, "sport"))
9852 else if (unformat (i, "dport"))
9854 else if (unformat (i, "proto"))
9856 else if (unformat (i, "reverse"))
9861 clib_warning ("parse error '%U'", format_unformat_error, i);
9866 if (vrf_id_set == 0)
9868 errmsg ("missing vrf id");
9872 M (SET_IP_FLOW_HASH, mp);
9878 mp->reverse = reverse;
9879 mp->vrf_id = ntohl (vrf_id);
9880 mp->is_ipv6 = is_ipv6;
9888 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
9890 unformat_input_t *i = vam->input;
9891 vl_api_sw_interface_ip6_enable_disable_t *mp;
9893 u8 sw_if_index_set = 0;
9897 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9899 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9900 sw_if_index_set = 1;
9901 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9902 sw_if_index_set = 1;
9903 else if (unformat (i, "enable"))
9905 else if (unformat (i, "disable"))
9909 clib_warning ("parse error '%U'", format_unformat_error, i);
9914 if (sw_if_index_set == 0)
9916 errmsg ("missing interface name or sw_if_index");
9920 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
9922 mp->sw_if_index = ntohl (sw_if_index);
9923 mp->enable = enable;
9931 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
9933 unformat_input_t *i = vam->input;
9934 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
9936 u8 sw_if_index_set = 0;
9937 u8 v6_address_set = 0;
9938 ip6_address_t v6address;
9941 /* Parse args required to build the message */
9942 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9944 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9945 sw_if_index_set = 1;
9946 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9947 sw_if_index_set = 1;
9948 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
9954 if (sw_if_index_set == 0)
9956 errmsg ("missing interface name or sw_if_index");
9959 if (!v6_address_set)
9961 errmsg ("no address set");
9965 /* Construct the API message */
9966 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, mp);
9968 mp->sw_if_index = ntohl (sw_if_index);
9969 clib_memcpy (mp->address, &v6address, sizeof (v6address));
9974 /* Wait for a reply, return good/bad news */
9980 api_ip6nd_proxy_add_del (vat_main_t * vam)
9982 unformat_input_t *i = vam->input;
9983 vl_api_ip6nd_proxy_add_del_t *mp;
9984 u32 sw_if_index = ~0;
9985 u8 v6_address_set = 0;
9986 ip6_address_t v6address;
9990 /* Parse args required to build the message */
9991 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9993 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9995 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9997 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
9999 if (unformat (i, "del"))
10003 clib_warning ("parse error '%U'", format_unformat_error, i);
10008 if (sw_if_index == ~0)
10010 errmsg ("missing interface name or sw_if_index");
10013 if (!v6_address_set)
10015 errmsg ("no address set");
10019 /* Construct the API message */
10020 M (IP6ND_PROXY_ADD_DEL, mp);
10022 mp->is_del = is_del;
10023 mp->sw_if_index = ntohl (sw_if_index);
10024 clib_memcpy (mp->address, &v6address, sizeof (v6address));
10029 /* Wait for a reply, return good/bad news */
10035 api_ip6nd_proxy_dump (vat_main_t * vam)
10037 vl_api_ip6nd_proxy_dump_t *mp;
10038 vl_api_control_ping_t *mp_ping;
10041 M (IP6ND_PROXY_DUMP, mp);
10045 /* Use a control ping for synchronization */
10046 MPING (CONTROL_PING, mp_ping);
10053 static void vl_api_ip6nd_proxy_details_t_handler
10054 (vl_api_ip6nd_proxy_details_t * mp)
10056 vat_main_t *vam = &vat_main;
10058 print (vam->ofp, "host %U sw_if_index %d",
10059 format_ip6_address, mp->address, ntohl (mp->sw_if_index));
10062 static void vl_api_ip6nd_proxy_details_t_handler_json
10063 (vl_api_ip6nd_proxy_details_t * mp)
10065 vat_main_t *vam = &vat_main;
10066 struct in6_addr ip6;
10067 vat_json_node_t *node = NULL;
10069 if (VAT_JSON_ARRAY != vam->json_tree.type)
10071 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10072 vat_json_init_array (&vam->json_tree);
10074 node = vat_json_array_add (&vam->json_tree);
10076 vat_json_init_object (node);
10077 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10079 clib_memcpy (&ip6, mp->address, sizeof (ip6));
10080 vat_json_object_add_ip6 (node, "host", ip6);
10084 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
10086 unformat_input_t *i = vam->input;
10087 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
10089 u8 sw_if_index_set = 0;
10090 u32 address_length = 0;
10091 u8 v6_address_set = 0;
10092 ip6_address_t v6address;
10093 u8 use_default = 0;
10094 u8 no_advertise = 0;
10096 u8 no_autoconfig = 0;
10099 u32 val_lifetime = 0;
10100 u32 pref_lifetime = 0;
10103 /* Parse args required to build the message */
10104 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10106 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10107 sw_if_index_set = 1;
10108 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10109 sw_if_index_set = 1;
10110 else if (unformat (i, "%U/%d",
10111 unformat_ip6_address, &v6address, &address_length))
10112 v6_address_set = 1;
10113 else if (unformat (i, "val_life %d", &val_lifetime))
10115 else if (unformat (i, "pref_life %d", &pref_lifetime))
10117 else if (unformat (i, "def"))
10119 else if (unformat (i, "noadv"))
10121 else if (unformat (i, "offl"))
10123 else if (unformat (i, "noauto"))
10125 else if (unformat (i, "nolink"))
10127 else if (unformat (i, "isno"))
10131 clib_warning ("parse error '%U'", format_unformat_error, i);
10136 if (sw_if_index_set == 0)
10138 errmsg ("missing interface name or sw_if_index");
10141 if (!v6_address_set)
10143 errmsg ("no address set");
10147 /* Construct the API message */
10148 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
10150 mp->sw_if_index = ntohl (sw_if_index);
10151 clib_memcpy (mp->address, &v6address, sizeof (v6address));
10152 mp->address_length = address_length;
10153 mp->use_default = use_default;
10154 mp->no_advertise = no_advertise;
10155 mp->off_link = off_link;
10156 mp->no_autoconfig = no_autoconfig;
10157 mp->no_onlink = no_onlink;
10159 mp->val_lifetime = ntohl (val_lifetime);
10160 mp->pref_lifetime = ntohl (pref_lifetime);
10165 /* Wait for a reply, return good/bad news */
10171 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
10173 unformat_input_t *i = vam->input;
10174 vl_api_sw_interface_ip6nd_ra_config_t *mp;
10176 u8 sw_if_index_set = 0;
10181 u8 send_unicast = 0;
10184 u8 default_router = 0;
10185 u32 max_interval = 0;
10186 u32 min_interval = 0;
10188 u32 initial_count = 0;
10189 u32 initial_interval = 0;
10193 /* Parse args required to build the message */
10194 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10196 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10197 sw_if_index_set = 1;
10198 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10199 sw_if_index_set = 1;
10200 else if (unformat (i, "maxint %d", &max_interval))
10202 else if (unformat (i, "minint %d", &min_interval))
10204 else if (unformat (i, "life %d", &lifetime))
10206 else if (unformat (i, "count %d", &initial_count))
10208 else if (unformat (i, "interval %d", &initial_interval))
10210 else if (unformat (i, "suppress") || unformat (i, "surpress"))
10212 else if (unformat (i, "managed"))
10214 else if (unformat (i, "other"))
10216 else if (unformat (i, "ll"))
10218 else if (unformat (i, "send"))
10220 else if (unformat (i, "cease"))
10222 else if (unformat (i, "isno"))
10224 else if (unformat (i, "def"))
10225 default_router = 1;
10228 clib_warning ("parse error '%U'", format_unformat_error, i);
10233 if (sw_if_index_set == 0)
10235 errmsg ("missing interface name or sw_if_index");
10239 /* Construct the API message */
10240 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
10242 mp->sw_if_index = ntohl (sw_if_index);
10243 mp->max_interval = ntohl (max_interval);
10244 mp->min_interval = ntohl (min_interval);
10245 mp->lifetime = ntohl (lifetime);
10246 mp->initial_count = ntohl (initial_count);
10247 mp->initial_interval = ntohl (initial_interval);
10248 mp->suppress = suppress;
10249 mp->managed = managed;
10251 mp->ll_option = ll_option;
10252 mp->send_unicast = send_unicast;
10255 mp->default_router = default_router;
10260 /* Wait for a reply, return good/bad news */
10266 api_set_arp_neighbor_limit (vat_main_t * vam)
10268 unformat_input_t *i = vam->input;
10269 vl_api_set_arp_neighbor_limit_t *mp;
10275 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10277 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
10279 else if (unformat (i, "ipv6"))
10283 clib_warning ("parse error '%U'", format_unformat_error, i);
10288 if (limit_set == 0)
10290 errmsg ("missing limit value");
10294 M (SET_ARP_NEIGHBOR_LIMIT, mp);
10296 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
10297 mp->is_ipv6 = is_ipv6;
10305 api_l2_patch_add_del (vat_main_t * vam)
10307 unformat_input_t *i = vam->input;
10308 vl_api_l2_patch_add_del_t *mp;
10309 u32 rx_sw_if_index;
10310 u8 rx_sw_if_index_set = 0;
10311 u32 tx_sw_if_index;
10312 u8 tx_sw_if_index_set = 0;
10316 /* Parse args required to build the message */
10317 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10319 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
10320 rx_sw_if_index_set = 1;
10321 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
10322 tx_sw_if_index_set = 1;
10323 else if (unformat (i, "rx"))
10325 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10327 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10329 rx_sw_if_index_set = 1;
10334 else if (unformat (i, "tx"))
10336 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10338 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10340 tx_sw_if_index_set = 1;
10345 else if (unformat (i, "del"))
10351 if (rx_sw_if_index_set == 0)
10353 errmsg ("missing rx interface name or rx_sw_if_index");
10357 if (tx_sw_if_index_set == 0)
10359 errmsg ("missing tx interface name or tx_sw_if_index");
10363 M (L2_PATCH_ADD_DEL, mp);
10365 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
10366 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
10367 mp->is_add = is_add;
10375 u8 localsid_addr[16];
10384 api_sr_localsid_add_del (vat_main_t * vam)
10386 unformat_input_t *i = vam->input;
10387 vl_api_sr_localsid_add_del_t *mp;
10390 ip6_address_t localsid;
10394 u32 fib_table = ~(u32) 0;
10395 ip6_address_t next_hop;
10397 bool nexthop_set = 0;
10401 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10403 if (unformat (i, "del"))
10405 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
10406 else if (unformat (i, "next-hop %U", unformat_ip6_address, &next_hop))
10408 else if (unformat (i, "behavior %u", &behavior));
10409 else if (unformat (i, "sw_if_index %u", &sw_if_index));
10410 else if (unformat (i, "fib-table %u", &fib_table));
10411 else if (unformat (i, "end.psp %u", &behavior));
10416 M (SR_LOCALSID_ADD_DEL, mp);
10418 clib_memcpy (mp->localsid_addr, &localsid, sizeof (mp->localsid_addr));
10420 clib_memcpy (mp->nh_addr, &next_hop, sizeof (mp->nh_addr));
10421 mp->behavior = behavior;
10422 mp->sw_if_index = ntohl (sw_if_index);
10423 mp->fib_table = ntohl (fib_table);
10424 mp->end_psp = end_psp;
10425 mp->is_del = is_del;
10433 api_ioam_enable (vat_main_t * vam)
10435 unformat_input_t *input = vam->input;
10436 vl_api_ioam_enable_t *mp;
10438 int has_trace_option = 0;
10439 int has_pot_option = 0;
10440 int has_seqno_option = 0;
10441 int has_analyse_option = 0;
10444 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10446 if (unformat (input, "trace"))
10447 has_trace_option = 1;
10448 else if (unformat (input, "pot"))
10449 has_pot_option = 1;
10450 else if (unformat (input, "seqno"))
10451 has_seqno_option = 1;
10452 else if (unformat (input, "analyse"))
10453 has_analyse_option = 1;
10457 M (IOAM_ENABLE, mp);
10458 mp->id = htons (id);
10459 mp->seqno = has_seqno_option;
10460 mp->analyse = has_analyse_option;
10461 mp->pot_enable = has_pot_option;
10462 mp->trace_enable = has_trace_option;
10471 api_ioam_disable (vat_main_t * vam)
10473 vl_api_ioam_disable_t *mp;
10476 M (IOAM_DISABLE, mp);
10482 #define foreach_tcp_proto_field \
10486 #define foreach_udp_proto_field \
10490 #define foreach_ip4_proto_field \
10502 u16 src_port, dst_port;
10505 #if VPP_API_TEST_BUILTIN == 0
10507 unformat_tcp_mask (unformat_input_t * input, va_list * args)
10509 u8 **maskp = va_arg (*args, u8 **);
10511 u8 found_something = 0;
10514 #define _(a) u8 a=0;
10515 foreach_tcp_proto_field;
10518 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10521 #define _(a) else if (unformat (input, #a)) a=1;
10522 foreach_tcp_proto_field
10528 #define _(a) found_something += a;
10529 foreach_tcp_proto_field;
10532 if (found_something == 0)
10535 vec_validate (mask, sizeof (*tcp) - 1);
10537 tcp = (tcp_header_t *) mask;
10539 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
10540 foreach_tcp_proto_field;
10548 unformat_udp_mask (unformat_input_t * input, va_list * args)
10550 u8 **maskp = va_arg (*args, u8 **);
10552 u8 found_something = 0;
10555 #define _(a) u8 a=0;
10556 foreach_udp_proto_field;
10559 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10562 #define _(a) else if (unformat (input, #a)) a=1;
10563 foreach_udp_proto_field
10569 #define _(a) found_something += a;
10570 foreach_udp_proto_field;
10573 if (found_something == 0)
10576 vec_validate (mask, sizeof (*udp) - 1);
10578 udp = (udp_header_t *) mask;
10580 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
10581 foreach_udp_proto_field;
10589 unformat_l4_mask (unformat_input_t * input, va_list * args)
10591 u8 **maskp = va_arg (*args, u8 **);
10592 u16 src_port = 0, dst_port = 0;
10593 tcpudp_header_t *tcpudp;
10595 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10597 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
10599 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
10601 else if (unformat (input, "src_port"))
10603 else if (unformat (input, "dst_port"))
10609 if (!src_port && !dst_port)
10613 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
10615 tcpudp = (tcpudp_header_t *) mask;
10616 tcpudp->src_port = src_port;
10617 tcpudp->dst_port = dst_port;
10625 unformat_ip4_mask (unformat_input_t * input, va_list * args)
10627 u8 **maskp = va_arg (*args, u8 **);
10629 u8 found_something = 0;
10632 #define _(a) u8 a=0;
10633 foreach_ip4_proto_field;
10639 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10641 if (unformat (input, "version"))
10643 else if (unformat (input, "hdr_length"))
10645 else if (unformat (input, "src"))
10647 else if (unformat (input, "dst"))
10649 else if (unformat (input, "proto"))
10652 #define _(a) else if (unformat (input, #a)) a=1;
10653 foreach_ip4_proto_field
10659 #define _(a) found_something += a;
10660 foreach_ip4_proto_field;
10663 if (found_something == 0)
10666 vec_validate (mask, sizeof (*ip) - 1);
10668 ip = (ip4_header_t *) mask;
10670 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
10671 foreach_ip4_proto_field;
10674 ip->ip_version_and_header_length = 0;
10677 ip->ip_version_and_header_length |= 0xF0;
10680 ip->ip_version_and_header_length |= 0x0F;
10686 #define foreach_ip6_proto_field \
10689 _(payload_length) \
10694 unformat_ip6_mask (unformat_input_t * input, va_list * args)
10696 u8 **maskp = va_arg (*args, u8 **);
10698 u8 found_something = 0;
10700 u32 ip_version_traffic_class_and_flow_label;
10702 #define _(a) u8 a=0;
10703 foreach_ip6_proto_field;
10706 u8 traffic_class = 0;
10709 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10711 if (unformat (input, "version"))
10713 else if (unformat (input, "traffic-class"))
10715 else if (unformat (input, "flow-label"))
10717 else if (unformat (input, "src"))
10719 else if (unformat (input, "dst"))
10721 else if (unformat (input, "proto"))
10724 #define _(a) else if (unformat (input, #a)) a=1;
10725 foreach_ip6_proto_field
10731 #define _(a) found_something += a;
10732 foreach_ip6_proto_field;
10735 if (found_something == 0)
10738 vec_validate (mask, sizeof (*ip) - 1);
10740 ip = (ip6_header_t *) mask;
10742 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
10743 foreach_ip6_proto_field;
10746 ip_version_traffic_class_and_flow_label = 0;
10749 ip_version_traffic_class_and_flow_label |= 0xF0000000;
10752 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
10755 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
10757 ip->ip_version_traffic_class_and_flow_label =
10758 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10765 unformat_l3_mask (unformat_input_t * input, va_list * args)
10767 u8 **maskp = va_arg (*args, u8 **);
10769 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10771 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
10773 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
10782 unformat_l2_mask (unformat_input_t * input, va_list * args)
10784 u8 **maskp = va_arg (*args, u8 **);
10791 u8 ignore_tag1 = 0;
10792 u8 ignore_tag2 = 0;
10799 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10801 if (unformat (input, "src"))
10803 else if (unformat (input, "dst"))
10805 else if (unformat (input, "proto"))
10807 else if (unformat (input, "tag1"))
10809 else if (unformat (input, "tag2"))
10811 else if (unformat (input, "ignore-tag1"))
10813 else if (unformat (input, "ignore-tag2"))
10815 else if (unformat (input, "cos1"))
10817 else if (unformat (input, "cos2"))
10819 else if (unformat (input, "dot1q"))
10821 else if (unformat (input, "dot1ad"))
10826 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
10827 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10830 if (tag1 || ignore_tag1 || cos1 || dot1q)
10832 if (tag2 || ignore_tag2 || cos2 || dot1ad)
10835 vec_validate (mask, len - 1);
10838 memset (mask, 0xff, 6);
10841 memset (mask + 6, 0xff, 6);
10843 if (tag2 || dot1ad)
10845 /* inner vlan tag */
10854 mask[21] = mask[20] = 0xff;
10875 mask[16] = mask[17] = 0xff;
10885 mask[12] = mask[13] = 0xff;
10892 unformat_classify_mask (unformat_input_t * input, va_list * args)
10894 u8 **maskp = va_arg (*args, u8 **);
10895 u32 *skipp = va_arg (*args, u32 *);
10896 u32 *matchp = va_arg (*args, u32 *);
10904 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10906 if (unformat (input, "hex %U", unformat_hex_string, &mask))
10908 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
10910 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
10912 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
10926 if (mask || l2 || l3 || l4)
10928 if (l2 || l3 || l4)
10930 /* "With a free Ethernet header in every package" */
10932 vec_validate (l2, 13);
10936 vec_append (mask, l3);
10941 vec_append (mask, l4);
10946 /* Scan forward looking for the first significant mask octet */
10947 for (i = 0; i < vec_len (mask); i++)
10951 /* compute (skip, match) params */
10952 *skipp = i / sizeof (u32x4);
10953 vec_delete (mask, *skipp * sizeof (u32x4), 0);
10955 /* Pad mask to an even multiple of the vector size */
10956 while (vec_len (mask) % sizeof (u32x4))
10957 vec_add1 (mask, 0);
10959 match = vec_len (mask) / sizeof (u32x4);
10961 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
10963 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
10964 if (*tmp || *(tmp + 1))
10969 clib_warning ("BUG: match 0");
10971 _vec_len (mask) = match * sizeof (u32x4);
10981 #endif /* VPP_API_TEST_BUILTIN */
10983 #define foreach_l2_next \
10985 _(ethernet, ETHERNET_INPUT) \
10986 _(ip4, IP4_INPUT) \
10990 unformat_l2_next_index (unformat_input_t * input, va_list * args)
10992 u32 *miss_next_indexp = va_arg (*args, u32 *);
10993 u32 next_index = 0;
10997 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
11001 if (unformat (input, "%d", &tmp))
11010 *miss_next_indexp = next_index;
11014 #define foreach_ip_next \
11017 _(rewrite, REWRITE)
11020 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
11022 u32 *miss_next_indexp = va_arg (*args, u32 *);
11023 u32 next_index = 0;
11027 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
11031 if (unformat (input, "%d", &tmp))
11040 *miss_next_indexp = next_index;
11044 #define foreach_acl_next \
11048 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
11050 u32 *miss_next_indexp = va_arg (*args, u32 *);
11051 u32 next_index = 0;
11055 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
11059 if (unformat (input, "permit"))
11064 else if (unformat (input, "%d", &tmp))
11073 *miss_next_indexp = next_index;
11078 unformat_policer_precolor (unformat_input_t * input, va_list * args)
11080 u32 *r = va_arg (*args, u32 *);
11082 if (unformat (input, "conform-color"))
11083 *r = POLICE_CONFORM;
11084 else if (unformat (input, "exceed-color"))
11085 *r = POLICE_EXCEED;
11093 api_classify_add_del_table (vat_main_t * vam)
11095 unformat_input_t *i = vam->input;
11096 vl_api_classify_add_del_table_t *mp;
11103 u32 table_index = ~0;
11104 u32 next_table_index = ~0;
11105 u32 miss_next_index = ~0;
11106 u32 memory_size = 32 << 20;
11108 u32 current_data_flag = 0;
11109 int current_data_offset = 0;
11112 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11114 if (unformat (i, "del"))
11116 else if (unformat (i, "del-chain"))
11121 else if (unformat (i, "buckets %d", &nbuckets))
11123 else if (unformat (i, "memory_size %d", &memory_size))
11125 else if (unformat (i, "skip %d", &skip))
11127 else if (unformat (i, "match %d", &match))
11129 else if (unformat (i, "table %d", &table_index))
11131 else if (unformat (i, "mask %U", unformat_classify_mask,
11132 &mask, &skip, &match))
11134 else if (unformat (i, "next-table %d", &next_table_index))
11136 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
11139 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
11142 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
11145 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
11147 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
11153 if (is_add && mask == 0)
11155 errmsg ("Mask required");
11159 if (is_add && skip == ~0)
11161 errmsg ("skip count required");
11165 if (is_add && match == ~0)
11167 errmsg ("match count required");
11171 if (!is_add && table_index == ~0)
11173 errmsg ("table index required for delete");
11177 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
11179 mp->is_add = is_add;
11180 mp->del_chain = del_chain;
11181 mp->table_index = ntohl (table_index);
11182 mp->nbuckets = ntohl (nbuckets);
11183 mp->memory_size = ntohl (memory_size);
11184 mp->skip_n_vectors = ntohl (skip);
11185 mp->match_n_vectors = ntohl (match);
11186 mp->next_table_index = ntohl (next_table_index);
11187 mp->miss_next_index = ntohl (miss_next_index);
11188 mp->current_data_flag = ntohl (current_data_flag);
11189 mp->current_data_offset = ntohl (current_data_offset);
11190 clib_memcpy (mp->mask, mask, vec_len (mask));
11199 #if VPP_API_TEST_BUILTIN == 0
11201 unformat_l4_match (unformat_input_t * input, va_list * args)
11203 u8 **matchp = va_arg (*args, u8 **);
11205 u8 *proto_header = 0;
11211 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11213 if (unformat (input, "src_port %d", &src_port))
11215 else if (unformat (input, "dst_port %d", &dst_port))
11221 h.src_port = clib_host_to_net_u16 (src_port);
11222 h.dst_port = clib_host_to_net_u16 (dst_port);
11223 vec_validate (proto_header, sizeof (h) - 1);
11224 memcpy (proto_header, &h, sizeof (h));
11226 *matchp = proto_header;
11232 unformat_ip4_match (unformat_input_t * input, va_list * args)
11234 u8 **matchp = va_arg (*args, u8 **);
11239 int hdr_length = 0;
11240 u32 hdr_length_val;
11241 int src = 0, dst = 0;
11242 ip4_address_t src_val, dst_val;
11249 int fragment_id = 0;
11250 u32 fragment_id_val;
11256 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11258 if (unformat (input, "version %d", &version_val))
11260 else if (unformat (input, "hdr_length %d", &hdr_length_val))
11262 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
11264 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
11266 else if (unformat (input, "proto %d", &proto_val))
11268 else if (unformat (input, "tos %d", &tos_val))
11270 else if (unformat (input, "length %d", &length_val))
11272 else if (unformat (input, "fragment_id %d", &fragment_id_val))
11274 else if (unformat (input, "ttl %d", &ttl_val))
11276 else if (unformat (input, "checksum %d", &checksum_val))
11282 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
11283 + ttl + checksum == 0)
11287 * Aligned because we use the real comparison functions
11289 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11291 ip = (ip4_header_t *) match;
11293 /* These are realistically matched in practice */
11295 ip->src_address.as_u32 = src_val.as_u32;
11298 ip->dst_address.as_u32 = dst_val.as_u32;
11301 ip->protocol = proto_val;
11304 /* These are not, but they're included for completeness */
11306 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
11309 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
11315 ip->length = clib_host_to_net_u16 (length_val);
11321 ip->checksum = clib_host_to_net_u16 (checksum_val);
11328 unformat_ip6_match (unformat_input_t * input, va_list * args)
11330 u8 **matchp = va_arg (*args, u8 **);
11335 u8 traffic_class = 0;
11336 u32 traffic_class_val = 0;
11339 int src = 0, dst = 0;
11340 ip6_address_t src_val, dst_val;
11343 int payload_length = 0;
11344 u32 payload_length_val;
11347 u32 ip_version_traffic_class_and_flow_label;
11349 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11351 if (unformat (input, "version %d", &version_val))
11353 else if (unformat (input, "traffic_class %d", &traffic_class_val))
11355 else if (unformat (input, "flow_label %d", &flow_label_val))
11357 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
11359 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
11361 else if (unformat (input, "proto %d", &proto_val))
11363 else if (unformat (input, "payload_length %d", &payload_length_val))
11364 payload_length = 1;
11365 else if (unformat (input, "hop_limit %d", &hop_limit_val))
11371 if (version + traffic_class + flow_label + src + dst + proto +
11372 payload_length + hop_limit == 0)
11376 * Aligned because we use the real comparison functions
11378 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11380 ip = (ip6_header_t *) match;
11383 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
11386 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
11389 ip->protocol = proto_val;
11391 ip_version_traffic_class_and_flow_label = 0;
11394 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
11397 ip_version_traffic_class_and_flow_label |=
11398 (traffic_class_val & 0xFF) << 20;
11401 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
11403 ip->ip_version_traffic_class_and_flow_label =
11404 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
11406 if (payload_length)
11407 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
11410 ip->hop_limit = hop_limit_val;
11417 unformat_l3_match (unformat_input_t * input, va_list * args)
11419 u8 **matchp = va_arg (*args, u8 **);
11421 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11423 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
11425 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
11434 unformat_vlan_tag (unformat_input_t * input, va_list * args)
11436 u8 *tagp = va_arg (*args, u8 *);
11439 if (unformat (input, "%d", &tag))
11441 tagp[0] = (tag >> 8) & 0x0F;
11442 tagp[1] = tag & 0xFF;
11450 unformat_l2_match (unformat_input_t * input, va_list * args)
11452 u8 **matchp = va_arg (*args, u8 **);
11465 u8 ignore_tag1 = 0;
11466 u8 ignore_tag2 = 0;
11472 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11474 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
11477 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
11479 else if (unformat (input, "proto %U",
11480 unformat_ethernet_type_host_byte_order, &proto_val))
11482 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
11484 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
11486 else if (unformat (input, "ignore-tag1"))
11488 else if (unformat (input, "ignore-tag2"))
11490 else if (unformat (input, "cos1 %d", &cos1_val))
11492 else if (unformat (input, "cos2 %d", &cos2_val))
11497 if ((src + dst + proto + tag1 + tag2 +
11498 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
11501 if (tag1 || ignore_tag1 || cos1)
11503 if (tag2 || ignore_tag2 || cos2)
11506 vec_validate_aligned (match, len - 1, sizeof (u32x4));
11509 clib_memcpy (match, dst_val, 6);
11512 clib_memcpy (match + 6, src_val, 6);
11516 /* inner vlan tag */
11517 match[19] = tag2_val[1];
11518 match[18] = tag2_val[0];
11520 match[18] |= (cos2_val & 0x7) << 5;
11523 match[21] = proto_val & 0xff;
11524 match[20] = proto_val >> 8;
11528 match[15] = tag1_val[1];
11529 match[14] = tag1_val[0];
11532 match[14] |= (cos1_val & 0x7) << 5;
11538 match[15] = tag1_val[1];
11539 match[14] = tag1_val[0];
11542 match[17] = proto_val & 0xff;
11543 match[16] = proto_val >> 8;
11546 match[14] |= (cos1_val & 0x7) << 5;
11552 match[18] |= (cos2_val & 0x7) << 5;
11554 match[14] |= (cos1_val & 0x7) << 5;
11557 match[13] = proto_val & 0xff;
11558 match[12] = proto_val >> 8;
11567 api_unformat_classify_match (unformat_input_t * input, va_list * args)
11569 u8 **matchp = va_arg (*args, u8 **);
11570 u32 skip_n_vectors = va_arg (*args, u32);
11571 u32 match_n_vectors = va_arg (*args, u32);
11578 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11580 if (unformat (input, "hex %U", unformat_hex_string, &match))
11582 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
11584 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
11586 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
11600 if (match || l2 || l3 || l4)
11602 if (l2 || l3 || l4)
11604 /* "Win a free Ethernet header in every packet" */
11606 vec_validate_aligned (l2, 13, sizeof (u32x4));
11610 vec_append_aligned (match, l3, sizeof (u32x4));
11615 vec_append_aligned (match, l4, sizeof (u32x4));
11620 /* Make sure the vector is big enough even if key is all 0's */
11621 vec_validate_aligned
11622 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
11625 /* Set size, include skipped vectors */
11626 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
11637 api_classify_add_del_session (vat_main_t * vam)
11639 unformat_input_t *i = vam->input;
11640 vl_api_classify_add_del_session_t *mp;
11642 u32 table_index = ~0;
11643 u32 hit_next_index = ~0;
11644 u32 opaque_index = ~0;
11647 u32 skip_n_vectors = 0;
11648 u32 match_n_vectors = 0;
11654 * Warning: you have to supply skip_n and match_n
11655 * because the API client cant simply look at the classify
11659 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11661 if (unformat (i, "del"))
11663 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
11666 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
11669 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
11672 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
11674 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
11676 else if (unformat (i, "opaque-index %d", &opaque_index))
11678 else if (unformat (i, "skip_n %d", &skip_n_vectors))
11680 else if (unformat (i, "match_n %d", &match_n_vectors))
11682 else if (unformat (i, "match %U", api_unformat_classify_match,
11683 &match, skip_n_vectors, match_n_vectors))
11685 else if (unformat (i, "advance %d", &advance))
11687 else if (unformat (i, "table-index %d", &table_index))
11689 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
11691 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
11693 else if (unformat (i, "action %d", &action))
11695 else if (unformat (i, "metadata %d", &metadata))
11701 if (table_index == ~0)
11703 errmsg ("Table index required");
11707 if (is_add && match == 0)
11709 errmsg ("Match value required");
11713 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
11715 mp->is_add = is_add;
11716 mp->table_index = ntohl (table_index);
11717 mp->hit_next_index = ntohl (hit_next_index);
11718 mp->opaque_index = ntohl (opaque_index);
11719 mp->advance = ntohl (advance);
11720 mp->action = action;
11721 mp->metadata = ntohl (metadata);
11722 clib_memcpy (mp->match, match, vec_len (match));
11731 api_classify_set_interface_ip_table (vat_main_t * vam)
11733 unformat_input_t *i = vam->input;
11734 vl_api_classify_set_interface_ip_table_t *mp;
11736 int sw_if_index_set;
11737 u32 table_index = ~0;
11741 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11743 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11744 sw_if_index_set = 1;
11745 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11746 sw_if_index_set = 1;
11747 else if (unformat (i, "table %d", &table_index))
11751 clib_warning ("parse error '%U'", format_unformat_error, i);
11756 if (sw_if_index_set == 0)
11758 errmsg ("missing interface name or sw_if_index");
11763 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
11765 mp->sw_if_index = ntohl (sw_if_index);
11766 mp->table_index = ntohl (table_index);
11767 mp->is_ipv6 = is_ipv6;
11775 api_classify_set_interface_l2_tables (vat_main_t * vam)
11777 unformat_input_t *i = vam->input;
11778 vl_api_classify_set_interface_l2_tables_t *mp;
11780 int sw_if_index_set;
11781 u32 ip4_table_index = ~0;
11782 u32 ip6_table_index = ~0;
11783 u32 other_table_index = ~0;
11787 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11789 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11790 sw_if_index_set = 1;
11791 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11792 sw_if_index_set = 1;
11793 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11795 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11797 else if (unformat (i, "other-table %d", &other_table_index))
11799 else if (unformat (i, "is-input %d", &is_input))
11803 clib_warning ("parse error '%U'", format_unformat_error, i);
11808 if (sw_if_index_set == 0)
11810 errmsg ("missing interface name or sw_if_index");
11815 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
11817 mp->sw_if_index = ntohl (sw_if_index);
11818 mp->ip4_table_index = ntohl (ip4_table_index);
11819 mp->ip6_table_index = ntohl (ip6_table_index);
11820 mp->other_table_index = ntohl (other_table_index);
11821 mp->is_input = (u8) is_input;
11829 api_set_ipfix_exporter (vat_main_t * vam)
11831 unformat_input_t *i = vam->input;
11832 vl_api_set_ipfix_exporter_t *mp;
11833 ip4_address_t collector_address;
11834 u8 collector_address_set = 0;
11835 u32 collector_port = ~0;
11836 ip4_address_t src_address;
11837 u8 src_address_set = 0;
11840 u32 template_interval = ~0;
11841 u8 udp_checksum = 0;
11844 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11846 if (unformat (i, "collector_address %U", unformat_ip4_address,
11847 &collector_address))
11848 collector_address_set = 1;
11849 else if (unformat (i, "collector_port %d", &collector_port))
11851 else if (unformat (i, "src_address %U", unformat_ip4_address,
11853 src_address_set = 1;
11854 else if (unformat (i, "vrf_id %d", &vrf_id))
11856 else if (unformat (i, "path_mtu %d", &path_mtu))
11858 else if (unformat (i, "template_interval %d", &template_interval))
11860 else if (unformat (i, "udp_checksum"))
11866 if (collector_address_set == 0)
11868 errmsg ("collector_address required");
11872 if (src_address_set == 0)
11874 errmsg ("src_address required");
11878 M (SET_IPFIX_EXPORTER, mp);
11880 memcpy (mp->collector_address, collector_address.data,
11881 sizeof (collector_address.data));
11882 mp->collector_port = htons ((u16) collector_port);
11883 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
11884 mp->vrf_id = htonl (vrf_id);
11885 mp->path_mtu = htonl (path_mtu);
11886 mp->template_interval = htonl (template_interval);
11887 mp->udp_checksum = udp_checksum;
11895 api_set_ipfix_classify_stream (vat_main_t * vam)
11897 unformat_input_t *i = vam->input;
11898 vl_api_set_ipfix_classify_stream_t *mp;
11900 u32 src_port = UDP_DST_PORT_ipfix;
11903 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11905 if (unformat (i, "domain %d", &domain_id))
11907 else if (unformat (i, "src_port %d", &src_port))
11911 errmsg ("unknown input `%U'", format_unformat_error, i);
11916 M (SET_IPFIX_CLASSIFY_STREAM, mp);
11918 mp->domain_id = htonl (domain_id);
11919 mp->src_port = htons ((u16) src_port);
11927 api_ipfix_classify_table_add_del (vat_main_t * vam)
11929 unformat_input_t *i = vam->input;
11930 vl_api_ipfix_classify_table_add_del_t *mp;
11932 u32 classify_table_index = ~0;
11934 u8 transport_protocol = 255;
11937 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11939 if (unformat (i, "add"))
11941 else if (unformat (i, "del"))
11943 else if (unformat (i, "table %d", &classify_table_index))
11945 else if (unformat (i, "ip4"))
11947 else if (unformat (i, "ip6"))
11949 else if (unformat (i, "tcp"))
11950 transport_protocol = 6;
11951 else if (unformat (i, "udp"))
11952 transport_protocol = 17;
11955 errmsg ("unknown input `%U'", format_unformat_error, i);
11962 errmsg ("expecting: add|del");
11965 if (classify_table_index == ~0)
11967 errmsg ("classifier table not specified");
11970 if (ip_version == 0)
11972 errmsg ("IP version not specified");
11976 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
11978 mp->is_add = is_add;
11979 mp->table_id = htonl (classify_table_index);
11980 mp->ip_version = ip_version;
11981 mp->transport_protocol = transport_protocol;
11989 api_get_node_index (vat_main_t * vam)
11991 unformat_input_t *i = vam->input;
11992 vl_api_get_node_index_t *mp;
11996 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11998 if (unformat (i, "node %s", &name))
12005 errmsg ("node name required");
12008 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
12010 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12014 M (GET_NODE_INDEX, mp);
12015 clib_memcpy (mp->node_name, name, vec_len (name));
12024 api_get_next_index (vat_main_t * vam)
12026 unformat_input_t *i = vam->input;
12027 vl_api_get_next_index_t *mp;
12028 u8 *node_name = 0, *next_node_name = 0;
12031 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12033 if (unformat (i, "node-name %s", &node_name))
12035 else if (unformat (i, "next-node-name %s", &next_node_name))
12039 if (node_name == 0)
12041 errmsg ("node name required");
12044 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
12046 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12050 if (next_node_name == 0)
12052 errmsg ("next node name required");
12055 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
12057 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
12061 M (GET_NEXT_INDEX, mp);
12062 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
12063 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
12064 vec_free (node_name);
12065 vec_free (next_node_name);
12073 api_add_node_next (vat_main_t * vam)
12075 unformat_input_t *i = vam->input;
12076 vl_api_add_node_next_t *mp;
12081 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12083 if (unformat (i, "node %s", &name))
12085 else if (unformat (i, "next %s", &next))
12092 errmsg ("node name required");
12095 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
12097 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12102 errmsg ("next node required");
12105 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
12107 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
12111 M (ADD_NODE_NEXT, mp);
12112 clib_memcpy (mp->node_name, name, vec_len (name));
12113 clib_memcpy (mp->next_name, next, vec_len (next));
12123 api_l2tpv3_create_tunnel (vat_main_t * vam)
12125 unformat_input_t *i = vam->input;
12126 ip6_address_t client_address, our_address;
12127 int client_address_set = 0;
12128 int our_address_set = 0;
12129 u32 local_session_id = 0;
12130 u32 remote_session_id = 0;
12131 u64 local_cookie = 0;
12132 u64 remote_cookie = 0;
12133 u8 l2_sublayer_present = 0;
12134 vl_api_l2tpv3_create_tunnel_t *mp;
12137 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12139 if (unformat (i, "client_address %U", unformat_ip6_address,
12141 client_address_set = 1;
12142 else if (unformat (i, "our_address %U", unformat_ip6_address,
12144 our_address_set = 1;
12145 else if (unformat (i, "local_session_id %d", &local_session_id))
12147 else if (unformat (i, "remote_session_id %d", &remote_session_id))
12149 else if (unformat (i, "local_cookie %lld", &local_cookie))
12151 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
12153 else if (unformat (i, "l2-sublayer-present"))
12154 l2_sublayer_present = 1;
12159 if (client_address_set == 0)
12161 errmsg ("client_address required");
12165 if (our_address_set == 0)
12167 errmsg ("our_address required");
12171 M (L2TPV3_CREATE_TUNNEL, mp);
12173 clib_memcpy (mp->client_address, client_address.as_u8,
12174 sizeof (mp->client_address));
12176 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
12178 mp->local_session_id = ntohl (local_session_id);
12179 mp->remote_session_id = ntohl (remote_session_id);
12180 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
12181 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
12182 mp->l2_sublayer_present = l2_sublayer_present;
12191 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
12193 unformat_input_t *i = vam->input;
12195 u8 sw_if_index_set = 0;
12196 u64 new_local_cookie = 0;
12197 u64 new_remote_cookie = 0;
12198 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
12201 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12203 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12204 sw_if_index_set = 1;
12205 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12206 sw_if_index_set = 1;
12207 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
12209 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
12215 if (sw_if_index_set == 0)
12217 errmsg ("missing interface name or sw_if_index");
12221 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
12223 mp->sw_if_index = ntohl (sw_if_index);
12224 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
12225 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
12233 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
12235 unformat_input_t *i = vam->input;
12236 vl_api_l2tpv3_interface_enable_disable_t *mp;
12238 u8 sw_if_index_set = 0;
12239 u8 enable_disable = 1;
12242 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12244 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12245 sw_if_index_set = 1;
12246 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12247 sw_if_index_set = 1;
12248 else if (unformat (i, "enable"))
12249 enable_disable = 1;
12250 else if (unformat (i, "disable"))
12251 enable_disable = 0;
12256 if (sw_if_index_set == 0)
12258 errmsg ("missing interface name or sw_if_index");
12262 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
12264 mp->sw_if_index = ntohl (sw_if_index);
12265 mp->enable_disable = enable_disable;
12273 api_l2tpv3_set_lookup_key (vat_main_t * vam)
12275 unformat_input_t *i = vam->input;
12276 vl_api_l2tpv3_set_lookup_key_t *mp;
12280 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12282 if (unformat (i, "lookup_v6_src"))
12283 key = L2T_LOOKUP_SRC_ADDRESS;
12284 else if (unformat (i, "lookup_v6_dst"))
12285 key = L2T_LOOKUP_DST_ADDRESS;
12286 else if (unformat (i, "lookup_session_id"))
12287 key = L2T_LOOKUP_SESSION_ID;
12292 if (key == (u8) ~ 0)
12294 errmsg ("l2tp session lookup key unset");
12298 M (L2TPV3_SET_LOOKUP_KEY, mp);
12307 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
12308 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12310 vat_main_t *vam = &vat_main;
12312 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
12313 format_ip6_address, mp->our_address,
12314 format_ip6_address, mp->client_address,
12315 clib_net_to_host_u32 (mp->sw_if_index));
12318 " local cookies %016llx %016llx remote cookie %016llx",
12319 clib_net_to_host_u64 (mp->local_cookie[0]),
12320 clib_net_to_host_u64 (mp->local_cookie[1]),
12321 clib_net_to_host_u64 (mp->remote_cookie));
12323 print (vam->ofp, " local session-id %d remote session-id %d",
12324 clib_net_to_host_u32 (mp->local_session_id),
12325 clib_net_to_host_u32 (mp->remote_session_id));
12327 print (vam->ofp, " l2 specific sublayer %s\n",
12328 mp->l2_sublayer_present ? "preset" : "absent");
12332 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
12333 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12335 vat_main_t *vam = &vat_main;
12336 vat_json_node_t *node = NULL;
12337 struct in6_addr addr;
12339 if (VAT_JSON_ARRAY != vam->json_tree.type)
12341 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12342 vat_json_init_array (&vam->json_tree);
12344 node = vat_json_array_add (&vam->json_tree);
12346 vat_json_init_object (node);
12348 clib_memcpy (&addr, mp->our_address, sizeof (addr));
12349 vat_json_object_add_ip6 (node, "our_address", addr);
12350 clib_memcpy (&addr, mp->client_address, sizeof (addr));
12351 vat_json_object_add_ip6 (node, "client_address", addr);
12353 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
12354 vat_json_init_array (lc);
12355 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
12356 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
12357 vat_json_object_add_uint (node, "remote_cookie",
12358 clib_net_to_host_u64 (mp->remote_cookie));
12360 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
12361 vat_json_object_add_uint (node, "local_session_id",
12362 clib_net_to_host_u32 (mp->local_session_id));
12363 vat_json_object_add_uint (node, "remote_session_id",
12364 clib_net_to_host_u32 (mp->remote_session_id));
12365 vat_json_object_add_string_copy (node, "l2_sublayer",
12366 mp->l2_sublayer_present ? (u8 *) "present"
12367 : (u8 *) "absent");
12371 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
12373 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
12374 vl_api_control_ping_t *mp_ping;
12377 /* Get list of l2tpv3-tunnel interfaces */
12378 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
12381 /* Use a control ping for synchronization */
12382 MPING (CONTROL_PING, mp_ping);
12390 static void vl_api_sw_interface_tap_details_t_handler
12391 (vl_api_sw_interface_tap_details_t * mp)
12393 vat_main_t *vam = &vat_main;
12395 print (vam->ofp, "%-16s %d",
12396 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
12399 static void vl_api_sw_interface_tap_details_t_handler_json
12400 (vl_api_sw_interface_tap_details_t * mp)
12402 vat_main_t *vam = &vat_main;
12403 vat_json_node_t *node = NULL;
12405 if (VAT_JSON_ARRAY != vam->json_tree.type)
12407 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12408 vat_json_init_array (&vam->json_tree);
12410 node = vat_json_array_add (&vam->json_tree);
12412 vat_json_init_object (node);
12413 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12414 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
12418 api_sw_interface_tap_dump (vat_main_t * vam)
12420 vl_api_sw_interface_tap_dump_t *mp;
12421 vl_api_control_ping_t *mp_ping;
12424 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
12425 /* Get list of tap interfaces */
12426 M (SW_INTERFACE_TAP_DUMP, mp);
12429 /* Use a control ping for synchronization */
12430 MPING (CONTROL_PING, mp_ping);
12437 static void vl_api_sw_interface_tap_v2_details_t_handler
12438 (vl_api_sw_interface_tap_v2_details_t * mp)
12440 vat_main_t *vam = &vat_main;
12442 u8 *ip4 = format (0, "%U/%d", format_ip4_address, mp->host_ip4_addr,
12443 mp->host_ip4_prefix_len);
12444 u8 *ip6 = format (0, "%U/%d", format_ip6_address, mp->host_ip6_addr,
12445 mp->host_ip6_prefix_len);
12448 "\n%-16s %-12d %-5d %-12d %-12d %-14U %-30s %-20s %-20s %-30s",
12449 mp->dev_name, ntohl (mp->sw_if_index), ntohl (mp->id),
12450 ntohs (mp->rx_ring_sz), ntohs (mp->tx_ring_sz),
12451 format_ethernet_address, mp->host_mac_addr, mp->host_namespace,
12452 mp->host_bridge, ip4, ip6);
12458 static void vl_api_sw_interface_tap_v2_details_t_handler_json
12459 (vl_api_sw_interface_tap_v2_details_t * mp)
12461 vat_main_t *vam = &vat_main;
12462 vat_json_node_t *node = NULL;
12464 if (VAT_JSON_ARRAY != vam->json_tree.type)
12466 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12467 vat_json_init_array (&vam->json_tree);
12469 node = vat_json_array_add (&vam->json_tree);
12471 vat_json_init_object (node);
12472 vat_json_object_add_uint (node, "id", ntohl (mp->id));
12473 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12474 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
12475 vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
12476 vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
12477 vat_json_object_add_string_copy (node, "host_mac_addr",
12478 format (0, "%U", format_ethernet_address,
12479 &mp->host_mac_addr));
12480 vat_json_object_add_string_copy (node, "host_namespace",
12481 mp->host_namespace);
12482 vat_json_object_add_string_copy (node, "host_bridge", mp->host_bridge);
12483 vat_json_object_add_string_copy (node, "host_ip4_addr",
12484 format (0, "%U/%d", format_ip4_address,
12486 mp->host_ip4_prefix_len));
12487 vat_json_object_add_string_copy (node, "host_ip6_addr",
12488 format (0, "%U/%d", format_ip6_address,
12490 mp->host_ip6_prefix_len));
12495 api_sw_interface_tap_v2_dump (vat_main_t * vam)
12497 vl_api_sw_interface_tap_v2_dump_t *mp;
12498 vl_api_control_ping_t *mp_ping;
12502 "\n%-16s %-12s %-5s %-12s %-12s %-14s %-30s %-20s %-20s %-30s",
12503 "dev_name", "sw_if_index", "id", "rx_ring_sz", "tx_ring_sz",
12504 "host_mac_addr", "host_namespace", "host_bridge", "host_ip4_addr",
12507 /* Get list of tap interfaces */
12508 M (SW_INTERFACE_TAP_V2_DUMP, mp);
12511 /* Use a control ping for synchronization */
12512 MPING (CONTROL_PING, mp_ping);
12519 static uword unformat_vxlan_decap_next
12520 (unformat_input_t * input, va_list * args)
12522 u32 *result = va_arg (*args, u32 *);
12525 if (unformat (input, "l2"))
12526 *result = VXLAN_INPUT_NEXT_L2_INPUT;
12527 else if (unformat (input, "%d", &tmp))
12535 api_vxlan_add_del_tunnel (vat_main_t * vam)
12537 unformat_input_t *line_input = vam->input;
12538 vl_api_vxlan_add_del_tunnel_t *mp;
12539 ip46_address_t src, dst;
12541 u8 ipv4_set = 0, ipv6_set = 0;
12545 u32 mcast_sw_if_index = ~0;
12546 u32 encap_vrf_id = 0;
12547 u32 decap_next_index = ~0;
12551 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12552 memset (&src, 0, sizeof src);
12553 memset (&dst, 0, sizeof dst);
12555 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12557 if (unformat (line_input, "del"))
12560 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12566 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12572 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12578 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12583 else if (unformat (line_input, "group %U %U",
12584 unformat_ip4_address, &dst.ip4,
12585 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12587 grp_set = dst_set = 1;
12590 else if (unformat (line_input, "group %U",
12591 unformat_ip4_address, &dst.ip4))
12593 grp_set = dst_set = 1;
12596 else if (unformat (line_input, "group %U %U",
12597 unformat_ip6_address, &dst.ip6,
12598 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12600 grp_set = dst_set = 1;
12603 else if (unformat (line_input, "group %U",
12604 unformat_ip6_address, &dst.ip6))
12606 grp_set = dst_set = 1;
12610 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12612 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12614 else if (unformat (line_input, "decap-next %U",
12615 unformat_vxlan_decap_next, &decap_next_index))
12617 else if (unformat (line_input, "vni %d", &vni))
12621 errmsg ("parse error '%U'", format_unformat_error, line_input);
12628 errmsg ("tunnel src address not specified");
12633 errmsg ("tunnel dst address not specified");
12637 if (grp_set && !ip46_address_is_multicast (&dst))
12639 errmsg ("tunnel group address not multicast");
12642 if (grp_set && mcast_sw_if_index == ~0)
12644 errmsg ("tunnel nonexistent multicast device");
12647 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12649 errmsg ("tunnel dst address must be unicast");
12654 if (ipv4_set && ipv6_set)
12656 errmsg ("both IPv4 and IPv6 addresses specified");
12660 if ((vni == 0) || (vni >> 24))
12662 errmsg ("vni not specified or out of range");
12666 M (VXLAN_ADD_DEL_TUNNEL, mp);
12670 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
12671 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
12675 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
12676 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
12678 mp->encap_vrf_id = ntohl (encap_vrf_id);
12679 mp->decap_next_index = ntohl (decap_next_index);
12680 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12681 mp->vni = ntohl (vni);
12682 mp->is_add = is_add;
12683 mp->is_ipv6 = ipv6_set;
12690 static void vl_api_vxlan_tunnel_details_t_handler
12691 (vl_api_vxlan_tunnel_details_t * mp)
12693 vat_main_t *vam = &vat_main;
12694 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12695 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12697 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12698 ntohl (mp->sw_if_index),
12699 format_ip46_address, &src, IP46_TYPE_ANY,
12700 format_ip46_address, &dst, IP46_TYPE_ANY,
12701 ntohl (mp->encap_vrf_id),
12702 ntohl (mp->decap_next_index), ntohl (mp->vni),
12703 ntohl (mp->mcast_sw_if_index));
12706 static void vl_api_vxlan_tunnel_details_t_handler_json
12707 (vl_api_vxlan_tunnel_details_t * mp)
12709 vat_main_t *vam = &vat_main;
12710 vat_json_node_t *node = NULL;
12712 if (VAT_JSON_ARRAY != vam->json_tree.type)
12714 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12715 vat_json_init_array (&vam->json_tree);
12717 node = vat_json_array_add (&vam->json_tree);
12719 vat_json_init_object (node);
12720 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12723 struct in6_addr ip6;
12725 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12726 vat_json_object_add_ip6 (node, "src_address", ip6);
12727 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12728 vat_json_object_add_ip6 (node, "dst_address", ip6);
12732 struct in_addr ip4;
12734 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12735 vat_json_object_add_ip4 (node, "src_address", ip4);
12736 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12737 vat_json_object_add_ip4 (node, "dst_address", ip4);
12739 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12740 vat_json_object_add_uint (node, "decap_next_index",
12741 ntohl (mp->decap_next_index));
12742 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12743 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12744 vat_json_object_add_uint (node, "mcast_sw_if_index",
12745 ntohl (mp->mcast_sw_if_index));
12749 api_vxlan_tunnel_dump (vat_main_t * vam)
12751 unformat_input_t *i = vam->input;
12752 vl_api_vxlan_tunnel_dump_t *mp;
12753 vl_api_control_ping_t *mp_ping;
12755 u8 sw_if_index_set = 0;
12758 /* Parse args required to build the message */
12759 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12761 if (unformat (i, "sw_if_index %d", &sw_if_index))
12762 sw_if_index_set = 1;
12767 if (sw_if_index_set == 0)
12772 if (!vam->json_output)
12774 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12775 "sw_if_index", "src_address", "dst_address",
12776 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12779 /* Get list of vxlan-tunnel interfaces */
12780 M (VXLAN_TUNNEL_DUMP, mp);
12782 mp->sw_if_index = htonl (sw_if_index);
12786 /* Use a control ping for synchronization */
12787 MPING (CONTROL_PING, mp_ping);
12794 static uword unformat_geneve_decap_next
12795 (unformat_input_t * input, va_list * args)
12797 u32 *result = va_arg (*args, u32 *);
12800 if (unformat (input, "l2"))
12801 *result = GENEVE_INPUT_NEXT_L2_INPUT;
12802 else if (unformat (input, "%d", &tmp))
12810 api_geneve_add_del_tunnel (vat_main_t * vam)
12812 unformat_input_t *line_input = vam->input;
12813 vl_api_geneve_add_del_tunnel_t *mp;
12814 ip46_address_t src, dst;
12816 u8 ipv4_set = 0, ipv6_set = 0;
12820 u32 mcast_sw_if_index = ~0;
12821 u32 encap_vrf_id = 0;
12822 u32 decap_next_index = ~0;
12826 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12827 memset (&src, 0, sizeof src);
12828 memset (&dst, 0, sizeof dst);
12830 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12832 if (unformat (line_input, "del"))
12835 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12841 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12847 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12853 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12858 else if (unformat (line_input, "group %U %U",
12859 unformat_ip4_address, &dst.ip4,
12860 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12862 grp_set = dst_set = 1;
12865 else if (unformat (line_input, "group %U",
12866 unformat_ip4_address, &dst.ip4))
12868 grp_set = dst_set = 1;
12871 else if (unformat (line_input, "group %U %U",
12872 unformat_ip6_address, &dst.ip6,
12873 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12875 grp_set = dst_set = 1;
12878 else if (unformat (line_input, "group %U",
12879 unformat_ip6_address, &dst.ip6))
12881 grp_set = dst_set = 1;
12885 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12887 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12889 else if (unformat (line_input, "decap-next %U",
12890 unformat_geneve_decap_next, &decap_next_index))
12892 else if (unformat (line_input, "vni %d", &vni))
12896 errmsg ("parse error '%U'", format_unformat_error, line_input);
12903 errmsg ("tunnel src address not specified");
12908 errmsg ("tunnel dst address not specified");
12912 if (grp_set && !ip46_address_is_multicast (&dst))
12914 errmsg ("tunnel group address not multicast");
12917 if (grp_set && mcast_sw_if_index == ~0)
12919 errmsg ("tunnel nonexistent multicast device");
12922 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12924 errmsg ("tunnel dst address must be unicast");
12929 if (ipv4_set && ipv6_set)
12931 errmsg ("both IPv4 and IPv6 addresses specified");
12935 if ((vni == 0) || (vni >> 24))
12937 errmsg ("vni not specified or out of range");
12941 M (GENEVE_ADD_DEL_TUNNEL, mp);
12945 clib_memcpy (mp->local_address, &src.ip6, sizeof (src.ip6));
12946 clib_memcpy (mp->remote_address, &dst.ip6, sizeof (dst.ip6));
12950 clib_memcpy (mp->local_address, &src.ip4, sizeof (src.ip4));
12951 clib_memcpy (mp->remote_address, &dst.ip4, sizeof (dst.ip4));
12953 mp->encap_vrf_id = ntohl (encap_vrf_id);
12954 mp->decap_next_index = ntohl (decap_next_index);
12955 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12956 mp->vni = ntohl (vni);
12957 mp->is_add = is_add;
12958 mp->is_ipv6 = ipv6_set;
12965 static void vl_api_geneve_tunnel_details_t_handler
12966 (vl_api_geneve_tunnel_details_t * mp)
12968 vat_main_t *vam = &vat_main;
12969 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12970 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12972 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12973 ntohl (mp->sw_if_index),
12974 format_ip46_address, &src, IP46_TYPE_ANY,
12975 format_ip46_address, &dst, IP46_TYPE_ANY,
12976 ntohl (mp->encap_vrf_id),
12977 ntohl (mp->decap_next_index), ntohl (mp->vni),
12978 ntohl (mp->mcast_sw_if_index));
12981 static void vl_api_geneve_tunnel_details_t_handler_json
12982 (vl_api_geneve_tunnel_details_t * mp)
12984 vat_main_t *vam = &vat_main;
12985 vat_json_node_t *node = NULL;
12987 if (VAT_JSON_ARRAY != vam->json_tree.type)
12989 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12990 vat_json_init_array (&vam->json_tree);
12992 node = vat_json_array_add (&vam->json_tree);
12994 vat_json_init_object (node);
12995 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12998 struct in6_addr ip6;
13000 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
13001 vat_json_object_add_ip6 (node, "src_address", ip6);
13002 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
13003 vat_json_object_add_ip6 (node, "dst_address", ip6);
13007 struct in_addr ip4;
13009 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
13010 vat_json_object_add_ip4 (node, "src_address", ip4);
13011 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
13012 vat_json_object_add_ip4 (node, "dst_address", ip4);
13014 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
13015 vat_json_object_add_uint (node, "decap_next_index",
13016 ntohl (mp->decap_next_index));
13017 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
13018 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
13019 vat_json_object_add_uint (node, "mcast_sw_if_index",
13020 ntohl (mp->mcast_sw_if_index));
13024 api_geneve_tunnel_dump (vat_main_t * vam)
13026 unformat_input_t *i = vam->input;
13027 vl_api_geneve_tunnel_dump_t *mp;
13028 vl_api_control_ping_t *mp_ping;
13030 u8 sw_if_index_set = 0;
13033 /* Parse args required to build the message */
13034 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13036 if (unformat (i, "sw_if_index %d", &sw_if_index))
13037 sw_if_index_set = 1;
13042 if (sw_if_index_set == 0)
13047 if (!vam->json_output)
13049 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
13050 "sw_if_index", "local_address", "remote_address",
13051 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
13054 /* Get list of geneve-tunnel interfaces */
13055 M (GENEVE_TUNNEL_DUMP, mp);
13057 mp->sw_if_index = htonl (sw_if_index);
13061 /* Use a control ping for synchronization */
13062 M (CONTROL_PING, mp_ping);
13070 api_gre_add_del_tunnel (vat_main_t * vam)
13072 unformat_input_t *line_input = vam->input;
13073 vl_api_gre_add_del_tunnel_t *mp;
13074 ip4_address_t src4, dst4;
13075 ip6_address_t src6, dst6;
13082 u32 outer_fib_id = 0;
13085 memset (&src4, 0, sizeof src4);
13086 memset (&dst4, 0, sizeof dst4);
13087 memset (&src6, 0, sizeof src6);
13088 memset (&dst6, 0, sizeof dst6);
13090 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13092 if (unformat (line_input, "del"))
13094 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
13099 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
13104 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
13109 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
13114 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
13116 else if (unformat (line_input, "teb"))
13120 errmsg ("parse error '%U'", format_unformat_error, line_input);
13127 errmsg ("tunnel src address not specified");
13132 errmsg ("tunnel dst address not specified");
13135 if (ipv4_set && ipv6_set)
13137 errmsg ("both IPv4 and IPv6 addresses specified");
13142 M (GRE_ADD_DEL_TUNNEL, mp);
13146 clib_memcpy (&mp->src_address, &src4, 4);
13147 clib_memcpy (&mp->dst_address, &dst4, 4);
13151 clib_memcpy (&mp->src_address, &src6, 16);
13152 clib_memcpy (&mp->dst_address, &dst6, 16);
13154 mp->outer_fib_id = ntohl (outer_fib_id);
13155 mp->is_add = is_add;
13157 mp->is_ipv6 = ipv6_set;
13164 static void vl_api_gre_tunnel_details_t_handler
13165 (vl_api_gre_tunnel_details_t * mp)
13167 vat_main_t *vam = &vat_main;
13168 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->src_address);
13169 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->dst_address);
13171 print (vam->ofp, "%11d%24U%24U%6d%14d",
13172 ntohl (mp->sw_if_index),
13173 format_ip46_address, &src, IP46_TYPE_ANY,
13174 format_ip46_address, &dst, IP46_TYPE_ANY,
13175 mp->teb, ntohl (mp->outer_fib_id));
13178 static void vl_api_gre_tunnel_details_t_handler_json
13179 (vl_api_gre_tunnel_details_t * mp)
13181 vat_main_t *vam = &vat_main;
13182 vat_json_node_t *node = NULL;
13183 struct in_addr ip4;
13184 struct in6_addr ip6;
13186 if (VAT_JSON_ARRAY != vam->json_tree.type)
13188 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13189 vat_json_init_array (&vam->json_tree);
13191 node = vat_json_array_add (&vam->json_tree);
13193 vat_json_init_object (node);
13194 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13197 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
13198 vat_json_object_add_ip4 (node, "src_address", ip4);
13199 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
13200 vat_json_object_add_ip4 (node, "dst_address", ip4);
13204 clib_memcpy (&ip6, &mp->src_address, sizeof (ip6));
13205 vat_json_object_add_ip6 (node, "src_address", ip6);
13206 clib_memcpy (&ip6, &mp->dst_address, sizeof (ip6));
13207 vat_json_object_add_ip6 (node, "dst_address", ip6);
13209 vat_json_object_add_uint (node, "teb", mp->teb);
13210 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
13211 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6);
13215 api_gre_tunnel_dump (vat_main_t * vam)
13217 unformat_input_t *i = vam->input;
13218 vl_api_gre_tunnel_dump_t *mp;
13219 vl_api_control_ping_t *mp_ping;
13221 u8 sw_if_index_set = 0;
13224 /* Parse args required to build the message */
13225 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13227 if (unformat (i, "sw_if_index %d", &sw_if_index))
13228 sw_if_index_set = 1;
13233 if (sw_if_index_set == 0)
13238 if (!vam->json_output)
13240 print (vam->ofp, "%11s%24s%24s%6s%14s",
13241 "sw_if_index", "src_address", "dst_address", "teb",
13245 /* Get list of gre-tunnel interfaces */
13246 M (GRE_TUNNEL_DUMP, mp);
13248 mp->sw_if_index = htonl (sw_if_index);
13252 /* Use a control ping for synchronization */
13253 MPING (CONTROL_PING, mp_ping);
13261 api_l2_fib_clear_table (vat_main_t * vam)
13263 // unformat_input_t * i = vam->input;
13264 vl_api_l2_fib_clear_table_t *mp;
13267 M (L2_FIB_CLEAR_TABLE, mp);
13275 api_l2_interface_efp_filter (vat_main_t * vam)
13277 unformat_input_t *i = vam->input;
13278 vl_api_l2_interface_efp_filter_t *mp;
13281 u8 sw_if_index_set = 0;
13284 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13286 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13287 sw_if_index_set = 1;
13288 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13289 sw_if_index_set = 1;
13290 else if (unformat (i, "enable"))
13292 else if (unformat (i, "disable"))
13296 clib_warning ("parse error '%U'", format_unformat_error, i);
13301 if (sw_if_index_set == 0)
13303 errmsg ("missing sw_if_index");
13307 M (L2_INTERFACE_EFP_FILTER, mp);
13309 mp->sw_if_index = ntohl (sw_if_index);
13310 mp->enable_disable = enable;
13317 #define foreach_vtr_op \
13318 _("disable", L2_VTR_DISABLED) \
13319 _("push-1", L2_VTR_PUSH_1) \
13320 _("push-2", L2_VTR_PUSH_2) \
13321 _("pop-1", L2_VTR_POP_1) \
13322 _("pop-2", L2_VTR_POP_2) \
13323 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
13324 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
13325 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
13326 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
13329 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
13331 unformat_input_t *i = vam->input;
13332 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
13334 u8 sw_if_index_set = 0;
13337 u32 push_dot1q = 1;
13342 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13344 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13345 sw_if_index_set = 1;
13346 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13347 sw_if_index_set = 1;
13348 else if (unformat (i, "vtr_op %d", &vtr_op))
13350 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
13353 else if (unformat (i, "push_dot1q %d", &push_dot1q))
13355 else if (unformat (i, "tag1 %d", &tag1))
13357 else if (unformat (i, "tag2 %d", &tag2))
13361 clib_warning ("parse error '%U'", format_unformat_error, i);
13366 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
13368 errmsg ("missing vtr operation or sw_if_index");
13372 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
13373 mp->sw_if_index = ntohl (sw_if_index);
13374 mp->vtr_op = ntohl (vtr_op);
13375 mp->push_dot1q = ntohl (push_dot1q);
13376 mp->tag1 = ntohl (tag1);
13377 mp->tag2 = ntohl (tag2);
13385 api_create_vhost_user_if (vat_main_t * vam)
13387 unformat_input_t *i = vam->input;
13388 vl_api_create_vhost_user_if_t *mp;
13391 u8 file_name_set = 0;
13392 u32 custom_dev_instance = ~0;
13394 u8 use_custom_mac = 0;
13398 /* Shut up coverity */
13399 memset (hwaddr, 0, sizeof (hwaddr));
13401 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13403 if (unformat (i, "socket %s", &file_name))
13407 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13409 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
13410 use_custom_mac = 1;
13411 else if (unformat (i, "server"))
13413 else if (unformat (i, "tag %s", &tag))
13419 if (file_name_set == 0)
13421 errmsg ("missing socket file name");
13425 if (vec_len (file_name) > 255)
13427 errmsg ("socket file name too long");
13430 vec_add1 (file_name, 0);
13432 M (CREATE_VHOST_USER_IF, mp);
13434 mp->is_server = is_server;
13435 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13436 vec_free (file_name);
13437 if (custom_dev_instance != ~0)
13440 mp->custom_dev_instance = ntohl (custom_dev_instance);
13442 mp->use_custom_mac = use_custom_mac;
13443 clib_memcpy (mp->mac_address, hwaddr, 6);
13445 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
13454 api_modify_vhost_user_if (vat_main_t * vam)
13456 unformat_input_t *i = vam->input;
13457 vl_api_modify_vhost_user_if_t *mp;
13460 u8 file_name_set = 0;
13461 u32 custom_dev_instance = ~0;
13462 u8 sw_if_index_set = 0;
13463 u32 sw_if_index = (u32) ~ 0;
13466 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13468 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13469 sw_if_index_set = 1;
13470 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13471 sw_if_index_set = 1;
13472 else if (unformat (i, "socket %s", &file_name))
13476 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13478 else if (unformat (i, "server"))
13484 if (sw_if_index_set == 0)
13486 errmsg ("missing sw_if_index or interface name");
13490 if (file_name_set == 0)
13492 errmsg ("missing socket file name");
13496 if (vec_len (file_name) > 255)
13498 errmsg ("socket file name too long");
13501 vec_add1 (file_name, 0);
13503 M (MODIFY_VHOST_USER_IF, mp);
13505 mp->sw_if_index = ntohl (sw_if_index);
13506 mp->is_server = is_server;
13507 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13508 vec_free (file_name);
13509 if (custom_dev_instance != ~0)
13512 mp->custom_dev_instance = ntohl (custom_dev_instance);
13521 api_delete_vhost_user_if (vat_main_t * vam)
13523 unformat_input_t *i = vam->input;
13524 vl_api_delete_vhost_user_if_t *mp;
13525 u32 sw_if_index = ~0;
13526 u8 sw_if_index_set = 0;
13529 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13531 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13532 sw_if_index_set = 1;
13533 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13534 sw_if_index_set = 1;
13539 if (sw_if_index_set == 0)
13541 errmsg ("missing sw_if_index or interface name");
13546 M (DELETE_VHOST_USER_IF, mp);
13548 mp->sw_if_index = ntohl (sw_if_index);
13555 static void vl_api_sw_interface_vhost_user_details_t_handler
13556 (vl_api_sw_interface_vhost_user_details_t * mp)
13558 vat_main_t *vam = &vat_main;
13560 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
13561 (char *) mp->interface_name,
13562 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
13563 clib_net_to_host_u64 (mp->features), mp->is_server,
13564 ntohl (mp->num_regions), (char *) mp->sock_filename);
13565 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
13568 static void vl_api_sw_interface_vhost_user_details_t_handler_json
13569 (vl_api_sw_interface_vhost_user_details_t * mp)
13571 vat_main_t *vam = &vat_main;
13572 vat_json_node_t *node = NULL;
13574 if (VAT_JSON_ARRAY != vam->json_tree.type)
13576 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13577 vat_json_init_array (&vam->json_tree);
13579 node = vat_json_array_add (&vam->json_tree);
13581 vat_json_init_object (node);
13582 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13583 vat_json_object_add_string_copy (node, "interface_name",
13584 mp->interface_name);
13585 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
13586 ntohl (mp->virtio_net_hdr_sz));
13587 vat_json_object_add_uint (node, "features",
13588 clib_net_to_host_u64 (mp->features));
13589 vat_json_object_add_uint (node, "is_server", mp->is_server);
13590 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
13591 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
13592 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
13596 api_sw_interface_vhost_user_dump (vat_main_t * vam)
13598 vl_api_sw_interface_vhost_user_dump_t *mp;
13599 vl_api_control_ping_t *mp_ping;
13602 "Interface name idx hdr_sz features server regions filename");
13604 /* Get list of vhost-user interfaces */
13605 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
13608 /* Use a control ping for synchronization */
13609 MPING (CONTROL_PING, mp_ping);
13617 api_show_version (vat_main_t * vam)
13619 vl_api_show_version_t *mp;
13622 M (SHOW_VERSION, mp);
13631 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
13633 unformat_input_t *line_input = vam->input;
13634 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
13635 ip4_address_t local4, remote4;
13636 ip6_address_t local6, remote6;
13638 u8 ipv4_set = 0, ipv6_set = 0;
13642 u32 mcast_sw_if_index = ~0;
13643 u32 encap_vrf_id = 0;
13644 u32 decap_vrf_id = 0;
13650 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
13651 memset (&local4, 0, sizeof local4);
13652 memset (&remote4, 0, sizeof remote4);
13653 memset (&local6, 0, sizeof local6);
13654 memset (&remote6, 0, sizeof remote6);
13656 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13658 if (unformat (line_input, "del"))
13660 else if (unformat (line_input, "local %U",
13661 unformat_ip4_address, &local4))
13666 else if (unformat (line_input, "remote %U",
13667 unformat_ip4_address, &remote4))
13672 else if (unformat (line_input, "local %U",
13673 unformat_ip6_address, &local6))
13678 else if (unformat (line_input, "remote %U",
13679 unformat_ip6_address, &remote6))
13684 else if (unformat (line_input, "group %U %U",
13685 unformat_ip4_address, &remote4,
13686 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13688 grp_set = remote_set = 1;
13691 else if (unformat (line_input, "group %U",
13692 unformat_ip4_address, &remote4))
13694 grp_set = remote_set = 1;
13697 else if (unformat (line_input, "group %U %U",
13698 unformat_ip6_address, &remote6,
13699 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13701 grp_set = remote_set = 1;
13704 else if (unformat (line_input, "group %U",
13705 unformat_ip6_address, &remote6))
13707 grp_set = remote_set = 1;
13711 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13713 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13715 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
13717 else if (unformat (line_input, "vni %d", &vni))
13719 else if (unformat (line_input, "next-ip4"))
13721 else if (unformat (line_input, "next-ip6"))
13723 else if (unformat (line_input, "next-ethernet"))
13725 else if (unformat (line_input, "next-nsh"))
13729 errmsg ("parse error '%U'", format_unformat_error, line_input);
13734 if (local_set == 0)
13736 errmsg ("tunnel local address not specified");
13739 if (remote_set == 0)
13741 errmsg ("tunnel remote address not specified");
13744 if (grp_set && mcast_sw_if_index == ~0)
13746 errmsg ("tunnel nonexistent multicast device");
13749 if (ipv4_set && ipv6_set)
13751 errmsg ("both IPv4 and IPv6 addresses specified");
13757 errmsg ("vni not specified");
13761 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
13766 clib_memcpy (&mp->local, &local6, sizeof (local6));
13767 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
13771 clib_memcpy (&mp->local, &local4, sizeof (local4));
13772 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
13775 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
13776 mp->encap_vrf_id = ntohl (encap_vrf_id);
13777 mp->decap_vrf_id = ntohl (decap_vrf_id);
13778 mp->protocol = protocol;
13779 mp->vni = ntohl (vni);
13780 mp->is_add = is_add;
13781 mp->is_ipv6 = ipv6_set;
13788 static void vl_api_vxlan_gpe_tunnel_details_t_handler
13789 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13791 vat_main_t *vam = &vat_main;
13792 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
13793 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
13795 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
13796 ntohl (mp->sw_if_index),
13797 format_ip46_address, &local, IP46_TYPE_ANY,
13798 format_ip46_address, &remote, IP46_TYPE_ANY,
13799 ntohl (mp->vni), mp->protocol,
13800 ntohl (mp->mcast_sw_if_index),
13801 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
13805 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
13806 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13808 vat_main_t *vam = &vat_main;
13809 vat_json_node_t *node = NULL;
13810 struct in_addr ip4;
13811 struct in6_addr ip6;
13813 if (VAT_JSON_ARRAY != vam->json_tree.type)
13815 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13816 vat_json_init_array (&vam->json_tree);
13818 node = vat_json_array_add (&vam->json_tree);
13820 vat_json_init_object (node);
13821 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13824 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
13825 vat_json_object_add_ip6 (node, "local", ip6);
13826 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
13827 vat_json_object_add_ip6 (node, "remote", ip6);
13831 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
13832 vat_json_object_add_ip4 (node, "local", ip4);
13833 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
13834 vat_json_object_add_ip4 (node, "remote", ip4);
13836 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
13837 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
13838 vat_json_object_add_uint (node, "mcast_sw_if_index",
13839 ntohl (mp->mcast_sw_if_index));
13840 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
13841 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
13842 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
13846 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
13848 unformat_input_t *i = vam->input;
13849 vl_api_vxlan_gpe_tunnel_dump_t *mp;
13850 vl_api_control_ping_t *mp_ping;
13852 u8 sw_if_index_set = 0;
13855 /* Parse args required to build the message */
13856 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13858 if (unformat (i, "sw_if_index %d", &sw_if_index))
13859 sw_if_index_set = 1;
13864 if (sw_if_index_set == 0)
13869 if (!vam->json_output)
13871 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
13872 "sw_if_index", "local", "remote", "vni",
13873 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
13876 /* Get list of vxlan-tunnel interfaces */
13877 M (VXLAN_GPE_TUNNEL_DUMP, mp);
13879 mp->sw_if_index = htonl (sw_if_index);
13883 /* Use a control ping for synchronization */
13884 MPING (CONTROL_PING, mp_ping);
13891 static void vl_api_l2_fib_table_details_t_handler
13892 (vl_api_l2_fib_table_details_t * mp)
13894 vat_main_t *vam = &vat_main;
13896 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
13898 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
13899 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
13903 static void vl_api_l2_fib_table_details_t_handler_json
13904 (vl_api_l2_fib_table_details_t * mp)
13906 vat_main_t *vam = &vat_main;
13907 vat_json_node_t *node = NULL;
13909 if (VAT_JSON_ARRAY != vam->json_tree.type)
13911 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13912 vat_json_init_array (&vam->json_tree);
13914 node = vat_json_array_add (&vam->json_tree);
13916 vat_json_init_object (node);
13917 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
13918 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
13919 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13920 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
13921 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
13922 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
13926 api_l2_fib_table_dump (vat_main_t * vam)
13928 unformat_input_t *i = vam->input;
13929 vl_api_l2_fib_table_dump_t *mp;
13930 vl_api_control_ping_t *mp_ping;
13935 /* Parse args required to build the message */
13936 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13938 if (unformat (i, "bd_id %d", &bd_id))
13944 if (bd_id_set == 0)
13946 errmsg ("missing bridge domain");
13950 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
13952 /* Get list of l2 fib entries */
13953 M (L2_FIB_TABLE_DUMP, mp);
13955 mp->bd_id = ntohl (bd_id);
13958 /* Use a control ping for synchronization */
13959 MPING (CONTROL_PING, mp_ping);
13968 api_interface_name_renumber (vat_main_t * vam)
13970 unformat_input_t *line_input = vam->input;
13971 vl_api_interface_name_renumber_t *mp;
13972 u32 sw_if_index = ~0;
13973 u32 new_show_dev_instance = ~0;
13976 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13978 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
13981 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13983 else if (unformat (line_input, "new_show_dev_instance %d",
13984 &new_show_dev_instance))
13990 if (sw_if_index == ~0)
13992 errmsg ("missing interface name or sw_if_index");
13996 if (new_show_dev_instance == ~0)
13998 errmsg ("missing new_show_dev_instance");
14002 M (INTERFACE_NAME_RENUMBER, mp);
14004 mp->sw_if_index = ntohl (sw_if_index);
14005 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
14013 api_want_ip4_arp_events (vat_main_t * vam)
14015 unformat_input_t *line_input = vam->input;
14016 vl_api_want_ip4_arp_events_t *mp;
14017 ip4_address_t address;
14018 int address_set = 0;
14019 u32 enable_disable = 1;
14022 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14024 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
14026 else if (unformat (line_input, "del"))
14027 enable_disable = 0;
14032 if (address_set == 0)
14034 errmsg ("missing addresses");
14038 M (WANT_IP4_ARP_EVENTS, mp);
14039 mp->enable_disable = enable_disable;
14040 mp->pid = htonl (getpid ());
14041 mp->address = address.as_u32;
14049 api_want_ip6_nd_events (vat_main_t * vam)
14051 unformat_input_t *line_input = vam->input;
14052 vl_api_want_ip6_nd_events_t *mp;
14053 ip6_address_t address;
14054 int address_set = 0;
14055 u32 enable_disable = 1;
14058 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14060 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
14062 else if (unformat (line_input, "del"))
14063 enable_disable = 0;
14068 if (address_set == 0)
14070 errmsg ("missing addresses");
14074 M (WANT_IP6_ND_EVENTS, mp);
14075 mp->enable_disable = enable_disable;
14076 mp->pid = htonl (getpid ());
14077 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
14085 api_want_l2_macs_events (vat_main_t * vam)
14087 unformat_input_t *line_input = vam->input;
14088 vl_api_want_l2_macs_events_t *mp;
14089 u8 enable_disable = 1;
14090 u32 scan_delay = 0;
14091 u32 max_macs_in_event = 0;
14092 u32 learn_limit = 0;
14095 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14097 if (unformat (line_input, "learn-limit %d", &learn_limit))
14099 else if (unformat (line_input, "scan-delay %d", &scan_delay))
14101 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
14103 else if (unformat (line_input, "disable"))
14104 enable_disable = 0;
14109 M (WANT_L2_MACS_EVENTS, mp);
14110 mp->enable_disable = enable_disable;
14111 mp->pid = htonl (getpid ());
14112 mp->learn_limit = htonl (learn_limit);
14113 mp->scan_delay = (u8) scan_delay;
14114 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
14121 api_input_acl_set_interface (vat_main_t * vam)
14123 unformat_input_t *i = vam->input;
14124 vl_api_input_acl_set_interface_t *mp;
14126 int sw_if_index_set;
14127 u32 ip4_table_index = ~0;
14128 u32 ip6_table_index = ~0;
14129 u32 l2_table_index = ~0;
14133 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14135 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14136 sw_if_index_set = 1;
14137 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14138 sw_if_index_set = 1;
14139 else if (unformat (i, "del"))
14141 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14143 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14145 else if (unformat (i, "l2-table %d", &l2_table_index))
14149 clib_warning ("parse error '%U'", format_unformat_error, i);
14154 if (sw_if_index_set == 0)
14156 errmsg ("missing interface name or sw_if_index");
14160 M (INPUT_ACL_SET_INTERFACE, mp);
14162 mp->sw_if_index = ntohl (sw_if_index);
14163 mp->ip4_table_index = ntohl (ip4_table_index);
14164 mp->ip6_table_index = ntohl (ip6_table_index);
14165 mp->l2_table_index = ntohl (l2_table_index);
14166 mp->is_add = is_add;
14174 api_ip_address_dump (vat_main_t * vam)
14176 unformat_input_t *i = vam->input;
14177 vl_api_ip_address_dump_t *mp;
14178 vl_api_control_ping_t *mp_ping;
14179 u32 sw_if_index = ~0;
14180 u8 sw_if_index_set = 0;
14185 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14187 if (unformat (i, "sw_if_index %d", &sw_if_index))
14188 sw_if_index_set = 1;
14190 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14191 sw_if_index_set = 1;
14192 else if (unformat (i, "ipv4"))
14194 else if (unformat (i, "ipv6"))
14200 if (ipv4_set && ipv6_set)
14202 errmsg ("ipv4 and ipv6 flags cannot be both set");
14206 if ((!ipv4_set) && (!ipv6_set))
14208 errmsg ("no ipv4 nor ipv6 flag set");
14212 if (sw_if_index_set == 0)
14214 errmsg ("missing interface name or sw_if_index");
14218 vam->current_sw_if_index = sw_if_index;
14219 vam->is_ipv6 = ipv6_set;
14221 M (IP_ADDRESS_DUMP, mp);
14222 mp->sw_if_index = ntohl (sw_if_index);
14223 mp->is_ipv6 = ipv6_set;
14226 /* Use a control ping for synchronization */
14227 MPING (CONTROL_PING, mp_ping);
14235 api_ip_dump (vat_main_t * vam)
14237 vl_api_ip_dump_t *mp;
14238 vl_api_control_ping_t *mp_ping;
14239 unformat_input_t *in = vam->input;
14246 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
14248 if (unformat (in, "ipv4"))
14250 else if (unformat (in, "ipv6"))
14256 if (ipv4_set && ipv6_set)
14258 errmsg ("ipv4 and ipv6 flags cannot be both set");
14262 if ((!ipv4_set) && (!ipv6_set))
14264 errmsg ("no ipv4 nor ipv6 flag set");
14268 is_ipv6 = ipv6_set;
14269 vam->is_ipv6 = is_ipv6;
14271 /* free old data */
14272 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
14274 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
14276 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
14279 mp->is_ipv6 = ipv6_set;
14282 /* Use a control ping for synchronization */
14283 MPING (CONTROL_PING, mp_ping);
14291 api_ipsec_spd_add_del (vat_main_t * vam)
14293 unformat_input_t *i = vam->input;
14294 vl_api_ipsec_spd_add_del_t *mp;
14299 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14301 if (unformat (i, "spd_id %d", &spd_id))
14303 else if (unformat (i, "del"))
14307 clib_warning ("parse error '%U'", format_unformat_error, i);
14313 errmsg ("spd_id must be set");
14317 M (IPSEC_SPD_ADD_DEL, mp);
14319 mp->spd_id = ntohl (spd_id);
14320 mp->is_add = is_add;
14328 api_ipsec_interface_add_del_spd (vat_main_t * vam)
14330 unformat_input_t *i = vam->input;
14331 vl_api_ipsec_interface_add_del_spd_t *mp;
14333 u8 sw_if_index_set = 0;
14334 u32 spd_id = (u32) ~ 0;
14338 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14340 if (unformat (i, "del"))
14342 else if (unformat (i, "spd_id %d", &spd_id))
14345 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14346 sw_if_index_set = 1;
14347 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14348 sw_if_index_set = 1;
14351 clib_warning ("parse error '%U'", format_unformat_error, i);
14357 if (spd_id == (u32) ~ 0)
14359 errmsg ("spd_id must be set");
14363 if (sw_if_index_set == 0)
14365 errmsg ("missing interface name or sw_if_index");
14369 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
14371 mp->spd_id = ntohl (spd_id);
14372 mp->sw_if_index = ntohl (sw_if_index);
14373 mp->is_add = is_add;
14381 api_ipsec_spd_add_del_entry (vat_main_t * vam)
14383 unformat_input_t *i = vam->input;
14384 vl_api_ipsec_spd_add_del_entry_t *mp;
14385 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
14386 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
14388 u32 rport_start = 0, rport_stop = (u32) ~ 0;
14389 u32 lport_start = 0, lport_stop = (u32) ~ 0;
14390 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
14391 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
14394 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
14395 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
14396 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
14397 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
14398 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
14399 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
14401 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14403 if (unformat (i, "del"))
14405 if (unformat (i, "outbound"))
14407 if (unformat (i, "inbound"))
14409 else if (unformat (i, "spd_id %d", &spd_id))
14411 else if (unformat (i, "sa_id %d", &sa_id))
14413 else if (unformat (i, "priority %d", &priority))
14415 else if (unformat (i, "protocol %d", &protocol))
14417 else if (unformat (i, "lport_start %d", &lport_start))
14419 else if (unformat (i, "lport_stop %d", &lport_stop))
14421 else if (unformat (i, "rport_start %d", &rport_start))
14423 else if (unformat (i, "rport_stop %d", &rport_stop))
14427 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
14433 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
14440 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
14446 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
14453 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
14459 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
14466 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
14472 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
14478 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
14480 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
14482 clib_warning ("unsupported action: 'resolve'");
14488 clib_warning ("parse error '%U'", format_unformat_error, i);
14494 M (IPSEC_SPD_ADD_DEL_ENTRY, mp);
14496 mp->spd_id = ntohl (spd_id);
14497 mp->priority = ntohl (priority);
14498 mp->is_outbound = is_outbound;
14500 mp->is_ipv6 = is_ipv6;
14501 if (is_ipv6 || is_ip_any)
14503 clib_memcpy (mp->remote_address_start, &raddr6_start,
14504 sizeof (ip6_address_t));
14505 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
14506 sizeof (ip6_address_t));
14507 clib_memcpy (mp->local_address_start, &laddr6_start,
14508 sizeof (ip6_address_t));
14509 clib_memcpy (mp->local_address_stop, &laddr6_stop,
14510 sizeof (ip6_address_t));
14514 clib_memcpy (mp->remote_address_start, &raddr4_start,
14515 sizeof (ip4_address_t));
14516 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
14517 sizeof (ip4_address_t));
14518 clib_memcpy (mp->local_address_start, &laddr4_start,
14519 sizeof (ip4_address_t));
14520 clib_memcpy (mp->local_address_stop, &laddr4_stop,
14521 sizeof (ip4_address_t));
14523 mp->protocol = (u8) protocol;
14524 mp->local_port_start = ntohs ((u16) lport_start);
14525 mp->local_port_stop = ntohs ((u16) lport_stop);
14526 mp->remote_port_start = ntohs ((u16) rport_start);
14527 mp->remote_port_stop = ntohs ((u16) rport_stop);
14528 mp->policy = (u8) policy;
14529 mp->sa_id = ntohl (sa_id);
14530 mp->is_add = is_add;
14531 mp->is_ip_any = is_ip_any;
14538 api_ipsec_sad_add_del_entry (vat_main_t * vam)
14540 unformat_input_t *i = vam->input;
14541 vl_api_ipsec_sad_add_del_entry_t *mp;
14542 u32 sad_id = 0, spi = 0;
14543 u8 *ck = 0, *ik = 0;
14546 u8 protocol = IPSEC_PROTOCOL_AH;
14547 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
14548 u32 crypto_alg = 0, integ_alg = 0;
14549 ip4_address_t tun_src4;
14550 ip4_address_t tun_dst4;
14551 ip6_address_t tun_src6;
14552 ip6_address_t tun_dst6;
14555 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14557 if (unformat (i, "del"))
14559 else if (unformat (i, "sad_id %d", &sad_id))
14561 else if (unformat (i, "spi %d", &spi))
14563 else if (unformat (i, "esp"))
14564 protocol = IPSEC_PROTOCOL_ESP;
14565 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
14568 is_tunnel_ipv6 = 0;
14570 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
14573 is_tunnel_ipv6 = 0;
14575 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
14578 is_tunnel_ipv6 = 1;
14580 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
14583 is_tunnel_ipv6 = 1;
14587 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
14589 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
14590 crypto_alg >= IPSEC_CRYPTO_N_ALG)
14592 clib_warning ("unsupported crypto-alg: '%U'",
14593 format_ipsec_crypto_alg, crypto_alg);
14597 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14601 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
14603 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
14604 integ_alg >= IPSEC_INTEG_N_ALG)
14606 clib_warning ("unsupported integ-alg: '%U'",
14607 format_ipsec_integ_alg, integ_alg);
14611 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14615 clib_warning ("parse error '%U'", format_unformat_error, i);
14621 M (IPSEC_SAD_ADD_DEL_ENTRY, mp);
14623 mp->sad_id = ntohl (sad_id);
14624 mp->is_add = is_add;
14625 mp->protocol = protocol;
14626 mp->spi = ntohl (spi);
14627 mp->is_tunnel = is_tunnel;
14628 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
14629 mp->crypto_algorithm = crypto_alg;
14630 mp->integrity_algorithm = integ_alg;
14631 mp->crypto_key_length = vec_len (ck);
14632 mp->integrity_key_length = vec_len (ik);
14634 if (mp->crypto_key_length > sizeof (mp->crypto_key))
14635 mp->crypto_key_length = sizeof (mp->crypto_key);
14637 if (mp->integrity_key_length > sizeof (mp->integrity_key))
14638 mp->integrity_key_length = sizeof (mp->integrity_key);
14641 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
14643 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
14647 if (is_tunnel_ipv6)
14649 clib_memcpy (mp->tunnel_src_address, &tun_src6,
14650 sizeof (ip6_address_t));
14651 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
14652 sizeof (ip6_address_t));
14656 clib_memcpy (mp->tunnel_src_address, &tun_src4,
14657 sizeof (ip4_address_t));
14658 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
14659 sizeof (ip4_address_t));
14669 api_ipsec_sa_set_key (vat_main_t * vam)
14671 unformat_input_t *i = vam->input;
14672 vl_api_ipsec_sa_set_key_t *mp;
14674 u8 *ck = 0, *ik = 0;
14677 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14679 if (unformat (i, "sa_id %d", &sa_id))
14681 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14683 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14687 clib_warning ("parse error '%U'", format_unformat_error, i);
14692 M (IPSEC_SA_SET_KEY, mp);
14694 mp->sa_id = ntohl (sa_id);
14695 mp->crypto_key_length = vec_len (ck);
14696 mp->integrity_key_length = vec_len (ik);
14698 if (mp->crypto_key_length > sizeof (mp->crypto_key))
14699 mp->crypto_key_length = sizeof (mp->crypto_key);
14701 if (mp->integrity_key_length > sizeof (mp->integrity_key))
14702 mp->integrity_key_length = sizeof (mp->integrity_key);
14705 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
14707 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
14715 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
14717 unformat_input_t *i = vam->input;
14718 vl_api_ipsec_tunnel_if_add_del_t *mp;
14719 u32 local_spi = 0, remote_spi = 0;
14720 u32 crypto_alg = 0, integ_alg = 0;
14721 u8 *lck = NULL, *rck = NULL;
14722 u8 *lik = NULL, *rik = NULL;
14723 ip4_address_t local_ip = { {0} };
14724 ip4_address_t remote_ip = { {0} };
14727 u8 anti_replay = 0;
14730 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14732 if (unformat (i, "del"))
14734 else if (unformat (i, "esn"))
14736 else if (unformat (i, "anti_replay"))
14738 else if (unformat (i, "local_spi %d", &local_spi))
14740 else if (unformat (i, "remote_spi %d", &remote_spi))
14742 else if (unformat (i, "local_ip %U", unformat_ip4_address, &local_ip))
14744 else if (unformat (i, "remote_ip %U", unformat_ip4_address, &remote_ip))
14746 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
14749 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
14751 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
14753 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
14757 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
14759 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
14760 crypto_alg >= IPSEC_CRYPTO_N_ALG)
14762 errmsg ("unsupported crypto-alg: '%U'\n",
14763 format_ipsec_crypto_alg, crypto_alg);
14769 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
14771 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
14772 integ_alg >= IPSEC_INTEG_N_ALG)
14774 errmsg ("unsupported integ-alg: '%U'\n",
14775 format_ipsec_integ_alg, integ_alg);
14781 errmsg ("parse error '%U'\n", format_unformat_error, i);
14786 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
14788 mp->is_add = is_add;
14790 mp->anti_replay = anti_replay;
14792 clib_memcpy (mp->local_ip, &local_ip, sizeof (ip4_address_t));
14793 clib_memcpy (mp->remote_ip, &remote_ip, sizeof (ip4_address_t));
14795 mp->local_spi = htonl (local_spi);
14796 mp->remote_spi = htonl (remote_spi);
14797 mp->crypto_alg = (u8) crypto_alg;
14799 mp->local_crypto_key_len = 0;
14802 mp->local_crypto_key_len = vec_len (lck);
14803 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
14804 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
14805 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
14808 mp->remote_crypto_key_len = 0;
14811 mp->remote_crypto_key_len = vec_len (rck);
14812 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
14813 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
14814 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
14817 mp->integ_alg = (u8) integ_alg;
14819 mp->local_integ_key_len = 0;
14822 mp->local_integ_key_len = vec_len (lik);
14823 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
14824 mp->local_integ_key_len = sizeof (mp->local_integ_key);
14825 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
14828 mp->remote_integ_key_len = 0;
14831 mp->remote_integ_key_len = vec_len (rik);
14832 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
14833 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
14834 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
14843 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
14845 vat_main_t *vam = &vat_main;
14847 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
14848 "crypto_key %U integ_alg %u integ_key %U use_esn %u "
14849 "use_anti_replay %u is_tunnel %u is_tunnel_ip6 %u "
14850 "tunnel_src_addr %U tunnel_dst_addr %U "
14851 "salt %u seq_outbound %lu last_seq_inbound %lu "
14852 "replay_window %lu total_data_size %lu\n",
14853 ntohl (mp->sa_id), ntohl (mp->sw_if_index), ntohl (mp->spi),
14855 mp->crypto_alg, format_hex_bytes, mp->crypto_key, mp->crypto_key_len,
14856 mp->integ_alg, format_hex_bytes, mp->integ_key, mp->integ_key_len,
14857 mp->use_esn, mp->use_anti_replay, mp->is_tunnel, mp->is_tunnel_ip6,
14858 (mp->is_tunnel_ip6) ? format_ip6_address : format_ip4_address,
14859 mp->tunnel_src_addr,
14860 (mp->is_tunnel_ip6) ? format_ip6_address : format_ip4_address,
14861 mp->tunnel_dst_addr,
14863 clib_net_to_host_u64 (mp->seq_outbound),
14864 clib_net_to_host_u64 (mp->last_seq_inbound),
14865 clib_net_to_host_u64 (mp->replay_window),
14866 clib_net_to_host_u64 (mp->total_data_size));
14869 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
14870 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
14872 static void vl_api_ipsec_sa_details_t_handler_json
14873 (vl_api_ipsec_sa_details_t * mp)
14875 vat_main_t *vam = &vat_main;
14876 vat_json_node_t *node = NULL;
14877 struct in_addr src_ip4, dst_ip4;
14878 struct in6_addr src_ip6, dst_ip6;
14880 if (VAT_JSON_ARRAY != vam->json_tree.type)
14882 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14883 vat_json_init_array (&vam->json_tree);
14885 node = vat_json_array_add (&vam->json_tree);
14887 vat_json_init_object (node);
14888 vat_json_object_add_uint (node, "sa_id", ntohl (mp->sa_id));
14889 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14890 vat_json_object_add_uint (node, "spi", ntohl (mp->spi));
14891 vat_json_object_add_uint (node, "proto", mp->protocol);
14892 vat_json_object_add_uint (node, "crypto_alg", mp->crypto_alg);
14893 vat_json_object_add_uint (node, "integ_alg", mp->integ_alg);
14894 vat_json_object_add_uint (node, "use_esn", mp->use_esn);
14895 vat_json_object_add_uint (node, "use_anti_replay", mp->use_anti_replay);
14896 vat_json_object_add_uint (node, "is_tunnel", mp->is_tunnel);
14897 vat_json_object_add_uint (node, "is_tunnel_ip6", mp->is_tunnel_ip6);
14898 vat_json_object_add_bytes (node, "crypto_key", mp->crypto_key,
14899 mp->crypto_key_len);
14900 vat_json_object_add_bytes (node, "integ_key", mp->integ_key,
14901 mp->integ_key_len);
14902 if (mp->is_tunnel_ip6)
14904 clib_memcpy (&src_ip6, mp->tunnel_src_addr, sizeof (src_ip6));
14905 vat_json_object_add_ip6 (node, "tunnel_src_addr", src_ip6);
14906 clib_memcpy (&dst_ip6, mp->tunnel_dst_addr, sizeof (dst_ip6));
14907 vat_json_object_add_ip6 (node, "tunnel_dst_addr", dst_ip6);
14911 clib_memcpy (&src_ip4, mp->tunnel_src_addr, sizeof (src_ip4));
14912 vat_json_object_add_ip4 (node, "tunnel_src_addr", src_ip4);
14913 clib_memcpy (&dst_ip4, mp->tunnel_dst_addr, sizeof (dst_ip4));
14914 vat_json_object_add_ip4 (node, "tunnel_dst_addr", dst_ip4);
14916 vat_json_object_add_uint (node, "replay_window",
14917 clib_net_to_host_u64 (mp->replay_window));
14918 vat_json_object_add_uint (node, "total_data_size",
14919 clib_net_to_host_u64 (mp->total_data_size));
14924 api_ipsec_sa_dump (vat_main_t * vam)
14926 unformat_input_t *i = vam->input;
14927 vl_api_ipsec_sa_dump_t *mp;
14928 vl_api_control_ping_t *mp_ping;
14932 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14934 if (unformat (i, "sa_id %d", &sa_id))
14938 clib_warning ("parse error '%U'", format_unformat_error, i);
14943 M (IPSEC_SA_DUMP, mp);
14945 mp->sa_id = ntohl (sa_id);
14949 /* Use a control ping for synchronization */
14950 M (CONTROL_PING, mp_ping);
14958 api_ipsec_tunnel_if_set_key (vat_main_t * vam)
14960 unformat_input_t *i = vam->input;
14961 vl_api_ipsec_tunnel_if_set_key_t *mp;
14962 u32 sw_if_index = ~0;
14963 u8 key_type = IPSEC_IF_SET_KEY_TYPE_NONE;
14968 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14970 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14973 if (unformat (i, "local crypto %U", unformat_ipsec_crypto_alg, &alg))
14974 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_CRYPTO;
14976 if (unformat (i, "remote crypto %U", unformat_ipsec_crypto_alg, &alg))
14977 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_CRYPTO;
14978 else if (unformat (i, "local integ %U", unformat_ipsec_integ_alg, &alg))
14979 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_INTEG;
14981 if (unformat (i, "remote integ %U", unformat_ipsec_integ_alg, &alg))
14982 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_INTEG;
14983 else if (unformat (i, "%U", unformat_hex_string, &key))
14987 clib_warning ("parse error '%U'", format_unformat_error, i);
14992 if (sw_if_index == ~0)
14994 errmsg ("interface must be specified");
14998 if (key_type == IPSEC_IF_SET_KEY_TYPE_NONE)
15000 errmsg ("key type must be specified");
15006 errmsg ("algorithm must be specified");
15010 if (vec_len (key) == 0)
15012 errmsg ("key must be specified");
15016 M (IPSEC_TUNNEL_IF_SET_KEY, mp);
15018 mp->sw_if_index = htonl (sw_if_index);
15020 mp->key_type = key_type;
15021 mp->key_len = vec_len (key);
15022 clib_memcpy (mp->key, key, vec_len (key));
15031 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
15033 unformat_input_t *i = vam->input;
15034 vl_api_ipsec_tunnel_if_set_sa_t *mp;
15035 u32 sw_if_index = ~0;
15037 u8 is_outbound = (u8) ~ 0;
15040 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15042 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15044 else if (unformat (i, "sa_id %d", &sa_id))
15046 else if (unformat (i, "outbound"))
15048 else if (unformat (i, "inbound"))
15052 clib_warning ("parse error '%U'", format_unformat_error, i);
15057 if (sw_if_index == ~0)
15059 errmsg ("interface must be specified");
15065 errmsg ("SA ID must be specified");
15069 M (IPSEC_TUNNEL_IF_SET_SA, mp);
15071 mp->sw_if_index = htonl (sw_if_index);
15072 mp->sa_id = htonl (sa_id);
15073 mp->is_outbound = is_outbound;
15082 api_ikev2_profile_add_del (vat_main_t * vam)
15084 unformat_input_t *i = vam->input;
15085 vl_api_ikev2_profile_add_del_t *mp;
15090 const char *valid_chars = "a-zA-Z0-9_";
15092 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15094 if (unformat (i, "del"))
15096 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15097 vec_add1 (name, 0);
15100 errmsg ("parse error '%U'", format_unformat_error, i);
15105 if (!vec_len (name))
15107 errmsg ("profile name must be specified");
15111 if (vec_len (name) > 64)
15113 errmsg ("profile name too long");
15117 M (IKEV2_PROFILE_ADD_DEL, mp);
15119 clib_memcpy (mp->name, name, vec_len (name));
15120 mp->is_add = is_add;
15129 api_ikev2_profile_set_auth (vat_main_t * vam)
15131 unformat_input_t *i = vam->input;
15132 vl_api_ikev2_profile_set_auth_t *mp;
15135 u32 auth_method = 0;
15139 const char *valid_chars = "a-zA-Z0-9_";
15141 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15143 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15144 vec_add1 (name, 0);
15145 else if (unformat (i, "auth_method %U",
15146 unformat_ikev2_auth_method, &auth_method))
15148 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
15150 else if (unformat (i, "auth_data %v", &data))
15154 errmsg ("parse error '%U'", format_unformat_error, i);
15159 if (!vec_len (name))
15161 errmsg ("profile name must be specified");
15165 if (vec_len (name) > 64)
15167 errmsg ("profile name too long");
15171 if (!vec_len (data))
15173 errmsg ("auth_data must be specified");
15179 errmsg ("auth_method must be specified");
15183 M (IKEV2_PROFILE_SET_AUTH, mp);
15185 mp->is_hex = is_hex;
15186 mp->auth_method = (u8) auth_method;
15187 mp->data_len = vec_len (data);
15188 clib_memcpy (mp->name, name, vec_len (name));
15189 clib_memcpy (mp->data, data, vec_len (data));
15199 api_ikev2_profile_set_id (vat_main_t * vam)
15201 unformat_input_t *i = vam->input;
15202 vl_api_ikev2_profile_set_id_t *mp;
15210 const char *valid_chars = "a-zA-Z0-9_";
15212 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15214 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15215 vec_add1 (name, 0);
15216 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
15218 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
15220 data = vec_new (u8, 4);
15221 clib_memcpy (data, ip4.as_u8, 4);
15223 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
15225 else if (unformat (i, "id_data %v", &data))
15227 else if (unformat (i, "local"))
15229 else if (unformat (i, "remote"))
15233 errmsg ("parse error '%U'", format_unformat_error, i);
15238 if (!vec_len (name))
15240 errmsg ("profile name must be specified");
15244 if (vec_len (name) > 64)
15246 errmsg ("profile name too long");
15250 if (!vec_len (data))
15252 errmsg ("id_data must be specified");
15258 errmsg ("id_type must be specified");
15262 M (IKEV2_PROFILE_SET_ID, mp);
15264 mp->is_local = is_local;
15265 mp->id_type = (u8) id_type;
15266 mp->data_len = vec_len (data);
15267 clib_memcpy (mp->name, name, vec_len (name));
15268 clib_memcpy (mp->data, data, vec_len (data));
15278 api_ikev2_profile_set_ts (vat_main_t * vam)
15280 unformat_input_t *i = vam->input;
15281 vl_api_ikev2_profile_set_ts_t *mp;
15284 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
15285 ip4_address_t start_addr, end_addr;
15287 const char *valid_chars = "a-zA-Z0-9_";
15290 start_addr.as_u32 = 0;
15291 end_addr.as_u32 = (u32) ~ 0;
15293 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15295 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15296 vec_add1 (name, 0);
15297 else if (unformat (i, "protocol %d", &proto))
15299 else if (unformat (i, "start_port %d", &start_port))
15301 else if (unformat (i, "end_port %d", &end_port))
15304 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
15306 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
15308 else if (unformat (i, "local"))
15310 else if (unformat (i, "remote"))
15314 errmsg ("parse error '%U'", format_unformat_error, i);
15319 if (!vec_len (name))
15321 errmsg ("profile name must be specified");
15325 if (vec_len (name) > 64)
15327 errmsg ("profile name too long");
15331 M (IKEV2_PROFILE_SET_TS, mp);
15333 mp->is_local = is_local;
15334 mp->proto = (u8) proto;
15335 mp->start_port = (u16) start_port;
15336 mp->end_port = (u16) end_port;
15337 mp->start_addr = start_addr.as_u32;
15338 mp->end_addr = end_addr.as_u32;
15339 clib_memcpy (mp->name, name, vec_len (name));
15348 api_ikev2_set_local_key (vat_main_t * vam)
15350 unformat_input_t *i = vam->input;
15351 vl_api_ikev2_set_local_key_t *mp;
15355 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15357 if (unformat (i, "file %v", &file))
15358 vec_add1 (file, 0);
15361 errmsg ("parse error '%U'", format_unformat_error, i);
15366 if (!vec_len (file))
15368 errmsg ("RSA key file must be specified");
15372 if (vec_len (file) > 256)
15374 errmsg ("file name too long");
15378 M (IKEV2_SET_LOCAL_KEY, mp);
15380 clib_memcpy (mp->key_file, file, vec_len (file));
15389 api_ikev2_set_responder (vat_main_t * vam)
15391 unformat_input_t *i = vam->input;
15392 vl_api_ikev2_set_responder_t *mp;
15395 u32 sw_if_index = ~0;
15396 ip4_address_t address;
15398 const char *valid_chars = "a-zA-Z0-9_";
15400 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15403 (i, "%U interface %d address %U", unformat_token, valid_chars,
15404 &name, &sw_if_index, unformat_ip4_address, &address))
15405 vec_add1 (name, 0);
15408 errmsg ("parse error '%U'", format_unformat_error, i);
15413 if (!vec_len (name))
15415 errmsg ("profile name must be specified");
15419 if (vec_len (name) > 64)
15421 errmsg ("profile name too long");
15425 M (IKEV2_SET_RESPONDER, mp);
15427 clib_memcpy (mp->name, name, vec_len (name));
15430 mp->sw_if_index = sw_if_index;
15431 clib_memcpy (mp->address, &address, sizeof (address));
15439 api_ikev2_set_ike_transforms (vat_main_t * vam)
15441 unformat_input_t *i = vam->input;
15442 vl_api_ikev2_set_ike_transforms_t *mp;
15445 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
15447 const char *valid_chars = "a-zA-Z0-9_";
15449 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15451 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
15452 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
15453 vec_add1 (name, 0);
15456 errmsg ("parse error '%U'", format_unformat_error, i);
15461 if (!vec_len (name))
15463 errmsg ("profile name must be specified");
15467 if (vec_len (name) > 64)
15469 errmsg ("profile name too long");
15473 M (IKEV2_SET_IKE_TRANSFORMS, mp);
15475 clib_memcpy (mp->name, name, vec_len (name));
15477 mp->crypto_alg = crypto_alg;
15478 mp->crypto_key_size = crypto_key_size;
15479 mp->integ_alg = integ_alg;
15480 mp->dh_group = dh_group;
15489 api_ikev2_set_esp_transforms (vat_main_t * vam)
15491 unformat_input_t *i = vam->input;
15492 vl_api_ikev2_set_esp_transforms_t *mp;
15495 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
15497 const char *valid_chars = "a-zA-Z0-9_";
15499 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15501 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
15502 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
15503 vec_add1 (name, 0);
15506 errmsg ("parse error '%U'", format_unformat_error, i);
15511 if (!vec_len (name))
15513 errmsg ("profile name must be specified");
15517 if (vec_len (name) > 64)
15519 errmsg ("profile name too long");
15523 M (IKEV2_SET_ESP_TRANSFORMS, mp);
15525 clib_memcpy (mp->name, name, vec_len (name));
15527 mp->crypto_alg = crypto_alg;
15528 mp->crypto_key_size = crypto_key_size;
15529 mp->integ_alg = integ_alg;
15530 mp->dh_group = dh_group;
15538 api_ikev2_set_sa_lifetime (vat_main_t * vam)
15540 unformat_input_t *i = vam->input;
15541 vl_api_ikev2_set_sa_lifetime_t *mp;
15544 u64 lifetime, lifetime_maxdata;
15545 u32 lifetime_jitter, handover;
15547 const char *valid_chars = "a-zA-Z0-9_";
15549 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15551 if (unformat (i, "%U %lu %u %u %lu", unformat_token, valid_chars, &name,
15552 &lifetime, &lifetime_jitter, &handover,
15553 &lifetime_maxdata))
15554 vec_add1 (name, 0);
15557 errmsg ("parse error '%U'", format_unformat_error, i);
15562 if (!vec_len (name))
15564 errmsg ("profile name must be specified");
15568 if (vec_len (name) > 64)
15570 errmsg ("profile name too long");
15574 M (IKEV2_SET_SA_LIFETIME, mp);
15576 clib_memcpy (mp->name, name, vec_len (name));
15578 mp->lifetime = lifetime;
15579 mp->lifetime_jitter = lifetime_jitter;
15580 mp->handover = handover;
15581 mp->lifetime_maxdata = lifetime_maxdata;
15589 api_ikev2_initiate_sa_init (vat_main_t * vam)
15591 unformat_input_t *i = vam->input;
15592 vl_api_ikev2_initiate_sa_init_t *mp;
15596 const char *valid_chars = "a-zA-Z0-9_";
15598 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15600 if (unformat (i, "%U", unformat_token, valid_chars, &name))
15601 vec_add1 (name, 0);
15604 errmsg ("parse error '%U'", format_unformat_error, i);
15609 if (!vec_len (name))
15611 errmsg ("profile name must be specified");
15615 if (vec_len (name) > 64)
15617 errmsg ("profile name too long");
15621 M (IKEV2_INITIATE_SA_INIT, mp);
15623 clib_memcpy (mp->name, name, vec_len (name));
15632 api_ikev2_initiate_del_ike_sa (vat_main_t * vam)
15634 unformat_input_t *i = vam->input;
15635 vl_api_ikev2_initiate_del_ike_sa_t *mp;
15640 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15642 if (unformat (i, "%lx", &ispi))
15646 errmsg ("parse error '%U'", format_unformat_error, i);
15651 M (IKEV2_INITIATE_DEL_IKE_SA, mp);
15661 api_ikev2_initiate_del_child_sa (vat_main_t * vam)
15663 unformat_input_t *i = vam->input;
15664 vl_api_ikev2_initiate_del_child_sa_t *mp;
15669 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15671 if (unformat (i, "%x", &ispi))
15675 errmsg ("parse error '%U'", format_unformat_error, i);
15680 M (IKEV2_INITIATE_DEL_CHILD_SA, mp);
15690 api_ikev2_initiate_rekey_child_sa (vat_main_t * vam)
15692 unformat_input_t *i = vam->input;
15693 vl_api_ikev2_initiate_rekey_child_sa_t *mp;
15698 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15700 if (unformat (i, "%x", &ispi))
15704 errmsg ("parse error '%U'", format_unformat_error, i);
15709 M (IKEV2_INITIATE_REKEY_CHILD_SA, mp);
15722 api_map_add_domain (vat_main_t * vam)
15724 unformat_input_t *i = vam->input;
15725 vl_api_map_add_domain_t *mp;
15727 ip4_address_t ip4_prefix;
15728 ip6_address_t ip6_prefix;
15729 ip6_address_t ip6_src;
15730 u32 num_m_args = 0;
15731 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
15732 0, psid_length = 0;
15733 u8 is_translation = 0;
15735 u32 ip6_src_len = 128;
15738 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15740 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
15741 &ip4_prefix, &ip4_prefix_len))
15743 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
15744 &ip6_prefix, &ip6_prefix_len))
15748 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
15751 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
15753 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
15755 else if (unformat (i, "psid-offset %d", &psid_offset))
15757 else if (unformat (i, "psid-len %d", &psid_length))
15759 else if (unformat (i, "mtu %d", &mtu))
15761 else if (unformat (i, "map-t"))
15762 is_translation = 1;
15765 clib_warning ("parse error '%U'", format_unformat_error, i);
15770 if (num_m_args < 3)
15772 errmsg ("mandatory argument(s) missing");
15776 /* Construct the API message */
15777 M (MAP_ADD_DOMAIN, mp);
15779 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
15780 mp->ip4_prefix_len = ip4_prefix_len;
15782 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
15783 mp->ip6_prefix_len = ip6_prefix_len;
15785 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
15786 mp->ip6_src_prefix_len = ip6_src_len;
15788 mp->ea_bits_len = ea_bits_len;
15789 mp->psid_offset = psid_offset;
15790 mp->psid_length = psid_length;
15791 mp->is_translation = is_translation;
15792 mp->mtu = htons (mtu);
15797 /* Wait for a reply, return good/bad news */
15803 api_map_del_domain (vat_main_t * vam)
15805 unformat_input_t *i = vam->input;
15806 vl_api_map_del_domain_t *mp;
15808 u32 num_m_args = 0;
15812 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15814 if (unformat (i, "index %d", &index))
15818 clib_warning ("parse error '%U'", format_unformat_error, i);
15823 if (num_m_args != 1)
15825 errmsg ("mandatory argument(s) missing");
15829 /* Construct the API message */
15830 M (MAP_DEL_DOMAIN, mp);
15832 mp->index = ntohl (index);
15837 /* Wait for a reply, return good/bad news */
15843 api_map_add_del_rule (vat_main_t * vam)
15845 unformat_input_t *i = vam->input;
15846 vl_api_map_add_del_rule_t *mp;
15848 ip6_address_t ip6_dst;
15849 u32 num_m_args = 0, index, psid = 0;
15852 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15854 if (unformat (i, "index %d", &index))
15856 else if (unformat (i, "psid %d", &psid))
15858 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
15860 else if (unformat (i, "del"))
15866 clib_warning ("parse error '%U'", format_unformat_error, i);
15871 /* Construct the API message */
15872 M (MAP_ADD_DEL_RULE, mp);
15874 mp->index = ntohl (index);
15875 mp->is_add = is_add;
15876 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
15877 mp->psid = ntohs (psid);
15882 /* Wait for a reply, return good/bad news */
15888 api_map_domain_dump (vat_main_t * vam)
15890 vl_api_map_domain_dump_t *mp;
15891 vl_api_control_ping_t *mp_ping;
15894 /* Construct the API message */
15895 M (MAP_DOMAIN_DUMP, mp);
15900 /* Use a control ping for synchronization */
15901 MPING (CONTROL_PING, mp_ping);
15909 api_map_rule_dump (vat_main_t * vam)
15911 unformat_input_t *i = vam->input;
15912 vl_api_map_rule_dump_t *mp;
15913 vl_api_control_ping_t *mp_ping;
15914 u32 domain_index = ~0;
15917 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15919 if (unformat (i, "index %u", &domain_index))
15925 if (domain_index == ~0)
15927 clib_warning ("parse error: domain index expected");
15931 /* Construct the API message */
15932 M (MAP_RULE_DUMP, mp);
15934 mp->domain_index = htonl (domain_index);
15939 /* Use a control ping for synchronization */
15940 MPING (CONTROL_PING, mp_ping);
15947 static void vl_api_map_add_domain_reply_t_handler
15948 (vl_api_map_add_domain_reply_t * mp)
15950 vat_main_t *vam = &vat_main;
15951 i32 retval = ntohl (mp->retval);
15953 if (vam->async_mode)
15955 vam->async_errors += (retval < 0);
15959 vam->retval = retval;
15960 vam->result_ready = 1;
15964 static void vl_api_map_add_domain_reply_t_handler_json
15965 (vl_api_map_add_domain_reply_t * mp)
15967 vat_main_t *vam = &vat_main;
15968 vat_json_node_t node;
15970 vat_json_init_object (&node);
15971 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
15972 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
15974 vat_json_print (vam->ofp, &node);
15975 vat_json_free (&node);
15977 vam->retval = ntohl (mp->retval);
15978 vam->result_ready = 1;
15982 api_get_first_msg_id (vat_main_t * vam)
15984 vl_api_get_first_msg_id_t *mp;
15985 unformat_input_t *i = vam->input;
15990 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15992 if (unformat (i, "client %s", &name))
16000 errmsg ("missing client name");
16003 vec_add1 (name, 0);
16005 if (vec_len (name) > 63)
16007 errmsg ("client name too long");
16011 M (GET_FIRST_MSG_ID, mp);
16012 clib_memcpy (mp->name, name, vec_len (name));
16019 api_cop_interface_enable_disable (vat_main_t * vam)
16021 unformat_input_t *line_input = vam->input;
16022 vl_api_cop_interface_enable_disable_t *mp;
16023 u32 sw_if_index = ~0;
16024 u8 enable_disable = 1;
16027 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
16029 if (unformat (line_input, "disable"))
16030 enable_disable = 0;
16031 if (unformat (line_input, "enable"))
16032 enable_disable = 1;
16033 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
16034 vam, &sw_if_index))
16036 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
16042 if (sw_if_index == ~0)
16044 errmsg ("missing interface name or sw_if_index");
16048 /* Construct the API message */
16049 M (COP_INTERFACE_ENABLE_DISABLE, mp);
16050 mp->sw_if_index = ntohl (sw_if_index);
16051 mp->enable_disable = enable_disable;
16055 /* Wait for the reply */
16061 api_cop_whitelist_enable_disable (vat_main_t * vam)
16063 unformat_input_t *line_input = vam->input;
16064 vl_api_cop_whitelist_enable_disable_t *mp;
16065 u32 sw_if_index = ~0;
16066 u8 ip4 = 0, ip6 = 0, default_cop = 0;
16070 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
16072 if (unformat (line_input, "ip4"))
16074 else if (unformat (line_input, "ip6"))
16076 else if (unformat (line_input, "default"))
16078 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
16079 vam, &sw_if_index))
16081 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
16083 else if (unformat (line_input, "fib-id %d", &fib_id))
16089 if (sw_if_index == ~0)
16091 errmsg ("missing interface name or sw_if_index");
16095 /* Construct the API message */
16096 M (COP_WHITELIST_ENABLE_DISABLE, mp);
16097 mp->sw_if_index = ntohl (sw_if_index);
16098 mp->fib_id = ntohl (fib_id);
16101 mp->default_cop = default_cop;
16105 /* Wait for the reply */
16111 api_get_node_graph (vat_main_t * vam)
16113 vl_api_get_node_graph_t *mp;
16116 M (GET_NODE_GRAPH, mp);
16120 /* Wait for the reply */
16126 /** Used for parsing LISP eids */
16127 typedef CLIB_PACKED(struct{
16128 u8 addr[16]; /**< eid address */
16129 u32 len; /**< prefix length if IP */
16130 u8 type; /**< type of eid */
16135 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
16137 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
16139 memset (a, 0, sizeof (a[0]));
16141 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
16143 a->type = 0; /* ipv4 type */
16145 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
16147 a->type = 1; /* ipv6 type */
16149 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
16151 a->type = 2; /* mac type */
16153 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
16155 a->type = 3; /* NSH type */
16156 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
16157 nsh->spi = clib_host_to_net_u32 (nsh->spi);
16164 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
16173 lisp_eid_size_vat (u8 type)
16190 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
16192 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
16196 api_one_add_del_locator_set (vat_main_t * vam)
16198 unformat_input_t *input = vam->input;
16199 vl_api_one_add_del_locator_set_t *mp;
16201 u8 *locator_set_name = NULL;
16202 u8 locator_set_name_set = 0;
16203 vl_api_local_locator_t locator, *locators = 0;
16204 u32 sw_if_index, priority, weight;
16208 /* Parse args required to build the message */
16209 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16211 if (unformat (input, "del"))
16215 else if (unformat (input, "locator-set %s", &locator_set_name))
16217 locator_set_name_set = 1;
16219 else if (unformat (input, "sw_if_index %u p %u w %u",
16220 &sw_if_index, &priority, &weight))
16222 locator.sw_if_index = htonl (sw_if_index);
16223 locator.priority = priority;
16224 locator.weight = weight;
16225 vec_add1 (locators, locator);
16229 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
16230 &sw_if_index, &priority, &weight))
16232 locator.sw_if_index = htonl (sw_if_index);
16233 locator.priority = priority;
16234 locator.weight = weight;
16235 vec_add1 (locators, locator);
16241 if (locator_set_name_set == 0)
16243 errmsg ("missing locator-set name");
16244 vec_free (locators);
16248 if (vec_len (locator_set_name) > 64)
16250 errmsg ("locator-set name too long");
16251 vec_free (locator_set_name);
16252 vec_free (locators);
16255 vec_add1 (locator_set_name, 0);
16257 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
16259 /* Construct the API message */
16260 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
16262 mp->is_add = is_add;
16263 clib_memcpy (mp->locator_set_name, locator_set_name,
16264 vec_len (locator_set_name));
16265 vec_free (locator_set_name);
16267 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
16269 clib_memcpy (mp->locators, locators, data_len);
16270 vec_free (locators);
16275 /* Wait for a reply... */
16280 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
16283 api_one_add_del_locator (vat_main_t * vam)
16285 unformat_input_t *input = vam->input;
16286 vl_api_one_add_del_locator_t *mp;
16287 u32 tmp_if_index = ~0;
16288 u32 sw_if_index = ~0;
16289 u8 sw_if_index_set = 0;
16290 u8 sw_if_index_if_name_set = 0;
16292 u8 priority_set = 0;
16296 u8 *locator_set_name = NULL;
16297 u8 locator_set_name_set = 0;
16300 /* Parse args required to build the message */
16301 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16303 if (unformat (input, "del"))
16307 else if (unformat (input, "locator-set %s", &locator_set_name))
16309 locator_set_name_set = 1;
16311 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
16314 sw_if_index_if_name_set = 1;
16315 sw_if_index = tmp_if_index;
16317 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
16319 sw_if_index_set = 1;
16320 sw_if_index = tmp_if_index;
16322 else if (unformat (input, "p %d", &priority))
16326 else if (unformat (input, "w %d", &weight))
16334 if (locator_set_name_set == 0)
16336 errmsg ("missing locator-set name");
16340 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
16342 errmsg ("missing sw_if_index");
16343 vec_free (locator_set_name);
16347 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
16349 errmsg ("cannot use both params interface name and sw_if_index");
16350 vec_free (locator_set_name);
16354 if (priority_set == 0)
16356 errmsg ("missing locator-set priority");
16357 vec_free (locator_set_name);
16361 if (weight_set == 0)
16363 errmsg ("missing locator-set weight");
16364 vec_free (locator_set_name);
16368 if (vec_len (locator_set_name) > 64)
16370 errmsg ("locator-set name too long");
16371 vec_free (locator_set_name);
16374 vec_add1 (locator_set_name, 0);
16376 /* Construct the API message */
16377 M (ONE_ADD_DEL_LOCATOR, mp);
16379 mp->is_add = is_add;
16380 mp->sw_if_index = ntohl (sw_if_index);
16381 mp->priority = priority;
16382 mp->weight = weight;
16383 clib_memcpy (mp->locator_set_name, locator_set_name,
16384 vec_len (locator_set_name));
16385 vec_free (locator_set_name);
16390 /* Wait for a reply... */
16395 #define api_lisp_add_del_locator api_one_add_del_locator
16398 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
16400 u32 *key_id = va_arg (*args, u32 *);
16403 if (unformat (input, "%s", &s))
16405 if (!strcmp ((char *) s, "sha1"))
16406 key_id[0] = HMAC_SHA_1_96;
16407 else if (!strcmp ((char *) s, "sha256"))
16408 key_id[0] = HMAC_SHA_256_128;
16411 clib_warning ("invalid key_id: '%s'", s);
16412 key_id[0] = HMAC_NO_KEY;
16423 api_one_add_del_local_eid (vat_main_t * vam)
16425 unformat_input_t *input = vam->input;
16426 vl_api_one_add_del_local_eid_t *mp;
16429 lisp_eid_vat_t _eid, *eid = &_eid;
16430 u8 *locator_set_name = 0;
16431 u8 locator_set_name_set = 0;
16437 /* Parse args required to build the message */
16438 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16440 if (unformat (input, "del"))
16444 else if (unformat (input, "vni %d", &vni))
16448 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
16452 else if (unformat (input, "locator-set %s", &locator_set_name))
16454 locator_set_name_set = 1;
16456 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
16458 else if (unformat (input, "secret-key %_%v%_", &key))
16464 if (locator_set_name_set == 0)
16466 errmsg ("missing locator-set name");
16472 errmsg ("EID address not set!");
16473 vec_free (locator_set_name);
16477 if (key && (0 == key_id))
16479 errmsg ("invalid key_id!");
16483 if (vec_len (key) > 64)
16485 errmsg ("key too long");
16490 if (vec_len (locator_set_name) > 64)
16492 errmsg ("locator-set name too long");
16493 vec_free (locator_set_name);
16496 vec_add1 (locator_set_name, 0);
16498 /* Construct the API message */
16499 M (ONE_ADD_DEL_LOCAL_EID, mp);
16501 mp->is_add = is_add;
16502 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
16503 mp->eid_type = eid->type;
16504 mp->prefix_len = eid->len;
16505 mp->vni = clib_host_to_net_u32 (vni);
16506 mp->key_id = clib_host_to_net_u16 (key_id);
16507 clib_memcpy (mp->locator_set_name, locator_set_name,
16508 vec_len (locator_set_name));
16509 clib_memcpy (mp->key, key, vec_len (key));
16511 vec_free (locator_set_name);
16517 /* Wait for a reply... */
16522 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
16525 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
16527 u32 dp_table = 0, vni = 0;;
16528 unformat_input_t *input = vam->input;
16529 vl_api_gpe_add_del_fwd_entry_t *mp;
16531 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
16532 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
16533 u8 rmt_eid_set = 0, lcl_eid_set = 0;
16534 u32 action = ~0, w;
16535 ip4_address_t rmt_rloc4, lcl_rloc4;
16536 ip6_address_t rmt_rloc6, lcl_rloc6;
16537 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
16540 memset (&rloc, 0, sizeof (rloc));
16542 /* Parse args required to build the message */
16543 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16545 if (unformat (input, "del"))
16547 else if (unformat (input, "add"))
16549 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
16553 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
16557 else if (unformat (input, "vrf %d", &dp_table))
16559 else if (unformat (input, "bd %d", &dp_table))
16561 else if (unformat (input, "vni %d", &vni))
16563 else if (unformat (input, "w %d", &w))
16567 errmsg ("No RLOC configured for setting priority/weight!");
16570 curr_rloc->weight = w;
16572 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
16573 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
16577 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
16579 vec_add1 (lcl_locs, rloc);
16581 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
16582 vec_add1 (rmt_locs, rloc);
16583 /* weight saved in rmt loc */
16584 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
16586 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
16587 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
16590 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
16592 vec_add1 (lcl_locs, rloc);
16594 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
16595 vec_add1 (rmt_locs, rloc);
16596 /* weight saved in rmt loc */
16597 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
16599 else if (unformat (input, "action %d", &action))
16605 clib_warning ("parse error '%U'", format_unformat_error, input);
16612 errmsg ("remote eid addresses not set");
16616 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
16618 errmsg ("eid types don't match");
16622 if (0 == rmt_locs && (u32) ~ 0 == action)
16624 errmsg ("action not set for negative mapping");
16628 /* Construct the API message */
16629 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
16630 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
16632 mp->is_add = is_add;
16633 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
16634 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
16635 mp->eid_type = rmt_eid->type;
16636 mp->dp_table = clib_host_to_net_u32 (dp_table);
16637 mp->vni = clib_host_to_net_u32 (vni);
16638 mp->rmt_len = rmt_eid->len;
16639 mp->lcl_len = lcl_eid->len;
16640 mp->action = action;
16642 if (0 != rmt_locs && 0 != lcl_locs)
16644 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
16645 clib_memcpy (mp->locs, lcl_locs,
16646 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
16648 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
16649 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
16650 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
16652 vec_free (lcl_locs);
16653 vec_free (rmt_locs);
16658 /* Wait for a reply... */
16664 api_one_add_del_map_server (vat_main_t * vam)
16666 unformat_input_t *input = vam->input;
16667 vl_api_one_add_del_map_server_t *mp;
16671 ip4_address_t ipv4;
16672 ip6_address_t ipv6;
16675 /* Parse args required to build the message */
16676 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16678 if (unformat (input, "del"))
16682 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
16686 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
16694 if (ipv4_set && ipv6_set)
16696 errmsg ("both eid v4 and v6 addresses set");
16700 if (!ipv4_set && !ipv6_set)
16702 errmsg ("eid addresses not set");
16706 /* Construct the API message */
16707 M (ONE_ADD_DEL_MAP_SERVER, mp);
16709 mp->is_add = is_add;
16713 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
16718 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
16724 /* Wait for a reply... */
16729 #define api_lisp_add_del_map_server api_one_add_del_map_server
16732 api_one_add_del_map_resolver (vat_main_t * vam)
16734 unformat_input_t *input = vam->input;
16735 vl_api_one_add_del_map_resolver_t *mp;
16739 ip4_address_t ipv4;
16740 ip6_address_t ipv6;
16743 /* Parse args required to build the message */
16744 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16746 if (unformat (input, "del"))
16750 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
16754 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
16762 if (ipv4_set && ipv6_set)
16764 errmsg ("both eid v4 and v6 addresses set");
16768 if (!ipv4_set && !ipv6_set)
16770 errmsg ("eid addresses not set");
16774 /* Construct the API message */
16775 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
16777 mp->is_add = is_add;
16781 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
16786 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
16792 /* Wait for a reply... */
16797 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
16800 api_lisp_gpe_enable_disable (vat_main_t * vam)
16802 unformat_input_t *input = vam->input;
16803 vl_api_gpe_enable_disable_t *mp;
16808 /* Parse args required to build the message */
16809 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16811 if (unformat (input, "enable"))
16816 else if (unformat (input, "disable"))
16827 errmsg ("Value not set");
16831 /* Construct the API message */
16832 M (GPE_ENABLE_DISABLE, mp);
16839 /* Wait for a reply... */
16845 api_one_rloc_probe_enable_disable (vat_main_t * vam)
16847 unformat_input_t *input = vam->input;
16848 vl_api_one_rloc_probe_enable_disable_t *mp;
16853 /* Parse args required to build the message */
16854 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16856 if (unformat (input, "enable"))
16861 else if (unformat (input, "disable"))
16869 errmsg ("Value not set");
16873 /* Construct the API message */
16874 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
16876 mp->is_enabled = is_en;
16881 /* Wait for a reply... */
16886 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
16889 api_one_map_register_enable_disable (vat_main_t * vam)
16891 unformat_input_t *input = vam->input;
16892 vl_api_one_map_register_enable_disable_t *mp;
16897 /* Parse args required to build the message */
16898 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16900 if (unformat (input, "enable"))
16905 else if (unformat (input, "disable"))
16913 errmsg ("Value not set");
16917 /* Construct the API message */
16918 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
16920 mp->is_enabled = is_en;
16925 /* Wait for a reply... */
16930 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
16933 api_one_enable_disable (vat_main_t * vam)
16935 unformat_input_t *input = vam->input;
16936 vl_api_one_enable_disable_t *mp;
16941 /* Parse args required to build the message */
16942 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16944 if (unformat (input, "enable"))
16949 else if (unformat (input, "disable"))
16959 errmsg ("Value not set");
16963 /* Construct the API message */
16964 M (ONE_ENABLE_DISABLE, mp);
16971 /* Wait for a reply... */
16976 #define api_lisp_enable_disable api_one_enable_disable
16979 api_one_enable_disable_xtr_mode (vat_main_t * vam)
16981 unformat_input_t *input = vam->input;
16982 vl_api_one_enable_disable_xtr_mode_t *mp;
16987 /* Parse args required to build the message */
16988 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16990 if (unformat (input, "enable"))
16995 else if (unformat (input, "disable"))
17005 errmsg ("Value not set");
17009 /* Construct the API message */
17010 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
17017 /* Wait for a reply... */
17023 api_one_show_xtr_mode (vat_main_t * vam)
17025 vl_api_one_show_xtr_mode_t *mp;
17028 /* Construct the API message */
17029 M (ONE_SHOW_XTR_MODE, mp);
17034 /* Wait for a reply... */
17040 api_one_enable_disable_pitr_mode (vat_main_t * vam)
17042 unformat_input_t *input = vam->input;
17043 vl_api_one_enable_disable_pitr_mode_t *mp;
17048 /* Parse args required to build the message */
17049 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17051 if (unformat (input, "enable"))
17056 else if (unformat (input, "disable"))
17066 errmsg ("Value not set");
17070 /* Construct the API message */
17071 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
17078 /* Wait for a reply... */
17084 api_one_show_pitr_mode (vat_main_t * vam)
17086 vl_api_one_show_pitr_mode_t *mp;
17089 /* Construct the API message */
17090 M (ONE_SHOW_PITR_MODE, mp);
17095 /* Wait for a reply... */
17101 api_one_enable_disable_petr_mode (vat_main_t * vam)
17103 unformat_input_t *input = vam->input;
17104 vl_api_one_enable_disable_petr_mode_t *mp;
17109 /* Parse args required to build the message */
17110 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17112 if (unformat (input, "enable"))
17117 else if (unformat (input, "disable"))
17127 errmsg ("Value not set");
17131 /* Construct the API message */
17132 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
17139 /* Wait for a reply... */
17145 api_one_show_petr_mode (vat_main_t * vam)
17147 vl_api_one_show_petr_mode_t *mp;
17150 /* Construct the API message */
17151 M (ONE_SHOW_PETR_MODE, mp);
17156 /* Wait for a reply... */
17162 api_show_one_map_register_state (vat_main_t * vam)
17164 vl_api_show_one_map_register_state_t *mp;
17167 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
17172 /* wait for reply */
17177 #define api_show_lisp_map_register_state api_show_one_map_register_state
17180 api_show_one_rloc_probe_state (vat_main_t * vam)
17182 vl_api_show_one_rloc_probe_state_t *mp;
17185 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
17190 /* wait for reply */
17195 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
17198 api_one_add_del_ndp_entry (vat_main_t * vam)
17200 vl_api_one_add_del_ndp_entry_t *mp;
17201 unformat_input_t *input = vam->input;
17206 u8 mac[6] = { 0, };
17207 u8 ip6[16] = { 0, };
17211 /* Parse args required to build the message */
17212 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17214 if (unformat (input, "del"))
17216 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
17218 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
17220 else if (unformat (input, "bd %d", &bd))
17224 errmsg ("parse error '%U'", format_unformat_error, input);
17229 if (!bd_set || !ip_set || (!mac_set && is_add))
17231 errmsg ("Missing BD, IP or MAC!");
17235 M (ONE_ADD_DEL_NDP_ENTRY, mp);
17236 mp->is_add = is_add;
17237 clib_memcpy (mp->mac, mac, 6);
17238 mp->bd = clib_host_to_net_u32 (bd);
17239 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
17244 /* wait for reply */
17250 api_one_add_del_l2_arp_entry (vat_main_t * vam)
17252 vl_api_one_add_del_l2_arp_entry_t *mp;
17253 unformat_input_t *input = vam->input;
17258 u8 mac[6] = { 0, };
17259 u32 ip4 = 0, bd = ~0;
17262 /* Parse args required to build the message */
17263 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17265 if (unformat (input, "del"))
17267 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
17269 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
17271 else if (unformat (input, "bd %d", &bd))
17275 errmsg ("parse error '%U'", format_unformat_error, input);
17280 if (!bd_set || !ip_set || (!mac_set && is_add))
17282 errmsg ("Missing BD, IP or MAC!");
17286 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
17287 mp->is_add = is_add;
17288 clib_memcpy (mp->mac, mac, 6);
17289 mp->bd = clib_host_to_net_u32 (bd);
17295 /* wait for reply */
17301 api_one_ndp_bd_get (vat_main_t * vam)
17303 vl_api_one_ndp_bd_get_t *mp;
17306 M (ONE_NDP_BD_GET, mp);
17311 /* wait for reply */
17317 api_one_ndp_entries_get (vat_main_t * vam)
17319 vl_api_one_ndp_entries_get_t *mp;
17320 unformat_input_t *input = vam->input;
17325 /* Parse args required to build the message */
17326 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17328 if (unformat (input, "bd %d", &bd))
17332 errmsg ("parse error '%U'", format_unformat_error, input);
17339 errmsg ("Expected bridge domain!");
17343 M (ONE_NDP_ENTRIES_GET, mp);
17344 mp->bd = clib_host_to_net_u32 (bd);
17349 /* wait for reply */
17355 api_one_l2_arp_bd_get (vat_main_t * vam)
17357 vl_api_one_l2_arp_bd_get_t *mp;
17360 M (ONE_L2_ARP_BD_GET, mp);
17365 /* wait for reply */
17371 api_one_l2_arp_entries_get (vat_main_t * vam)
17373 vl_api_one_l2_arp_entries_get_t *mp;
17374 unformat_input_t *input = vam->input;
17379 /* Parse args required to build the message */
17380 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17382 if (unformat (input, "bd %d", &bd))
17386 errmsg ("parse error '%U'", format_unformat_error, input);
17393 errmsg ("Expected bridge domain!");
17397 M (ONE_L2_ARP_ENTRIES_GET, mp);
17398 mp->bd = clib_host_to_net_u32 (bd);
17403 /* wait for reply */
17409 api_one_stats_enable_disable (vat_main_t * vam)
17411 vl_api_one_stats_enable_disable_t *mp;
17412 unformat_input_t *input = vam->input;
17417 /* Parse args required to build the message */
17418 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17420 if (unformat (input, "enable"))
17425 else if (unformat (input, "disable"))
17435 errmsg ("Value not set");
17439 M (ONE_STATS_ENABLE_DISABLE, mp);
17445 /* wait for reply */
17451 api_show_one_stats_enable_disable (vat_main_t * vam)
17453 vl_api_show_one_stats_enable_disable_t *mp;
17456 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
17461 /* wait for reply */
17467 api_show_one_map_request_mode (vat_main_t * vam)
17469 vl_api_show_one_map_request_mode_t *mp;
17472 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
17477 /* wait for reply */
17482 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
17485 api_one_map_request_mode (vat_main_t * vam)
17487 unformat_input_t *input = vam->input;
17488 vl_api_one_map_request_mode_t *mp;
17492 /* Parse args required to build the message */
17493 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17495 if (unformat (input, "dst-only"))
17497 else if (unformat (input, "src-dst"))
17501 errmsg ("parse error '%U'", format_unformat_error, input);
17506 M (ONE_MAP_REQUEST_MODE, mp);
17513 /* wait for reply */
17518 #define api_lisp_map_request_mode api_one_map_request_mode
17521 * Enable/disable ONE proxy ITR.
17523 * @param vam vpp API test context
17524 * @return return code
17527 api_one_pitr_set_locator_set (vat_main_t * vam)
17529 u8 ls_name_set = 0;
17530 unformat_input_t *input = vam->input;
17531 vl_api_one_pitr_set_locator_set_t *mp;
17536 /* Parse args required to build the message */
17537 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17539 if (unformat (input, "del"))
17541 else if (unformat (input, "locator-set %s", &ls_name))
17545 errmsg ("parse error '%U'", format_unformat_error, input);
17552 errmsg ("locator-set name not set!");
17556 M (ONE_PITR_SET_LOCATOR_SET, mp);
17558 mp->is_add = is_add;
17559 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
17560 vec_free (ls_name);
17565 /* wait for reply */
17570 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
17573 api_one_nsh_set_locator_set (vat_main_t * vam)
17575 u8 ls_name_set = 0;
17576 unformat_input_t *input = vam->input;
17577 vl_api_one_nsh_set_locator_set_t *mp;
17582 /* Parse args required to build the message */
17583 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17585 if (unformat (input, "del"))
17587 else if (unformat (input, "ls %s", &ls_name))
17591 errmsg ("parse error '%U'", format_unformat_error, input);
17596 if (!ls_name_set && is_add)
17598 errmsg ("locator-set name not set!");
17602 M (ONE_NSH_SET_LOCATOR_SET, mp);
17604 mp->is_add = is_add;
17605 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
17606 vec_free (ls_name);
17611 /* wait for reply */
17617 api_show_one_pitr (vat_main_t * vam)
17619 vl_api_show_one_pitr_t *mp;
17622 if (!vam->json_output)
17624 print (vam->ofp, "%=20s", "lisp status:");
17627 M (SHOW_ONE_PITR, mp);
17631 /* Wait for a reply... */
17636 #define api_show_lisp_pitr api_show_one_pitr
17639 api_one_use_petr (vat_main_t * vam)
17641 unformat_input_t *input = vam->input;
17642 vl_api_one_use_petr_t *mp;
17647 memset (&ip, 0, sizeof (ip));
17649 /* Parse args required to build the message */
17650 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17652 if (unformat (input, "disable"))
17655 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
17658 ip_addr_version (&ip) = IP4;
17661 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
17664 ip_addr_version (&ip) = IP6;
17668 errmsg ("parse error '%U'", format_unformat_error, input);
17673 M (ONE_USE_PETR, mp);
17675 mp->is_add = is_add;
17678 mp->is_ip4 = ip_addr_version (&ip) == IP4 ? 1 : 0;
17680 clib_memcpy (mp->address, &ip, 4);
17682 clib_memcpy (mp->address, &ip, 16);
17688 /* wait for reply */
17693 #define api_lisp_use_petr api_one_use_petr
17696 api_show_one_nsh_mapping (vat_main_t * vam)
17698 vl_api_show_one_use_petr_t *mp;
17701 if (!vam->json_output)
17703 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
17706 M (SHOW_ONE_NSH_MAPPING, mp);
17710 /* Wait for a reply... */
17716 api_show_one_use_petr (vat_main_t * vam)
17718 vl_api_show_one_use_petr_t *mp;
17721 if (!vam->json_output)
17723 print (vam->ofp, "%=20s", "Proxy-ETR status:");
17726 M (SHOW_ONE_USE_PETR, mp);
17730 /* Wait for a reply... */
17735 #define api_show_lisp_use_petr api_show_one_use_petr
17738 * Add/delete mapping between vni and vrf
17741 api_one_eid_table_add_del_map (vat_main_t * vam)
17743 unformat_input_t *input = vam->input;
17744 vl_api_one_eid_table_add_del_map_t *mp;
17745 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
17746 u32 vni, vrf, bd_index;
17749 /* Parse args required to build the message */
17750 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17752 if (unformat (input, "del"))
17754 else if (unformat (input, "vrf %d", &vrf))
17756 else if (unformat (input, "bd_index %d", &bd_index))
17758 else if (unformat (input, "vni %d", &vni))
17764 if (!vni_set || (!vrf_set && !bd_index_set))
17766 errmsg ("missing arguments!");
17770 if (vrf_set && bd_index_set)
17772 errmsg ("error: both vrf and bd entered!");
17776 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
17778 mp->is_add = is_add;
17779 mp->vni = htonl (vni);
17780 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
17781 mp->is_l2 = bd_index_set;
17786 /* wait for reply */
17791 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
17794 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
17796 u32 *action = va_arg (*args, u32 *);
17799 if (unformat (input, "%s", &s))
17801 if (!strcmp ((char *) s, "no-action"))
17803 else if (!strcmp ((char *) s, "natively-forward"))
17805 else if (!strcmp ((char *) s, "send-map-request"))
17807 else if (!strcmp ((char *) s, "drop"))
17811 clib_warning ("invalid action: '%s'", s);
17823 * Add/del remote mapping to/from ONE control plane
17825 * @param vam vpp API test context
17826 * @return return code
17829 api_one_add_del_remote_mapping (vat_main_t * vam)
17831 unformat_input_t *input = vam->input;
17832 vl_api_one_add_del_remote_mapping_t *mp;
17834 lisp_eid_vat_t _eid, *eid = &_eid;
17835 lisp_eid_vat_t _seid, *seid = &_seid;
17836 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
17837 u32 action = ~0, p, w, data_len;
17838 ip4_address_t rloc4;
17839 ip6_address_t rloc6;
17840 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
17843 memset (&rloc, 0, sizeof (rloc));
17845 /* Parse args required to build the message */
17846 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17848 if (unformat (input, "del-all"))
17852 else if (unformat (input, "del"))
17856 else if (unformat (input, "add"))
17860 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
17864 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
17868 else if (unformat (input, "vni %d", &vni))
17872 else if (unformat (input, "p %d w %d", &p, &w))
17876 errmsg ("No RLOC configured for setting priority/weight!");
17879 curr_rloc->priority = p;
17880 curr_rloc->weight = w;
17882 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
17885 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
17886 vec_add1 (rlocs, rloc);
17887 curr_rloc = &rlocs[vec_len (rlocs) - 1];
17889 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
17892 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
17893 vec_add1 (rlocs, rloc);
17894 curr_rloc = &rlocs[vec_len (rlocs) - 1];
17896 else if (unformat (input, "action %U",
17897 unformat_negative_mapping_action, &action))
17903 clib_warning ("parse error '%U'", format_unformat_error, input);
17910 errmsg ("missing params!");
17914 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
17916 errmsg ("no action set for negative map-reply!");
17920 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
17922 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
17923 mp->is_add = is_add;
17924 mp->vni = htonl (vni);
17925 mp->action = (u8) action;
17926 mp->is_src_dst = seid_set;
17927 mp->eid_len = eid->len;
17928 mp->seid_len = seid->len;
17929 mp->del_all = del_all;
17930 mp->eid_type = eid->type;
17931 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
17932 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
17934 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
17935 clib_memcpy (mp->rlocs, rlocs, data_len);
17941 /* Wait for a reply... */
17946 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
17949 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
17950 * forwarding entries in data-plane accordingly.
17952 * @param vam vpp API test context
17953 * @return return code
17956 api_one_add_del_adjacency (vat_main_t * vam)
17958 unformat_input_t *input = vam->input;
17959 vl_api_one_add_del_adjacency_t *mp;
17961 ip4_address_t leid4, reid4;
17962 ip6_address_t leid6, reid6;
17963 u8 reid_mac[6] = { 0 };
17964 u8 leid_mac[6] = { 0 };
17965 u8 reid_type, leid_type;
17966 u32 leid_len = 0, reid_len = 0, len;
17970 leid_type = reid_type = (u8) ~ 0;
17972 /* Parse args required to build the message */
17973 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17975 if (unformat (input, "del"))
17979 else if (unformat (input, "add"))
17983 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
17986 reid_type = 0; /* ipv4 */
17989 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
17992 reid_type = 1; /* ipv6 */
17995 else if (unformat (input, "reid %U", unformat_ethernet_address,
17998 reid_type = 2; /* mac */
18000 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
18003 leid_type = 0; /* ipv4 */
18006 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
18009 leid_type = 1; /* ipv6 */
18012 else if (unformat (input, "leid %U", unformat_ethernet_address,
18015 leid_type = 2; /* mac */
18017 else if (unformat (input, "vni %d", &vni))
18023 errmsg ("parse error '%U'", format_unformat_error, input);
18028 if ((u8) ~ 0 == reid_type)
18030 errmsg ("missing params!");
18034 if (leid_type != reid_type)
18036 errmsg ("remote and local EIDs are of different types!");
18040 M (ONE_ADD_DEL_ADJACENCY, mp);
18041 mp->is_add = is_add;
18042 mp->vni = htonl (vni);
18043 mp->leid_len = leid_len;
18044 mp->reid_len = reid_len;
18045 mp->eid_type = reid_type;
18047 switch (mp->eid_type)
18050 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
18051 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
18054 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
18055 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
18058 clib_memcpy (mp->leid, leid_mac, 6);
18059 clib_memcpy (mp->reid, reid_mac, 6);
18062 errmsg ("unknown EID type %d!", mp->eid_type);
18069 /* Wait for a reply... */
18074 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
18077 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
18079 u32 *mode = va_arg (*args, u32 *);
18081 if (unformat (input, "lisp"))
18083 else if (unformat (input, "vxlan"))
18092 api_gpe_get_encap_mode (vat_main_t * vam)
18094 vl_api_gpe_get_encap_mode_t *mp;
18097 /* Construct the API message */
18098 M (GPE_GET_ENCAP_MODE, mp);
18103 /* Wait for a reply... */
18109 api_gpe_set_encap_mode (vat_main_t * vam)
18111 unformat_input_t *input = vam->input;
18112 vl_api_gpe_set_encap_mode_t *mp;
18116 /* Parse args required to build the message */
18117 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18119 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
18125 /* Construct the API message */
18126 M (GPE_SET_ENCAP_MODE, mp);
18133 /* Wait for a reply... */
18139 api_lisp_gpe_add_del_iface (vat_main_t * vam)
18141 unformat_input_t *input = vam->input;
18142 vl_api_gpe_add_del_iface_t *mp;
18143 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
18144 u32 dp_table = 0, vni = 0;
18147 /* Parse args required to build the message */
18148 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18150 if (unformat (input, "up"))
18155 else if (unformat (input, "down"))
18160 else if (unformat (input, "table_id %d", &dp_table))
18164 else if (unformat (input, "bd_id %d", &dp_table))
18169 else if (unformat (input, "vni %d", &vni))
18177 if (action_set == 0)
18179 errmsg ("Action not set");
18182 if (dp_table_set == 0 || vni_set == 0)
18184 errmsg ("vni and dp_table must be set");
18188 /* Construct the API message */
18189 M (GPE_ADD_DEL_IFACE, mp);
18191 mp->is_add = is_add;
18192 mp->dp_table = clib_host_to_net_u32 (dp_table);
18194 mp->vni = clib_host_to_net_u32 (vni);
18199 /* Wait for a reply... */
18205 api_one_map_register_fallback_threshold (vat_main_t * vam)
18207 unformat_input_t *input = vam->input;
18208 vl_api_one_map_register_fallback_threshold_t *mp;
18213 /* Parse args required to build the message */
18214 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18216 if (unformat (input, "%u", &value))
18220 clib_warning ("parse error '%U'", format_unformat_error, input);
18227 errmsg ("fallback threshold value is missing!");
18231 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
18232 mp->value = clib_host_to_net_u32 (value);
18237 /* Wait for a reply... */
18243 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
18245 vl_api_show_one_map_register_fallback_threshold_t *mp;
18248 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
18253 /* Wait for a reply... */
18259 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
18261 u32 *proto = va_arg (*args, u32 *);
18263 if (unformat (input, "udp"))
18265 else if (unformat (input, "api"))
18274 api_one_set_transport_protocol (vat_main_t * vam)
18276 unformat_input_t *input = vam->input;
18277 vl_api_one_set_transport_protocol_t *mp;
18282 /* Parse args required to build the message */
18283 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18285 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
18289 clib_warning ("parse error '%U'", format_unformat_error, input);
18296 errmsg ("Transport protocol missing!");
18300 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
18301 mp->protocol = (u8) protocol;
18306 /* Wait for a reply... */
18312 api_one_get_transport_protocol (vat_main_t * vam)
18314 vl_api_one_get_transport_protocol_t *mp;
18317 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
18322 /* Wait for a reply... */
18328 api_one_map_register_set_ttl (vat_main_t * vam)
18330 unformat_input_t *input = vam->input;
18331 vl_api_one_map_register_set_ttl_t *mp;
18336 /* Parse args required to build the message */
18337 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18339 if (unformat (input, "%u", &ttl))
18343 clib_warning ("parse error '%U'", format_unformat_error, input);
18350 errmsg ("TTL value missing!");
18354 M (ONE_MAP_REGISTER_SET_TTL, mp);
18355 mp->ttl = clib_host_to_net_u32 (ttl);
18360 /* Wait for a reply... */
18366 api_show_one_map_register_ttl (vat_main_t * vam)
18368 vl_api_show_one_map_register_ttl_t *mp;
18371 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
18376 /* Wait for a reply... */
18382 * Add/del map request itr rlocs from ONE control plane and updates
18384 * @param vam vpp API test context
18385 * @return return code
18388 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
18390 unformat_input_t *input = vam->input;
18391 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
18392 u8 *locator_set_name = 0;
18393 u8 locator_set_name_set = 0;
18397 /* Parse args required to build the message */
18398 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18400 if (unformat (input, "del"))
18404 else if (unformat (input, "%_%v%_", &locator_set_name))
18406 locator_set_name_set = 1;
18410 clib_warning ("parse error '%U'", format_unformat_error, input);
18415 if (is_add && !locator_set_name_set)
18417 errmsg ("itr-rloc is not set!");
18421 if (is_add && vec_len (locator_set_name) > 64)
18423 errmsg ("itr-rloc locator-set name too long");
18424 vec_free (locator_set_name);
18428 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
18429 mp->is_add = is_add;
18432 clib_memcpy (mp->locator_set_name, locator_set_name,
18433 vec_len (locator_set_name));
18437 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
18439 vec_free (locator_set_name);
18444 /* Wait for a reply... */
18449 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
18452 api_one_locator_dump (vat_main_t * vam)
18454 unformat_input_t *input = vam->input;
18455 vl_api_one_locator_dump_t *mp;
18456 vl_api_control_ping_t *mp_ping;
18457 u8 is_index_set = 0, is_name_set = 0;
18462 /* Parse args required to build the message */
18463 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18465 if (unformat (input, "ls_name %_%v%_", &ls_name))
18469 else if (unformat (input, "ls_index %d", &ls_index))
18475 errmsg ("parse error '%U'", format_unformat_error, input);
18480 if (!is_index_set && !is_name_set)
18482 errmsg ("error: expected one of index or name!");
18486 if (is_index_set && is_name_set)
18488 errmsg ("error: only one param expected!");
18492 if (vec_len (ls_name) > 62)
18494 errmsg ("error: locator set name too long!");
18498 if (!vam->json_output)
18500 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
18503 M (ONE_LOCATOR_DUMP, mp);
18504 mp->is_index_set = is_index_set;
18507 mp->ls_index = clib_host_to_net_u32 (ls_index);
18510 vec_add1 (ls_name, 0);
18511 strncpy ((char *) mp->ls_name, (char *) ls_name,
18512 sizeof (mp->ls_name) - 1);
18518 /* Use a control ping for synchronization */
18519 MPING (CONTROL_PING, mp_ping);
18522 /* Wait for a reply... */
18527 #define api_lisp_locator_dump api_one_locator_dump
18530 api_one_locator_set_dump (vat_main_t * vam)
18532 vl_api_one_locator_set_dump_t *mp;
18533 vl_api_control_ping_t *mp_ping;
18534 unformat_input_t *input = vam->input;
18538 /* Parse args required to build the message */
18539 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18541 if (unformat (input, "local"))
18545 else if (unformat (input, "remote"))
18551 errmsg ("parse error '%U'", format_unformat_error, input);
18556 if (!vam->json_output)
18558 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
18561 M (ONE_LOCATOR_SET_DUMP, mp);
18563 mp->filter = filter;
18568 /* Use a control ping for synchronization */
18569 MPING (CONTROL_PING, mp_ping);
18572 /* Wait for a reply... */
18577 #define api_lisp_locator_set_dump api_one_locator_set_dump
18580 api_one_eid_table_map_dump (vat_main_t * vam)
18584 unformat_input_t *input = vam->input;
18585 vl_api_one_eid_table_map_dump_t *mp;
18586 vl_api_control_ping_t *mp_ping;
18589 /* Parse args required to build the message */
18590 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18592 if (unformat (input, "l2"))
18597 else if (unformat (input, "l3"))
18604 errmsg ("parse error '%U'", format_unformat_error, input);
18611 errmsg ("expected one of 'l2' or 'l3' parameter!");
18615 if (!vam->json_output)
18617 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
18620 M (ONE_EID_TABLE_MAP_DUMP, mp);
18626 /* Use a control ping for synchronization */
18627 MPING (CONTROL_PING, mp_ping);
18630 /* Wait for a reply... */
18635 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
18638 api_one_eid_table_vni_dump (vat_main_t * vam)
18640 vl_api_one_eid_table_vni_dump_t *mp;
18641 vl_api_control_ping_t *mp_ping;
18644 if (!vam->json_output)
18646 print (vam->ofp, "VNI");
18649 M (ONE_EID_TABLE_VNI_DUMP, mp);
18654 /* Use a control ping for synchronization */
18655 MPING (CONTROL_PING, mp_ping);
18658 /* Wait for a reply... */
18663 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
18666 api_one_eid_table_dump (vat_main_t * vam)
18668 unformat_input_t *i = vam->input;
18669 vl_api_one_eid_table_dump_t *mp;
18670 vl_api_control_ping_t *mp_ping;
18671 struct in_addr ip4;
18672 struct in6_addr ip6;
18674 u8 eid_type = ~0, eid_set = 0;
18675 u32 prefix_length = ~0, t, vni = 0;
18678 lisp_nsh_api_t nsh;
18680 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18682 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
18688 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
18694 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
18699 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
18704 else if (unformat (i, "vni %d", &t))
18708 else if (unformat (i, "local"))
18712 else if (unformat (i, "remote"))
18718 errmsg ("parse error '%U'", format_unformat_error, i);
18723 if (!vam->json_output)
18725 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
18726 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
18729 M (ONE_EID_TABLE_DUMP, mp);
18731 mp->filter = filter;
18735 mp->vni = htonl (vni);
18736 mp->eid_type = eid_type;
18740 mp->prefix_length = prefix_length;
18741 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
18744 mp->prefix_length = prefix_length;
18745 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
18748 clib_memcpy (mp->eid, mac, sizeof (mac));
18751 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
18754 errmsg ("unknown EID type %d!", eid_type);
18762 /* Use a control ping for synchronization */
18763 MPING (CONTROL_PING, mp_ping);
18766 /* Wait for a reply... */
18771 #define api_lisp_eid_table_dump api_one_eid_table_dump
18774 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
18776 unformat_input_t *i = vam->input;
18777 vl_api_gpe_fwd_entries_get_t *mp;
18782 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18784 if (unformat (i, "vni %d", &vni))
18790 errmsg ("parse error '%U'", format_unformat_error, i);
18797 errmsg ("vni not set!");
18801 if (!vam->json_output)
18803 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
18807 M (GPE_FWD_ENTRIES_GET, mp);
18808 mp->vni = clib_host_to_net_u32 (vni);
18813 /* Wait for a reply... */
18818 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
18819 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
18820 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
18821 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
18822 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
18823 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
18824 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
18825 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
18828 api_one_adjacencies_get (vat_main_t * vam)
18830 unformat_input_t *i = vam->input;
18831 vl_api_one_adjacencies_get_t *mp;
18836 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18838 if (unformat (i, "vni %d", &vni))
18844 errmsg ("parse error '%U'", format_unformat_error, i);
18851 errmsg ("vni not set!");
18855 if (!vam->json_output)
18857 print (vam->ofp, "%s %40s", "leid", "reid");
18860 M (ONE_ADJACENCIES_GET, mp);
18861 mp->vni = clib_host_to_net_u32 (vni);
18866 /* Wait for a reply... */
18871 #define api_lisp_adjacencies_get api_one_adjacencies_get
18874 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
18876 unformat_input_t *i = vam->input;
18877 vl_api_gpe_native_fwd_rpaths_get_t *mp;
18879 u8 ip_family_set = 0, is_ip4 = 1;
18881 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18883 if (unformat (i, "ip4"))
18888 else if (unformat (i, "ip6"))
18895 errmsg ("parse error '%U'", format_unformat_error, i);
18900 if (!ip_family_set)
18902 errmsg ("ip family not set!");
18906 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
18907 mp->is_ip4 = is_ip4;
18912 /* Wait for a reply... */
18918 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
18920 vl_api_gpe_fwd_entry_vnis_get_t *mp;
18923 if (!vam->json_output)
18925 print (vam->ofp, "VNIs");
18928 M (GPE_FWD_ENTRY_VNIS_GET, mp);
18933 /* Wait for a reply... */
18939 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
18941 unformat_input_t *i = vam->input;
18942 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
18944 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
18945 struct in_addr ip4;
18946 struct in6_addr ip6;
18947 u32 table_id = 0, nh_sw_if_index = ~0;
18949 memset (&ip4, 0, sizeof (ip4));
18950 memset (&ip6, 0, sizeof (ip6));
18952 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18954 if (unformat (i, "del"))
18956 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
18957 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18962 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
18963 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18968 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
18972 nh_sw_if_index = ~0;
18974 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
18978 nh_sw_if_index = ~0;
18980 else if (unformat (i, "table %d", &table_id))
18984 errmsg ("parse error '%U'", format_unformat_error, i);
18991 errmsg ("nh addr not set!");
18995 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
18996 mp->is_add = is_add;
18997 mp->table_id = clib_host_to_net_u32 (table_id);
18998 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
18999 mp->is_ip4 = is_ip4;
19001 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
19003 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
19008 /* Wait for a reply... */
19014 api_one_map_server_dump (vat_main_t * vam)
19016 vl_api_one_map_server_dump_t *mp;
19017 vl_api_control_ping_t *mp_ping;
19020 if (!vam->json_output)
19022 print (vam->ofp, "%=20s", "Map server");
19025 M (ONE_MAP_SERVER_DUMP, mp);
19029 /* Use a control ping for synchronization */
19030 MPING (CONTROL_PING, mp_ping);
19033 /* Wait for a reply... */
19038 #define api_lisp_map_server_dump api_one_map_server_dump
19041 api_one_map_resolver_dump (vat_main_t * vam)
19043 vl_api_one_map_resolver_dump_t *mp;
19044 vl_api_control_ping_t *mp_ping;
19047 if (!vam->json_output)
19049 print (vam->ofp, "%=20s", "Map resolver");
19052 M (ONE_MAP_RESOLVER_DUMP, mp);
19056 /* Use a control ping for synchronization */
19057 MPING (CONTROL_PING, mp_ping);
19060 /* Wait for a reply... */
19065 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
19068 api_one_stats_flush (vat_main_t * vam)
19070 vl_api_one_stats_flush_t *mp;
19073 M (ONE_STATS_FLUSH, mp);
19080 api_one_stats_dump (vat_main_t * vam)
19082 vl_api_one_stats_dump_t *mp;
19083 vl_api_control_ping_t *mp_ping;
19086 M (ONE_STATS_DUMP, mp);
19090 /* Use a control ping for synchronization */
19091 MPING (CONTROL_PING, mp_ping);
19094 /* Wait for a reply... */
19100 api_show_one_status (vat_main_t * vam)
19102 vl_api_show_one_status_t *mp;
19105 if (!vam->json_output)
19107 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
19110 M (SHOW_ONE_STATUS, mp);
19113 /* Wait for a reply... */
19118 #define api_show_lisp_status api_show_one_status
19121 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
19123 vl_api_gpe_fwd_entry_path_dump_t *mp;
19124 vl_api_control_ping_t *mp_ping;
19125 unformat_input_t *i = vam->input;
19126 u32 fwd_entry_index = ~0;
19129 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19131 if (unformat (i, "index %d", &fwd_entry_index))
19137 if (~0 == fwd_entry_index)
19139 errmsg ("no index specified!");
19143 if (!vam->json_output)
19145 print (vam->ofp, "first line");
19148 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
19152 /* Use a control ping for synchronization */
19153 MPING (CONTROL_PING, mp_ping);
19156 /* Wait for a reply... */
19162 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
19164 vl_api_one_get_map_request_itr_rlocs_t *mp;
19167 if (!vam->json_output)
19169 print (vam->ofp, "%=20s", "itr-rlocs:");
19172 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
19175 /* Wait for a reply... */
19180 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
19183 api_af_packet_create (vat_main_t * vam)
19185 unformat_input_t *i = vam->input;
19186 vl_api_af_packet_create_t *mp;
19187 u8 *host_if_name = 0;
19189 u8 random_hw_addr = 1;
19192 memset (hw_addr, 0, sizeof (hw_addr));
19194 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19196 if (unformat (i, "name %s", &host_if_name))
19197 vec_add1 (host_if_name, 0);
19198 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
19199 random_hw_addr = 0;
19204 if (!vec_len (host_if_name))
19206 errmsg ("host-interface name must be specified");
19210 if (vec_len (host_if_name) > 64)
19212 errmsg ("host-interface name too long");
19216 M (AF_PACKET_CREATE, mp);
19218 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
19219 clib_memcpy (mp->hw_addr, hw_addr, 6);
19220 mp->use_random_hw_addr = random_hw_addr;
19221 vec_free (host_if_name);
19229 fprintf (vam->ofp ? vam->ofp : stderr,
19230 " new sw_if_index = %d\n", vam->sw_if_index);
19237 api_af_packet_delete (vat_main_t * vam)
19239 unformat_input_t *i = vam->input;
19240 vl_api_af_packet_delete_t *mp;
19241 u8 *host_if_name = 0;
19244 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19246 if (unformat (i, "name %s", &host_if_name))
19247 vec_add1 (host_if_name, 0);
19252 if (!vec_len (host_if_name))
19254 errmsg ("host-interface name must be specified");
19258 if (vec_len (host_if_name) > 64)
19260 errmsg ("host-interface name too long");
19264 M (AF_PACKET_DELETE, mp);
19266 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
19267 vec_free (host_if_name);
19275 api_policer_add_del (vat_main_t * vam)
19277 unformat_input_t *i = vam->input;
19278 vl_api_policer_add_del_t *mp;
19288 u8 color_aware = 0;
19289 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
19292 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
19293 conform_action.dscp = 0;
19294 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
19295 exceed_action.dscp = 0;
19296 violate_action.action_type = SSE2_QOS_ACTION_DROP;
19297 violate_action.dscp = 0;
19299 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19301 if (unformat (i, "del"))
19303 else if (unformat (i, "name %s", &name))
19304 vec_add1 (name, 0);
19305 else if (unformat (i, "cir %u", &cir))
19307 else if (unformat (i, "eir %u", &eir))
19309 else if (unformat (i, "cb %u", &cb))
19311 else if (unformat (i, "eb %u", &eb))
19313 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
19316 else if (unformat (i, "round_type %U", unformat_policer_round_type,
19319 else if (unformat (i, "type %U", unformat_policer_type, &type))
19321 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
19324 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
19327 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
19330 else if (unformat (i, "color-aware"))
19336 if (!vec_len (name))
19338 errmsg ("policer name must be specified");
19342 if (vec_len (name) > 64)
19344 errmsg ("policer name too long");
19348 M (POLICER_ADD_DEL, mp);
19350 clib_memcpy (mp->name, name, vec_len (name));
19352 mp->is_add = is_add;
19353 mp->cir = ntohl (cir);
19354 mp->eir = ntohl (eir);
19355 mp->cb = clib_net_to_host_u64 (cb);
19356 mp->eb = clib_net_to_host_u64 (eb);
19357 mp->rate_type = rate_type;
19358 mp->round_type = round_type;
19360 mp->conform_action_type = conform_action.action_type;
19361 mp->conform_dscp = conform_action.dscp;
19362 mp->exceed_action_type = exceed_action.action_type;
19363 mp->exceed_dscp = exceed_action.dscp;
19364 mp->violate_action_type = violate_action.action_type;
19365 mp->violate_dscp = violate_action.dscp;
19366 mp->color_aware = color_aware;
19374 api_policer_dump (vat_main_t * vam)
19376 unformat_input_t *i = vam->input;
19377 vl_api_policer_dump_t *mp;
19378 vl_api_control_ping_t *mp_ping;
19379 u8 *match_name = 0;
19380 u8 match_name_valid = 0;
19383 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19385 if (unformat (i, "name %s", &match_name))
19387 vec_add1 (match_name, 0);
19388 match_name_valid = 1;
19394 M (POLICER_DUMP, mp);
19395 mp->match_name_valid = match_name_valid;
19396 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
19397 vec_free (match_name);
19401 /* Use a control ping for synchronization */
19402 MPING (CONTROL_PING, mp_ping);
19405 /* Wait for a reply... */
19411 api_policer_classify_set_interface (vat_main_t * vam)
19413 unformat_input_t *i = vam->input;
19414 vl_api_policer_classify_set_interface_t *mp;
19416 int sw_if_index_set;
19417 u32 ip4_table_index = ~0;
19418 u32 ip6_table_index = ~0;
19419 u32 l2_table_index = ~0;
19423 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19425 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19426 sw_if_index_set = 1;
19427 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19428 sw_if_index_set = 1;
19429 else if (unformat (i, "del"))
19431 else if (unformat (i, "ip4-table %d", &ip4_table_index))
19433 else if (unformat (i, "ip6-table %d", &ip6_table_index))
19435 else if (unformat (i, "l2-table %d", &l2_table_index))
19439 clib_warning ("parse error '%U'", format_unformat_error, i);
19444 if (sw_if_index_set == 0)
19446 errmsg ("missing interface name or sw_if_index");
19450 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
19452 mp->sw_if_index = ntohl (sw_if_index);
19453 mp->ip4_table_index = ntohl (ip4_table_index);
19454 mp->ip6_table_index = ntohl (ip6_table_index);
19455 mp->l2_table_index = ntohl (l2_table_index);
19456 mp->is_add = is_add;
19464 api_policer_classify_dump (vat_main_t * vam)
19466 unformat_input_t *i = vam->input;
19467 vl_api_policer_classify_dump_t *mp;
19468 vl_api_control_ping_t *mp_ping;
19469 u8 type = POLICER_CLASSIFY_N_TABLES;
19472 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
19476 errmsg ("classify table type must be specified");
19480 if (!vam->json_output)
19482 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
19485 M (POLICER_CLASSIFY_DUMP, mp);
19490 /* Use a control ping for synchronization */
19491 MPING (CONTROL_PING, mp_ping);
19494 /* Wait for a reply... */
19500 api_netmap_create (vat_main_t * vam)
19502 unformat_input_t *i = vam->input;
19503 vl_api_netmap_create_t *mp;
19506 u8 random_hw_addr = 1;
19511 memset (hw_addr, 0, sizeof (hw_addr));
19513 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19515 if (unformat (i, "name %s", &if_name))
19516 vec_add1 (if_name, 0);
19517 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
19518 random_hw_addr = 0;
19519 else if (unformat (i, "pipe"))
19521 else if (unformat (i, "master"))
19523 else if (unformat (i, "slave"))
19529 if (!vec_len (if_name))
19531 errmsg ("interface name must be specified");
19535 if (vec_len (if_name) > 64)
19537 errmsg ("interface name too long");
19541 M (NETMAP_CREATE, mp);
19543 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
19544 clib_memcpy (mp->hw_addr, hw_addr, 6);
19545 mp->use_random_hw_addr = random_hw_addr;
19546 mp->is_pipe = is_pipe;
19547 mp->is_master = is_master;
19548 vec_free (if_name);
19556 api_netmap_delete (vat_main_t * vam)
19558 unformat_input_t *i = vam->input;
19559 vl_api_netmap_delete_t *mp;
19563 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19565 if (unformat (i, "name %s", &if_name))
19566 vec_add1 (if_name, 0);
19571 if (!vec_len (if_name))
19573 errmsg ("interface name must be specified");
19577 if (vec_len (if_name) > 64)
19579 errmsg ("interface name too long");
19583 M (NETMAP_DELETE, mp);
19585 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
19586 vec_free (if_name);
19594 vl_api_mpls_fib_path_print (vat_main_t * vam, vl_api_fib_path2_t * fp)
19596 if (fp->afi == IP46_TYPE_IP6)
19598 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19599 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19600 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19601 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19602 format_ip6_address, fp->next_hop);
19603 else if (fp->afi == IP46_TYPE_IP4)
19605 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19606 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19607 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19608 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19609 format_ip4_address, fp->next_hop);
19613 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
19614 vl_api_fib_path2_t * fp)
19616 struct in_addr ip4;
19617 struct in6_addr ip6;
19619 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19620 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19621 vat_json_object_add_uint (node, "is_local", fp->is_local);
19622 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19623 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19624 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19625 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19626 if (fp->afi == IP46_TYPE_IP4)
19628 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19629 vat_json_object_add_ip4 (node, "next_hop", ip4);
19631 else if (fp->afi == IP46_TYPE_IP6)
19633 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19634 vat_json_object_add_ip6 (node, "next_hop", ip6);
19639 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
19641 vat_main_t *vam = &vat_main;
19642 int count = ntohl (mp->mt_count);
19643 vl_api_fib_path2_t *fp;
19646 print (vam->ofp, "[%d]: sw_if_index %d via:",
19647 ntohl (mp->mt_tunnel_index), ntohl (mp->mt_sw_if_index));
19649 for (i = 0; i < count; i++)
19651 vl_api_mpls_fib_path_print (vam, fp);
19655 print (vam->ofp, "");
19658 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
19659 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
19662 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
19664 vat_main_t *vam = &vat_main;
19665 vat_json_node_t *node = NULL;
19666 int count = ntohl (mp->mt_count);
19667 vl_api_fib_path2_t *fp;
19670 if (VAT_JSON_ARRAY != vam->json_tree.type)
19672 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19673 vat_json_init_array (&vam->json_tree);
19675 node = vat_json_array_add (&vam->json_tree);
19677 vat_json_init_object (node);
19678 vat_json_object_add_uint (node, "tunnel_index",
19679 ntohl (mp->mt_tunnel_index));
19680 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->mt_sw_if_index));
19682 vat_json_object_add_uint (node, "l2_only", mp->mt_l2_only);
19685 for (i = 0; i < count; i++)
19687 vl_api_mpls_fib_path_json_print (node, fp);
19693 api_mpls_tunnel_dump (vat_main_t * vam)
19695 vl_api_mpls_tunnel_dump_t *mp;
19696 vl_api_control_ping_t *mp_ping;
19700 /* Parse args required to build the message */
19701 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
19703 if (!unformat (vam->input, "tunnel_index %d", &index))
19710 print (vam->ofp, " tunnel_index %d", index);
19712 M (MPLS_TUNNEL_DUMP, mp);
19713 mp->tunnel_index = htonl (index);
19716 /* Use a control ping for synchronization */
19717 MPING (CONTROL_PING, mp_ping);
19724 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
19725 #define vl_api_mpls_fib_details_t_print vl_noop_handler
19729 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
19731 vat_main_t *vam = &vat_main;
19732 int count = ntohl (mp->count);
19733 vl_api_fib_path2_t *fp;
19737 "table-id %d, label %u, ess_bit %u",
19738 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
19740 for (i = 0; i < count; i++)
19742 vl_api_mpls_fib_path_print (vam, fp);
19747 static void vl_api_mpls_fib_details_t_handler_json
19748 (vl_api_mpls_fib_details_t * mp)
19750 vat_main_t *vam = &vat_main;
19751 int count = ntohl (mp->count);
19752 vat_json_node_t *node = NULL;
19753 vl_api_fib_path2_t *fp;
19756 if (VAT_JSON_ARRAY != vam->json_tree.type)
19758 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19759 vat_json_init_array (&vam->json_tree);
19761 node = vat_json_array_add (&vam->json_tree);
19763 vat_json_init_object (node);
19764 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19765 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
19766 vat_json_object_add_uint (node, "label", ntohl (mp->label));
19767 vat_json_object_add_uint (node, "path_count", count);
19769 for (i = 0; i < count; i++)
19771 vl_api_mpls_fib_path_json_print (node, fp);
19777 api_mpls_fib_dump (vat_main_t * vam)
19779 vl_api_mpls_fib_dump_t *mp;
19780 vl_api_control_ping_t *mp_ping;
19783 M (MPLS_FIB_DUMP, mp);
19786 /* Use a control ping for synchronization */
19787 MPING (CONTROL_PING, mp_ping);
19794 #define vl_api_ip_fib_details_t_endian vl_noop_handler
19795 #define vl_api_ip_fib_details_t_print vl_noop_handler
19798 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
19800 vat_main_t *vam = &vat_main;
19801 int count = ntohl (mp->count);
19802 vl_api_fib_path_t *fp;
19806 "table-id %d, prefix %U/%d",
19807 ntohl (mp->table_id), format_ip4_address, mp->address,
19808 mp->address_length);
19810 for (i = 0; i < count; i++)
19812 if (fp->afi == IP46_TYPE_IP6)
19814 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19815 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19816 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19817 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19818 format_ip6_address, fp->next_hop);
19819 else if (fp->afi == IP46_TYPE_IP4)
19821 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19822 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19823 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19824 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19825 format_ip4_address, fp->next_hop);
19830 static void vl_api_ip_fib_details_t_handler_json
19831 (vl_api_ip_fib_details_t * mp)
19833 vat_main_t *vam = &vat_main;
19834 int count = ntohl (mp->count);
19835 vat_json_node_t *node = NULL;
19836 struct in_addr ip4;
19837 struct in6_addr ip6;
19838 vl_api_fib_path_t *fp;
19841 if (VAT_JSON_ARRAY != vam->json_tree.type)
19843 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19844 vat_json_init_array (&vam->json_tree);
19846 node = vat_json_array_add (&vam->json_tree);
19848 vat_json_init_object (node);
19849 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19850 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
19851 vat_json_object_add_ip4 (node, "prefix", ip4);
19852 vat_json_object_add_uint (node, "mask_length", mp->address_length);
19853 vat_json_object_add_uint (node, "path_count", count);
19855 for (i = 0; i < count; i++)
19857 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19858 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19859 vat_json_object_add_uint (node, "is_local", fp->is_local);
19860 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19861 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19862 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19863 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19864 if (fp->afi == IP46_TYPE_IP4)
19866 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19867 vat_json_object_add_ip4 (node, "next_hop", ip4);
19869 else if (fp->afi == IP46_TYPE_IP6)
19871 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19872 vat_json_object_add_ip6 (node, "next_hop", ip6);
19878 api_ip_fib_dump (vat_main_t * vam)
19880 vl_api_ip_fib_dump_t *mp;
19881 vl_api_control_ping_t *mp_ping;
19884 M (IP_FIB_DUMP, mp);
19887 /* Use a control ping for synchronization */
19888 MPING (CONTROL_PING, mp_ping);
19896 api_ip_mfib_dump (vat_main_t * vam)
19898 vl_api_ip_mfib_dump_t *mp;
19899 vl_api_control_ping_t *mp_ping;
19902 M (IP_MFIB_DUMP, mp);
19905 /* Use a control ping for synchronization */
19906 MPING (CONTROL_PING, mp_ping);
19913 static void vl_api_ip_neighbor_details_t_handler
19914 (vl_api_ip_neighbor_details_t * mp)
19916 vat_main_t *vam = &vat_main;
19918 print (vam->ofp, "%c %U %U",
19919 (mp->is_static) ? 'S' : 'D',
19920 format_ethernet_address, &mp->mac_address,
19921 (mp->is_ipv6) ? format_ip6_address : format_ip4_address,
19925 static void vl_api_ip_neighbor_details_t_handler_json
19926 (vl_api_ip_neighbor_details_t * mp)
19929 vat_main_t *vam = &vat_main;
19930 vat_json_node_t *node;
19931 struct in_addr ip4;
19932 struct in6_addr ip6;
19934 if (VAT_JSON_ARRAY != vam->json_tree.type)
19936 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19937 vat_json_init_array (&vam->json_tree);
19939 node = vat_json_array_add (&vam->json_tree);
19941 vat_json_init_object (node);
19942 vat_json_object_add_string_copy (node, "flag",
19943 (mp->is_static) ? (u8 *) "static" : (u8 *)
19946 vat_json_object_add_string_copy (node, "link_layer",
19947 format (0, "%U", format_ethernet_address,
19948 &mp->mac_address));
19952 clib_memcpy (&ip6, &mp->ip_address, sizeof (ip6));
19953 vat_json_object_add_ip6 (node, "ip_address", ip6);
19957 clib_memcpy (&ip4, &mp->ip_address, sizeof (ip4));
19958 vat_json_object_add_ip4 (node, "ip_address", ip4);
19963 api_ip_neighbor_dump (vat_main_t * vam)
19965 unformat_input_t *i = vam->input;
19966 vl_api_ip_neighbor_dump_t *mp;
19967 vl_api_control_ping_t *mp_ping;
19969 u32 sw_if_index = ~0;
19972 /* Parse args required to build the message */
19973 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19975 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19977 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19979 else if (unformat (i, "ip6"))
19985 if (sw_if_index == ~0)
19987 errmsg ("missing interface name or sw_if_index");
19991 M (IP_NEIGHBOR_DUMP, mp);
19992 mp->is_ipv6 = (u8) is_ipv6;
19993 mp->sw_if_index = ntohl (sw_if_index);
19996 /* Use a control ping for synchronization */
19997 MPING (CONTROL_PING, mp_ping);
20004 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
20005 #define vl_api_ip6_fib_details_t_print vl_noop_handler
20008 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
20010 vat_main_t *vam = &vat_main;
20011 int count = ntohl (mp->count);
20012 vl_api_fib_path_t *fp;
20016 "table-id %d, prefix %U/%d",
20017 ntohl (mp->table_id), format_ip6_address, mp->address,
20018 mp->address_length);
20020 for (i = 0; i < count; i++)
20022 if (fp->afi == IP46_TYPE_IP6)
20024 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
20025 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
20026 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
20027 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
20028 format_ip6_address, fp->next_hop);
20029 else if (fp->afi == IP46_TYPE_IP4)
20031 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
20032 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
20033 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
20034 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
20035 format_ip4_address, fp->next_hop);
20040 static void vl_api_ip6_fib_details_t_handler_json
20041 (vl_api_ip6_fib_details_t * mp)
20043 vat_main_t *vam = &vat_main;
20044 int count = ntohl (mp->count);
20045 vat_json_node_t *node = NULL;
20046 struct in_addr ip4;
20047 struct in6_addr ip6;
20048 vl_api_fib_path_t *fp;
20051 if (VAT_JSON_ARRAY != vam->json_tree.type)
20053 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20054 vat_json_init_array (&vam->json_tree);
20056 node = vat_json_array_add (&vam->json_tree);
20058 vat_json_init_object (node);
20059 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
20060 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
20061 vat_json_object_add_ip6 (node, "prefix", ip6);
20062 vat_json_object_add_uint (node, "mask_length", mp->address_length);
20063 vat_json_object_add_uint (node, "path_count", count);
20065 for (i = 0; i < count; i++)
20067 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
20068 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
20069 vat_json_object_add_uint (node, "is_local", fp->is_local);
20070 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
20071 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
20072 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
20073 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
20074 if (fp->afi == IP46_TYPE_IP4)
20076 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
20077 vat_json_object_add_ip4 (node, "next_hop", ip4);
20079 else if (fp->afi == IP46_TYPE_IP6)
20081 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
20082 vat_json_object_add_ip6 (node, "next_hop", ip6);
20088 api_ip6_fib_dump (vat_main_t * vam)
20090 vl_api_ip6_fib_dump_t *mp;
20091 vl_api_control_ping_t *mp_ping;
20094 M (IP6_FIB_DUMP, mp);
20097 /* Use a control ping for synchronization */
20098 MPING (CONTROL_PING, mp_ping);
20106 api_ip6_mfib_dump (vat_main_t * vam)
20108 vl_api_ip6_mfib_dump_t *mp;
20109 vl_api_control_ping_t *mp_ping;
20112 M (IP6_MFIB_DUMP, mp);
20115 /* Use a control ping for synchronization */
20116 MPING (CONTROL_PING, mp_ping);
20124 api_classify_table_ids (vat_main_t * vam)
20126 vl_api_classify_table_ids_t *mp;
20129 /* Construct the API message */
20130 M (CLASSIFY_TABLE_IDS, mp);
20139 api_classify_table_by_interface (vat_main_t * vam)
20141 unformat_input_t *input = vam->input;
20142 vl_api_classify_table_by_interface_t *mp;
20144 u32 sw_if_index = ~0;
20146 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20148 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20150 else if (unformat (input, "sw_if_index %d", &sw_if_index))
20155 if (sw_if_index == ~0)
20157 errmsg ("missing interface name or sw_if_index");
20161 /* Construct the API message */
20162 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
20164 mp->sw_if_index = ntohl (sw_if_index);
20172 api_classify_table_info (vat_main_t * vam)
20174 unformat_input_t *input = vam->input;
20175 vl_api_classify_table_info_t *mp;
20179 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20181 if (unformat (input, "table_id %d", &table_id))
20186 if (table_id == ~0)
20188 errmsg ("missing table id");
20192 /* Construct the API message */
20193 M (CLASSIFY_TABLE_INFO, mp);
20195 mp->table_id = ntohl (table_id);
20203 api_classify_session_dump (vat_main_t * vam)
20205 unformat_input_t *input = vam->input;
20206 vl_api_classify_session_dump_t *mp;
20207 vl_api_control_ping_t *mp_ping;
20211 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20213 if (unformat (input, "table_id %d", &table_id))
20218 if (table_id == ~0)
20220 errmsg ("missing table id");
20224 /* Construct the API message */
20225 M (CLASSIFY_SESSION_DUMP, mp);
20227 mp->table_id = ntohl (table_id);
20230 /* Use a control ping for synchronization */
20231 MPING (CONTROL_PING, mp_ping);
20239 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
20241 vat_main_t *vam = &vat_main;
20243 print (vam->ofp, "collector_address %U, collector_port %d, "
20244 "src_address %U, vrf_id %d, path_mtu %u, "
20245 "template_interval %u, udp_checksum %d",
20246 format_ip4_address, mp->collector_address,
20247 ntohs (mp->collector_port),
20248 format_ip4_address, mp->src_address,
20249 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
20250 ntohl (mp->template_interval), mp->udp_checksum);
20253 vam->result_ready = 1;
20257 vl_api_ipfix_exporter_details_t_handler_json
20258 (vl_api_ipfix_exporter_details_t * mp)
20260 vat_main_t *vam = &vat_main;
20261 vat_json_node_t node;
20262 struct in_addr collector_address;
20263 struct in_addr src_address;
20265 vat_json_init_object (&node);
20266 clib_memcpy (&collector_address, &mp->collector_address,
20267 sizeof (collector_address));
20268 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
20269 vat_json_object_add_uint (&node, "collector_port",
20270 ntohs (mp->collector_port));
20271 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
20272 vat_json_object_add_ip4 (&node, "src_address", src_address);
20273 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
20274 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
20275 vat_json_object_add_uint (&node, "template_interval",
20276 ntohl (mp->template_interval));
20277 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
20279 vat_json_print (vam->ofp, &node);
20280 vat_json_free (&node);
20282 vam->result_ready = 1;
20286 api_ipfix_exporter_dump (vat_main_t * vam)
20288 vl_api_ipfix_exporter_dump_t *mp;
20291 /* Construct the API message */
20292 M (IPFIX_EXPORTER_DUMP, mp);
20301 api_ipfix_classify_stream_dump (vat_main_t * vam)
20303 vl_api_ipfix_classify_stream_dump_t *mp;
20306 /* Construct the API message */
20307 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
20318 vl_api_ipfix_classify_stream_details_t_handler
20319 (vl_api_ipfix_classify_stream_details_t * mp)
20321 vat_main_t *vam = &vat_main;
20322 print (vam->ofp, "domain_id %d, src_port %d",
20323 ntohl (mp->domain_id), ntohs (mp->src_port));
20325 vam->result_ready = 1;
20329 vl_api_ipfix_classify_stream_details_t_handler_json
20330 (vl_api_ipfix_classify_stream_details_t * mp)
20332 vat_main_t *vam = &vat_main;
20333 vat_json_node_t node;
20335 vat_json_init_object (&node);
20336 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
20337 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
20339 vat_json_print (vam->ofp, &node);
20340 vat_json_free (&node);
20342 vam->result_ready = 1;
20346 api_ipfix_classify_table_dump (vat_main_t * vam)
20348 vl_api_ipfix_classify_table_dump_t *mp;
20349 vl_api_control_ping_t *mp_ping;
20352 if (!vam->json_output)
20354 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
20355 "transport_protocol");
20358 /* Construct the API message */
20359 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
20364 /* Use a control ping for synchronization */
20365 MPING (CONTROL_PING, mp_ping);
20373 vl_api_ipfix_classify_table_details_t_handler
20374 (vl_api_ipfix_classify_table_details_t * mp)
20376 vat_main_t *vam = &vat_main;
20377 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
20378 mp->transport_protocol);
20382 vl_api_ipfix_classify_table_details_t_handler_json
20383 (vl_api_ipfix_classify_table_details_t * mp)
20385 vat_json_node_t *node = NULL;
20386 vat_main_t *vam = &vat_main;
20388 if (VAT_JSON_ARRAY != vam->json_tree.type)
20390 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20391 vat_json_init_array (&vam->json_tree);
20394 node = vat_json_array_add (&vam->json_tree);
20395 vat_json_init_object (node);
20397 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
20398 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
20399 vat_json_object_add_uint (node, "transport_protocol",
20400 mp->transport_protocol);
20404 api_sw_interface_span_enable_disable (vat_main_t * vam)
20406 unformat_input_t *i = vam->input;
20407 vl_api_sw_interface_span_enable_disable_t *mp;
20408 u32 src_sw_if_index = ~0;
20409 u32 dst_sw_if_index = ~0;
20414 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20417 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
20419 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
20423 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
20425 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
20427 else if (unformat (i, "disable"))
20429 else if (unformat (i, "rx"))
20431 else if (unformat (i, "tx"))
20433 else if (unformat (i, "both"))
20435 else if (unformat (i, "l2"))
20441 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
20443 mp->sw_if_index_from = htonl (src_sw_if_index);
20444 mp->sw_if_index_to = htonl (dst_sw_if_index);
20454 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
20457 vat_main_t *vam = &vat_main;
20458 u8 *sw_if_from_name = 0;
20459 u8 *sw_if_to_name = 0;
20460 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
20461 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
20462 char *states[] = { "none", "rx", "tx", "both" };
20466 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
20468 if ((u32) p->value[0] == sw_if_index_from)
20470 sw_if_from_name = (u8 *)(p->key);
20474 if ((u32) p->value[0] == sw_if_index_to)
20476 sw_if_to_name = (u8 *)(p->key);
20477 if (sw_if_from_name)
20482 print (vam->ofp, "%20s => %20s (%s)",
20483 sw_if_from_name, sw_if_to_name, states[mp->state]);
20487 vl_api_sw_interface_span_details_t_handler_json
20488 (vl_api_sw_interface_span_details_t * mp)
20490 vat_main_t *vam = &vat_main;
20491 vat_json_node_t *node = NULL;
20492 u8 *sw_if_from_name = 0;
20493 u8 *sw_if_to_name = 0;
20494 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
20495 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
20499 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
20501 if ((u32) p->value[0] == sw_if_index_from)
20503 sw_if_from_name = (u8 *)(p->key);
20507 if ((u32) p->value[0] == sw_if_index_to)
20509 sw_if_to_name = (u8 *)(p->key);
20510 if (sw_if_from_name)
20516 if (VAT_JSON_ARRAY != vam->json_tree.type)
20518 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20519 vat_json_init_array (&vam->json_tree);
20521 node = vat_json_array_add (&vam->json_tree);
20523 vat_json_init_object (node);
20524 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
20525 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
20526 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
20527 if (0 != sw_if_to_name)
20529 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
20531 vat_json_object_add_uint (node, "state", mp->state);
20535 api_sw_interface_span_dump (vat_main_t * vam)
20537 unformat_input_t *input = vam->input;
20538 vl_api_sw_interface_span_dump_t *mp;
20539 vl_api_control_ping_t *mp_ping;
20543 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20545 if (unformat (input, "l2"))
20551 M (SW_INTERFACE_SPAN_DUMP, mp);
20555 /* Use a control ping for synchronization */
20556 MPING (CONTROL_PING, mp_ping);
20564 api_pg_create_interface (vat_main_t * vam)
20566 unformat_input_t *input = vam->input;
20567 vl_api_pg_create_interface_t *mp;
20571 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20573 if (unformat (input, "if_id %d", &if_id))
20580 errmsg ("missing pg interface index");
20584 /* Construct the API message */
20585 M (PG_CREATE_INTERFACE, mp);
20587 mp->interface_id = ntohl (if_id);
20595 api_pg_capture (vat_main_t * vam)
20597 unformat_input_t *input = vam->input;
20598 vl_api_pg_capture_t *mp;
20603 u8 pcap_file_set = 0;
20606 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20608 if (unformat (input, "if_id %d", &if_id))
20610 else if (unformat (input, "pcap %s", &pcap_file))
20612 else if (unformat (input, "count %d", &count))
20614 else if (unformat (input, "disable"))
20621 errmsg ("missing pg interface index");
20624 if (pcap_file_set > 0)
20626 if (vec_len (pcap_file) > 255)
20628 errmsg ("pcap file name is too long");
20633 u32 name_len = vec_len (pcap_file);
20634 /* Construct the API message */
20635 M (PG_CAPTURE, mp);
20637 mp->interface_id = ntohl (if_id);
20638 mp->is_enabled = enable;
20639 mp->count = ntohl (count);
20640 mp->pcap_name_length = ntohl (name_len);
20641 if (pcap_file_set != 0)
20643 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
20645 vec_free (pcap_file);
20653 api_pg_enable_disable (vat_main_t * vam)
20655 unformat_input_t *input = vam->input;
20656 vl_api_pg_enable_disable_t *mp;
20659 u8 stream_name_set = 0;
20660 u8 *stream_name = 0;
20662 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20664 if (unformat (input, "stream %s", &stream_name))
20665 stream_name_set = 1;
20666 else if (unformat (input, "disable"))
20672 if (stream_name_set > 0)
20674 if (vec_len (stream_name) > 255)
20676 errmsg ("stream name too long");
20681 u32 name_len = vec_len (stream_name);
20682 /* Construct the API message */
20683 M (PG_ENABLE_DISABLE, mp);
20685 mp->is_enabled = enable;
20686 if (stream_name_set != 0)
20688 mp->stream_name_length = ntohl (name_len);
20689 clib_memcpy (mp->stream_name, stream_name, name_len);
20691 vec_free (stream_name);
20699 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
20701 unformat_input_t *input = vam->input;
20702 vl_api_ip_source_and_port_range_check_add_del_t *mp;
20704 u16 *low_ports = 0;
20705 u16 *high_ports = 0;
20708 ip4_address_t ip4_addr;
20709 ip6_address_t ip6_addr;
20718 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20720 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
20726 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
20731 else if (unformat (input, "vrf %d", &vrf_id))
20733 else if (unformat (input, "del"))
20735 else if (unformat (input, "port %d", &tmp))
20737 if (tmp == 0 || tmp > 65535)
20739 errmsg ("port %d out of range", tmp);
20743 this_hi = this_low + 1;
20744 vec_add1 (low_ports, this_low);
20745 vec_add1 (high_ports, this_hi);
20747 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
20749 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
20751 errmsg ("incorrect range parameters");
20755 /* Note: in debug CLI +1 is added to high before
20756 passing to real fn that does "the work"
20757 (ip_source_and_port_range_check_add_del).
20758 This fn is a wrapper around the binary API fn a
20759 control plane will call, which expects this increment
20760 to have occurred. Hence letting the binary API control
20761 plane fn do the increment for consistency between VAT
20762 and other control planes.
20765 vec_add1 (low_ports, this_low);
20766 vec_add1 (high_ports, this_hi);
20772 if (prefix_set == 0)
20774 errmsg ("<address>/<mask> not specified");
20780 errmsg ("VRF ID required, not specified");
20787 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
20791 if (vec_len (low_ports) == 0)
20793 errmsg ("At least one port or port range required");
20797 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
20799 mp->is_add = is_add;
20804 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
20809 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
20812 mp->mask_length = length;
20813 mp->number_of_ranges = vec_len (low_ports);
20815 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
20816 vec_free (low_ports);
20818 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
20819 vec_free (high_ports);
20821 mp->vrf_id = ntohl (vrf_id);
20829 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
20831 unformat_input_t *input = vam->input;
20832 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
20833 u32 sw_if_index = ~0;
20835 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
20836 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
20840 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20842 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20844 else if (unformat (input, "sw_if_index %d", &sw_if_index))
20846 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
20848 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
20850 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
20852 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
20854 else if (unformat (input, "del"))
20860 if (sw_if_index == ~0)
20862 errmsg ("Interface required but not specified");
20868 errmsg ("VRF ID required but not specified");
20872 if (tcp_out_vrf_id == 0
20873 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
20876 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
20880 /* Construct the API message */
20881 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
20883 mp->sw_if_index = ntohl (sw_if_index);
20884 mp->is_add = is_add;
20885 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
20886 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
20887 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
20888 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
20893 /* Wait for a reply... */
20899 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
20901 unformat_input_t *i = vam->input;
20902 vl_api_ipsec_gre_add_del_tunnel_t *mp;
20903 u32 local_sa_id = 0;
20904 u32 remote_sa_id = 0;
20905 ip4_address_t src_address;
20906 ip4_address_t dst_address;
20910 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20912 if (unformat (i, "local_sa %d", &local_sa_id))
20914 else if (unformat (i, "remote_sa %d", &remote_sa_id))
20916 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
20918 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
20920 else if (unformat (i, "del"))
20924 clib_warning ("parse error '%U'", format_unformat_error, i);
20929 M (IPSEC_GRE_ADD_DEL_TUNNEL, mp);
20931 mp->local_sa_id = ntohl (local_sa_id);
20932 mp->remote_sa_id = ntohl (remote_sa_id);
20933 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
20934 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
20935 mp->is_add = is_add;
20943 api_punt (vat_main_t * vam)
20945 unformat_input_t *i = vam->input;
20953 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20955 if (unformat (i, "ip %d", &ipv))
20957 else if (unformat (i, "protocol %d", &protocol))
20959 else if (unformat (i, "port %d", &port))
20961 else if (unformat (i, "del"))
20965 clib_warning ("parse error '%U'", format_unformat_error, i);
20972 mp->is_add = (u8) is_add;
20973 mp->ipv = (u8) ipv;
20974 mp->l4_protocol = (u8) protocol;
20975 mp->l4_port = htons ((u16) port);
20982 static void vl_api_ipsec_gre_tunnel_details_t_handler
20983 (vl_api_ipsec_gre_tunnel_details_t * mp)
20985 vat_main_t *vam = &vat_main;
20987 print (vam->ofp, "%11d%15U%15U%14d%14d",
20988 ntohl (mp->sw_if_index),
20989 format_ip4_address, &mp->src_address,
20990 format_ip4_address, &mp->dst_address,
20991 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
20994 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
20995 (vl_api_ipsec_gre_tunnel_details_t * mp)
20997 vat_main_t *vam = &vat_main;
20998 vat_json_node_t *node = NULL;
20999 struct in_addr ip4;
21001 if (VAT_JSON_ARRAY != vam->json_tree.type)
21003 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
21004 vat_json_init_array (&vam->json_tree);
21006 node = vat_json_array_add (&vam->json_tree);
21008 vat_json_init_object (node);
21009 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
21010 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
21011 vat_json_object_add_ip4 (node, "src_address", ip4);
21012 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
21013 vat_json_object_add_ip4 (node, "dst_address", ip4);
21014 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
21015 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
21019 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
21021 unformat_input_t *i = vam->input;
21022 vl_api_ipsec_gre_tunnel_dump_t *mp;
21023 vl_api_control_ping_t *mp_ping;
21025 u8 sw_if_index_set = 0;
21028 /* Parse args required to build the message */
21029 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21031 if (unformat (i, "sw_if_index %d", &sw_if_index))
21032 sw_if_index_set = 1;
21037 if (sw_if_index_set == 0)
21042 if (!vam->json_output)
21044 print (vam->ofp, "%11s%15s%15s%14s%14s",
21045 "sw_if_index", "src_address", "dst_address",
21046 "local_sa_id", "remote_sa_id");
21049 /* Get list of gre-tunnel interfaces */
21050 M (IPSEC_GRE_TUNNEL_DUMP, mp);
21052 mp->sw_if_index = htonl (sw_if_index);
21056 /* Use a control ping for synchronization */
21057 MPING (CONTROL_PING, mp_ping);
21065 api_delete_subif (vat_main_t * vam)
21067 unformat_input_t *i = vam->input;
21068 vl_api_delete_subif_t *mp;
21069 u32 sw_if_index = ~0;
21072 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21074 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21076 if (unformat (i, "sw_if_index %d", &sw_if_index))
21082 if (sw_if_index == ~0)
21084 errmsg ("missing sw_if_index");
21088 /* Construct the API message */
21089 M (DELETE_SUBIF, mp);
21090 mp->sw_if_index = ntohl (sw_if_index);
21097 #define foreach_pbb_vtr_op \
21098 _("disable", L2_VTR_DISABLED) \
21099 _("pop", L2_VTR_POP_2) \
21100 _("push", L2_VTR_PUSH_2)
21103 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
21105 unformat_input_t *i = vam->input;
21106 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
21107 u32 sw_if_index = ~0, vtr_op = ~0;
21108 u16 outer_tag = ~0;
21109 u8 dmac[6], smac[6];
21110 u8 dmac_set = 0, smac_set = 0;
21116 /* Shut up coverity */
21117 memset (dmac, 0, sizeof (dmac));
21118 memset (smac, 0, sizeof (smac));
21120 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21122 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21124 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21126 else if (unformat (i, "vtr_op %d", &vtr_op))
21128 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
21131 else if (unformat (i, "translate_pbb_stag"))
21133 if (unformat (i, "%d", &tmp))
21135 vtr_op = L2_VTR_TRANSLATE_2_1;
21141 ("translate_pbb_stag operation requires outer tag definition");
21145 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
21147 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
21149 else if (unformat (i, "sid %d", &sid))
21151 else if (unformat (i, "vlanid %d", &tmp))
21155 clib_warning ("parse error '%U'", format_unformat_error, i);
21160 if ((sw_if_index == ~0) || (vtr_op == ~0))
21162 errmsg ("missing sw_if_index or vtr operation");
21165 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
21166 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
21169 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
21173 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
21174 mp->sw_if_index = ntohl (sw_if_index);
21175 mp->vtr_op = ntohl (vtr_op);
21176 mp->outer_tag = ntohs (outer_tag);
21177 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
21178 clib_memcpy (mp->b_smac, smac, sizeof (smac));
21179 mp->b_vlanid = ntohs (vlanid);
21180 mp->i_sid = ntohl (sid);
21188 api_flow_classify_set_interface (vat_main_t * vam)
21190 unformat_input_t *i = vam->input;
21191 vl_api_flow_classify_set_interface_t *mp;
21193 int sw_if_index_set;
21194 u32 ip4_table_index = ~0;
21195 u32 ip6_table_index = ~0;
21199 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21201 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21202 sw_if_index_set = 1;
21203 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21204 sw_if_index_set = 1;
21205 else if (unformat (i, "del"))
21207 else if (unformat (i, "ip4-table %d", &ip4_table_index))
21209 else if (unformat (i, "ip6-table %d", &ip6_table_index))
21213 clib_warning ("parse error '%U'", format_unformat_error, i);
21218 if (sw_if_index_set == 0)
21220 errmsg ("missing interface name or sw_if_index");
21224 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
21226 mp->sw_if_index = ntohl (sw_if_index);
21227 mp->ip4_table_index = ntohl (ip4_table_index);
21228 mp->ip6_table_index = ntohl (ip6_table_index);
21229 mp->is_add = is_add;
21237 api_flow_classify_dump (vat_main_t * vam)
21239 unformat_input_t *i = vam->input;
21240 vl_api_flow_classify_dump_t *mp;
21241 vl_api_control_ping_t *mp_ping;
21242 u8 type = FLOW_CLASSIFY_N_TABLES;
21245 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
21249 errmsg ("classify table type must be specified");
21253 if (!vam->json_output)
21255 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
21258 M (FLOW_CLASSIFY_DUMP, mp);
21263 /* Use a control ping for synchronization */
21264 MPING (CONTROL_PING, mp_ping);
21267 /* Wait for a reply... */
21273 api_feature_enable_disable (vat_main_t * vam)
21275 unformat_input_t *i = vam->input;
21276 vl_api_feature_enable_disable_t *mp;
21278 u8 *feature_name = 0;
21279 u32 sw_if_index = ~0;
21283 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21285 if (unformat (i, "arc_name %s", &arc_name))
21287 else if (unformat (i, "feature_name %s", &feature_name))
21290 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21292 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21294 else if (unformat (i, "disable"))
21302 errmsg ("missing arc name");
21305 if (vec_len (arc_name) > 63)
21307 errmsg ("arc name too long");
21310 if (feature_name == 0)
21312 errmsg ("missing feature name");
21315 if (vec_len (feature_name) > 63)
21317 errmsg ("feature name too long");
21320 if (sw_if_index == ~0)
21322 errmsg ("missing interface name or sw_if_index");
21326 /* Construct the API message */
21327 M (FEATURE_ENABLE_DISABLE, mp);
21328 mp->sw_if_index = ntohl (sw_if_index);
21329 mp->enable = enable;
21330 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
21331 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
21332 vec_free (arc_name);
21333 vec_free (feature_name);
21341 api_sw_interface_tag_add_del (vat_main_t * vam)
21343 unformat_input_t *i = vam->input;
21344 vl_api_sw_interface_tag_add_del_t *mp;
21345 u32 sw_if_index = ~0;
21350 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21352 if (unformat (i, "tag %s", &tag))
21354 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21356 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21358 else if (unformat (i, "del"))
21364 if (sw_if_index == ~0)
21366 errmsg ("missing interface name or sw_if_index");
21370 if (enable && (tag == 0))
21372 errmsg ("no tag specified");
21376 /* Construct the API message */
21377 M (SW_INTERFACE_TAG_ADD_DEL, mp);
21378 mp->sw_if_index = ntohl (sw_if_index);
21379 mp->is_add = enable;
21381 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
21389 static void vl_api_l2_xconnect_details_t_handler
21390 (vl_api_l2_xconnect_details_t * mp)
21392 vat_main_t *vam = &vat_main;
21394 print (vam->ofp, "%15d%15d",
21395 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
21398 static void vl_api_l2_xconnect_details_t_handler_json
21399 (vl_api_l2_xconnect_details_t * mp)
21401 vat_main_t *vam = &vat_main;
21402 vat_json_node_t *node = NULL;
21404 if (VAT_JSON_ARRAY != vam->json_tree.type)
21406 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
21407 vat_json_init_array (&vam->json_tree);
21409 node = vat_json_array_add (&vam->json_tree);
21411 vat_json_init_object (node);
21412 vat_json_object_add_uint (node, "rx_sw_if_index",
21413 ntohl (mp->rx_sw_if_index));
21414 vat_json_object_add_uint (node, "tx_sw_if_index",
21415 ntohl (mp->tx_sw_if_index));
21419 api_l2_xconnect_dump (vat_main_t * vam)
21421 vl_api_l2_xconnect_dump_t *mp;
21422 vl_api_control_ping_t *mp_ping;
21425 if (!vam->json_output)
21427 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
21430 M (L2_XCONNECT_DUMP, mp);
21434 /* Use a control ping for synchronization */
21435 MPING (CONTROL_PING, mp_ping);
21443 api_sw_interface_set_mtu (vat_main_t * vam)
21445 unformat_input_t *i = vam->input;
21446 vl_api_sw_interface_set_mtu_t *mp;
21447 u32 sw_if_index = ~0;
21451 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21453 if (unformat (i, "mtu %d", &mtu))
21455 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21457 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21463 if (sw_if_index == ~0)
21465 errmsg ("missing interface name or sw_if_index");
21471 errmsg ("no mtu specified");
21475 /* Construct the API message */
21476 M (SW_INTERFACE_SET_MTU, mp);
21477 mp->sw_if_index = ntohl (sw_if_index);
21478 mp->mtu = ntohs ((u16) mtu);
21486 api_p2p_ethernet_add (vat_main_t * vam)
21488 unformat_input_t *i = vam->input;
21489 vl_api_p2p_ethernet_add_t *mp;
21490 u32 parent_if_index = ~0;
21496 memset (remote_mac, 0, sizeof (remote_mac));
21497 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21499 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
21501 else if (unformat (i, "sw_if_index %d", &parent_if_index))
21505 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
21507 else if (unformat (i, "sub_id %d", &sub_id))
21511 clib_warning ("parse error '%U'", format_unformat_error, i);
21516 if (parent_if_index == ~0)
21518 errmsg ("missing interface name or sw_if_index");
21523 errmsg ("missing remote mac address");
21528 errmsg ("missing sub-interface id");
21532 M (P2P_ETHERNET_ADD, mp);
21533 mp->parent_if_index = ntohl (parent_if_index);
21534 mp->subif_id = ntohl (sub_id);
21535 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
21543 api_p2p_ethernet_del (vat_main_t * vam)
21545 unformat_input_t *i = vam->input;
21546 vl_api_p2p_ethernet_del_t *mp;
21547 u32 parent_if_index = ~0;
21552 memset (remote_mac, 0, sizeof (remote_mac));
21553 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21555 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
21557 else if (unformat (i, "sw_if_index %d", &parent_if_index))
21561 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
21565 clib_warning ("parse error '%U'", format_unformat_error, i);
21570 if (parent_if_index == ~0)
21572 errmsg ("missing interface name or sw_if_index");
21577 errmsg ("missing remote mac address");
21581 M (P2P_ETHERNET_DEL, mp);
21582 mp->parent_if_index = ntohl (parent_if_index);
21583 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
21591 api_lldp_config (vat_main_t * vam)
21593 unformat_input_t *i = vam->input;
21594 vl_api_lldp_config_t *mp;
21596 int tx_interval = 0;
21597 u8 *sys_name = NULL;
21600 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21602 if (unformat (i, "system-name %s", &sys_name))
21604 else if (unformat (i, "tx-hold %d", &tx_hold))
21606 else if (unformat (i, "tx-interval %d", &tx_interval))
21610 clib_warning ("parse error '%U'", format_unformat_error, i);
21615 vec_add1 (sys_name, 0);
21617 M (LLDP_CONFIG, mp);
21618 mp->tx_hold = htonl (tx_hold);
21619 mp->tx_interval = htonl (tx_interval);
21620 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
21621 vec_free (sys_name);
21629 api_sw_interface_set_lldp (vat_main_t * vam)
21631 unformat_input_t *i = vam->input;
21632 vl_api_sw_interface_set_lldp_t *mp;
21633 u32 sw_if_index = ~0;
21635 u8 *port_desc = NULL, *mgmt_oid = NULL;
21636 ip4_address_t ip4_addr;
21637 ip6_address_t ip6_addr;
21640 memset (&ip4_addr, 0, sizeof (ip4_addr));
21641 memset (&ip6_addr, 0, sizeof (ip6_addr));
21643 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21645 if (unformat (i, "disable"))
21648 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21650 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21652 else if (unformat (i, "port-desc %s", &port_desc))
21654 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
21656 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
21658 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
21664 if (sw_if_index == ~0)
21666 errmsg ("missing interface name or sw_if_index");
21670 /* Construct the API message */
21671 vec_add1 (port_desc, 0);
21672 vec_add1 (mgmt_oid, 0);
21673 M (SW_INTERFACE_SET_LLDP, mp);
21674 mp->sw_if_index = ntohl (sw_if_index);
21675 mp->enable = enable;
21676 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
21677 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
21678 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
21679 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
21680 vec_free (port_desc);
21681 vec_free (mgmt_oid);
21689 api_tcp_configure_src_addresses (vat_main_t * vam)
21691 vl_api_tcp_configure_src_addresses_t *mp;
21692 unformat_input_t *i = vam->input;
21693 ip4_address_t v4first, v4last;
21694 ip6_address_t v6first, v6last;
21699 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21701 if (unformat (i, "%U - %U",
21702 unformat_ip4_address, &v4first,
21703 unformat_ip4_address, &v4last))
21707 errmsg ("one range per message (range already set)");
21712 else if (unformat (i, "%U - %U",
21713 unformat_ip6_address, &v6first,
21714 unformat_ip6_address, &v6last))
21718 errmsg ("one range per message (range already set)");
21723 else if (unformat (i, "vrf %d", &vrf_id))
21729 if (range_set == 0)
21731 errmsg ("address range not set");
21735 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
21736 mp->vrf_id = ntohl (vrf_id);
21738 if (range_set == 2)
21741 clib_memcpy (mp->first_address, &v6first, sizeof (v6first));
21742 clib_memcpy (mp->last_address, &v6last, sizeof (v6last));
21747 clib_memcpy (mp->first_address, &v4first, sizeof (v4first));
21748 clib_memcpy (mp->last_address, &v4last, sizeof (v4last));
21755 static void vl_api_app_namespace_add_del_reply_t_handler
21756 (vl_api_app_namespace_add_del_reply_t * mp)
21758 vat_main_t *vam = &vat_main;
21759 i32 retval = ntohl (mp->retval);
21760 if (vam->async_mode)
21762 vam->async_errors += (retval < 0);
21766 vam->retval = retval;
21768 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
21769 vam->result_ready = 1;
21773 static void vl_api_app_namespace_add_del_reply_t_handler_json
21774 (vl_api_app_namespace_add_del_reply_t * mp)
21776 vat_main_t *vam = &vat_main;
21777 vat_json_node_t node;
21779 vat_json_init_object (&node);
21780 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
21781 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
21783 vat_json_print (vam->ofp, &node);
21784 vat_json_free (&node);
21786 vam->retval = ntohl (mp->retval);
21787 vam->result_ready = 1;
21791 api_app_namespace_add_del (vat_main_t * vam)
21793 vl_api_app_namespace_add_del_t *mp;
21794 unformat_input_t *i = vam->input;
21795 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
21796 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
21800 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21802 if (unformat (i, "id %_%v%_", &ns_id))
21804 else if (unformat (i, "secret %lu", &secret))
21806 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21807 sw_if_index_set = 1;
21808 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
21810 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
21815 if (!ns_id || !secret_set || !sw_if_index_set)
21817 errmsg ("namespace id, secret and sw_if_index must be set");
21820 if (vec_len (ns_id) > 64)
21822 errmsg ("namespace id too long");
21825 M (APP_NAMESPACE_ADD_DEL, mp);
21827 clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
21828 mp->namespace_id_len = vec_len (ns_id);
21829 mp->secret = clib_host_to_net_u64 (secret);
21830 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
21831 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
21832 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
21840 api_memfd_segment_create (vat_main_t * vam)
21842 #if VPP_API_TEST_BUILTIN == 0
21843 unformat_input_t *i = vam->input;
21844 vl_api_memfd_segment_create_t *mp;
21845 u64 size = 64 << 20;
21848 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21850 if (unformat (i, "size %U", unformat_memory_size, &size))
21856 M (MEMFD_SEGMENT_CREATE, mp);
21857 mp->requested_size = size;
21863 errmsg ("memfd_segment_create (builtin) not supported");
21869 api_dns_enable_disable (vat_main_t * vam)
21871 unformat_input_t *line_input = vam->input;
21872 vl_api_dns_enable_disable_t *mp;
21873 u8 enable_disable = 1;
21876 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21878 if (unformat (line_input, "disable"))
21879 enable_disable = 0;
21880 if (unformat (line_input, "enable"))
21881 enable_disable = 1;
21886 /* Construct the API message */
21887 M (DNS_ENABLE_DISABLE, mp);
21888 mp->enable = enable_disable;
21892 /* Wait for the reply */
21898 api_dns_resolve_name (vat_main_t * vam)
21900 unformat_input_t *line_input = vam->input;
21901 vl_api_dns_resolve_name_t *mp;
21905 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21907 if (unformat (line_input, "%s", &name))
21913 if (vec_len (name) > 127)
21915 errmsg ("name too long");
21919 /* Construct the API message */
21920 M (DNS_RESOLVE_NAME, mp);
21921 memcpy (mp->name, name, vec_len (name));
21926 /* Wait for the reply */
21932 api_dns_resolve_ip (vat_main_t * vam)
21934 unformat_input_t *line_input = vam->input;
21935 vl_api_dns_resolve_ip_t *mp;
21937 ip4_address_t addr4;
21938 ip6_address_t addr6;
21941 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21943 if (unformat (line_input, "%U", unformat_ip6_address, &addr6))
21945 else if (unformat (line_input, "%U", unformat_ip4_address, &addr4))
21953 errmsg ("missing address");
21957 /* Construct the API message */
21958 M (DNS_RESOLVE_IP, mp);
21959 mp->is_ip6 = is_ip6;
21961 memcpy (mp->address, &addr6, sizeof (addr6));
21963 memcpy (mp->address, &addr4, sizeof (addr4));
21967 /* Wait for the reply */
21973 api_dns_name_server_add_del (vat_main_t * vam)
21975 unformat_input_t *i = vam->input;
21976 vl_api_dns_name_server_add_del_t *mp;
21978 ip6_address_t ip6_server;
21979 ip4_address_t ip4_server;
21984 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21986 if (unformat (i, "%U", unformat_ip6_address, &ip6_server))
21988 else if (unformat (i, "%U", unformat_ip4_address, &ip4_server))
21990 else if (unformat (i, "del"))
21994 clib_warning ("parse error '%U'", format_unformat_error, i);
21999 if (ip4_set && ip6_set)
22001 errmsg ("Only one server address allowed per message");
22004 if ((ip4_set + ip6_set) == 0)
22006 errmsg ("Server address required");
22010 /* Construct the API message */
22011 M (DNS_NAME_SERVER_ADD_DEL, mp);
22015 memcpy (mp->server_address, &ip6_server, sizeof (ip6_address_t));
22020 memcpy (mp->server_address, &ip4_server, sizeof (ip4_address_t));
22024 mp->is_add = is_add;
22029 /* Wait for a reply, return good/bad news */
22035 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
22037 vat_main_t *vam = &vat_main;
22042 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
22043 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
22044 mp->scope, format_ip4_address, &mp->lcl_ip, mp->lcl_plen,
22045 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
22046 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
22047 clib_net_to_host_u32 (mp->action_index), mp->tag);
22052 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
22053 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
22054 mp->scope, format_ip6_address, &mp->lcl_ip, mp->lcl_plen,
22055 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
22056 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
22057 clib_net_to_host_u32 (mp->action_index), mp->tag);
22062 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
22065 vat_main_t *vam = &vat_main;
22066 vat_json_node_t *node = NULL;
22067 struct in6_addr ip6;
22068 struct in_addr ip4;
22070 if (VAT_JSON_ARRAY != vam->json_tree.type)
22072 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
22073 vat_json_init_array (&vam->json_tree);
22075 node = vat_json_array_add (&vam->json_tree);
22076 vat_json_init_object (node);
22078 vat_json_object_add_uint (node, "is_ip4", mp->is_ip4 ? 1 : 0);
22079 vat_json_object_add_uint (node, "appns_index",
22080 clib_net_to_host_u32 (mp->appns_index));
22081 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
22082 vat_json_object_add_uint (node, "scope", mp->scope);
22083 vat_json_object_add_uint (node, "action_index",
22084 clib_net_to_host_u32 (mp->action_index));
22085 vat_json_object_add_uint (node, "lcl_port",
22086 clib_net_to_host_u16 (mp->lcl_port));
22087 vat_json_object_add_uint (node, "rmt_port",
22088 clib_net_to_host_u16 (mp->rmt_port));
22089 vat_json_object_add_uint (node, "lcl_plen", mp->lcl_plen);
22090 vat_json_object_add_uint (node, "rmt_plen", mp->rmt_plen);
22091 vat_json_object_add_string_copy (node, "tag", mp->tag);
22094 clib_memcpy (&ip4, mp->lcl_ip, sizeof (ip4));
22095 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
22096 clib_memcpy (&ip4, mp->rmt_ip, sizeof (ip4));
22097 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
22101 clib_memcpy (&ip6, mp->lcl_ip, sizeof (ip6));
22102 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
22103 clib_memcpy (&ip6, mp->rmt_ip, sizeof (ip6));
22104 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
22109 api_session_rule_add_del (vat_main_t * vam)
22111 vl_api_session_rule_add_del_t *mp;
22112 unformat_input_t *i = vam->input;
22113 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
22114 u32 appns_index = 0, scope = 0;
22115 ip4_address_t lcl_ip4, rmt_ip4;
22116 ip6_address_t lcl_ip6, rmt_ip6;
22117 u8 is_ip4 = 1, conn_set = 0;
22118 u8 is_add = 1, *tag = 0;
22121 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22123 if (unformat (i, "del"))
22125 else if (unformat (i, "add"))
22127 else if (unformat (i, "proto tcp"))
22129 else if (unformat (i, "proto udp"))
22131 else if (unformat (i, "appns %d", &appns_index))
22133 else if (unformat (i, "scope %d", &scope))
22135 else if (unformat (i, "tag %_%v%_", &tag))
22139 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
22140 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
22148 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
22149 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
22155 else if (unformat (i, "action %d", &action))
22160 if (proto == ~0 || !conn_set || action == ~0)
22162 errmsg ("transport proto, connection and action must be set");
22168 errmsg ("scope should be 0-3");
22172 M (SESSION_RULE_ADD_DEL, mp);
22174 mp->is_ip4 = is_ip4;
22175 mp->transport_proto = proto;
22176 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
22177 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
22178 mp->lcl_plen = lcl_plen;
22179 mp->rmt_plen = rmt_plen;
22180 mp->action_index = clib_host_to_net_u32 (action);
22181 mp->appns_index = clib_host_to_net_u32 (appns_index);
22183 mp->is_add = is_add;
22186 clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
22187 clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
22191 clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
22192 clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
22196 clib_memcpy (mp->tag, tag, vec_len (tag));
22206 api_session_rules_dump (vat_main_t * vam)
22208 vl_api_session_rules_dump_t *mp;
22209 vl_api_control_ping_t *mp_ping;
22212 if (!vam->json_output)
22214 print (vam->ofp, "%=20s", "Session Rules");
22217 M (SESSION_RULES_DUMP, mp);
22221 /* Use a control ping for synchronization */
22222 MPING (CONTROL_PING, mp_ping);
22225 /* Wait for a reply... */
22231 api_ip_container_proxy_add_del (vat_main_t * vam)
22233 vl_api_ip_container_proxy_add_del_t *mp;
22234 unformat_input_t *i = vam->input;
22235 u32 plen = ~0, sw_if_index = ~0;
22242 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22244 if (unformat (i, "del"))
22246 else if (unformat (i, "add"))
22248 if (unformat (i, "%U", unformat_ip4_address, &ip4))
22253 else if (unformat (i, "%U", unformat_ip6_address, &ip6))
22258 else if (unformat (i, "sw_if_index %u", &sw_if_index))
22263 if (sw_if_index == ~0 || plen == ~0)
22265 errmsg ("address and sw_if_index must be set");
22269 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
22271 mp->is_ip4 = is_ip4;
22272 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
22274 mp->is_add = is_add;
22276 clib_memcpy (mp->ip, &ip4, sizeof (ip4));
22278 clib_memcpy (mp->ip, &ip6, sizeof (ip6));
22286 q_or_quit (vat_main_t * vam)
22288 #if VPP_API_TEST_BUILTIN == 0
22289 longjmp (vam->jump_buf, 1);
22291 return 0; /* not so much */
22295 q (vat_main_t * vam)
22297 return q_or_quit (vam);
22301 quit (vat_main_t * vam)
22303 return q_or_quit (vam);
22307 comment (vat_main_t * vam)
22313 cmd_cmp (void *a1, void *a2)
22318 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
22322 help (vat_main_t * vam)
22327 unformat_input_t *i = vam->input;
22330 if (unformat (i, "%s", &name))
22334 vec_add1 (name, 0);
22336 hs = hash_get_mem (vam->help_by_name, name);
22338 print (vam->ofp, "usage: %s %s", name, hs[0]);
22340 print (vam->ofp, "No such msg / command '%s'", name);
22345 print (vam->ofp, "Help is available for the following:");
22348 hash_foreach_pair (p, vam->function_by_name,
22350 vec_add1 (cmds, (u8 *)(p->key));
22354 vec_sort_with_function (cmds, cmd_cmp);
22356 for (j = 0; j < vec_len (cmds); j++)
22357 print (vam->ofp, "%s", cmds[j]);
22364 set (vat_main_t * vam)
22366 u8 *name = 0, *value = 0;
22367 unformat_input_t *i = vam->input;
22369 if (unformat (i, "%s", &name))
22371 /* The input buffer is a vector, not a string. */
22372 value = vec_dup (i->buffer);
22373 vec_delete (value, i->index, 0);
22374 /* Almost certainly has a trailing newline */
22375 if (value[vec_len (value) - 1] == '\n')
22376 value[vec_len (value) - 1] = 0;
22377 /* Make sure it's a proper string, one way or the other */
22378 vec_add1 (value, 0);
22379 (void) clib_macro_set_value (&vam->macro_main,
22380 (char *) name, (char *) value);
22383 errmsg ("usage: set <name> <value>");
22391 unset (vat_main_t * vam)
22395 if (unformat (vam->input, "%s", &name))
22396 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
22397 errmsg ("unset: %s wasn't set", name);
22410 macro_sort_cmp (void *a1, void *a2)
22412 macro_sort_t *s1 = a1;
22413 macro_sort_t *s2 = a2;
22415 return strcmp ((char *) (s1->name), (char *) (s2->name));
22419 dump_macro_table (vat_main_t * vam)
22421 macro_sort_t *sort_me = 0, *sm;
22426 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
22428 vec_add2 (sort_me, sm, 1);
22429 sm->name = (u8 *)(p->key);
22430 sm->value = (u8 *) (p->value[0]);
22434 vec_sort_with_function (sort_me, macro_sort_cmp);
22436 if (vec_len (sort_me))
22437 print (vam->ofp, "%-15s%s", "Name", "Value");
22439 print (vam->ofp, "The macro table is empty...");
22441 for (i = 0; i < vec_len (sort_me); i++)
22442 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
22447 dump_node_table (vat_main_t * vam)
22450 vlib_node_t *node, *next_node;
22452 if (vec_len (vam->graph_nodes) == 0)
22454 print (vam->ofp, "Node table empty, issue get_node_graph...");
22458 for (i = 0; i < vec_len (vam->graph_nodes); i++)
22460 node = vam->graph_nodes[i];
22461 print (vam->ofp, "[%d] %s", i, node->name);
22462 for (j = 0; j < vec_len (node->next_nodes); j++)
22464 if (node->next_nodes[j] != ~0)
22466 next_node = vam->graph_nodes[node->next_nodes[j]];
22467 print (vam->ofp, " [%d] %s", j, next_node->name);
22475 value_sort_cmp (void *a1, void *a2)
22477 name_sort_t *n1 = a1;
22478 name_sort_t *n2 = a2;
22480 if (n1->value < n2->value)
22482 if (n1->value > n2->value)
22489 dump_msg_api_table (vat_main_t * vam)
22491 api_main_t *am = &api_main;
22492 name_sort_t *nses = 0, *ns;
22497 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
22499 vec_add2 (nses, ns, 1);
22500 ns->name = (u8 *)(hp->key);
22501 ns->value = (u32) hp->value[0];
22505 vec_sort_with_function (nses, value_sort_cmp);
22507 for (i = 0; i < vec_len (nses); i++)
22508 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
22514 get_msg_id (vat_main_t * vam)
22519 if (unformat (vam->input, "%s", &name_and_crc))
22521 message_index = vl_api_get_msg_index (name_and_crc);
22522 if (message_index == ~0)
22524 print (vam->ofp, " '%s' not found", name_and_crc);
22527 print (vam->ofp, " '%s' has message index %d",
22528 name_and_crc, message_index);
22531 errmsg ("name_and_crc required...");
22536 search_node_table (vat_main_t * vam)
22538 unformat_input_t *line_input = vam->input;
22541 vlib_node_t *node, *next_node;
22544 if (vam->graph_node_index_by_name == 0)
22546 print (vam->ofp, "Node table empty, issue get_node_graph...");
22550 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
22552 if (unformat (line_input, "%s", &node_to_find))
22554 vec_add1 (node_to_find, 0);
22555 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
22558 print (vam->ofp, "%s not found...", node_to_find);
22561 node = vam->graph_nodes[p[0]];
22562 print (vam->ofp, "[%d] %s", p[0], node->name);
22563 for (j = 0; j < vec_len (node->next_nodes); j++)
22565 if (node->next_nodes[j] != ~0)
22567 next_node = vam->graph_nodes[node->next_nodes[j]];
22568 print (vam->ofp, " [%d] %s", j, next_node->name);
22575 clib_warning ("parse error '%U'", format_unformat_error,
22581 vec_free (node_to_find);
22590 script (vat_main_t * vam)
22592 #if (VPP_API_TEST_BUILTIN==0)
22594 char *save_current_file;
22595 unformat_input_t save_input;
22596 jmp_buf save_jump_buf;
22597 u32 save_line_number;
22599 FILE *new_fp, *save_ifp;
22601 if (unformat (vam->input, "%s", &s))
22603 new_fp = fopen ((char *) s, "r");
22606 errmsg ("Couldn't open script file %s", s);
22613 errmsg ("Missing script name");
22617 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
22618 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
22619 save_ifp = vam->ifp;
22620 save_line_number = vam->input_line_number;
22621 save_current_file = (char *) vam->current_file;
22623 vam->input_line_number = 0;
22625 vam->current_file = s;
22628 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
22629 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
22630 vam->ifp = save_ifp;
22631 vam->input_line_number = save_line_number;
22632 vam->current_file = (u8 *) save_current_file;
22637 clib_warning ("use the exec command...");
22643 echo (vat_main_t * vam)
22645 print (vam->ofp, "%v", vam->input->buffer);
22649 /* List of API message constructors, CLI names map to api_xxx */
22650 #define foreach_vpe_api_msg \
22651 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
22652 _(sw_interface_dump,"") \
22653 _(sw_interface_set_flags, \
22654 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
22655 _(sw_interface_add_del_address, \
22656 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
22657 _(sw_interface_set_rx_mode, \
22658 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
22659 _(sw_interface_set_table, \
22660 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
22661 _(sw_interface_set_mpls_enable, \
22662 "<intfc> | sw_if_index [disable | dis]") \
22663 _(sw_interface_set_vpath, \
22664 "<intfc> | sw_if_index <id> enable | disable") \
22665 _(sw_interface_set_vxlan_bypass, \
22666 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
22667 _(sw_interface_set_geneve_bypass, \
22668 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
22669 _(sw_interface_set_l2_xconnect, \
22670 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
22671 "enable | disable") \
22672 _(sw_interface_set_l2_bridge, \
22673 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
22674 "[shg <split-horizon-group>] [bvi]\n" \
22675 "enable | disable") \
22676 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
22677 _(bridge_domain_add_del, \
22678 "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") \
22679 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
22681 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
22682 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
22683 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
22685 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
22687 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
22689 "tapname <name> mac <mac-addr> | random-mac [tag <string>]") \
22691 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
22693 "<vpp-if-name> | sw_if_index <id>") \
22694 _(sw_interface_tap_dump, "") \
22696 "name <name> [hw-addr <mac-addr>] [host-ns <name>] [rx-ring-size <num> [tx-ring-size <num>]") \
22698 "<vpp-if-name> | sw_if_index <id>") \
22699 _(sw_interface_tap_v2_dump, "") \
22700 _(ip_table_add_del, \
22701 "table-id <n> [ipv6]\n") \
22702 _(ip_add_del_route, \
22703 "<addr>/<mask> via <addr> [table-id <n>]\n" \
22704 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
22705 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
22706 "[multipath] [count <n>]") \
22707 _(ip_mroute_add_del, \
22708 "<src> <grp>/<mask> [table-id <n>]\n" \
22709 "[<intfc> | sw_if_index <id>] [local] [del]") \
22710 _(mpls_table_add_del, \
22711 "table-id <n>\n") \
22712 _(mpls_route_add_del, \
22713 "<label> <eos> via <addr> [table-id <n>]\n" \
22714 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
22715 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
22716 "[multipath] [count <n>]") \
22717 _(mpls_ip_bind_unbind, \
22718 "<label> <addr/len>") \
22719 _(mpls_tunnel_add_del, \
22720 " via <addr> [table-id <n>]\n" \
22721 "sw_if_index <id>] [l2] [del]") \
22722 _(bier_table_add_del, \
22723 "<label> <sub-domain> <set> <bsl> [del]") \
22724 _(bier_route_add_del, \
22725 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
22726 "[<intfc> | sw_if_index <id>]" \
22727 "[weight <n>] [del] [multipath]") \
22728 _(proxy_arp_add_del, \
22729 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
22730 _(proxy_arp_intfc_enable_disable, \
22731 "<intfc> | sw_if_index <id> enable | disable") \
22732 _(sw_interface_set_unnumbered, \
22733 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
22734 _(ip_neighbor_add_del, \
22735 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
22736 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
22737 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
22738 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
22739 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
22740 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
22741 "[outer_vlan_id_any][inner_vlan_id_any]") \
22742 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
22743 _(reset_fib, "vrf <n> [ipv6]") \
22744 _(dhcp_proxy_config, \
22745 "svr <v46-address> src <v46-address>\n" \
22746 "rx_vrf_id <nn> server_vrf_id <nn> [del]") \
22747 _(dhcp_proxy_set_vss, \
22748 "tbl_id <n> [fib_id <n> oui <n> | vpn_ascii_id <text>] [ipv6] [del]") \
22749 _(dhcp_proxy_dump, "ip6") \
22750 _(dhcp_client_config, \
22751 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
22752 _(set_ip_flow_hash, \
22753 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
22754 _(sw_interface_ip6_enable_disable, \
22755 "<intfc> | sw_if_index <id> enable | disable") \
22756 _(sw_interface_ip6_set_link_local_address, \
22757 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
22758 _(ip6nd_proxy_add_del, \
22759 "<intfc> | sw_if_index <id> <ip6-address>") \
22760 _(ip6nd_proxy_dump, "") \
22761 _(sw_interface_ip6nd_ra_prefix, \
22762 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
22763 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
22764 "[nolink] [isno]") \
22765 _(sw_interface_ip6nd_ra_config, \
22766 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
22767 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
22768 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
22769 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
22770 _(l2_patch_add_del, \
22771 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
22772 "enable | disable") \
22773 _(sr_localsid_add_del, \
22774 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
22775 "fib-table <num> (end.psp) sw_if_index <num>") \
22776 _(classify_add_del_table, \
22777 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
22778 " [del] [del-chain] mask <mask-value>\n" \
22779 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
22780 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
22781 _(classify_add_del_session, \
22782 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
22783 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
22784 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
22785 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
22786 _(classify_set_interface_ip_table, \
22787 "<intfc> | sw_if_index <nn> table <nn>") \
22788 _(classify_set_interface_l2_tables, \
22789 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22790 " [other-table <nn>]") \
22791 _(get_node_index, "node <node-name") \
22792 _(add_node_next, "node <node-name> next <next-node-name>") \
22793 _(l2tpv3_create_tunnel, \
22794 "client_address <ip6-addr> our_address <ip6-addr>\n" \
22795 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
22796 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
22797 _(l2tpv3_set_tunnel_cookies, \
22798 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
22799 "[new_remote_cookie <nn>]\n") \
22800 _(l2tpv3_interface_enable_disable, \
22801 "<intfc> | sw_if_index <nn> enable | disable") \
22802 _(l2tpv3_set_lookup_key, \
22803 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
22804 _(sw_if_l2tpv3_tunnel_dump, "") \
22805 _(vxlan_add_del_tunnel, \
22806 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
22807 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22808 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
22809 _(geneve_add_del_tunnel, \
22810 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
22811 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22812 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
22813 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22814 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22815 _(gre_add_del_tunnel, \
22816 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [teb] [del]\n") \
22817 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22818 _(l2_fib_clear_table, "") \
22819 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
22820 _(l2_interface_vlan_tag_rewrite, \
22821 "<intfc> | sw_if_index <nn> \n" \
22822 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
22823 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
22824 _(create_vhost_user_if, \
22825 "socket <filename> [server] [renumber <dev_instance>] " \
22826 "[mac <mac_address>]") \
22827 _(modify_vhost_user_if, \
22828 "<intfc> | sw_if_index <nn> socket <filename>\n" \
22829 "[server] [renumber <dev_instance>]") \
22830 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
22831 _(sw_interface_vhost_user_dump, "") \
22832 _(show_version, "") \
22833 _(vxlan_gpe_add_del_tunnel, \
22834 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
22835 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22836 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
22837 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
22838 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22839 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
22840 _(interface_name_renumber, \
22841 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
22842 _(input_acl_set_interface, \
22843 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22844 " [l2-table <nn>] [del]") \
22845 _(want_ip4_arp_events, "address <ip4-address> [del]") \
22846 _(want_ip6_nd_events, "address <ip6-address> [del]") \
22847 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
22848 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
22849 _(ip_dump, "ipv4 | ipv6") \
22850 _(ipsec_spd_add_del, "spd_id <n> [del]") \
22851 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
22853 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
22854 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
22855 " integ_alg <alg> integ_key <hex>") \
22856 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
22857 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
22858 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
22859 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
22860 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
22861 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
22862 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
22863 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
22864 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n") \
22865 _(ipsec_sa_dump, "[sa_id <n>]") \
22866 _(ipsec_tunnel_if_set_key, "<intfc> <local|remote> <crypto|integ>\n" \
22867 " <alg> <hex>\n") \
22868 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
22869 _(ikev2_profile_add_del, "name <profile_name> [del]") \
22870 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
22871 "(auth_data 0x<data> | auth_data <data>)") \
22872 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
22873 "(id_data 0x<data> | id_data <data>) (local|remote)") \
22874 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
22875 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
22876 "(local|remote)") \
22877 _(ikev2_set_local_key, "file <absolute_file_path>") \
22878 _(ikev2_set_responder, "<profile_name> interface <interface> address <addr>") \
22879 _(ikev2_set_ike_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
22880 _(ikev2_set_esp_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
22881 _(ikev2_set_sa_lifetime, "<profile_name> <seconds> <jitter> <handover> <max bytes>") \
22882 _(ikev2_initiate_sa_init, "<profile_name>") \
22883 _(ikev2_initiate_del_ike_sa, "<ispi>") \
22884 _(ikev2_initiate_del_child_sa, "<ispi>") \
22885 _(ikev2_initiate_rekey_child_sa, "<ispi>") \
22886 _(delete_loopback,"sw_if_index <nn>") \
22887 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
22888 _(map_add_domain, \
22889 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
22890 "ip6-src <ip6addr> " \
22891 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
22892 _(map_del_domain, "index <n>") \
22893 _(map_add_del_rule, \
22894 "index <n> psid <n> dst <ip6addr> [del]") \
22895 _(map_domain_dump, "") \
22896 _(map_rule_dump, "index <map-domain>") \
22897 _(want_interface_events, "enable|disable") \
22898 _(want_stats,"enable|disable") \
22899 _(get_first_msg_id, "client <name>") \
22900 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
22901 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
22902 "fib-id <nn> [ip4][ip6][default]") \
22903 _(get_node_graph, " ") \
22904 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
22905 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
22906 _(ioam_disable, "") \
22907 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
22908 " sw_if_index <sw_if_index> p <priority> " \
22909 "w <weight>] [del]") \
22910 _(one_add_del_locator, "locator-set <locator_name> " \
22911 "iface <intf> | sw_if_index <sw_if_index> " \
22912 "p <priority> w <weight> [del]") \
22913 _(one_add_del_local_eid,"vni <vni> eid " \
22914 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22915 "locator-set <locator_name> [del]" \
22916 "[key-id sha1|sha256 secret-key <secret-key>]")\
22917 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
22918 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
22919 _(one_enable_disable, "enable|disable") \
22920 _(one_map_register_enable_disable, "enable|disable") \
22921 _(one_map_register_fallback_threshold, "<value>") \
22922 _(one_rloc_probe_enable_disable, "enable|disable") \
22923 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22925 "rloc <locator> p <prio> " \
22926 "w <weight> [rloc <loc> ... ] " \
22927 "action <action> [del-all]") \
22928 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22930 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22931 _(one_use_petr, "ip-address> | disable") \
22932 _(one_map_request_mode, "src-dst|dst-only") \
22933 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22934 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22935 _(one_locator_set_dump, "[local | remote]") \
22936 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
22937 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22938 "[local] | [remote]") \
22939 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
22940 _(one_ndp_bd_get, "") \
22941 _(one_ndp_entries_get, "bd <bridge-domain>") \
22942 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
22943 _(one_l2_arp_bd_get, "") \
22944 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
22945 _(one_stats_enable_disable, "enable|disalbe") \
22946 _(show_one_stats_enable_disable, "") \
22947 _(one_eid_table_vni_dump, "") \
22948 _(one_eid_table_map_dump, "l2|l3") \
22949 _(one_map_resolver_dump, "") \
22950 _(one_map_server_dump, "") \
22951 _(one_adjacencies_get, "vni <vni>") \
22952 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
22953 _(show_one_rloc_probe_state, "") \
22954 _(show_one_map_register_state, "") \
22955 _(show_one_status, "") \
22956 _(one_stats_dump, "") \
22957 _(one_stats_flush, "") \
22958 _(one_get_map_request_itr_rlocs, "") \
22959 _(one_map_register_set_ttl, "<ttl>") \
22960 _(one_set_transport_protocol, "udp|api") \
22961 _(one_get_transport_protocol, "") \
22962 _(one_enable_disable_xtr_mode, "enable|disable") \
22963 _(one_show_xtr_mode, "") \
22964 _(one_enable_disable_pitr_mode, "enable|disable") \
22965 _(one_show_pitr_mode, "") \
22966 _(one_enable_disable_petr_mode, "enable|disable") \
22967 _(one_show_petr_mode, "") \
22968 _(show_one_nsh_mapping, "") \
22969 _(show_one_pitr, "") \
22970 _(show_one_use_petr, "") \
22971 _(show_one_map_request_mode, "") \
22972 _(show_one_map_register_ttl, "") \
22973 _(show_one_map_register_fallback_threshold, "") \
22974 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
22975 " sw_if_index <sw_if_index> p <priority> " \
22976 "w <weight>] [del]") \
22977 _(lisp_add_del_locator, "locator-set <locator_name> " \
22978 "iface <intf> | sw_if_index <sw_if_index> " \
22979 "p <priority> w <weight> [del]") \
22980 _(lisp_add_del_local_eid,"vni <vni> eid " \
22981 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22982 "locator-set <locator_name> [del]" \
22983 "[key-id sha1|sha256 secret-key <secret-key>]") \
22984 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
22985 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
22986 _(lisp_enable_disable, "enable|disable") \
22987 _(lisp_map_register_enable_disable, "enable|disable") \
22988 _(lisp_rloc_probe_enable_disable, "enable|disable") \
22989 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22991 "rloc <locator> p <prio> " \
22992 "w <weight> [rloc <loc> ... ] " \
22993 "action <action> [del-all]") \
22994 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22996 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22997 _(lisp_use_petr, "<ip-address> | disable") \
22998 _(lisp_map_request_mode, "src-dst|dst-only") \
22999 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
23000 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
23001 _(lisp_locator_set_dump, "[local | remote]") \
23002 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
23003 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
23004 "[local] | [remote]") \
23005 _(lisp_eid_table_vni_dump, "") \
23006 _(lisp_eid_table_map_dump, "l2|l3") \
23007 _(lisp_map_resolver_dump, "") \
23008 _(lisp_map_server_dump, "") \
23009 _(lisp_adjacencies_get, "vni <vni>") \
23010 _(gpe_fwd_entry_vnis_get, "") \
23011 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
23012 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
23013 "[table <table-id>]") \
23014 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
23015 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
23016 _(gpe_set_encap_mode, "lisp|vxlan") \
23017 _(gpe_get_encap_mode, "") \
23018 _(lisp_gpe_add_del_iface, "up|down") \
23019 _(lisp_gpe_enable_disable, "enable|disable") \
23020 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
23021 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
23022 _(show_lisp_rloc_probe_state, "") \
23023 _(show_lisp_map_register_state, "") \
23024 _(show_lisp_status, "") \
23025 _(lisp_get_map_request_itr_rlocs, "") \
23026 _(show_lisp_pitr, "") \
23027 _(show_lisp_use_petr, "") \
23028 _(show_lisp_map_request_mode, "") \
23029 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
23030 _(af_packet_delete, "name <host interface name>") \
23031 _(policer_add_del, "name <policer name> <params> [del]") \
23032 _(policer_dump, "[name <policer name>]") \
23033 _(policer_classify_set_interface, \
23034 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
23035 " [l2-table <nn>] [del]") \
23036 _(policer_classify_dump, "type [ip4|ip6|l2]") \
23037 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
23038 "[master|slave]") \
23039 _(netmap_delete, "name <interface name>") \
23040 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
23041 _(mpls_fib_dump, "") \
23042 _(classify_table_ids, "") \
23043 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
23044 _(classify_table_info, "table_id <nn>") \
23045 _(classify_session_dump, "table_id <nn>") \
23046 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
23047 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
23048 "[template_interval <nn>] [udp_checksum]") \
23049 _(ipfix_exporter_dump, "") \
23050 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
23051 _(ipfix_classify_stream_dump, "") \
23052 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
23053 _(ipfix_classify_table_dump, "") \
23054 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
23055 _(sw_interface_span_dump, "[l2]") \
23056 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
23057 _(pg_create_interface, "if_id <nn>") \
23058 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
23059 _(pg_enable_disable, "[stream <id>] disable") \
23060 _(ip_source_and_port_range_check_add_del, \
23061 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
23062 _(ip_source_and_port_range_check_interface_add_del, \
23063 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
23064 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
23065 _(ipsec_gre_add_del_tunnel, \
23066 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
23067 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
23068 _(delete_subif,"<intfc> | sw_if_index <nn>") \
23069 _(l2_interface_pbb_tag_rewrite, \
23070 "<intfc> | sw_if_index <nn> \n" \
23071 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
23072 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
23073 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
23074 _(flow_classify_set_interface, \
23075 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
23076 _(flow_classify_dump, "type [ip4|ip6]") \
23077 _(ip_fib_dump, "") \
23078 _(ip_mfib_dump, "") \
23079 _(ip6_fib_dump, "") \
23080 _(ip6_mfib_dump, "") \
23081 _(feature_enable_disable, "arc_name <arc_name> " \
23082 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
23083 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
23085 _(l2_xconnect_dump, "") \
23086 _(sw_interface_set_mtu, "<intfc> | sw_if_index <nn> mtu <nn>") \
23087 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
23088 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
23089 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
23090 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
23091 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
23092 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
23093 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
23094 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
23095 _(memfd_segment_create,"size <nnn>") \
23096 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
23097 _(dns_enable_disable, "[enable][disable]") \
23098 _(dns_name_server_add_del, "<ip-address> [del]") \
23099 _(dns_resolve_name, "<hostname>") \
23100 _(dns_resolve_ip, "<ip4|ip6>") \
23101 _(dns_name_server_add_del, "<ip-address> [del]") \
23102 _(dns_resolve_name, "<hostname>") \
23103 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
23104 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
23105 _(session_rules_dump, "") \
23106 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
23108 /* List of command functions, CLI names map directly to functions */
23109 #define foreach_cli_function \
23110 _(comment, "usage: comment <ignore-rest-of-line>") \
23111 _(dump_interface_table, "usage: dump_interface_table") \
23112 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
23113 _(dump_ipv4_table, "usage: dump_ipv4_table") \
23114 _(dump_ipv6_table, "usage: dump_ipv6_table") \
23115 _(dump_stats_table, "usage: dump_stats_table") \
23116 _(dump_macro_table, "usage: dump_macro_table ") \
23117 _(dump_node_table, "usage: dump_node_table") \
23118 _(dump_msg_api_table, "usage: dump_msg_api_table") \
23119 _(get_msg_id, "usage: get_msg_id name_and_crc") \
23120 _(echo, "usage: echo <message>") \
23121 _(exec, "usage: exec <vpe-debug-CLI-command>") \
23122 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
23123 _(help, "usage: help") \
23124 _(q, "usage: quit") \
23125 _(quit, "usage: quit") \
23126 _(search_node_table, "usage: search_node_table <name>...") \
23127 _(set, "usage: set <variable-name> <value>") \
23128 _(script, "usage: script <file-name>") \
23129 _(unset, "usage: unset <variable-name>")
23131 static void vl_api_##n##_t_handler_uni \
23132 (vl_api_##n##_t * mp) \
23134 vat_main_t * vam = &vat_main; \
23135 if (vam->json_output) { \
23136 vl_api_##n##_t_handler_json(mp); \
23138 vl_api_##n##_t_handler(mp); \
23141 foreach_vpe_api_reply_msg;
23142 #if VPP_API_TEST_BUILTIN == 0
23143 foreach_standalone_reply_msg;
23148 vat_api_hookup (vat_main_t * vam)
23151 vl_msg_api_set_handlers(VL_API_##N, #n, \
23152 vl_api_##n##_t_handler_uni, \
23154 vl_api_##n##_t_endian, \
23155 vl_api_##n##_t_print, \
23156 sizeof(vl_api_##n##_t), 1);
23157 foreach_vpe_api_reply_msg;
23158 #if VPP_API_TEST_BUILTIN == 0
23159 foreach_standalone_reply_msg;
23163 #if (VPP_API_TEST_BUILTIN==0)
23164 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
23166 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
23168 vam->function_by_name = hash_create_string (0, sizeof (uword));
23170 vam->help_by_name = hash_create_string (0, sizeof (uword));
23173 /* API messages we can send */
23174 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
23175 foreach_vpe_api_msg;
23179 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
23180 foreach_vpe_api_msg;
23183 /* CLI functions */
23184 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
23185 foreach_cli_function;
23189 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
23190 foreach_cli_function;
23194 #if VPP_API_TEST_BUILTIN
23195 static clib_error_t *
23196 vat_api_hookup_shim (vlib_main_t * vm)
23198 vat_api_hookup (&vat_main);
23202 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
23206 * fd.io coding-style-patch-verification: ON
23209 * eval: (c-set-style "gnu")