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;
7818 int rx_ring_sz = 0, tx_ring_sz = 0;
7820 memset (mac_address, 0, sizeof (mac_address));
7822 /* Parse args required to build the message */
7823 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7825 if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
7829 else if (unformat (i, "name %s", &tap_name))
7831 else if (unformat (i, "host-ns %s", &net_ns))
7833 else if (unformat (i, "rx-ring-size %d", &rx_ring_sz))
7835 else if (unformat (i, "tx-ring-size %d", &tx_ring_sz))
7843 errmsg ("missing tap name. ");
7846 if (vec_len (tap_name) > 63)
7848 errmsg ("tap name too long. ");
7851 if (vec_len (net_ns) > 63)
7853 errmsg ("host name space too long. ");
7856 if (!is_pow2 (rx_ring_sz))
7858 errmsg ("rx ring size must be power of 2. ");
7861 if (rx_ring_sz > 32768)
7863 errmsg ("rx ring size must be 32768 or lower. ");
7866 if (!is_pow2 (tx_ring_sz))
7868 errmsg ("tx ring size must be power of 2. ");
7871 if (tx_ring_sz > 32768)
7873 errmsg ("tx ring size must be 32768 or lower. ");
7877 vec_add1 (tap_name, 0);
7879 /* Construct the API message */
7880 M (TAP_CREATE_V2, mp);
7882 mp->use_random_mac = random_mac;
7883 clib_memcpy (mp->mac_address, mac_address, 6);
7884 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
7885 mp->net_ns_set = net_ns_set;
7886 mp->rx_ring_sz = rx_ring_sz;
7887 mp->tx_ring_sz = tx_ring_sz;
7889 clib_memcpy (mp->net_ns, net_ns, vec_len (net_ns));
7891 vec_free (tap_name);
7896 /* Wait for a reply... */
7902 api_tap_delete_v2 (vat_main_t * vam)
7904 unformat_input_t *i = vam->input;
7905 vl_api_tap_delete_v2_t *mp;
7906 u32 sw_if_index = ~0;
7907 u8 sw_if_index_set = 0;
7910 /* Parse args required to build the message */
7911 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7913 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7914 sw_if_index_set = 1;
7915 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7916 sw_if_index_set = 1;
7921 if (sw_if_index_set == 0)
7923 errmsg ("missing vpp interface name. ");
7927 /* Construct the API message */
7928 M (TAP_DELETE_V2, mp);
7930 mp->sw_if_index = ntohl (sw_if_index);
7935 /* Wait for a reply... */
7941 api_ip_table_add_del (vat_main_t * vam)
7943 unformat_input_t *i = vam->input;
7944 vl_api_ip_table_add_del_t *mp;
7950 /* Parse args required to build the message */
7951 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7953 if (unformat (i, "ipv6"))
7955 else if (unformat (i, "del"))
7957 else if (unformat (i, "add"))
7959 else if (unformat (i, "table %d", &table_id))
7963 clib_warning ("parse error '%U'", format_unformat_error, i);
7970 errmsg ("missing table-ID");
7974 /* Construct the API message */
7975 M (IP_TABLE_ADD_DEL, mp);
7977 mp->table_id = ntohl (table_id);
7978 mp->is_ipv6 = is_ipv6;
7979 mp->is_add = is_add;
7984 /* Wait for a reply... */
7991 api_ip_add_del_route (vat_main_t * vam)
7993 unformat_input_t *i = vam->input;
7994 vl_api_ip_add_del_route_t *mp;
7995 u32 sw_if_index = ~0, vrf_id = 0;
7997 u8 is_local = 0, is_drop = 0;
7998 u8 is_unreach = 0, is_prohibit = 0;
7999 u8 create_vrf_if_needed = 0;
8001 u32 next_hop_weight = 1;
8002 u8 is_multipath = 0;
8004 u8 address_length_set = 0;
8005 u32 next_hop_table_id = 0;
8006 u32 resolve_attempts = 0;
8007 u32 dst_address_length = 0;
8008 u8 next_hop_set = 0;
8009 ip4_address_t v4_dst_address, v4_next_hop_address;
8010 ip6_address_t v6_dst_address, v6_next_hop_address;
8014 u32 random_add_del = 0;
8015 u32 *random_vector = 0;
8017 u32 random_seed = 0xdeaddabe;
8018 u32 classify_table_index = ~0;
8020 u8 resolve_host = 0, resolve_attached = 0;
8021 mpls_label_t *next_hop_out_label_stack = NULL;
8022 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8023 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
8025 /* Parse args required to build the message */
8026 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8028 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8030 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8032 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
8037 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
8042 else if (unformat (i, "/%d", &dst_address_length))
8044 address_length_set = 1;
8047 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
8048 &v4_next_hop_address))
8052 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
8053 &v6_next_hop_address))
8057 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
8059 else if (unformat (i, "weight %d", &next_hop_weight))
8061 else if (unformat (i, "drop"))
8065 else if (unformat (i, "null-send-unreach"))
8069 else if (unformat (i, "null-send-prohibit"))
8073 else if (unformat (i, "local"))
8077 else if (unformat (i, "classify %d", &classify_table_index))
8081 else if (unformat (i, "del"))
8083 else if (unformat (i, "add"))
8085 else if (unformat (i, "resolve-via-host"))
8087 else if (unformat (i, "resolve-via-attached"))
8088 resolve_attached = 1;
8089 else if (unformat (i, "multipath"))
8091 else if (unformat (i, "vrf %d", &vrf_id))
8093 else if (unformat (i, "create-vrf"))
8094 create_vrf_if_needed = 1;
8095 else if (unformat (i, "count %d", &count))
8097 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
8099 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
8101 else if (unformat (i, "out-label %d", &next_hop_out_label))
8102 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
8103 else if (unformat (i, "via-label %d", &next_hop_via_label))
8105 else if (unformat (i, "random"))
8107 else if (unformat (i, "seed %d", &random_seed))
8111 clib_warning ("parse error '%U'", format_unformat_error, i);
8116 if (!next_hop_set && !is_drop && !is_local &&
8117 !is_classify && !is_unreach && !is_prohibit &&
8118 MPLS_LABEL_INVALID == next_hop_via_label)
8121 ("next hop / local / drop / unreach / prohibit / classify not set");
8125 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
8127 errmsg ("next hop and next-hop via label set");
8130 if (address_set == 0)
8132 errmsg ("missing addresses");
8136 if (address_length_set == 0)
8138 errmsg ("missing address length");
8142 /* Generate a pile of unique, random routes */
8145 u32 this_random_address;
8146 random_hash = hash_create (count, sizeof (uword));
8148 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
8149 for (j = 0; j <= count; j++)
8153 this_random_address = random_u32 (&random_seed);
8154 this_random_address =
8155 clib_host_to_net_u32 (this_random_address);
8157 while (hash_get (random_hash, this_random_address));
8158 vec_add1 (random_vector, this_random_address);
8159 hash_set (random_hash, this_random_address, 1);
8161 hash_free (random_hash);
8162 v4_dst_address.as_u32 = random_vector[0];
8167 /* Turn on async mode */
8168 vam->async_mode = 1;
8169 vam->async_errors = 0;
8170 before = vat_time_now (vam);
8173 for (j = 0; j < count; j++)
8175 /* Construct the API message */
8176 M2 (IP_ADD_DEL_ROUTE, mp,
8177 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
8179 mp->next_hop_sw_if_index = ntohl (sw_if_index);
8180 mp->table_id = ntohl (vrf_id);
8181 mp->create_vrf_if_needed = create_vrf_if_needed;
8183 mp->is_add = is_add;
8184 mp->is_drop = is_drop;
8185 mp->is_unreach = is_unreach;
8186 mp->is_prohibit = is_prohibit;
8187 mp->is_ipv6 = is_ipv6;
8188 mp->is_local = is_local;
8189 mp->is_classify = is_classify;
8190 mp->is_multipath = is_multipath;
8191 mp->is_resolve_host = resolve_host;
8192 mp->is_resolve_attached = resolve_attached;
8193 mp->next_hop_weight = next_hop_weight;
8194 mp->dst_address_length = dst_address_length;
8195 mp->next_hop_table_id = ntohl (next_hop_table_id);
8196 mp->classify_table_index = ntohl (classify_table_index);
8197 mp->next_hop_via_label = ntohl (next_hop_via_label);
8198 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
8199 if (0 != mp->next_hop_n_out_labels)
8201 memcpy (mp->next_hop_out_label_stack,
8202 next_hop_out_label_stack,
8203 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
8204 vec_free (next_hop_out_label_stack);
8209 clib_memcpy (mp->dst_address, &v6_dst_address,
8210 sizeof (v6_dst_address));
8212 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
8213 sizeof (v6_next_hop_address));
8214 increment_v6_address (&v6_dst_address);
8218 clib_memcpy (mp->dst_address, &v4_dst_address,
8219 sizeof (v4_dst_address));
8221 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
8222 sizeof (v4_next_hop_address));
8224 v4_dst_address.as_u32 = random_vector[j + 1];
8226 increment_v4_address (&v4_dst_address);
8230 /* If we receive SIGTERM, stop now... */
8235 /* When testing multiple add/del ops, use a control-ping to sync */
8238 vl_api_control_ping_t *mp_ping;
8242 /* Shut off async mode */
8243 vam->async_mode = 0;
8245 MPING (CONTROL_PING, mp_ping);
8248 timeout = vat_time_now (vam) + 1.0;
8249 while (vat_time_now (vam) < timeout)
8250 if (vam->result_ready == 1)
8255 if (vam->retval == -99)
8258 if (vam->async_errors > 0)
8260 errmsg ("%d asynchronous errors", vam->async_errors);
8263 vam->async_errors = 0;
8264 after = vat_time_now (vam);
8266 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8270 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8271 count, after - before, count / (after - before));
8277 /* Wait for a reply... */
8282 /* Return the good/bad news */
8283 return (vam->retval);
8287 api_ip_mroute_add_del (vat_main_t * vam)
8289 unformat_input_t *i = vam->input;
8290 vl_api_ip_mroute_add_del_t *mp;
8291 u32 sw_if_index = ~0, vrf_id = 0;
8294 u8 create_vrf_if_needed = 0;
8297 u32 grp_address_length = 0;
8298 ip4_address_t v4_grp_address, v4_src_address;
8299 ip6_address_t v6_grp_address, v6_src_address;
8300 mfib_itf_flags_t iflags = 0;
8301 mfib_entry_flags_t eflags = 0;
8304 /* Parse args required to build the message */
8305 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8307 if (unformat (i, "sw_if_index %d", &sw_if_index))
8309 else if (unformat (i, "%U %U",
8310 unformat_ip4_address, &v4_src_address,
8311 unformat_ip4_address, &v4_grp_address))
8313 grp_address_length = 64;
8317 else if (unformat (i, "%U %U",
8318 unformat_ip6_address, &v6_src_address,
8319 unformat_ip6_address, &v6_grp_address))
8321 grp_address_length = 256;
8325 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
8327 memset (&v4_src_address, 0, sizeof (v4_src_address));
8328 grp_address_length = 32;
8332 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
8334 memset (&v6_src_address, 0, sizeof (v6_src_address));
8335 grp_address_length = 128;
8339 else if (unformat (i, "/%d", &grp_address_length))
8341 else if (unformat (i, "local"))
8345 else if (unformat (i, "del"))
8347 else if (unformat (i, "add"))
8349 else if (unformat (i, "vrf %d", &vrf_id))
8351 else if (unformat (i, "create-vrf"))
8352 create_vrf_if_needed = 1;
8353 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
8355 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8359 clib_warning ("parse error '%U'", format_unformat_error, i);
8364 if (address_set == 0)
8366 errmsg ("missing addresses\n");
8370 /* Construct the API message */
8371 M (IP_MROUTE_ADD_DEL, mp);
8373 mp->next_hop_sw_if_index = ntohl (sw_if_index);
8374 mp->table_id = ntohl (vrf_id);
8375 mp->create_vrf_if_needed = create_vrf_if_needed;
8377 mp->is_add = is_add;
8378 mp->is_ipv6 = is_ipv6;
8379 mp->is_local = is_local;
8380 mp->itf_flags = ntohl (iflags);
8381 mp->entry_flags = ntohl (eflags);
8382 mp->grp_address_length = grp_address_length;
8383 mp->grp_address_length = ntohs (mp->grp_address_length);
8387 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
8388 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
8392 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
8393 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
8399 /* Wait for a reply... */
8405 api_mpls_table_add_del (vat_main_t * vam)
8407 unformat_input_t *i = vam->input;
8408 vl_api_mpls_table_add_del_t *mp;
8413 /* Parse args required to build the message */
8414 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8416 if (unformat (i, "table %d", &table_id))
8418 else if (unformat (i, "del"))
8420 else if (unformat (i, "add"))
8424 clib_warning ("parse error '%U'", format_unformat_error, i);
8431 errmsg ("missing table-ID");
8435 /* Construct the API message */
8436 M (MPLS_TABLE_ADD_DEL, mp);
8438 mp->mt_table_id = ntohl (table_id);
8439 mp->mt_is_add = is_add;
8444 /* Wait for a reply... */
8451 api_mpls_route_add_del (vat_main_t * vam)
8453 unformat_input_t *i = vam->input;
8454 vl_api_mpls_route_add_del_t *mp;
8455 u32 sw_if_index = ~0, table_id = 0;
8456 u8 create_table_if_needed = 0;
8458 u32 next_hop_weight = 1;
8459 u8 is_multipath = 0;
8460 u32 next_hop_table_id = 0;
8461 u8 next_hop_set = 0;
8462 ip4_address_t v4_next_hop_address = {
8465 ip6_address_t v6_next_hop_address = { {0} };
8469 u32 classify_table_index = ~0;
8471 u8 resolve_host = 0, resolve_attached = 0;
8472 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
8473 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8474 mpls_label_t *next_hop_out_label_stack = NULL;
8475 mpls_label_t local_label = MPLS_LABEL_INVALID;
8477 dpo_proto_t next_hop_proto = DPO_PROTO_IP4;
8479 /* Parse args required to build the message */
8480 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8482 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8484 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8486 else if (unformat (i, "%d", &local_label))
8488 else if (unformat (i, "eos"))
8490 else if (unformat (i, "non-eos"))
8492 else if (unformat (i, "via %U", unformat_ip4_address,
8493 &v4_next_hop_address))
8496 next_hop_proto = DPO_PROTO_IP4;
8498 else if (unformat (i, "via %U", unformat_ip6_address,
8499 &v6_next_hop_address))
8502 next_hop_proto = DPO_PROTO_IP6;
8504 else if (unformat (i, "weight %d", &next_hop_weight))
8506 else if (unformat (i, "create-table"))
8507 create_table_if_needed = 1;
8508 else if (unformat (i, "classify %d", &classify_table_index))
8512 else if (unformat (i, "del"))
8514 else if (unformat (i, "add"))
8516 else if (unformat (i, "resolve-via-host"))
8518 else if (unformat (i, "resolve-via-attached"))
8519 resolve_attached = 1;
8520 else if (unformat (i, "multipath"))
8522 else if (unformat (i, "count %d", &count))
8524 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
8527 next_hop_proto = DPO_PROTO_IP4;
8529 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
8532 next_hop_proto = DPO_PROTO_IP6;
8534 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
8536 else if (unformat (i, "via-label %d", &next_hop_via_label))
8538 else if (unformat (i, "out-label %d", &next_hop_out_label))
8539 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
8542 clib_warning ("parse error '%U'", format_unformat_error, i);
8547 if (!next_hop_set && !is_classify)
8549 errmsg ("next hop / classify not set");
8553 if (MPLS_LABEL_INVALID == local_label)
8555 errmsg ("missing label");
8561 /* Turn on async mode */
8562 vam->async_mode = 1;
8563 vam->async_errors = 0;
8564 before = vat_time_now (vam);
8567 for (j = 0; j < count; j++)
8569 /* Construct the API message */
8570 M2 (MPLS_ROUTE_ADD_DEL, mp,
8571 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
8573 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
8574 mp->mr_table_id = ntohl (table_id);
8575 mp->mr_create_table_if_needed = create_table_if_needed;
8577 mp->mr_is_add = is_add;
8578 mp->mr_next_hop_proto = next_hop_proto;
8579 mp->mr_is_classify = is_classify;
8580 mp->mr_is_multipath = is_multipath;
8581 mp->mr_is_resolve_host = resolve_host;
8582 mp->mr_is_resolve_attached = resolve_attached;
8583 mp->mr_next_hop_weight = next_hop_weight;
8584 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
8585 mp->mr_classify_table_index = ntohl (classify_table_index);
8586 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
8587 mp->mr_label = ntohl (local_label);
8588 mp->mr_eos = is_eos;
8590 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
8591 if (0 != mp->mr_next_hop_n_out_labels)
8593 memcpy (mp->mr_next_hop_out_label_stack,
8594 next_hop_out_label_stack,
8595 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
8596 vec_free (next_hop_out_label_stack);
8601 if (DPO_PROTO_IP4 == next_hop_proto)
8603 clib_memcpy (mp->mr_next_hop,
8604 &v4_next_hop_address,
8605 sizeof (v4_next_hop_address));
8607 else if (DPO_PROTO_IP6 == next_hop_proto)
8610 clib_memcpy (mp->mr_next_hop,
8611 &v6_next_hop_address,
8612 sizeof (v6_next_hop_address));
8619 /* If we receive SIGTERM, stop now... */
8624 /* When testing multiple add/del ops, use a control-ping to sync */
8627 vl_api_control_ping_t *mp_ping;
8631 /* Shut off async mode */
8632 vam->async_mode = 0;
8634 MPING (CONTROL_PING, mp_ping);
8637 timeout = vat_time_now (vam) + 1.0;
8638 while (vat_time_now (vam) < timeout)
8639 if (vam->result_ready == 1)
8644 if (vam->retval == -99)
8647 if (vam->async_errors > 0)
8649 errmsg ("%d asynchronous errors", vam->async_errors);
8652 vam->async_errors = 0;
8653 after = vat_time_now (vam);
8655 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8659 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8660 count, after - before, count / (after - before));
8666 /* Wait for a reply... */
8671 /* Return the good/bad news */
8672 return (vam->retval);
8676 api_mpls_ip_bind_unbind (vat_main_t * vam)
8678 unformat_input_t *i = vam->input;
8679 vl_api_mpls_ip_bind_unbind_t *mp;
8680 u32 ip_table_id = 0;
8681 u8 create_table_if_needed = 0;
8684 ip4_address_t v4_address;
8685 ip6_address_t v6_address;
8688 mpls_label_t local_label = MPLS_LABEL_INVALID;
8691 /* Parse args required to build the message */
8692 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8694 if (unformat (i, "%U/%d", unformat_ip4_address,
8695 &v4_address, &address_length))
8700 else if (unformat (i, "%U/%d", unformat_ip6_address,
8701 &v6_address, &address_length))
8706 else if (unformat (i, "%d", &local_label))
8708 else if (unformat (i, "create-table"))
8709 create_table_if_needed = 1;
8710 else if (unformat (i, "table-id %d", &ip_table_id))
8712 else if (unformat (i, "unbind"))
8714 else if (unformat (i, "bind"))
8718 clib_warning ("parse error '%U'", format_unformat_error, i);
8725 errmsg ("IP addres not set");
8729 if (MPLS_LABEL_INVALID == local_label)
8731 errmsg ("missing label");
8735 /* Construct the API message */
8736 M (MPLS_IP_BIND_UNBIND, mp);
8738 mp->mb_create_table_if_needed = create_table_if_needed;
8739 mp->mb_is_bind = is_bind;
8740 mp->mb_is_ip4 = is_ip4;
8741 mp->mb_ip_table_id = ntohl (ip_table_id);
8742 mp->mb_mpls_table_id = 0;
8743 mp->mb_label = ntohl (local_label);
8744 mp->mb_address_length = address_length;
8747 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
8749 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
8754 /* Wait for a reply... */
8760 api_bier_table_add_del (vat_main_t * vam)
8762 unformat_input_t *i = vam->input;
8763 vl_api_bier_table_add_del_t *mp;
8765 u32 set = 0, sub_domain = 0, hdr_len = 3;
8766 mpls_label_t local_label = MPLS_LABEL_INVALID;
8769 /* Parse args required to build the message */
8770 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8772 if (unformat (i, "sub-domain %d", &sub_domain))
8774 else if (unformat (i, "set %d", &set))
8776 else if (unformat (i, "label %d", &local_label))
8778 else if (unformat (i, "hdr-len %d", &hdr_len))
8780 else if (unformat (i, "add"))
8782 else if (unformat (i, "del"))
8786 clib_warning ("parse error '%U'", format_unformat_error, i);
8791 if (MPLS_LABEL_INVALID == local_label)
8793 errmsg ("missing label\n");
8797 /* Construct the API message */
8798 M (BIER_TABLE_ADD_DEL, mp);
8800 mp->bt_is_add = is_add;
8801 mp->bt_label = ntohl (local_label);
8802 mp->bt_tbl_id.bt_set = set;
8803 mp->bt_tbl_id.bt_sub_domain = sub_domain;
8804 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
8809 /* Wait for a reply... */
8816 api_bier_route_add_del (vat_main_t * vam)
8818 unformat_input_t *i = vam->input;
8819 vl_api_bier_route_add_del_t *mp;
8821 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
8822 ip4_address_t v4_next_hop_address;
8823 ip6_address_t v6_next_hop_address;
8824 u8 next_hop_set = 0;
8825 u8 next_hop_proto_is_ip4 = 1;
8826 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8829 /* Parse args required to build the message */
8830 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8832 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
8834 next_hop_proto_is_ip4 = 1;
8837 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
8839 next_hop_proto_is_ip4 = 0;
8842 if (unformat (i, "sub-domain %d", &sub_domain))
8844 else if (unformat (i, "set %d", &set))
8846 else if (unformat (i, "hdr-len %d", &hdr_len))
8848 else if (unformat (i, "bp %d", &bp))
8850 else if (unformat (i, "add"))
8852 else if (unformat (i, "del"))
8854 else if (unformat (i, "out-label %d", &next_hop_out_label))
8858 clib_warning ("parse error '%U'", format_unformat_error, i);
8863 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
8865 errmsg ("next hop / label set\n");
8870 errmsg ("bit=position not set\n");
8874 /* Construct the API message */
8875 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path3_t));
8877 mp->br_is_add = is_add;
8878 mp->br_tbl_id.bt_set = set;
8879 mp->br_tbl_id.bt_sub_domain = sub_domain;
8880 mp->br_tbl_id.bt_hdr_len_id = hdr_len;
8881 mp->br_bp = ntohs (bp);
8883 mp->br_paths[0].n_labels = 1;
8884 mp->br_paths[0].label_stack[0] = ntohl (next_hop_out_label);
8885 mp->br_paths[0].afi = (next_hop_proto_is_ip4 ? 0 : 1);
8887 if (next_hop_proto_is_ip4)
8889 clib_memcpy (mp->br_paths[0].next_hop,
8890 &v4_next_hop_address, sizeof (v4_next_hop_address));
8894 clib_memcpy (mp->br_paths[0].next_hop,
8895 &v6_next_hop_address, sizeof (v6_next_hop_address));
8901 /* Wait for a reply... */
8908 api_proxy_arp_add_del (vat_main_t * vam)
8910 unformat_input_t *i = vam->input;
8911 vl_api_proxy_arp_add_del_t *mp;
8914 ip4_address_t lo, hi;
8918 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8920 if (unformat (i, "vrf %d", &vrf_id))
8922 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
8923 unformat_ip4_address, &hi))
8925 else if (unformat (i, "del"))
8929 clib_warning ("parse error '%U'", format_unformat_error, i);
8936 errmsg ("address range not set");
8940 M (PROXY_ARP_ADD_DEL, mp);
8942 mp->vrf_id = ntohl (vrf_id);
8943 mp->is_add = is_add;
8944 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
8945 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
8953 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
8955 unformat_input_t *i = vam->input;
8956 vl_api_proxy_arp_intfc_enable_disable_t *mp;
8959 u8 sw_if_index_set = 0;
8962 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8964 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8965 sw_if_index_set = 1;
8966 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8967 sw_if_index_set = 1;
8968 else if (unformat (i, "enable"))
8970 else if (unformat (i, "disable"))
8974 clib_warning ("parse error '%U'", format_unformat_error, i);
8979 if (sw_if_index_set == 0)
8981 errmsg ("missing interface name or sw_if_index");
8985 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
8987 mp->sw_if_index = ntohl (sw_if_index);
8988 mp->enable_disable = enable;
8996 api_mpls_tunnel_add_del (vat_main_t * vam)
8998 unformat_input_t *i = vam->input;
8999 vl_api_mpls_tunnel_add_del_t *mp;
9003 u32 sw_if_index = ~0;
9004 u32 next_hop_sw_if_index = ~0;
9005 u32 next_hop_proto_is_ip4 = 1;
9007 u32 next_hop_table_id = 0;
9008 ip4_address_t v4_next_hop_address = {
9011 ip6_address_t v6_next_hop_address = { {0} };
9012 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID, *labels = NULL;
9015 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9017 if (unformat (i, "add"))
9019 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
9021 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
9023 else if (unformat (i, "via %U",
9024 unformat_ip4_address, &v4_next_hop_address))
9026 next_hop_proto_is_ip4 = 1;
9028 else if (unformat (i, "via %U",
9029 unformat_ip6_address, &v6_next_hop_address))
9031 next_hop_proto_is_ip4 = 0;
9033 else if (unformat (i, "l2-only"))
9035 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
9037 else if (unformat (i, "out-label %d", &next_hop_out_label))
9038 vec_add1 (labels, ntohl (next_hop_out_label));
9041 clib_warning ("parse error '%U'", format_unformat_error, i);
9046 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (mpls_label_t) * vec_len (labels));
9048 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
9049 mp->mt_sw_if_index = ntohl (sw_if_index);
9050 mp->mt_is_add = is_add;
9051 mp->mt_l2_only = l2_only;
9052 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
9053 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
9055 mp->mt_next_hop_n_out_labels = vec_len (labels);
9057 if (0 != mp->mt_next_hop_n_out_labels)
9059 clib_memcpy (mp->mt_next_hop_out_label_stack, labels,
9060 sizeof (mpls_label_t) * mp->mt_next_hop_n_out_labels);
9064 if (next_hop_proto_is_ip4)
9066 clib_memcpy (mp->mt_next_hop,
9067 &v4_next_hop_address, sizeof (v4_next_hop_address));
9071 clib_memcpy (mp->mt_next_hop,
9072 &v6_next_hop_address, sizeof (v6_next_hop_address));
9081 api_sw_interface_set_unnumbered (vat_main_t * vam)
9083 unformat_input_t *i = vam->input;
9084 vl_api_sw_interface_set_unnumbered_t *mp;
9086 u32 unnum_sw_index = ~0;
9088 u8 sw_if_index_set = 0;
9091 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9093 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9094 sw_if_index_set = 1;
9095 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9096 sw_if_index_set = 1;
9097 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
9099 else if (unformat (i, "del"))
9103 clib_warning ("parse error '%U'", format_unformat_error, i);
9108 if (sw_if_index_set == 0)
9110 errmsg ("missing interface name or sw_if_index");
9114 M (SW_INTERFACE_SET_UNNUMBERED, mp);
9116 mp->sw_if_index = ntohl (sw_if_index);
9117 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
9118 mp->is_add = is_add;
9126 api_ip_neighbor_add_del (vat_main_t * vam)
9128 unformat_input_t *i = vam->input;
9129 vl_api_ip_neighbor_add_del_t *mp;
9131 u8 sw_if_index_set = 0;
9134 u8 is_no_fib_entry = 0;
9137 u8 v4_address_set = 0;
9138 u8 v6_address_set = 0;
9139 ip4_address_t v4address;
9140 ip6_address_t v6address;
9143 memset (mac_address, 0, sizeof (mac_address));
9145 /* Parse args required to build the message */
9146 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9148 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
9152 else if (unformat (i, "del"))
9155 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9156 sw_if_index_set = 1;
9157 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9158 sw_if_index_set = 1;
9159 else if (unformat (i, "is_static"))
9161 else if (unformat (i, "no-fib-entry"))
9162 is_no_fib_entry = 1;
9163 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
9165 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
9169 clib_warning ("parse error '%U'", format_unformat_error, i);
9174 if (sw_if_index_set == 0)
9176 errmsg ("missing interface name or sw_if_index");
9179 if (v4_address_set && v6_address_set)
9181 errmsg ("both v4 and v6 addresses set");
9184 if (!v4_address_set && !v6_address_set)
9186 errmsg ("no address set");
9190 /* Construct the API message */
9191 M (IP_NEIGHBOR_ADD_DEL, mp);
9193 mp->sw_if_index = ntohl (sw_if_index);
9194 mp->is_add = is_add;
9195 mp->is_static = is_static;
9196 mp->is_no_adj_fib = is_no_fib_entry;
9198 clib_memcpy (mp->mac_address, mac_address, 6);
9202 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
9206 /* mp->is_ipv6 = 0; via memset in M macro above */
9207 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
9213 /* Wait for a reply, return good/bad news */
9219 api_create_vlan_subif (vat_main_t * vam)
9221 unformat_input_t *i = vam->input;
9222 vl_api_create_vlan_subif_t *mp;
9224 u8 sw_if_index_set = 0;
9229 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9231 if (unformat (i, "sw_if_index %d", &sw_if_index))
9232 sw_if_index_set = 1;
9234 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9235 sw_if_index_set = 1;
9236 else if (unformat (i, "vlan %d", &vlan_id))
9240 clib_warning ("parse error '%U'", format_unformat_error, i);
9245 if (sw_if_index_set == 0)
9247 errmsg ("missing interface name or sw_if_index");
9251 if (vlan_id_set == 0)
9253 errmsg ("missing vlan_id");
9256 M (CREATE_VLAN_SUBIF, mp);
9258 mp->sw_if_index = ntohl (sw_if_index);
9259 mp->vlan_id = ntohl (vlan_id);
9266 #define foreach_create_subif_bit \
9273 _(outer_vlan_id_any) \
9274 _(inner_vlan_id_any)
9277 api_create_subif (vat_main_t * vam)
9279 unformat_input_t *i = vam->input;
9280 vl_api_create_subif_t *mp;
9282 u8 sw_if_index_set = 0;
9289 u32 exact_match = 0;
9290 u32 default_sub = 0;
9291 u32 outer_vlan_id_any = 0;
9292 u32 inner_vlan_id_any = 0;
9294 u16 outer_vlan_id = 0;
9295 u16 inner_vlan_id = 0;
9298 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9300 if (unformat (i, "sw_if_index %d", &sw_if_index))
9301 sw_if_index_set = 1;
9303 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9304 sw_if_index_set = 1;
9305 else if (unformat (i, "sub_id %d", &sub_id))
9307 else if (unformat (i, "outer_vlan_id %d", &tmp))
9308 outer_vlan_id = tmp;
9309 else if (unformat (i, "inner_vlan_id %d", &tmp))
9310 inner_vlan_id = tmp;
9312 #define _(a) else if (unformat (i, #a)) a = 1 ;
9313 foreach_create_subif_bit
9317 clib_warning ("parse error '%U'", format_unformat_error, i);
9322 if (sw_if_index_set == 0)
9324 errmsg ("missing interface name or sw_if_index");
9328 if (sub_id_set == 0)
9330 errmsg ("missing sub_id");
9333 M (CREATE_SUBIF, mp);
9335 mp->sw_if_index = ntohl (sw_if_index);
9336 mp->sub_id = ntohl (sub_id);
9338 #define _(a) mp->a = a;
9339 foreach_create_subif_bit;
9342 mp->outer_vlan_id = ntohs (outer_vlan_id);
9343 mp->inner_vlan_id = ntohs (inner_vlan_id);
9351 api_oam_add_del (vat_main_t * vam)
9353 unformat_input_t *i = vam->input;
9354 vl_api_oam_add_del_t *mp;
9357 ip4_address_t src, dst;
9362 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9364 if (unformat (i, "vrf %d", &vrf_id))
9366 else if (unformat (i, "src %U", unformat_ip4_address, &src))
9368 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
9370 else if (unformat (i, "del"))
9374 clib_warning ("parse error '%U'", format_unformat_error, i);
9381 errmsg ("missing src addr");
9387 errmsg ("missing dst addr");
9391 M (OAM_ADD_DEL, mp);
9393 mp->vrf_id = ntohl (vrf_id);
9394 mp->is_add = is_add;
9395 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
9396 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
9404 api_reset_fib (vat_main_t * vam)
9406 unformat_input_t *i = vam->input;
9407 vl_api_reset_fib_t *mp;
9413 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9415 if (unformat (i, "vrf %d", &vrf_id))
9417 else if (unformat (i, "ipv6"))
9421 clib_warning ("parse error '%U'", format_unformat_error, i);
9426 if (vrf_id_set == 0)
9428 errmsg ("missing vrf id");
9434 mp->vrf_id = ntohl (vrf_id);
9435 mp->is_ipv6 = is_ipv6;
9443 api_dhcp_proxy_config (vat_main_t * vam)
9445 unformat_input_t *i = vam->input;
9446 vl_api_dhcp_proxy_config_t *mp;
9448 u32 server_vrf_id = 0;
9450 u8 v4_address_set = 0;
9451 u8 v6_address_set = 0;
9452 ip4_address_t v4address;
9453 ip6_address_t v6address;
9454 u8 v4_src_address_set = 0;
9455 u8 v6_src_address_set = 0;
9456 ip4_address_t v4srcaddress;
9457 ip6_address_t v6srcaddress;
9460 /* Parse args required to build the message */
9461 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9463 if (unformat (i, "del"))
9465 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
9467 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
9469 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
9471 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
9473 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
9474 v4_src_address_set = 1;
9475 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
9476 v6_src_address_set = 1;
9481 if (v4_address_set && v6_address_set)
9483 errmsg ("both v4 and v6 server addresses set");
9486 if (!v4_address_set && !v6_address_set)
9488 errmsg ("no server addresses set");
9492 if (v4_src_address_set && v6_src_address_set)
9494 errmsg ("both v4 and v6 src addresses set");
9497 if (!v4_src_address_set && !v6_src_address_set)
9499 errmsg ("no src addresses set");
9503 if (!(v4_src_address_set && v4_address_set) &&
9504 !(v6_src_address_set && v6_address_set))
9506 errmsg ("no matching server and src addresses set");
9510 /* Construct the API message */
9511 M (DHCP_PROXY_CONFIG, mp);
9513 mp->is_add = is_add;
9514 mp->rx_vrf_id = ntohl (rx_vrf_id);
9515 mp->server_vrf_id = ntohl (server_vrf_id);
9519 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
9520 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
9524 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
9525 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
9531 /* Wait for a reply, return good/bad news */
9536 #define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
9537 #define vl_api_dhcp_proxy_details_t_print vl_noop_handler
9540 vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
9542 vat_main_t *vam = &vat_main;
9543 u32 i, count = mp->count;
9544 vl_api_dhcp_server_t *s;
9548 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9549 "VSS VPN-ID '%s', VSS FIB-ID %d, VSS OUI %d",
9550 ntohl (mp->rx_vrf_id),
9551 format_ip6_address, mp->dhcp_src_address,
9552 mp->vss_type, mp->vss_vpn_ascii_id,
9553 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9556 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9557 "VSS VPN-ID '%s', VSS FIB-ID %d, VSS OUI %d",
9558 ntohl (mp->rx_vrf_id),
9559 format_ip4_address, mp->dhcp_src_address,
9560 mp->vss_type, mp->vss_vpn_ascii_id,
9561 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9563 for (i = 0; i < count; i++)
9565 s = &mp->servers[i];
9569 " Server Table-ID %d, Server Address %U",
9570 ntohl (s->server_vrf_id), format_ip6_address, s->dhcp_server);
9573 " Server Table-ID %d, Server Address %U",
9574 ntohl (s->server_vrf_id), format_ip4_address, s->dhcp_server);
9578 static void vl_api_dhcp_proxy_details_t_handler_json
9579 (vl_api_dhcp_proxy_details_t * mp)
9581 vat_main_t *vam = &vat_main;
9582 vat_json_node_t *node = NULL;
9583 u32 i, count = mp->count;
9585 struct in6_addr ip6;
9586 vl_api_dhcp_server_t *s;
9588 if (VAT_JSON_ARRAY != vam->json_tree.type)
9590 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9591 vat_json_init_array (&vam->json_tree);
9593 node = vat_json_array_add (&vam->json_tree);
9595 vat_json_init_object (node);
9596 vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
9597 vat_json_object_add_bytes (node, "vss-type", &mp->vss_type,
9598 sizeof (mp->vss_type));
9599 vat_json_object_add_string_copy (node, "vss-vpn-ascii-id",
9600 mp->vss_vpn_ascii_id);
9601 vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
9602 vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
9606 clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
9607 vat_json_object_add_ip6 (node, "src_address", ip6);
9611 clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
9612 vat_json_object_add_ip4 (node, "src_address", ip4);
9615 for (i = 0; i < count; i++)
9617 s = &mp->servers[i];
9619 vat_json_object_add_uint (node, "server-table-id",
9620 ntohl (s->server_vrf_id));
9624 clib_memcpy (&ip4, &s->dhcp_server, sizeof (ip4));
9625 vat_json_object_add_ip4 (node, "src_address", ip4);
9629 clib_memcpy (&ip6, &s->dhcp_server, sizeof (ip6));
9630 vat_json_object_add_ip6 (node, "server_address", ip6);
9636 api_dhcp_proxy_dump (vat_main_t * vam)
9638 unformat_input_t *i = vam->input;
9639 vl_api_control_ping_t *mp_ping;
9640 vl_api_dhcp_proxy_dump_t *mp;
9644 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9646 if (unformat (i, "ipv6"))
9650 clib_warning ("parse error '%U'", format_unformat_error, i);
9655 M (DHCP_PROXY_DUMP, mp);
9657 mp->is_ip6 = is_ipv6;
9660 /* Use a control ping for synchronization */
9661 MPING (CONTROL_PING, mp_ping);
9669 api_dhcp_proxy_set_vss (vat_main_t * vam)
9671 unformat_input_t *i = vam->input;
9672 vl_api_dhcp_proxy_set_vss_t *mp;
9676 u8 vss_type = VSS_TYPE_DEFAULT;
9677 u8 *vpn_ascii_id = 0;
9682 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9684 if (unformat (i, "tbl_id %d", &tbl_id))
9686 else if (unformat (i, "vpn_ascii_id %s", &vpn_ascii_id))
9687 vss_type = VSS_TYPE_ASCII;
9688 else if (unformat (i, "fib_id %d", &fib_id))
9689 vss_type = VSS_TYPE_VPN_ID;
9690 else if (unformat (i, "oui %d", &oui))
9691 vss_type = VSS_TYPE_VPN_ID;
9692 else if (unformat (i, "ipv6"))
9694 else if (unformat (i, "del"))
9702 errmsg ("missing tbl_id ");
9703 vec_free (vpn_ascii_id);
9707 if ((vpn_ascii_id) && (vec_len (vpn_ascii_id) > 128))
9709 errmsg ("vpn_ascii_id cannot be longer than 128 ");
9710 vec_free (vpn_ascii_id);
9714 M (DHCP_PROXY_SET_VSS, mp);
9715 mp->tbl_id = ntohl (tbl_id);
9716 mp->vss_type = vss_type;
9719 clib_memcpy (mp->vpn_ascii_id, vpn_ascii_id, vec_len (vpn_ascii_id));
9720 mp->vpn_ascii_id[vec_len (vpn_ascii_id)] = 0;
9722 mp->vpn_index = ntohl (fib_id);
9723 mp->oui = ntohl (oui);
9724 mp->is_ipv6 = is_ipv6;
9725 mp->is_add = is_add;
9730 vec_free (vpn_ascii_id);
9735 api_dhcp_client_config (vat_main_t * vam)
9737 unformat_input_t *i = vam->input;
9738 vl_api_dhcp_client_config_t *mp;
9740 u8 sw_if_index_set = 0;
9743 u8 disable_event = 0;
9746 /* Parse args required to build the message */
9747 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9749 if (unformat (i, "del"))
9752 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9753 sw_if_index_set = 1;
9754 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9755 sw_if_index_set = 1;
9756 else if (unformat (i, "hostname %s", &hostname))
9758 else if (unformat (i, "disable_event"))
9764 if (sw_if_index_set == 0)
9766 errmsg ("missing interface name or sw_if_index");
9770 if (vec_len (hostname) > 63)
9772 errmsg ("hostname too long");
9774 vec_add1 (hostname, 0);
9776 /* Construct the API message */
9777 M (DHCP_CLIENT_CONFIG, mp);
9779 mp->sw_if_index = htonl (sw_if_index);
9780 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
9781 vec_free (hostname);
9782 mp->is_add = is_add;
9783 mp->want_dhcp_event = disable_event ? 0 : 1;
9784 mp->pid = htonl (getpid ());
9789 /* Wait for a reply, return good/bad news */
9795 api_set_ip_flow_hash (vat_main_t * vam)
9797 unformat_input_t *i = vam->input;
9798 vl_api_set_ip_flow_hash_t *mp;
9810 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9812 if (unformat (i, "vrf %d", &vrf_id))
9814 else if (unformat (i, "ipv6"))
9816 else if (unformat (i, "src"))
9818 else if (unformat (i, "dst"))
9820 else if (unformat (i, "sport"))
9822 else if (unformat (i, "dport"))
9824 else if (unformat (i, "proto"))
9826 else if (unformat (i, "reverse"))
9831 clib_warning ("parse error '%U'", format_unformat_error, i);
9836 if (vrf_id_set == 0)
9838 errmsg ("missing vrf id");
9842 M (SET_IP_FLOW_HASH, mp);
9848 mp->reverse = reverse;
9849 mp->vrf_id = ntohl (vrf_id);
9850 mp->is_ipv6 = is_ipv6;
9858 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
9860 unformat_input_t *i = vam->input;
9861 vl_api_sw_interface_ip6_enable_disable_t *mp;
9863 u8 sw_if_index_set = 0;
9867 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9869 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9870 sw_if_index_set = 1;
9871 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9872 sw_if_index_set = 1;
9873 else if (unformat (i, "enable"))
9875 else if (unformat (i, "disable"))
9879 clib_warning ("parse error '%U'", format_unformat_error, i);
9884 if (sw_if_index_set == 0)
9886 errmsg ("missing interface name or sw_if_index");
9890 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
9892 mp->sw_if_index = ntohl (sw_if_index);
9893 mp->enable = enable;
9901 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
9903 unformat_input_t *i = vam->input;
9904 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
9906 u8 sw_if_index_set = 0;
9907 u8 v6_address_set = 0;
9908 ip6_address_t v6address;
9911 /* Parse args required to build the message */
9912 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9914 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9915 sw_if_index_set = 1;
9916 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9917 sw_if_index_set = 1;
9918 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
9924 if (sw_if_index_set == 0)
9926 errmsg ("missing interface name or sw_if_index");
9929 if (!v6_address_set)
9931 errmsg ("no address set");
9935 /* Construct the API message */
9936 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, mp);
9938 mp->sw_if_index = ntohl (sw_if_index);
9939 clib_memcpy (mp->address, &v6address, sizeof (v6address));
9944 /* Wait for a reply, return good/bad news */
9950 api_ip6nd_proxy_add_del (vat_main_t * vam)
9952 unformat_input_t *i = vam->input;
9953 vl_api_ip6nd_proxy_add_del_t *mp;
9954 u32 sw_if_index = ~0;
9955 u8 v6_address_set = 0;
9956 ip6_address_t v6address;
9960 /* Parse args required to build the message */
9961 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9963 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9965 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9967 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
9969 if (unformat (i, "del"))
9973 clib_warning ("parse error '%U'", format_unformat_error, i);
9978 if (sw_if_index == ~0)
9980 errmsg ("missing interface name or sw_if_index");
9983 if (!v6_address_set)
9985 errmsg ("no address set");
9989 /* Construct the API message */
9990 M (IP6ND_PROXY_ADD_DEL, mp);
9992 mp->is_del = is_del;
9993 mp->sw_if_index = ntohl (sw_if_index);
9994 clib_memcpy (mp->address, &v6address, sizeof (v6address));
9999 /* Wait for a reply, return good/bad news */
10005 api_ip6nd_proxy_dump (vat_main_t * vam)
10007 vl_api_ip6nd_proxy_dump_t *mp;
10008 vl_api_control_ping_t *mp_ping;
10011 M (IP6ND_PROXY_DUMP, mp);
10015 /* Use a control ping for synchronization */
10016 MPING (CONTROL_PING, mp_ping);
10023 static void vl_api_ip6nd_proxy_details_t_handler
10024 (vl_api_ip6nd_proxy_details_t * mp)
10026 vat_main_t *vam = &vat_main;
10028 print (vam->ofp, "host %U sw_if_index %d",
10029 format_ip6_address, mp->address, ntohl (mp->sw_if_index));
10032 static void vl_api_ip6nd_proxy_details_t_handler_json
10033 (vl_api_ip6nd_proxy_details_t * mp)
10035 vat_main_t *vam = &vat_main;
10036 struct in6_addr ip6;
10037 vat_json_node_t *node = NULL;
10039 if (VAT_JSON_ARRAY != vam->json_tree.type)
10041 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10042 vat_json_init_array (&vam->json_tree);
10044 node = vat_json_array_add (&vam->json_tree);
10046 vat_json_init_object (node);
10047 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10049 clib_memcpy (&ip6, mp->address, sizeof (ip6));
10050 vat_json_object_add_ip6 (node, "host", ip6);
10054 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
10056 unformat_input_t *i = vam->input;
10057 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
10059 u8 sw_if_index_set = 0;
10060 u32 address_length = 0;
10061 u8 v6_address_set = 0;
10062 ip6_address_t v6address;
10063 u8 use_default = 0;
10064 u8 no_advertise = 0;
10066 u8 no_autoconfig = 0;
10069 u32 val_lifetime = 0;
10070 u32 pref_lifetime = 0;
10073 /* Parse args required to build the message */
10074 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10076 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10077 sw_if_index_set = 1;
10078 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10079 sw_if_index_set = 1;
10080 else if (unformat (i, "%U/%d",
10081 unformat_ip6_address, &v6address, &address_length))
10082 v6_address_set = 1;
10083 else if (unformat (i, "val_life %d", &val_lifetime))
10085 else if (unformat (i, "pref_life %d", &pref_lifetime))
10087 else if (unformat (i, "def"))
10089 else if (unformat (i, "noadv"))
10091 else if (unformat (i, "offl"))
10093 else if (unformat (i, "noauto"))
10095 else if (unformat (i, "nolink"))
10097 else if (unformat (i, "isno"))
10101 clib_warning ("parse error '%U'", format_unformat_error, i);
10106 if (sw_if_index_set == 0)
10108 errmsg ("missing interface name or sw_if_index");
10111 if (!v6_address_set)
10113 errmsg ("no address set");
10117 /* Construct the API message */
10118 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
10120 mp->sw_if_index = ntohl (sw_if_index);
10121 clib_memcpy (mp->address, &v6address, sizeof (v6address));
10122 mp->address_length = address_length;
10123 mp->use_default = use_default;
10124 mp->no_advertise = no_advertise;
10125 mp->off_link = off_link;
10126 mp->no_autoconfig = no_autoconfig;
10127 mp->no_onlink = no_onlink;
10129 mp->val_lifetime = ntohl (val_lifetime);
10130 mp->pref_lifetime = ntohl (pref_lifetime);
10135 /* Wait for a reply, return good/bad news */
10141 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
10143 unformat_input_t *i = vam->input;
10144 vl_api_sw_interface_ip6nd_ra_config_t *mp;
10146 u8 sw_if_index_set = 0;
10151 u8 send_unicast = 0;
10154 u8 default_router = 0;
10155 u32 max_interval = 0;
10156 u32 min_interval = 0;
10158 u32 initial_count = 0;
10159 u32 initial_interval = 0;
10163 /* Parse args required to build the message */
10164 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10166 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10167 sw_if_index_set = 1;
10168 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10169 sw_if_index_set = 1;
10170 else if (unformat (i, "maxint %d", &max_interval))
10172 else if (unformat (i, "minint %d", &min_interval))
10174 else if (unformat (i, "life %d", &lifetime))
10176 else if (unformat (i, "count %d", &initial_count))
10178 else if (unformat (i, "interval %d", &initial_interval))
10180 else if (unformat (i, "suppress") || unformat (i, "surpress"))
10182 else if (unformat (i, "managed"))
10184 else if (unformat (i, "other"))
10186 else if (unformat (i, "ll"))
10188 else if (unformat (i, "send"))
10190 else if (unformat (i, "cease"))
10192 else if (unformat (i, "isno"))
10194 else if (unformat (i, "def"))
10195 default_router = 1;
10198 clib_warning ("parse error '%U'", format_unformat_error, i);
10203 if (sw_if_index_set == 0)
10205 errmsg ("missing interface name or sw_if_index");
10209 /* Construct the API message */
10210 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
10212 mp->sw_if_index = ntohl (sw_if_index);
10213 mp->max_interval = ntohl (max_interval);
10214 mp->min_interval = ntohl (min_interval);
10215 mp->lifetime = ntohl (lifetime);
10216 mp->initial_count = ntohl (initial_count);
10217 mp->initial_interval = ntohl (initial_interval);
10218 mp->suppress = suppress;
10219 mp->managed = managed;
10221 mp->ll_option = ll_option;
10222 mp->send_unicast = send_unicast;
10225 mp->default_router = default_router;
10230 /* Wait for a reply, return good/bad news */
10236 api_set_arp_neighbor_limit (vat_main_t * vam)
10238 unformat_input_t *i = vam->input;
10239 vl_api_set_arp_neighbor_limit_t *mp;
10245 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10247 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
10249 else if (unformat (i, "ipv6"))
10253 clib_warning ("parse error '%U'", format_unformat_error, i);
10258 if (limit_set == 0)
10260 errmsg ("missing limit value");
10264 M (SET_ARP_NEIGHBOR_LIMIT, mp);
10266 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
10267 mp->is_ipv6 = is_ipv6;
10275 api_l2_patch_add_del (vat_main_t * vam)
10277 unformat_input_t *i = vam->input;
10278 vl_api_l2_patch_add_del_t *mp;
10279 u32 rx_sw_if_index;
10280 u8 rx_sw_if_index_set = 0;
10281 u32 tx_sw_if_index;
10282 u8 tx_sw_if_index_set = 0;
10286 /* Parse args required to build the message */
10287 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10289 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
10290 rx_sw_if_index_set = 1;
10291 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
10292 tx_sw_if_index_set = 1;
10293 else if (unformat (i, "rx"))
10295 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10297 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10299 rx_sw_if_index_set = 1;
10304 else if (unformat (i, "tx"))
10306 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10308 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10310 tx_sw_if_index_set = 1;
10315 else if (unformat (i, "del"))
10321 if (rx_sw_if_index_set == 0)
10323 errmsg ("missing rx interface name or rx_sw_if_index");
10327 if (tx_sw_if_index_set == 0)
10329 errmsg ("missing tx interface name or tx_sw_if_index");
10333 M (L2_PATCH_ADD_DEL, mp);
10335 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
10336 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
10337 mp->is_add = is_add;
10345 u8 localsid_addr[16];
10354 api_sr_localsid_add_del (vat_main_t * vam)
10356 unformat_input_t *i = vam->input;
10357 vl_api_sr_localsid_add_del_t *mp;
10360 ip6_address_t localsid;
10364 u32 fib_table = ~(u32) 0;
10365 ip6_address_t next_hop;
10367 bool nexthop_set = 0;
10371 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10373 if (unformat (i, "del"))
10375 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
10376 else if (unformat (i, "next-hop %U", unformat_ip6_address, &next_hop))
10378 else if (unformat (i, "behavior %u", &behavior));
10379 else if (unformat (i, "sw_if_index %u", &sw_if_index));
10380 else if (unformat (i, "fib-table %u", &fib_table));
10381 else if (unformat (i, "end.psp %u", &behavior));
10386 M (SR_LOCALSID_ADD_DEL, mp);
10388 clib_memcpy (mp->localsid_addr, &localsid, sizeof (mp->localsid_addr));
10390 clib_memcpy (mp->nh_addr, &next_hop, sizeof (mp->nh_addr));
10391 mp->behavior = behavior;
10392 mp->sw_if_index = ntohl (sw_if_index);
10393 mp->fib_table = ntohl (fib_table);
10394 mp->end_psp = end_psp;
10395 mp->is_del = is_del;
10403 api_ioam_enable (vat_main_t * vam)
10405 unformat_input_t *input = vam->input;
10406 vl_api_ioam_enable_t *mp;
10408 int has_trace_option = 0;
10409 int has_pot_option = 0;
10410 int has_seqno_option = 0;
10411 int has_analyse_option = 0;
10414 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10416 if (unformat (input, "trace"))
10417 has_trace_option = 1;
10418 else if (unformat (input, "pot"))
10419 has_pot_option = 1;
10420 else if (unformat (input, "seqno"))
10421 has_seqno_option = 1;
10422 else if (unformat (input, "analyse"))
10423 has_analyse_option = 1;
10427 M (IOAM_ENABLE, mp);
10428 mp->id = htons (id);
10429 mp->seqno = has_seqno_option;
10430 mp->analyse = has_analyse_option;
10431 mp->pot_enable = has_pot_option;
10432 mp->trace_enable = has_trace_option;
10441 api_ioam_disable (vat_main_t * vam)
10443 vl_api_ioam_disable_t *mp;
10446 M (IOAM_DISABLE, mp);
10452 #define foreach_tcp_proto_field \
10456 #define foreach_udp_proto_field \
10460 #define foreach_ip4_proto_field \
10472 u16 src_port, dst_port;
10475 #if VPP_API_TEST_BUILTIN == 0
10477 unformat_tcp_mask (unformat_input_t * input, va_list * args)
10479 u8 **maskp = va_arg (*args, u8 **);
10481 u8 found_something = 0;
10484 #define _(a) u8 a=0;
10485 foreach_tcp_proto_field;
10488 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10491 #define _(a) else if (unformat (input, #a)) a=1;
10492 foreach_tcp_proto_field
10498 #define _(a) found_something += a;
10499 foreach_tcp_proto_field;
10502 if (found_something == 0)
10505 vec_validate (mask, sizeof (*tcp) - 1);
10507 tcp = (tcp_header_t *) mask;
10509 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
10510 foreach_tcp_proto_field;
10518 unformat_udp_mask (unformat_input_t * input, va_list * args)
10520 u8 **maskp = va_arg (*args, u8 **);
10522 u8 found_something = 0;
10525 #define _(a) u8 a=0;
10526 foreach_udp_proto_field;
10529 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10532 #define _(a) else if (unformat (input, #a)) a=1;
10533 foreach_udp_proto_field
10539 #define _(a) found_something += a;
10540 foreach_udp_proto_field;
10543 if (found_something == 0)
10546 vec_validate (mask, sizeof (*udp) - 1);
10548 udp = (udp_header_t *) mask;
10550 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
10551 foreach_udp_proto_field;
10559 unformat_l4_mask (unformat_input_t * input, va_list * args)
10561 u8 **maskp = va_arg (*args, u8 **);
10562 u16 src_port = 0, dst_port = 0;
10563 tcpudp_header_t *tcpudp;
10565 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10567 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
10569 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
10571 else if (unformat (input, "src_port"))
10573 else if (unformat (input, "dst_port"))
10579 if (!src_port && !dst_port)
10583 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
10585 tcpudp = (tcpudp_header_t *) mask;
10586 tcpudp->src_port = src_port;
10587 tcpudp->dst_port = dst_port;
10595 unformat_ip4_mask (unformat_input_t * input, va_list * args)
10597 u8 **maskp = va_arg (*args, u8 **);
10599 u8 found_something = 0;
10602 #define _(a) u8 a=0;
10603 foreach_ip4_proto_field;
10609 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10611 if (unformat (input, "version"))
10613 else if (unformat (input, "hdr_length"))
10615 else if (unformat (input, "src"))
10617 else if (unformat (input, "dst"))
10619 else if (unformat (input, "proto"))
10622 #define _(a) else if (unformat (input, #a)) a=1;
10623 foreach_ip4_proto_field
10629 #define _(a) found_something += a;
10630 foreach_ip4_proto_field;
10633 if (found_something == 0)
10636 vec_validate (mask, sizeof (*ip) - 1);
10638 ip = (ip4_header_t *) mask;
10640 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
10641 foreach_ip4_proto_field;
10644 ip->ip_version_and_header_length = 0;
10647 ip->ip_version_and_header_length |= 0xF0;
10650 ip->ip_version_and_header_length |= 0x0F;
10656 #define foreach_ip6_proto_field \
10659 _(payload_length) \
10664 unformat_ip6_mask (unformat_input_t * input, va_list * args)
10666 u8 **maskp = va_arg (*args, u8 **);
10668 u8 found_something = 0;
10670 u32 ip_version_traffic_class_and_flow_label;
10672 #define _(a) u8 a=0;
10673 foreach_ip6_proto_field;
10676 u8 traffic_class = 0;
10679 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10681 if (unformat (input, "version"))
10683 else if (unformat (input, "traffic-class"))
10685 else if (unformat (input, "flow-label"))
10687 else if (unformat (input, "src"))
10689 else if (unformat (input, "dst"))
10691 else if (unformat (input, "proto"))
10694 #define _(a) else if (unformat (input, #a)) a=1;
10695 foreach_ip6_proto_field
10701 #define _(a) found_something += a;
10702 foreach_ip6_proto_field;
10705 if (found_something == 0)
10708 vec_validate (mask, sizeof (*ip) - 1);
10710 ip = (ip6_header_t *) mask;
10712 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
10713 foreach_ip6_proto_field;
10716 ip_version_traffic_class_and_flow_label = 0;
10719 ip_version_traffic_class_and_flow_label |= 0xF0000000;
10722 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
10725 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
10727 ip->ip_version_traffic_class_and_flow_label =
10728 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10735 unformat_l3_mask (unformat_input_t * input, va_list * args)
10737 u8 **maskp = va_arg (*args, u8 **);
10739 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10741 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
10743 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
10752 unformat_l2_mask (unformat_input_t * input, va_list * args)
10754 u8 **maskp = va_arg (*args, u8 **);
10761 u8 ignore_tag1 = 0;
10762 u8 ignore_tag2 = 0;
10769 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10771 if (unformat (input, "src"))
10773 else if (unformat (input, "dst"))
10775 else if (unformat (input, "proto"))
10777 else if (unformat (input, "tag1"))
10779 else if (unformat (input, "tag2"))
10781 else if (unformat (input, "ignore-tag1"))
10783 else if (unformat (input, "ignore-tag2"))
10785 else if (unformat (input, "cos1"))
10787 else if (unformat (input, "cos2"))
10789 else if (unformat (input, "dot1q"))
10791 else if (unformat (input, "dot1ad"))
10796 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
10797 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10800 if (tag1 || ignore_tag1 || cos1 || dot1q)
10802 if (tag2 || ignore_tag2 || cos2 || dot1ad)
10805 vec_validate (mask, len - 1);
10808 memset (mask, 0xff, 6);
10811 memset (mask + 6, 0xff, 6);
10813 if (tag2 || dot1ad)
10815 /* inner vlan tag */
10824 mask[21] = mask[20] = 0xff;
10845 mask[16] = mask[17] = 0xff;
10855 mask[12] = mask[13] = 0xff;
10862 unformat_classify_mask (unformat_input_t * input, va_list * args)
10864 u8 **maskp = va_arg (*args, u8 **);
10865 u32 *skipp = va_arg (*args, u32 *);
10866 u32 *matchp = va_arg (*args, u32 *);
10874 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10876 if (unformat (input, "hex %U", unformat_hex_string, &mask))
10878 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
10880 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
10882 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
10896 if (mask || l2 || l3 || l4)
10898 if (l2 || l3 || l4)
10900 /* "With a free Ethernet header in every package" */
10902 vec_validate (l2, 13);
10906 vec_append (mask, l3);
10911 vec_append (mask, l4);
10916 /* Scan forward looking for the first significant mask octet */
10917 for (i = 0; i < vec_len (mask); i++)
10921 /* compute (skip, match) params */
10922 *skipp = i / sizeof (u32x4);
10923 vec_delete (mask, *skipp * sizeof (u32x4), 0);
10925 /* Pad mask to an even multiple of the vector size */
10926 while (vec_len (mask) % sizeof (u32x4))
10927 vec_add1 (mask, 0);
10929 match = vec_len (mask) / sizeof (u32x4);
10931 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
10933 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
10934 if (*tmp || *(tmp + 1))
10939 clib_warning ("BUG: match 0");
10941 _vec_len (mask) = match * sizeof (u32x4);
10951 #endif /* VPP_API_TEST_BUILTIN */
10953 #define foreach_l2_next \
10955 _(ethernet, ETHERNET_INPUT) \
10956 _(ip4, IP4_INPUT) \
10960 unformat_l2_next_index (unformat_input_t * input, va_list * args)
10962 u32 *miss_next_indexp = va_arg (*args, u32 *);
10963 u32 next_index = 0;
10967 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
10971 if (unformat (input, "%d", &tmp))
10980 *miss_next_indexp = next_index;
10984 #define foreach_ip_next \
10987 _(rewrite, REWRITE)
10990 api_unformat_ip_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 = IP_LOOKUP_NEXT_##N; goto out;}
11001 if (unformat (input, "%d", &tmp))
11010 *miss_next_indexp = next_index;
11014 #define foreach_acl_next \
11018 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
11020 u32 *miss_next_indexp = va_arg (*args, u32 *);
11021 u32 next_index = 0;
11025 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
11029 if (unformat (input, "permit"))
11034 else if (unformat (input, "%d", &tmp))
11043 *miss_next_indexp = next_index;
11048 unformat_policer_precolor (unformat_input_t * input, va_list * args)
11050 u32 *r = va_arg (*args, u32 *);
11052 if (unformat (input, "conform-color"))
11053 *r = POLICE_CONFORM;
11054 else if (unformat (input, "exceed-color"))
11055 *r = POLICE_EXCEED;
11063 api_classify_add_del_table (vat_main_t * vam)
11065 unformat_input_t *i = vam->input;
11066 vl_api_classify_add_del_table_t *mp;
11073 u32 table_index = ~0;
11074 u32 next_table_index = ~0;
11075 u32 miss_next_index = ~0;
11076 u32 memory_size = 32 << 20;
11078 u32 current_data_flag = 0;
11079 int current_data_offset = 0;
11082 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11084 if (unformat (i, "del"))
11086 else if (unformat (i, "del-chain"))
11091 else if (unformat (i, "buckets %d", &nbuckets))
11093 else if (unformat (i, "memory_size %d", &memory_size))
11095 else if (unformat (i, "skip %d", &skip))
11097 else if (unformat (i, "match %d", &match))
11099 else if (unformat (i, "table %d", &table_index))
11101 else if (unformat (i, "mask %U", unformat_classify_mask,
11102 &mask, &skip, &match))
11104 else if (unformat (i, "next-table %d", &next_table_index))
11106 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
11109 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
11112 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
11115 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
11117 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
11123 if (is_add && mask == 0)
11125 errmsg ("Mask required");
11129 if (is_add && skip == ~0)
11131 errmsg ("skip count required");
11135 if (is_add && match == ~0)
11137 errmsg ("match count required");
11141 if (!is_add && table_index == ~0)
11143 errmsg ("table index required for delete");
11147 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
11149 mp->is_add = is_add;
11150 mp->del_chain = del_chain;
11151 mp->table_index = ntohl (table_index);
11152 mp->nbuckets = ntohl (nbuckets);
11153 mp->memory_size = ntohl (memory_size);
11154 mp->skip_n_vectors = ntohl (skip);
11155 mp->match_n_vectors = ntohl (match);
11156 mp->next_table_index = ntohl (next_table_index);
11157 mp->miss_next_index = ntohl (miss_next_index);
11158 mp->current_data_flag = ntohl (current_data_flag);
11159 mp->current_data_offset = ntohl (current_data_offset);
11160 clib_memcpy (mp->mask, mask, vec_len (mask));
11169 #if VPP_API_TEST_BUILTIN == 0
11171 unformat_l4_match (unformat_input_t * input, va_list * args)
11173 u8 **matchp = va_arg (*args, u8 **);
11175 u8 *proto_header = 0;
11181 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11183 if (unformat (input, "src_port %d", &src_port))
11185 else if (unformat (input, "dst_port %d", &dst_port))
11191 h.src_port = clib_host_to_net_u16 (src_port);
11192 h.dst_port = clib_host_to_net_u16 (dst_port);
11193 vec_validate (proto_header, sizeof (h) - 1);
11194 memcpy (proto_header, &h, sizeof (h));
11196 *matchp = proto_header;
11202 unformat_ip4_match (unformat_input_t * input, va_list * args)
11204 u8 **matchp = va_arg (*args, u8 **);
11209 int hdr_length = 0;
11210 u32 hdr_length_val;
11211 int src = 0, dst = 0;
11212 ip4_address_t src_val, dst_val;
11219 int fragment_id = 0;
11220 u32 fragment_id_val;
11226 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11228 if (unformat (input, "version %d", &version_val))
11230 else if (unformat (input, "hdr_length %d", &hdr_length_val))
11232 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
11234 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
11236 else if (unformat (input, "proto %d", &proto_val))
11238 else if (unformat (input, "tos %d", &tos_val))
11240 else if (unformat (input, "length %d", &length_val))
11242 else if (unformat (input, "fragment_id %d", &fragment_id_val))
11244 else if (unformat (input, "ttl %d", &ttl_val))
11246 else if (unformat (input, "checksum %d", &checksum_val))
11252 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
11253 + ttl + checksum == 0)
11257 * Aligned because we use the real comparison functions
11259 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11261 ip = (ip4_header_t *) match;
11263 /* These are realistically matched in practice */
11265 ip->src_address.as_u32 = src_val.as_u32;
11268 ip->dst_address.as_u32 = dst_val.as_u32;
11271 ip->protocol = proto_val;
11274 /* These are not, but they're included for completeness */
11276 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
11279 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
11285 ip->length = clib_host_to_net_u16 (length_val);
11291 ip->checksum = clib_host_to_net_u16 (checksum_val);
11298 unformat_ip6_match (unformat_input_t * input, va_list * args)
11300 u8 **matchp = va_arg (*args, u8 **);
11305 u8 traffic_class = 0;
11306 u32 traffic_class_val = 0;
11309 int src = 0, dst = 0;
11310 ip6_address_t src_val, dst_val;
11313 int payload_length = 0;
11314 u32 payload_length_val;
11317 u32 ip_version_traffic_class_and_flow_label;
11319 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11321 if (unformat (input, "version %d", &version_val))
11323 else if (unformat (input, "traffic_class %d", &traffic_class_val))
11325 else if (unformat (input, "flow_label %d", &flow_label_val))
11327 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
11329 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
11331 else if (unformat (input, "proto %d", &proto_val))
11333 else if (unformat (input, "payload_length %d", &payload_length_val))
11334 payload_length = 1;
11335 else if (unformat (input, "hop_limit %d", &hop_limit_val))
11341 if (version + traffic_class + flow_label + src + dst + proto +
11342 payload_length + hop_limit == 0)
11346 * Aligned because we use the real comparison functions
11348 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11350 ip = (ip6_header_t *) match;
11353 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
11356 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
11359 ip->protocol = proto_val;
11361 ip_version_traffic_class_and_flow_label = 0;
11364 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
11367 ip_version_traffic_class_and_flow_label |=
11368 (traffic_class_val & 0xFF) << 20;
11371 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
11373 ip->ip_version_traffic_class_and_flow_label =
11374 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
11376 if (payload_length)
11377 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
11380 ip->hop_limit = hop_limit_val;
11387 unformat_l3_match (unformat_input_t * input, va_list * args)
11389 u8 **matchp = va_arg (*args, u8 **);
11391 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11393 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
11395 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
11404 unformat_vlan_tag (unformat_input_t * input, va_list * args)
11406 u8 *tagp = va_arg (*args, u8 *);
11409 if (unformat (input, "%d", &tag))
11411 tagp[0] = (tag >> 8) & 0x0F;
11412 tagp[1] = tag & 0xFF;
11420 unformat_l2_match (unformat_input_t * input, va_list * args)
11422 u8 **matchp = va_arg (*args, u8 **);
11435 u8 ignore_tag1 = 0;
11436 u8 ignore_tag2 = 0;
11442 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11444 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
11447 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
11449 else if (unformat (input, "proto %U",
11450 unformat_ethernet_type_host_byte_order, &proto_val))
11452 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
11454 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
11456 else if (unformat (input, "ignore-tag1"))
11458 else if (unformat (input, "ignore-tag2"))
11460 else if (unformat (input, "cos1 %d", &cos1_val))
11462 else if (unformat (input, "cos2 %d", &cos2_val))
11467 if ((src + dst + proto + tag1 + tag2 +
11468 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
11471 if (tag1 || ignore_tag1 || cos1)
11473 if (tag2 || ignore_tag2 || cos2)
11476 vec_validate_aligned (match, len - 1, sizeof (u32x4));
11479 clib_memcpy (match, dst_val, 6);
11482 clib_memcpy (match + 6, src_val, 6);
11486 /* inner vlan tag */
11487 match[19] = tag2_val[1];
11488 match[18] = tag2_val[0];
11490 match[18] |= (cos2_val & 0x7) << 5;
11493 match[21] = proto_val & 0xff;
11494 match[20] = proto_val >> 8;
11498 match[15] = tag1_val[1];
11499 match[14] = tag1_val[0];
11502 match[14] |= (cos1_val & 0x7) << 5;
11508 match[15] = tag1_val[1];
11509 match[14] = tag1_val[0];
11512 match[17] = proto_val & 0xff;
11513 match[16] = proto_val >> 8;
11516 match[14] |= (cos1_val & 0x7) << 5;
11522 match[18] |= (cos2_val & 0x7) << 5;
11524 match[14] |= (cos1_val & 0x7) << 5;
11527 match[13] = proto_val & 0xff;
11528 match[12] = proto_val >> 8;
11537 api_unformat_classify_match (unformat_input_t * input, va_list * args)
11539 u8 **matchp = va_arg (*args, u8 **);
11540 u32 skip_n_vectors = va_arg (*args, u32);
11541 u32 match_n_vectors = va_arg (*args, u32);
11548 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11550 if (unformat (input, "hex %U", unformat_hex_string, &match))
11552 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
11554 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
11556 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
11570 if (match || l2 || l3 || l4)
11572 if (l2 || l3 || l4)
11574 /* "Win a free Ethernet header in every packet" */
11576 vec_validate_aligned (l2, 13, sizeof (u32x4));
11580 vec_append_aligned (match, l3, sizeof (u32x4));
11585 vec_append_aligned (match, l4, sizeof (u32x4));
11590 /* Make sure the vector is big enough even if key is all 0's */
11591 vec_validate_aligned
11592 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
11595 /* Set size, include skipped vectors */
11596 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
11607 api_classify_add_del_session (vat_main_t * vam)
11609 unformat_input_t *i = vam->input;
11610 vl_api_classify_add_del_session_t *mp;
11612 u32 table_index = ~0;
11613 u32 hit_next_index = ~0;
11614 u32 opaque_index = ~0;
11617 u32 skip_n_vectors = 0;
11618 u32 match_n_vectors = 0;
11624 * Warning: you have to supply skip_n and match_n
11625 * because the API client cant simply look at the classify
11629 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11631 if (unformat (i, "del"))
11633 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
11636 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
11639 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
11642 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
11644 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
11646 else if (unformat (i, "opaque-index %d", &opaque_index))
11648 else if (unformat (i, "skip_n %d", &skip_n_vectors))
11650 else if (unformat (i, "match_n %d", &match_n_vectors))
11652 else if (unformat (i, "match %U", api_unformat_classify_match,
11653 &match, skip_n_vectors, match_n_vectors))
11655 else if (unformat (i, "advance %d", &advance))
11657 else if (unformat (i, "table-index %d", &table_index))
11659 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
11661 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
11663 else if (unformat (i, "action %d", &action))
11665 else if (unformat (i, "metadata %d", &metadata))
11671 if (table_index == ~0)
11673 errmsg ("Table index required");
11677 if (is_add && match == 0)
11679 errmsg ("Match value required");
11683 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
11685 mp->is_add = is_add;
11686 mp->table_index = ntohl (table_index);
11687 mp->hit_next_index = ntohl (hit_next_index);
11688 mp->opaque_index = ntohl (opaque_index);
11689 mp->advance = ntohl (advance);
11690 mp->action = action;
11691 mp->metadata = ntohl (metadata);
11692 clib_memcpy (mp->match, match, vec_len (match));
11701 api_classify_set_interface_ip_table (vat_main_t * vam)
11703 unformat_input_t *i = vam->input;
11704 vl_api_classify_set_interface_ip_table_t *mp;
11706 int sw_if_index_set;
11707 u32 table_index = ~0;
11711 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11713 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11714 sw_if_index_set = 1;
11715 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11716 sw_if_index_set = 1;
11717 else if (unformat (i, "table %d", &table_index))
11721 clib_warning ("parse error '%U'", format_unformat_error, i);
11726 if (sw_if_index_set == 0)
11728 errmsg ("missing interface name or sw_if_index");
11733 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
11735 mp->sw_if_index = ntohl (sw_if_index);
11736 mp->table_index = ntohl (table_index);
11737 mp->is_ipv6 = is_ipv6;
11745 api_classify_set_interface_l2_tables (vat_main_t * vam)
11747 unformat_input_t *i = vam->input;
11748 vl_api_classify_set_interface_l2_tables_t *mp;
11750 int sw_if_index_set;
11751 u32 ip4_table_index = ~0;
11752 u32 ip6_table_index = ~0;
11753 u32 other_table_index = ~0;
11757 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11759 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11760 sw_if_index_set = 1;
11761 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11762 sw_if_index_set = 1;
11763 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11765 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11767 else if (unformat (i, "other-table %d", &other_table_index))
11769 else if (unformat (i, "is-input %d", &is_input))
11773 clib_warning ("parse error '%U'", format_unformat_error, i);
11778 if (sw_if_index_set == 0)
11780 errmsg ("missing interface name or sw_if_index");
11785 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
11787 mp->sw_if_index = ntohl (sw_if_index);
11788 mp->ip4_table_index = ntohl (ip4_table_index);
11789 mp->ip6_table_index = ntohl (ip6_table_index);
11790 mp->other_table_index = ntohl (other_table_index);
11791 mp->is_input = (u8) is_input;
11799 api_set_ipfix_exporter (vat_main_t * vam)
11801 unformat_input_t *i = vam->input;
11802 vl_api_set_ipfix_exporter_t *mp;
11803 ip4_address_t collector_address;
11804 u8 collector_address_set = 0;
11805 u32 collector_port = ~0;
11806 ip4_address_t src_address;
11807 u8 src_address_set = 0;
11810 u32 template_interval = ~0;
11811 u8 udp_checksum = 0;
11814 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11816 if (unformat (i, "collector_address %U", unformat_ip4_address,
11817 &collector_address))
11818 collector_address_set = 1;
11819 else if (unformat (i, "collector_port %d", &collector_port))
11821 else if (unformat (i, "src_address %U", unformat_ip4_address,
11823 src_address_set = 1;
11824 else if (unformat (i, "vrf_id %d", &vrf_id))
11826 else if (unformat (i, "path_mtu %d", &path_mtu))
11828 else if (unformat (i, "template_interval %d", &template_interval))
11830 else if (unformat (i, "udp_checksum"))
11836 if (collector_address_set == 0)
11838 errmsg ("collector_address required");
11842 if (src_address_set == 0)
11844 errmsg ("src_address required");
11848 M (SET_IPFIX_EXPORTER, mp);
11850 memcpy (mp->collector_address, collector_address.data,
11851 sizeof (collector_address.data));
11852 mp->collector_port = htons ((u16) collector_port);
11853 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
11854 mp->vrf_id = htonl (vrf_id);
11855 mp->path_mtu = htonl (path_mtu);
11856 mp->template_interval = htonl (template_interval);
11857 mp->udp_checksum = udp_checksum;
11865 api_set_ipfix_classify_stream (vat_main_t * vam)
11867 unformat_input_t *i = vam->input;
11868 vl_api_set_ipfix_classify_stream_t *mp;
11870 u32 src_port = UDP_DST_PORT_ipfix;
11873 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11875 if (unformat (i, "domain %d", &domain_id))
11877 else if (unformat (i, "src_port %d", &src_port))
11881 errmsg ("unknown input `%U'", format_unformat_error, i);
11886 M (SET_IPFIX_CLASSIFY_STREAM, mp);
11888 mp->domain_id = htonl (domain_id);
11889 mp->src_port = htons ((u16) src_port);
11897 api_ipfix_classify_table_add_del (vat_main_t * vam)
11899 unformat_input_t *i = vam->input;
11900 vl_api_ipfix_classify_table_add_del_t *mp;
11902 u32 classify_table_index = ~0;
11904 u8 transport_protocol = 255;
11907 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11909 if (unformat (i, "add"))
11911 else if (unformat (i, "del"))
11913 else if (unformat (i, "table %d", &classify_table_index))
11915 else if (unformat (i, "ip4"))
11917 else if (unformat (i, "ip6"))
11919 else if (unformat (i, "tcp"))
11920 transport_protocol = 6;
11921 else if (unformat (i, "udp"))
11922 transport_protocol = 17;
11925 errmsg ("unknown input `%U'", format_unformat_error, i);
11932 errmsg ("expecting: add|del");
11935 if (classify_table_index == ~0)
11937 errmsg ("classifier table not specified");
11940 if (ip_version == 0)
11942 errmsg ("IP version not specified");
11946 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
11948 mp->is_add = is_add;
11949 mp->table_id = htonl (classify_table_index);
11950 mp->ip_version = ip_version;
11951 mp->transport_protocol = transport_protocol;
11959 api_get_node_index (vat_main_t * vam)
11961 unformat_input_t *i = vam->input;
11962 vl_api_get_node_index_t *mp;
11966 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11968 if (unformat (i, "node %s", &name))
11975 errmsg ("node name required");
11978 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11980 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11984 M (GET_NODE_INDEX, mp);
11985 clib_memcpy (mp->node_name, name, vec_len (name));
11994 api_get_next_index (vat_main_t * vam)
11996 unformat_input_t *i = vam->input;
11997 vl_api_get_next_index_t *mp;
11998 u8 *node_name = 0, *next_node_name = 0;
12001 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12003 if (unformat (i, "node-name %s", &node_name))
12005 else if (unformat (i, "next-node-name %s", &next_node_name))
12009 if (node_name == 0)
12011 errmsg ("node name required");
12014 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
12016 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12020 if (next_node_name == 0)
12022 errmsg ("next node name required");
12025 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
12027 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
12031 M (GET_NEXT_INDEX, mp);
12032 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
12033 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
12034 vec_free (node_name);
12035 vec_free (next_node_name);
12043 api_add_node_next (vat_main_t * vam)
12045 unformat_input_t *i = vam->input;
12046 vl_api_add_node_next_t *mp;
12051 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12053 if (unformat (i, "node %s", &name))
12055 else if (unformat (i, "next %s", &next))
12062 errmsg ("node name required");
12065 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
12067 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12072 errmsg ("next node required");
12075 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
12077 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
12081 M (ADD_NODE_NEXT, mp);
12082 clib_memcpy (mp->node_name, name, vec_len (name));
12083 clib_memcpy (mp->next_name, next, vec_len (next));
12093 api_l2tpv3_create_tunnel (vat_main_t * vam)
12095 unformat_input_t *i = vam->input;
12096 ip6_address_t client_address, our_address;
12097 int client_address_set = 0;
12098 int our_address_set = 0;
12099 u32 local_session_id = 0;
12100 u32 remote_session_id = 0;
12101 u64 local_cookie = 0;
12102 u64 remote_cookie = 0;
12103 u8 l2_sublayer_present = 0;
12104 vl_api_l2tpv3_create_tunnel_t *mp;
12107 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12109 if (unformat (i, "client_address %U", unformat_ip6_address,
12111 client_address_set = 1;
12112 else if (unformat (i, "our_address %U", unformat_ip6_address,
12114 our_address_set = 1;
12115 else if (unformat (i, "local_session_id %d", &local_session_id))
12117 else if (unformat (i, "remote_session_id %d", &remote_session_id))
12119 else if (unformat (i, "local_cookie %lld", &local_cookie))
12121 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
12123 else if (unformat (i, "l2-sublayer-present"))
12124 l2_sublayer_present = 1;
12129 if (client_address_set == 0)
12131 errmsg ("client_address required");
12135 if (our_address_set == 0)
12137 errmsg ("our_address required");
12141 M (L2TPV3_CREATE_TUNNEL, mp);
12143 clib_memcpy (mp->client_address, client_address.as_u8,
12144 sizeof (mp->client_address));
12146 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
12148 mp->local_session_id = ntohl (local_session_id);
12149 mp->remote_session_id = ntohl (remote_session_id);
12150 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
12151 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
12152 mp->l2_sublayer_present = l2_sublayer_present;
12161 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
12163 unformat_input_t *i = vam->input;
12165 u8 sw_if_index_set = 0;
12166 u64 new_local_cookie = 0;
12167 u64 new_remote_cookie = 0;
12168 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
12171 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12173 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12174 sw_if_index_set = 1;
12175 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12176 sw_if_index_set = 1;
12177 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
12179 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
12185 if (sw_if_index_set == 0)
12187 errmsg ("missing interface name or sw_if_index");
12191 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
12193 mp->sw_if_index = ntohl (sw_if_index);
12194 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
12195 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
12203 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
12205 unformat_input_t *i = vam->input;
12206 vl_api_l2tpv3_interface_enable_disable_t *mp;
12208 u8 sw_if_index_set = 0;
12209 u8 enable_disable = 1;
12212 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12214 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12215 sw_if_index_set = 1;
12216 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12217 sw_if_index_set = 1;
12218 else if (unformat (i, "enable"))
12219 enable_disable = 1;
12220 else if (unformat (i, "disable"))
12221 enable_disable = 0;
12226 if (sw_if_index_set == 0)
12228 errmsg ("missing interface name or sw_if_index");
12232 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
12234 mp->sw_if_index = ntohl (sw_if_index);
12235 mp->enable_disable = enable_disable;
12243 api_l2tpv3_set_lookup_key (vat_main_t * vam)
12245 unformat_input_t *i = vam->input;
12246 vl_api_l2tpv3_set_lookup_key_t *mp;
12250 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12252 if (unformat (i, "lookup_v6_src"))
12253 key = L2T_LOOKUP_SRC_ADDRESS;
12254 else if (unformat (i, "lookup_v6_dst"))
12255 key = L2T_LOOKUP_DST_ADDRESS;
12256 else if (unformat (i, "lookup_session_id"))
12257 key = L2T_LOOKUP_SESSION_ID;
12262 if (key == (u8) ~ 0)
12264 errmsg ("l2tp session lookup key unset");
12268 M (L2TPV3_SET_LOOKUP_KEY, mp);
12277 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
12278 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12280 vat_main_t *vam = &vat_main;
12282 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
12283 format_ip6_address, mp->our_address,
12284 format_ip6_address, mp->client_address,
12285 clib_net_to_host_u32 (mp->sw_if_index));
12288 " local cookies %016llx %016llx remote cookie %016llx",
12289 clib_net_to_host_u64 (mp->local_cookie[0]),
12290 clib_net_to_host_u64 (mp->local_cookie[1]),
12291 clib_net_to_host_u64 (mp->remote_cookie));
12293 print (vam->ofp, " local session-id %d remote session-id %d",
12294 clib_net_to_host_u32 (mp->local_session_id),
12295 clib_net_to_host_u32 (mp->remote_session_id));
12297 print (vam->ofp, " l2 specific sublayer %s\n",
12298 mp->l2_sublayer_present ? "preset" : "absent");
12302 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
12303 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12305 vat_main_t *vam = &vat_main;
12306 vat_json_node_t *node = NULL;
12307 struct in6_addr addr;
12309 if (VAT_JSON_ARRAY != vam->json_tree.type)
12311 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12312 vat_json_init_array (&vam->json_tree);
12314 node = vat_json_array_add (&vam->json_tree);
12316 vat_json_init_object (node);
12318 clib_memcpy (&addr, mp->our_address, sizeof (addr));
12319 vat_json_object_add_ip6 (node, "our_address", addr);
12320 clib_memcpy (&addr, mp->client_address, sizeof (addr));
12321 vat_json_object_add_ip6 (node, "client_address", addr);
12323 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
12324 vat_json_init_array (lc);
12325 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
12326 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
12327 vat_json_object_add_uint (node, "remote_cookie",
12328 clib_net_to_host_u64 (mp->remote_cookie));
12330 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
12331 vat_json_object_add_uint (node, "local_session_id",
12332 clib_net_to_host_u32 (mp->local_session_id));
12333 vat_json_object_add_uint (node, "remote_session_id",
12334 clib_net_to_host_u32 (mp->remote_session_id));
12335 vat_json_object_add_string_copy (node, "l2_sublayer",
12336 mp->l2_sublayer_present ? (u8 *) "present"
12337 : (u8 *) "absent");
12341 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
12343 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
12344 vl_api_control_ping_t *mp_ping;
12347 /* Get list of l2tpv3-tunnel interfaces */
12348 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
12351 /* Use a control ping for synchronization */
12352 MPING (CONTROL_PING, mp_ping);
12360 static void vl_api_sw_interface_tap_details_t_handler
12361 (vl_api_sw_interface_tap_details_t * mp)
12363 vat_main_t *vam = &vat_main;
12365 print (vam->ofp, "%-16s %d",
12366 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
12369 static void vl_api_sw_interface_tap_details_t_handler_json
12370 (vl_api_sw_interface_tap_details_t * mp)
12372 vat_main_t *vam = &vat_main;
12373 vat_json_node_t *node = NULL;
12375 if (VAT_JSON_ARRAY != vam->json_tree.type)
12377 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12378 vat_json_init_array (&vam->json_tree);
12380 node = vat_json_array_add (&vam->json_tree);
12382 vat_json_init_object (node);
12383 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12384 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
12388 api_sw_interface_tap_dump (vat_main_t * vam)
12390 vl_api_sw_interface_tap_dump_t *mp;
12391 vl_api_control_ping_t *mp_ping;
12394 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
12395 /* Get list of tap interfaces */
12396 M (SW_INTERFACE_TAP_DUMP, mp);
12399 /* Use a control ping for synchronization */
12400 MPING (CONTROL_PING, mp_ping);
12407 static void vl_api_sw_interface_tap_v2_details_t_handler
12408 (vl_api_sw_interface_tap_v2_details_t * mp)
12410 vat_main_t *vam = &vat_main;
12412 print (vam->ofp, "%-16s %d",
12413 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
12416 static void vl_api_sw_interface_tap_v2_details_t_handler_json
12417 (vl_api_sw_interface_tap_v2_details_t * mp)
12419 vat_main_t *vam = &vat_main;
12420 vat_json_node_t *node = NULL;
12422 if (VAT_JSON_ARRAY != vam->json_tree.type)
12424 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12425 vat_json_init_array (&vam->json_tree);
12427 node = vat_json_array_add (&vam->json_tree);
12429 vat_json_init_object (node);
12430 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12431 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
12435 api_sw_interface_tap_v2_dump (vat_main_t * vam)
12437 vl_api_sw_interface_tap_v2_dump_t *mp;
12438 vl_api_control_ping_t *mp_ping;
12441 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
12442 /* Get list of tap interfaces */
12443 M (SW_INTERFACE_TAP_V2_DUMP, mp);
12446 /* Use a control ping for synchronization */
12447 MPING (CONTROL_PING, mp_ping);
12454 static uword unformat_vxlan_decap_next
12455 (unformat_input_t * input, va_list * args)
12457 u32 *result = va_arg (*args, u32 *);
12460 if (unformat (input, "l2"))
12461 *result = VXLAN_INPUT_NEXT_L2_INPUT;
12462 else if (unformat (input, "%d", &tmp))
12470 api_vxlan_add_del_tunnel (vat_main_t * vam)
12472 unformat_input_t *line_input = vam->input;
12473 vl_api_vxlan_add_del_tunnel_t *mp;
12474 ip46_address_t src, dst;
12476 u8 ipv4_set = 0, ipv6_set = 0;
12480 u32 mcast_sw_if_index = ~0;
12481 u32 encap_vrf_id = 0;
12482 u32 decap_next_index = ~0;
12486 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12487 memset (&src, 0, sizeof src);
12488 memset (&dst, 0, sizeof dst);
12490 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12492 if (unformat (line_input, "del"))
12495 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12501 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12507 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12513 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12518 else if (unformat (line_input, "group %U %U",
12519 unformat_ip4_address, &dst.ip4,
12520 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12522 grp_set = dst_set = 1;
12525 else if (unformat (line_input, "group %U",
12526 unformat_ip4_address, &dst.ip4))
12528 grp_set = dst_set = 1;
12531 else if (unformat (line_input, "group %U %U",
12532 unformat_ip6_address, &dst.ip6,
12533 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12535 grp_set = dst_set = 1;
12538 else if (unformat (line_input, "group %U",
12539 unformat_ip6_address, &dst.ip6))
12541 grp_set = dst_set = 1;
12545 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12547 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12549 else if (unformat (line_input, "decap-next %U",
12550 unformat_vxlan_decap_next, &decap_next_index))
12552 else if (unformat (line_input, "vni %d", &vni))
12556 errmsg ("parse error '%U'", format_unformat_error, line_input);
12563 errmsg ("tunnel src address not specified");
12568 errmsg ("tunnel dst address not specified");
12572 if (grp_set && !ip46_address_is_multicast (&dst))
12574 errmsg ("tunnel group address not multicast");
12577 if (grp_set && mcast_sw_if_index == ~0)
12579 errmsg ("tunnel nonexistent multicast device");
12582 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12584 errmsg ("tunnel dst address must be unicast");
12589 if (ipv4_set && ipv6_set)
12591 errmsg ("both IPv4 and IPv6 addresses specified");
12595 if ((vni == 0) || (vni >> 24))
12597 errmsg ("vni not specified or out of range");
12601 M (VXLAN_ADD_DEL_TUNNEL, mp);
12605 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
12606 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
12610 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
12611 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
12613 mp->encap_vrf_id = ntohl (encap_vrf_id);
12614 mp->decap_next_index = ntohl (decap_next_index);
12615 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12616 mp->vni = ntohl (vni);
12617 mp->is_add = is_add;
12618 mp->is_ipv6 = ipv6_set;
12625 static void vl_api_vxlan_tunnel_details_t_handler
12626 (vl_api_vxlan_tunnel_details_t * mp)
12628 vat_main_t *vam = &vat_main;
12629 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12630 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12632 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12633 ntohl (mp->sw_if_index),
12634 format_ip46_address, &src, IP46_TYPE_ANY,
12635 format_ip46_address, &dst, IP46_TYPE_ANY,
12636 ntohl (mp->encap_vrf_id),
12637 ntohl (mp->decap_next_index), ntohl (mp->vni),
12638 ntohl (mp->mcast_sw_if_index));
12641 static void vl_api_vxlan_tunnel_details_t_handler_json
12642 (vl_api_vxlan_tunnel_details_t * mp)
12644 vat_main_t *vam = &vat_main;
12645 vat_json_node_t *node = NULL;
12647 if (VAT_JSON_ARRAY != vam->json_tree.type)
12649 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12650 vat_json_init_array (&vam->json_tree);
12652 node = vat_json_array_add (&vam->json_tree);
12654 vat_json_init_object (node);
12655 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12658 struct in6_addr ip6;
12660 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12661 vat_json_object_add_ip6 (node, "src_address", ip6);
12662 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12663 vat_json_object_add_ip6 (node, "dst_address", ip6);
12667 struct in_addr ip4;
12669 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12670 vat_json_object_add_ip4 (node, "src_address", ip4);
12671 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12672 vat_json_object_add_ip4 (node, "dst_address", ip4);
12674 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12675 vat_json_object_add_uint (node, "decap_next_index",
12676 ntohl (mp->decap_next_index));
12677 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12678 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12679 vat_json_object_add_uint (node, "mcast_sw_if_index",
12680 ntohl (mp->mcast_sw_if_index));
12684 api_vxlan_tunnel_dump (vat_main_t * vam)
12686 unformat_input_t *i = vam->input;
12687 vl_api_vxlan_tunnel_dump_t *mp;
12688 vl_api_control_ping_t *mp_ping;
12690 u8 sw_if_index_set = 0;
12693 /* Parse args required to build the message */
12694 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12696 if (unformat (i, "sw_if_index %d", &sw_if_index))
12697 sw_if_index_set = 1;
12702 if (sw_if_index_set == 0)
12707 if (!vam->json_output)
12709 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12710 "sw_if_index", "src_address", "dst_address",
12711 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12714 /* Get list of vxlan-tunnel interfaces */
12715 M (VXLAN_TUNNEL_DUMP, mp);
12717 mp->sw_if_index = htonl (sw_if_index);
12721 /* Use a control ping for synchronization */
12722 MPING (CONTROL_PING, mp_ping);
12729 static uword unformat_geneve_decap_next
12730 (unformat_input_t * input, va_list * args)
12732 u32 *result = va_arg (*args, u32 *);
12735 if (unformat (input, "l2"))
12736 *result = GENEVE_INPUT_NEXT_L2_INPUT;
12737 else if (unformat (input, "%d", &tmp))
12745 api_geneve_add_del_tunnel (vat_main_t * vam)
12747 unformat_input_t *line_input = vam->input;
12748 vl_api_geneve_add_del_tunnel_t *mp;
12749 ip46_address_t src, dst;
12751 u8 ipv4_set = 0, ipv6_set = 0;
12755 u32 mcast_sw_if_index = ~0;
12756 u32 encap_vrf_id = 0;
12757 u32 decap_next_index = ~0;
12761 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12762 memset (&src, 0, sizeof src);
12763 memset (&dst, 0, sizeof dst);
12765 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12767 if (unformat (line_input, "del"))
12770 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12776 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12782 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12788 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12793 else if (unformat (line_input, "group %U %U",
12794 unformat_ip4_address, &dst.ip4,
12795 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12797 grp_set = dst_set = 1;
12800 else if (unformat (line_input, "group %U",
12801 unformat_ip4_address, &dst.ip4))
12803 grp_set = dst_set = 1;
12806 else if (unformat (line_input, "group %U %U",
12807 unformat_ip6_address, &dst.ip6,
12808 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12810 grp_set = dst_set = 1;
12813 else if (unformat (line_input, "group %U",
12814 unformat_ip6_address, &dst.ip6))
12816 grp_set = dst_set = 1;
12820 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12822 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12824 else if (unformat (line_input, "decap-next %U",
12825 unformat_geneve_decap_next, &decap_next_index))
12827 else if (unformat (line_input, "vni %d", &vni))
12831 errmsg ("parse error '%U'", format_unformat_error, line_input);
12838 errmsg ("tunnel src address not specified");
12843 errmsg ("tunnel dst address not specified");
12847 if (grp_set && !ip46_address_is_multicast (&dst))
12849 errmsg ("tunnel group address not multicast");
12852 if (grp_set && mcast_sw_if_index == ~0)
12854 errmsg ("tunnel nonexistent multicast device");
12857 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12859 errmsg ("tunnel dst address must be unicast");
12864 if (ipv4_set && ipv6_set)
12866 errmsg ("both IPv4 and IPv6 addresses specified");
12870 if ((vni == 0) || (vni >> 24))
12872 errmsg ("vni not specified or out of range");
12876 M (GENEVE_ADD_DEL_TUNNEL, mp);
12880 clib_memcpy (mp->local_address, &src.ip6, sizeof (src.ip6));
12881 clib_memcpy (mp->remote_address, &dst.ip6, sizeof (dst.ip6));
12885 clib_memcpy (mp->local_address, &src.ip4, sizeof (src.ip4));
12886 clib_memcpy (mp->remote_address, &dst.ip4, sizeof (dst.ip4));
12888 mp->encap_vrf_id = ntohl (encap_vrf_id);
12889 mp->decap_next_index = ntohl (decap_next_index);
12890 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12891 mp->vni = ntohl (vni);
12892 mp->is_add = is_add;
12893 mp->is_ipv6 = ipv6_set;
12900 static void vl_api_geneve_tunnel_details_t_handler
12901 (vl_api_geneve_tunnel_details_t * mp)
12903 vat_main_t *vam = &vat_main;
12904 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12905 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12907 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12908 ntohl (mp->sw_if_index),
12909 format_ip46_address, &src, IP46_TYPE_ANY,
12910 format_ip46_address, &dst, IP46_TYPE_ANY,
12911 ntohl (mp->encap_vrf_id),
12912 ntohl (mp->decap_next_index), ntohl (mp->vni),
12913 ntohl (mp->mcast_sw_if_index));
12916 static void vl_api_geneve_tunnel_details_t_handler_json
12917 (vl_api_geneve_tunnel_details_t * mp)
12919 vat_main_t *vam = &vat_main;
12920 vat_json_node_t *node = NULL;
12922 if (VAT_JSON_ARRAY != vam->json_tree.type)
12924 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12925 vat_json_init_array (&vam->json_tree);
12927 node = vat_json_array_add (&vam->json_tree);
12929 vat_json_init_object (node);
12930 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12933 struct in6_addr ip6;
12935 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12936 vat_json_object_add_ip6 (node, "src_address", ip6);
12937 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12938 vat_json_object_add_ip6 (node, "dst_address", ip6);
12942 struct in_addr ip4;
12944 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12945 vat_json_object_add_ip4 (node, "src_address", ip4);
12946 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12947 vat_json_object_add_ip4 (node, "dst_address", ip4);
12949 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12950 vat_json_object_add_uint (node, "decap_next_index",
12951 ntohl (mp->decap_next_index));
12952 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12953 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12954 vat_json_object_add_uint (node, "mcast_sw_if_index",
12955 ntohl (mp->mcast_sw_if_index));
12959 api_geneve_tunnel_dump (vat_main_t * vam)
12961 unformat_input_t *i = vam->input;
12962 vl_api_geneve_tunnel_dump_t *mp;
12963 vl_api_control_ping_t *mp_ping;
12965 u8 sw_if_index_set = 0;
12968 /* Parse args required to build the message */
12969 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12971 if (unformat (i, "sw_if_index %d", &sw_if_index))
12972 sw_if_index_set = 1;
12977 if (sw_if_index_set == 0)
12982 if (!vam->json_output)
12984 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12985 "sw_if_index", "local_address", "remote_address",
12986 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12989 /* Get list of geneve-tunnel interfaces */
12990 M (GENEVE_TUNNEL_DUMP, mp);
12992 mp->sw_if_index = htonl (sw_if_index);
12996 /* Use a control ping for synchronization */
12997 M (CONTROL_PING, mp_ping);
13005 api_gre_add_del_tunnel (vat_main_t * vam)
13007 unformat_input_t *line_input = vam->input;
13008 vl_api_gre_add_del_tunnel_t *mp;
13009 ip4_address_t src4, dst4;
13010 ip6_address_t src6, dst6;
13017 u32 outer_fib_id = 0;
13020 memset (&src4, 0, sizeof src4);
13021 memset (&dst4, 0, sizeof dst4);
13022 memset (&src6, 0, sizeof src6);
13023 memset (&dst6, 0, sizeof dst6);
13025 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13027 if (unformat (line_input, "del"))
13029 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
13034 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
13039 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
13044 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
13049 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
13051 else if (unformat (line_input, "teb"))
13055 errmsg ("parse error '%U'", format_unformat_error, line_input);
13062 errmsg ("tunnel src address not specified");
13067 errmsg ("tunnel dst address not specified");
13070 if (ipv4_set && ipv6_set)
13072 errmsg ("both IPv4 and IPv6 addresses specified");
13077 M (GRE_ADD_DEL_TUNNEL, mp);
13081 clib_memcpy (&mp->src_address, &src4, 4);
13082 clib_memcpy (&mp->dst_address, &dst4, 4);
13086 clib_memcpy (&mp->src_address, &src6, 16);
13087 clib_memcpy (&mp->dst_address, &dst6, 16);
13089 mp->outer_fib_id = ntohl (outer_fib_id);
13090 mp->is_add = is_add;
13092 mp->is_ipv6 = ipv6_set;
13099 static void vl_api_gre_tunnel_details_t_handler
13100 (vl_api_gre_tunnel_details_t * mp)
13102 vat_main_t *vam = &vat_main;
13103 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->src_address);
13104 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->dst_address);
13106 print (vam->ofp, "%11d%24U%24U%6d%14d",
13107 ntohl (mp->sw_if_index),
13108 format_ip46_address, &src, IP46_TYPE_ANY,
13109 format_ip46_address, &dst, IP46_TYPE_ANY,
13110 mp->teb, ntohl (mp->outer_fib_id));
13113 static void vl_api_gre_tunnel_details_t_handler_json
13114 (vl_api_gre_tunnel_details_t * mp)
13116 vat_main_t *vam = &vat_main;
13117 vat_json_node_t *node = NULL;
13118 struct in_addr ip4;
13119 struct in6_addr ip6;
13121 if (VAT_JSON_ARRAY != vam->json_tree.type)
13123 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13124 vat_json_init_array (&vam->json_tree);
13126 node = vat_json_array_add (&vam->json_tree);
13128 vat_json_init_object (node);
13129 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13132 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
13133 vat_json_object_add_ip4 (node, "src_address", ip4);
13134 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
13135 vat_json_object_add_ip4 (node, "dst_address", ip4);
13139 clib_memcpy (&ip6, &mp->src_address, sizeof (ip6));
13140 vat_json_object_add_ip6 (node, "src_address", ip6);
13141 clib_memcpy (&ip6, &mp->dst_address, sizeof (ip6));
13142 vat_json_object_add_ip6 (node, "dst_address", ip6);
13144 vat_json_object_add_uint (node, "teb", mp->teb);
13145 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
13146 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6);
13150 api_gre_tunnel_dump (vat_main_t * vam)
13152 unformat_input_t *i = vam->input;
13153 vl_api_gre_tunnel_dump_t *mp;
13154 vl_api_control_ping_t *mp_ping;
13156 u8 sw_if_index_set = 0;
13159 /* Parse args required to build the message */
13160 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13162 if (unformat (i, "sw_if_index %d", &sw_if_index))
13163 sw_if_index_set = 1;
13168 if (sw_if_index_set == 0)
13173 if (!vam->json_output)
13175 print (vam->ofp, "%11s%24s%24s%6s%14s",
13176 "sw_if_index", "src_address", "dst_address", "teb",
13180 /* Get list of gre-tunnel interfaces */
13181 M (GRE_TUNNEL_DUMP, mp);
13183 mp->sw_if_index = htonl (sw_if_index);
13187 /* Use a control ping for synchronization */
13188 MPING (CONTROL_PING, mp_ping);
13196 api_l2_fib_clear_table (vat_main_t * vam)
13198 // unformat_input_t * i = vam->input;
13199 vl_api_l2_fib_clear_table_t *mp;
13202 M (L2_FIB_CLEAR_TABLE, mp);
13210 api_l2_interface_efp_filter (vat_main_t * vam)
13212 unformat_input_t *i = vam->input;
13213 vl_api_l2_interface_efp_filter_t *mp;
13216 u8 sw_if_index_set = 0;
13219 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13221 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13222 sw_if_index_set = 1;
13223 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13224 sw_if_index_set = 1;
13225 else if (unformat (i, "enable"))
13227 else if (unformat (i, "disable"))
13231 clib_warning ("parse error '%U'", format_unformat_error, i);
13236 if (sw_if_index_set == 0)
13238 errmsg ("missing sw_if_index");
13242 M (L2_INTERFACE_EFP_FILTER, mp);
13244 mp->sw_if_index = ntohl (sw_if_index);
13245 mp->enable_disable = enable;
13252 #define foreach_vtr_op \
13253 _("disable", L2_VTR_DISABLED) \
13254 _("push-1", L2_VTR_PUSH_1) \
13255 _("push-2", L2_VTR_PUSH_2) \
13256 _("pop-1", L2_VTR_POP_1) \
13257 _("pop-2", L2_VTR_POP_2) \
13258 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
13259 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
13260 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
13261 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
13264 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
13266 unformat_input_t *i = vam->input;
13267 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
13269 u8 sw_if_index_set = 0;
13272 u32 push_dot1q = 1;
13277 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13279 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13280 sw_if_index_set = 1;
13281 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13282 sw_if_index_set = 1;
13283 else if (unformat (i, "vtr_op %d", &vtr_op))
13285 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
13288 else if (unformat (i, "push_dot1q %d", &push_dot1q))
13290 else if (unformat (i, "tag1 %d", &tag1))
13292 else if (unformat (i, "tag2 %d", &tag2))
13296 clib_warning ("parse error '%U'", format_unformat_error, i);
13301 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
13303 errmsg ("missing vtr operation or sw_if_index");
13307 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
13308 mp->sw_if_index = ntohl (sw_if_index);
13309 mp->vtr_op = ntohl (vtr_op);
13310 mp->push_dot1q = ntohl (push_dot1q);
13311 mp->tag1 = ntohl (tag1);
13312 mp->tag2 = ntohl (tag2);
13320 api_create_vhost_user_if (vat_main_t * vam)
13322 unformat_input_t *i = vam->input;
13323 vl_api_create_vhost_user_if_t *mp;
13326 u8 file_name_set = 0;
13327 u32 custom_dev_instance = ~0;
13329 u8 use_custom_mac = 0;
13333 /* Shut up coverity */
13334 memset (hwaddr, 0, sizeof (hwaddr));
13336 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13338 if (unformat (i, "socket %s", &file_name))
13342 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13344 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
13345 use_custom_mac = 1;
13346 else if (unformat (i, "server"))
13348 else if (unformat (i, "tag %s", &tag))
13354 if (file_name_set == 0)
13356 errmsg ("missing socket file name");
13360 if (vec_len (file_name) > 255)
13362 errmsg ("socket file name too long");
13365 vec_add1 (file_name, 0);
13367 M (CREATE_VHOST_USER_IF, mp);
13369 mp->is_server = is_server;
13370 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13371 vec_free (file_name);
13372 if (custom_dev_instance != ~0)
13375 mp->custom_dev_instance = ntohl (custom_dev_instance);
13377 mp->use_custom_mac = use_custom_mac;
13378 clib_memcpy (mp->mac_address, hwaddr, 6);
13380 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
13389 api_modify_vhost_user_if (vat_main_t * vam)
13391 unformat_input_t *i = vam->input;
13392 vl_api_modify_vhost_user_if_t *mp;
13395 u8 file_name_set = 0;
13396 u32 custom_dev_instance = ~0;
13397 u8 sw_if_index_set = 0;
13398 u32 sw_if_index = (u32) ~ 0;
13401 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13403 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13404 sw_if_index_set = 1;
13405 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13406 sw_if_index_set = 1;
13407 else if (unformat (i, "socket %s", &file_name))
13411 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13413 else if (unformat (i, "server"))
13419 if (sw_if_index_set == 0)
13421 errmsg ("missing sw_if_index or interface name");
13425 if (file_name_set == 0)
13427 errmsg ("missing socket file name");
13431 if (vec_len (file_name) > 255)
13433 errmsg ("socket file name too long");
13436 vec_add1 (file_name, 0);
13438 M (MODIFY_VHOST_USER_IF, mp);
13440 mp->sw_if_index = ntohl (sw_if_index);
13441 mp->is_server = is_server;
13442 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13443 vec_free (file_name);
13444 if (custom_dev_instance != ~0)
13447 mp->custom_dev_instance = ntohl (custom_dev_instance);
13456 api_delete_vhost_user_if (vat_main_t * vam)
13458 unformat_input_t *i = vam->input;
13459 vl_api_delete_vhost_user_if_t *mp;
13460 u32 sw_if_index = ~0;
13461 u8 sw_if_index_set = 0;
13464 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13466 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13467 sw_if_index_set = 1;
13468 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13469 sw_if_index_set = 1;
13474 if (sw_if_index_set == 0)
13476 errmsg ("missing sw_if_index or interface name");
13481 M (DELETE_VHOST_USER_IF, mp);
13483 mp->sw_if_index = ntohl (sw_if_index);
13490 static void vl_api_sw_interface_vhost_user_details_t_handler
13491 (vl_api_sw_interface_vhost_user_details_t * mp)
13493 vat_main_t *vam = &vat_main;
13495 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
13496 (char *) mp->interface_name,
13497 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
13498 clib_net_to_host_u64 (mp->features), mp->is_server,
13499 ntohl (mp->num_regions), (char *) mp->sock_filename);
13500 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
13503 static void vl_api_sw_interface_vhost_user_details_t_handler_json
13504 (vl_api_sw_interface_vhost_user_details_t * mp)
13506 vat_main_t *vam = &vat_main;
13507 vat_json_node_t *node = NULL;
13509 if (VAT_JSON_ARRAY != vam->json_tree.type)
13511 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13512 vat_json_init_array (&vam->json_tree);
13514 node = vat_json_array_add (&vam->json_tree);
13516 vat_json_init_object (node);
13517 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13518 vat_json_object_add_string_copy (node, "interface_name",
13519 mp->interface_name);
13520 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
13521 ntohl (mp->virtio_net_hdr_sz));
13522 vat_json_object_add_uint (node, "features",
13523 clib_net_to_host_u64 (mp->features));
13524 vat_json_object_add_uint (node, "is_server", mp->is_server);
13525 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
13526 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
13527 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
13531 api_sw_interface_vhost_user_dump (vat_main_t * vam)
13533 vl_api_sw_interface_vhost_user_dump_t *mp;
13534 vl_api_control_ping_t *mp_ping;
13537 "Interface name idx hdr_sz features server regions filename");
13539 /* Get list of vhost-user interfaces */
13540 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
13543 /* Use a control ping for synchronization */
13544 MPING (CONTROL_PING, mp_ping);
13552 api_show_version (vat_main_t * vam)
13554 vl_api_show_version_t *mp;
13557 M (SHOW_VERSION, mp);
13566 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
13568 unformat_input_t *line_input = vam->input;
13569 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
13570 ip4_address_t local4, remote4;
13571 ip6_address_t local6, remote6;
13573 u8 ipv4_set = 0, ipv6_set = 0;
13577 u32 mcast_sw_if_index = ~0;
13578 u32 encap_vrf_id = 0;
13579 u32 decap_vrf_id = 0;
13585 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
13586 memset (&local4, 0, sizeof local4);
13587 memset (&remote4, 0, sizeof remote4);
13588 memset (&local6, 0, sizeof local6);
13589 memset (&remote6, 0, sizeof remote6);
13591 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13593 if (unformat (line_input, "del"))
13595 else if (unformat (line_input, "local %U",
13596 unformat_ip4_address, &local4))
13601 else if (unformat (line_input, "remote %U",
13602 unformat_ip4_address, &remote4))
13607 else if (unformat (line_input, "local %U",
13608 unformat_ip6_address, &local6))
13613 else if (unformat (line_input, "remote %U",
13614 unformat_ip6_address, &remote6))
13619 else if (unformat (line_input, "group %U %U",
13620 unformat_ip4_address, &remote4,
13621 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13623 grp_set = remote_set = 1;
13626 else if (unformat (line_input, "group %U",
13627 unformat_ip4_address, &remote4))
13629 grp_set = remote_set = 1;
13632 else if (unformat (line_input, "group %U %U",
13633 unformat_ip6_address, &remote6,
13634 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13636 grp_set = remote_set = 1;
13639 else if (unformat (line_input, "group %U",
13640 unformat_ip6_address, &remote6))
13642 grp_set = remote_set = 1;
13646 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13648 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13650 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
13652 else if (unformat (line_input, "vni %d", &vni))
13654 else if (unformat (line_input, "next-ip4"))
13656 else if (unformat (line_input, "next-ip6"))
13658 else if (unformat (line_input, "next-ethernet"))
13660 else if (unformat (line_input, "next-nsh"))
13664 errmsg ("parse error '%U'", format_unformat_error, line_input);
13669 if (local_set == 0)
13671 errmsg ("tunnel local address not specified");
13674 if (remote_set == 0)
13676 errmsg ("tunnel remote address not specified");
13679 if (grp_set && mcast_sw_if_index == ~0)
13681 errmsg ("tunnel nonexistent multicast device");
13684 if (ipv4_set && ipv6_set)
13686 errmsg ("both IPv4 and IPv6 addresses specified");
13692 errmsg ("vni not specified");
13696 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
13701 clib_memcpy (&mp->local, &local6, sizeof (local6));
13702 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
13706 clib_memcpy (&mp->local, &local4, sizeof (local4));
13707 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
13710 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
13711 mp->encap_vrf_id = ntohl (encap_vrf_id);
13712 mp->decap_vrf_id = ntohl (decap_vrf_id);
13713 mp->protocol = protocol;
13714 mp->vni = ntohl (vni);
13715 mp->is_add = is_add;
13716 mp->is_ipv6 = ipv6_set;
13723 static void vl_api_vxlan_gpe_tunnel_details_t_handler
13724 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13726 vat_main_t *vam = &vat_main;
13727 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
13728 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
13730 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
13731 ntohl (mp->sw_if_index),
13732 format_ip46_address, &local, IP46_TYPE_ANY,
13733 format_ip46_address, &remote, IP46_TYPE_ANY,
13734 ntohl (mp->vni), mp->protocol,
13735 ntohl (mp->mcast_sw_if_index),
13736 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
13740 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
13741 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13743 vat_main_t *vam = &vat_main;
13744 vat_json_node_t *node = NULL;
13745 struct in_addr ip4;
13746 struct in6_addr ip6;
13748 if (VAT_JSON_ARRAY != vam->json_tree.type)
13750 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13751 vat_json_init_array (&vam->json_tree);
13753 node = vat_json_array_add (&vam->json_tree);
13755 vat_json_init_object (node);
13756 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13759 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
13760 vat_json_object_add_ip6 (node, "local", ip6);
13761 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
13762 vat_json_object_add_ip6 (node, "remote", ip6);
13766 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
13767 vat_json_object_add_ip4 (node, "local", ip4);
13768 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
13769 vat_json_object_add_ip4 (node, "remote", ip4);
13771 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
13772 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
13773 vat_json_object_add_uint (node, "mcast_sw_if_index",
13774 ntohl (mp->mcast_sw_if_index));
13775 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
13776 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
13777 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
13781 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
13783 unformat_input_t *i = vam->input;
13784 vl_api_vxlan_gpe_tunnel_dump_t *mp;
13785 vl_api_control_ping_t *mp_ping;
13787 u8 sw_if_index_set = 0;
13790 /* Parse args required to build the message */
13791 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13793 if (unformat (i, "sw_if_index %d", &sw_if_index))
13794 sw_if_index_set = 1;
13799 if (sw_if_index_set == 0)
13804 if (!vam->json_output)
13806 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
13807 "sw_if_index", "local", "remote", "vni",
13808 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
13811 /* Get list of vxlan-tunnel interfaces */
13812 M (VXLAN_GPE_TUNNEL_DUMP, mp);
13814 mp->sw_if_index = htonl (sw_if_index);
13818 /* Use a control ping for synchronization */
13819 MPING (CONTROL_PING, mp_ping);
13826 static void vl_api_l2_fib_table_details_t_handler
13827 (vl_api_l2_fib_table_details_t * mp)
13829 vat_main_t *vam = &vat_main;
13831 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
13833 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
13834 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
13838 static void vl_api_l2_fib_table_details_t_handler_json
13839 (vl_api_l2_fib_table_details_t * mp)
13841 vat_main_t *vam = &vat_main;
13842 vat_json_node_t *node = NULL;
13844 if (VAT_JSON_ARRAY != vam->json_tree.type)
13846 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13847 vat_json_init_array (&vam->json_tree);
13849 node = vat_json_array_add (&vam->json_tree);
13851 vat_json_init_object (node);
13852 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
13853 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
13854 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13855 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
13856 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
13857 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
13861 api_l2_fib_table_dump (vat_main_t * vam)
13863 unformat_input_t *i = vam->input;
13864 vl_api_l2_fib_table_dump_t *mp;
13865 vl_api_control_ping_t *mp_ping;
13870 /* Parse args required to build the message */
13871 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13873 if (unformat (i, "bd_id %d", &bd_id))
13879 if (bd_id_set == 0)
13881 errmsg ("missing bridge domain");
13885 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
13887 /* Get list of l2 fib entries */
13888 M (L2_FIB_TABLE_DUMP, mp);
13890 mp->bd_id = ntohl (bd_id);
13893 /* Use a control ping for synchronization */
13894 MPING (CONTROL_PING, mp_ping);
13903 api_interface_name_renumber (vat_main_t * vam)
13905 unformat_input_t *line_input = vam->input;
13906 vl_api_interface_name_renumber_t *mp;
13907 u32 sw_if_index = ~0;
13908 u32 new_show_dev_instance = ~0;
13911 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13913 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
13916 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13918 else if (unformat (line_input, "new_show_dev_instance %d",
13919 &new_show_dev_instance))
13925 if (sw_if_index == ~0)
13927 errmsg ("missing interface name or sw_if_index");
13931 if (new_show_dev_instance == ~0)
13933 errmsg ("missing new_show_dev_instance");
13937 M (INTERFACE_NAME_RENUMBER, mp);
13939 mp->sw_if_index = ntohl (sw_if_index);
13940 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
13948 api_want_ip4_arp_events (vat_main_t * vam)
13950 unformat_input_t *line_input = vam->input;
13951 vl_api_want_ip4_arp_events_t *mp;
13952 ip4_address_t address;
13953 int address_set = 0;
13954 u32 enable_disable = 1;
13957 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13959 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
13961 else if (unformat (line_input, "del"))
13962 enable_disable = 0;
13967 if (address_set == 0)
13969 errmsg ("missing addresses");
13973 M (WANT_IP4_ARP_EVENTS, mp);
13974 mp->enable_disable = enable_disable;
13975 mp->pid = htonl (getpid ());
13976 mp->address = address.as_u32;
13984 api_want_ip6_nd_events (vat_main_t * vam)
13986 unformat_input_t *line_input = vam->input;
13987 vl_api_want_ip6_nd_events_t *mp;
13988 ip6_address_t address;
13989 int address_set = 0;
13990 u32 enable_disable = 1;
13993 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13995 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
13997 else if (unformat (line_input, "del"))
13998 enable_disable = 0;
14003 if (address_set == 0)
14005 errmsg ("missing addresses");
14009 M (WANT_IP6_ND_EVENTS, mp);
14010 mp->enable_disable = enable_disable;
14011 mp->pid = htonl (getpid ());
14012 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
14020 api_want_l2_macs_events (vat_main_t * vam)
14022 unformat_input_t *line_input = vam->input;
14023 vl_api_want_l2_macs_events_t *mp;
14024 u8 enable_disable = 1;
14025 u32 scan_delay = 0;
14026 u32 max_macs_in_event = 0;
14027 u32 learn_limit = 0;
14030 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14032 if (unformat (line_input, "learn-limit %d", &learn_limit))
14034 else if (unformat (line_input, "scan-delay %d", &scan_delay))
14036 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
14038 else if (unformat (line_input, "disable"))
14039 enable_disable = 0;
14044 M (WANT_L2_MACS_EVENTS, mp);
14045 mp->enable_disable = enable_disable;
14046 mp->pid = htonl (getpid ());
14047 mp->learn_limit = htonl (learn_limit);
14048 mp->scan_delay = (u8) scan_delay;
14049 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
14056 api_input_acl_set_interface (vat_main_t * vam)
14058 unformat_input_t *i = vam->input;
14059 vl_api_input_acl_set_interface_t *mp;
14061 int sw_if_index_set;
14062 u32 ip4_table_index = ~0;
14063 u32 ip6_table_index = ~0;
14064 u32 l2_table_index = ~0;
14068 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14070 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14071 sw_if_index_set = 1;
14072 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14073 sw_if_index_set = 1;
14074 else if (unformat (i, "del"))
14076 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14078 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14080 else if (unformat (i, "l2-table %d", &l2_table_index))
14084 clib_warning ("parse error '%U'", format_unformat_error, i);
14089 if (sw_if_index_set == 0)
14091 errmsg ("missing interface name or sw_if_index");
14095 M (INPUT_ACL_SET_INTERFACE, mp);
14097 mp->sw_if_index = ntohl (sw_if_index);
14098 mp->ip4_table_index = ntohl (ip4_table_index);
14099 mp->ip6_table_index = ntohl (ip6_table_index);
14100 mp->l2_table_index = ntohl (l2_table_index);
14101 mp->is_add = is_add;
14109 api_ip_address_dump (vat_main_t * vam)
14111 unformat_input_t *i = vam->input;
14112 vl_api_ip_address_dump_t *mp;
14113 vl_api_control_ping_t *mp_ping;
14114 u32 sw_if_index = ~0;
14115 u8 sw_if_index_set = 0;
14120 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14122 if (unformat (i, "sw_if_index %d", &sw_if_index))
14123 sw_if_index_set = 1;
14125 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14126 sw_if_index_set = 1;
14127 else if (unformat (i, "ipv4"))
14129 else if (unformat (i, "ipv6"))
14135 if (ipv4_set && ipv6_set)
14137 errmsg ("ipv4 and ipv6 flags cannot be both set");
14141 if ((!ipv4_set) && (!ipv6_set))
14143 errmsg ("no ipv4 nor ipv6 flag set");
14147 if (sw_if_index_set == 0)
14149 errmsg ("missing interface name or sw_if_index");
14153 vam->current_sw_if_index = sw_if_index;
14154 vam->is_ipv6 = ipv6_set;
14156 M (IP_ADDRESS_DUMP, mp);
14157 mp->sw_if_index = ntohl (sw_if_index);
14158 mp->is_ipv6 = ipv6_set;
14161 /* Use a control ping for synchronization */
14162 MPING (CONTROL_PING, mp_ping);
14170 api_ip_dump (vat_main_t * vam)
14172 vl_api_ip_dump_t *mp;
14173 vl_api_control_ping_t *mp_ping;
14174 unformat_input_t *in = vam->input;
14181 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
14183 if (unformat (in, "ipv4"))
14185 else if (unformat (in, "ipv6"))
14191 if (ipv4_set && ipv6_set)
14193 errmsg ("ipv4 and ipv6 flags cannot be both set");
14197 if ((!ipv4_set) && (!ipv6_set))
14199 errmsg ("no ipv4 nor ipv6 flag set");
14203 is_ipv6 = ipv6_set;
14204 vam->is_ipv6 = is_ipv6;
14206 /* free old data */
14207 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
14209 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
14211 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
14214 mp->is_ipv6 = ipv6_set;
14217 /* Use a control ping for synchronization */
14218 MPING (CONTROL_PING, mp_ping);
14226 api_ipsec_spd_add_del (vat_main_t * vam)
14228 unformat_input_t *i = vam->input;
14229 vl_api_ipsec_spd_add_del_t *mp;
14234 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14236 if (unformat (i, "spd_id %d", &spd_id))
14238 else if (unformat (i, "del"))
14242 clib_warning ("parse error '%U'", format_unformat_error, i);
14248 errmsg ("spd_id must be set");
14252 M (IPSEC_SPD_ADD_DEL, mp);
14254 mp->spd_id = ntohl (spd_id);
14255 mp->is_add = is_add;
14263 api_ipsec_interface_add_del_spd (vat_main_t * vam)
14265 unformat_input_t *i = vam->input;
14266 vl_api_ipsec_interface_add_del_spd_t *mp;
14268 u8 sw_if_index_set = 0;
14269 u32 spd_id = (u32) ~ 0;
14273 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14275 if (unformat (i, "del"))
14277 else if (unformat (i, "spd_id %d", &spd_id))
14280 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14281 sw_if_index_set = 1;
14282 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14283 sw_if_index_set = 1;
14286 clib_warning ("parse error '%U'", format_unformat_error, i);
14292 if (spd_id == (u32) ~ 0)
14294 errmsg ("spd_id must be set");
14298 if (sw_if_index_set == 0)
14300 errmsg ("missing interface name or sw_if_index");
14304 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
14306 mp->spd_id = ntohl (spd_id);
14307 mp->sw_if_index = ntohl (sw_if_index);
14308 mp->is_add = is_add;
14316 api_ipsec_spd_add_del_entry (vat_main_t * vam)
14318 unformat_input_t *i = vam->input;
14319 vl_api_ipsec_spd_add_del_entry_t *mp;
14320 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
14321 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
14323 u32 rport_start = 0, rport_stop = (u32) ~ 0;
14324 u32 lport_start = 0, lport_stop = (u32) ~ 0;
14325 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
14326 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
14329 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
14330 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
14331 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
14332 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
14333 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
14334 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
14336 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14338 if (unformat (i, "del"))
14340 if (unformat (i, "outbound"))
14342 if (unformat (i, "inbound"))
14344 else if (unformat (i, "spd_id %d", &spd_id))
14346 else if (unformat (i, "sa_id %d", &sa_id))
14348 else if (unformat (i, "priority %d", &priority))
14350 else if (unformat (i, "protocol %d", &protocol))
14352 else if (unformat (i, "lport_start %d", &lport_start))
14354 else if (unformat (i, "lport_stop %d", &lport_stop))
14356 else if (unformat (i, "rport_start %d", &rport_start))
14358 else if (unformat (i, "rport_stop %d", &rport_stop))
14362 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
14368 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
14375 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
14381 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
14388 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
14394 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
14401 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
14407 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
14413 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
14415 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
14417 clib_warning ("unsupported action: 'resolve'");
14423 clib_warning ("parse error '%U'", format_unformat_error, i);
14429 M (IPSEC_SPD_ADD_DEL_ENTRY, mp);
14431 mp->spd_id = ntohl (spd_id);
14432 mp->priority = ntohl (priority);
14433 mp->is_outbound = is_outbound;
14435 mp->is_ipv6 = is_ipv6;
14436 if (is_ipv6 || is_ip_any)
14438 clib_memcpy (mp->remote_address_start, &raddr6_start,
14439 sizeof (ip6_address_t));
14440 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
14441 sizeof (ip6_address_t));
14442 clib_memcpy (mp->local_address_start, &laddr6_start,
14443 sizeof (ip6_address_t));
14444 clib_memcpy (mp->local_address_stop, &laddr6_stop,
14445 sizeof (ip6_address_t));
14449 clib_memcpy (mp->remote_address_start, &raddr4_start,
14450 sizeof (ip4_address_t));
14451 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
14452 sizeof (ip4_address_t));
14453 clib_memcpy (mp->local_address_start, &laddr4_start,
14454 sizeof (ip4_address_t));
14455 clib_memcpy (mp->local_address_stop, &laddr4_stop,
14456 sizeof (ip4_address_t));
14458 mp->protocol = (u8) protocol;
14459 mp->local_port_start = ntohs ((u16) lport_start);
14460 mp->local_port_stop = ntohs ((u16) lport_stop);
14461 mp->remote_port_start = ntohs ((u16) rport_start);
14462 mp->remote_port_stop = ntohs ((u16) rport_stop);
14463 mp->policy = (u8) policy;
14464 mp->sa_id = ntohl (sa_id);
14465 mp->is_add = is_add;
14466 mp->is_ip_any = is_ip_any;
14473 api_ipsec_sad_add_del_entry (vat_main_t * vam)
14475 unformat_input_t *i = vam->input;
14476 vl_api_ipsec_sad_add_del_entry_t *mp;
14477 u32 sad_id = 0, spi = 0;
14478 u8 *ck = 0, *ik = 0;
14481 u8 protocol = IPSEC_PROTOCOL_AH;
14482 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
14483 u32 crypto_alg = 0, integ_alg = 0;
14484 ip4_address_t tun_src4;
14485 ip4_address_t tun_dst4;
14486 ip6_address_t tun_src6;
14487 ip6_address_t tun_dst6;
14490 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14492 if (unformat (i, "del"))
14494 else if (unformat (i, "sad_id %d", &sad_id))
14496 else if (unformat (i, "spi %d", &spi))
14498 else if (unformat (i, "esp"))
14499 protocol = IPSEC_PROTOCOL_ESP;
14500 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
14503 is_tunnel_ipv6 = 0;
14505 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
14508 is_tunnel_ipv6 = 0;
14510 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
14513 is_tunnel_ipv6 = 1;
14515 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
14518 is_tunnel_ipv6 = 1;
14522 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
14524 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
14525 crypto_alg >= IPSEC_CRYPTO_N_ALG)
14527 clib_warning ("unsupported crypto-alg: '%U'",
14528 format_ipsec_crypto_alg, crypto_alg);
14532 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14536 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
14538 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
14539 integ_alg >= IPSEC_INTEG_N_ALG)
14541 clib_warning ("unsupported integ-alg: '%U'",
14542 format_ipsec_integ_alg, integ_alg);
14546 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14550 clib_warning ("parse error '%U'", format_unformat_error, i);
14556 M (IPSEC_SAD_ADD_DEL_ENTRY, mp);
14558 mp->sad_id = ntohl (sad_id);
14559 mp->is_add = is_add;
14560 mp->protocol = protocol;
14561 mp->spi = ntohl (spi);
14562 mp->is_tunnel = is_tunnel;
14563 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
14564 mp->crypto_algorithm = crypto_alg;
14565 mp->integrity_algorithm = integ_alg;
14566 mp->crypto_key_length = vec_len (ck);
14567 mp->integrity_key_length = vec_len (ik);
14569 if (mp->crypto_key_length > sizeof (mp->crypto_key))
14570 mp->crypto_key_length = sizeof (mp->crypto_key);
14572 if (mp->integrity_key_length > sizeof (mp->integrity_key))
14573 mp->integrity_key_length = sizeof (mp->integrity_key);
14576 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
14578 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
14582 if (is_tunnel_ipv6)
14584 clib_memcpy (mp->tunnel_src_address, &tun_src6,
14585 sizeof (ip6_address_t));
14586 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
14587 sizeof (ip6_address_t));
14591 clib_memcpy (mp->tunnel_src_address, &tun_src4,
14592 sizeof (ip4_address_t));
14593 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
14594 sizeof (ip4_address_t));
14604 api_ipsec_sa_set_key (vat_main_t * vam)
14606 unformat_input_t *i = vam->input;
14607 vl_api_ipsec_sa_set_key_t *mp;
14609 u8 *ck = 0, *ik = 0;
14612 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14614 if (unformat (i, "sa_id %d", &sa_id))
14616 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14618 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14622 clib_warning ("parse error '%U'", format_unformat_error, i);
14627 M (IPSEC_SA_SET_KEY, mp);
14629 mp->sa_id = ntohl (sa_id);
14630 mp->crypto_key_length = vec_len (ck);
14631 mp->integrity_key_length = vec_len (ik);
14633 if (mp->crypto_key_length > sizeof (mp->crypto_key))
14634 mp->crypto_key_length = sizeof (mp->crypto_key);
14636 if (mp->integrity_key_length > sizeof (mp->integrity_key))
14637 mp->integrity_key_length = sizeof (mp->integrity_key);
14640 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
14642 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
14650 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
14652 unformat_input_t *i = vam->input;
14653 vl_api_ipsec_tunnel_if_add_del_t *mp;
14654 u32 local_spi = 0, remote_spi = 0;
14655 u32 crypto_alg = 0, integ_alg = 0;
14656 u8 *lck = NULL, *rck = NULL;
14657 u8 *lik = NULL, *rik = NULL;
14658 ip4_address_t local_ip = { {0} };
14659 ip4_address_t remote_ip = { {0} };
14662 u8 anti_replay = 0;
14665 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14667 if (unformat (i, "del"))
14669 else if (unformat (i, "esn"))
14671 else if (unformat (i, "anti_replay"))
14673 else if (unformat (i, "local_spi %d", &local_spi))
14675 else if (unformat (i, "remote_spi %d", &remote_spi))
14677 else if (unformat (i, "local_ip %U", unformat_ip4_address, &local_ip))
14679 else if (unformat (i, "remote_ip %U", unformat_ip4_address, &remote_ip))
14681 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
14684 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
14686 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
14688 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
14692 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
14694 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
14695 crypto_alg >= IPSEC_CRYPTO_N_ALG)
14697 errmsg ("unsupported crypto-alg: '%U'\n",
14698 format_ipsec_crypto_alg, crypto_alg);
14704 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
14706 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
14707 integ_alg >= IPSEC_INTEG_N_ALG)
14709 errmsg ("unsupported integ-alg: '%U'\n",
14710 format_ipsec_integ_alg, integ_alg);
14716 errmsg ("parse error '%U'\n", format_unformat_error, i);
14721 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
14723 mp->is_add = is_add;
14725 mp->anti_replay = anti_replay;
14727 clib_memcpy (mp->local_ip, &local_ip, sizeof (ip4_address_t));
14728 clib_memcpy (mp->remote_ip, &remote_ip, sizeof (ip4_address_t));
14730 mp->local_spi = htonl (local_spi);
14731 mp->remote_spi = htonl (remote_spi);
14732 mp->crypto_alg = (u8) crypto_alg;
14734 mp->local_crypto_key_len = 0;
14737 mp->local_crypto_key_len = vec_len (lck);
14738 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
14739 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
14740 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
14743 mp->remote_crypto_key_len = 0;
14746 mp->remote_crypto_key_len = vec_len (rck);
14747 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
14748 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
14749 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
14752 mp->integ_alg = (u8) integ_alg;
14754 mp->local_integ_key_len = 0;
14757 mp->local_integ_key_len = vec_len (lik);
14758 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
14759 mp->local_integ_key_len = sizeof (mp->local_integ_key);
14760 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
14763 mp->remote_integ_key_len = 0;
14766 mp->remote_integ_key_len = vec_len (rik);
14767 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
14768 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
14769 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
14778 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
14780 vat_main_t *vam = &vat_main;
14782 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
14783 "crypto_key %U integ_alg %u integ_key %U use_esn %u "
14784 "use_anti_replay %u is_tunnel %u is_tunnel_ip6 %u "
14785 "tunnel_src_addr %U tunnel_dst_addr %U "
14786 "salt %u seq_outbound %lu last_seq_inbound %lu "
14787 "replay_window %lu total_data_size %lu\n",
14788 ntohl (mp->sa_id), ntohl (mp->sw_if_index), ntohl (mp->spi),
14790 mp->crypto_alg, format_hex_bytes, mp->crypto_key, mp->crypto_key_len,
14791 mp->integ_alg, format_hex_bytes, mp->integ_key, mp->integ_key_len,
14792 mp->use_esn, mp->use_anti_replay, mp->is_tunnel, mp->is_tunnel_ip6,
14793 (mp->is_tunnel_ip6) ? format_ip6_address : format_ip4_address,
14794 mp->tunnel_src_addr,
14795 (mp->is_tunnel_ip6) ? format_ip6_address : format_ip4_address,
14796 mp->tunnel_dst_addr,
14798 clib_net_to_host_u64 (mp->seq_outbound),
14799 clib_net_to_host_u64 (mp->last_seq_inbound),
14800 clib_net_to_host_u64 (mp->replay_window),
14801 clib_net_to_host_u64 (mp->total_data_size));
14804 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
14805 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
14807 static void vl_api_ipsec_sa_details_t_handler_json
14808 (vl_api_ipsec_sa_details_t * mp)
14810 vat_main_t *vam = &vat_main;
14811 vat_json_node_t *node = NULL;
14812 struct in_addr src_ip4, dst_ip4;
14813 struct in6_addr src_ip6, dst_ip6;
14815 if (VAT_JSON_ARRAY != vam->json_tree.type)
14817 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14818 vat_json_init_array (&vam->json_tree);
14820 node = vat_json_array_add (&vam->json_tree);
14822 vat_json_init_object (node);
14823 vat_json_object_add_uint (node, "sa_id", ntohl (mp->sa_id));
14824 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14825 vat_json_object_add_uint (node, "spi", ntohl (mp->spi));
14826 vat_json_object_add_uint (node, "proto", mp->protocol);
14827 vat_json_object_add_uint (node, "crypto_alg", mp->crypto_alg);
14828 vat_json_object_add_uint (node, "integ_alg", mp->integ_alg);
14829 vat_json_object_add_uint (node, "use_esn", mp->use_esn);
14830 vat_json_object_add_uint (node, "use_anti_replay", mp->use_anti_replay);
14831 vat_json_object_add_uint (node, "is_tunnel", mp->is_tunnel);
14832 vat_json_object_add_uint (node, "is_tunnel_ip6", mp->is_tunnel_ip6);
14833 vat_json_object_add_bytes (node, "crypto_key", mp->crypto_key,
14834 mp->crypto_key_len);
14835 vat_json_object_add_bytes (node, "integ_key", mp->integ_key,
14836 mp->integ_key_len);
14837 if (mp->is_tunnel_ip6)
14839 clib_memcpy (&src_ip6, mp->tunnel_src_addr, sizeof (src_ip6));
14840 vat_json_object_add_ip6 (node, "tunnel_src_addr", src_ip6);
14841 clib_memcpy (&dst_ip6, mp->tunnel_dst_addr, sizeof (dst_ip6));
14842 vat_json_object_add_ip6 (node, "tunnel_dst_addr", dst_ip6);
14846 clib_memcpy (&src_ip4, mp->tunnel_src_addr, sizeof (src_ip4));
14847 vat_json_object_add_ip4 (node, "tunnel_src_addr", src_ip4);
14848 clib_memcpy (&dst_ip4, mp->tunnel_dst_addr, sizeof (dst_ip4));
14849 vat_json_object_add_ip4 (node, "tunnel_dst_addr", dst_ip4);
14851 vat_json_object_add_uint (node, "replay_window",
14852 clib_net_to_host_u64 (mp->replay_window));
14853 vat_json_object_add_uint (node, "total_data_size",
14854 clib_net_to_host_u64 (mp->total_data_size));
14859 api_ipsec_sa_dump (vat_main_t * vam)
14861 unformat_input_t *i = vam->input;
14862 vl_api_ipsec_sa_dump_t *mp;
14863 vl_api_control_ping_t *mp_ping;
14867 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14869 if (unformat (i, "sa_id %d", &sa_id))
14873 clib_warning ("parse error '%U'", format_unformat_error, i);
14878 M (IPSEC_SA_DUMP, mp);
14880 mp->sa_id = ntohl (sa_id);
14884 /* Use a control ping for synchronization */
14885 M (CONTROL_PING, mp_ping);
14893 api_ipsec_tunnel_if_set_key (vat_main_t * vam)
14895 unformat_input_t *i = vam->input;
14896 vl_api_ipsec_tunnel_if_set_key_t *mp;
14897 u32 sw_if_index = ~0;
14898 u8 key_type = IPSEC_IF_SET_KEY_TYPE_NONE;
14903 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14905 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14908 if (unformat (i, "local crypto %U", unformat_ipsec_crypto_alg, &alg))
14909 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_CRYPTO;
14911 if (unformat (i, "remote crypto %U", unformat_ipsec_crypto_alg, &alg))
14912 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_CRYPTO;
14913 else if (unformat (i, "local integ %U", unformat_ipsec_integ_alg, &alg))
14914 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_INTEG;
14916 if (unformat (i, "remote integ %U", unformat_ipsec_integ_alg, &alg))
14917 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_INTEG;
14918 else if (unformat (i, "%U", unformat_hex_string, &key))
14922 clib_warning ("parse error '%U'", format_unformat_error, i);
14927 if (sw_if_index == ~0)
14929 errmsg ("interface must be specified");
14933 if (key_type == IPSEC_IF_SET_KEY_TYPE_NONE)
14935 errmsg ("key type must be specified");
14941 errmsg ("algorithm must be specified");
14945 if (vec_len (key) == 0)
14947 errmsg ("key must be specified");
14951 M (IPSEC_TUNNEL_IF_SET_KEY, mp);
14953 mp->sw_if_index = htonl (sw_if_index);
14955 mp->key_type = key_type;
14956 mp->key_len = vec_len (key);
14957 clib_memcpy (mp->key, key, vec_len (key));
14966 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
14968 unformat_input_t *i = vam->input;
14969 vl_api_ipsec_tunnel_if_set_sa_t *mp;
14970 u32 sw_if_index = ~0;
14972 u8 is_outbound = (u8) ~ 0;
14975 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14977 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14979 else if (unformat (i, "sa_id %d", &sa_id))
14981 else if (unformat (i, "outbound"))
14983 else if (unformat (i, "inbound"))
14987 clib_warning ("parse error '%U'", format_unformat_error, i);
14992 if (sw_if_index == ~0)
14994 errmsg ("interface must be specified");
15000 errmsg ("SA ID must be specified");
15004 M (IPSEC_TUNNEL_IF_SET_SA, mp);
15006 mp->sw_if_index = htonl (sw_if_index);
15007 mp->sa_id = htonl (sa_id);
15008 mp->is_outbound = is_outbound;
15017 api_ikev2_profile_add_del (vat_main_t * vam)
15019 unformat_input_t *i = vam->input;
15020 vl_api_ikev2_profile_add_del_t *mp;
15025 const char *valid_chars = "a-zA-Z0-9_";
15027 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15029 if (unformat (i, "del"))
15031 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15032 vec_add1 (name, 0);
15035 errmsg ("parse error '%U'", format_unformat_error, i);
15040 if (!vec_len (name))
15042 errmsg ("profile name must be specified");
15046 if (vec_len (name) > 64)
15048 errmsg ("profile name too long");
15052 M (IKEV2_PROFILE_ADD_DEL, mp);
15054 clib_memcpy (mp->name, name, vec_len (name));
15055 mp->is_add = is_add;
15064 api_ikev2_profile_set_auth (vat_main_t * vam)
15066 unformat_input_t *i = vam->input;
15067 vl_api_ikev2_profile_set_auth_t *mp;
15070 u32 auth_method = 0;
15074 const char *valid_chars = "a-zA-Z0-9_";
15076 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15078 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15079 vec_add1 (name, 0);
15080 else if (unformat (i, "auth_method %U",
15081 unformat_ikev2_auth_method, &auth_method))
15083 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
15085 else if (unformat (i, "auth_data %v", &data))
15089 errmsg ("parse error '%U'", format_unformat_error, i);
15094 if (!vec_len (name))
15096 errmsg ("profile name must be specified");
15100 if (vec_len (name) > 64)
15102 errmsg ("profile name too long");
15106 if (!vec_len (data))
15108 errmsg ("auth_data must be specified");
15114 errmsg ("auth_method must be specified");
15118 M (IKEV2_PROFILE_SET_AUTH, mp);
15120 mp->is_hex = is_hex;
15121 mp->auth_method = (u8) auth_method;
15122 mp->data_len = vec_len (data);
15123 clib_memcpy (mp->name, name, vec_len (name));
15124 clib_memcpy (mp->data, data, vec_len (data));
15134 api_ikev2_profile_set_id (vat_main_t * vam)
15136 unformat_input_t *i = vam->input;
15137 vl_api_ikev2_profile_set_id_t *mp;
15145 const char *valid_chars = "a-zA-Z0-9_";
15147 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15149 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15150 vec_add1 (name, 0);
15151 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
15153 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
15155 data = vec_new (u8, 4);
15156 clib_memcpy (data, ip4.as_u8, 4);
15158 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
15160 else if (unformat (i, "id_data %v", &data))
15162 else if (unformat (i, "local"))
15164 else if (unformat (i, "remote"))
15168 errmsg ("parse error '%U'", format_unformat_error, i);
15173 if (!vec_len (name))
15175 errmsg ("profile name must be specified");
15179 if (vec_len (name) > 64)
15181 errmsg ("profile name too long");
15185 if (!vec_len (data))
15187 errmsg ("id_data must be specified");
15193 errmsg ("id_type must be specified");
15197 M (IKEV2_PROFILE_SET_ID, mp);
15199 mp->is_local = is_local;
15200 mp->id_type = (u8) id_type;
15201 mp->data_len = vec_len (data);
15202 clib_memcpy (mp->name, name, vec_len (name));
15203 clib_memcpy (mp->data, data, vec_len (data));
15213 api_ikev2_profile_set_ts (vat_main_t * vam)
15215 unformat_input_t *i = vam->input;
15216 vl_api_ikev2_profile_set_ts_t *mp;
15219 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
15220 ip4_address_t start_addr, end_addr;
15222 const char *valid_chars = "a-zA-Z0-9_";
15225 start_addr.as_u32 = 0;
15226 end_addr.as_u32 = (u32) ~ 0;
15228 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15230 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15231 vec_add1 (name, 0);
15232 else if (unformat (i, "protocol %d", &proto))
15234 else if (unformat (i, "start_port %d", &start_port))
15236 else if (unformat (i, "end_port %d", &end_port))
15239 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
15241 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
15243 else if (unformat (i, "local"))
15245 else if (unformat (i, "remote"))
15249 errmsg ("parse error '%U'", format_unformat_error, i);
15254 if (!vec_len (name))
15256 errmsg ("profile name must be specified");
15260 if (vec_len (name) > 64)
15262 errmsg ("profile name too long");
15266 M (IKEV2_PROFILE_SET_TS, mp);
15268 mp->is_local = is_local;
15269 mp->proto = (u8) proto;
15270 mp->start_port = (u16) start_port;
15271 mp->end_port = (u16) end_port;
15272 mp->start_addr = start_addr.as_u32;
15273 mp->end_addr = end_addr.as_u32;
15274 clib_memcpy (mp->name, name, vec_len (name));
15283 api_ikev2_set_local_key (vat_main_t * vam)
15285 unformat_input_t *i = vam->input;
15286 vl_api_ikev2_set_local_key_t *mp;
15290 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15292 if (unformat (i, "file %v", &file))
15293 vec_add1 (file, 0);
15296 errmsg ("parse error '%U'", format_unformat_error, i);
15301 if (!vec_len (file))
15303 errmsg ("RSA key file must be specified");
15307 if (vec_len (file) > 256)
15309 errmsg ("file name too long");
15313 M (IKEV2_SET_LOCAL_KEY, mp);
15315 clib_memcpy (mp->key_file, file, vec_len (file));
15324 api_ikev2_set_responder (vat_main_t * vam)
15326 unformat_input_t *i = vam->input;
15327 vl_api_ikev2_set_responder_t *mp;
15330 u32 sw_if_index = ~0;
15331 ip4_address_t address;
15333 const char *valid_chars = "a-zA-Z0-9_";
15335 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15338 (i, "%U interface %d address %U", unformat_token, valid_chars,
15339 &name, &sw_if_index, unformat_ip4_address, &address))
15340 vec_add1 (name, 0);
15343 errmsg ("parse error '%U'", format_unformat_error, i);
15348 if (!vec_len (name))
15350 errmsg ("profile name must be specified");
15354 if (vec_len (name) > 64)
15356 errmsg ("profile name too long");
15360 M (IKEV2_SET_RESPONDER, mp);
15362 clib_memcpy (mp->name, name, vec_len (name));
15365 mp->sw_if_index = sw_if_index;
15366 clib_memcpy (mp->address, &address, sizeof (address));
15374 api_ikev2_set_ike_transforms (vat_main_t * vam)
15376 unformat_input_t *i = vam->input;
15377 vl_api_ikev2_set_ike_transforms_t *mp;
15380 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
15382 const char *valid_chars = "a-zA-Z0-9_";
15384 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15386 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
15387 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
15388 vec_add1 (name, 0);
15391 errmsg ("parse error '%U'", format_unformat_error, i);
15396 if (!vec_len (name))
15398 errmsg ("profile name must be specified");
15402 if (vec_len (name) > 64)
15404 errmsg ("profile name too long");
15408 M (IKEV2_SET_IKE_TRANSFORMS, mp);
15410 clib_memcpy (mp->name, name, vec_len (name));
15412 mp->crypto_alg = crypto_alg;
15413 mp->crypto_key_size = crypto_key_size;
15414 mp->integ_alg = integ_alg;
15415 mp->dh_group = dh_group;
15424 api_ikev2_set_esp_transforms (vat_main_t * vam)
15426 unformat_input_t *i = vam->input;
15427 vl_api_ikev2_set_esp_transforms_t *mp;
15430 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
15432 const char *valid_chars = "a-zA-Z0-9_";
15434 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15436 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
15437 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
15438 vec_add1 (name, 0);
15441 errmsg ("parse error '%U'", format_unformat_error, i);
15446 if (!vec_len (name))
15448 errmsg ("profile name must be specified");
15452 if (vec_len (name) > 64)
15454 errmsg ("profile name too long");
15458 M (IKEV2_SET_ESP_TRANSFORMS, mp);
15460 clib_memcpy (mp->name, name, vec_len (name));
15462 mp->crypto_alg = crypto_alg;
15463 mp->crypto_key_size = crypto_key_size;
15464 mp->integ_alg = integ_alg;
15465 mp->dh_group = dh_group;
15473 api_ikev2_set_sa_lifetime (vat_main_t * vam)
15475 unformat_input_t *i = vam->input;
15476 vl_api_ikev2_set_sa_lifetime_t *mp;
15479 u64 lifetime, lifetime_maxdata;
15480 u32 lifetime_jitter, handover;
15482 const char *valid_chars = "a-zA-Z0-9_";
15484 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15486 if (unformat (i, "%U %lu %u %u %lu", unformat_token, valid_chars, &name,
15487 &lifetime, &lifetime_jitter, &handover,
15488 &lifetime_maxdata))
15489 vec_add1 (name, 0);
15492 errmsg ("parse error '%U'", format_unformat_error, i);
15497 if (!vec_len (name))
15499 errmsg ("profile name must be specified");
15503 if (vec_len (name) > 64)
15505 errmsg ("profile name too long");
15509 M (IKEV2_SET_SA_LIFETIME, mp);
15511 clib_memcpy (mp->name, name, vec_len (name));
15513 mp->lifetime = lifetime;
15514 mp->lifetime_jitter = lifetime_jitter;
15515 mp->handover = handover;
15516 mp->lifetime_maxdata = lifetime_maxdata;
15524 api_ikev2_initiate_sa_init (vat_main_t * vam)
15526 unformat_input_t *i = vam->input;
15527 vl_api_ikev2_initiate_sa_init_t *mp;
15531 const char *valid_chars = "a-zA-Z0-9_";
15533 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15535 if (unformat (i, "%U", unformat_token, valid_chars, &name))
15536 vec_add1 (name, 0);
15539 errmsg ("parse error '%U'", format_unformat_error, i);
15544 if (!vec_len (name))
15546 errmsg ("profile name must be specified");
15550 if (vec_len (name) > 64)
15552 errmsg ("profile name too long");
15556 M (IKEV2_INITIATE_SA_INIT, mp);
15558 clib_memcpy (mp->name, name, vec_len (name));
15567 api_ikev2_initiate_del_ike_sa (vat_main_t * vam)
15569 unformat_input_t *i = vam->input;
15570 vl_api_ikev2_initiate_del_ike_sa_t *mp;
15575 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15577 if (unformat (i, "%lx", &ispi))
15581 errmsg ("parse error '%U'", format_unformat_error, i);
15586 M (IKEV2_INITIATE_DEL_IKE_SA, mp);
15596 api_ikev2_initiate_del_child_sa (vat_main_t * vam)
15598 unformat_input_t *i = vam->input;
15599 vl_api_ikev2_initiate_del_child_sa_t *mp;
15604 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15606 if (unformat (i, "%x", &ispi))
15610 errmsg ("parse error '%U'", format_unformat_error, i);
15615 M (IKEV2_INITIATE_DEL_CHILD_SA, mp);
15625 api_ikev2_initiate_rekey_child_sa (vat_main_t * vam)
15627 unformat_input_t *i = vam->input;
15628 vl_api_ikev2_initiate_rekey_child_sa_t *mp;
15633 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15635 if (unformat (i, "%x", &ispi))
15639 errmsg ("parse error '%U'", format_unformat_error, i);
15644 M (IKEV2_INITIATE_REKEY_CHILD_SA, mp);
15657 api_map_add_domain (vat_main_t * vam)
15659 unformat_input_t *i = vam->input;
15660 vl_api_map_add_domain_t *mp;
15662 ip4_address_t ip4_prefix;
15663 ip6_address_t ip6_prefix;
15664 ip6_address_t ip6_src;
15665 u32 num_m_args = 0;
15666 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
15667 0, psid_length = 0;
15668 u8 is_translation = 0;
15670 u32 ip6_src_len = 128;
15673 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15675 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
15676 &ip4_prefix, &ip4_prefix_len))
15678 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
15679 &ip6_prefix, &ip6_prefix_len))
15683 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
15686 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
15688 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
15690 else if (unformat (i, "psid-offset %d", &psid_offset))
15692 else if (unformat (i, "psid-len %d", &psid_length))
15694 else if (unformat (i, "mtu %d", &mtu))
15696 else if (unformat (i, "map-t"))
15697 is_translation = 1;
15700 clib_warning ("parse error '%U'", format_unformat_error, i);
15705 if (num_m_args < 3)
15707 errmsg ("mandatory argument(s) missing");
15711 /* Construct the API message */
15712 M (MAP_ADD_DOMAIN, mp);
15714 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
15715 mp->ip4_prefix_len = ip4_prefix_len;
15717 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
15718 mp->ip6_prefix_len = ip6_prefix_len;
15720 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
15721 mp->ip6_src_prefix_len = ip6_src_len;
15723 mp->ea_bits_len = ea_bits_len;
15724 mp->psid_offset = psid_offset;
15725 mp->psid_length = psid_length;
15726 mp->is_translation = is_translation;
15727 mp->mtu = htons (mtu);
15732 /* Wait for a reply, return good/bad news */
15738 api_map_del_domain (vat_main_t * vam)
15740 unformat_input_t *i = vam->input;
15741 vl_api_map_del_domain_t *mp;
15743 u32 num_m_args = 0;
15747 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15749 if (unformat (i, "index %d", &index))
15753 clib_warning ("parse error '%U'", format_unformat_error, i);
15758 if (num_m_args != 1)
15760 errmsg ("mandatory argument(s) missing");
15764 /* Construct the API message */
15765 M (MAP_DEL_DOMAIN, mp);
15767 mp->index = ntohl (index);
15772 /* Wait for a reply, return good/bad news */
15778 api_map_add_del_rule (vat_main_t * vam)
15780 unformat_input_t *i = vam->input;
15781 vl_api_map_add_del_rule_t *mp;
15783 ip6_address_t ip6_dst;
15784 u32 num_m_args = 0, index, psid = 0;
15787 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15789 if (unformat (i, "index %d", &index))
15791 else if (unformat (i, "psid %d", &psid))
15793 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
15795 else if (unformat (i, "del"))
15801 clib_warning ("parse error '%U'", format_unformat_error, i);
15806 /* Construct the API message */
15807 M (MAP_ADD_DEL_RULE, mp);
15809 mp->index = ntohl (index);
15810 mp->is_add = is_add;
15811 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
15812 mp->psid = ntohs (psid);
15817 /* Wait for a reply, return good/bad news */
15823 api_map_domain_dump (vat_main_t * vam)
15825 vl_api_map_domain_dump_t *mp;
15826 vl_api_control_ping_t *mp_ping;
15829 /* Construct the API message */
15830 M (MAP_DOMAIN_DUMP, mp);
15835 /* Use a control ping for synchronization */
15836 MPING (CONTROL_PING, mp_ping);
15844 api_map_rule_dump (vat_main_t * vam)
15846 unformat_input_t *i = vam->input;
15847 vl_api_map_rule_dump_t *mp;
15848 vl_api_control_ping_t *mp_ping;
15849 u32 domain_index = ~0;
15852 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15854 if (unformat (i, "index %u", &domain_index))
15860 if (domain_index == ~0)
15862 clib_warning ("parse error: domain index expected");
15866 /* Construct the API message */
15867 M (MAP_RULE_DUMP, mp);
15869 mp->domain_index = htonl (domain_index);
15874 /* Use a control ping for synchronization */
15875 MPING (CONTROL_PING, mp_ping);
15882 static void vl_api_map_add_domain_reply_t_handler
15883 (vl_api_map_add_domain_reply_t * mp)
15885 vat_main_t *vam = &vat_main;
15886 i32 retval = ntohl (mp->retval);
15888 if (vam->async_mode)
15890 vam->async_errors += (retval < 0);
15894 vam->retval = retval;
15895 vam->result_ready = 1;
15899 static void vl_api_map_add_domain_reply_t_handler_json
15900 (vl_api_map_add_domain_reply_t * mp)
15902 vat_main_t *vam = &vat_main;
15903 vat_json_node_t node;
15905 vat_json_init_object (&node);
15906 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
15907 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
15909 vat_json_print (vam->ofp, &node);
15910 vat_json_free (&node);
15912 vam->retval = ntohl (mp->retval);
15913 vam->result_ready = 1;
15917 api_get_first_msg_id (vat_main_t * vam)
15919 vl_api_get_first_msg_id_t *mp;
15920 unformat_input_t *i = vam->input;
15925 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15927 if (unformat (i, "client %s", &name))
15935 errmsg ("missing client name");
15938 vec_add1 (name, 0);
15940 if (vec_len (name) > 63)
15942 errmsg ("client name too long");
15946 M (GET_FIRST_MSG_ID, mp);
15947 clib_memcpy (mp->name, name, vec_len (name));
15954 api_cop_interface_enable_disable (vat_main_t * vam)
15956 unformat_input_t *line_input = vam->input;
15957 vl_api_cop_interface_enable_disable_t *mp;
15958 u32 sw_if_index = ~0;
15959 u8 enable_disable = 1;
15962 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15964 if (unformat (line_input, "disable"))
15965 enable_disable = 0;
15966 if (unformat (line_input, "enable"))
15967 enable_disable = 1;
15968 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
15969 vam, &sw_if_index))
15971 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
15977 if (sw_if_index == ~0)
15979 errmsg ("missing interface name or sw_if_index");
15983 /* Construct the API message */
15984 M (COP_INTERFACE_ENABLE_DISABLE, mp);
15985 mp->sw_if_index = ntohl (sw_if_index);
15986 mp->enable_disable = enable_disable;
15990 /* Wait for the reply */
15996 api_cop_whitelist_enable_disable (vat_main_t * vam)
15998 unformat_input_t *line_input = vam->input;
15999 vl_api_cop_whitelist_enable_disable_t *mp;
16000 u32 sw_if_index = ~0;
16001 u8 ip4 = 0, ip6 = 0, default_cop = 0;
16005 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
16007 if (unformat (line_input, "ip4"))
16009 else if (unformat (line_input, "ip6"))
16011 else if (unformat (line_input, "default"))
16013 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
16014 vam, &sw_if_index))
16016 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
16018 else if (unformat (line_input, "fib-id %d", &fib_id))
16024 if (sw_if_index == ~0)
16026 errmsg ("missing interface name or sw_if_index");
16030 /* Construct the API message */
16031 M (COP_WHITELIST_ENABLE_DISABLE, mp);
16032 mp->sw_if_index = ntohl (sw_if_index);
16033 mp->fib_id = ntohl (fib_id);
16036 mp->default_cop = default_cop;
16040 /* Wait for the reply */
16046 api_get_node_graph (vat_main_t * vam)
16048 vl_api_get_node_graph_t *mp;
16051 M (GET_NODE_GRAPH, mp);
16055 /* Wait for the reply */
16061 /** Used for parsing LISP eids */
16062 typedef CLIB_PACKED(struct{
16063 u8 addr[16]; /**< eid address */
16064 u32 len; /**< prefix length if IP */
16065 u8 type; /**< type of eid */
16070 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
16072 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
16074 memset (a, 0, sizeof (a[0]));
16076 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
16078 a->type = 0; /* ipv4 type */
16080 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
16082 a->type = 1; /* ipv6 type */
16084 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
16086 a->type = 2; /* mac type */
16088 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
16090 a->type = 3; /* NSH type */
16091 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
16092 nsh->spi = clib_host_to_net_u32 (nsh->spi);
16099 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
16108 lisp_eid_size_vat (u8 type)
16125 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
16127 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
16131 api_one_add_del_locator_set (vat_main_t * vam)
16133 unformat_input_t *input = vam->input;
16134 vl_api_one_add_del_locator_set_t *mp;
16136 u8 *locator_set_name = NULL;
16137 u8 locator_set_name_set = 0;
16138 vl_api_local_locator_t locator, *locators = 0;
16139 u32 sw_if_index, priority, weight;
16143 /* Parse args required to build the message */
16144 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16146 if (unformat (input, "del"))
16150 else if (unformat (input, "locator-set %s", &locator_set_name))
16152 locator_set_name_set = 1;
16154 else if (unformat (input, "sw_if_index %u p %u w %u",
16155 &sw_if_index, &priority, &weight))
16157 locator.sw_if_index = htonl (sw_if_index);
16158 locator.priority = priority;
16159 locator.weight = weight;
16160 vec_add1 (locators, locator);
16164 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
16165 &sw_if_index, &priority, &weight))
16167 locator.sw_if_index = htonl (sw_if_index);
16168 locator.priority = priority;
16169 locator.weight = weight;
16170 vec_add1 (locators, locator);
16176 if (locator_set_name_set == 0)
16178 errmsg ("missing locator-set name");
16179 vec_free (locators);
16183 if (vec_len (locator_set_name) > 64)
16185 errmsg ("locator-set name too long");
16186 vec_free (locator_set_name);
16187 vec_free (locators);
16190 vec_add1 (locator_set_name, 0);
16192 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
16194 /* Construct the API message */
16195 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
16197 mp->is_add = is_add;
16198 clib_memcpy (mp->locator_set_name, locator_set_name,
16199 vec_len (locator_set_name));
16200 vec_free (locator_set_name);
16202 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
16204 clib_memcpy (mp->locators, locators, data_len);
16205 vec_free (locators);
16210 /* Wait for a reply... */
16215 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
16218 api_one_add_del_locator (vat_main_t * vam)
16220 unformat_input_t *input = vam->input;
16221 vl_api_one_add_del_locator_t *mp;
16222 u32 tmp_if_index = ~0;
16223 u32 sw_if_index = ~0;
16224 u8 sw_if_index_set = 0;
16225 u8 sw_if_index_if_name_set = 0;
16227 u8 priority_set = 0;
16231 u8 *locator_set_name = NULL;
16232 u8 locator_set_name_set = 0;
16235 /* Parse args required to build the message */
16236 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16238 if (unformat (input, "del"))
16242 else if (unformat (input, "locator-set %s", &locator_set_name))
16244 locator_set_name_set = 1;
16246 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
16249 sw_if_index_if_name_set = 1;
16250 sw_if_index = tmp_if_index;
16252 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
16254 sw_if_index_set = 1;
16255 sw_if_index = tmp_if_index;
16257 else if (unformat (input, "p %d", &priority))
16261 else if (unformat (input, "w %d", &weight))
16269 if (locator_set_name_set == 0)
16271 errmsg ("missing locator-set name");
16275 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
16277 errmsg ("missing sw_if_index");
16278 vec_free (locator_set_name);
16282 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
16284 errmsg ("cannot use both params interface name and sw_if_index");
16285 vec_free (locator_set_name);
16289 if (priority_set == 0)
16291 errmsg ("missing locator-set priority");
16292 vec_free (locator_set_name);
16296 if (weight_set == 0)
16298 errmsg ("missing locator-set weight");
16299 vec_free (locator_set_name);
16303 if (vec_len (locator_set_name) > 64)
16305 errmsg ("locator-set name too long");
16306 vec_free (locator_set_name);
16309 vec_add1 (locator_set_name, 0);
16311 /* Construct the API message */
16312 M (ONE_ADD_DEL_LOCATOR, mp);
16314 mp->is_add = is_add;
16315 mp->sw_if_index = ntohl (sw_if_index);
16316 mp->priority = priority;
16317 mp->weight = weight;
16318 clib_memcpy (mp->locator_set_name, locator_set_name,
16319 vec_len (locator_set_name));
16320 vec_free (locator_set_name);
16325 /* Wait for a reply... */
16330 #define api_lisp_add_del_locator api_one_add_del_locator
16333 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
16335 u32 *key_id = va_arg (*args, u32 *);
16338 if (unformat (input, "%s", &s))
16340 if (!strcmp ((char *) s, "sha1"))
16341 key_id[0] = HMAC_SHA_1_96;
16342 else if (!strcmp ((char *) s, "sha256"))
16343 key_id[0] = HMAC_SHA_256_128;
16346 clib_warning ("invalid key_id: '%s'", s);
16347 key_id[0] = HMAC_NO_KEY;
16358 api_one_add_del_local_eid (vat_main_t * vam)
16360 unformat_input_t *input = vam->input;
16361 vl_api_one_add_del_local_eid_t *mp;
16364 lisp_eid_vat_t _eid, *eid = &_eid;
16365 u8 *locator_set_name = 0;
16366 u8 locator_set_name_set = 0;
16372 /* Parse args required to build the message */
16373 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16375 if (unformat (input, "del"))
16379 else if (unformat (input, "vni %d", &vni))
16383 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
16387 else if (unformat (input, "locator-set %s", &locator_set_name))
16389 locator_set_name_set = 1;
16391 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
16393 else if (unformat (input, "secret-key %_%v%_", &key))
16399 if (locator_set_name_set == 0)
16401 errmsg ("missing locator-set name");
16407 errmsg ("EID address not set!");
16408 vec_free (locator_set_name);
16412 if (key && (0 == key_id))
16414 errmsg ("invalid key_id!");
16418 if (vec_len (key) > 64)
16420 errmsg ("key too long");
16425 if (vec_len (locator_set_name) > 64)
16427 errmsg ("locator-set name too long");
16428 vec_free (locator_set_name);
16431 vec_add1 (locator_set_name, 0);
16433 /* Construct the API message */
16434 M (ONE_ADD_DEL_LOCAL_EID, mp);
16436 mp->is_add = is_add;
16437 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
16438 mp->eid_type = eid->type;
16439 mp->prefix_len = eid->len;
16440 mp->vni = clib_host_to_net_u32 (vni);
16441 mp->key_id = clib_host_to_net_u16 (key_id);
16442 clib_memcpy (mp->locator_set_name, locator_set_name,
16443 vec_len (locator_set_name));
16444 clib_memcpy (mp->key, key, vec_len (key));
16446 vec_free (locator_set_name);
16452 /* Wait for a reply... */
16457 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
16460 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
16462 u32 dp_table = 0, vni = 0;;
16463 unformat_input_t *input = vam->input;
16464 vl_api_gpe_add_del_fwd_entry_t *mp;
16466 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
16467 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
16468 u8 rmt_eid_set = 0, lcl_eid_set = 0;
16469 u32 action = ~0, w;
16470 ip4_address_t rmt_rloc4, lcl_rloc4;
16471 ip6_address_t rmt_rloc6, lcl_rloc6;
16472 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
16475 memset (&rloc, 0, sizeof (rloc));
16477 /* Parse args required to build the message */
16478 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16480 if (unformat (input, "del"))
16482 else if (unformat (input, "add"))
16484 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
16488 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
16492 else if (unformat (input, "vrf %d", &dp_table))
16494 else if (unformat (input, "bd %d", &dp_table))
16496 else if (unformat (input, "vni %d", &vni))
16498 else if (unformat (input, "w %d", &w))
16502 errmsg ("No RLOC configured for setting priority/weight!");
16505 curr_rloc->weight = w;
16507 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
16508 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
16512 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
16514 vec_add1 (lcl_locs, rloc);
16516 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
16517 vec_add1 (rmt_locs, rloc);
16518 /* weight saved in rmt loc */
16519 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
16521 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
16522 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
16525 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
16527 vec_add1 (lcl_locs, rloc);
16529 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
16530 vec_add1 (rmt_locs, rloc);
16531 /* weight saved in rmt loc */
16532 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
16534 else if (unformat (input, "action %d", &action))
16540 clib_warning ("parse error '%U'", format_unformat_error, input);
16547 errmsg ("remote eid addresses not set");
16551 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
16553 errmsg ("eid types don't match");
16557 if (0 == rmt_locs && (u32) ~ 0 == action)
16559 errmsg ("action not set for negative mapping");
16563 /* Construct the API message */
16564 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
16565 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
16567 mp->is_add = is_add;
16568 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
16569 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
16570 mp->eid_type = rmt_eid->type;
16571 mp->dp_table = clib_host_to_net_u32 (dp_table);
16572 mp->vni = clib_host_to_net_u32 (vni);
16573 mp->rmt_len = rmt_eid->len;
16574 mp->lcl_len = lcl_eid->len;
16575 mp->action = action;
16577 if (0 != rmt_locs && 0 != lcl_locs)
16579 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
16580 clib_memcpy (mp->locs, lcl_locs,
16581 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
16583 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
16584 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
16585 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
16587 vec_free (lcl_locs);
16588 vec_free (rmt_locs);
16593 /* Wait for a reply... */
16599 api_one_add_del_map_server (vat_main_t * vam)
16601 unformat_input_t *input = vam->input;
16602 vl_api_one_add_del_map_server_t *mp;
16606 ip4_address_t ipv4;
16607 ip6_address_t ipv6;
16610 /* Parse args required to build the message */
16611 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16613 if (unformat (input, "del"))
16617 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
16621 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
16629 if (ipv4_set && ipv6_set)
16631 errmsg ("both eid v4 and v6 addresses set");
16635 if (!ipv4_set && !ipv6_set)
16637 errmsg ("eid addresses not set");
16641 /* Construct the API message */
16642 M (ONE_ADD_DEL_MAP_SERVER, mp);
16644 mp->is_add = is_add;
16648 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
16653 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
16659 /* Wait for a reply... */
16664 #define api_lisp_add_del_map_server api_one_add_del_map_server
16667 api_one_add_del_map_resolver (vat_main_t * vam)
16669 unformat_input_t *input = vam->input;
16670 vl_api_one_add_del_map_resolver_t *mp;
16674 ip4_address_t ipv4;
16675 ip6_address_t ipv6;
16678 /* Parse args required to build the message */
16679 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16681 if (unformat (input, "del"))
16685 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
16689 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
16697 if (ipv4_set && ipv6_set)
16699 errmsg ("both eid v4 and v6 addresses set");
16703 if (!ipv4_set && !ipv6_set)
16705 errmsg ("eid addresses not set");
16709 /* Construct the API message */
16710 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
16712 mp->is_add = is_add;
16716 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
16721 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
16727 /* Wait for a reply... */
16732 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
16735 api_lisp_gpe_enable_disable (vat_main_t * vam)
16737 unformat_input_t *input = vam->input;
16738 vl_api_gpe_enable_disable_t *mp;
16743 /* Parse args required to build the message */
16744 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16746 if (unformat (input, "enable"))
16751 else if (unformat (input, "disable"))
16762 errmsg ("Value not set");
16766 /* Construct the API message */
16767 M (GPE_ENABLE_DISABLE, mp);
16774 /* Wait for a reply... */
16780 api_one_rloc_probe_enable_disable (vat_main_t * vam)
16782 unformat_input_t *input = vam->input;
16783 vl_api_one_rloc_probe_enable_disable_t *mp;
16788 /* Parse args required to build the message */
16789 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16791 if (unformat (input, "enable"))
16796 else if (unformat (input, "disable"))
16804 errmsg ("Value not set");
16808 /* Construct the API message */
16809 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
16811 mp->is_enabled = is_en;
16816 /* Wait for a reply... */
16821 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
16824 api_one_map_register_enable_disable (vat_main_t * vam)
16826 unformat_input_t *input = vam->input;
16827 vl_api_one_map_register_enable_disable_t *mp;
16832 /* Parse args required to build the message */
16833 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16835 if (unformat (input, "enable"))
16840 else if (unformat (input, "disable"))
16848 errmsg ("Value not set");
16852 /* Construct the API message */
16853 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
16855 mp->is_enabled = is_en;
16860 /* Wait for a reply... */
16865 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
16868 api_one_enable_disable (vat_main_t * vam)
16870 unformat_input_t *input = vam->input;
16871 vl_api_one_enable_disable_t *mp;
16876 /* Parse args required to build the message */
16877 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16879 if (unformat (input, "enable"))
16884 else if (unformat (input, "disable"))
16894 errmsg ("Value not set");
16898 /* Construct the API message */
16899 M (ONE_ENABLE_DISABLE, mp);
16906 /* Wait for a reply... */
16911 #define api_lisp_enable_disable api_one_enable_disable
16914 api_one_enable_disable_xtr_mode (vat_main_t * vam)
16916 unformat_input_t *input = vam->input;
16917 vl_api_one_enable_disable_xtr_mode_t *mp;
16922 /* Parse args required to build the message */
16923 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16925 if (unformat (input, "enable"))
16930 else if (unformat (input, "disable"))
16940 errmsg ("Value not set");
16944 /* Construct the API message */
16945 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
16952 /* Wait for a reply... */
16958 api_one_show_xtr_mode (vat_main_t * vam)
16960 vl_api_one_show_xtr_mode_t *mp;
16963 /* Construct the API message */
16964 M (ONE_SHOW_XTR_MODE, mp);
16969 /* Wait for a reply... */
16975 api_one_enable_disable_pitr_mode (vat_main_t * vam)
16977 unformat_input_t *input = vam->input;
16978 vl_api_one_enable_disable_pitr_mode_t *mp;
16983 /* Parse args required to build the message */
16984 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16986 if (unformat (input, "enable"))
16991 else if (unformat (input, "disable"))
17001 errmsg ("Value not set");
17005 /* Construct the API message */
17006 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
17013 /* Wait for a reply... */
17019 api_one_show_pitr_mode (vat_main_t * vam)
17021 vl_api_one_show_pitr_mode_t *mp;
17024 /* Construct the API message */
17025 M (ONE_SHOW_PITR_MODE, mp);
17030 /* Wait for a reply... */
17036 api_one_enable_disable_petr_mode (vat_main_t * vam)
17038 unformat_input_t *input = vam->input;
17039 vl_api_one_enable_disable_petr_mode_t *mp;
17044 /* Parse args required to build the message */
17045 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17047 if (unformat (input, "enable"))
17052 else if (unformat (input, "disable"))
17062 errmsg ("Value not set");
17066 /* Construct the API message */
17067 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
17074 /* Wait for a reply... */
17080 api_one_show_petr_mode (vat_main_t * vam)
17082 vl_api_one_show_petr_mode_t *mp;
17085 /* Construct the API message */
17086 M (ONE_SHOW_PETR_MODE, mp);
17091 /* Wait for a reply... */
17097 api_show_one_map_register_state (vat_main_t * vam)
17099 vl_api_show_one_map_register_state_t *mp;
17102 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
17107 /* wait for reply */
17112 #define api_show_lisp_map_register_state api_show_one_map_register_state
17115 api_show_one_rloc_probe_state (vat_main_t * vam)
17117 vl_api_show_one_rloc_probe_state_t *mp;
17120 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
17125 /* wait for reply */
17130 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
17133 api_one_add_del_ndp_entry (vat_main_t * vam)
17135 vl_api_one_add_del_ndp_entry_t *mp;
17136 unformat_input_t *input = vam->input;
17141 u8 mac[6] = { 0, };
17142 u8 ip6[16] = { 0, };
17146 /* Parse args required to build the message */
17147 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17149 if (unformat (input, "del"))
17151 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
17153 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
17155 else if (unformat (input, "bd %d", &bd))
17159 errmsg ("parse error '%U'", format_unformat_error, input);
17164 if (!bd_set || !ip_set || (!mac_set && is_add))
17166 errmsg ("Missing BD, IP or MAC!");
17170 M (ONE_ADD_DEL_NDP_ENTRY, mp);
17171 mp->is_add = is_add;
17172 clib_memcpy (mp->mac, mac, 6);
17173 mp->bd = clib_host_to_net_u32 (bd);
17174 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
17179 /* wait for reply */
17185 api_one_add_del_l2_arp_entry (vat_main_t * vam)
17187 vl_api_one_add_del_l2_arp_entry_t *mp;
17188 unformat_input_t *input = vam->input;
17193 u8 mac[6] = { 0, };
17194 u32 ip4 = 0, bd = ~0;
17197 /* Parse args required to build the message */
17198 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17200 if (unformat (input, "del"))
17202 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
17204 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
17206 else if (unformat (input, "bd %d", &bd))
17210 errmsg ("parse error '%U'", format_unformat_error, input);
17215 if (!bd_set || !ip_set || (!mac_set && is_add))
17217 errmsg ("Missing BD, IP or MAC!");
17221 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
17222 mp->is_add = is_add;
17223 clib_memcpy (mp->mac, mac, 6);
17224 mp->bd = clib_host_to_net_u32 (bd);
17230 /* wait for reply */
17236 api_one_ndp_bd_get (vat_main_t * vam)
17238 vl_api_one_ndp_bd_get_t *mp;
17241 M (ONE_NDP_BD_GET, mp);
17246 /* wait for reply */
17252 api_one_ndp_entries_get (vat_main_t * vam)
17254 vl_api_one_ndp_entries_get_t *mp;
17255 unformat_input_t *input = vam->input;
17260 /* Parse args required to build the message */
17261 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17263 if (unformat (input, "bd %d", &bd))
17267 errmsg ("parse error '%U'", format_unformat_error, input);
17274 errmsg ("Expected bridge domain!");
17278 M (ONE_NDP_ENTRIES_GET, mp);
17279 mp->bd = clib_host_to_net_u32 (bd);
17284 /* wait for reply */
17290 api_one_l2_arp_bd_get (vat_main_t * vam)
17292 vl_api_one_l2_arp_bd_get_t *mp;
17295 M (ONE_L2_ARP_BD_GET, mp);
17300 /* wait for reply */
17306 api_one_l2_arp_entries_get (vat_main_t * vam)
17308 vl_api_one_l2_arp_entries_get_t *mp;
17309 unformat_input_t *input = vam->input;
17314 /* Parse args required to build the message */
17315 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17317 if (unformat (input, "bd %d", &bd))
17321 errmsg ("parse error '%U'", format_unformat_error, input);
17328 errmsg ("Expected bridge domain!");
17332 M (ONE_L2_ARP_ENTRIES_GET, mp);
17333 mp->bd = clib_host_to_net_u32 (bd);
17338 /* wait for reply */
17344 api_one_stats_enable_disable (vat_main_t * vam)
17346 vl_api_one_stats_enable_disable_t *mp;
17347 unformat_input_t *input = vam->input;
17352 /* Parse args required to build the message */
17353 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17355 if (unformat (input, "enable"))
17360 else if (unformat (input, "disable"))
17370 errmsg ("Value not set");
17374 M (ONE_STATS_ENABLE_DISABLE, mp);
17380 /* wait for reply */
17386 api_show_one_stats_enable_disable (vat_main_t * vam)
17388 vl_api_show_one_stats_enable_disable_t *mp;
17391 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
17396 /* wait for reply */
17402 api_show_one_map_request_mode (vat_main_t * vam)
17404 vl_api_show_one_map_request_mode_t *mp;
17407 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
17412 /* wait for reply */
17417 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
17420 api_one_map_request_mode (vat_main_t * vam)
17422 unformat_input_t *input = vam->input;
17423 vl_api_one_map_request_mode_t *mp;
17427 /* Parse args required to build the message */
17428 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17430 if (unformat (input, "dst-only"))
17432 else if (unformat (input, "src-dst"))
17436 errmsg ("parse error '%U'", format_unformat_error, input);
17441 M (ONE_MAP_REQUEST_MODE, mp);
17448 /* wait for reply */
17453 #define api_lisp_map_request_mode api_one_map_request_mode
17456 * Enable/disable ONE proxy ITR.
17458 * @param vam vpp API test context
17459 * @return return code
17462 api_one_pitr_set_locator_set (vat_main_t * vam)
17464 u8 ls_name_set = 0;
17465 unformat_input_t *input = vam->input;
17466 vl_api_one_pitr_set_locator_set_t *mp;
17471 /* Parse args required to build the message */
17472 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17474 if (unformat (input, "del"))
17476 else if (unformat (input, "locator-set %s", &ls_name))
17480 errmsg ("parse error '%U'", format_unformat_error, input);
17487 errmsg ("locator-set name not set!");
17491 M (ONE_PITR_SET_LOCATOR_SET, mp);
17493 mp->is_add = is_add;
17494 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
17495 vec_free (ls_name);
17500 /* wait for reply */
17505 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
17508 api_one_nsh_set_locator_set (vat_main_t * vam)
17510 u8 ls_name_set = 0;
17511 unformat_input_t *input = vam->input;
17512 vl_api_one_nsh_set_locator_set_t *mp;
17517 /* Parse args required to build the message */
17518 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17520 if (unformat (input, "del"))
17522 else if (unformat (input, "ls %s", &ls_name))
17526 errmsg ("parse error '%U'", format_unformat_error, input);
17531 if (!ls_name_set && is_add)
17533 errmsg ("locator-set name not set!");
17537 M (ONE_NSH_SET_LOCATOR_SET, mp);
17539 mp->is_add = is_add;
17540 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
17541 vec_free (ls_name);
17546 /* wait for reply */
17552 api_show_one_pitr (vat_main_t * vam)
17554 vl_api_show_one_pitr_t *mp;
17557 if (!vam->json_output)
17559 print (vam->ofp, "%=20s", "lisp status:");
17562 M (SHOW_ONE_PITR, mp);
17566 /* Wait for a reply... */
17571 #define api_show_lisp_pitr api_show_one_pitr
17574 api_one_use_petr (vat_main_t * vam)
17576 unformat_input_t *input = vam->input;
17577 vl_api_one_use_petr_t *mp;
17582 memset (&ip, 0, sizeof (ip));
17584 /* Parse args required to build the message */
17585 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17587 if (unformat (input, "disable"))
17590 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
17593 ip_addr_version (&ip) = IP4;
17596 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
17599 ip_addr_version (&ip) = IP6;
17603 errmsg ("parse error '%U'", format_unformat_error, input);
17608 M (ONE_USE_PETR, mp);
17610 mp->is_add = is_add;
17613 mp->is_ip4 = ip_addr_version (&ip) == IP4 ? 1 : 0;
17615 clib_memcpy (mp->address, &ip, 4);
17617 clib_memcpy (mp->address, &ip, 16);
17623 /* wait for reply */
17628 #define api_lisp_use_petr api_one_use_petr
17631 api_show_one_nsh_mapping (vat_main_t * vam)
17633 vl_api_show_one_use_petr_t *mp;
17636 if (!vam->json_output)
17638 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
17641 M (SHOW_ONE_NSH_MAPPING, mp);
17645 /* Wait for a reply... */
17651 api_show_one_use_petr (vat_main_t * vam)
17653 vl_api_show_one_use_petr_t *mp;
17656 if (!vam->json_output)
17658 print (vam->ofp, "%=20s", "Proxy-ETR status:");
17661 M (SHOW_ONE_USE_PETR, mp);
17665 /* Wait for a reply... */
17670 #define api_show_lisp_use_petr api_show_one_use_petr
17673 * Add/delete mapping between vni and vrf
17676 api_one_eid_table_add_del_map (vat_main_t * vam)
17678 unformat_input_t *input = vam->input;
17679 vl_api_one_eid_table_add_del_map_t *mp;
17680 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
17681 u32 vni, vrf, bd_index;
17684 /* Parse args required to build the message */
17685 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17687 if (unformat (input, "del"))
17689 else if (unformat (input, "vrf %d", &vrf))
17691 else if (unformat (input, "bd_index %d", &bd_index))
17693 else if (unformat (input, "vni %d", &vni))
17699 if (!vni_set || (!vrf_set && !bd_index_set))
17701 errmsg ("missing arguments!");
17705 if (vrf_set && bd_index_set)
17707 errmsg ("error: both vrf and bd entered!");
17711 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
17713 mp->is_add = is_add;
17714 mp->vni = htonl (vni);
17715 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
17716 mp->is_l2 = bd_index_set;
17721 /* wait for reply */
17726 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
17729 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
17731 u32 *action = va_arg (*args, u32 *);
17734 if (unformat (input, "%s", &s))
17736 if (!strcmp ((char *) s, "no-action"))
17738 else if (!strcmp ((char *) s, "natively-forward"))
17740 else if (!strcmp ((char *) s, "send-map-request"))
17742 else if (!strcmp ((char *) s, "drop"))
17746 clib_warning ("invalid action: '%s'", s);
17758 * Add/del remote mapping to/from ONE control plane
17760 * @param vam vpp API test context
17761 * @return return code
17764 api_one_add_del_remote_mapping (vat_main_t * vam)
17766 unformat_input_t *input = vam->input;
17767 vl_api_one_add_del_remote_mapping_t *mp;
17769 lisp_eid_vat_t _eid, *eid = &_eid;
17770 lisp_eid_vat_t _seid, *seid = &_seid;
17771 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
17772 u32 action = ~0, p, w, data_len;
17773 ip4_address_t rloc4;
17774 ip6_address_t rloc6;
17775 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
17778 memset (&rloc, 0, sizeof (rloc));
17780 /* Parse args required to build the message */
17781 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17783 if (unformat (input, "del-all"))
17787 else if (unformat (input, "del"))
17791 else if (unformat (input, "add"))
17795 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
17799 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
17803 else if (unformat (input, "vni %d", &vni))
17807 else if (unformat (input, "p %d w %d", &p, &w))
17811 errmsg ("No RLOC configured for setting priority/weight!");
17814 curr_rloc->priority = p;
17815 curr_rloc->weight = w;
17817 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
17820 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
17821 vec_add1 (rlocs, rloc);
17822 curr_rloc = &rlocs[vec_len (rlocs) - 1];
17824 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
17827 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
17828 vec_add1 (rlocs, rloc);
17829 curr_rloc = &rlocs[vec_len (rlocs) - 1];
17831 else if (unformat (input, "action %U",
17832 unformat_negative_mapping_action, &action))
17838 clib_warning ("parse error '%U'", format_unformat_error, input);
17845 errmsg ("missing params!");
17849 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
17851 errmsg ("no action set for negative map-reply!");
17855 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
17857 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
17858 mp->is_add = is_add;
17859 mp->vni = htonl (vni);
17860 mp->action = (u8) action;
17861 mp->is_src_dst = seid_set;
17862 mp->eid_len = eid->len;
17863 mp->seid_len = seid->len;
17864 mp->del_all = del_all;
17865 mp->eid_type = eid->type;
17866 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
17867 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
17869 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
17870 clib_memcpy (mp->rlocs, rlocs, data_len);
17876 /* Wait for a reply... */
17881 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
17884 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
17885 * forwarding entries in data-plane accordingly.
17887 * @param vam vpp API test context
17888 * @return return code
17891 api_one_add_del_adjacency (vat_main_t * vam)
17893 unformat_input_t *input = vam->input;
17894 vl_api_one_add_del_adjacency_t *mp;
17896 ip4_address_t leid4, reid4;
17897 ip6_address_t leid6, reid6;
17898 u8 reid_mac[6] = { 0 };
17899 u8 leid_mac[6] = { 0 };
17900 u8 reid_type, leid_type;
17901 u32 leid_len = 0, reid_len = 0, len;
17905 leid_type = reid_type = (u8) ~ 0;
17907 /* Parse args required to build the message */
17908 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17910 if (unformat (input, "del"))
17914 else if (unformat (input, "add"))
17918 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
17921 reid_type = 0; /* ipv4 */
17924 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
17927 reid_type = 1; /* ipv6 */
17930 else if (unformat (input, "reid %U", unformat_ethernet_address,
17933 reid_type = 2; /* mac */
17935 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
17938 leid_type = 0; /* ipv4 */
17941 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
17944 leid_type = 1; /* ipv6 */
17947 else if (unformat (input, "leid %U", unformat_ethernet_address,
17950 leid_type = 2; /* mac */
17952 else if (unformat (input, "vni %d", &vni))
17958 errmsg ("parse error '%U'", format_unformat_error, input);
17963 if ((u8) ~ 0 == reid_type)
17965 errmsg ("missing params!");
17969 if (leid_type != reid_type)
17971 errmsg ("remote and local EIDs are of different types!");
17975 M (ONE_ADD_DEL_ADJACENCY, mp);
17976 mp->is_add = is_add;
17977 mp->vni = htonl (vni);
17978 mp->leid_len = leid_len;
17979 mp->reid_len = reid_len;
17980 mp->eid_type = reid_type;
17982 switch (mp->eid_type)
17985 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
17986 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
17989 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
17990 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
17993 clib_memcpy (mp->leid, leid_mac, 6);
17994 clib_memcpy (mp->reid, reid_mac, 6);
17997 errmsg ("unknown EID type %d!", mp->eid_type);
18004 /* Wait for a reply... */
18009 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
18012 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
18014 u32 *mode = va_arg (*args, u32 *);
18016 if (unformat (input, "lisp"))
18018 else if (unformat (input, "vxlan"))
18027 api_gpe_get_encap_mode (vat_main_t * vam)
18029 vl_api_gpe_get_encap_mode_t *mp;
18032 /* Construct the API message */
18033 M (GPE_GET_ENCAP_MODE, mp);
18038 /* Wait for a reply... */
18044 api_gpe_set_encap_mode (vat_main_t * vam)
18046 unformat_input_t *input = vam->input;
18047 vl_api_gpe_set_encap_mode_t *mp;
18051 /* Parse args required to build the message */
18052 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18054 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
18060 /* Construct the API message */
18061 M (GPE_SET_ENCAP_MODE, mp);
18068 /* Wait for a reply... */
18074 api_lisp_gpe_add_del_iface (vat_main_t * vam)
18076 unformat_input_t *input = vam->input;
18077 vl_api_gpe_add_del_iface_t *mp;
18078 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
18079 u32 dp_table = 0, vni = 0;
18082 /* Parse args required to build the message */
18083 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18085 if (unformat (input, "up"))
18090 else if (unformat (input, "down"))
18095 else if (unformat (input, "table_id %d", &dp_table))
18099 else if (unformat (input, "bd_id %d", &dp_table))
18104 else if (unformat (input, "vni %d", &vni))
18112 if (action_set == 0)
18114 errmsg ("Action not set");
18117 if (dp_table_set == 0 || vni_set == 0)
18119 errmsg ("vni and dp_table must be set");
18123 /* Construct the API message */
18124 M (GPE_ADD_DEL_IFACE, mp);
18126 mp->is_add = is_add;
18127 mp->dp_table = clib_host_to_net_u32 (dp_table);
18129 mp->vni = clib_host_to_net_u32 (vni);
18134 /* Wait for a reply... */
18140 api_one_map_register_fallback_threshold (vat_main_t * vam)
18142 unformat_input_t *input = vam->input;
18143 vl_api_one_map_register_fallback_threshold_t *mp;
18148 /* Parse args required to build the message */
18149 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18151 if (unformat (input, "%u", &value))
18155 clib_warning ("parse error '%U'", format_unformat_error, input);
18162 errmsg ("fallback threshold value is missing!");
18166 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
18167 mp->value = clib_host_to_net_u32 (value);
18172 /* Wait for a reply... */
18178 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
18180 vl_api_show_one_map_register_fallback_threshold_t *mp;
18183 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
18188 /* Wait for a reply... */
18194 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
18196 u32 *proto = va_arg (*args, u32 *);
18198 if (unformat (input, "udp"))
18200 else if (unformat (input, "api"))
18209 api_one_set_transport_protocol (vat_main_t * vam)
18211 unformat_input_t *input = vam->input;
18212 vl_api_one_set_transport_protocol_t *mp;
18217 /* Parse args required to build the message */
18218 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18220 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
18224 clib_warning ("parse error '%U'", format_unformat_error, input);
18231 errmsg ("Transport protocol missing!");
18235 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
18236 mp->protocol = (u8) protocol;
18241 /* Wait for a reply... */
18247 api_one_get_transport_protocol (vat_main_t * vam)
18249 vl_api_one_get_transport_protocol_t *mp;
18252 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
18257 /* Wait for a reply... */
18263 api_one_map_register_set_ttl (vat_main_t * vam)
18265 unformat_input_t *input = vam->input;
18266 vl_api_one_map_register_set_ttl_t *mp;
18271 /* Parse args required to build the message */
18272 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18274 if (unformat (input, "%u", &ttl))
18278 clib_warning ("parse error '%U'", format_unformat_error, input);
18285 errmsg ("TTL value missing!");
18289 M (ONE_MAP_REGISTER_SET_TTL, mp);
18290 mp->ttl = clib_host_to_net_u32 (ttl);
18295 /* Wait for a reply... */
18301 api_show_one_map_register_ttl (vat_main_t * vam)
18303 vl_api_show_one_map_register_ttl_t *mp;
18306 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
18311 /* Wait for a reply... */
18317 * Add/del map request itr rlocs from ONE control plane and updates
18319 * @param vam vpp API test context
18320 * @return return code
18323 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
18325 unformat_input_t *input = vam->input;
18326 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
18327 u8 *locator_set_name = 0;
18328 u8 locator_set_name_set = 0;
18332 /* Parse args required to build the message */
18333 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18335 if (unformat (input, "del"))
18339 else if (unformat (input, "%_%v%_", &locator_set_name))
18341 locator_set_name_set = 1;
18345 clib_warning ("parse error '%U'", format_unformat_error, input);
18350 if (is_add && !locator_set_name_set)
18352 errmsg ("itr-rloc is not set!");
18356 if (is_add && vec_len (locator_set_name) > 64)
18358 errmsg ("itr-rloc locator-set name too long");
18359 vec_free (locator_set_name);
18363 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
18364 mp->is_add = is_add;
18367 clib_memcpy (mp->locator_set_name, locator_set_name,
18368 vec_len (locator_set_name));
18372 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
18374 vec_free (locator_set_name);
18379 /* Wait for a reply... */
18384 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
18387 api_one_locator_dump (vat_main_t * vam)
18389 unformat_input_t *input = vam->input;
18390 vl_api_one_locator_dump_t *mp;
18391 vl_api_control_ping_t *mp_ping;
18392 u8 is_index_set = 0, is_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, "ls_name %_%v%_", &ls_name))
18404 else if (unformat (input, "ls_index %d", &ls_index))
18410 errmsg ("parse error '%U'", format_unformat_error, input);
18415 if (!is_index_set && !is_name_set)
18417 errmsg ("error: expected one of index or name!");
18421 if (is_index_set && is_name_set)
18423 errmsg ("error: only one param expected!");
18427 if (vec_len (ls_name) > 62)
18429 errmsg ("error: locator set name too long!");
18433 if (!vam->json_output)
18435 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
18438 M (ONE_LOCATOR_DUMP, mp);
18439 mp->is_index_set = is_index_set;
18442 mp->ls_index = clib_host_to_net_u32 (ls_index);
18445 vec_add1 (ls_name, 0);
18446 strncpy ((char *) mp->ls_name, (char *) ls_name,
18447 sizeof (mp->ls_name) - 1);
18453 /* Use a control ping for synchronization */
18454 MPING (CONTROL_PING, mp_ping);
18457 /* Wait for a reply... */
18462 #define api_lisp_locator_dump api_one_locator_dump
18465 api_one_locator_set_dump (vat_main_t * vam)
18467 vl_api_one_locator_set_dump_t *mp;
18468 vl_api_control_ping_t *mp_ping;
18469 unformat_input_t *input = vam->input;
18473 /* Parse args required to build the message */
18474 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18476 if (unformat (input, "local"))
18480 else if (unformat (input, "remote"))
18486 errmsg ("parse error '%U'", format_unformat_error, input);
18491 if (!vam->json_output)
18493 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
18496 M (ONE_LOCATOR_SET_DUMP, mp);
18498 mp->filter = filter;
18503 /* Use a control ping for synchronization */
18504 MPING (CONTROL_PING, mp_ping);
18507 /* Wait for a reply... */
18512 #define api_lisp_locator_set_dump api_one_locator_set_dump
18515 api_one_eid_table_map_dump (vat_main_t * vam)
18519 unformat_input_t *input = vam->input;
18520 vl_api_one_eid_table_map_dump_t *mp;
18521 vl_api_control_ping_t *mp_ping;
18524 /* Parse args required to build the message */
18525 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18527 if (unformat (input, "l2"))
18532 else if (unformat (input, "l3"))
18539 errmsg ("parse error '%U'", format_unformat_error, input);
18546 errmsg ("expected one of 'l2' or 'l3' parameter!");
18550 if (!vam->json_output)
18552 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
18555 M (ONE_EID_TABLE_MAP_DUMP, mp);
18561 /* Use a control ping for synchronization */
18562 MPING (CONTROL_PING, mp_ping);
18565 /* Wait for a reply... */
18570 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
18573 api_one_eid_table_vni_dump (vat_main_t * vam)
18575 vl_api_one_eid_table_vni_dump_t *mp;
18576 vl_api_control_ping_t *mp_ping;
18579 if (!vam->json_output)
18581 print (vam->ofp, "VNI");
18584 M (ONE_EID_TABLE_VNI_DUMP, mp);
18589 /* Use a control ping for synchronization */
18590 MPING (CONTROL_PING, mp_ping);
18593 /* Wait for a reply... */
18598 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
18601 api_one_eid_table_dump (vat_main_t * vam)
18603 unformat_input_t *i = vam->input;
18604 vl_api_one_eid_table_dump_t *mp;
18605 vl_api_control_ping_t *mp_ping;
18606 struct in_addr ip4;
18607 struct in6_addr ip6;
18609 u8 eid_type = ~0, eid_set = 0;
18610 u32 prefix_length = ~0, t, vni = 0;
18613 lisp_nsh_api_t nsh;
18615 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18617 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
18623 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
18629 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
18634 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
18639 else if (unformat (i, "vni %d", &t))
18643 else if (unformat (i, "local"))
18647 else if (unformat (i, "remote"))
18653 errmsg ("parse error '%U'", format_unformat_error, i);
18658 if (!vam->json_output)
18660 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
18661 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
18664 M (ONE_EID_TABLE_DUMP, mp);
18666 mp->filter = filter;
18670 mp->vni = htonl (vni);
18671 mp->eid_type = eid_type;
18675 mp->prefix_length = prefix_length;
18676 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
18679 mp->prefix_length = prefix_length;
18680 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
18683 clib_memcpy (mp->eid, mac, sizeof (mac));
18686 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
18689 errmsg ("unknown EID type %d!", eid_type);
18697 /* Use a control ping for synchronization */
18698 MPING (CONTROL_PING, mp_ping);
18701 /* Wait for a reply... */
18706 #define api_lisp_eid_table_dump api_one_eid_table_dump
18709 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
18711 unformat_input_t *i = vam->input;
18712 vl_api_gpe_fwd_entries_get_t *mp;
18717 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18719 if (unformat (i, "vni %d", &vni))
18725 errmsg ("parse error '%U'", format_unformat_error, i);
18732 errmsg ("vni not set!");
18736 if (!vam->json_output)
18738 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
18742 M (GPE_FWD_ENTRIES_GET, mp);
18743 mp->vni = clib_host_to_net_u32 (vni);
18748 /* Wait for a reply... */
18753 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
18754 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
18755 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
18756 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
18757 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
18758 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
18759 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
18760 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
18763 api_one_adjacencies_get (vat_main_t * vam)
18765 unformat_input_t *i = vam->input;
18766 vl_api_one_adjacencies_get_t *mp;
18771 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18773 if (unformat (i, "vni %d", &vni))
18779 errmsg ("parse error '%U'", format_unformat_error, i);
18786 errmsg ("vni not set!");
18790 if (!vam->json_output)
18792 print (vam->ofp, "%s %40s", "leid", "reid");
18795 M (ONE_ADJACENCIES_GET, mp);
18796 mp->vni = clib_host_to_net_u32 (vni);
18801 /* Wait for a reply... */
18806 #define api_lisp_adjacencies_get api_one_adjacencies_get
18809 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
18811 unformat_input_t *i = vam->input;
18812 vl_api_gpe_native_fwd_rpaths_get_t *mp;
18814 u8 ip_family_set = 0, is_ip4 = 1;
18816 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18818 if (unformat (i, "ip4"))
18823 else if (unformat (i, "ip6"))
18830 errmsg ("parse error '%U'", format_unformat_error, i);
18835 if (!ip_family_set)
18837 errmsg ("ip family not set!");
18841 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
18842 mp->is_ip4 = is_ip4;
18847 /* Wait for a reply... */
18853 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
18855 vl_api_gpe_fwd_entry_vnis_get_t *mp;
18858 if (!vam->json_output)
18860 print (vam->ofp, "VNIs");
18863 M (GPE_FWD_ENTRY_VNIS_GET, mp);
18868 /* Wait for a reply... */
18874 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
18876 unformat_input_t *i = vam->input;
18877 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
18879 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
18880 struct in_addr ip4;
18881 struct in6_addr ip6;
18882 u32 table_id = 0, nh_sw_if_index = ~0;
18884 memset (&ip4, 0, sizeof (ip4));
18885 memset (&ip6, 0, sizeof (ip6));
18887 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18889 if (unformat (i, "del"))
18891 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
18892 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18897 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
18898 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18903 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
18907 nh_sw_if_index = ~0;
18909 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
18913 nh_sw_if_index = ~0;
18915 else if (unformat (i, "table %d", &table_id))
18919 errmsg ("parse error '%U'", format_unformat_error, i);
18926 errmsg ("nh addr not set!");
18930 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
18931 mp->is_add = is_add;
18932 mp->table_id = clib_host_to_net_u32 (table_id);
18933 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
18934 mp->is_ip4 = is_ip4;
18936 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
18938 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
18943 /* Wait for a reply... */
18949 api_one_map_server_dump (vat_main_t * vam)
18951 vl_api_one_map_server_dump_t *mp;
18952 vl_api_control_ping_t *mp_ping;
18955 if (!vam->json_output)
18957 print (vam->ofp, "%=20s", "Map server");
18960 M (ONE_MAP_SERVER_DUMP, mp);
18964 /* Use a control ping for synchronization */
18965 MPING (CONTROL_PING, mp_ping);
18968 /* Wait for a reply... */
18973 #define api_lisp_map_server_dump api_one_map_server_dump
18976 api_one_map_resolver_dump (vat_main_t * vam)
18978 vl_api_one_map_resolver_dump_t *mp;
18979 vl_api_control_ping_t *mp_ping;
18982 if (!vam->json_output)
18984 print (vam->ofp, "%=20s", "Map resolver");
18987 M (ONE_MAP_RESOLVER_DUMP, mp);
18991 /* Use a control ping for synchronization */
18992 MPING (CONTROL_PING, mp_ping);
18995 /* Wait for a reply... */
19000 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
19003 api_one_stats_flush (vat_main_t * vam)
19005 vl_api_one_stats_flush_t *mp;
19008 M (ONE_STATS_FLUSH, mp);
19015 api_one_stats_dump (vat_main_t * vam)
19017 vl_api_one_stats_dump_t *mp;
19018 vl_api_control_ping_t *mp_ping;
19021 M (ONE_STATS_DUMP, mp);
19025 /* Use a control ping for synchronization */
19026 MPING (CONTROL_PING, mp_ping);
19029 /* Wait for a reply... */
19035 api_show_one_status (vat_main_t * vam)
19037 vl_api_show_one_status_t *mp;
19040 if (!vam->json_output)
19042 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
19045 M (SHOW_ONE_STATUS, mp);
19048 /* Wait for a reply... */
19053 #define api_show_lisp_status api_show_one_status
19056 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
19058 vl_api_gpe_fwd_entry_path_dump_t *mp;
19059 vl_api_control_ping_t *mp_ping;
19060 unformat_input_t *i = vam->input;
19061 u32 fwd_entry_index = ~0;
19064 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19066 if (unformat (i, "index %d", &fwd_entry_index))
19072 if (~0 == fwd_entry_index)
19074 errmsg ("no index specified!");
19078 if (!vam->json_output)
19080 print (vam->ofp, "first line");
19083 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
19087 /* Use a control ping for synchronization */
19088 MPING (CONTROL_PING, mp_ping);
19091 /* Wait for a reply... */
19097 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
19099 vl_api_one_get_map_request_itr_rlocs_t *mp;
19102 if (!vam->json_output)
19104 print (vam->ofp, "%=20s", "itr-rlocs:");
19107 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
19110 /* Wait for a reply... */
19115 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
19118 api_af_packet_create (vat_main_t * vam)
19120 unformat_input_t *i = vam->input;
19121 vl_api_af_packet_create_t *mp;
19122 u8 *host_if_name = 0;
19124 u8 random_hw_addr = 1;
19127 memset (hw_addr, 0, sizeof (hw_addr));
19129 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19131 if (unformat (i, "name %s", &host_if_name))
19132 vec_add1 (host_if_name, 0);
19133 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
19134 random_hw_addr = 0;
19139 if (!vec_len (host_if_name))
19141 errmsg ("host-interface name must be specified");
19145 if (vec_len (host_if_name) > 64)
19147 errmsg ("host-interface name too long");
19151 M (AF_PACKET_CREATE, mp);
19153 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
19154 clib_memcpy (mp->hw_addr, hw_addr, 6);
19155 mp->use_random_hw_addr = random_hw_addr;
19156 vec_free (host_if_name);
19164 fprintf (vam->ofp ? vam->ofp : stderr,
19165 " new sw_if_index = %d\n", vam->sw_if_index);
19172 api_af_packet_delete (vat_main_t * vam)
19174 unformat_input_t *i = vam->input;
19175 vl_api_af_packet_delete_t *mp;
19176 u8 *host_if_name = 0;
19179 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19181 if (unformat (i, "name %s", &host_if_name))
19182 vec_add1 (host_if_name, 0);
19187 if (!vec_len (host_if_name))
19189 errmsg ("host-interface name must be specified");
19193 if (vec_len (host_if_name) > 64)
19195 errmsg ("host-interface name too long");
19199 M (AF_PACKET_DELETE, mp);
19201 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
19202 vec_free (host_if_name);
19210 api_policer_add_del (vat_main_t * vam)
19212 unformat_input_t *i = vam->input;
19213 vl_api_policer_add_del_t *mp;
19223 u8 color_aware = 0;
19224 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
19227 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
19228 conform_action.dscp = 0;
19229 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
19230 exceed_action.dscp = 0;
19231 violate_action.action_type = SSE2_QOS_ACTION_DROP;
19232 violate_action.dscp = 0;
19234 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19236 if (unformat (i, "del"))
19238 else if (unformat (i, "name %s", &name))
19239 vec_add1 (name, 0);
19240 else if (unformat (i, "cir %u", &cir))
19242 else if (unformat (i, "eir %u", &eir))
19244 else if (unformat (i, "cb %u", &cb))
19246 else if (unformat (i, "eb %u", &eb))
19248 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
19251 else if (unformat (i, "round_type %U", unformat_policer_round_type,
19254 else if (unformat (i, "type %U", unformat_policer_type, &type))
19256 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
19259 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
19262 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
19265 else if (unformat (i, "color-aware"))
19271 if (!vec_len (name))
19273 errmsg ("policer name must be specified");
19277 if (vec_len (name) > 64)
19279 errmsg ("policer name too long");
19283 M (POLICER_ADD_DEL, mp);
19285 clib_memcpy (mp->name, name, vec_len (name));
19287 mp->is_add = is_add;
19288 mp->cir = ntohl (cir);
19289 mp->eir = ntohl (eir);
19290 mp->cb = clib_net_to_host_u64 (cb);
19291 mp->eb = clib_net_to_host_u64 (eb);
19292 mp->rate_type = rate_type;
19293 mp->round_type = round_type;
19295 mp->conform_action_type = conform_action.action_type;
19296 mp->conform_dscp = conform_action.dscp;
19297 mp->exceed_action_type = exceed_action.action_type;
19298 mp->exceed_dscp = exceed_action.dscp;
19299 mp->violate_action_type = violate_action.action_type;
19300 mp->violate_dscp = violate_action.dscp;
19301 mp->color_aware = color_aware;
19309 api_policer_dump (vat_main_t * vam)
19311 unformat_input_t *i = vam->input;
19312 vl_api_policer_dump_t *mp;
19313 vl_api_control_ping_t *mp_ping;
19314 u8 *match_name = 0;
19315 u8 match_name_valid = 0;
19318 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19320 if (unformat (i, "name %s", &match_name))
19322 vec_add1 (match_name, 0);
19323 match_name_valid = 1;
19329 M (POLICER_DUMP, mp);
19330 mp->match_name_valid = match_name_valid;
19331 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
19332 vec_free (match_name);
19336 /* Use a control ping for synchronization */
19337 MPING (CONTROL_PING, mp_ping);
19340 /* Wait for a reply... */
19346 api_policer_classify_set_interface (vat_main_t * vam)
19348 unformat_input_t *i = vam->input;
19349 vl_api_policer_classify_set_interface_t *mp;
19351 int sw_if_index_set;
19352 u32 ip4_table_index = ~0;
19353 u32 ip6_table_index = ~0;
19354 u32 l2_table_index = ~0;
19358 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19360 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19361 sw_if_index_set = 1;
19362 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19363 sw_if_index_set = 1;
19364 else if (unformat (i, "del"))
19366 else if (unformat (i, "ip4-table %d", &ip4_table_index))
19368 else if (unformat (i, "ip6-table %d", &ip6_table_index))
19370 else if (unformat (i, "l2-table %d", &l2_table_index))
19374 clib_warning ("parse error '%U'", format_unformat_error, i);
19379 if (sw_if_index_set == 0)
19381 errmsg ("missing interface name or sw_if_index");
19385 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
19387 mp->sw_if_index = ntohl (sw_if_index);
19388 mp->ip4_table_index = ntohl (ip4_table_index);
19389 mp->ip6_table_index = ntohl (ip6_table_index);
19390 mp->l2_table_index = ntohl (l2_table_index);
19391 mp->is_add = is_add;
19399 api_policer_classify_dump (vat_main_t * vam)
19401 unformat_input_t *i = vam->input;
19402 vl_api_policer_classify_dump_t *mp;
19403 vl_api_control_ping_t *mp_ping;
19404 u8 type = POLICER_CLASSIFY_N_TABLES;
19407 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
19411 errmsg ("classify table type must be specified");
19415 if (!vam->json_output)
19417 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
19420 M (POLICER_CLASSIFY_DUMP, mp);
19425 /* Use a control ping for synchronization */
19426 MPING (CONTROL_PING, mp_ping);
19429 /* Wait for a reply... */
19435 api_netmap_create (vat_main_t * vam)
19437 unformat_input_t *i = vam->input;
19438 vl_api_netmap_create_t *mp;
19441 u8 random_hw_addr = 1;
19446 memset (hw_addr, 0, sizeof (hw_addr));
19448 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19450 if (unformat (i, "name %s", &if_name))
19451 vec_add1 (if_name, 0);
19452 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
19453 random_hw_addr = 0;
19454 else if (unformat (i, "pipe"))
19456 else if (unformat (i, "master"))
19458 else if (unformat (i, "slave"))
19464 if (!vec_len (if_name))
19466 errmsg ("interface name must be specified");
19470 if (vec_len (if_name) > 64)
19472 errmsg ("interface name too long");
19476 M (NETMAP_CREATE, mp);
19478 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
19479 clib_memcpy (mp->hw_addr, hw_addr, 6);
19480 mp->use_random_hw_addr = random_hw_addr;
19481 mp->is_pipe = is_pipe;
19482 mp->is_master = is_master;
19483 vec_free (if_name);
19491 api_netmap_delete (vat_main_t * vam)
19493 unformat_input_t *i = vam->input;
19494 vl_api_netmap_delete_t *mp;
19498 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19500 if (unformat (i, "name %s", &if_name))
19501 vec_add1 (if_name, 0);
19506 if (!vec_len (if_name))
19508 errmsg ("interface name must be specified");
19512 if (vec_len (if_name) > 64)
19514 errmsg ("interface name too long");
19518 M (NETMAP_DELETE, mp);
19520 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
19521 vec_free (if_name);
19529 vl_api_mpls_fib_path_print (vat_main_t * vam, vl_api_fib_path2_t * fp)
19531 if (fp->afi == IP46_TYPE_IP6)
19533 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19534 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19535 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19536 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19537 format_ip6_address, fp->next_hop);
19538 else if (fp->afi == IP46_TYPE_IP4)
19540 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19541 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19542 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19543 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19544 format_ip4_address, fp->next_hop);
19548 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
19549 vl_api_fib_path2_t * fp)
19551 struct in_addr ip4;
19552 struct in6_addr ip6;
19554 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19555 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19556 vat_json_object_add_uint (node, "is_local", fp->is_local);
19557 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19558 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19559 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19560 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19561 if (fp->afi == IP46_TYPE_IP4)
19563 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19564 vat_json_object_add_ip4 (node, "next_hop", ip4);
19566 else if (fp->afi == IP46_TYPE_IP6)
19568 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19569 vat_json_object_add_ip6 (node, "next_hop", ip6);
19574 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
19576 vat_main_t *vam = &vat_main;
19577 int count = ntohl (mp->mt_count);
19578 vl_api_fib_path2_t *fp;
19581 print (vam->ofp, "[%d]: sw_if_index %d via:",
19582 ntohl (mp->mt_tunnel_index), ntohl (mp->mt_sw_if_index));
19584 for (i = 0; i < count; i++)
19586 vl_api_mpls_fib_path_print (vam, fp);
19590 print (vam->ofp, "");
19593 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
19594 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
19597 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
19599 vat_main_t *vam = &vat_main;
19600 vat_json_node_t *node = NULL;
19601 int count = ntohl (mp->mt_count);
19602 vl_api_fib_path2_t *fp;
19605 if (VAT_JSON_ARRAY != vam->json_tree.type)
19607 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19608 vat_json_init_array (&vam->json_tree);
19610 node = vat_json_array_add (&vam->json_tree);
19612 vat_json_init_object (node);
19613 vat_json_object_add_uint (node, "tunnel_index",
19614 ntohl (mp->mt_tunnel_index));
19615 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->mt_sw_if_index));
19617 vat_json_object_add_uint (node, "l2_only", mp->mt_l2_only);
19620 for (i = 0; i < count; i++)
19622 vl_api_mpls_fib_path_json_print (node, fp);
19628 api_mpls_tunnel_dump (vat_main_t * vam)
19630 vl_api_mpls_tunnel_dump_t *mp;
19631 vl_api_control_ping_t *mp_ping;
19635 /* Parse args required to build the message */
19636 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
19638 if (!unformat (vam->input, "tunnel_index %d", &index))
19645 print (vam->ofp, " tunnel_index %d", index);
19647 M (MPLS_TUNNEL_DUMP, mp);
19648 mp->tunnel_index = htonl (index);
19651 /* Use a control ping for synchronization */
19652 MPING (CONTROL_PING, mp_ping);
19659 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
19660 #define vl_api_mpls_fib_details_t_print vl_noop_handler
19664 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
19666 vat_main_t *vam = &vat_main;
19667 int count = ntohl (mp->count);
19668 vl_api_fib_path2_t *fp;
19672 "table-id %d, label %u, ess_bit %u",
19673 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
19675 for (i = 0; i < count; i++)
19677 vl_api_mpls_fib_path_print (vam, fp);
19682 static void vl_api_mpls_fib_details_t_handler_json
19683 (vl_api_mpls_fib_details_t * mp)
19685 vat_main_t *vam = &vat_main;
19686 int count = ntohl (mp->count);
19687 vat_json_node_t *node = NULL;
19688 vl_api_fib_path2_t *fp;
19691 if (VAT_JSON_ARRAY != vam->json_tree.type)
19693 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19694 vat_json_init_array (&vam->json_tree);
19696 node = vat_json_array_add (&vam->json_tree);
19698 vat_json_init_object (node);
19699 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19700 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
19701 vat_json_object_add_uint (node, "label", ntohl (mp->label));
19702 vat_json_object_add_uint (node, "path_count", count);
19704 for (i = 0; i < count; i++)
19706 vl_api_mpls_fib_path_json_print (node, fp);
19712 api_mpls_fib_dump (vat_main_t * vam)
19714 vl_api_mpls_fib_dump_t *mp;
19715 vl_api_control_ping_t *mp_ping;
19718 M (MPLS_FIB_DUMP, mp);
19721 /* Use a control ping for synchronization */
19722 MPING (CONTROL_PING, mp_ping);
19729 #define vl_api_ip_fib_details_t_endian vl_noop_handler
19730 #define vl_api_ip_fib_details_t_print vl_noop_handler
19733 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
19735 vat_main_t *vam = &vat_main;
19736 int count = ntohl (mp->count);
19737 vl_api_fib_path_t *fp;
19741 "table-id %d, prefix %U/%d",
19742 ntohl (mp->table_id), format_ip4_address, mp->address,
19743 mp->address_length);
19745 for (i = 0; i < count; i++)
19747 if (fp->afi == IP46_TYPE_IP6)
19749 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19750 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19751 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19752 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19753 format_ip6_address, fp->next_hop);
19754 else if (fp->afi == IP46_TYPE_IP4)
19756 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19757 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19758 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19759 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19760 format_ip4_address, fp->next_hop);
19765 static void vl_api_ip_fib_details_t_handler_json
19766 (vl_api_ip_fib_details_t * mp)
19768 vat_main_t *vam = &vat_main;
19769 int count = ntohl (mp->count);
19770 vat_json_node_t *node = NULL;
19771 struct in_addr ip4;
19772 struct in6_addr ip6;
19773 vl_api_fib_path_t *fp;
19776 if (VAT_JSON_ARRAY != vam->json_tree.type)
19778 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19779 vat_json_init_array (&vam->json_tree);
19781 node = vat_json_array_add (&vam->json_tree);
19783 vat_json_init_object (node);
19784 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19785 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
19786 vat_json_object_add_ip4 (node, "prefix", ip4);
19787 vat_json_object_add_uint (node, "mask_length", mp->address_length);
19788 vat_json_object_add_uint (node, "path_count", count);
19790 for (i = 0; i < count; i++)
19792 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19793 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19794 vat_json_object_add_uint (node, "is_local", fp->is_local);
19795 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19796 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19797 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19798 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19799 if (fp->afi == IP46_TYPE_IP4)
19801 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19802 vat_json_object_add_ip4 (node, "next_hop", ip4);
19804 else if (fp->afi == IP46_TYPE_IP6)
19806 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19807 vat_json_object_add_ip6 (node, "next_hop", ip6);
19813 api_ip_fib_dump (vat_main_t * vam)
19815 vl_api_ip_fib_dump_t *mp;
19816 vl_api_control_ping_t *mp_ping;
19819 M (IP_FIB_DUMP, mp);
19822 /* Use a control ping for synchronization */
19823 MPING (CONTROL_PING, mp_ping);
19831 api_ip_mfib_dump (vat_main_t * vam)
19833 vl_api_ip_mfib_dump_t *mp;
19834 vl_api_control_ping_t *mp_ping;
19837 M (IP_MFIB_DUMP, mp);
19840 /* Use a control ping for synchronization */
19841 MPING (CONTROL_PING, mp_ping);
19848 static void vl_api_ip_neighbor_details_t_handler
19849 (vl_api_ip_neighbor_details_t * mp)
19851 vat_main_t *vam = &vat_main;
19853 print (vam->ofp, "%c %U %U",
19854 (mp->is_static) ? 'S' : 'D',
19855 format_ethernet_address, &mp->mac_address,
19856 (mp->is_ipv6) ? format_ip6_address : format_ip4_address,
19860 static void vl_api_ip_neighbor_details_t_handler_json
19861 (vl_api_ip_neighbor_details_t * mp)
19864 vat_main_t *vam = &vat_main;
19865 vat_json_node_t *node;
19866 struct in_addr ip4;
19867 struct in6_addr ip6;
19869 if (VAT_JSON_ARRAY != vam->json_tree.type)
19871 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19872 vat_json_init_array (&vam->json_tree);
19874 node = vat_json_array_add (&vam->json_tree);
19876 vat_json_init_object (node);
19877 vat_json_object_add_string_copy (node, "flag",
19878 (mp->is_static) ? (u8 *) "static" : (u8 *)
19881 vat_json_object_add_string_copy (node, "link_layer",
19882 format (0, "%U", format_ethernet_address,
19883 &mp->mac_address));
19887 clib_memcpy (&ip6, &mp->ip_address, sizeof (ip6));
19888 vat_json_object_add_ip6 (node, "ip_address", ip6);
19892 clib_memcpy (&ip4, &mp->ip_address, sizeof (ip4));
19893 vat_json_object_add_ip4 (node, "ip_address", ip4);
19898 api_ip_neighbor_dump (vat_main_t * vam)
19900 unformat_input_t *i = vam->input;
19901 vl_api_ip_neighbor_dump_t *mp;
19902 vl_api_control_ping_t *mp_ping;
19904 u32 sw_if_index = ~0;
19907 /* Parse args required to build the message */
19908 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19910 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19912 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19914 else if (unformat (i, "ip6"))
19920 if (sw_if_index == ~0)
19922 errmsg ("missing interface name or sw_if_index");
19926 M (IP_NEIGHBOR_DUMP, mp);
19927 mp->is_ipv6 = (u8) is_ipv6;
19928 mp->sw_if_index = ntohl (sw_if_index);
19931 /* Use a control ping for synchronization */
19932 MPING (CONTROL_PING, mp_ping);
19939 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
19940 #define vl_api_ip6_fib_details_t_print vl_noop_handler
19943 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
19945 vat_main_t *vam = &vat_main;
19946 int count = ntohl (mp->count);
19947 vl_api_fib_path_t *fp;
19951 "table-id %d, prefix %U/%d",
19952 ntohl (mp->table_id), format_ip6_address, mp->address,
19953 mp->address_length);
19955 for (i = 0; i < count; i++)
19957 if (fp->afi == IP46_TYPE_IP6)
19959 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19960 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19961 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19962 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19963 format_ip6_address, fp->next_hop);
19964 else if (fp->afi == IP46_TYPE_IP4)
19966 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19967 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19968 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19969 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19970 format_ip4_address, fp->next_hop);
19975 static void vl_api_ip6_fib_details_t_handler_json
19976 (vl_api_ip6_fib_details_t * mp)
19978 vat_main_t *vam = &vat_main;
19979 int count = ntohl (mp->count);
19980 vat_json_node_t *node = NULL;
19981 struct in_addr ip4;
19982 struct in6_addr ip6;
19983 vl_api_fib_path_t *fp;
19986 if (VAT_JSON_ARRAY != vam->json_tree.type)
19988 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19989 vat_json_init_array (&vam->json_tree);
19991 node = vat_json_array_add (&vam->json_tree);
19993 vat_json_init_object (node);
19994 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19995 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
19996 vat_json_object_add_ip6 (node, "prefix", ip6);
19997 vat_json_object_add_uint (node, "mask_length", mp->address_length);
19998 vat_json_object_add_uint (node, "path_count", count);
20000 for (i = 0; i < count; i++)
20002 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
20003 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
20004 vat_json_object_add_uint (node, "is_local", fp->is_local);
20005 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
20006 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
20007 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
20008 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
20009 if (fp->afi == IP46_TYPE_IP4)
20011 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
20012 vat_json_object_add_ip4 (node, "next_hop", ip4);
20014 else if (fp->afi == IP46_TYPE_IP6)
20016 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
20017 vat_json_object_add_ip6 (node, "next_hop", ip6);
20023 api_ip6_fib_dump (vat_main_t * vam)
20025 vl_api_ip6_fib_dump_t *mp;
20026 vl_api_control_ping_t *mp_ping;
20029 M (IP6_FIB_DUMP, mp);
20032 /* Use a control ping for synchronization */
20033 MPING (CONTROL_PING, mp_ping);
20041 api_ip6_mfib_dump (vat_main_t * vam)
20043 vl_api_ip6_mfib_dump_t *mp;
20044 vl_api_control_ping_t *mp_ping;
20047 M (IP6_MFIB_DUMP, mp);
20050 /* Use a control ping for synchronization */
20051 MPING (CONTROL_PING, mp_ping);
20059 api_classify_table_ids (vat_main_t * vam)
20061 vl_api_classify_table_ids_t *mp;
20064 /* Construct the API message */
20065 M (CLASSIFY_TABLE_IDS, mp);
20074 api_classify_table_by_interface (vat_main_t * vam)
20076 unformat_input_t *input = vam->input;
20077 vl_api_classify_table_by_interface_t *mp;
20079 u32 sw_if_index = ~0;
20081 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20083 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20085 else if (unformat (input, "sw_if_index %d", &sw_if_index))
20090 if (sw_if_index == ~0)
20092 errmsg ("missing interface name or sw_if_index");
20096 /* Construct the API message */
20097 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
20099 mp->sw_if_index = ntohl (sw_if_index);
20107 api_classify_table_info (vat_main_t * vam)
20109 unformat_input_t *input = vam->input;
20110 vl_api_classify_table_info_t *mp;
20114 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20116 if (unformat (input, "table_id %d", &table_id))
20121 if (table_id == ~0)
20123 errmsg ("missing table id");
20127 /* Construct the API message */
20128 M (CLASSIFY_TABLE_INFO, mp);
20130 mp->table_id = ntohl (table_id);
20138 api_classify_session_dump (vat_main_t * vam)
20140 unformat_input_t *input = vam->input;
20141 vl_api_classify_session_dump_t *mp;
20142 vl_api_control_ping_t *mp_ping;
20146 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20148 if (unformat (input, "table_id %d", &table_id))
20153 if (table_id == ~0)
20155 errmsg ("missing table id");
20159 /* Construct the API message */
20160 M (CLASSIFY_SESSION_DUMP, mp);
20162 mp->table_id = ntohl (table_id);
20165 /* Use a control ping for synchronization */
20166 MPING (CONTROL_PING, mp_ping);
20174 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
20176 vat_main_t *vam = &vat_main;
20178 print (vam->ofp, "collector_address %U, collector_port %d, "
20179 "src_address %U, vrf_id %d, path_mtu %u, "
20180 "template_interval %u, udp_checksum %d",
20181 format_ip4_address, mp->collector_address,
20182 ntohs (mp->collector_port),
20183 format_ip4_address, mp->src_address,
20184 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
20185 ntohl (mp->template_interval), mp->udp_checksum);
20188 vam->result_ready = 1;
20192 vl_api_ipfix_exporter_details_t_handler_json
20193 (vl_api_ipfix_exporter_details_t * mp)
20195 vat_main_t *vam = &vat_main;
20196 vat_json_node_t node;
20197 struct in_addr collector_address;
20198 struct in_addr src_address;
20200 vat_json_init_object (&node);
20201 clib_memcpy (&collector_address, &mp->collector_address,
20202 sizeof (collector_address));
20203 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
20204 vat_json_object_add_uint (&node, "collector_port",
20205 ntohs (mp->collector_port));
20206 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
20207 vat_json_object_add_ip4 (&node, "src_address", src_address);
20208 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
20209 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
20210 vat_json_object_add_uint (&node, "template_interval",
20211 ntohl (mp->template_interval));
20212 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
20214 vat_json_print (vam->ofp, &node);
20215 vat_json_free (&node);
20217 vam->result_ready = 1;
20221 api_ipfix_exporter_dump (vat_main_t * vam)
20223 vl_api_ipfix_exporter_dump_t *mp;
20226 /* Construct the API message */
20227 M (IPFIX_EXPORTER_DUMP, mp);
20236 api_ipfix_classify_stream_dump (vat_main_t * vam)
20238 vl_api_ipfix_classify_stream_dump_t *mp;
20241 /* Construct the API message */
20242 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
20253 vl_api_ipfix_classify_stream_details_t_handler
20254 (vl_api_ipfix_classify_stream_details_t * mp)
20256 vat_main_t *vam = &vat_main;
20257 print (vam->ofp, "domain_id %d, src_port %d",
20258 ntohl (mp->domain_id), ntohs (mp->src_port));
20260 vam->result_ready = 1;
20264 vl_api_ipfix_classify_stream_details_t_handler_json
20265 (vl_api_ipfix_classify_stream_details_t * mp)
20267 vat_main_t *vam = &vat_main;
20268 vat_json_node_t node;
20270 vat_json_init_object (&node);
20271 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
20272 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
20274 vat_json_print (vam->ofp, &node);
20275 vat_json_free (&node);
20277 vam->result_ready = 1;
20281 api_ipfix_classify_table_dump (vat_main_t * vam)
20283 vl_api_ipfix_classify_table_dump_t *mp;
20284 vl_api_control_ping_t *mp_ping;
20287 if (!vam->json_output)
20289 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
20290 "transport_protocol");
20293 /* Construct the API message */
20294 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
20299 /* Use a control ping for synchronization */
20300 MPING (CONTROL_PING, mp_ping);
20308 vl_api_ipfix_classify_table_details_t_handler
20309 (vl_api_ipfix_classify_table_details_t * mp)
20311 vat_main_t *vam = &vat_main;
20312 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
20313 mp->transport_protocol);
20317 vl_api_ipfix_classify_table_details_t_handler_json
20318 (vl_api_ipfix_classify_table_details_t * mp)
20320 vat_json_node_t *node = NULL;
20321 vat_main_t *vam = &vat_main;
20323 if (VAT_JSON_ARRAY != vam->json_tree.type)
20325 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20326 vat_json_init_array (&vam->json_tree);
20329 node = vat_json_array_add (&vam->json_tree);
20330 vat_json_init_object (node);
20332 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
20333 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
20334 vat_json_object_add_uint (node, "transport_protocol",
20335 mp->transport_protocol);
20339 api_sw_interface_span_enable_disable (vat_main_t * vam)
20341 unformat_input_t *i = vam->input;
20342 vl_api_sw_interface_span_enable_disable_t *mp;
20343 u32 src_sw_if_index = ~0;
20344 u32 dst_sw_if_index = ~0;
20349 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20352 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
20354 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
20358 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
20360 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
20362 else if (unformat (i, "disable"))
20364 else if (unformat (i, "rx"))
20366 else if (unformat (i, "tx"))
20368 else if (unformat (i, "both"))
20370 else if (unformat (i, "l2"))
20376 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
20378 mp->sw_if_index_from = htonl (src_sw_if_index);
20379 mp->sw_if_index_to = htonl (dst_sw_if_index);
20389 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
20392 vat_main_t *vam = &vat_main;
20393 u8 *sw_if_from_name = 0;
20394 u8 *sw_if_to_name = 0;
20395 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
20396 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
20397 char *states[] = { "none", "rx", "tx", "both" };
20401 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
20403 if ((u32) p->value[0] == sw_if_index_from)
20405 sw_if_from_name = (u8 *)(p->key);
20409 if ((u32) p->value[0] == sw_if_index_to)
20411 sw_if_to_name = (u8 *)(p->key);
20412 if (sw_if_from_name)
20417 print (vam->ofp, "%20s => %20s (%s)",
20418 sw_if_from_name, sw_if_to_name, states[mp->state]);
20422 vl_api_sw_interface_span_details_t_handler_json
20423 (vl_api_sw_interface_span_details_t * mp)
20425 vat_main_t *vam = &vat_main;
20426 vat_json_node_t *node = NULL;
20427 u8 *sw_if_from_name = 0;
20428 u8 *sw_if_to_name = 0;
20429 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
20430 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
20434 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
20436 if ((u32) p->value[0] == sw_if_index_from)
20438 sw_if_from_name = (u8 *)(p->key);
20442 if ((u32) p->value[0] == sw_if_index_to)
20444 sw_if_to_name = (u8 *)(p->key);
20445 if (sw_if_from_name)
20451 if (VAT_JSON_ARRAY != vam->json_tree.type)
20453 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20454 vat_json_init_array (&vam->json_tree);
20456 node = vat_json_array_add (&vam->json_tree);
20458 vat_json_init_object (node);
20459 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
20460 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
20461 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
20462 if (0 != sw_if_to_name)
20464 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
20466 vat_json_object_add_uint (node, "state", mp->state);
20470 api_sw_interface_span_dump (vat_main_t * vam)
20472 unformat_input_t *input = vam->input;
20473 vl_api_sw_interface_span_dump_t *mp;
20474 vl_api_control_ping_t *mp_ping;
20478 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20480 if (unformat (input, "l2"))
20486 M (SW_INTERFACE_SPAN_DUMP, mp);
20490 /* Use a control ping for synchronization */
20491 MPING (CONTROL_PING, mp_ping);
20499 api_pg_create_interface (vat_main_t * vam)
20501 unformat_input_t *input = vam->input;
20502 vl_api_pg_create_interface_t *mp;
20506 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20508 if (unformat (input, "if_id %d", &if_id))
20515 errmsg ("missing pg interface index");
20519 /* Construct the API message */
20520 M (PG_CREATE_INTERFACE, mp);
20522 mp->interface_id = ntohl (if_id);
20530 api_pg_capture (vat_main_t * vam)
20532 unformat_input_t *input = vam->input;
20533 vl_api_pg_capture_t *mp;
20538 u8 pcap_file_set = 0;
20541 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20543 if (unformat (input, "if_id %d", &if_id))
20545 else if (unformat (input, "pcap %s", &pcap_file))
20547 else if (unformat (input, "count %d", &count))
20549 else if (unformat (input, "disable"))
20556 errmsg ("missing pg interface index");
20559 if (pcap_file_set > 0)
20561 if (vec_len (pcap_file) > 255)
20563 errmsg ("pcap file name is too long");
20568 u32 name_len = vec_len (pcap_file);
20569 /* Construct the API message */
20570 M (PG_CAPTURE, mp);
20572 mp->interface_id = ntohl (if_id);
20573 mp->is_enabled = enable;
20574 mp->count = ntohl (count);
20575 mp->pcap_name_length = ntohl (name_len);
20576 if (pcap_file_set != 0)
20578 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
20580 vec_free (pcap_file);
20588 api_pg_enable_disable (vat_main_t * vam)
20590 unformat_input_t *input = vam->input;
20591 vl_api_pg_enable_disable_t *mp;
20594 u8 stream_name_set = 0;
20595 u8 *stream_name = 0;
20597 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20599 if (unformat (input, "stream %s", &stream_name))
20600 stream_name_set = 1;
20601 else if (unformat (input, "disable"))
20607 if (stream_name_set > 0)
20609 if (vec_len (stream_name) > 255)
20611 errmsg ("stream name too long");
20616 u32 name_len = vec_len (stream_name);
20617 /* Construct the API message */
20618 M (PG_ENABLE_DISABLE, mp);
20620 mp->is_enabled = enable;
20621 if (stream_name_set != 0)
20623 mp->stream_name_length = ntohl (name_len);
20624 clib_memcpy (mp->stream_name, stream_name, name_len);
20626 vec_free (stream_name);
20634 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
20636 unformat_input_t *input = vam->input;
20637 vl_api_ip_source_and_port_range_check_add_del_t *mp;
20639 u16 *low_ports = 0;
20640 u16 *high_ports = 0;
20643 ip4_address_t ip4_addr;
20644 ip6_address_t ip6_addr;
20653 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20655 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
20661 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
20666 else if (unformat (input, "vrf %d", &vrf_id))
20668 else if (unformat (input, "del"))
20670 else if (unformat (input, "port %d", &tmp))
20672 if (tmp == 0 || tmp > 65535)
20674 errmsg ("port %d out of range", tmp);
20678 this_hi = this_low + 1;
20679 vec_add1 (low_ports, this_low);
20680 vec_add1 (high_ports, this_hi);
20682 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
20684 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
20686 errmsg ("incorrect range parameters");
20690 /* Note: in debug CLI +1 is added to high before
20691 passing to real fn that does "the work"
20692 (ip_source_and_port_range_check_add_del).
20693 This fn is a wrapper around the binary API fn a
20694 control plane will call, which expects this increment
20695 to have occurred. Hence letting the binary API control
20696 plane fn do the increment for consistency between VAT
20697 and other control planes.
20700 vec_add1 (low_ports, this_low);
20701 vec_add1 (high_ports, this_hi);
20707 if (prefix_set == 0)
20709 errmsg ("<address>/<mask> not specified");
20715 errmsg ("VRF ID required, not specified");
20722 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
20726 if (vec_len (low_ports) == 0)
20728 errmsg ("At least one port or port range required");
20732 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
20734 mp->is_add = is_add;
20739 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
20744 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
20747 mp->mask_length = length;
20748 mp->number_of_ranges = vec_len (low_ports);
20750 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
20751 vec_free (low_ports);
20753 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
20754 vec_free (high_ports);
20756 mp->vrf_id = ntohl (vrf_id);
20764 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
20766 unformat_input_t *input = vam->input;
20767 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
20768 u32 sw_if_index = ~0;
20770 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
20771 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
20775 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20777 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20779 else if (unformat (input, "sw_if_index %d", &sw_if_index))
20781 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
20783 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
20785 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
20787 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
20789 else if (unformat (input, "del"))
20795 if (sw_if_index == ~0)
20797 errmsg ("Interface required but not specified");
20803 errmsg ("VRF ID required but not specified");
20807 if (tcp_out_vrf_id == 0
20808 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
20811 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
20815 /* Construct the API message */
20816 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
20818 mp->sw_if_index = ntohl (sw_if_index);
20819 mp->is_add = is_add;
20820 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
20821 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
20822 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
20823 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
20828 /* Wait for a reply... */
20834 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
20836 unformat_input_t *i = vam->input;
20837 vl_api_ipsec_gre_add_del_tunnel_t *mp;
20838 u32 local_sa_id = 0;
20839 u32 remote_sa_id = 0;
20840 ip4_address_t src_address;
20841 ip4_address_t dst_address;
20845 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20847 if (unformat (i, "local_sa %d", &local_sa_id))
20849 else if (unformat (i, "remote_sa %d", &remote_sa_id))
20851 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
20853 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
20855 else if (unformat (i, "del"))
20859 clib_warning ("parse error '%U'", format_unformat_error, i);
20864 M (IPSEC_GRE_ADD_DEL_TUNNEL, mp);
20866 mp->local_sa_id = ntohl (local_sa_id);
20867 mp->remote_sa_id = ntohl (remote_sa_id);
20868 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
20869 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
20870 mp->is_add = is_add;
20878 api_punt (vat_main_t * vam)
20880 unformat_input_t *i = vam->input;
20888 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20890 if (unformat (i, "ip %d", &ipv))
20892 else if (unformat (i, "protocol %d", &protocol))
20894 else if (unformat (i, "port %d", &port))
20896 else if (unformat (i, "del"))
20900 clib_warning ("parse error '%U'", format_unformat_error, i);
20907 mp->is_add = (u8) is_add;
20908 mp->ipv = (u8) ipv;
20909 mp->l4_protocol = (u8) protocol;
20910 mp->l4_port = htons ((u16) port);
20917 static void vl_api_ipsec_gre_tunnel_details_t_handler
20918 (vl_api_ipsec_gre_tunnel_details_t * mp)
20920 vat_main_t *vam = &vat_main;
20922 print (vam->ofp, "%11d%15U%15U%14d%14d",
20923 ntohl (mp->sw_if_index),
20924 format_ip4_address, &mp->src_address,
20925 format_ip4_address, &mp->dst_address,
20926 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
20929 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
20930 (vl_api_ipsec_gre_tunnel_details_t * mp)
20932 vat_main_t *vam = &vat_main;
20933 vat_json_node_t *node = NULL;
20934 struct in_addr ip4;
20936 if (VAT_JSON_ARRAY != vam->json_tree.type)
20938 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20939 vat_json_init_array (&vam->json_tree);
20941 node = vat_json_array_add (&vam->json_tree);
20943 vat_json_init_object (node);
20944 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
20945 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
20946 vat_json_object_add_ip4 (node, "src_address", ip4);
20947 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
20948 vat_json_object_add_ip4 (node, "dst_address", ip4);
20949 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
20950 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
20954 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
20956 unformat_input_t *i = vam->input;
20957 vl_api_ipsec_gre_tunnel_dump_t *mp;
20958 vl_api_control_ping_t *mp_ping;
20960 u8 sw_if_index_set = 0;
20963 /* Parse args required to build the message */
20964 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20966 if (unformat (i, "sw_if_index %d", &sw_if_index))
20967 sw_if_index_set = 1;
20972 if (sw_if_index_set == 0)
20977 if (!vam->json_output)
20979 print (vam->ofp, "%11s%15s%15s%14s%14s",
20980 "sw_if_index", "src_address", "dst_address",
20981 "local_sa_id", "remote_sa_id");
20984 /* Get list of gre-tunnel interfaces */
20985 M (IPSEC_GRE_TUNNEL_DUMP, mp);
20987 mp->sw_if_index = htonl (sw_if_index);
20991 /* Use a control ping for synchronization */
20992 MPING (CONTROL_PING, mp_ping);
21000 api_delete_subif (vat_main_t * vam)
21002 unformat_input_t *i = vam->input;
21003 vl_api_delete_subif_t *mp;
21004 u32 sw_if_index = ~0;
21007 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21009 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21011 if (unformat (i, "sw_if_index %d", &sw_if_index))
21017 if (sw_if_index == ~0)
21019 errmsg ("missing sw_if_index");
21023 /* Construct the API message */
21024 M (DELETE_SUBIF, mp);
21025 mp->sw_if_index = ntohl (sw_if_index);
21032 #define foreach_pbb_vtr_op \
21033 _("disable", L2_VTR_DISABLED) \
21034 _("pop", L2_VTR_POP_2) \
21035 _("push", L2_VTR_PUSH_2)
21038 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
21040 unformat_input_t *i = vam->input;
21041 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
21042 u32 sw_if_index = ~0, vtr_op = ~0;
21043 u16 outer_tag = ~0;
21044 u8 dmac[6], smac[6];
21045 u8 dmac_set = 0, smac_set = 0;
21051 /* Shut up coverity */
21052 memset (dmac, 0, sizeof (dmac));
21053 memset (smac, 0, sizeof (smac));
21055 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21057 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21059 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21061 else if (unformat (i, "vtr_op %d", &vtr_op))
21063 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
21066 else if (unformat (i, "translate_pbb_stag"))
21068 if (unformat (i, "%d", &tmp))
21070 vtr_op = L2_VTR_TRANSLATE_2_1;
21076 ("translate_pbb_stag operation requires outer tag definition");
21080 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
21082 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
21084 else if (unformat (i, "sid %d", &sid))
21086 else if (unformat (i, "vlanid %d", &tmp))
21090 clib_warning ("parse error '%U'", format_unformat_error, i);
21095 if ((sw_if_index == ~0) || (vtr_op == ~0))
21097 errmsg ("missing sw_if_index or vtr operation");
21100 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
21101 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
21104 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
21108 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
21109 mp->sw_if_index = ntohl (sw_if_index);
21110 mp->vtr_op = ntohl (vtr_op);
21111 mp->outer_tag = ntohs (outer_tag);
21112 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
21113 clib_memcpy (mp->b_smac, smac, sizeof (smac));
21114 mp->b_vlanid = ntohs (vlanid);
21115 mp->i_sid = ntohl (sid);
21123 api_flow_classify_set_interface (vat_main_t * vam)
21125 unformat_input_t *i = vam->input;
21126 vl_api_flow_classify_set_interface_t *mp;
21128 int sw_if_index_set;
21129 u32 ip4_table_index = ~0;
21130 u32 ip6_table_index = ~0;
21134 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21136 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21137 sw_if_index_set = 1;
21138 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21139 sw_if_index_set = 1;
21140 else if (unformat (i, "del"))
21142 else if (unformat (i, "ip4-table %d", &ip4_table_index))
21144 else if (unformat (i, "ip6-table %d", &ip6_table_index))
21148 clib_warning ("parse error '%U'", format_unformat_error, i);
21153 if (sw_if_index_set == 0)
21155 errmsg ("missing interface name or sw_if_index");
21159 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
21161 mp->sw_if_index = ntohl (sw_if_index);
21162 mp->ip4_table_index = ntohl (ip4_table_index);
21163 mp->ip6_table_index = ntohl (ip6_table_index);
21164 mp->is_add = is_add;
21172 api_flow_classify_dump (vat_main_t * vam)
21174 unformat_input_t *i = vam->input;
21175 vl_api_flow_classify_dump_t *mp;
21176 vl_api_control_ping_t *mp_ping;
21177 u8 type = FLOW_CLASSIFY_N_TABLES;
21180 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
21184 errmsg ("classify table type must be specified");
21188 if (!vam->json_output)
21190 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
21193 M (FLOW_CLASSIFY_DUMP, mp);
21198 /* Use a control ping for synchronization */
21199 MPING (CONTROL_PING, mp_ping);
21202 /* Wait for a reply... */
21208 api_feature_enable_disable (vat_main_t * vam)
21210 unformat_input_t *i = vam->input;
21211 vl_api_feature_enable_disable_t *mp;
21213 u8 *feature_name = 0;
21214 u32 sw_if_index = ~0;
21218 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21220 if (unformat (i, "arc_name %s", &arc_name))
21222 else if (unformat (i, "feature_name %s", &feature_name))
21225 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21227 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21229 else if (unformat (i, "disable"))
21237 errmsg ("missing arc name");
21240 if (vec_len (arc_name) > 63)
21242 errmsg ("arc name too long");
21245 if (feature_name == 0)
21247 errmsg ("missing feature name");
21250 if (vec_len (feature_name) > 63)
21252 errmsg ("feature name too long");
21255 if (sw_if_index == ~0)
21257 errmsg ("missing interface name or sw_if_index");
21261 /* Construct the API message */
21262 M (FEATURE_ENABLE_DISABLE, mp);
21263 mp->sw_if_index = ntohl (sw_if_index);
21264 mp->enable = enable;
21265 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
21266 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
21267 vec_free (arc_name);
21268 vec_free (feature_name);
21276 api_sw_interface_tag_add_del (vat_main_t * vam)
21278 unformat_input_t *i = vam->input;
21279 vl_api_sw_interface_tag_add_del_t *mp;
21280 u32 sw_if_index = ~0;
21285 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21287 if (unformat (i, "tag %s", &tag))
21289 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21291 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21293 else if (unformat (i, "del"))
21299 if (sw_if_index == ~0)
21301 errmsg ("missing interface name or sw_if_index");
21305 if (enable && (tag == 0))
21307 errmsg ("no tag specified");
21311 /* Construct the API message */
21312 M (SW_INTERFACE_TAG_ADD_DEL, mp);
21313 mp->sw_if_index = ntohl (sw_if_index);
21314 mp->is_add = enable;
21316 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
21324 static void vl_api_l2_xconnect_details_t_handler
21325 (vl_api_l2_xconnect_details_t * mp)
21327 vat_main_t *vam = &vat_main;
21329 print (vam->ofp, "%15d%15d",
21330 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
21333 static void vl_api_l2_xconnect_details_t_handler_json
21334 (vl_api_l2_xconnect_details_t * mp)
21336 vat_main_t *vam = &vat_main;
21337 vat_json_node_t *node = NULL;
21339 if (VAT_JSON_ARRAY != vam->json_tree.type)
21341 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
21342 vat_json_init_array (&vam->json_tree);
21344 node = vat_json_array_add (&vam->json_tree);
21346 vat_json_init_object (node);
21347 vat_json_object_add_uint (node, "rx_sw_if_index",
21348 ntohl (mp->rx_sw_if_index));
21349 vat_json_object_add_uint (node, "tx_sw_if_index",
21350 ntohl (mp->tx_sw_if_index));
21354 api_l2_xconnect_dump (vat_main_t * vam)
21356 vl_api_l2_xconnect_dump_t *mp;
21357 vl_api_control_ping_t *mp_ping;
21360 if (!vam->json_output)
21362 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
21365 M (L2_XCONNECT_DUMP, mp);
21369 /* Use a control ping for synchronization */
21370 MPING (CONTROL_PING, mp_ping);
21378 api_sw_interface_set_mtu (vat_main_t * vam)
21380 unformat_input_t *i = vam->input;
21381 vl_api_sw_interface_set_mtu_t *mp;
21382 u32 sw_if_index = ~0;
21386 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21388 if (unformat (i, "mtu %d", &mtu))
21390 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21392 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21398 if (sw_if_index == ~0)
21400 errmsg ("missing interface name or sw_if_index");
21406 errmsg ("no mtu specified");
21410 /* Construct the API message */
21411 M (SW_INTERFACE_SET_MTU, mp);
21412 mp->sw_if_index = ntohl (sw_if_index);
21413 mp->mtu = ntohs ((u16) mtu);
21421 api_p2p_ethernet_add (vat_main_t * vam)
21423 unformat_input_t *i = vam->input;
21424 vl_api_p2p_ethernet_add_t *mp;
21425 u32 parent_if_index = ~0;
21431 memset (remote_mac, 0, sizeof (remote_mac));
21432 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21434 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
21436 else if (unformat (i, "sw_if_index %d", &parent_if_index))
21440 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
21442 else if (unformat (i, "sub_id %d", &sub_id))
21446 clib_warning ("parse error '%U'", format_unformat_error, i);
21451 if (parent_if_index == ~0)
21453 errmsg ("missing interface name or sw_if_index");
21458 errmsg ("missing remote mac address");
21463 errmsg ("missing sub-interface id");
21467 M (P2P_ETHERNET_ADD, mp);
21468 mp->parent_if_index = ntohl (parent_if_index);
21469 mp->subif_id = ntohl (sub_id);
21470 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
21478 api_p2p_ethernet_del (vat_main_t * vam)
21480 unformat_input_t *i = vam->input;
21481 vl_api_p2p_ethernet_del_t *mp;
21482 u32 parent_if_index = ~0;
21487 memset (remote_mac, 0, sizeof (remote_mac));
21488 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21490 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
21492 else if (unformat (i, "sw_if_index %d", &parent_if_index))
21496 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
21500 clib_warning ("parse error '%U'", format_unformat_error, i);
21505 if (parent_if_index == ~0)
21507 errmsg ("missing interface name or sw_if_index");
21512 errmsg ("missing remote mac address");
21516 M (P2P_ETHERNET_DEL, mp);
21517 mp->parent_if_index = ntohl (parent_if_index);
21518 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
21526 api_lldp_config (vat_main_t * vam)
21528 unformat_input_t *i = vam->input;
21529 vl_api_lldp_config_t *mp;
21531 int tx_interval = 0;
21532 u8 *sys_name = NULL;
21535 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21537 if (unformat (i, "system-name %s", &sys_name))
21539 else if (unformat (i, "tx-hold %d", &tx_hold))
21541 else if (unformat (i, "tx-interval %d", &tx_interval))
21545 clib_warning ("parse error '%U'", format_unformat_error, i);
21550 vec_add1 (sys_name, 0);
21552 M (LLDP_CONFIG, mp);
21553 mp->tx_hold = htonl (tx_hold);
21554 mp->tx_interval = htonl (tx_interval);
21555 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
21556 vec_free (sys_name);
21564 api_sw_interface_set_lldp (vat_main_t * vam)
21566 unformat_input_t *i = vam->input;
21567 vl_api_sw_interface_set_lldp_t *mp;
21568 u32 sw_if_index = ~0;
21570 u8 *port_desc = NULL, *mgmt_oid = NULL;
21571 ip4_address_t ip4_addr;
21572 ip6_address_t ip6_addr;
21575 memset (&ip4_addr, 0, sizeof (ip4_addr));
21576 memset (&ip6_addr, 0, sizeof (ip6_addr));
21578 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21580 if (unformat (i, "disable"))
21583 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21585 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21587 else if (unformat (i, "port-desc %s", &port_desc))
21589 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
21591 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
21593 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
21599 if (sw_if_index == ~0)
21601 errmsg ("missing interface name or sw_if_index");
21605 /* Construct the API message */
21606 vec_add1 (port_desc, 0);
21607 vec_add1 (mgmt_oid, 0);
21608 M (SW_INTERFACE_SET_LLDP, mp);
21609 mp->sw_if_index = ntohl (sw_if_index);
21610 mp->enable = enable;
21611 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
21612 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
21613 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
21614 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
21615 vec_free (port_desc);
21616 vec_free (mgmt_oid);
21624 api_tcp_configure_src_addresses (vat_main_t * vam)
21626 vl_api_tcp_configure_src_addresses_t *mp;
21627 unformat_input_t *i = vam->input;
21628 ip4_address_t v4first, v4last;
21629 ip6_address_t v6first, v6last;
21634 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21636 if (unformat (i, "%U - %U",
21637 unformat_ip4_address, &v4first,
21638 unformat_ip4_address, &v4last))
21642 errmsg ("one range per message (range already set)");
21647 else if (unformat (i, "%U - %U",
21648 unformat_ip6_address, &v6first,
21649 unformat_ip6_address, &v6last))
21653 errmsg ("one range per message (range already set)");
21658 else if (unformat (i, "vrf %d", &vrf_id))
21664 if (range_set == 0)
21666 errmsg ("address range not set");
21670 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
21671 mp->vrf_id = ntohl (vrf_id);
21673 if (range_set == 2)
21676 clib_memcpy (mp->first_address, &v6first, sizeof (v6first));
21677 clib_memcpy (mp->last_address, &v6last, sizeof (v6last));
21682 clib_memcpy (mp->first_address, &v4first, sizeof (v4first));
21683 clib_memcpy (mp->last_address, &v4last, sizeof (v4last));
21690 static void vl_api_app_namespace_add_del_reply_t_handler
21691 (vl_api_app_namespace_add_del_reply_t * mp)
21693 vat_main_t *vam = &vat_main;
21694 i32 retval = ntohl (mp->retval);
21695 if (vam->async_mode)
21697 vam->async_errors += (retval < 0);
21701 vam->retval = retval;
21703 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
21704 vam->result_ready = 1;
21708 static void vl_api_app_namespace_add_del_reply_t_handler_json
21709 (vl_api_app_namespace_add_del_reply_t * mp)
21711 vat_main_t *vam = &vat_main;
21712 vat_json_node_t node;
21714 vat_json_init_object (&node);
21715 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
21716 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
21718 vat_json_print (vam->ofp, &node);
21719 vat_json_free (&node);
21721 vam->retval = ntohl (mp->retval);
21722 vam->result_ready = 1;
21726 api_app_namespace_add_del (vat_main_t * vam)
21728 vl_api_app_namespace_add_del_t *mp;
21729 unformat_input_t *i = vam->input;
21730 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
21731 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
21735 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21737 if (unformat (i, "id %_%v%_", &ns_id))
21739 else if (unformat (i, "secret %lu", &secret))
21741 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21742 sw_if_index_set = 1;
21743 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
21745 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
21750 if (!ns_id || !secret_set || !sw_if_index_set)
21752 errmsg ("namespace id, secret and sw_if_index must be set");
21755 if (vec_len (ns_id) > 64)
21757 errmsg ("namespace id too long");
21760 M (APP_NAMESPACE_ADD_DEL, mp);
21762 clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
21763 mp->namespace_id_len = vec_len (ns_id);
21764 mp->secret = clib_host_to_net_u64 (secret);
21765 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
21766 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
21767 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
21775 api_memfd_segment_create (vat_main_t * vam)
21777 #if VPP_API_TEST_BUILTIN == 0
21778 unformat_input_t *i = vam->input;
21779 vl_api_memfd_segment_create_t *mp;
21780 u64 size = 64 << 20;
21783 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21785 if (unformat (i, "size %U", unformat_memory_size, &size))
21791 M (MEMFD_SEGMENT_CREATE, mp);
21792 mp->requested_size = size;
21798 errmsg ("memfd_segment_create (builtin) not supported");
21804 api_dns_enable_disable (vat_main_t * vam)
21806 unformat_input_t *line_input = vam->input;
21807 vl_api_dns_enable_disable_t *mp;
21808 u8 enable_disable = 1;
21811 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21813 if (unformat (line_input, "disable"))
21814 enable_disable = 0;
21815 if (unformat (line_input, "enable"))
21816 enable_disable = 1;
21821 /* Construct the API message */
21822 M (DNS_ENABLE_DISABLE, mp);
21823 mp->enable = enable_disable;
21827 /* Wait for the reply */
21833 api_dns_resolve_name (vat_main_t * vam)
21835 unformat_input_t *line_input = vam->input;
21836 vl_api_dns_resolve_name_t *mp;
21840 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21842 if (unformat (line_input, "%s", &name))
21848 if (vec_len (name) > 127)
21850 errmsg ("name too long");
21854 /* Construct the API message */
21855 M (DNS_RESOLVE_NAME, mp);
21856 memcpy (mp->name, name, vec_len (name));
21861 /* Wait for the reply */
21867 api_dns_resolve_ip (vat_main_t * vam)
21869 unformat_input_t *line_input = vam->input;
21870 vl_api_dns_resolve_ip_t *mp;
21872 ip4_address_t addr4;
21873 ip6_address_t addr6;
21876 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21878 if (unformat (line_input, "%U", unformat_ip6_address, &addr6))
21880 else if (unformat (line_input, "%U", unformat_ip4_address, &addr4))
21888 errmsg ("missing address");
21892 /* Construct the API message */
21893 M (DNS_RESOLVE_IP, mp);
21894 mp->is_ip6 = is_ip6;
21896 memcpy (mp->address, &addr6, sizeof (addr6));
21898 memcpy (mp->address, &addr4, sizeof (addr4));
21902 /* Wait for the reply */
21908 api_dns_name_server_add_del (vat_main_t * vam)
21910 unformat_input_t *i = vam->input;
21911 vl_api_dns_name_server_add_del_t *mp;
21913 ip6_address_t ip6_server;
21914 ip4_address_t ip4_server;
21919 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21921 if (unformat (i, "%U", unformat_ip6_address, &ip6_server))
21923 else if (unformat (i, "%U", unformat_ip4_address, &ip4_server))
21925 else if (unformat (i, "del"))
21929 clib_warning ("parse error '%U'", format_unformat_error, i);
21934 if (ip4_set && ip6_set)
21936 errmsg ("Only one server address allowed per message");
21939 if ((ip4_set + ip6_set) == 0)
21941 errmsg ("Server address required");
21945 /* Construct the API message */
21946 M (DNS_NAME_SERVER_ADD_DEL, mp);
21950 memcpy (mp->server_address, &ip6_server, sizeof (ip6_address_t));
21955 memcpy (mp->server_address, &ip4_server, sizeof (ip4_address_t));
21959 mp->is_add = is_add;
21964 /* Wait for a reply, return good/bad news */
21970 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
21972 vat_main_t *vam = &vat_main;
21977 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
21978 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
21979 mp->scope, format_ip4_address, &mp->lcl_ip, mp->lcl_plen,
21980 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
21981 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
21982 clib_net_to_host_u32 (mp->action_index), mp->tag);
21987 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
21988 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
21989 mp->scope, format_ip6_address, &mp->lcl_ip, mp->lcl_plen,
21990 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
21991 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
21992 clib_net_to_host_u32 (mp->action_index), mp->tag);
21997 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
22000 vat_main_t *vam = &vat_main;
22001 vat_json_node_t *node = NULL;
22002 struct in6_addr ip6;
22003 struct in_addr ip4;
22005 if (VAT_JSON_ARRAY != vam->json_tree.type)
22007 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
22008 vat_json_init_array (&vam->json_tree);
22010 node = vat_json_array_add (&vam->json_tree);
22011 vat_json_init_object (node);
22013 vat_json_object_add_uint (node, "is_ip4", mp->is_ip4 ? 1 : 0);
22014 vat_json_object_add_uint (node, "appns_index",
22015 clib_net_to_host_u32 (mp->appns_index));
22016 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
22017 vat_json_object_add_uint (node, "scope", mp->scope);
22018 vat_json_object_add_uint (node, "action_index",
22019 clib_net_to_host_u32 (mp->action_index));
22020 vat_json_object_add_uint (node, "lcl_port",
22021 clib_net_to_host_u16 (mp->lcl_port));
22022 vat_json_object_add_uint (node, "rmt_port",
22023 clib_net_to_host_u16 (mp->rmt_port));
22024 vat_json_object_add_uint (node, "lcl_plen", mp->lcl_plen);
22025 vat_json_object_add_uint (node, "rmt_plen", mp->rmt_plen);
22026 vat_json_object_add_string_copy (node, "tag", mp->tag);
22029 clib_memcpy (&ip4, mp->lcl_ip, sizeof (ip4));
22030 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
22031 clib_memcpy (&ip4, mp->rmt_ip, sizeof (ip4));
22032 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
22036 clib_memcpy (&ip6, mp->lcl_ip, sizeof (ip6));
22037 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
22038 clib_memcpy (&ip6, mp->rmt_ip, sizeof (ip6));
22039 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
22044 api_session_rule_add_del (vat_main_t * vam)
22046 vl_api_session_rule_add_del_t *mp;
22047 unformat_input_t *i = vam->input;
22048 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
22049 u32 appns_index = 0, scope = 0;
22050 ip4_address_t lcl_ip4, rmt_ip4;
22051 ip6_address_t lcl_ip6, rmt_ip6;
22052 u8 is_ip4 = 1, conn_set = 0;
22053 u8 is_add = 1, *tag = 0;
22056 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22058 if (unformat (i, "del"))
22060 else if (unformat (i, "add"))
22062 else if (unformat (i, "proto tcp"))
22064 else if (unformat (i, "proto udp"))
22066 else if (unformat (i, "appns %d", &appns_index))
22068 else if (unformat (i, "scope %d", &scope))
22070 else if (unformat (i, "tag %_%v%_", &tag))
22074 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
22075 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
22083 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
22084 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
22090 else if (unformat (i, "action %d", &action))
22095 if (proto == ~0 || !conn_set || action == ~0)
22097 errmsg ("transport proto, connection and action must be set");
22103 errmsg ("scope should be 0-3");
22107 M (SESSION_RULE_ADD_DEL, mp);
22109 mp->is_ip4 = is_ip4;
22110 mp->transport_proto = proto;
22111 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
22112 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
22113 mp->lcl_plen = lcl_plen;
22114 mp->rmt_plen = rmt_plen;
22115 mp->action_index = clib_host_to_net_u32 (action);
22116 mp->appns_index = clib_host_to_net_u32 (appns_index);
22118 mp->is_add = is_add;
22121 clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
22122 clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
22126 clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
22127 clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
22131 clib_memcpy (mp->tag, tag, vec_len (tag));
22141 api_session_rules_dump (vat_main_t * vam)
22143 vl_api_session_rules_dump_t *mp;
22144 vl_api_control_ping_t *mp_ping;
22147 if (!vam->json_output)
22149 print (vam->ofp, "%=20s", "Session Rules");
22152 M (SESSION_RULES_DUMP, mp);
22156 /* Use a control ping for synchronization */
22157 MPING (CONTROL_PING, mp_ping);
22160 /* Wait for a reply... */
22166 api_ip_container_proxy_add_del (vat_main_t * vam)
22168 vl_api_ip_container_proxy_add_del_t *mp;
22169 unformat_input_t *i = vam->input;
22170 u32 plen = ~0, sw_if_index = ~0;
22177 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22179 if (unformat (i, "del"))
22181 else if (unformat (i, "add"))
22183 if (unformat (i, "%U", unformat_ip4_address, &ip4))
22188 else if (unformat (i, "%U", unformat_ip6_address, &ip6))
22193 else if (unformat (i, "sw_if_index %u", &sw_if_index))
22198 if (sw_if_index == ~0 || plen == ~0)
22200 errmsg ("address and sw_if_index must be set");
22204 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
22206 mp->is_ip4 = is_ip4;
22207 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
22209 mp->is_add = is_add;
22211 clib_memcpy (mp->ip, &ip4, sizeof (ip4));
22213 clib_memcpy (mp->ip, &ip6, sizeof (ip6));
22221 q_or_quit (vat_main_t * vam)
22223 #if VPP_API_TEST_BUILTIN == 0
22224 longjmp (vam->jump_buf, 1);
22226 return 0; /* not so much */
22230 q (vat_main_t * vam)
22232 return q_or_quit (vam);
22236 quit (vat_main_t * vam)
22238 return q_or_quit (vam);
22242 comment (vat_main_t * vam)
22248 cmd_cmp (void *a1, void *a2)
22253 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
22257 help (vat_main_t * vam)
22262 unformat_input_t *i = vam->input;
22265 if (unformat (i, "%s", &name))
22269 vec_add1 (name, 0);
22271 hs = hash_get_mem (vam->help_by_name, name);
22273 print (vam->ofp, "usage: %s %s", name, hs[0]);
22275 print (vam->ofp, "No such msg / command '%s'", name);
22280 print (vam->ofp, "Help is available for the following:");
22283 hash_foreach_pair (p, vam->function_by_name,
22285 vec_add1 (cmds, (u8 *)(p->key));
22289 vec_sort_with_function (cmds, cmd_cmp);
22291 for (j = 0; j < vec_len (cmds); j++)
22292 print (vam->ofp, "%s", cmds[j]);
22299 set (vat_main_t * vam)
22301 u8 *name = 0, *value = 0;
22302 unformat_input_t *i = vam->input;
22304 if (unformat (i, "%s", &name))
22306 /* The input buffer is a vector, not a string. */
22307 value = vec_dup (i->buffer);
22308 vec_delete (value, i->index, 0);
22309 /* Almost certainly has a trailing newline */
22310 if (value[vec_len (value) - 1] == '\n')
22311 value[vec_len (value) - 1] = 0;
22312 /* Make sure it's a proper string, one way or the other */
22313 vec_add1 (value, 0);
22314 (void) clib_macro_set_value (&vam->macro_main,
22315 (char *) name, (char *) value);
22318 errmsg ("usage: set <name> <value>");
22326 unset (vat_main_t * vam)
22330 if (unformat (vam->input, "%s", &name))
22331 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
22332 errmsg ("unset: %s wasn't set", name);
22345 macro_sort_cmp (void *a1, void *a2)
22347 macro_sort_t *s1 = a1;
22348 macro_sort_t *s2 = a2;
22350 return strcmp ((char *) (s1->name), (char *) (s2->name));
22354 dump_macro_table (vat_main_t * vam)
22356 macro_sort_t *sort_me = 0, *sm;
22361 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
22363 vec_add2 (sort_me, sm, 1);
22364 sm->name = (u8 *)(p->key);
22365 sm->value = (u8 *) (p->value[0]);
22369 vec_sort_with_function (sort_me, macro_sort_cmp);
22371 if (vec_len (sort_me))
22372 print (vam->ofp, "%-15s%s", "Name", "Value");
22374 print (vam->ofp, "The macro table is empty...");
22376 for (i = 0; i < vec_len (sort_me); i++)
22377 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
22382 dump_node_table (vat_main_t * vam)
22385 vlib_node_t *node, *next_node;
22387 if (vec_len (vam->graph_nodes) == 0)
22389 print (vam->ofp, "Node table empty, issue get_node_graph...");
22393 for (i = 0; i < vec_len (vam->graph_nodes); i++)
22395 node = vam->graph_nodes[i];
22396 print (vam->ofp, "[%d] %s", i, node->name);
22397 for (j = 0; j < vec_len (node->next_nodes); j++)
22399 if (node->next_nodes[j] != ~0)
22401 next_node = vam->graph_nodes[node->next_nodes[j]];
22402 print (vam->ofp, " [%d] %s", j, next_node->name);
22410 value_sort_cmp (void *a1, void *a2)
22412 name_sort_t *n1 = a1;
22413 name_sort_t *n2 = a2;
22415 if (n1->value < n2->value)
22417 if (n1->value > n2->value)
22424 dump_msg_api_table (vat_main_t * vam)
22426 api_main_t *am = &api_main;
22427 name_sort_t *nses = 0, *ns;
22432 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
22434 vec_add2 (nses, ns, 1);
22435 ns->name = (u8 *)(hp->key);
22436 ns->value = (u32) hp->value[0];
22440 vec_sort_with_function (nses, value_sort_cmp);
22442 for (i = 0; i < vec_len (nses); i++)
22443 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
22449 get_msg_id (vat_main_t * vam)
22454 if (unformat (vam->input, "%s", &name_and_crc))
22456 message_index = vl_api_get_msg_index (name_and_crc);
22457 if (message_index == ~0)
22459 print (vam->ofp, " '%s' not found", name_and_crc);
22462 print (vam->ofp, " '%s' has message index %d",
22463 name_and_crc, message_index);
22466 errmsg ("name_and_crc required...");
22471 search_node_table (vat_main_t * vam)
22473 unformat_input_t *line_input = vam->input;
22476 vlib_node_t *node, *next_node;
22479 if (vam->graph_node_index_by_name == 0)
22481 print (vam->ofp, "Node table empty, issue get_node_graph...");
22485 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
22487 if (unformat (line_input, "%s", &node_to_find))
22489 vec_add1 (node_to_find, 0);
22490 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
22493 print (vam->ofp, "%s not found...", node_to_find);
22496 node = vam->graph_nodes[p[0]];
22497 print (vam->ofp, "[%d] %s", p[0], node->name);
22498 for (j = 0; j < vec_len (node->next_nodes); j++)
22500 if (node->next_nodes[j] != ~0)
22502 next_node = vam->graph_nodes[node->next_nodes[j]];
22503 print (vam->ofp, " [%d] %s", j, next_node->name);
22510 clib_warning ("parse error '%U'", format_unformat_error,
22516 vec_free (node_to_find);
22525 script (vat_main_t * vam)
22527 #if (VPP_API_TEST_BUILTIN==0)
22529 char *save_current_file;
22530 unformat_input_t save_input;
22531 jmp_buf save_jump_buf;
22532 u32 save_line_number;
22534 FILE *new_fp, *save_ifp;
22536 if (unformat (vam->input, "%s", &s))
22538 new_fp = fopen ((char *) s, "r");
22541 errmsg ("Couldn't open script file %s", s);
22548 errmsg ("Missing script name");
22552 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
22553 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
22554 save_ifp = vam->ifp;
22555 save_line_number = vam->input_line_number;
22556 save_current_file = (char *) vam->current_file;
22558 vam->input_line_number = 0;
22560 vam->current_file = s;
22563 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
22564 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
22565 vam->ifp = save_ifp;
22566 vam->input_line_number = save_line_number;
22567 vam->current_file = (u8 *) save_current_file;
22572 clib_warning ("use the exec command...");
22578 echo (vat_main_t * vam)
22580 print (vam->ofp, "%v", vam->input->buffer);
22584 /* List of API message constructors, CLI names map to api_xxx */
22585 #define foreach_vpe_api_msg \
22586 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
22587 _(sw_interface_dump,"") \
22588 _(sw_interface_set_flags, \
22589 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
22590 _(sw_interface_add_del_address, \
22591 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
22592 _(sw_interface_set_rx_mode, \
22593 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
22594 _(sw_interface_set_table, \
22595 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
22596 _(sw_interface_set_mpls_enable, \
22597 "<intfc> | sw_if_index [disable | dis]") \
22598 _(sw_interface_set_vpath, \
22599 "<intfc> | sw_if_index <id> enable | disable") \
22600 _(sw_interface_set_vxlan_bypass, \
22601 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
22602 _(sw_interface_set_geneve_bypass, \
22603 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
22604 _(sw_interface_set_l2_xconnect, \
22605 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
22606 "enable | disable") \
22607 _(sw_interface_set_l2_bridge, \
22608 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
22609 "[shg <split-horizon-group>] [bvi]\n" \
22610 "enable | disable") \
22611 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
22612 _(bridge_domain_add_del, \
22613 "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") \
22614 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
22616 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
22617 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
22618 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
22620 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
22622 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
22624 "tapname <name> mac <mac-addr> | random-mac [tag <string>]") \
22626 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
22628 "<vpp-if-name> | sw_if_index <id>") \
22629 _(sw_interface_tap_dump, "") \
22631 "name <name> [hw-addr <mac-addr>] [host-ns <name>] [rx-ring-size <num> [tx-ring-size <num>]") \
22633 "<vpp-if-name> | sw_if_index <id>") \
22634 _(sw_interface_tap_v2_dump, "") \
22635 _(ip_table_add_del, \
22636 "table-id <n> [ipv6]\n") \
22637 _(ip_add_del_route, \
22638 "<addr>/<mask> via <addr> [table-id <n>]\n" \
22639 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
22640 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
22641 "[multipath] [count <n>]") \
22642 _(ip_mroute_add_del, \
22643 "<src> <grp>/<mask> [table-id <n>]\n" \
22644 "[<intfc> | sw_if_index <id>] [local] [del]") \
22645 _(mpls_table_add_del, \
22646 "table-id <n>\n") \
22647 _(mpls_route_add_del, \
22648 "<label> <eos> via <addr> [table-id <n>]\n" \
22649 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
22650 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
22651 "[multipath] [count <n>]") \
22652 _(mpls_ip_bind_unbind, \
22653 "<label> <addr/len>") \
22654 _(mpls_tunnel_add_del, \
22655 " via <addr> [table-id <n>]\n" \
22656 "sw_if_index <id>] [l2] [del]") \
22657 _(bier_table_add_del, \
22658 "<label> <sub-domain> <set> <bsl> [del]") \
22659 _(bier_route_add_del, \
22660 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
22661 "[<intfc> | sw_if_index <id>]" \
22662 "[weight <n>] [del] [multipath]") \
22663 _(proxy_arp_add_del, \
22664 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
22665 _(proxy_arp_intfc_enable_disable, \
22666 "<intfc> | sw_if_index <id> enable | disable") \
22667 _(sw_interface_set_unnumbered, \
22668 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
22669 _(ip_neighbor_add_del, \
22670 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
22671 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
22672 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
22673 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
22674 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
22675 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
22676 "[outer_vlan_id_any][inner_vlan_id_any]") \
22677 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
22678 _(reset_fib, "vrf <n> [ipv6]") \
22679 _(dhcp_proxy_config, \
22680 "svr <v46-address> src <v46-address>\n" \
22681 "rx_vrf_id <nn> server_vrf_id <nn> [del]") \
22682 _(dhcp_proxy_set_vss, \
22683 "tbl_id <n> [fib_id <n> oui <n> | vpn_ascii_id <text>] [ipv6] [del]") \
22684 _(dhcp_proxy_dump, "ip6") \
22685 _(dhcp_client_config, \
22686 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
22687 _(set_ip_flow_hash, \
22688 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
22689 _(sw_interface_ip6_enable_disable, \
22690 "<intfc> | sw_if_index <id> enable | disable") \
22691 _(sw_interface_ip6_set_link_local_address, \
22692 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
22693 _(ip6nd_proxy_add_del, \
22694 "<intfc> | sw_if_index <id> <ip6-address>") \
22695 _(ip6nd_proxy_dump, "") \
22696 _(sw_interface_ip6nd_ra_prefix, \
22697 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
22698 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
22699 "[nolink] [isno]") \
22700 _(sw_interface_ip6nd_ra_config, \
22701 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
22702 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
22703 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
22704 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
22705 _(l2_patch_add_del, \
22706 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
22707 "enable | disable") \
22708 _(sr_localsid_add_del, \
22709 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
22710 "fib-table <num> (end.psp) sw_if_index <num>") \
22711 _(classify_add_del_table, \
22712 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
22713 " [del] [del-chain] mask <mask-value>\n" \
22714 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
22715 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
22716 _(classify_add_del_session, \
22717 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
22718 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
22719 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
22720 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
22721 _(classify_set_interface_ip_table, \
22722 "<intfc> | sw_if_index <nn> table <nn>") \
22723 _(classify_set_interface_l2_tables, \
22724 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22725 " [other-table <nn>]") \
22726 _(get_node_index, "node <node-name") \
22727 _(add_node_next, "node <node-name> next <next-node-name>") \
22728 _(l2tpv3_create_tunnel, \
22729 "client_address <ip6-addr> our_address <ip6-addr>\n" \
22730 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
22731 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
22732 _(l2tpv3_set_tunnel_cookies, \
22733 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
22734 "[new_remote_cookie <nn>]\n") \
22735 _(l2tpv3_interface_enable_disable, \
22736 "<intfc> | sw_if_index <nn> enable | disable") \
22737 _(l2tpv3_set_lookup_key, \
22738 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
22739 _(sw_if_l2tpv3_tunnel_dump, "") \
22740 _(vxlan_add_del_tunnel, \
22741 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
22742 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22743 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
22744 _(geneve_add_del_tunnel, \
22745 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
22746 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22747 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
22748 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22749 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22750 _(gre_add_del_tunnel, \
22751 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [teb] [del]\n") \
22752 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22753 _(l2_fib_clear_table, "") \
22754 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
22755 _(l2_interface_vlan_tag_rewrite, \
22756 "<intfc> | sw_if_index <nn> \n" \
22757 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
22758 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
22759 _(create_vhost_user_if, \
22760 "socket <filename> [server] [renumber <dev_instance>] " \
22761 "[mac <mac_address>]") \
22762 _(modify_vhost_user_if, \
22763 "<intfc> | sw_if_index <nn> socket <filename>\n" \
22764 "[server] [renumber <dev_instance>]") \
22765 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
22766 _(sw_interface_vhost_user_dump, "") \
22767 _(show_version, "") \
22768 _(vxlan_gpe_add_del_tunnel, \
22769 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
22770 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22771 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
22772 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
22773 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22774 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
22775 _(interface_name_renumber, \
22776 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
22777 _(input_acl_set_interface, \
22778 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22779 " [l2-table <nn>] [del]") \
22780 _(want_ip4_arp_events, "address <ip4-address> [del]") \
22781 _(want_ip6_nd_events, "address <ip6-address> [del]") \
22782 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
22783 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
22784 _(ip_dump, "ipv4 | ipv6") \
22785 _(ipsec_spd_add_del, "spd_id <n> [del]") \
22786 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
22788 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
22789 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
22790 " integ_alg <alg> integ_key <hex>") \
22791 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
22792 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
22793 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
22794 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
22795 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
22796 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
22797 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
22798 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
22799 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n") \
22800 _(ipsec_sa_dump, "[sa_id <n>]") \
22801 _(ipsec_tunnel_if_set_key, "<intfc> <local|remote> <crypto|integ>\n" \
22802 " <alg> <hex>\n") \
22803 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
22804 _(ikev2_profile_add_del, "name <profile_name> [del]") \
22805 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
22806 "(auth_data 0x<data> | auth_data <data>)") \
22807 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
22808 "(id_data 0x<data> | id_data <data>) (local|remote)") \
22809 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
22810 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
22811 "(local|remote)") \
22812 _(ikev2_set_local_key, "file <absolute_file_path>") \
22813 _(ikev2_set_responder, "<profile_name> interface <interface> address <addr>") \
22814 _(ikev2_set_ike_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
22815 _(ikev2_set_esp_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
22816 _(ikev2_set_sa_lifetime, "<profile_name> <seconds> <jitter> <handover> <max bytes>") \
22817 _(ikev2_initiate_sa_init, "<profile_name>") \
22818 _(ikev2_initiate_del_ike_sa, "<ispi>") \
22819 _(ikev2_initiate_del_child_sa, "<ispi>") \
22820 _(ikev2_initiate_rekey_child_sa, "<ispi>") \
22821 _(delete_loopback,"sw_if_index <nn>") \
22822 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
22823 _(map_add_domain, \
22824 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
22825 "ip6-src <ip6addr> " \
22826 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
22827 _(map_del_domain, "index <n>") \
22828 _(map_add_del_rule, \
22829 "index <n> psid <n> dst <ip6addr> [del]") \
22830 _(map_domain_dump, "") \
22831 _(map_rule_dump, "index <map-domain>") \
22832 _(want_interface_events, "enable|disable") \
22833 _(want_stats,"enable|disable") \
22834 _(get_first_msg_id, "client <name>") \
22835 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
22836 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
22837 "fib-id <nn> [ip4][ip6][default]") \
22838 _(get_node_graph, " ") \
22839 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
22840 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
22841 _(ioam_disable, "") \
22842 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
22843 " sw_if_index <sw_if_index> p <priority> " \
22844 "w <weight>] [del]") \
22845 _(one_add_del_locator, "locator-set <locator_name> " \
22846 "iface <intf> | sw_if_index <sw_if_index> " \
22847 "p <priority> w <weight> [del]") \
22848 _(one_add_del_local_eid,"vni <vni> eid " \
22849 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22850 "locator-set <locator_name> [del]" \
22851 "[key-id sha1|sha256 secret-key <secret-key>]")\
22852 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
22853 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
22854 _(one_enable_disable, "enable|disable") \
22855 _(one_map_register_enable_disable, "enable|disable") \
22856 _(one_map_register_fallback_threshold, "<value>") \
22857 _(one_rloc_probe_enable_disable, "enable|disable") \
22858 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22860 "rloc <locator> p <prio> " \
22861 "w <weight> [rloc <loc> ... ] " \
22862 "action <action> [del-all]") \
22863 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22865 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22866 _(one_use_petr, "ip-address> | disable") \
22867 _(one_map_request_mode, "src-dst|dst-only") \
22868 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22869 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22870 _(one_locator_set_dump, "[local | remote]") \
22871 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
22872 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22873 "[local] | [remote]") \
22874 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
22875 _(one_ndp_bd_get, "") \
22876 _(one_ndp_entries_get, "bd <bridge-domain>") \
22877 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
22878 _(one_l2_arp_bd_get, "") \
22879 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
22880 _(one_stats_enable_disable, "enable|disalbe") \
22881 _(show_one_stats_enable_disable, "") \
22882 _(one_eid_table_vni_dump, "") \
22883 _(one_eid_table_map_dump, "l2|l3") \
22884 _(one_map_resolver_dump, "") \
22885 _(one_map_server_dump, "") \
22886 _(one_adjacencies_get, "vni <vni>") \
22887 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
22888 _(show_one_rloc_probe_state, "") \
22889 _(show_one_map_register_state, "") \
22890 _(show_one_status, "") \
22891 _(one_stats_dump, "") \
22892 _(one_stats_flush, "") \
22893 _(one_get_map_request_itr_rlocs, "") \
22894 _(one_map_register_set_ttl, "<ttl>") \
22895 _(one_set_transport_protocol, "udp|api") \
22896 _(one_get_transport_protocol, "") \
22897 _(one_enable_disable_xtr_mode, "enable|disable") \
22898 _(one_show_xtr_mode, "") \
22899 _(one_enable_disable_pitr_mode, "enable|disable") \
22900 _(one_show_pitr_mode, "") \
22901 _(one_enable_disable_petr_mode, "enable|disable") \
22902 _(one_show_petr_mode, "") \
22903 _(show_one_nsh_mapping, "") \
22904 _(show_one_pitr, "") \
22905 _(show_one_use_petr, "") \
22906 _(show_one_map_request_mode, "") \
22907 _(show_one_map_register_ttl, "") \
22908 _(show_one_map_register_fallback_threshold, "") \
22909 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
22910 " sw_if_index <sw_if_index> p <priority> " \
22911 "w <weight>] [del]") \
22912 _(lisp_add_del_locator, "locator-set <locator_name> " \
22913 "iface <intf> | sw_if_index <sw_if_index> " \
22914 "p <priority> w <weight> [del]") \
22915 _(lisp_add_del_local_eid,"vni <vni> eid " \
22916 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22917 "locator-set <locator_name> [del]" \
22918 "[key-id sha1|sha256 secret-key <secret-key>]") \
22919 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
22920 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
22921 _(lisp_enable_disable, "enable|disable") \
22922 _(lisp_map_register_enable_disable, "enable|disable") \
22923 _(lisp_rloc_probe_enable_disable, "enable|disable") \
22924 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22926 "rloc <locator> p <prio> " \
22927 "w <weight> [rloc <loc> ... ] " \
22928 "action <action> [del-all]") \
22929 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22931 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22932 _(lisp_use_petr, "<ip-address> | disable") \
22933 _(lisp_map_request_mode, "src-dst|dst-only") \
22934 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22935 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22936 _(lisp_locator_set_dump, "[local | remote]") \
22937 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
22938 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22939 "[local] | [remote]") \
22940 _(lisp_eid_table_vni_dump, "") \
22941 _(lisp_eid_table_map_dump, "l2|l3") \
22942 _(lisp_map_resolver_dump, "") \
22943 _(lisp_map_server_dump, "") \
22944 _(lisp_adjacencies_get, "vni <vni>") \
22945 _(gpe_fwd_entry_vnis_get, "") \
22946 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
22947 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
22948 "[table <table-id>]") \
22949 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
22950 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
22951 _(gpe_set_encap_mode, "lisp|vxlan") \
22952 _(gpe_get_encap_mode, "") \
22953 _(lisp_gpe_add_del_iface, "up|down") \
22954 _(lisp_gpe_enable_disable, "enable|disable") \
22955 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
22956 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
22957 _(show_lisp_rloc_probe_state, "") \
22958 _(show_lisp_map_register_state, "") \
22959 _(show_lisp_status, "") \
22960 _(lisp_get_map_request_itr_rlocs, "") \
22961 _(show_lisp_pitr, "") \
22962 _(show_lisp_use_petr, "") \
22963 _(show_lisp_map_request_mode, "") \
22964 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
22965 _(af_packet_delete, "name <host interface name>") \
22966 _(policer_add_del, "name <policer name> <params> [del]") \
22967 _(policer_dump, "[name <policer name>]") \
22968 _(policer_classify_set_interface, \
22969 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22970 " [l2-table <nn>] [del]") \
22971 _(policer_classify_dump, "type [ip4|ip6|l2]") \
22972 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
22973 "[master|slave]") \
22974 _(netmap_delete, "name <interface name>") \
22975 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
22976 _(mpls_fib_dump, "") \
22977 _(classify_table_ids, "") \
22978 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
22979 _(classify_table_info, "table_id <nn>") \
22980 _(classify_session_dump, "table_id <nn>") \
22981 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
22982 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
22983 "[template_interval <nn>] [udp_checksum]") \
22984 _(ipfix_exporter_dump, "") \
22985 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
22986 _(ipfix_classify_stream_dump, "") \
22987 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
22988 _(ipfix_classify_table_dump, "") \
22989 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
22990 _(sw_interface_span_dump, "[l2]") \
22991 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
22992 _(pg_create_interface, "if_id <nn>") \
22993 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
22994 _(pg_enable_disable, "[stream <id>] disable") \
22995 _(ip_source_and_port_range_check_add_del, \
22996 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
22997 _(ip_source_and_port_range_check_interface_add_del, \
22998 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
22999 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
23000 _(ipsec_gre_add_del_tunnel, \
23001 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
23002 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
23003 _(delete_subif,"<intfc> | sw_if_index <nn>") \
23004 _(l2_interface_pbb_tag_rewrite, \
23005 "<intfc> | sw_if_index <nn> \n" \
23006 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
23007 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
23008 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
23009 _(flow_classify_set_interface, \
23010 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
23011 _(flow_classify_dump, "type [ip4|ip6]") \
23012 _(ip_fib_dump, "") \
23013 _(ip_mfib_dump, "") \
23014 _(ip6_fib_dump, "") \
23015 _(ip6_mfib_dump, "") \
23016 _(feature_enable_disable, "arc_name <arc_name> " \
23017 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
23018 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
23020 _(l2_xconnect_dump, "") \
23021 _(sw_interface_set_mtu, "<intfc> | sw_if_index <nn> mtu <nn>") \
23022 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
23023 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
23024 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
23025 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
23026 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
23027 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
23028 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
23029 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
23030 _(memfd_segment_create,"size <nnn>") \
23031 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
23032 _(dns_enable_disable, "[enable][disable]") \
23033 _(dns_name_server_add_del, "<ip-address> [del]") \
23034 _(dns_resolve_name, "<hostname>") \
23035 _(dns_resolve_ip, "<ip4|ip6>") \
23036 _(dns_name_server_add_del, "<ip-address> [del]") \
23037 _(dns_resolve_name, "<hostname>") \
23038 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
23039 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
23040 _(session_rules_dump, "") \
23041 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
23043 /* List of command functions, CLI names map directly to functions */
23044 #define foreach_cli_function \
23045 _(comment, "usage: comment <ignore-rest-of-line>") \
23046 _(dump_interface_table, "usage: dump_interface_table") \
23047 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
23048 _(dump_ipv4_table, "usage: dump_ipv4_table") \
23049 _(dump_ipv6_table, "usage: dump_ipv6_table") \
23050 _(dump_stats_table, "usage: dump_stats_table") \
23051 _(dump_macro_table, "usage: dump_macro_table ") \
23052 _(dump_node_table, "usage: dump_node_table") \
23053 _(dump_msg_api_table, "usage: dump_msg_api_table") \
23054 _(get_msg_id, "usage: get_msg_id name_and_crc") \
23055 _(echo, "usage: echo <message>") \
23056 _(exec, "usage: exec <vpe-debug-CLI-command>") \
23057 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
23058 _(help, "usage: help") \
23059 _(q, "usage: quit") \
23060 _(quit, "usage: quit") \
23061 _(search_node_table, "usage: search_node_table <name>...") \
23062 _(set, "usage: set <variable-name> <value>") \
23063 _(script, "usage: script <file-name>") \
23064 _(unset, "usage: unset <variable-name>")
23066 static void vl_api_##n##_t_handler_uni \
23067 (vl_api_##n##_t * mp) \
23069 vat_main_t * vam = &vat_main; \
23070 if (vam->json_output) { \
23071 vl_api_##n##_t_handler_json(mp); \
23073 vl_api_##n##_t_handler(mp); \
23076 foreach_vpe_api_reply_msg;
23077 #if VPP_API_TEST_BUILTIN == 0
23078 foreach_standalone_reply_msg;
23083 vat_api_hookup (vat_main_t * vam)
23086 vl_msg_api_set_handlers(VL_API_##N, #n, \
23087 vl_api_##n##_t_handler_uni, \
23089 vl_api_##n##_t_endian, \
23090 vl_api_##n##_t_print, \
23091 sizeof(vl_api_##n##_t), 1);
23092 foreach_vpe_api_reply_msg;
23093 #if VPP_API_TEST_BUILTIN == 0
23094 foreach_standalone_reply_msg;
23098 #if (VPP_API_TEST_BUILTIN==0)
23099 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
23101 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
23103 vam->function_by_name = hash_create_string (0, sizeof (uword));
23105 vam->help_by_name = hash_create_string (0, sizeof (uword));
23108 /* API messages we can send */
23109 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
23110 foreach_vpe_api_msg;
23114 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
23115 foreach_vpe_api_msg;
23118 /* CLI functions */
23119 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
23120 foreach_cli_function;
23124 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
23125 foreach_cli_function;
23129 #if VPP_API_TEST_BUILTIN
23130 static clib_error_t *
23131 vat_api_hookup_shim (vlib_main_t * vm)
23133 vat_api_hookup (&vat_main);
23137 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
23141 * fd.io coding-style-patch-verification: ON
23144 * eval: (c-set-style "gnu")