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);
7878 vec_add1 (net_ns, 0);
7880 /* Construct the API message */
7881 M (TAP_CREATE_V2, mp);
7883 mp->use_random_mac = random_mac;
7884 clib_memcpy (mp->mac_address, mac_address, 6);
7885 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
7886 mp->net_ns_set = net_ns_set;
7887 mp->rx_ring_sz = rx_ring_sz;
7888 mp->tx_ring_sz = tx_ring_sz;
7890 clib_memcpy (mp->net_ns, net_ns, vec_len (net_ns));
7892 vec_free (tap_name);
7898 /* Wait for a reply... */
7904 api_tap_delete_v2 (vat_main_t * vam)
7906 unformat_input_t *i = vam->input;
7907 vl_api_tap_delete_v2_t *mp;
7908 u32 sw_if_index = ~0;
7909 u8 sw_if_index_set = 0;
7912 /* Parse args required to build the message */
7913 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7915 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7916 sw_if_index_set = 1;
7917 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7918 sw_if_index_set = 1;
7923 if (sw_if_index_set == 0)
7925 errmsg ("missing vpp interface name. ");
7929 /* Construct the API message */
7930 M (TAP_DELETE_V2, mp);
7932 mp->sw_if_index = ntohl (sw_if_index);
7937 /* Wait for a reply... */
7943 api_ip_table_add_del (vat_main_t * vam)
7945 unformat_input_t *i = vam->input;
7946 vl_api_ip_table_add_del_t *mp;
7952 /* Parse args required to build the message */
7953 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7955 if (unformat (i, "ipv6"))
7957 else if (unformat (i, "del"))
7959 else if (unformat (i, "add"))
7961 else if (unformat (i, "table %d", &table_id))
7965 clib_warning ("parse error '%U'", format_unformat_error, i);
7972 errmsg ("missing table-ID");
7976 /* Construct the API message */
7977 M (IP_TABLE_ADD_DEL, mp);
7979 mp->table_id = ntohl (table_id);
7980 mp->is_ipv6 = is_ipv6;
7981 mp->is_add = is_add;
7986 /* Wait for a reply... */
7993 api_ip_add_del_route (vat_main_t * vam)
7995 unformat_input_t *i = vam->input;
7996 vl_api_ip_add_del_route_t *mp;
7997 u32 sw_if_index = ~0, vrf_id = 0;
7999 u8 is_local = 0, is_drop = 0;
8000 u8 is_unreach = 0, is_prohibit = 0;
8001 u8 create_vrf_if_needed = 0;
8003 u32 next_hop_weight = 1;
8004 u8 is_multipath = 0;
8006 u8 address_length_set = 0;
8007 u32 next_hop_table_id = 0;
8008 u32 resolve_attempts = 0;
8009 u32 dst_address_length = 0;
8010 u8 next_hop_set = 0;
8011 ip4_address_t v4_dst_address, v4_next_hop_address;
8012 ip6_address_t v6_dst_address, v6_next_hop_address;
8016 u32 random_add_del = 0;
8017 u32 *random_vector = 0;
8019 u32 random_seed = 0xdeaddabe;
8020 u32 classify_table_index = ~0;
8022 u8 resolve_host = 0, resolve_attached = 0;
8023 mpls_label_t *next_hop_out_label_stack = NULL;
8024 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8025 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
8027 /* Parse args required to build the message */
8028 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8030 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8032 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8034 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
8039 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
8044 else if (unformat (i, "/%d", &dst_address_length))
8046 address_length_set = 1;
8049 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
8050 &v4_next_hop_address))
8054 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
8055 &v6_next_hop_address))
8059 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
8061 else if (unformat (i, "weight %d", &next_hop_weight))
8063 else if (unformat (i, "drop"))
8067 else if (unformat (i, "null-send-unreach"))
8071 else if (unformat (i, "null-send-prohibit"))
8075 else if (unformat (i, "local"))
8079 else if (unformat (i, "classify %d", &classify_table_index))
8083 else if (unformat (i, "del"))
8085 else if (unformat (i, "add"))
8087 else if (unformat (i, "resolve-via-host"))
8089 else if (unformat (i, "resolve-via-attached"))
8090 resolve_attached = 1;
8091 else if (unformat (i, "multipath"))
8093 else if (unformat (i, "vrf %d", &vrf_id))
8095 else if (unformat (i, "create-vrf"))
8096 create_vrf_if_needed = 1;
8097 else if (unformat (i, "count %d", &count))
8099 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
8101 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
8103 else if (unformat (i, "out-label %d", &next_hop_out_label))
8104 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
8105 else if (unformat (i, "via-label %d", &next_hop_via_label))
8107 else if (unformat (i, "random"))
8109 else if (unformat (i, "seed %d", &random_seed))
8113 clib_warning ("parse error '%U'", format_unformat_error, i);
8118 if (!next_hop_set && !is_drop && !is_local &&
8119 !is_classify && !is_unreach && !is_prohibit &&
8120 MPLS_LABEL_INVALID == next_hop_via_label)
8123 ("next hop / local / drop / unreach / prohibit / classify not set");
8127 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
8129 errmsg ("next hop and next-hop via label set");
8132 if (address_set == 0)
8134 errmsg ("missing addresses");
8138 if (address_length_set == 0)
8140 errmsg ("missing address length");
8144 /* Generate a pile of unique, random routes */
8147 u32 this_random_address;
8148 random_hash = hash_create (count, sizeof (uword));
8150 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
8151 for (j = 0; j <= count; j++)
8155 this_random_address = random_u32 (&random_seed);
8156 this_random_address =
8157 clib_host_to_net_u32 (this_random_address);
8159 while (hash_get (random_hash, this_random_address));
8160 vec_add1 (random_vector, this_random_address);
8161 hash_set (random_hash, this_random_address, 1);
8163 hash_free (random_hash);
8164 v4_dst_address.as_u32 = random_vector[0];
8169 /* Turn on async mode */
8170 vam->async_mode = 1;
8171 vam->async_errors = 0;
8172 before = vat_time_now (vam);
8175 for (j = 0; j < count; j++)
8177 /* Construct the API message */
8178 M2 (IP_ADD_DEL_ROUTE, mp,
8179 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
8181 mp->next_hop_sw_if_index = ntohl (sw_if_index);
8182 mp->table_id = ntohl (vrf_id);
8183 mp->create_vrf_if_needed = create_vrf_if_needed;
8185 mp->is_add = is_add;
8186 mp->is_drop = is_drop;
8187 mp->is_unreach = is_unreach;
8188 mp->is_prohibit = is_prohibit;
8189 mp->is_ipv6 = is_ipv6;
8190 mp->is_local = is_local;
8191 mp->is_classify = is_classify;
8192 mp->is_multipath = is_multipath;
8193 mp->is_resolve_host = resolve_host;
8194 mp->is_resolve_attached = resolve_attached;
8195 mp->next_hop_weight = next_hop_weight;
8196 mp->dst_address_length = dst_address_length;
8197 mp->next_hop_table_id = ntohl (next_hop_table_id);
8198 mp->classify_table_index = ntohl (classify_table_index);
8199 mp->next_hop_via_label = ntohl (next_hop_via_label);
8200 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
8201 if (0 != mp->next_hop_n_out_labels)
8203 memcpy (mp->next_hop_out_label_stack,
8204 next_hop_out_label_stack,
8205 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
8206 vec_free (next_hop_out_label_stack);
8211 clib_memcpy (mp->dst_address, &v6_dst_address,
8212 sizeof (v6_dst_address));
8214 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
8215 sizeof (v6_next_hop_address));
8216 increment_v6_address (&v6_dst_address);
8220 clib_memcpy (mp->dst_address, &v4_dst_address,
8221 sizeof (v4_dst_address));
8223 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
8224 sizeof (v4_next_hop_address));
8226 v4_dst_address.as_u32 = random_vector[j + 1];
8228 increment_v4_address (&v4_dst_address);
8232 /* If we receive SIGTERM, stop now... */
8237 /* When testing multiple add/del ops, use a control-ping to sync */
8240 vl_api_control_ping_t *mp_ping;
8244 /* Shut off async mode */
8245 vam->async_mode = 0;
8247 MPING (CONTROL_PING, mp_ping);
8250 timeout = vat_time_now (vam) + 1.0;
8251 while (vat_time_now (vam) < timeout)
8252 if (vam->result_ready == 1)
8257 if (vam->retval == -99)
8260 if (vam->async_errors > 0)
8262 errmsg ("%d asynchronous errors", vam->async_errors);
8265 vam->async_errors = 0;
8266 after = vat_time_now (vam);
8268 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8272 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8273 count, after - before, count / (after - before));
8279 /* Wait for a reply... */
8284 /* Return the good/bad news */
8285 return (vam->retval);
8289 api_ip_mroute_add_del (vat_main_t * vam)
8291 unformat_input_t *i = vam->input;
8292 vl_api_ip_mroute_add_del_t *mp;
8293 u32 sw_if_index = ~0, vrf_id = 0;
8296 u8 create_vrf_if_needed = 0;
8299 u32 grp_address_length = 0;
8300 ip4_address_t v4_grp_address, v4_src_address;
8301 ip6_address_t v6_grp_address, v6_src_address;
8302 mfib_itf_flags_t iflags = 0;
8303 mfib_entry_flags_t eflags = 0;
8306 /* Parse args required to build the message */
8307 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8309 if (unformat (i, "sw_if_index %d", &sw_if_index))
8311 else if (unformat (i, "%U %U",
8312 unformat_ip4_address, &v4_src_address,
8313 unformat_ip4_address, &v4_grp_address))
8315 grp_address_length = 64;
8319 else if (unformat (i, "%U %U",
8320 unformat_ip6_address, &v6_src_address,
8321 unformat_ip6_address, &v6_grp_address))
8323 grp_address_length = 256;
8327 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
8329 memset (&v4_src_address, 0, sizeof (v4_src_address));
8330 grp_address_length = 32;
8334 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
8336 memset (&v6_src_address, 0, sizeof (v6_src_address));
8337 grp_address_length = 128;
8341 else if (unformat (i, "/%d", &grp_address_length))
8343 else if (unformat (i, "local"))
8347 else if (unformat (i, "del"))
8349 else if (unformat (i, "add"))
8351 else if (unformat (i, "vrf %d", &vrf_id))
8353 else if (unformat (i, "create-vrf"))
8354 create_vrf_if_needed = 1;
8355 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
8357 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
8361 clib_warning ("parse error '%U'", format_unformat_error, i);
8366 if (address_set == 0)
8368 errmsg ("missing addresses\n");
8372 /* Construct the API message */
8373 M (IP_MROUTE_ADD_DEL, mp);
8375 mp->next_hop_sw_if_index = ntohl (sw_if_index);
8376 mp->table_id = ntohl (vrf_id);
8377 mp->create_vrf_if_needed = create_vrf_if_needed;
8379 mp->is_add = is_add;
8380 mp->is_ipv6 = is_ipv6;
8381 mp->is_local = is_local;
8382 mp->itf_flags = ntohl (iflags);
8383 mp->entry_flags = ntohl (eflags);
8384 mp->grp_address_length = grp_address_length;
8385 mp->grp_address_length = ntohs (mp->grp_address_length);
8389 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
8390 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
8394 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
8395 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
8401 /* Wait for a reply... */
8407 api_mpls_table_add_del (vat_main_t * vam)
8409 unformat_input_t *i = vam->input;
8410 vl_api_mpls_table_add_del_t *mp;
8415 /* Parse args required to build the message */
8416 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8418 if (unformat (i, "table %d", &table_id))
8420 else if (unformat (i, "del"))
8422 else if (unformat (i, "add"))
8426 clib_warning ("parse error '%U'", format_unformat_error, i);
8433 errmsg ("missing table-ID");
8437 /* Construct the API message */
8438 M (MPLS_TABLE_ADD_DEL, mp);
8440 mp->mt_table_id = ntohl (table_id);
8441 mp->mt_is_add = is_add;
8446 /* Wait for a reply... */
8453 api_mpls_route_add_del (vat_main_t * vam)
8455 unformat_input_t *i = vam->input;
8456 vl_api_mpls_route_add_del_t *mp;
8457 u32 sw_if_index = ~0, table_id = 0;
8458 u8 create_table_if_needed = 0;
8460 u32 next_hop_weight = 1;
8461 u8 is_multipath = 0;
8462 u32 next_hop_table_id = 0;
8463 u8 next_hop_set = 0;
8464 ip4_address_t v4_next_hop_address = {
8467 ip6_address_t v6_next_hop_address = { {0} };
8471 u32 classify_table_index = ~0;
8473 u8 resolve_host = 0, resolve_attached = 0;
8474 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
8475 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8476 mpls_label_t *next_hop_out_label_stack = NULL;
8477 mpls_label_t local_label = MPLS_LABEL_INVALID;
8479 dpo_proto_t next_hop_proto = DPO_PROTO_IP4;
8481 /* Parse args required to build the message */
8482 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8484 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8486 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8488 else if (unformat (i, "%d", &local_label))
8490 else if (unformat (i, "eos"))
8492 else if (unformat (i, "non-eos"))
8494 else if (unformat (i, "via %U", unformat_ip4_address,
8495 &v4_next_hop_address))
8498 next_hop_proto = DPO_PROTO_IP4;
8500 else if (unformat (i, "via %U", unformat_ip6_address,
8501 &v6_next_hop_address))
8504 next_hop_proto = DPO_PROTO_IP6;
8506 else if (unformat (i, "weight %d", &next_hop_weight))
8508 else if (unformat (i, "create-table"))
8509 create_table_if_needed = 1;
8510 else if (unformat (i, "classify %d", &classify_table_index))
8514 else if (unformat (i, "del"))
8516 else if (unformat (i, "add"))
8518 else if (unformat (i, "resolve-via-host"))
8520 else if (unformat (i, "resolve-via-attached"))
8521 resolve_attached = 1;
8522 else if (unformat (i, "multipath"))
8524 else if (unformat (i, "count %d", &count))
8526 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
8529 next_hop_proto = DPO_PROTO_IP4;
8531 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
8534 next_hop_proto = DPO_PROTO_IP6;
8536 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
8538 else if (unformat (i, "via-label %d", &next_hop_via_label))
8540 else if (unformat (i, "out-label %d", &next_hop_out_label))
8541 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
8544 clib_warning ("parse error '%U'", format_unformat_error, i);
8549 if (!next_hop_set && !is_classify)
8551 errmsg ("next hop / classify not set");
8555 if (MPLS_LABEL_INVALID == local_label)
8557 errmsg ("missing label");
8563 /* Turn on async mode */
8564 vam->async_mode = 1;
8565 vam->async_errors = 0;
8566 before = vat_time_now (vam);
8569 for (j = 0; j < count; j++)
8571 /* Construct the API message */
8572 M2 (MPLS_ROUTE_ADD_DEL, mp,
8573 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
8575 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
8576 mp->mr_table_id = ntohl (table_id);
8577 mp->mr_create_table_if_needed = create_table_if_needed;
8579 mp->mr_is_add = is_add;
8580 mp->mr_next_hop_proto = next_hop_proto;
8581 mp->mr_is_classify = is_classify;
8582 mp->mr_is_multipath = is_multipath;
8583 mp->mr_is_resolve_host = resolve_host;
8584 mp->mr_is_resolve_attached = resolve_attached;
8585 mp->mr_next_hop_weight = next_hop_weight;
8586 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
8587 mp->mr_classify_table_index = ntohl (classify_table_index);
8588 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
8589 mp->mr_label = ntohl (local_label);
8590 mp->mr_eos = is_eos;
8592 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
8593 if (0 != mp->mr_next_hop_n_out_labels)
8595 memcpy (mp->mr_next_hop_out_label_stack,
8596 next_hop_out_label_stack,
8597 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
8598 vec_free (next_hop_out_label_stack);
8603 if (DPO_PROTO_IP4 == next_hop_proto)
8605 clib_memcpy (mp->mr_next_hop,
8606 &v4_next_hop_address,
8607 sizeof (v4_next_hop_address));
8609 else if (DPO_PROTO_IP6 == next_hop_proto)
8612 clib_memcpy (mp->mr_next_hop,
8613 &v6_next_hop_address,
8614 sizeof (v6_next_hop_address));
8621 /* If we receive SIGTERM, stop now... */
8626 /* When testing multiple add/del ops, use a control-ping to sync */
8629 vl_api_control_ping_t *mp_ping;
8633 /* Shut off async mode */
8634 vam->async_mode = 0;
8636 MPING (CONTROL_PING, mp_ping);
8639 timeout = vat_time_now (vam) + 1.0;
8640 while (vat_time_now (vam) < timeout)
8641 if (vam->result_ready == 1)
8646 if (vam->retval == -99)
8649 if (vam->async_errors > 0)
8651 errmsg ("%d asynchronous errors", vam->async_errors);
8654 vam->async_errors = 0;
8655 after = vat_time_now (vam);
8657 /* slim chance, but we might have eaten SIGTERM on the first iteration */
8661 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
8662 count, after - before, count / (after - before));
8668 /* Wait for a reply... */
8673 /* Return the good/bad news */
8674 return (vam->retval);
8678 api_mpls_ip_bind_unbind (vat_main_t * vam)
8680 unformat_input_t *i = vam->input;
8681 vl_api_mpls_ip_bind_unbind_t *mp;
8682 u32 ip_table_id = 0;
8683 u8 create_table_if_needed = 0;
8686 ip4_address_t v4_address;
8687 ip6_address_t v6_address;
8690 mpls_label_t local_label = MPLS_LABEL_INVALID;
8693 /* Parse args required to build the message */
8694 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8696 if (unformat (i, "%U/%d", unformat_ip4_address,
8697 &v4_address, &address_length))
8702 else if (unformat (i, "%U/%d", unformat_ip6_address,
8703 &v6_address, &address_length))
8708 else if (unformat (i, "%d", &local_label))
8710 else if (unformat (i, "create-table"))
8711 create_table_if_needed = 1;
8712 else if (unformat (i, "table-id %d", &ip_table_id))
8714 else if (unformat (i, "unbind"))
8716 else if (unformat (i, "bind"))
8720 clib_warning ("parse error '%U'", format_unformat_error, i);
8727 errmsg ("IP addres not set");
8731 if (MPLS_LABEL_INVALID == local_label)
8733 errmsg ("missing label");
8737 /* Construct the API message */
8738 M (MPLS_IP_BIND_UNBIND, mp);
8740 mp->mb_create_table_if_needed = create_table_if_needed;
8741 mp->mb_is_bind = is_bind;
8742 mp->mb_is_ip4 = is_ip4;
8743 mp->mb_ip_table_id = ntohl (ip_table_id);
8744 mp->mb_mpls_table_id = 0;
8745 mp->mb_label = ntohl (local_label);
8746 mp->mb_address_length = address_length;
8749 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
8751 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
8756 /* Wait for a reply... */
8762 api_bier_table_add_del (vat_main_t * vam)
8764 unformat_input_t *i = vam->input;
8765 vl_api_bier_table_add_del_t *mp;
8767 u32 set = 0, sub_domain = 0, hdr_len = 3;
8768 mpls_label_t local_label = MPLS_LABEL_INVALID;
8771 /* Parse args required to build the message */
8772 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8774 if (unformat (i, "sub-domain %d", &sub_domain))
8776 else if (unformat (i, "set %d", &set))
8778 else if (unformat (i, "label %d", &local_label))
8780 else if (unformat (i, "hdr-len %d", &hdr_len))
8782 else if (unformat (i, "add"))
8784 else if (unformat (i, "del"))
8788 clib_warning ("parse error '%U'", format_unformat_error, i);
8793 if (MPLS_LABEL_INVALID == local_label)
8795 errmsg ("missing label\n");
8799 /* Construct the API message */
8800 M (BIER_TABLE_ADD_DEL, mp);
8802 mp->bt_is_add = is_add;
8803 mp->bt_label = ntohl (local_label);
8804 mp->bt_tbl_id.bt_set = set;
8805 mp->bt_tbl_id.bt_sub_domain = sub_domain;
8806 mp->bt_tbl_id.bt_hdr_len_id = hdr_len;
8811 /* Wait for a reply... */
8818 api_bier_route_add_del (vat_main_t * vam)
8820 unformat_input_t *i = vam->input;
8821 vl_api_bier_route_add_del_t *mp;
8823 u32 set = 0, sub_domain = 0, hdr_len = 3, bp = 0;
8824 ip4_address_t v4_next_hop_address;
8825 ip6_address_t v6_next_hop_address;
8826 u8 next_hop_set = 0;
8827 u8 next_hop_proto_is_ip4 = 1;
8828 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
8831 /* Parse args required to build the message */
8832 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8834 if (unformat (i, "%U", unformat_ip4_address, &v4_next_hop_address))
8836 next_hop_proto_is_ip4 = 1;
8839 else if (unformat (i, "%U", unformat_ip6_address, &v6_next_hop_address))
8841 next_hop_proto_is_ip4 = 0;
8844 if (unformat (i, "sub-domain %d", &sub_domain))
8846 else if (unformat (i, "set %d", &set))
8848 else if (unformat (i, "hdr-len %d", &hdr_len))
8850 else if (unformat (i, "bp %d", &bp))
8852 else if (unformat (i, "add"))
8854 else if (unformat (i, "del"))
8856 else if (unformat (i, "out-label %d", &next_hop_out_label))
8860 clib_warning ("parse error '%U'", format_unformat_error, i);
8865 if (!next_hop_set || (MPLS_LABEL_INVALID == next_hop_out_label))
8867 errmsg ("next hop / label set\n");
8872 errmsg ("bit=position not set\n");
8876 /* Construct the API message */
8877 M2 (BIER_ROUTE_ADD_DEL, mp, sizeof (vl_api_fib_path3_t));
8879 mp->br_is_add = is_add;
8880 mp->br_tbl_id.bt_set = set;
8881 mp->br_tbl_id.bt_sub_domain = sub_domain;
8882 mp->br_tbl_id.bt_hdr_len_id = hdr_len;
8883 mp->br_bp = ntohs (bp);
8885 mp->br_paths[0].n_labels = 1;
8886 mp->br_paths[0].label_stack[0] = ntohl (next_hop_out_label);
8887 mp->br_paths[0].afi = (next_hop_proto_is_ip4 ? 0 : 1);
8889 if (next_hop_proto_is_ip4)
8891 clib_memcpy (mp->br_paths[0].next_hop,
8892 &v4_next_hop_address, sizeof (v4_next_hop_address));
8896 clib_memcpy (mp->br_paths[0].next_hop,
8897 &v6_next_hop_address, sizeof (v6_next_hop_address));
8903 /* Wait for a reply... */
8910 api_proxy_arp_add_del (vat_main_t * vam)
8912 unformat_input_t *i = vam->input;
8913 vl_api_proxy_arp_add_del_t *mp;
8916 ip4_address_t lo, hi;
8920 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8922 if (unformat (i, "vrf %d", &vrf_id))
8924 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
8925 unformat_ip4_address, &hi))
8927 else if (unformat (i, "del"))
8931 clib_warning ("parse error '%U'", format_unformat_error, i);
8938 errmsg ("address range not set");
8942 M (PROXY_ARP_ADD_DEL, mp);
8944 mp->vrf_id = ntohl (vrf_id);
8945 mp->is_add = is_add;
8946 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
8947 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
8955 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
8957 unformat_input_t *i = vam->input;
8958 vl_api_proxy_arp_intfc_enable_disable_t *mp;
8961 u8 sw_if_index_set = 0;
8964 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8966 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8967 sw_if_index_set = 1;
8968 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8969 sw_if_index_set = 1;
8970 else if (unformat (i, "enable"))
8972 else if (unformat (i, "disable"))
8976 clib_warning ("parse error '%U'", format_unformat_error, i);
8981 if (sw_if_index_set == 0)
8983 errmsg ("missing interface name or sw_if_index");
8987 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
8989 mp->sw_if_index = ntohl (sw_if_index);
8990 mp->enable_disable = enable;
8998 api_mpls_tunnel_add_del (vat_main_t * vam)
9000 unformat_input_t *i = vam->input;
9001 vl_api_mpls_tunnel_add_del_t *mp;
9005 u32 sw_if_index = ~0;
9006 u32 next_hop_sw_if_index = ~0;
9007 u32 next_hop_proto_is_ip4 = 1;
9009 u32 next_hop_table_id = 0;
9010 ip4_address_t v4_next_hop_address = {
9013 ip6_address_t v6_next_hop_address = { {0} };
9014 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID, *labels = NULL;
9017 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9019 if (unformat (i, "add"))
9021 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
9023 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
9025 else if (unformat (i, "via %U",
9026 unformat_ip4_address, &v4_next_hop_address))
9028 next_hop_proto_is_ip4 = 1;
9030 else if (unformat (i, "via %U",
9031 unformat_ip6_address, &v6_next_hop_address))
9033 next_hop_proto_is_ip4 = 0;
9035 else if (unformat (i, "l2-only"))
9037 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
9039 else if (unformat (i, "out-label %d", &next_hop_out_label))
9040 vec_add1 (labels, ntohl (next_hop_out_label));
9043 clib_warning ("parse error '%U'", format_unformat_error, i);
9048 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (mpls_label_t) * vec_len (labels));
9050 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
9051 mp->mt_sw_if_index = ntohl (sw_if_index);
9052 mp->mt_is_add = is_add;
9053 mp->mt_l2_only = l2_only;
9054 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
9055 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
9057 mp->mt_next_hop_n_out_labels = vec_len (labels);
9059 if (0 != mp->mt_next_hop_n_out_labels)
9061 clib_memcpy (mp->mt_next_hop_out_label_stack, labels,
9062 sizeof (mpls_label_t) * mp->mt_next_hop_n_out_labels);
9066 if (next_hop_proto_is_ip4)
9068 clib_memcpy (mp->mt_next_hop,
9069 &v4_next_hop_address, sizeof (v4_next_hop_address));
9073 clib_memcpy (mp->mt_next_hop,
9074 &v6_next_hop_address, sizeof (v6_next_hop_address));
9083 api_sw_interface_set_unnumbered (vat_main_t * vam)
9085 unformat_input_t *i = vam->input;
9086 vl_api_sw_interface_set_unnumbered_t *mp;
9088 u32 unnum_sw_index = ~0;
9090 u8 sw_if_index_set = 0;
9093 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9095 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9096 sw_if_index_set = 1;
9097 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9098 sw_if_index_set = 1;
9099 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
9101 else if (unformat (i, "del"))
9105 clib_warning ("parse error '%U'", format_unformat_error, i);
9110 if (sw_if_index_set == 0)
9112 errmsg ("missing interface name or sw_if_index");
9116 M (SW_INTERFACE_SET_UNNUMBERED, mp);
9118 mp->sw_if_index = ntohl (sw_if_index);
9119 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
9120 mp->is_add = is_add;
9128 api_ip_neighbor_add_del (vat_main_t * vam)
9130 unformat_input_t *i = vam->input;
9131 vl_api_ip_neighbor_add_del_t *mp;
9133 u8 sw_if_index_set = 0;
9136 u8 is_no_fib_entry = 0;
9139 u8 v4_address_set = 0;
9140 u8 v6_address_set = 0;
9141 ip4_address_t v4address;
9142 ip6_address_t v6address;
9145 memset (mac_address, 0, sizeof (mac_address));
9147 /* Parse args required to build the message */
9148 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9150 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
9154 else if (unformat (i, "del"))
9157 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9158 sw_if_index_set = 1;
9159 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9160 sw_if_index_set = 1;
9161 else if (unformat (i, "is_static"))
9163 else if (unformat (i, "no-fib-entry"))
9164 is_no_fib_entry = 1;
9165 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
9167 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
9171 clib_warning ("parse error '%U'", format_unformat_error, i);
9176 if (sw_if_index_set == 0)
9178 errmsg ("missing interface name or sw_if_index");
9181 if (v4_address_set && v6_address_set)
9183 errmsg ("both v4 and v6 addresses set");
9186 if (!v4_address_set && !v6_address_set)
9188 errmsg ("no address set");
9192 /* Construct the API message */
9193 M (IP_NEIGHBOR_ADD_DEL, mp);
9195 mp->sw_if_index = ntohl (sw_if_index);
9196 mp->is_add = is_add;
9197 mp->is_static = is_static;
9198 mp->is_no_adj_fib = is_no_fib_entry;
9200 clib_memcpy (mp->mac_address, mac_address, 6);
9204 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
9208 /* mp->is_ipv6 = 0; via memset in M macro above */
9209 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
9215 /* Wait for a reply, return good/bad news */
9221 api_create_vlan_subif (vat_main_t * vam)
9223 unformat_input_t *i = vam->input;
9224 vl_api_create_vlan_subif_t *mp;
9226 u8 sw_if_index_set = 0;
9231 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9233 if (unformat (i, "sw_if_index %d", &sw_if_index))
9234 sw_if_index_set = 1;
9236 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9237 sw_if_index_set = 1;
9238 else if (unformat (i, "vlan %d", &vlan_id))
9242 clib_warning ("parse error '%U'", format_unformat_error, i);
9247 if (sw_if_index_set == 0)
9249 errmsg ("missing interface name or sw_if_index");
9253 if (vlan_id_set == 0)
9255 errmsg ("missing vlan_id");
9258 M (CREATE_VLAN_SUBIF, mp);
9260 mp->sw_if_index = ntohl (sw_if_index);
9261 mp->vlan_id = ntohl (vlan_id);
9268 #define foreach_create_subif_bit \
9275 _(outer_vlan_id_any) \
9276 _(inner_vlan_id_any)
9279 api_create_subif (vat_main_t * vam)
9281 unformat_input_t *i = vam->input;
9282 vl_api_create_subif_t *mp;
9284 u8 sw_if_index_set = 0;
9291 u32 exact_match = 0;
9292 u32 default_sub = 0;
9293 u32 outer_vlan_id_any = 0;
9294 u32 inner_vlan_id_any = 0;
9296 u16 outer_vlan_id = 0;
9297 u16 inner_vlan_id = 0;
9300 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9302 if (unformat (i, "sw_if_index %d", &sw_if_index))
9303 sw_if_index_set = 1;
9305 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9306 sw_if_index_set = 1;
9307 else if (unformat (i, "sub_id %d", &sub_id))
9309 else if (unformat (i, "outer_vlan_id %d", &tmp))
9310 outer_vlan_id = tmp;
9311 else if (unformat (i, "inner_vlan_id %d", &tmp))
9312 inner_vlan_id = tmp;
9314 #define _(a) else if (unformat (i, #a)) a = 1 ;
9315 foreach_create_subif_bit
9319 clib_warning ("parse error '%U'", format_unformat_error, i);
9324 if (sw_if_index_set == 0)
9326 errmsg ("missing interface name or sw_if_index");
9330 if (sub_id_set == 0)
9332 errmsg ("missing sub_id");
9335 M (CREATE_SUBIF, mp);
9337 mp->sw_if_index = ntohl (sw_if_index);
9338 mp->sub_id = ntohl (sub_id);
9340 #define _(a) mp->a = a;
9341 foreach_create_subif_bit;
9344 mp->outer_vlan_id = ntohs (outer_vlan_id);
9345 mp->inner_vlan_id = ntohs (inner_vlan_id);
9353 api_oam_add_del (vat_main_t * vam)
9355 unformat_input_t *i = vam->input;
9356 vl_api_oam_add_del_t *mp;
9359 ip4_address_t src, dst;
9364 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9366 if (unformat (i, "vrf %d", &vrf_id))
9368 else if (unformat (i, "src %U", unformat_ip4_address, &src))
9370 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
9372 else if (unformat (i, "del"))
9376 clib_warning ("parse error '%U'", format_unformat_error, i);
9383 errmsg ("missing src addr");
9389 errmsg ("missing dst addr");
9393 M (OAM_ADD_DEL, mp);
9395 mp->vrf_id = ntohl (vrf_id);
9396 mp->is_add = is_add;
9397 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
9398 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
9406 api_reset_fib (vat_main_t * vam)
9408 unformat_input_t *i = vam->input;
9409 vl_api_reset_fib_t *mp;
9415 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9417 if (unformat (i, "vrf %d", &vrf_id))
9419 else if (unformat (i, "ipv6"))
9423 clib_warning ("parse error '%U'", format_unformat_error, i);
9428 if (vrf_id_set == 0)
9430 errmsg ("missing vrf id");
9436 mp->vrf_id = ntohl (vrf_id);
9437 mp->is_ipv6 = is_ipv6;
9445 api_dhcp_proxy_config (vat_main_t * vam)
9447 unformat_input_t *i = vam->input;
9448 vl_api_dhcp_proxy_config_t *mp;
9450 u32 server_vrf_id = 0;
9452 u8 v4_address_set = 0;
9453 u8 v6_address_set = 0;
9454 ip4_address_t v4address;
9455 ip6_address_t v6address;
9456 u8 v4_src_address_set = 0;
9457 u8 v6_src_address_set = 0;
9458 ip4_address_t v4srcaddress;
9459 ip6_address_t v6srcaddress;
9462 /* Parse args required to build the message */
9463 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9465 if (unformat (i, "del"))
9467 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
9469 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
9471 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
9473 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
9475 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
9476 v4_src_address_set = 1;
9477 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
9478 v6_src_address_set = 1;
9483 if (v4_address_set && v6_address_set)
9485 errmsg ("both v4 and v6 server addresses set");
9488 if (!v4_address_set && !v6_address_set)
9490 errmsg ("no server addresses set");
9494 if (v4_src_address_set && v6_src_address_set)
9496 errmsg ("both v4 and v6 src addresses set");
9499 if (!v4_src_address_set && !v6_src_address_set)
9501 errmsg ("no src addresses set");
9505 if (!(v4_src_address_set && v4_address_set) &&
9506 !(v6_src_address_set && v6_address_set))
9508 errmsg ("no matching server and src addresses set");
9512 /* Construct the API message */
9513 M (DHCP_PROXY_CONFIG, mp);
9515 mp->is_add = is_add;
9516 mp->rx_vrf_id = ntohl (rx_vrf_id);
9517 mp->server_vrf_id = ntohl (server_vrf_id);
9521 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
9522 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
9526 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
9527 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
9533 /* Wait for a reply, return good/bad news */
9538 #define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
9539 #define vl_api_dhcp_proxy_details_t_print vl_noop_handler
9542 vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
9544 vat_main_t *vam = &vat_main;
9545 u32 i, count = mp->count;
9546 vl_api_dhcp_server_t *s;
9550 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9551 "VSS VPN-ID '%s', VSS FIB-ID %d, VSS OUI %d",
9552 ntohl (mp->rx_vrf_id),
9553 format_ip6_address, mp->dhcp_src_address,
9554 mp->vss_type, mp->vss_vpn_ascii_id,
9555 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9558 "RX Table-ID %d, Source Address %U, VSS Type %d, "
9559 "VSS VPN-ID '%s', VSS FIB-ID %d, VSS OUI %d",
9560 ntohl (mp->rx_vrf_id),
9561 format_ip4_address, mp->dhcp_src_address,
9562 mp->vss_type, mp->vss_vpn_ascii_id,
9563 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
9565 for (i = 0; i < count; i++)
9567 s = &mp->servers[i];
9571 " Server Table-ID %d, Server Address %U",
9572 ntohl (s->server_vrf_id), format_ip6_address, s->dhcp_server);
9575 " Server Table-ID %d, Server Address %U",
9576 ntohl (s->server_vrf_id), format_ip4_address, s->dhcp_server);
9580 static void vl_api_dhcp_proxy_details_t_handler_json
9581 (vl_api_dhcp_proxy_details_t * mp)
9583 vat_main_t *vam = &vat_main;
9584 vat_json_node_t *node = NULL;
9585 u32 i, count = mp->count;
9587 struct in6_addr ip6;
9588 vl_api_dhcp_server_t *s;
9590 if (VAT_JSON_ARRAY != vam->json_tree.type)
9592 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9593 vat_json_init_array (&vam->json_tree);
9595 node = vat_json_array_add (&vam->json_tree);
9597 vat_json_init_object (node);
9598 vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
9599 vat_json_object_add_bytes (node, "vss-type", &mp->vss_type,
9600 sizeof (mp->vss_type));
9601 vat_json_object_add_string_copy (node, "vss-vpn-ascii-id",
9602 mp->vss_vpn_ascii_id);
9603 vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
9604 vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
9608 clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
9609 vat_json_object_add_ip6 (node, "src_address", ip6);
9613 clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
9614 vat_json_object_add_ip4 (node, "src_address", ip4);
9617 for (i = 0; i < count; i++)
9619 s = &mp->servers[i];
9621 vat_json_object_add_uint (node, "server-table-id",
9622 ntohl (s->server_vrf_id));
9626 clib_memcpy (&ip4, &s->dhcp_server, sizeof (ip4));
9627 vat_json_object_add_ip4 (node, "src_address", ip4);
9631 clib_memcpy (&ip6, &s->dhcp_server, sizeof (ip6));
9632 vat_json_object_add_ip6 (node, "server_address", ip6);
9638 api_dhcp_proxy_dump (vat_main_t * vam)
9640 unformat_input_t *i = vam->input;
9641 vl_api_control_ping_t *mp_ping;
9642 vl_api_dhcp_proxy_dump_t *mp;
9646 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9648 if (unformat (i, "ipv6"))
9652 clib_warning ("parse error '%U'", format_unformat_error, i);
9657 M (DHCP_PROXY_DUMP, mp);
9659 mp->is_ip6 = is_ipv6;
9662 /* Use a control ping for synchronization */
9663 MPING (CONTROL_PING, mp_ping);
9671 api_dhcp_proxy_set_vss (vat_main_t * vam)
9673 unformat_input_t *i = vam->input;
9674 vl_api_dhcp_proxy_set_vss_t *mp;
9678 u8 vss_type = VSS_TYPE_DEFAULT;
9679 u8 *vpn_ascii_id = 0;
9684 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9686 if (unformat (i, "tbl_id %d", &tbl_id))
9688 else if (unformat (i, "vpn_ascii_id %s", &vpn_ascii_id))
9689 vss_type = VSS_TYPE_ASCII;
9690 else if (unformat (i, "fib_id %d", &fib_id))
9691 vss_type = VSS_TYPE_VPN_ID;
9692 else if (unformat (i, "oui %d", &oui))
9693 vss_type = VSS_TYPE_VPN_ID;
9694 else if (unformat (i, "ipv6"))
9696 else if (unformat (i, "del"))
9704 errmsg ("missing tbl_id ");
9705 vec_free (vpn_ascii_id);
9709 if ((vpn_ascii_id) && (vec_len (vpn_ascii_id) > 128))
9711 errmsg ("vpn_ascii_id cannot be longer than 128 ");
9712 vec_free (vpn_ascii_id);
9716 M (DHCP_PROXY_SET_VSS, mp);
9717 mp->tbl_id = ntohl (tbl_id);
9718 mp->vss_type = vss_type;
9721 clib_memcpy (mp->vpn_ascii_id, vpn_ascii_id, vec_len (vpn_ascii_id));
9722 mp->vpn_ascii_id[vec_len (vpn_ascii_id)] = 0;
9724 mp->vpn_index = ntohl (fib_id);
9725 mp->oui = ntohl (oui);
9726 mp->is_ipv6 = is_ipv6;
9727 mp->is_add = is_add;
9732 vec_free (vpn_ascii_id);
9737 api_dhcp_client_config (vat_main_t * vam)
9739 unformat_input_t *i = vam->input;
9740 vl_api_dhcp_client_config_t *mp;
9742 u8 sw_if_index_set = 0;
9745 u8 disable_event = 0;
9748 /* Parse args required to build the message */
9749 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9751 if (unformat (i, "del"))
9754 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9755 sw_if_index_set = 1;
9756 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9757 sw_if_index_set = 1;
9758 else if (unformat (i, "hostname %s", &hostname))
9760 else if (unformat (i, "disable_event"))
9766 if (sw_if_index_set == 0)
9768 errmsg ("missing interface name or sw_if_index");
9772 if (vec_len (hostname) > 63)
9774 errmsg ("hostname too long");
9776 vec_add1 (hostname, 0);
9778 /* Construct the API message */
9779 M (DHCP_CLIENT_CONFIG, mp);
9781 mp->sw_if_index = htonl (sw_if_index);
9782 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
9783 vec_free (hostname);
9784 mp->is_add = is_add;
9785 mp->want_dhcp_event = disable_event ? 0 : 1;
9786 mp->pid = htonl (getpid ());
9791 /* Wait for a reply, return good/bad news */
9797 api_set_ip_flow_hash (vat_main_t * vam)
9799 unformat_input_t *i = vam->input;
9800 vl_api_set_ip_flow_hash_t *mp;
9812 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9814 if (unformat (i, "vrf %d", &vrf_id))
9816 else if (unformat (i, "ipv6"))
9818 else if (unformat (i, "src"))
9820 else if (unformat (i, "dst"))
9822 else if (unformat (i, "sport"))
9824 else if (unformat (i, "dport"))
9826 else if (unformat (i, "proto"))
9828 else if (unformat (i, "reverse"))
9833 clib_warning ("parse error '%U'", format_unformat_error, i);
9838 if (vrf_id_set == 0)
9840 errmsg ("missing vrf id");
9844 M (SET_IP_FLOW_HASH, mp);
9850 mp->reverse = reverse;
9851 mp->vrf_id = ntohl (vrf_id);
9852 mp->is_ipv6 = is_ipv6;
9860 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
9862 unformat_input_t *i = vam->input;
9863 vl_api_sw_interface_ip6_enable_disable_t *mp;
9865 u8 sw_if_index_set = 0;
9869 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9871 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9872 sw_if_index_set = 1;
9873 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9874 sw_if_index_set = 1;
9875 else if (unformat (i, "enable"))
9877 else if (unformat (i, "disable"))
9881 clib_warning ("parse error '%U'", format_unformat_error, i);
9886 if (sw_if_index_set == 0)
9888 errmsg ("missing interface name or sw_if_index");
9892 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
9894 mp->sw_if_index = ntohl (sw_if_index);
9895 mp->enable = enable;
9903 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
9905 unformat_input_t *i = vam->input;
9906 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
9908 u8 sw_if_index_set = 0;
9909 u8 v6_address_set = 0;
9910 ip6_address_t v6address;
9913 /* Parse args required to build the message */
9914 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9916 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9917 sw_if_index_set = 1;
9918 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9919 sw_if_index_set = 1;
9920 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
9926 if (sw_if_index_set == 0)
9928 errmsg ("missing interface name or sw_if_index");
9931 if (!v6_address_set)
9933 errmsg ("no address set");
9937 /* Construct the API message */
9938 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, mp);
9940 mp->sw_if_index = ntohl (sw_if_index);
9941 clib_memcpy (mp->address, &v6address, sizeof (v6address));
9946 /* Wait for a reply, return good/bad news */
9952 api_ip6nd_proxy_add_del (vat_main_t * vam)
9954 unformat_input_t *i = vam->input;
9955 vl_api_ip6nd_proxy_add_del_t *mp;
9956 u32 sw_if_index = ~0;
9957 u8 v6_address_set = 0;
9958 ip6_address_t v6address;
9962 /* Parse args required to build the message */
9963 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9965 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9967 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9969 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
9971 if (unformat (i, "del"))
9975 clib_warning ("parse error '%U'", format_unformat_error, i);
9980 if (sw_if_index == ~0)
9982 errmsg ("missing interface name or sw_if_index");
9985 if (!v6_address_set)
9987 errmsg ("no address set");
9991 /* Construct the API message */
9992 M (IP6ND_PROXY_ADD_DEL, mp);
9994 mp->is_del = is_del;
9995 mp->sw_if_index = ntohl (sw_if_index);
9996 clib_memcpy (mp->address, &v6address, sizeof (v6address));
10001 /* Wait for a reply, return good/bad news */
10007 api_ip6nd_proxy_dump (vat_main_t * vam)
10009 vl_api_ip6nd_proxy_dump_t *mp;
10010 vl_api_control_ping_t *mp_ping;
10013 M (IP6ND_PROXY_DUMP, mp);
10017 /* Use a control ping for synchronization */
10018 MPING (CONTROL_PING, mp_ping);
10025 static void vl_api_ip6nd_proxy_details_t_handler
10026 (vl_api_ip6nd_proxy_details_t * mp)
10028 vat_main_t *vam = &vat_main;
10030 print (vam->ofp, "host %U sw_if_index %d",
10031 format_ip6_address, mp->address, ntohl (mp->sw_if_index));
10034 static void vl_api_ip6nd_proxy_details_t_handler_json
10035 (vl_api_ip6nd_proxy_details_t * mp)
10037 vat_main_t *vam = &vat_main;
10038 struct in6_addr ip6;
10039 vat_json_node_t *node = NULL;
10041 if (VAT_JSON_ARRAY != vam->json_tree.type)
10043 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10044 vat_json_init_array (&vam->json_tree);
10046 node = vat_json_array_add (&vam->json_tree);
10048 vat_json_init_object (node);
10049 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10051 clib_memcpy (&ip6, mp->address, sizeof (ip6));
10052 vat_json_object_add_ip6 (node, "host", ip6);
10056 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
10058 unformat_input_t *i = vam->input;
10059 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
10061 u8 sw_if_index_set = 0;
10062 u32 address_length = 0;
10063 u8 v6_address_set = 0;
10064 ip6_address_t v6address;
10065 u8 use_default = 0;
10066 u8 no_advertise = 0;
10068 u8 no_autoconfig = 0;
10071 u32 val_lifetime = 0;
10072 u32 pref_lifetime = 0;
10075 /* Parse args required to build the message */
10076 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10078 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10079 sw_if_index_set = 1;
10080 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10081 sw_if_index_set = 1;
10082 else if (unformat (i, "%U/%d",
10083 unformat_ip6_address, &v6address, &address_length))
10084 v6_address_set = 1;
10085 else if (unformat (i, "val_life %d", &val_lifetime))
10087 else if (unformat (i, "pref_life %d", &pref_lifetime))
10089 else if (unformat (i, "def"))
10091 else if (unformat (i, "noadv"))
10093 else if (unformat (i, "offl"))
10095 else if (unformat (i, "noauto"))
10097 else if (unformat (i, "nolink"))
10099 else if (unformat (i, "isno"))
10103 clib_warning ("parse error '%U'", format_unformat_error, i);
10108 if (sw_if_index_set == 0)
10110 errmsg ("missing interface name or sw_if_index");
10113 if (!v6_address_set)
10115 errmsg ("no address set");
10119 /* Construct the API message */
10120 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
10122 mp->sw_if_index = ntohl (sw_if_index);
10123 clib_memcpy (mp->address, &v6address, sizeof (v6address));
10124 mp->address_length = address_length;
10125 mp->use_default = use_default;
10126 mp->no_advertise = no_advertise;
10127 mp->off_link = off_link;
10128 mp->no_autoconfig = no_autoconfig;
10129 mp->no_onlink = no_onlink;
10131 mp->val_lifetime = ntohl (val_lifetime);
10132 mp->pref_lifetime = ntohl (pref_lifetime);
10137 /* Wait for a reply, return good/bad news */
10143 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
10145 unformat_input_t *i = vam->input;
10146 vl_api_sw_interface_ip6nd_ra_config_t *mp;
10148 u8 sw_if_index_set = 0;
10153 u8 send_unicast = 0;
10156 u8 default_router = 0;
10157 u32 max_interval = 0;
10158 u32 min_interval = 0;
10160 u32 initial_count = 0;
10161 u32 initial_interval = 0;
10165 /* Parse args required to build the message */
10166 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10168 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10169 sw_if_index_set = 1;
10170 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10171 sw_if_index_set = 1;
10172 else if (unformat (i, "maxint %d", &max_interval))
10174 else if (unformat (i, "minint %d", &min_interval))
10176 else if (unformat (i, "life %d", &lifetime))
10178 else if (unformat (i, "count %d", &initial_count))
10180 else if (unformat (i, "interval %d", &initial_interval))
10182 else if (unformat (i, "suppress") || unformat (i, "surpress"))
10184 else if (unformat (i, "managed"))
10186 else if (unformat (i, "other"))
10188 else if (unformat (i, "ll"))
10190 else if (unformat (i, "send"))
10192 else if (unformat (i, "cease"))
10194 else if (unformat (i, "isno"))
10196 else if (unformat (i, "def"))
10197 default_router = 1;
10200 clib_warning ("parse error '%U'", format_unformat_error, i);
10205 if (sw_if_index_set == 0)
10207 errmsg ("missing interface name or sw_if_index");
10211 /* Construct the API message */
10212 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
10214 mp->sw_if_index = ntohl (sw_if_index);
10215 mp->max_interval = ntohl (max_interval);
10216 mp->min_interval = ntohl (min_interval);
10217 mp->lifetime = ntohl (lifetime);
10218 mp->initial_count = ntohl (initial_count);
10219 mp->initial_interval = ntohl (initial_interval);
10220 mp->suppress = suppress;
10221 mp->managed = managed;
10223 mp->ll_option = ll_option;
10224 mp->send_unicast = send_unicast;
10227 mp->default_router = default_router;
10232 /* Wait for a reply, return good/bad news */
10238 api_set_arp_neighbor_limit (vat_main_t * vam)
10240 unformat_input_t *i = vam->input;
10241 vl_api_set_arp_neighbor_limit_t *mp;
10247 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10249 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
10251 else if (unformat (i, "ipv6"))
10255 clib_warning ("parse error '%U'", format_unformat_error, i);
10260 if (limit_set == 0)
10262 errmsg ("missing limit value");
10266 M (SET_ARP_NEIGHBOR_LIMIT, mp);
10268 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
10269 mp->is_ipv6 = is_ipv6;
10277 api_l2_patch_add_del (vat_main_t * vam)
10279 unformat_input_t *i = vam->input;
10280 vl_api_l2_patch_add_del_t *mp;
10281 u32 rx_sw_if_index;
10282 u8 rx_sw_if_index_set = 0;
10283 u32 tx_sw_if_index;
10284 u8 tx_sw_if_index_set = 0;
10288 /* Parse args required to build the message */
10289 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10291 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
10292 rx_sw_if_index_set = 1;
10293 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
10294 tx_sw_if_index_set = 1;
10295 else if (unformat (i, "rx"))
10297 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10299 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10301 rx_sw_if_index_set = 1;
10306 else if (unformat (i, "tx"))
10308 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10310 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
10312 tx_sw_if_index_set = 1;
10317 else if (unformat (i, "del"))
10323 if (rx_sw_if_index_set == 0)
10325 errmsg ("missing rx interface name or rx_sw_if_index");
10329 if (tx_sw_if_index_set == 0)
10331 errmsg ("missing tx interface name or tx_sw_if_index");
10335 M (L2_PATCH_ADD_DEL, mp);
10337 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
10338 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
10339 mp->is_add = is_add;
10347 u8 localsid_addr[16];
10356 api_sr_localsid_add_del (vat_main_t * vam)
10358 unformat_input_t *i = vam->input;
10359 vl_api_sr_localsid_add_del_t *mp;
10362 ip6_address_t localsid;
10366 u32 fib_table = ~(u32) 0;
10367 ip6_address_t next_hop;
10369 bool nexthop_set = 0;
10373 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10375 if (unformat (i, "del"))
10377 else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
10378 else if (unformat (i, "next-hop %U", unformat_ip6_address, &next_hop))
10380 else if (unformat (i, "behavior %u", &behavior));
10381 else if (unformat (i, "sw_if_index %u", &sw_if_index));
10382 else if (unformat (i, "fib-table %u", &fib_table));
10383 else if (unformat (i, "end.psp %u", &behavior));
10388 M (SR_LOCALSID_ADD_DEL, mp);
10390 clib_memcpy (mp->localsid_addr, &localsid, sizeof (mp->localsid_addr));
10392 clib_memcpy (mp->nh_addr, &next_hop, sizeof (mp->nh_addr));
10393 mp->behavior = behavior;
10394 mp->sw_if_index = ntohl (sw_if_index);
10395 mp->fib_table = ntohl (fib_table);
10396 mp->end_psp = end_psp;
10397 mp->is_del = is_del;
10405 api_ioam_enable (vat_main_t * vam)
10407 unformat_input_t *input = vam->input;
10408 vl_api_ioam_enable_t *mp;
10410 int has_trace_option = 0;
10411 int has_pot_option = 0;
10412 int has_seqno_option = 0;
10413 int has_analyse_option = 0;
10416 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10418 if (unformat (input, "trace"))
10419 has_trace_option = 1;
10420 else if (unformat (input, "pot"))
10421 has_pot_option = 1;
10422 else if (unformat (input, "seqno"))
10423 has_seqno_option = 1;
10424 else if (unformat (input, "analyse"))
10425 has_analyse_option = 1;
10429 M (IOAM_ENABLE, mp);
10430 mp->id = htons (id);
10431 mp->seqno = has_seqno_option;
10432 mp->analyse = has_analyse_option;
10433 mp->pot_enable = has_pot_option;
10434 mp->trace_enable = has_trace_option;
10443 api_ioam_disable (vat_main_t * vam)
10445 vl_api_ioam_disable_t *mp;
10448 M (IOAM_DISABLE, mp);
10454 #define foreach_tcp_proto_field \
10458 #define foreach_udp_proto_field \
10462 #define foreach_ip4_proto_field \
10474 u16 src_port, dst_port;
10477 #if VPP_API_TEST_BUILTIN == 0
10479 unformat_tcp_mask (unformat_input_t * input, va_list * args)
10481 u8 **maskp = va_arg (*args, u8 **);
10483 u8 found_something = 0;
10486 #define _(a) u8 a=0;
10487 foreach_tcp_proto_field;
10490 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10493 #define _(a) else if (unformat (input, #a)) a=1;
10494 foreach_tcp_proto_field
10500 #define _(a) found_something += a;
10501 foreach_tcp_proto_field;
10504 if (found_something == 0)
10507 vec_validate (mask, sizeof (*tcp) - 1);
10509 tcp = (tcp_header_t *) mask;
10511 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
10512 foreach_tcp_proto_field;
10520 unformat_udp_mask (unformat_input_t * input, va_list * args)
10522 u8 **maskp = va_arg (*args, u8 **);
10524 u8 found_something = 0;
10527 #define _(a) u8 a=0;
10528 foreach_udp_proto_field;
10531 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10534 #define _(a) else if (unformat (input, #a)) a=1;
10535 foreach_udp_proto_field
10541 #define _(a) found_something += a;
10542 foreach_udp_proto_field;
10545 if (found_something == 0)
10548 vec_validate (mask, sizeof (*udp) - 1);
10550 udp = (udp_header_t *) mask;
10552 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
10553 foreach_udp_proto_field;
10561 unformat_l4_mask (unformat_input_t * input, va_list * args)
10563 u8 **maskp = va_arg (*args, u8 **);
10564 u16 src_port = 0, dst_port = 0;
10565 tcpudp_header_t *tcpudp;
10567 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10569 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
10571 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
10573 else if (unformat (input, "src_port"))
10575 else if (unformat (input, "dst_port"))
10581 if (!src_port && !dst_port)
10585 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
10587 tcpudp = (tcpudp_header_t *) mask;
10588 tcpudp->src_port = src_port;
10589 tcpudp->dst_port = dst_port;
10597 unformat_ip4_mask (unformat_input_t * input, va_list * args)
10599 u8 **maskp = va_arg (*args, u8 **);
10601 u8 found_something = 0;
10604 #define _(a) u8 a=0;
10605 foreach_ip4_proto_field;
10611 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10613 if (unformat (input, "version"))
10615 else if (unformat (input, "hdr_length"))
10617 else if (unformat (input, "src"))
10619 else if (unformat (input, "dst"))
10621 else if (unformat (input, "proto"))
10624 #define _(a) else if (unformat (input, #a)) a=1;
10625 foreach_ip4_proto_field
10631 #define _(a) found_something += a;
10632 foreach_ip4_proto_field;
10635 if (found_something == 0)
10638 vec_validate (mask, sizeof (*ip) - 1);
10640 ip = (ip4_header_t *) mask;
10642 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
10643 foreach_ip4_proto_field;
10646 ip->ip_version_and_header_length = 0;
10649 ip->ip_version_and_header_length |= 0xF0;
10652 ip->ip_version_and_header_length |= 0x0F;
10658 #define foreach_ip6_proto_field \
10661 _(payload_length) \
10666 unformat_ip6_mask (unformat_input_t * input, va_list * args)
10668 u8 **maskp = va_arg (*args, u8 **);
10670 u8 found_something = 0;
10672 u32 ip_version_traffic_class_and_flow_label;
10674 #define _(a) u8 a=0;
10675 foreach_ip6_proto_field;
10678 u8 traffic_class = 0;
10681 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10683 if (unformat (input, "version"))
10685 else if (unformat (input, "traffic-class"))
10687 else if (unformat (input, "flow-label"))
10689 else if (unformat (input, "src"))
10691 else if (unformat (input, "dst"))
10693 else if (unformat (input, "proto"))
10696 #define _(a) else if (unformat (input, #a)) a=1;
10697 foreach_ip6_proto_field
10703 #define _(a) found_something += a;
10704 foreach_ip6_proto_field;
10707 if (found_something == 0)
10710 vec_validate (mask, sizeof (*ip) - 1);
10712 ip = (ip6_header_t *) mask;
10714 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
10715 foreach_ip6_proto_field;
10718 ip_version_traffic_class_and_flow_label = 0;
10721 ip_version_traffic_class_and_flow_label |= 0xF0000000;
10724 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
10727 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
10729 ip->ip_version_traffic_class_and_flow_label =
10730 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
10737 unformat_l3_mask (unformat_input_t * input, va_list * args)
10739 u8 **maskp = va_arg (*args, u8 **);
10741 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10743 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
10745 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
10754 unformat_l2_mask (unformat_input_t * input, va_list * args)
10756 u8 **maskp = va_arg (*args, u8 **);
10763 u8 ignore_tag1 = 0;
10764 u8 ignore_tag2 = 0;
10771 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10773 if (unformat (input, "src"))
10775 else if (unformat (input, "dst"))
10777 else if (unformat (input, "proto"))
10779 else if (unformat (input, "tag1"))
10781 else if (unformat (input, "tag2"))
10783 else if (unformat (input, "ignore-tag1"))
10785 else if (unformat (input, "ignore-tag2"))
10787 else if (unformat (input, "cos1"))
10789 else if (unformat (input, "cos2"))
10791 else if (unformat (input, "dot1q"))
10793 else if (unformat (input, "dot1ad"))
10798 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
10799 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
10802 if (tag1 || ignore_tag1 || cos1 || dot1q)
10804 if (tag2 || ignore_tag2 || cos2 || dot1ad)
10807 vec_validate (mask, len - 1);
10810 memset (mask, 0xff, 6);
10813 memset (mask + 6, 0xff, 6);
10815 if (tag2 || dot1ad)
10817 /* inner vlan tag */
10826 mask[21] = mask[20] = 0xff;
10847 mask[16] = mask[17] = 0xff;
10857 mask[12] = mask[13] = 0xff;
10864 unformat_classify_mask (unformat_input_t * input, va_list * args)
10866 u8 **maskp = va_arg (*args, u8 **);
10867 u32 *skipp = va_arg (*args, u32 *);
10868 u32 *matchp = va_arg (*args, u32 *);
10876 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10878 if (unformat (input, "hex %U", unformat_hex_string, &mask))
10880 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
10882 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
10884 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
10898 if (mask || l2 || l3 || l4)
10900 if (l2 || l3 || l4)
10902 /* "With a free Ethernet header in every package" */
10904 vec_validate (l2, 13);
10908 vec_append (mask, l3);
10913 vec_append (mask, l4);
10918 /* Scan forward looking for the first significant mask octet */
10919 for (i = 0; i < vec_len (mask); i++)
10923 /* compute (skip, match) params */
10924 *skipp = i / sizeof (u32x4);
10925 vec_delete (mask, *skipp * sizeof (u32x4), 0);
10927 /* Pad mask to an even multiple of the vector size */
10928 while (vec_len (mask) % sizeof (u32x4))
10929 vec_add1 (mask, 0);
10931 match = vec_len (mask) / sizeof (u32x4);
10933 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
10935 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
10936 if (*tmp || *(tmp + 1))
10941 clib_warning ("BUG: match 0");
10943 _vec_len (mask) = match * sizeof (u32x4);
10953 #endif /* VPP_API_TEST_BUILTIN */
10955 #define foreach_l2_next \
10957 _(ethernet, ETHERNET_INPUT) \
10958 _(ip4, IP4_INPUT) \
10962 unformat_l2_next_index (unformat_input_t * input, va_list * args)
10964 u32 *miss_next_indexp = va_arg (*args, u32 *);
10965 u32 next_index = 0;
10969 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
10973 if (unformat (input, "%d", &tmp))
10982 *miss_next_indexp = next_index;
10986 #define foreach_ip_next \
10989 _(rewrite, REWRITE)
10992 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
10994 u32 *miss_next_indexp = va_arg (*args, u32 *);
10995 u32 next_index = 0;
10999 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
11003 if (unformat (input, "%d", &tmp))
11012 *miss_next_indexp = next_index;
11016 #define foreach_acl_next \
11020 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
11022 u32 *miss_next_indexp = va_arg (*args, u32 *);
11023 u32 next_index = 0;
11027 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
11031 if (unformat (input, "permit"))
11036 else if (unformat (input, "%d", &tmp))
11045 *miss_next_indexp = next_index;
11050 unformat_policer_precolor (unformat_input_t * input, va_list * args)
11052 u32 *r = va_arg (*args, u32 *);
11054 if (unformat (input, "conform-color"))
11055 *r = POLICE_CONFORM;
11056 else if (unformat (input, "exceed-color"))
11057 *r = POLICE_EXCEED;
11065 api_classify_add_del_table (vat_main_t * vam)
11067 unformat_input_t *i = vam->input;
11068 vl_api_classify_add_del_table_t *mp;
11075 u32 table_index = ~0;
11076 u32 next_table_index = ~0;
11077 u32 miss_next_index = ~0;
11078 u32 memory_size = 32 << 20;
11080 u32 current_data_flag = 0;
11081 int current_data_offset = 0;
11084 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11086 if (unformat (i, "del"))
11088 else if (unformat (i, "del-chain"))
11093 else if (unformat (i, "buckets %d", &nbuckets))
11095 else if (unformat (i, "memory_size %d", &memory_size))
11097 else if (unformat (i, "skip %d", &skip))
11099 else if (unformat (i, "match %d", &match))
11101 else if (unformat (i, "table %d", &table_index))
11103 else if (unformat (i, "mask %U", unformat_classify_mask,
11104 &mask, &skip, &match))
11106 else if (unformat (i, "next-table %d", &next_table_index))
11108 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
11111 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
11114 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
11117 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
11119 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
11125 if (is_add && mask == 0)
11127 errmsg ("Mask required");
11131 if (is_add && skip == ~0)
11133 errmsg ("skip count required");
11137 if (is_add && match == ~0)
11139 errmsg ("match count required");
11143 if (!is_add && table_index == ~0)
11145 errmsg ("table index required for delete");
11149 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
11151 mp->is_add = is_add;
11152 mp->del_chain = del_chain;
11153 mp->table_index = ntohl (table_index);
11154 mp->nbuckets = ntohl (nbuckets);
11155 mp->memory_size = ntohl (memory_size);
11156 mp->skip_n_vectors = ntohl (skip);
11157 mp->match_n_vectors = ntohl (match);
11158 mp->next_table_index = ntohl (next_table_index);
11159 mp->miss_next_index = ntohl (miss_next_index);
11160 mp->current_data_flag = ntohl (current_data_flag);
11161 mp->current_data_offset = ntohl (current_data_offset);
11162 clib_memcpy (mp->mask, mask, vec_len (mask));
11171 #if VPP_API_TEST_BUILTIN == 0
11173 unformat_l4_match (unformat_input_t * input, va_list * args)
11175 u8 **matchp = va_arg (*args, u8 **);
11177 u8 *proto_header = 0;
11183 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11185 if (unformat (input, "src_port %d", &src_port))
11187 else if (unformat (input, "dst_port %d", &dst_port))
11193 h.src_port = clib_host_to_net_u16 (src_port);
11194 h.dst_port = clib_host_to_net_u16 (dst_port);
11195 vec_validate (proto_header, sizeof (h) - 1);
11196 memcpy (proto_header, &h, sizeof (h));
11198 *matchp = proto_header;
11204 unformat_ip4_match (unformat_input_t * input, va_list * args)
11206 u8 **matchp = va_arg (*args, u8 **);
11211 int hdr_length = 0;
11212 u32 hdr_length_val;
11213 int src = 0, dst = 0;
11214 ip4_address_t src_val, dst_val;
11221 int fragment_id = 0;
11222 u32 fragment_id_val;
11228 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11230 if (unformat (input, "version %d", &version_val))
11232 else if (unformat (input, "hdr_length %d", &hdr_length_val))
11234 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
11236 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
11238 else if (unformat (input, "proto %d", &proto_val))
11240 else if (unformat (input, "tos %d", &tos_val))
11242 else if (unformat (input, "length %d", &length_val))
11244 else if (unformat (input, "fragment_id %d", &fragment_id_val))
11246 else if (unformat (input, "ttl %d", &ttl_val))
11248 else if (unformat (input, "checksum %d", &checksum_val))
11254 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
11255 + ttl + checksum == 0)
11259 * Aligned because we use the real comparison functions
11261 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11263 ip = (ip4_header_t *) match;
11265 /* These are realistically matched in practice */
11267 ip->src_address.as_u32 = src_val.as_u32;
11270 ip->dst_address.as_u32 = dst_val.as_u32;
11273 ip->protocol = proto_val;
11276 /* These are not, but they're included for completeness */
11278 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
11281 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
11287 ip->length = clib_host_to_net_u16 (length_val);
11293 ip->checksum = clib_host_to_net_u16 (checksum_val);
11300 unformat_ip6_match (unformat_input_t * input, va_list * args)
11302 u8 **matchp = va_arg (*args, u8 **);
11307 u8 traffic_class = 0;
11308 u32 traffic_class_val = 0;
11311 int src = 0, dst = 0;
11312 ip6_address_t src_val, dst_val;
11315 int payload_length = 0;
11316 u32 payload_length_val;
11319 u32 ip_version_traffic_class_and_flow_label;
11321 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11323 if (unformat (input, "version %d", &version_val))
11325 else if (unformat (input, "traffic_class %d", &traffic_class_val))
11327 else if (unformat (input, "flow_label %d", &flow_label_val))
11329 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
11331 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
11333 else if (unformat (input, "proto %d", &proto_val))
11335 else if (unformat (input, "payload_length %d", &payload_length_val))
11336 payload_length = 1;
11337 else if (unformat (input, "hop_limit %d", &hop_limit_val))
11343 if (version + traffic_class + flow_label + src + dst + proto +
11344 payload_length + hop_limit == 0)
11348 * Aligned because we use the real comparison functions
11350 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
11352 ip = (ip6_header_t *) match;
11355 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
11358 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
11361 ip->protocol = proto_val;
11363 ip_version_traffic_class_and_flow_label = 0;
11366 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
11369 ip_version_traffic_class_and_flow_label |=
11370 (traffic_class_val & 0xFF) << 20;
11373 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
11375 ip->ip_version_traffic_class_and_flow_label =
11376 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
11378 if (payload_length)
11379 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
11382 ip->hop_limit = hop_limit_val;
11389 unformat_l3_match (unformat_input_t * input, va_list * args)
11391 u8 **matchp = va_arg (*args, u8 **);
11393 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11395 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
11397 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
11406 unformat_vlan_tag (unformat_input_t * input, va_list * args)
11408 u8 *tagp = va_arg (*args, u8 *);
11411 if (unformat (input, "%d", &tag))
11413 tagp[0] = (tag >> 8) & 0x0F;
11414 tagp[1] = tag & 0xFF;
11422 unformat_l2_match (unformat_input_t * input, va_list * args)
11424 u8 **matchp = va_arg (*args, u8 **);
11437 u8 ignore_tag1 = 0;
11438 u8 ignore_tag2 = 0;
11444 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11446 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
11449 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
11451 else if (unformat (input, "proto %U",
11452 unformat_ethernet_type_host_byte_order, &proto_val))
11454 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
11456 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
11458 else if (unformat (input, "ignore-tag1"))
11460 else if (unformat (input, "ignore-tag2"))
11462 else if (unformat (input, "cos1 %d", &cos1_val))
11464 else if (unformat (input, "cos2 %d", &cos2_val))
11469 if ((src + dst + proto + tag1 + tag2 +
11470 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
11473 if (tag1 || ignore_tag1 || cos1)
11475 if (tag2 || ignore_tag2 || cos2)
11478 vec_validate_aligned (match, len - 1, sizeof (u32x4));
11481 clib_memcpy (match, dst_val, 6);
11484 clib_memcpy (match + 6, src_val, 6);
11488 /* inner vlan tag */
11489 match[19] = tag2_val[1];
11490 match[18] = tag2_val[0];
11492 match[18] |= (cos2_val & 0x7) << 5;
11495 match[21] = proto_val & 0xff;
11496 match[20] = proto_val >> 8;
11500 match[15] = tag1_val[1];
11501 match[14] = tag1_val[0];
11504 match[14] |= (cos1_val & 0x7) << 5;
11510 match[15] = tag1_val[1];
11511 match[14] = tag1_val[0];
11514 match[17] = proto_val & 0xff;
11515 match[16] = proto_val >> 8;
11518 match[14] |= (cos1_val & 0x7) << 5;
11524 match[18] |= (cos2_val & 0x7) << 5;
11526 match[14] |= (cos1_val & 0x7) << 5;
11529 match[13] = proto_val & 0xff;
11530 match[12] = proto_val >> 8;
11539 api_unformat_classify_match (unformat_input_t * input, va_list * args)
11541 u8 **matchp = va_arg (*args, u8 **);
11542 u32 skip_n_vectors = va_arg (*args, u32);
11543 u32 match_n_vectors = va_arg (*args, u32);
11550 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11552 if (unformat (input, "hex %U", unformat_hex_string, &match))
11554 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
11556 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
11558 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
11572 if (match || l2 || l3 || l4)
11574 if (l2 || l3 || l4)
11576 /* "Win a free Ethernet header in every packet" */
11578 vec_validate_aligned (l2, 13, sizeof (u32x4));
11582 vec_append_aligned (match, l3, sizeof (u32x4));
11587 vec_append_aligned (match, l4, sizeof (u32x4));
11592 /* Make sure the vector is big enough even if key is all 0's */
11593 vec_validate_aligned
11594 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
11597 /* Set size, include skipped vectors */
11598 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
11609 api_classify_add_del_session (vat_main_t * vam)
11611 unformat_input_t *i = vam->input;
11612 vl_api_classify_add_del_session_t *mp;
11614 u32 table_index = ~0;
11615 u32 hit_next_index = ~0;
11616 u32 opaque_index = ~0;
11619 u32 skip_n_vectors = 0;
11620 u32 match_n_vectors = 0;
11626 * Warning: you have to supply skip_n and match_n
11627 * because the API client cant simply look at the classify
11631 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11633 if (unformat (i, "del"))
11635 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
11638 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
11641 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
11644 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
11646 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
11648 else if (unformat (i, "opaque-index %d", &opaque_index))
11650 else if (unformat (i, "skip_n %d", &skip_n_vectors))
11652 else if (unformat (i, "match_n %d", &match_n_vectors))
11654 else if (unformat (i, "match %U", api_unformat_classify_match,
11655 &match, skip_n_vectors, match_n_vectors))
11657 else if (unformat (i, "advance %d", &advance))
11659 else if (unformat (i, "table-index %d", &table_index))
11661 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
11663 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
11665 else if (unformat (i, "action %d", &action))
11667 else if (unformat (i, "metadata %d", &metadata))
11673 if (table_index == ~0)
11675 errmsg ("Table index required");
11679 if (is_add && match == 0)
11681 errmsg ("Match value required");
11685 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
11687 mp->is_add = is_add;
11688 mp->table_index = ntohl (table_index);
11689 mp->hit_next_index = ntohl (hit_next_index);
11690 mp->opaque_index = ntohl (opaque_index);
11691 mp->advance = ntohl (advance);
11692 mp->action = action;
11693 mp->metadata = ntohl (metadata);
11694 clib_memcpy (mp->match, match, vec_len (match));
11703 api_classify_set_interface_ip_table (vat_main_t * vam)
11705 unformat_input_t *i = vam->input;
11706 vl_api_classify_set_interface_ip_table_t *mp;
11708 int sw_if_index_set;
11709 u32 table_index = ~0;
11713 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11715 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11716 sw_if_index_set = 1;
11717 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11718 sw_if_index_set = 1;
11719 else if (unformat (i, "table %d", &table_index))
11723 clib_warning ("parse error '%U'", format_unformat_error, i);
11728 if (sw_if_index_set == 0)
11730 errmsg ("missing interface name or sw_if_index");
11735 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
11737 mp->sw_if_index = ntohl (sw_if_index);
11738 mp->table_index = ntohl (table_index);
11739 mp->is_ipv6 = is_ipv6;
11747 api_classify_set_interface_l2_tables (vat_main_t * vam)
11749 unformat_input_t *i = vam->input;
11750 vl_api_classify_set_interface_l2_tables_t *mp;
11752 int sw_if_index_set;
11753 u32 ip4_table_index = ~0;
11754 u32 ip6_table_index = ~0;
11755 u32 other_table_index = ~0;
11759 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11761 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11762 sw_if_index_set = 1;
11763 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11764 sw_if_index_set = 1;
11765 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11767 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11769 else if (unformat (i, "other-table %d", &other_table_index))
11771 else if (unformat (i, "is-input %d", &is_input))
11775 clib_warning ("parse error '%U'", format_unformat_error, i);
11780 if (sw_if_index_set == 0)
11782 errmsg ("missing interface name or sw_if_index");
11787 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
11789 mp->sw_if_index = ntohl (sw_if_index);
11790 mp->ip4_table_index = ntohl (ip4_table_index);
11791 mp->ip6_table_index = ntohl (ip6_table_index);
11792 mp->other_table_index = ntohl (other_table_index);
11793 mp->is_input = (u8) is_input;
11801 api_set_ipfix_exporter (vat_main_t * vam)
11803 unformat_input_t *i = vam->input;
11804 vl_api_set_ipfix_exporter_t *mp;
11805 ip4_address_t collector_address;
11806 u8 collector_address_set = 0;
11807 u32 collector_port = ~0;
11808 ip4_address_t src_address;
11809 u8 src_address_set = 0;
11812 u32 template_interval = ~0;
11813 u8 udp_checksum = 0;
11816 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11818 if (unformat (i, "collector_address %U", unformat_ip4_address,
11819 &collector_address))
11820 collector_address_set = 1;
11821 else if (unformat (i, "collector_port %d", &collector_port))
11823 else if (unformat (i, "src_address %U", unformat_ip4_address,
11825 src_address_set = 1;
11826 else if (unformat (i, "vrf_id %d", &vrf_id))
11828 else if (unformat (i, "path_mtu %d", &path_mtu))
11830 else if (unformat (i, "template_interval %d", &template_interval))
11832 else if (unformat (i, "udp_checksum"))
11838 if (collector_address_set == 0)
11840 errmsg ("collector_address required");
11844 if (src_address_set == 0)
11846 errmsg ("src_address required");
11850 M (SET_IPFIX_EXPORTER, mp);
11852 memcpy (mp->collector_address, collector_address.data,
11853 sizeof (collector_address.data));
11854 mp->collector_port = htons ((u16) collector_port);
11855 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
11856 mp->vrf_id = htonl (vrf_id);
11857 mp->path_mtu = htonl (path_mtu);
11858 mp->template_interval = htonl (template_interval);
11859 mp->udp_checksum = udp_checksum;
11867 api_set_ipfix_classify_stream (vat_main_t * vam)
11869 unformat_input_t *i = vam->input;
11870 vl_api_set_ipfix_classify_stream_t *mp;
11872 u32 src_port = UDP_DST_PORT_ipfix;
11875 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11877 if (unformat (i, "domain %d", &domain_id))
11879 else if (unformat (i, "src_port %d", &src_port))
11883 errmsg ("unknown input `%U'", format_unformat_error, i);
11888 M (SET_IPFIX_CLASSIFY_STREAM, mp);
11890 mp->domain_id = htonl (domain_id);
11891 mp->src_port = htons ((u16) src_port);
11899 api_ipfix_classify_table_add_del (vat_main_t * vam)
11901 unformat_input_t *i = vam->input;
11902 vl_api_ipfix_classify_table_add_del_t *mp;
11904 u32 classify_table_index = ~0;
11906 u8 transport_protocol = 255;
11909 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11911 if (unformat (i, "add"))
11913 else if (unformat (i, "del"))
11915 else if (unformat (i, "table %d", &classify_table_index))
11917 else if (unformat (i, "ip4"))
11919 else if (unformat (i, "ip6"))
11921 else if (unformat (i, "tcp"))
11922 transport_protocol = 6;
11923 else if (unformat (i, "udp"))
11924 transport_protocol = 17;
11927 errmsg ("unknown input `%U'", format_unformat_error, i);
11934 errmsg ("expecting: add|del");
11937 if (classify_table_index == ~0)
11939 errmsg ("classifier table not specified");
11942 if (ip_version == 0)
11944 errmsg ("IP version not specified");
11948 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
11950 mp->is_add = is_add;
11951 mp->table_id = htonl (classify_table_index);
11952 mp->ip_version = ip_version;
11953 mp->transport_protocol = transport_protocol;
11961 api_get_node_index (vat_main_t * vam)
11963 unformat_input_t *i = vam->input;
11964 vl_api_get_node_index_t *mp;
11968 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11970 if (unformat (i, "node %s", &name))
11977 errmsg ("node name required");
11980 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
11982 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
11986 M (GET_NODE_INDEX, mp);
11987 clib_memcpy (mp->node_name, name, vec_len (name));
11996 api_get_next_index (vat_main_t * vam)
11998 unformat_input_t *i = vam->input;
11999 vl_api_get_next_index_t *mp;
12000 u8 *node_name = 0, *next_node_name = 0;
12003 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12005 if (unformat (i, "node-name %s", &node_name))
12007 else if (unformat (i, "next-node-name %s", &next_node_name))
12011 if (node_name == 0)
12013 errmsg ("node name required");
12016 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
12018 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12022 if (next_node_name == 0)
12024 errmsg ("next node name required");
12027 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
12029 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
12033 M (GET_NEXT_INDEX, mp);
12034 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
12035 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
12036 vec_free (node_name);
12037 vec_free (next_node_name);
12045 api_add_node_next (vat_main_t * vam)
12047 unformat_input_t *i = vam->input;
12048 vl_api_add_node_next_t *mp;
12053 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12055 if (unformat (i, "node %s", &name))
12057 else if (unformat (i, "next %s", &next))
12064 errmsg ("node name required");
12067 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
12069 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
12074 errmsg ("next node required");
12077 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
12079 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
12083 M (ADD_NODE_NEXT, mp);
12084 clib_memcpy (mp->node_name, name, vec_len (name));
12085 clib_memcpy (mp->next_name, next, vec_len (next));
12095 api_l2tpv3_create_tunnel (vat_main_t * vam)
12097 unformat_input_t *i = vam->input;
12098 ip6_address_t client_address, our_address;
12099 int client_address_set = 0;
12100 int our_address_set = 0;
12101 u32 local_session_id = 0;
12102 u32 remote_session_id = 0;
12103 u64 local_cookie = 0;
12104 u64 remote_cookie = 0;
12105 u8 l2_sublayer_present = 0;
12106 vl_api_l2tpv3_create_tunnel_t *mp;
12109 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12111 if (unformat (i, "client_address %U", unformat_ip6_address,
12113 client_address_set = 1;
12114 else if (unformat (i, "our_address %U", unformat_ip6_address,
12116 our_address_set = 1;
12117 else if (unformat (i, "local_session_id %d", &local_session_id))
12119 else if (unformat (i, "remote_session_id %d", &remote_session_id))
12121 else if (unformat (i, "local_cookie %lld", &local_cookie))
12123 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
12125 else if (unformat (i, "l2-sublayer-present"))
12126 l2_sublayer_present = 1;
12131 if (client_address_set == 0)
12133 errmsg ("client_address required");
12137 if (our_address_set == 0)
12139 errmsg ("our_address required");
12143 M (L2TPV3_CREATE_TUNNEL, mp);
12145 clib_memcpy (mp->client_address, client_address.as_u8,
12146 sizeof (mp->client_address));
12148 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
12150 mp->local_session_id = ntohl (local_session_id);
12151 mp->remote_session_id = ntohl (remote_session_id);
12152 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
12153 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
12154 mp->l2_sublayer_present = l2_sublayer_present;
12163 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
12165 unformat_input_t *i = vam->input;
12167 u8 sw_if_index_set = 0;
12168 u64 new_local_cookie = 0;
12169 u64 new_remote_cookie = 0;
12170 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
12173 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12175 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12176 sw_if_index_set = 1;
12177 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12178 sw_if_index_set = 1;
12179 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
12181 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
12187 if (sw_if_index_set == 0)
12189 errmsg ("missing interface name or sw_if_index");
12193 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
12195 mp->sw_if_index = ntohl (sw_if_index);
12196 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
12197 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
12205 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
12207 unformat_input_t *i = vam->input;
12208 vl_api_l2tpv3_interface_enable_disable_t *mp;
12210 u8 sw_if_index_set = 0;
12211 u8 enable_disable = 1;
12214 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12216 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12217 sw_if_index_set = 1;
12218 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12219 sw_if_index_set = 1;
12220 else if (unformat (i, "enable"))
12221 enable_disable = 1;
12222 else if (unformat (i, "disable"))
12223 enable_disable = 0;
12228 if (sw_if_index_set == 0)
12230 errmsg ("missing interface name or sw_if_index");
12234 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
12236 mp->sw_if_index = ntohl (sw_if_index);
12237 mp->enable_disable = enable_disable;
12245 api_l2tpv3_set_lookup_key (vat_main_t * vam)
12247 unformat_input_t *i = vam->input;
12248 vl_api_l2tpv3_set_lookup_key_t *mp;
12252 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12254 if (unformat (i, "lookup_v6_src"))
12255 key = L2T_LOOKUP_SRC_ADDRESS;
12256 else if (unformat (i, "lookup_v6_dst"))
12257 key = L2T_LOOKUP_DST_ADDRESS;
12258 else if (unformat (i, "lookup_session_id"))
12259 key = L2T_LOOKUP_SESSION_ID;
12264 if (key == (u8) ~ 0)
12266 errmsg ("l2tp session lookup key unset");
12270 M (L2TPV3_SET_LOOKUP_KEY, mp);
12279 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
12280 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12282 vat_main_t *vam = &vat_main;
12284 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
12285 format_ip6_address, mp->our_address,
12286 format_ip6_address, mp->client_address,
12287 clib_net_to_host_u32 (mp->sw_if_index));
12290 " local cookies %016llx %016llx remote cookie %016llx",
12291 clib_net_to_host_u64 (mp->local_cookie[0]),
12292 clib_net_to_host_u64 (mp->local_cookie[1]),
12293 clib_net_to_host_u64 (mp->remote_cookie));
12295 print (vam->ofp, " local session-id %d remote session-id %d",
12296 clib_net_to_host_u32 (mp->local_session_id),
12297 clib_net_to_host_u32 (mp->remote_session_id));
12299 print (vam->ofp, " l2 specific sublayer %s\n",
12300 mp->l2_sublayer_present ? "preset" : "absent");
12304 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
12305 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
12307 vat_main_t *vam = &vat_main;
12308 vat_json_node_t *node = NULL;
12309 struct in6_addr addr;
12311 if (VAT_JSON_ARRAY != vam->json_tree.type)
12313 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12314 vat_json_init_array (&vam->json_tree);
12316 node = vat_json_array_add (&vam->json_tree);
12318 vat_json_init_object (node);
12320 clib_memcpy (&addr, mp->our_address, sizeof (addr));
12321 vat_json_object_add_ip6 (node, "our_address", addr);
12322 clib_memcpy (&addr, mp->client_address, sizeof (addr));
12323 vat_json_object_add_ip6 (node, "client_address", addr);
12325 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
12326 vat_json_init_array (lc);
12327 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
12328 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
12329 vat_json_object_add_uint (node, "remote_cookie",
12330 clib_net_to_host_u64 (mp->remote_cookie));
12332 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
12333 vat_json_object_add_uint (node, "local_session_id",
12334 clib_net_to_host_u32 (mp->local_session_id));
12335 vat_json_object_add_uint (node, "remote_session_id",
12336 clib_net_to_host_u32 (mp->remote_session_id));
12337 vat_json_object_add_string_copy (node, "l2_sublayer",
12338 mp->l2_sublayer_present ? (u8 *) "present"
12339 : (u8 *) "absent");
12343 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
12345 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
12346 vl_api_control_ping_t *mp_ping;
12349 /* Get list of l2tpv3-tunnel interfaces */
12350 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
12353 /* Use a control ping for synchronization */
12354 MPING (CONTROL_PING, mp_ping);
12362 static void vl_api_sw_interface_tap_details_t_handler
12363 (vl_api_sw_interface_tap_details_t * mp)
12365 vat_main_t *vam = &vat_main;
12367 print (vam->ofp, "%-16s %d",
12368 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
12371 static void vl_api_sw_interface_tap_details_t_handler_json
12372 (vl_api_sw_interface_tap_details_t * mp)
12374 vat_main_t *vam = &vat_main;
12375 vat_json_node_t *node = NULL;
12377 if (VAT_JSON_ARRAY != vam->json_tree.type)
12379 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12380 vat_json_init_array (&vam->json_tree);
12382 node = vat_json_array_add (&vam->json_tree);
12384 vat_json_init_object (node);
12385 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12386 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
12390 api_sw_interface_tap_dump (vat_main_t * vam)
12392 vl_api_sw_interface_tap_dump_t *mp;
12393 vl_api_control_ping_t *mp_ping;
12396 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
12397 /* Get list of tap interfaces */
12398 M (SW_INTERFACE_TAP_DUMP, mp);
12401 /* Use a control ping for synchronization */
12402 MPING (CONTROL_PING, mp_ping);
12409 static void vl_api_sw_interface_tap_v2_details_t_handler
12410 (vl_api_sw_interface_tap_v2_details_t * mp)
12412 vat_main_t *vam = &vat_main;
12414 print (vam->ofp, "%-16s %d",
12415 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
12418 static void vl_api_sw_interface_tap_v2_details_t_handler_json
12419 (vl_api_sw_interface_tap_v2_details_t * mp)
12421 vat_main_t *vam = &vat_main;
12422 vat_json_node_t *node = NULL;
12424 if (VAT_JSON_ARRAY != vam->json_tree.type)
12426 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12427 vat_json_init_array (&vam->json_tree);
12429 node = vat_json_array_add (&vam->json_tree);
12431 vat_json_init_object (node);
12432 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12433 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
12437 api_sw_interface_tap_v2_dump (vat_main_t * vam)
12439 vl_api_sw_interface_tap_v2_dump_t *mp;
12440 vl_api_control_ping_t *mp_ping;
12443 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
12444 /* Get list of tap interfaces */
12445 M (SW_INTERFACE_TAP_V2_DUMP, mp);
12448 /* Use a control ping for synchronization */
12449 MPING (CONTROL_PING, mp_ping);
12456 static uword unformat_vxlan_decap_next
12457 (unformat_input_t * input, va_list * args)
12459 u32 *result = va_arg (*args, u32 *);
12462 if (unformat (input, "l2"))
12463 *result = VXLAN_INPUT_NEXT_L2_INPUT;
12464 else if (unformat (input, "%d", &tmp))
12472 api_vxlan_add_del_tunnel (vat_main_t * vam)
12474 unformat_input_t *line_input = vam->input;
12475 vl_api_vxlan_add_del_tunnel_t *mp;
12476 ip46_address_t src, dst;
12478 u8 ipv4_set = 0, ipv6_set = 0;
12482 u32 mcast_sw_if_index = ~0;
12483 u32 encap_vrf_id = 0;
12484 u32 decap_next_index = ~0;
12488 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12489 memset (&src, 0, sizeof src);
12490 memset (&dst, 0, sizeof dst);
12492 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12494 if (unformat (line_input, "del"))
12497 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12503 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12509 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12515 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12520 else if (unformat (line_input, "group %U %U",
12521 unformat_ip4_address, &dst.ip4,
12522 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12524 grp_set = dst_set = 1;
12527 else if (unformat (line_input, "group %U",
12528 unformat_ip4_address, &dst.ip4))
12530 grp_set = dst_set = 1;
12533 else if (unformat (line_input, "group %U %U",
12534 unformat_ip6_address, &dst.ip6,
12535 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12537 grp_set = dst_set = 1;
12540 else if (unformat (line_input, "group %U",
12541 unformat_ip6_address, &dst.ip6))
12543 grp_set = dst_set = 1;
12547 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12549 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12551 else if (unformat (line_input, "decap-next %U",
12552 unformat_vxlan_decap_next, &decap_next_index))
12554 else if (unformat (line_input, "vni %d", &vni))
12558 errmsg ("parse error '%U'", format_unformat_error, line_input);
12565 errmsg ("tunnel src address not specified");
12570 errmsg ("tunnel dst address not specified");
12574 if (grp_set && !ip46_address_is_multicast (&dst))
12576 errmsg ("tunnel group address not multicast");
12579 if (grp_set && mcast_sw_if_index == ~0)
12581 errmsg ("tunnel nonexistent multicast device");
12584 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12586 errmsg ("tunnel dst address must be unicast");
12591 if (ipv4_set && ipv6_set)
12593 errmsg ("both IPv4 and IPv6 addresses specified");
12597 if ((vni == 0) || (vni >> 24))
12599 errmsg ("vni not specified or out of range");
12603 M (VXLAN_ADD_DEL_TUNNEL, mp);
12607 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
12608 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
12612 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
12613 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
12615 mp->encap_vrf_id = ntohl (encap_vrf_id);
12616 mp->decap_next_index = ntohl (decap_next_index);
12617 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12618 mp->vni = ntohl (vni);
12619 mp->is_add = is_add;
12620 mp->is_ipv6 = ipv6_set;
12627 static void vl_api_vxlan_tunnel_details_t_handler
12628 (vl_api_vxlan_tunnel_details_t * mp)
12630 vat_main_t *vam = &vat_main;
12631 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12632 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12634 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12635 ntohl (mp->sw_if_index),
12636 format_ip46_address, &src, IP46_TYPE_ANY,
12637 format_ip46_address, &dst, IP46_TYPE_ANY,
12638 ntohl (mp->encap_vrf_id),
12639 ntohl (mp->decap_next_index), ntohl (mp->vni),
12640 ntohl (mp->mcast_sw_if_index));
12643 static void vl_api_vxlan_tunnel_details_t_handler_json
12644 (vl_api_vxlan_tunnel_details_t * mp)
12646 vat_main_t *vam = &vat_main;
12647 vat_json_node_t *node = NULL;
12649 if (VAT_JSON_ARRAY != vam->json_tree.type)
12651 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12652 vat_json_init_array (&vam->json_tree);
12654 node = vat_json_array_add (&vam->json_tree);
12656 vat_json_init_object (node);
12657 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12660 struct in6_addr ip6;
12662 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12663 vat_json_object_add_ip6 (node, "src_address", ip6);
12664 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12665 vat_json_object_add_ip6 (node, "dst_address", ip6);
12669 struct in_addr ip4;
12671 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12672 vat_json_object_add_ip4 (node, "src_address", ip4);
12673 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12674 vat_json_object_add_ip4 (node, "dst_address", ip4);
12676 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12677 vat_json_object_add_uint (node, "decap_next_index",
12678 ntohl (mp->decap_next_index));
12679 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12680 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12681 vat_json_object_add_uint (node, "mcast_sw_if_index",
12682 ntohl (mp->mcast_sw_if_index));
12686 api_vxlan_tunnel_dump (vat_main_t * vam)
12688 unformat_input_t *i = vam->input;
12689 vl_api_vxlan_tunnel_dump_t *mp;
12690 vl_api_control_ping_t *mp_ping;
12692 u8 sw_if_index_set = 0;
12695 /* Parse args required to build the message */
12696 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12698 if (unformat (i, "sw_if_index %d", &sw_if_index))
12699 sw_if_index_set = 1;
12704 if (sw_if_index_set == 0)
12709 if (!vam->json_output)
12711 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12712 "sw_if_index", "src_address", "dst_address",
12713 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12716 /* Get list of vxlan-tunnel interfaces */
12717 M (VXLAN_TUNNEL_DUMP, mp);
12719 mp->sw_if_index = htonl (sw_if_index);
12723 /* Use a control ping for synchronization */
12724 MPING (CONTROL_PING, mp_ping);
12731 static uword unformat_geneve_decap_next
12732 (unformat_input_t * input, va_list * args)
12734 u32 *result = va_arg (*args, u32 *);
12737 if (unformat (input, "l2"))
12738 *result = GENEVE_INPUT_NEXT_L2_INPUT;
12739 else if (unformat (input, "%d", &tmp))
12747 api_geneve_add_del_tunnel (vat_main_t * vam)
12749 unformat_input_t *line_input = vam->input;
12750 vl_api_geneve_add_del_tunnel_t *mp;
12751 ip46_address_t src, dst;
12753 u8 ipv4_set = 0, ipv6_set = 0;
12757 u32 mcast_sw_if_index = ~0;
12758 u32 encap_vrf_id = 0;
12759 u32 decap_next_index = ~0;
12763 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
12764 memset (&src, 0, sizeof src);
12765 memset (&dst, 0, sizeof dst);
12767 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12769 if (unformat (line_input, "del"))
12772 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
12778 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
12784 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
12790 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
12795 else if (unformat (line_input, "group %U %U",
12796 unformat_ip4_address, &dst.ip4,
12797 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12799 grp_set = dst_set = 1;
12802 else if (unformat (line_input, "group %U",
12803 unformat_ip4_address, &dst.ip4))
12805 grp_set = dst_set = 1;
12808 else if (unformat (line_input, "group %U %U",
12809 unformat_ip6_address, &dst.ip6,
12810 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
12812 grp_set = dst_set = 1;
12815 else if (unformat (line_input, "group %U",
12816 unformat_ip6_address, &dst.ip6))
12818 grp_set = dst_set = 1;
12822 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
12824 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
12826 else if (unformat (line_input, "decap-next %U",
12827 unformat_geneve_decap_next, &decap_next_index))
12829 else if (unformat (line_input, "vni %d", &vni))
12833 errmsg ("parse error '%U'", format_unformat_error, line_input);
12840 errmsg ("tunnel src address not specified");
12845 errmsg ("tunnel dst address not specified");
12849 if (grp_set && !ip46_address_is_multicast (&dst))
12851 errmsg ("tunnel group address not multicast");
12854 if (grp_set && mcast_sw_if_index == ~0)
12856 errmsg ("tunnel nonexistent multicast device");
12859 if (grp_set == 0 && ip46_address_is_multicast (&dst))
12861 errmsg ("tunnel dst address must be unicast");
12866 if (ipv4_set && ipv6_set)
12868 errmsg ("both IPv4 and IPv6 addresses specified");
12872 if ((vni == 0) || (vni >> 24))
12874 errmsg ("vni not specified or out of range");
12878 M (GENEVE_ADD_DEL_TUNNEL, mp);
12882 clib_memcpy (mp->local_address, &src.ip6, sizeof (src.ip6));
12883 clib_memcpy (mp->remote_address, &dst.ip6, sizeof (dst.ip6));
12887 clib_memcpy (mp->local_address, &src.ip4, sizeof (src.ip4));
12888 clib_memcpy (mp->remote_address, &dst.ip4, sizeof (dst.ip4));
12890 mp->encap_vrf_id = ntohl (encap_vrf_id);
12891 mp->decap_next_index = ntohl (decap_next_index);
12892 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
12893 mp->vni = ntohl (vni);
12894 mp->is_add = is_add;
12895 mp->is_ipv6 = ipv6_set;
12902 static void vl_api_geneve_tunnel_details_t_handler
12903 (vl_api_geneve_tunnel_details_t * mp)
12905 vat_main_t *vam = &vat_main;
12906 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
12907 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
12909 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
12910 ntohl (mp->sw_if_index),
12911 format_ip46_address, &src, IP46_TYPE_ANY,
12912 format_ip46_address, &dst, IP46_TYPE_ANY,
12913 ntohl (mp->encap_vrf_id),
12914 ntohl (mp->decap_next_index), ntohl (mp->vni),
12915 ntohl (mp->mcast_sw_if_index));
12918 static void vl_api_geneve_tunnel_details_t_handler_json
12919 (vl_api_geneve_tunnel_details_t * mp)
12921 vat_main_t *vam = &vat_main;
12922 vat_json_node_t *node = NULL;
12924 if (VAT_JSON_ARRAY != vam->json_tree.type)
12926 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12927 vat_json_init_array (&vam->json_tree);
12929 node = vat_json_array_add (&vam->json_tree);
12931 vat_json_init_object (node);
12932 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
12935 struct in6_addr ip6;
12937 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
12938 vat_json_object_add_ip6 (node, "src_address", ip6);
12939 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
12940 vat_json_object_add_ip6 (node, "dst_address", ip6);
12944 struct in_addr ip4;
12946 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
12947 vat_json_object_add_ip4 (node, "src_address", ip4);
12948 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
12949 vat_json_object_add_ip4 (node, "dst_address", ip4);
12951 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
12952 vat_json_object_add_uint (node, "decap_next_index",
12953 ntohl (mp->decap_next_index));
12954 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
12955 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
12956 vat_json_object_add_uint (node, "mcast_sw_if_index",
12957 ntohl (mp->mcast_sw_if_index));
12961 api_geneve_tunnel_dump (vat_main_t * vam)
12963 unformat_input_t *i = vam->input;
12964 vl_api_geneve_tunnel_dump_t *mp;
12965 vl_api_control_ping_t *mp_ping;
12967 u8 sw_if_index_set = 0;
12970 /* Parse args required to build the message */
12971 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12973 if (unformat (i, "sw_if_index %d", &sw_if_index))
12974 sw_if_index_set = 1;
12979 if (sw_if_index_set == 0)
12984 if (!vam->json_output)
12986 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
12987 "sw_if_index", "local_address", "remote_address",
12988 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
12991 /* Get list of geneve-tunnel interfaces */
12992 M (GENEVE_TUNNEL_DUMP, mp);
12994 mp->sw_if_index = htonl (sw_if_index);
12998 /* Use a control ping for synchronization */
12999 M (CONTROL_PING, mp_ping);
13007 api_gre_add_del_tunnel (vat_main_t * vam)
13009 unformat_input_t *line_input = vam->input;
13010 vl_api_gre_add_del_tunnel_t *mp;
13011 ip4_address_t src4, dst4;
13012 ip6_address_t src6, dst6;
13019 u32 outer_fib_id = 0;
13022 memset (&src4, 0, sizeof src4);
13023 memset (&dst4, 0, sizeof dst4);
13024 memset (&src6, 0, sizeof src6);
13025 memset (&dst6, 0, sizeof dst6);
13027 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13029 if (unformat (line_input, "del"))
13031 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
13036 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
13041 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
13046 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
13051 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
13053 else if (unformat (line_input, "teb"))
13057 errmsg ("parse error '%U'", format_unformat_error, line_input);
13064 errmsg ("tunnel src address not specified");
13069 errmsg ("tunnel dst address not specified");
13072 if (ipv4_set && ipv6_set)
13074 errmsg ("both IPv4 and IPv6 addresses specified");
13079 M (GRE_ADD_DEL_TUNNEL, mp);
13083 clib_memcpy (&mp->src_address, &src4, 4);
13084 clib_memcpy (&mp->dst_address, &dst4, 4);
13088 clib_memcpy (&mp->src_address, &src6, 16);
13089 clib_memcpy (&mp->dst_address, &dst6, 16);
13091 mp->outer_fib_id = ntohl (outer_fib_id);
13092 mp->is_add = is_add;
13094 mp->is_ipv6 = ipv6_set;
13101 static void vl_api_gre_tunnel_details_t_handler
13102 (vl_api_gre_tunnel_details_t * mp)
13104 vat_main_t *vam = &vat_main;
13105 ip46_address_t src = to_ip46 (mp->is_ipv6, mp->src_address);
13106 ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->dst_address);
13108 print (vam->ofp, "%11d%24U%24U%6d%14d",
13109 ntohl (mp->sw_if_index),
13110 format_ip46_address, &src, IP46_TYPE_ANY,
13111 format_ip46_address, &dst, IP46_TYPE_ANY,
13112 mp->teb, ntohl (mp->outer_fib_id));
13115 static void vl_api_gre_tunnel_details_t_handler_json
13116 (vl_api_gre_tunnel_details_t * mp)
13118 vat_main_t *vam = &vat_main;
13119 vat_json_node_t *node = NULL;
13120 struct in_addr ip4;
13121 struct in6_addr ip6;
13123 if (VAT_JSON_ARRAY != vam->json_tree.type)
13125 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13126 vat_json_init_array (&vam->json_tree);
13128 node = vat_json_array_add (&vam->json_tree);
13130 vat_json_init_object (node);
13131 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13134 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
13135 vat_json_object_add_ip4 (node, "src_address", ip4);
13136 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
13137 vat_json_object_add_ip4 (node, "dst_address", ip4);
13141 clib_memcpy (&ip6, &mp->src_address, sizeof (ip6));
13142 vat_json_object_add_ip6 (node, "src_address", ip6);
13143 clib_memcpy (&ip6, &mp->dst_address, sizeof (ip6));
13144 vat_json_object_add_ip6 (node, "dst_address", ip6);
13146 vat_json_object_add_uint (node, "teb", mp->teb);
13147 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
13148 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6);
13152 api_gre_tunnel_dump (vat_main_t * vam)
13154 unformat_input_t *i = vam->input;
13155 vl_api_gre_tunnel_dump_t *mp;
13156 vl_api_control_ping_t *mp_ping;
13158 u8 sw_if_index_set = 0;
13161 /* Parse args required to build the message */
13162 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13164 if (unformat (i, "sw_if_index %d", &sw_if_index))
13165 sw_if_index_set = 1;
13170 if (sw_if_index_set == 0)
13175 if (!vam->json_output)
13177 print (vam->ofp, "%11s%24s%24s%6s%14s",
13178 "sw_if_index", "src_address", "dst_address", "teb",
13182 /* Get list of gre-tunnel interfaces */
13183 M (GRE_TUNNEL_DUMP, mp);
13185 mp->sw_if_index = htonl (sw_if_index);
13189 /* Use a control ping for synchronization */
13190 MPING (CONTROL_PING, mp_ping);
13198 api_l2_fib_clear_table (vat_main_t * vam)
13200 // unformat_input_t * i = vam->input;
13201 vl_api_l2_fib_clear_table_t *mp;
13204 M (L2_FIB_CLEAR_TABLE, mp);
13212 api_l2_interface_efp_filter (vat_main_t * vam)
13214 unformat_input_t *i = vam->input;
13215 vl_api_l2_interface_efp_filter_t *mp;
13218 u8 sw_if_index_set = 0;
13221 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13223 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13224 sw_if_index_set = 1;
13225 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13226 sw_if_index_set = 1;
13227 else if (unformat (i, "enable"))
13229 else if (unformat (i, "disable"))
13233 clib_warning ("parse error '%U'", format_unformat_error, i);
13238 if (sw_if_index_set == 0)
13240 errmsg ("missing sw_if_index");
13244 M (L2_INTERFACE_EFP_FILTER, mp);
13246 mp->sw_if_index = ntohl (sw_if_index);
13247 mp->enable_disable = enable;
13254 #define foreach_vtr_op \
13255 _("disable", L2_VTR_DISABLED) \
13256 _("push-1", L2_VTR_PUSH_1) \
13257 _("push-2", L2_VTR_PUSH_2) \
13258 _("pop-1", L2_VTR_POP_1) \
13259 _("pop-2", L2_VTR_POP_2) \
13260 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
13261 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
13262 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
13263 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
13266 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
13268 unformat_input_t *i = vam->input;
13269 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
13271 u8 sw_if_index_set = 0;
13274 u32 push_dot1q = 1;
13279 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13281 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13282 sw_if_index_set = 1;
13283 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13284 sw_if_index_set = 1;
13285 else if (unformat (i, "vtr_op %d", &vtr_op))
13287 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
13290 else if (unformat (i, "push_dot1q %d", &push_dot1q))
13292 else if (unformat (i, "tag1 %d", &tag1))
13294 else if (unformat (i, "tag2 %d", &tag2))
13298 clib_warning ("parse error '%U'", format_unformat_error, i);
13303 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
13305 errmsg ("missing vtr operation or sw_if_index");
13309 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
13310 mp->sw_if_index = ntohl (sw_if_index);
13311 mp->vtr_op = ntohl (vtr_op);
13312 mp->push_dot1q = ntohl (push_dot1q);
13313 mp->tag1 = ntohl (tag1);
13314 mp->tag2 = ntohl (tag2);
13322 api_create_vhost_user_if (vat_main_t * vam)
13324 unformat_input_t *i = vam->input;
13325 vl_api_create_vhost_user_if_t *mp;
13328 u8 file_name_set = 0;
13329 u32 custom_dev_instance = ~0;
13331 u8 use_custom_mac = 0;
13335 /* Shut up coverity */
13336 memset (hwaddr, 0, sizeof (hwaddr));
13338 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13340 if (unformat (i, "socket %s", &file_name))
13344 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13346 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
13347 use_custom_mac = 1;
13348 else if (unformat (i, "server"))
13350 else if (unformat (i, "tag %s", &tag))
13356 if (file_name_set == 0)
13358 errmsg ("missing socket file name");
13362 if (vec_len (file_name) > 255)
13364 errmsg ("socket file name too long");
13367 vec_add1 (file_name, 0);
13369 M (CREATE_VHOST_USER_IF, mp);
13371 mp->is_server = is_server;
13372 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13373 vec_free (file_name);
13374 if (custom_dev_instance != ~0)
13377 mp->custom_dev_instance = ntohl (custom_dev_instance);
13379 mp->use_custom_mac = use_custom_mac;
13380 clib_memcpy (mp->mac_address, hwaddr, 6);
13382 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
13391 api_modify_vhost_user_if (vat_main_t * vam)
13393 unformat_input_t *i = vam->input;
13394 vl_api_modify_vhost_user_if_t *mp;
13397 u8 file_name_set = 0;
13398 u32 custom_dev_instance = ~0;
13399 u8 sw_if_index_set = 0;
13400 u32 sw_if_index = (u32) ~ 0;
13403 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13405 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13406 sw_if_index_set = 1;
13407 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13408 sw_if_index_set = 1;
13409 else if (unformat (i, "socket %s", &file_name))
13413 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
13415 else if (unformat (i, "server"))
13421 if (sw_if_index_set == 0)
13423 errmsg ("missing sw_if_index or interface name");
13427 if (file_name_set == 0)
13429 errmsg ("missing socket file name");
13433 if (vec_len (file_name) > 255)
13435 errmsg ("socket file name too long");
13438 vec_add1 (file_name, 0);
13440 M (MODIFY_VHOST_USER_IF, mp);
13442 mp->sw_if_index = ntohl (sw_if_index);
13443 mp->is_server = is_server;
13444 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
13445 vec_free (file_name);
13446 if (custom_dev_instance != ~0)
13449 mp->custom_dev_instance = ntohl (custom_dev_instance);
13458 api_delete_vhost_user_if (vat_main_t * vam)
13460 unformat_input_t *i = vam->input;
13461 vl_api_delete_vhost_user_if_t *mp;
13462 u32 sw_if_index = ~0;
13463 u8 sw_if_index_set = 0;
13466 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13468 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
13469 sw_if_index_set = 1;
13470 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13471 sw_if_index_set = 1;
13476 if (sw_if_index_set == 0)
13478 errmsg ("missing sw_if_index or interface name");
13483 M (DELETE_VHOST_USER_IF, mp);
13485 mp->sw_if_index = ntohl (sw_if_index);
13492 static void vl_api_sw_interface_vhost_user_details_t_handler
13493 (vl_api_sw_interface_vhost_user_details_t * mp)
13495 vat_main_t *vam = &vat_main;
13497 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
13498 (char *) mp->interface_name,
13499 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
13500 clib_net_to_host_u64 (mp->features), mp->is_server,
13501 ntohl (mp->num_regions), (char *) mp->sock_filename);
13502 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
13505 static void vl_api_sw_interface_vhost_user_details_t_handler_json
13506 (vl_api_sw_interface_vhost_user_details_t * mp)
13508 vat_main_t *vam = &vat_main;
13509 vat_json_node_t *node = NULL;
13511 if (VAT_JSON_ARRAY != vam->json_tree.type)
13513 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13514 vat_json_init_array (&vam->json_tree);
13516 node = vat_json_array_add (&vam->json_tree);
13518 vat_json_init_object (node);
13519 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13520 vat_json_object_add_string_copy (node, "interface_name",
13521 mp->interface_name);
13522 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
13523 ntohl (mp->virtio_net_hdr_sz));
13524 vat_json_object_add_uint (node, "features",
13525 clib_net_to_host_u64 (mp->features));
13526 vat_json_object_add_uint (node, "is_server", mp->is_server);
13527 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
13528 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
13529 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
13533 api_sw_interface_vhost_user_dump (vat_main_t * vam)
13535 vl_api_sw_interface_vhost_user_dump_t *mp;
13536 vl_api_control_ping_t *mp_ping;
13539 "Interface name idx hdr_sz features server regions filename");
13541 /* Get list of vhost-user interfaces */
13542 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
13545 /* Use a control ping for synchronization */
13546 MPING (CONTROL_PING, mp_ping);
13554 api_show_version (vat_main_t * vam)
13556 vl_api_show_version_t *mp;
13559 M (SHOW_VERSION, mp);
13568 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
13570 unformat_input_t *line_input = vam->input;
13571 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
13572 ip4_address_t local4, remote4;
13573 ip6_address_t local6, remote6;
13575 u8 ipv4_set = 0, ipv6_set = 0;
13579 u32 mcast_sw_if_index = ~0;
13580 u32 encap_vrf_id = 0;
13581 u32 decap_vrf_id = 0;
13587 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
13588 memset (&local4, 0, sizeof local4);
13589 memset (&remote4, 0, sizeof remote4);
13590 memset (&local6, 0, sizeof local6);
13591 memset (&remote6, 0, sizeof remote6);
13593 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13595 if (unformat (line_input, "del"))
13597 else if (unformat (line_input, "local %U",
13598 unformat_ip4_address, &local4))
13603 else if (unformat (line_input, "remote %U",
13604 unformat_ip4_address, &remote4))
13609 else if (unformat (line_input, "local %U",
13610 unformat_ip6_address, &local6))
13615 else if (unformat (line_input, "remote %U",
13616 unformat_ip6_address, &remote6))
13621 else if (unformat (line_input, "group %U %U",
13622 unformat_ip4_address, &remote4,
13623 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13625 grp_set = remote_set = 1;
13628 else if (unformat (line_input, "group %U",
13629 unformat_ip4_address, &remote4))
13631 grp_set = remote_set = 1;
13634 else if (unformat (line_input, "group %U %U",
13635 unformat_ip6_address, &remote6,
13636 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
13638 grp_set = remote_set = 1;
13641 else if (unformat (line_input, "group %U",
13642 unformat_ip6_address, &remote6))
13644 grp_set = remote_set = 1;
13648 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
13650 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
13652 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
13654 else if (unformat (line_input, "vni %d", &vni))
13656 else if (unformat (line_input, "next-ip4"))
13658 else if (unformat (line_input, "next-ip6"))
13660 else if (unformat (line_input, "next-ethernet"))
13662 else if (unformat (line_input, "next-nsh"))
13666 errmsg ("parse error '%U'", format_unformat_error, line_input);
13671 if (local_set == 0)
13673 errmsg ("tunnel local address not specified");
13676 if (remote_set == 0)
13678 errmsg ("tunnel remote address not specified");
13681 if (grp_set && mcast_sw_if_index == ~0)
13683 errmsg ("tunnel nonexistent multicast device");
13686 if (ipv4_set && ipv6_set)
13688 errmsg ("both IPv4 and IPv6 addresses specified");
13694 errmsg ("vni not specified");
13698 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
13703 clib_memcpy (&mp->local, &local6, sizeof (local6));
13704 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
13708 clib_memcpy (&mp->local, &local4, sizeof (local4));
13709 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
13712 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
13713 mp->encap_vrf_id = ntohl (encap_vrf_id);
13714 mp->decap_vrf_id = ntohl (decap_vrf_id);
13715 mp->protocol = protocol;
13716 mp->vni = ntohl (vni);
13717 mp->is_add = is_add;
13718 mp->is_ipv6 = ipv6_set;
13725 static void vl_api_vxlan_gpe_tunnel_details_t_handler
13726 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13728 vat_main_t *vam = &vat_main;
13729 ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
13730 ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
13732 print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
13733 ntohl (mp->sw_if_index),
13734 format_ip46_address, &local, IP46_TYPE_ANY,
13735 format_ip46_address, &remote, IP46_TYPE_ANY,
13736 ntohl (mp->vni), mp->protocol,
13737 ntohl (mp->mcast_sw_if_index),
13738 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
13742 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
13743 (vl_api_vxlan_gpe_tunnel_details_t * mp)
13745 vat_main_t *vam = &vat_main;
13746 vat_json_node_t *node = NULL;
13747 struct in_addr ip4;
13748 struct in6_addr ip6;
13750 if (VAT_JSON_ARRAY != vam->json_tree.type)
13752 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13753 vat_json_init_array (&vam->json_tree);
13755 node = vat_json_array_add (&vam->json_tree);
13757 vat_json_init_object (node);
13758 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13761 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
13762 vat_json_object_add_ip6 (node, "local", ip6);
13763 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
13764 vat_json_object_add_ip6 (node, "remote", ip6);
13768 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
13769 vat_json_object_add_ip4 (node, "local", ip4);
13770 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
13771 vat_json_object_add_ip4 (node, "remote", ip4);
13773 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
13774 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
13775 vat_json_object_add_uint (node, "mcast_sw_if_index",
13776 ntohl (mp->mcast_sw_if_index));
13777 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
13778 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
13779 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
13783 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
13785 unformat_input_t *i = vam->input;
13786 vl_api_vxlan_gpe_tunnel_dump_t *mp;
13787 vl_api_control_ping_t *mp_ping;
13789 u8 sw_if_index_set = 0;
13792 /* Parse args required to build the message */
13793 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13795 if (unformat (i, "sw_if_index %d", &sw_if_index))
13796 sw_if_index_set = 1;
13801 if (sw_if_index_set == 0)
13806 if (!vam->json_output)
13808 print (vam->ofp, "%11s%24s%24s%13s%15s%19s%14s%14s",
13809 "sw_if_index", "local", "remote", "vni",
13810 "protocol", "mcast_sw_if_index", "encap_vrf_id", "decap_vrf_id");
13813 /* Get list of vxlan-tunnel interfaces */
13814 M (VXLAN_GPE_TUNNEL_DUMP, mp);
13816 mp->sw_if_index = htonl (sw_if_index);
13820 /* Use a control ping for synchronization */
13821 MPING (CONTROL_PING, mp_ping);
13828 static void vl_api_l2_fib_table_details_t_handler
13829 (vl_api_l2_fib_table_details_t * mp)
13831 vat_main_t *vam = &vat_main;
13833 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
13835 ntohl (mp->bd_id), format_ethernet_address, mp->mac,
13836 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
13840 static void vl_api_l2_fib_table_details_t_handler_json
13841 (vl_api_l2_fib_table_details_t * mp)
13843 vat_main_t *vam = &vat_main;
13844 vat_json_node_t *node = NULL;
13846 if (VAT_JSON_ARRAY != vam->json_tree.type)
13848 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13849 vat_json_init_array (&vam->json_tree);
13851 node = vat_json_array_add (&vam->json_tree);
13853 vat_json_init_object (node);
13854 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
13855 vat_json_object_add_bytes (node, "mac", mp->mac, 6);
13856 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
13857 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
13858 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
13859 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
13863 api_l2_fib_table_dump (vat_main_t * vam)
13865 unformat_input_t *i = vam->input;
13866 vl_api_l2_fib_table_dump_t *mp;
13867 vl_api_control_ping_t *mp_ping;
13872 /* Parse args required to build the message */
13873 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13875 if (unformat (i, "bd_id %d", &bd_id))
13881 if (bd_id_set == 0)
13883 errmsg ("missing bridge domain");
13887 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
13889 /* Get list of l2 fib entries */
13890 M (L2_FIB_TABLE_DUMP, mp);
13892 mp->bd_id = ntohl (bd_id);
13895 /* Use a control ping for synchronization */
13896 MPING (CONTROL_PING, mp_ping);
13905 api_interface_name_renumber (vat_main_t * vam)
13907 unformat_input_t *line_input = vam->input;
13908 vl_api_interface_name_renumber_t *mp;
13909 u32 sw_if_index = ~0;
13910 u32 new_show_dev_instance = ~0;
13913 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13915 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
13918 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13920 else if (unformat (line_input, "new_show_dev_instance %d",
13921 &new_show_dev_instance))
13927 if (sw_if_index == ~0)
13929 errmsg ("missing interface name or sw_if_index");
13933 if (new_show_dev_instance == ~0)
13935 errmsg ("missing new_show_dev_instance");
13939 M (INTERFACE_NAME_RENUMBER, mp);
13941 mp->sw_if_index = ntohl (sw_if_index);
13942 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
13950 api_want_ip4_arp_events (vat_main_t * vam)
13952 unformat_input_t *line_input = vam->input;
13953 vl_api_want_ip4_arp_events_t *mp;
13954 ip4_address_t address;
13955 int address_set = 0;
13956 u32 enable_disable = 1;
13959 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13961 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
13963 else if (unformat (line_input, "del"))
13964 enable_disable = 0;
13969 if (address_set == 0)
13971 errmsg ("missing addresses");
13975 M (WANT_IP4_ARP_EVENTS, mp);
13976 mp->enable_disable = enable_disable;
13977 mp->pid = htonl (getpid ());
13978 mp->address = address.as_u32;
13986 api_want_ip6_nd_events (vat_main_t * vam)
13988 unformat_input_t *line_input = vam->input;
13989 vl_api_want_ip6_nd_events_t *mp;
13990 ip6_address_t address;
13991 int address_set = 0;
13992 u32 enable_disable = 1;
13995 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13997 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
13999 else if (unformat (line_input, "del"))
14000 enable_disable = 0;
14005 if (address_set == 0)
14007 errmsg ("missing addresses");
14011 M (WANT_IP6_ND_EVENTS, mp);
14012 mp->enable_disable = enable_disable;
14013 mp->pid = htonl (getpid ());
14014 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
14022 api_want_l2_macs_events (vat_main_t * vam)
14024 unformat_input_t *line_input = vam->input;
14025 vl_api_want_l2_macs_events_t *mp;
14026 u8 enable_disable = 1;
14027 u32 scan_delay = 0;
14028 u32 max_macs_in_event = 0;
14029 u32 learn_limit = 0;
14032 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
14034 if (unformat (line_input, "learn-limit %d", &learn_limit))
14036 else if (unformat (line_input, "scan-delay %d", &scan_delay))
14038 else if (unformat (line_input, "max-entries %d", &max_macs_in_event))
14040 else if (unformat (line_input, "disable"))
14041 enable_disable = 0;
14046 M (WANT_L2_MACS_EVENTS, mp);
14047 mp->enable_disable = enable_disable;
14048 mp->pid = htonl (getpid ());
14049 mp->learn_limit = htonl (learn_limit);
14050 mp->scan_delay = (u8) scan_delay;
14051 mp->max_macs_in_event = (u8) (max_macs_in_event / 10);
14058 api_input_acl_set_interface (vat_main_t * vam)
14060 unformat_input_t *i = vam->input;
14061 vl_api_input_acl_set_interface_t *mp;
14063 int sw_if_index_set;
14064 u32 ip4_table_index = ~0;
14065 u32 ip6_table_index = ~0;
14066 u32 l2_table_index = ~0;
14070 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14072 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14073 sw_if_index_set = 1;
14074 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14075 sw_if_index_set = 1;
14076 else if (unformat (i, "del"))
14078 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14080 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14082 else if (unformat (i, "l2-table %d", &l2_table_index))
14086 clib_warning ("parse error '%U'", format_unformat_error, i);
14091 if (sw_if_index_set == 0)
14093 errmsg ("missing interface name or sw_if_index");
14097 M (INPUT_ACL_SET_INTERFACE, mp);
14099 mp->sw_if_index = ntohl (sw_if_index);
14100 mp->ip4_table_index = ntohl (ip4_table_index);
14101 mp->ip6_table_index = ntohl (ip6_table_index);
14102 mp->l2_table_index = ntohl (l2_table_index);
14103 mp->is_add = is_add;
14111 api_ip_address_dump (vat_main_t * vam)
14113 unformat_input_t *i = vam->input;
14114 vl_api_ip_address_dump_t *mp;
14115 vl_api_control_ping_t *mp_ping;
14116 u32 sw_if_index = ~0;
14117 u8 sw_if_index_set = 0;
14122 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14124 if (unformat (i, "sw_if_index %d", &sw_if_index))
14125 sw_if_index_set = 1;
14127 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14128 sw_if_index_set = 1;
14129 else if (unformat (i, "ipv4"))
14131 else if (unformat (i, "ipv6"))
14137 if (ipv4_set && ipv6_set)
14139 errmsg ("ipv4 and ipv6 flags cannot be both set");
14143 if ((!ipv4_set) && (!ipv6_set))
14145 errmsg ("no ipv4 nor ipv6 flag set");
14149 if (sw_if_index_set == 0)
14151 errmsg ("missing interface name or sw_if_index");
14155 vam->current_sw_if_index = sw_if_index;
14156 vam->is_ipv6 = ipv6_set;
14158 M (IP_ADDRESS_DUMP, mp);
14159 mp->sw_if_index = ntohl (sw_if_index);
14160 mp->is_ipv6 = ipv6_set;
14163 /* Use a control ping for synchronization */
14164 MPING (CONTROL_PING, mp_ping);
14172 api_ip_dump (vat_main_t * vam)
14174 vl_api_ip_dump_t *mp;
14175 vl_api_control_ping_t *mp_ping;
14176 unformat_input_t *in = vam->input;
14183 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
14185 if (unformat (in, "ipv4"))
14187 else if (unformat (in, "ipv6"))
14193 if (ipv4_set && ipv6_set)
14195 errmsg ("ipv4 and ipv6 flags cannot be both set");
14199 if ((!ipv4_set) && (!ipv6_set))
14201 errmsg ("no ipv4 nor ipv6 flag set");
14205 is_ipv6 = ipv6_set;
14206 vam->is_ipv6 = is_ipv6;
14208 /* free old data */
14209 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
14211 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
14213 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
14216 mp->is_ipv6 = ipv6_set;
14219 /* Use a control ping for synchronization */
14220 MPING (CONTROL_PING, mp_ping);
14228 api_ipsec_spd_add_del (vat_main_t * vam)
14230 unformat_input_t *i = vam->input;
14231 vl_api_ipsec_spd_add_del_t *mp;
14236 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14238 if (unformat (i, "spd_id %d", &spd_id))
14240 else if (unformat (i, "del"))
14244 clib_warning ("parse error '%U'", format_unformat_error, i);
14250 errmsg ("spd_id must be set");
14254 M (IPSEC_SPD_ADD_DEL, mp);
14256 mp->spd_id = ntohl (spd_id);
14257 mp->is_add = is_add;
14265 api_ipsec_interface_add_del_spd (vat_main_t * vam)
14267 unformat_input_t *i = vam->input;
14268 vl_api_ipsec_interface_add_del_spd_t *mp;
14270 u8 sw_if_index_set = 0;
14271 u32 spd_id = (u32) ~ 0;
14275 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14277 if (unformat (i, "del"))
14279 else if (unformat (i, "spd_id %d", &spd_id))
14282 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14283 sw_if_index_set = 1;
14284 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14285 sw_if_index_set = 1;
14288 clib_warning ("parse error '%U'", format_unformat_error, i);
14294 if (spd_id == (u32) ~ 0)
14296 errmsg ("spd_id must be set");
14300 if (sw_if_index_set == 0)
14302 errmsg ("missing interface name or sw_if_index");
14306 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
14308 mp->spd_id = ntohl (spd_id);
14309 mp->sw_if_index = ntohl (sw_if_index);
14310 mp->is_add = is_add;
14318 api_ipsec_spd_add_del_entry (vat_main_t * vam)
14320 unformat_input_t *i = vam->input;
14321 vl_api_ipsec_spd_add_del_entry_t *mp;
14322 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
14323 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
14325 u32 rport_start = 0, rport_stop = (u32) ~ 0;
14326 u32 lport_start = 0, lport_stop = (u32) ~ 0;
14327 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
14328 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
14331 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
14332 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
14333 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
14334 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
14335 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
14336 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
14338 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14340 if (unformat (i, "del"))
14342 if (unformat (i, "outbound"))
14344 if (unformat (i, "inbound"))
14346 else if (unformat (i, "spd_id %d", &spd_id))
14348 else if (unformat (i, "sa_id %d", &sa_id))
14350 else if (unformat (i, "priority %d", &priority))
14352 else if (unformat (i, "protocol %d", &protocol))
14354 else if (unformat (i, "lport_start %d", &lport_start))
14356 else if (unformat (i, "lport_stop %d", &lport_stop))
14358 else if (unformat (i, "rport_start %d", &rport_start))
14360 else if (unformat (i, "rport_stop %d", &rport_stop))
14364 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
14370 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
14377 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
14383 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
14390 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
14396 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
14403 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
14409 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
14415 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
14417 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
14419 clib_warning ("unsupported action: 'resolve'");
14425 clib_warning ("parse error '%U'", format_unformat_error, i);
14431 M (IPSEC_SPD_ADD_DEL_ENTRY, mp);
14433 mp->spd_id = ntohl (spd_id);
14434 mp->priority = ntohl (priority);
14435 mp->is_outbound = is_outbound;
14437 mp->is_ipv6 = is_ipv6;
14438 if (is_ipv6 || is_ip_any)
14440 clib_memcpy (mp->remote_address_start, &raddr6_start,
14441 sizeof (ip6_address_t));
14442 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
14443 sizeof (ip6_address_t));
14444 clib_memcpy (mp->local_address_start, &laddr6_start,
14445 sizeof (ip6_address_t));
14446 clib_memcpy (mp->local_address_stop, &laddr6_stop,
14447 sizeof (ip6_address_t));
14451 clib_memcpy (mp->remote_address_start, &raddr4_start,
14452 sizeof (ip4_address_t));
14453 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
14454 sizeof (ip4_address_t));
14455 clib_memcpy (mp->local_address_start, &laddr4_start,
14456 sizeof (ip4_address_t));
14457 clib_memcpy (mp->local_address_stop, &laddr4_stop,
14458 sizeof (ip4_address_t));
14460 mp->protocol = (u8) protocol;
14461 mp->local_port_start = ntohs ((u16) lport_start);
14462 mp->local_port_stop = ntohs ((u16) lport_stop);
14463 mp->remote_port_start = ntohs ((u16) rport_start);
14464 mp->remote_port_stop = ntohs ((u16) rport_stop);
14465 mp->policy = (u8) policy;
14466 mp->sa_id = ntohl (sa_id);
14467 mp->is_add = is_add;
14468 mp->is_ip_any = is_ip_any;
14475 api_ipsec_sad_add_del_entry (vat_main_t * vam)
14477 unformat_input_t *i = vam->input;
14478 vl_api_ipsec_sad_add_del_entry_t *mp;
14479 u32 sad_id = 0, spi = 0;
14480 u8 *ck = 0, *ik = 0;
14483 u8 protocol = IPSEC_PROTOCOL_AH;
14484 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
14485 u32 crypto_alg = 0, integ_alg = 0;
14486 ip4_address_t tun_src4;
14487 ip4_address_t tun_dst4;
14488 ip6_address_t tun_src6;
14489 ip6_address_t tun_dst6;
14492 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14494 if (unformat (i, "del"))
14496 else if (unformat (i, "sad_id %d", &sad_id))
14498 else if (unformat (i, "spi %d", &spi))
14500 else if (unformat (i, "esp"))
14501 protocol = IPSEC_PROTOCOL_ESP;
14502 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
14505 is_tunnel_ipv6 = 0;
14507 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
14510 is_tunnel_ipv6 = 0;
14512 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
14515 is_tunnel_ipv6 = 1;
14517 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
14520 is_tunnel_ipv6 = 1;
14524 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
14526 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
14527 crypto_alg >= IPSEC_CRYPTO_N_ALG)
14529 clib_warning ("unsupported crypto-alg: '%U'",
14530 format_ipsec_crypto_alg, crypto_alg);
14534 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14538 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
14540 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
14541 integ_alg >= IPSEC_INTEG_N_ALG)
14543 clib_warning ("unsupported integ-alg: '%U'",
14544 format_ipsec_integ_alg, integ_alg);
14548 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14552 clib_warning ("parse error '%U'", format_unformat_error, i);
14558 M (IPSEC_SAD_ADD_DEL_ENTRY, mp);
14560 mp->sad_id = ntohl (sad_id);
14561 mp->is_add = is_add;
14562 mp->protocol = protocol;
14563 mp->spi = ntohl (spi);
14564 mp->is_tunnel = is_tunnel;
14565 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
14566 mp->crypto_algorithm = crypto_alg;
14567 mp->integrity_algorithm = integ_alg;
14568 mp->crypto_key_length = vec_len (ck);
14569 mp->integrity_key_length = vec_len (ik);
14571 if (mp->crypto_key_length > sizeof (mp->crypto_key))
14572 mp->crypto_key_length = sizeof (mp->crypto_key);
14574 if (mp->integrity_key_length > sizeof (mp->integrity_key))
14575 mp->integrity_key_length = sizeof (mp->integrity_key);
14578 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
14580 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
14584 if (is_tunnel_ipv6)
14586 clib_memcpy (mp->tunnel_src_address, &tun_src6,
14587 sizeof (ip6_address_t));
14588 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
14589 sizeof (ip6_address_t));
14593 clib_memcpy (mp->tunnel_src_address, &tun_src4,
14594 sizeof (ip4_address_t));
14595 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
14596 sizeof (ip4_address_t));
14606 api_ipsec_sa_set_key (vat_main_t * vam)
14608 unformat_input_t *i = vam->input;
14609 vl_api_ipsec_sa_set_key_t *mp;
14611 u8 *ck = 0, *ik = 0;
14614 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14616 if (unformat (i, "sa_id %d", &sa_id))
14618 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
14620 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
14624 clib_warning ("parse error '%U'", format_unformat_error, i);
14629 M (IPSEC_SA_SET_KEY, mp);
14631 mp->sa_id = ntohl (sa_id);
14632 mp->crypto_key_length = vec_len (ck);
14633 mp->integrity_key_length = vec_len (ik);
14635 if (mp->crypto_key_length > sizeof (mp->crypto_key))
14636 mp->crypto_key_length = sizeof (mp->crypto_key);
14638 if (mp->integrity_key_length > sizeof (mp->integrity_key))
14639 mp->integrity_key_length = sizeof (mp->integrity_key);
14642 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
14644 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
14652 api_ipsec_tunnel_if_add_del (vat_main_t * vam)
14654 unformat_input_t *i = vam->input;
14655 vl_api_ipsec_tunnel_if_add_del_t *mp;
14656 u32 local_spi = 0, remote_spi = 0;
14657 u32 crypto_alg = 0, integ_alg = 0;
14658 u8 *lck = NULL, *rck = NULL;
14659 u8 *lik = NULL, *rik = NULL;
14660 ip4_address_t local_ip = { {0} };
14661 ip4_address_t remote_ip = { {0} };
14664 u8 anti_replay = 0;
14667 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14669 if (unformat (i, "del"))
14671 else if (unformat (i, "esn"))
14673 else if (unformat (i, "anti_replay"))
14675 else if (unformat (i, "local_spi %d", &local_spi))
14677 else if (unformat (i, "remote_spi %d", &remote_spi))
14679 else if (unformat (i, "local_ip %U", unformat_ip4_address, &local_ip))
14681 else if (unformat (i, "remote_ip %U", unformat_ip4_address, &remote_ip))
14683 else if (unformat (i, "local_crypto_key %U", unformat_hex_string, &lck))
14686 if (unformat (i, "remote_crypto_key %U", unformat_hex_string, &rck))
14688 else if (unformat (i, "local_integ_key %U", unformat_hex_string, &lik))
14690 else if (unformat (i, "remote_integ_key %U", unformat_hex_string, &rik))
14694 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
14696 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
14697 crypto_alg >= IPSEC_CRYPTO_N_ALG)
14699 errmsg ("unsupported crypto-alg: '%U'\n",
14700 format_ipsec_crypto_alg, crypto_alg);
14706 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
14708 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
14709 integ_alg >= IPSEC_INTEG_N_ALG)
14711 errmsg ("unsupported integ-alg: '%U'\n",
14712 format_ipsec_integ_alg, integ_alg);
14718 errmsg ("parse error '%U'\n", format_unformat_error, i);
14723 M (IPSEC_TUNNEL_IF_ADD_DEL, mp);
14725 mp->is_add = is_add;
14727 mp->anti_replay = anti_replay;
14729 clib_memcpy (mp->local_ip, &local_ip, sizeof (ip4_address_t));
14730 clib_memcpy (mp->remote_ip, &remote_ip, sizeof (ip4_address_t));
14732 mp->local_spi = htonl (local_spi);
14733 mp->remote_spi = htonl (remote_spi);
14734 mp->crypto_alg = (u8) crypto_alg;
14736 mp->local_crypto_key_len = 0;
14739 mp->local_crypto_key_len = vec_len (lck);
14740 if (mp->local_crypto_key_len > sizeof (mp->local_crypto_key))
14741 mp->local_crypto_key_len = sizeof (mp->local_crypto_key);
14742 clib_memcpy (mp->local_crypto_key, lck, mp->local_crypto_key_len);
14745 mp->remote_crypto_key_len = 0;
14748 mp->remote_crypto_key_len = vec_len (rck);
14749 if (mp->remote_crypto_key_len > sizeof (mp->remote_crypto_key))
14750 mp->remote_crypto_key_len = sizeof (mp->remote_crypto_key);
14751 clib_memcpy (mp->remote_crypto_key, rck, mp->remote_crypto_key_len);
14754 mp->integ_alg = (u8) integ_alg;
14756 mp->local_integ_key_len = 0;
14759 mp->local_integ_key_len = vec_len (lik);
14760 if (mp->local_integ_key_len > sizeof (mp->local_integ_key))
14761 mp->local_integ_key_len = sizeof (mp->local_integ_key);
14762 clib_memcpy (mp->local_integ_key, lik, mp->local_integ_key_len);
14765 mp->remote_integ_key_len = 0;
14768 mp->remote_integ_key_len = vec_len (rik);
14769 if (mp->remote_integ_key_len > sizeof (mp->remote_integ_key))
14770 mp->remote_integ_key_len = sizeof (mp->remote_integ_key);
14771 clib_memcpy (mp->remote_integ_key, rik, mp->remote_integ_key_len);
14780 vl_api_ipsec_sa_details_t_handler (vl_api_ipsec_sa_details_t * mp)
14782 vat_main_t *vam = &vat_main;
14784 print (vam->ofp, "sa_id %u sw_if_index %u spi %u proto %u crypto_alg %u "
14785 "crypto_key %U integ_alg %u integ_key %U use_esn %u "
14786 "use_anti_replay %u is_tunnel %u is_tunnel_ip6 %u "
14787 "tunnel_src_addr %U tunnel_dst_addr %U "
14788 "salt %u seq_outbound %lu last_seq_inbound %lu "
14789 "replay_window %lu total_data_size %lu\n",
14790 ntohl (mp->sa_id), ntohl (mp->sw_if_index), ntohl (mp->spi),
14792 mp->crypto_alg, format_hex_bytes, mp->crypto_key, mp->crypto_key_len,
14793 mp->integ_alg, format_hex_bytes, mp->integ_key, mp->integ_key_len,
14794 mp->use_esn, mp->use_anti_replay, mp->is_tunnel, mp->is_tunnel_ip6,
14795 (mp->is_tunnel_ip6) ? format_ip6_address : format_ip4_address,
14796 mp->tunnel_src_addr,
14797 (mp->is_tunnel_ip6) ? format_ip6_address : format_ip4_address,
14798 mp->tunnel_dst_addr,
14800 clib_net_to_host_u64 (mp->seq_outbound),
14801 clib_net_to_host_u64 (mp->last_seq_inbound),
14802 clib_net_to_host_u64 (mp->replay_window),
14803 clib_net_to_host_u64 (mp->total_data_size));
14806 #define vl_api_ipsec_sa_details_t_endian vl_noop_handler
14807 #define vl_api_ipsec_sa_details_t_print vl_noop_handler
14809 static void vl_api_ipsec_sa_details_t_handler_json
14810 (vl_api_ipsec_sa_details_t * mp)
14812 vat_main_t *vam = &vat_main;
14813 vat_json_node_t *node = NULL;
14814 struct in_addr src_ip4, dst_ip4;
14815 struct in6_addr src_ip6, dst_ip6;
14817 if (VAT_JSON_ARRAY != vam->json_tree.type)
14819 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14820 vat_json_init_array (&vam->json_tree);
14822 node = vat_json_array_add (&vam->json_tree);
14824 vat_json_init_object (node);
14825 vat_json_object_add_uint (node, "sa_id", ntohl (mp->sa_id));
14826 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14827 vat_json_object_add_uint (node, "spi", ntohl (mp->spi));
14828 vat_json_object_add_uint (node, "proto", mp->protocol);
14829 vat_json_object_add_uint (node, "crypto_alg", mp->crypto_alg);
14830 vat_json_object_add_uint (node, "integ_alg", mp->integ_alg);
14831 vat_json_object_add_uint (node, "use_esn", mp->use_esn);
14832 vat_json_object_add_uint (node, "use_anti_replay", mp->use_anti_replay);
14833 vat_json_object_add_uint (node, "is_tunnel", mp->is_tunnel);
14834 vat_json_object_add_uint (node, "is_tunnel_ip6", mp->is_tunnel_ip6);
14835 vat_json_object_add_bytes (node, "crypto_key", mp->crypto_key,
14836 mp->crypto_key_len);
14837 vat_json_object_add_bytes (node, "integ_key", mp->integ_key,
14838 mp->integ_key_len);
14839 if (mp->is_tunnel_ip6)
14841 clib_memcpy (&src_ip6, mp->tunnel_src_addr, sizeof (src_ip6));
14842 vat_json_object_add_ip6 (node, "tunnel_src_addr", src_ip6);
14843 clib_memcpy (&dst_ip6, mp->tunnel_dst_addr, sizeof (dst_ip6));
14844 vat_json_object_add_ip6 (node, "tunnel_dst_addr", dst_ip6);
14848 clib_memcpy (&src_ip4, mp->tunnel_src_addr, sizeof (src_ip4));
14849 vat_json_object_add_ip4 (node, "tunnel_src_addr", src_ip4);
14850 clib_memcpy (&dst_ip4, mp->tunnel_dst_addr, sizeof (dst_ip4));
14851 vat_json_object_add_ip4 (node, "tunnel_dst_addr", dst_ip4);
14853 vat_json_object_add_uint (node, "replay_window",
14854 clib_net_to_host_u64 (mp->replay_window));
14855 vat_json_object_add_uint (node, "total_data_size",
14856 clib_net_to_host_u64 (mp->total_data_size));
14861 api_ipsec_sa_dump (vat_main_t * vam)
14863 unformat_input_t *i = vam->input;
14864 vl_api_ipsec_sa_dump_t *mp;
14865 vl_api_control_ping_t *mp_ping;
14869 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14871 if (unformat (i, "sa_id %d", &sa_id))
14875 clib_warning ("parse error '%U'", format_unformat_error, i);
14880 M (IPSEC_SA_DUMP, mp);
14882 mp->sa_id = ntohl (sa_id);
14886 /* Use a control ping for synchronization */
14887 M (CONTROL_PING, mp_ping);
14895 api_ipsec_tunnel_if_set_key (vat_main_t * vam)
14897 unformat_input_t *i = vam->input;
14898 vl_api_ipsec_tunnel_if_set_key_t *mp;
14899 u32 sw_if_index = ~0;
14900 u8 key_type = IPSEC_IF_SET_KEY_TYPE_NONE;
14905 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14907 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14910 if (unformat (i, "local crypto %U", unformat_ipsec_crypto_alg, &alg))
14911 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_CRYPTO;
14913 if (unformat (i, "remote crypto %U", unformat_ipsec_crypto_alg, &alg))
14914 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_CRYPTO;
14915 else if (unformat (i, "local integ %U", unformat_ipsec_integ_alg, &alg))
14916 key_type = IPSEC_IF_SET_KEY_TYPE_LOCAL_INTEG;
14918 if (unformat (i, "remote integ %U", unformat_ipsec_integ_alg, &alg))
14919 key_type = IPSEC_IF_SET_KEY_TYPE_REMOTE_INTEG;
14920 else if (unformat (i, "%U", unformat_hex_string, &key))
14924 clib_warning ("parse error '%U'", format_unformat_error, i);
14929 if (sw_if_index == ~0)
14931 errmsg ("interface must be specified");
14935 if (key_type == IPSEC_IF_SET_KEY_TYPE_NONE)
14937 errmsg ("key type must be specified");
14943 errmsg ("algorithm must be specified");
14947 if (vec_len (key) == 0)
14949 errmsg ("key must be specified");
14953 M (IPSEC_TUNNEL_IF_SET_KEY, mp);
14955 mp->sw_if_index = htonl (sw_if_index);
14957 mp->key_type = key_type;
14958 mp->key_len = vec_len (key);
14959 clib_memcpy (mp->key, key, vec_len (key));
14968 api_ipsec_tunnel_if_set_sa (vat_main_t * vam)
14970 unformat_input_t *i = vam->input;
14971 vl_api_ipsec_tunnel_if_set_sa_t *mp;
14972 u32 sw_if_index = ~0;
14974 u8 is_outbound = (u8) ~ 0;
14977 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14979 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
14981 else if (unformat (i, "sa_id %d", &sa_id))
14983 else if (unformat (i, "outbound"))
14985 else if (unformat (i, "inbound"))
14989 clib_warning ("parse error '%U'", format_unformat_error, i);
14994 if (sw_if_index == ~0)
14996 errmsg ("interface must be specified");
15002 errmsg ("SA ID must be specified");
15006 M (IPSEC_TUNNEL_IF_SET_SA, mp);
15008 mp->sw_if_index = htonl (sw_if_index);
15009 mp->sa_id = htonl (sa_id);
15010 mp->is_outbound = is_outbound;
15019 api_ikev2_profile_add_del (vat_main_t * vam)
15021 unformat_input_t *i = vam->input;
15022 vl_api_ikev2_profile_add_del_t *mp;
15027 const char *valid_chars = "a-zA-Z0-9_";
15029 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15031 if (unformat (i, "del"))
15033 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15034 vec_add1 (name, 0);
15037 errmsg ("parse error '%U'", format_unformat_error, i);
15042 if (!vec_len (name))
15044 errmsg ("profile name must be specified");
15048 if (vec_len (name) > 64)
15050 errmsg ("profile name too long");
15054 M (IKEV2_PROFILE_ADD_DEL, mp);
15056 clib_memcpy (mp->name, name, vec_len (name));
15057 mp->is_add = is_add;
15066 api_ikev2_profile_set_auth (vat_main_t * vam)
15068 unformat_input_t *i = vam->input;
15069 vl_api_ikev2_profile_set_auth_t *mp;
15072 u32 auth_method = 0;
15076 const char *valid_chars = "a-zA-Z0-9_";
15078 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15080 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15081 vec_add1 (name, 0);
15082 else if (unformat (i, "auth_method %U",
15083 unformat_ikev2_auth_method, &auth_method))
15085 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
15087 else if (unformat (i, "auth_data %v", &data))
15091 errmsg ("parse error '%U'", format_unformat_error, i);
15096 if (!vec_len (name))
15098 errmsg ("profile name must be specified");
15102 if (vec_len (name) > 64)
15104 errmsg ("profile name too long");
15108 if (!vec_len (data))
15110 errmsg ("auth_data must be specified");
15116 errmsg ("auth_method must be specified");
15120 M (IKEV2_PROFILE_SET_AUTH, mp);
15122 mp->is_hex = is_hex;
15123 mp->auth_method = (u8) auth_method;
15124 mp->data_len = vec_len (data);
15125 clib_memcpy (mp->name, name, vec_len (name));
15126 clib_memcpy (mp->data, data, vec_len (data));
15136 api_ikev2_profile_set_id (vat_main_t * vam)
15138 unformat_input_t *i = vam->input;
15139 vl_api_ikev2_profile_set_id_t *mp;
15147 const char *valid_chars = "a-zA-Z0-9_";
15149 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15151 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15152 vec_add1 (name, 0);
15153 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
15155 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
15157 data = vec_new (u8, 4);
15158 clib_memcpy (data, ip4.as_u8, 4);
15160 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
15162 else if (unformat (i, "id_data %v", &data))
15164 else if (unformat (i, "local"))
15166 else if (unformat (i, "remote"))
15170 errmsg ("parse error '%U'", format_unformat_error, i);
15175 if (!vec_len (name))
15177 errmsg ("profile name must be specified");
15181 if (vec_len (name) > 64)
15183 errmsg ("profile name too long");
15187 if (!vec_len (data))
15189 errmsg ("id_data must be specified");
15195 errmsg ("id_type must be specified");
15199 M (IKEV2_PROFILE_SET_ID, mp);
15201 mp->is_local = is_local;
15202 mp->id_type = (u8) id_type;
15203 mp->data_len = vec_len (data);
15204 clib_memcpy (mp->name, name, vec_len (name));
15205 clib_memcpy (mp->data, data, vec_len (data));
15215 api_ikev2_profile_set_ts (vat_main_t * vam)
15217 unformat_input_t *i = vam->input;
15218 vl_api_ikev2_profile_set_ts_t *mp;
15221 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
15222 ip4_address_t start_addr, end_addr;
15224 const char *valid_chars = "a-zA-Z0-9_";
15227 start_addr.as_u32 = 0;
15228 end_addr.as_u32 = (u32) ~ 0;
15230 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15232 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
15233 vec_add1 (name, 0);
15234 else if (unformat (i, "protocol %d", &proto))
15236 else if (unformat (i, "start_port %d", &start_port))
15238 else if (unformat (i, "end_port %d", &end_port))
15241 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
15243 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
15245 else if (unformat (i, "local"))
15247 else if (unformat (i, "remote"))
15251 errmsg ("parse error '%U'", format_unformat_error, i);
15256 if (!vec_len (name))
15258 errmsg ("profile name must be specified");
15262 if (vec_len (name) > 64)
15264 errmsg ("profile name too long");
15268 M (IKEV2_PROFILE_SET_TS, mp);
15270 mp->is_local = is_local;
15271 mp->proto = (u8) proto;
15272 mp->start_port = (u16) start_port;
15273 mp->end_port = (u16) end_port;
15274 mp->start_addr = start_addr.as_u32;
15275 mp->end_addr = end_addr.as_u32;
15276 clib_memcpy (mp->name, name, vec_len (name));
15285 api_ikev2_set_local_key (vat_main_t * vam)
15287 unformat_input_t *i = vam->input;
15288 vl_api_ikev2_set_local_key_t *mp;
15292 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15294 if (unformat (i, "file %v", &file))
15295 vec_add1 (file, 0);
15298 errmsg ("parse error '%U'", format_unformat_error, i);
15303 if (!vec_len (file))
15305 errmsg ("RSA key file must be specified");
15309 if (vec_len (file) > 256)
15311 errmsg ("file name too long");
15315 M (IKEV2_SET_LOCAL_KEY, mp);
15317 clib_memcpy (mp->key_file, file, vec_len (file));
15326 api_ikev2_set_responder (vat_main_t * vam)
15328 unformat_input_t *i = vam->input;
15329 vl_api_ikev2_set_responder_t *mp;
15332 u32 sw_if_index = ~0;
15333 ip4_address_t address;
15335 const char *valid_chars = "a-zA-Z0-9_";
15337 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15340 (i, "%U interface %d address %U", unformat_token, valid_chars,
15341 &name, &sw_if_index, unformat_ip4_address, &address))
15342 vec_add1 (name, 0);
15345 errmsg ("parse error '%U'", format_unformat_error, i);
15350 if (!vec_len (name))
15352 errmsg ("profile name must be specified");
15356 if (vec_len (name) > 64)
15358 errmsg ("profile name too long");
15362 M (IKEV2_SET_RESPONDER, mp);
15364 clib_memcpy (mp->name, name, vec_len (name));
15367 mp->sw_if_index = sw_if_index;
15368 clib_memcpy (mp->address, &address, sizeof (address));
15376 api_ikev2_set_ike_transforms (vat_main_t * vam)
15378 unformat_input_t *i = vam->input;
15379 vl_api_ikev2_set_ike_transforms_t *mp;
15382 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
15384 const char *valid_chars = "a-zA-Z0-9_";
15386 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15388 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
15389 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
15390 vec_add1 (name, 0);
15393 errmsg ("parse error '%U'", format_unformat_error, i);
15398 if (!vec_len (name))
15400 errmsg ("profile name must be specified");
15404 if (vec_len (name) > 64)
15406 errmsg ("profile name too long");
15410 M (IKEV2_SET_IKE_TRANSFORMS, mp);
15412 clib_memcpy (mp->name, name, vec_len (name));
15414 mp->crypto_alg = crypto_alg;
15415 mp->crypto_key_size = crypto_key_size;
15416 mp->integ_alg = integ_alg;
15417 mp->dh_group = dh_group;
15426 api_ikev2_set_esp_transforms (vat_main_t * vam)
15428 unformat_input_t *i = vam->input;
15429 vl_api_ikev2_set_esp_transforms_t *mp;
15432 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
15434 const char *valid_chars = "a-zA-Z0-9_";
15436 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15438 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
15439 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
15440 vec_add1 (name, 0);
15443 errmsg ("parse error '%U'", format_unformat_error, i);
15448 if (!vec_len (name))
15450 errmsg ("profile name must be specified");
15454 if (vec_len (name) > 64)
15456 errmsg ("profile name too long");
15460 M (IKEV2_SET_ESP_TRANSFORMS, mp);
15462 clib_memcpy (mp->name, name, vec_len (name));
15464 mp->crypto_alg = crypto_alg;
15465 mp->crypto_key_size = crypto_key_size;
15466 mp->integ_alg = integ_alg;
15467 mp->dh_group = dh_group;
15475 api_ikev2_set_sa_lifetime (vat_main_t * vam)
15477 unformat_input_t *i = vam->input;
15478 vl_api_ikev2_set_sa_lifetime_t *mp;
15481 u64 lifetime, lifetime_maxdata;
15482 u32 lifetime_jitter, handover;
15484 const char *valid_chars = "a-zA-Z0-9_";
15486 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15488 if (unformat (i, "%U %lu %u %u %lu", unformat_token, valid_chars, &name,
15489 &lifetime, &lifetime_jitter, &handover,
15490 &lifetime_maxdata))
15491 vec_add1 (name, 0);
15494 errmsg ("parse error '%U'", format_unformat_error, i);
15499 if (!vec_len (name))
15501 errmsg ("profile name must be specified");
15505 if (vec_len (name) > 64)
15507 errmsg ("profile name too long");
15511 M (IKEV2_SET_SA_LIFETIME, mp);
15513 clib_memcpy (mp->name, name, vec_len (name));
15515 mp->lifetime = lifetime;
15516 mp->lifetime_jitter = lifetime_jitter;
15517 mp->handover = handover;
15518 mp->lifetime_maxdata = lifetime_maxdata;
15526 api_ikev2_initiate_sa_init (vat_main_t * vam)
15528 unformat_input_t *i = vam->input;
15529 vl_api_ikev2_initiate_sa_init_t *mp;
15533 const char *valid_chars = "a-zA-Z0-9_";
15535 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15537 if (unformat (i, "%U", unformat_token, valid_chars, &name))
15538 vec_add1 (name, 0);
15541 errmsg ("parse error '%U'", format_unformat_error, i);
15546 if (!vec_len (name))
15548 errmsg ("profile name must be specified");
15552 if (vec_len (name) > 64)
15554 errmsg ("profile name too long");
15558 M (IKEV2_INITIATE_SA_INIT, mp);
15560 clib_memcpy (mp->name, name, vec_len (name));
15569 api_ikev2_initiate_del_ike_sa (vat_main_t * vam)
15571 unformat_input_t *i = vam->input;
15572 vl_api_ikev2_initiate_del_ike_sa_t *mp;
15577 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15579 if (unformat (i, "%lx", &ispi))
15583 errmsg ("parse error '%U'", format_unformat_error, i);
15588 M (IKEV2_INITIATE_DEL_IKE_SA, mp);
15598 api_ikev2_initiate_del_child_sa (vat_main_t * vam)
15600 unformat_input_t *i = vam->input;
15601 vl_api_ikev2_initiate_del_child_sa_t *mp;
15606 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15608 if (unformat (i, "%x", &ispi))
15612 errmsg ("parse error '%U'", format_unformat_error, i);
15617 M (IKEV2_INITIATE_DEL_CHILD_SA, mp);
15627 api_ikev2_initiate_rekey_child_sa (vat_main_t * vam)
15629 unformat_input_t *i = vam->input;
15630 vl_api_ikev2_initiate_rekey_child_sa_t *mp;
15635 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15637 if (unformat (i, "%x", &ispi))
15641 errmsg ("parse error '%U'", format_unformat_error, i);
15646 M (IKEV2_INITIATE_REKEY_CHILD_SA, mp);
15659 api_map_add_domain (vat_main_t * vam)
15661 unformat_input_t *i = vam->input;
15662 vl_api_map_add_domain_t *mp;
15664 ip4_address_t ip4_prefix;
15665 ip6_address_t ip6_prefix;
15666 ip6_address_t ip6_src;
15667 u32 num_m_args = 0;
15668 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
15669 0, psid_length = 0;
15670 u8 is_translation = 0;
15672 u32 ip6_src_len = 128;
15675 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15677 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
15678 &ip4_prefix, &ip4_prefix_len))
15680 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
15681 &ip6_prefix, &ip6_prefix_len))
15685 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
15688 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
15690 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
15692 else if (unformat (i, "psid-offset %d", &psid_offset))
15694 else if (unformat (i, "psid-len %d", &psid_length))
15696 else if (unformat (i, "mtu %d", &mtu))
15698 else if (unformat (i, "map-t"))
15699 is_translation = 1;
15702 clib_warning ("parse error '%U'", format_unformat_error, i);
15707 if (num_m_args < 3)
15709 errmsg ("mandatory argument(s) missing");
15713 /* Construct the API message */
15714 M (MAP_ADD_DOMAIN, mp);
15716 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
15717 mp->ip4_prefix_len = ip4_prefix_len;
15719 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
15720 mp->ip6_prefix_len = ip6_prefix_len;
15722 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
15723 mp->ip6_src_prefix_len = ip6_src_len;
15725 mp->ea_bits_len = ea_bits_len;
15726 mp->psid_offset = psid_offset;
15727 mp->psid_length = psid_length;
15728 mp->is_translation = is_translation;
15729 mp->mtu = htons (mtu);
15734 /* Wait for a reply, return good/bad news */
15740 api_map_del_domain (vat_main_t * vam)
15742 unformat_input_t *i = vam->input;
15743 vl_api_map_del_domain_t *mp;
15745 u32 num_m_args = 0;
15749 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15751 if (unformat (i, "index %d", &index))
15755 clib_warning ("parse error '%U'", format_unformat_error, i);
15760 if (num_m_args != 1)
15762 errmsg ("mandatory argument(s) missing");
15766 /* Construct the API message */
15767 M (MAP_DEL_DOMAIN, mp);
15769 mp->index = ntohl (index);
15774 /* Wait for a reply, return good/bad news */
15780 api_map_add_del_rule (vat_main_t * vam)
15782 unformat_input_t *i = vam->input;
15783 vl_api_map_add_del_rule_t *mp;
15785 ip6_address_t ip6_dst;
15786 u32 num_m_args = 0, index, psid = 0;
15789 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15791 if (unformat (i, "index %d", &index))
15793 else if (unformat (i, "psid %d", &psid))
15795 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
15797 else if (unformat (i, "del"))
15803 clib_warning ("parse error '%U'", format_unformat_error, i);
15808 /* Construct the API message */
15809 M (MAP_ADD_DEL_RULE, mp);
15811 mp->index = ntohl (index);
15812 mp->is_add = is_add;
15813 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
15814 mp->psid = ntohs (psid);
15819 /* Wait for a reply, return good/bad news */
15825 api_map_domain_dump (vat_main_t * vam)
15827 vl_api_map_domain_dump_t *mp;
15828 vl_api_control_ping_t *mp_ping;
15831 /* Construct the API message */
15832 M (MAP_DOMAIN_DUMP, mp);
15837 /* Use a control ping for synchronization */
15838 MPING (CONTROL_PING, mp_ping);
15846 api_map_rule_dump (vat_main_t * vam)
15848 unformat_input_t *i = vam->input;
15849 vl_api_map_rule_dump_t *mp;
15850 vl_api_control_ping_t *mp_ping;
15851 u32 domain_index = ~0;
15854 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15856 if (unformat (i, "index %u", &domain_index))
15862 if (domain_index == ~0)
15864 clib_warning ("parse error: domain index expected");
15868 /* Construct the API message */
15869 M (MAP_RULE_DUMP, mp);
15871 mp->domain_index = htonl (domain_index);
15876 /* Use a control ping for synchronization */
15877 MPING (CONTROL_PING, mp_ping);
15884 static void vl_api_map_add_domain_reply_t_handler
15885 (vl_api_map_add_domain_reply_t * mp)
15887 vat_main_t *vam = &vat_main;
15888 i32 retval = ntohl (mp->retval);
15890 if (vam->async_mode)
15892 vam->async_errors += (retval < 0);
15896 vam->retval = retval;
15897 vam->result_ready = 1;
15901 static void vl_api_map_add_domain_reply_t_handler_json
15902 (vl_api_map_add_domain_reply_t * mp)
15904 vat_main_t *vam = &vat_main;
15905 vat_json_node_t node;
15907 vat_json_init_object (&node);
15908 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
15909 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
15911 vat_json_print (vam->ofp, &node);
15912 vat_json_free (&node);
15914 vam->retval = ntohl (mp->retval);
15915 vam->result_ready = 1;
15919 api_get_first_msg_id (vat_main_t * vam)
15921 vl_api_get_first_msg_id_t *mp;
15922 unformat_input_t *i = vam->input;
15927 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15929 if (unformat (i, "client %s", &name))
15937 errmsg ("missing client name");
15940 vec_add1 (name, 0);
15942 if (vec_len (name) > 63)
15944 errmsg ("client name too long");
15948 M (GET_FIRST_MSG_ID, mp);
15949 clib_memcpy (mp->name, name, vec_len (name));
15956 api_cop_interface_enable_disable (vat_main_t * vam)
15958 unformat_input_t *line_input = vam->input;
15959 vl_api_cop_interface_enable_disable_t *mp;
15960 u32 sw_if_index = ~0;
15961 u8 enable_disable = 1;
15964 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15966 if (unformat (line_input, "disable"))
15967 enable_disable = 0;
15968 if (unformat (line_input, "enable"))
15969 enable_disable = 1;
15970 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
15971 vam, &sw_if_index))
15973 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
15979 if (sw_if_index == ~0)
15981 errmsg ("missing interface name or sw_if_index");
15985 /* Construct the API message */
15986 M (COP_INTERFACE_ENABLE_DISABLE, mp);
15987 mp->sw_if_index = ntohl (sw_if_index);
15988 mp->enable_disable = enable_disable;
15992 /* Wait for the reply */
15998 api_cop_whitelist_enable_disable (vat_main_t * vam)
16000 unformat_input_t *line_input = vam->input;
16001 vl_api_cop_whitelist_enable_disable_t *mp;
16002 u32 sw_if_index = ~0;
16003 u8 ip4 = 0, ip6 = 0, default_cop = 0;
16007 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
16009 if (unformat (line_input, "ip4"))
16011 else if (unformat (line_input, "ip6"))
16013 else if (unformat (line_input, "default"))
16015 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
16016 vam, &sw_if_index))
16018 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
16020 else if (unformat (line_input, "fib-id %d", &fib_id))
16026 if (sw_if_index == ~0)
16028 errmsg ("missing interface name or sw_if_index");
16032 /* Construct the API message */
16033 M (COP_WHITELIST_ENABLE_DISABLE, mp);
16034 mp->sw_if_index = ntohl (sw_if_index);
16035 mp->fib_id = ntohl (fib_id);
16038 mp->default_cop = default_cop;
16042 /* Wait for the reply */
16048 api_get_node_graph (vat_main_t * vam)
16050 vl_api_get_node_graph_t *mp;
16053 M (GET_NODE_GRAPH, mp);
16057 /* Wait for the reply */
16063 /** Used for parsing LISP eids */
16064 typedef CLIB_PACKED(struct{
16065 u8 addr[16]; /**< eid address */
16066 u32 len; /**< prefix length if IP */
16067 u8 type; /**< type of eid */
16072 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
16074 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
16076 memset (a, 0, sizeof (a[0]));
16078 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
16080 a->type = 0; /* ipv4 type */
16082 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
16084 a->type = 1; /* ipv6 type */
16086 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
16088 a->type = 2; /* mac type */
16090 else if (unformat (input, "%U", unformat_nsh_address, a->addr))
16092 a->type = 3; /* NSH type */
16093 lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
16094 nsh->spi = clib_host_to_net_u32 (nsh->spi);
16101 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
16110 lisp_eid_size_vat (u8 type)
16127 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
16129 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
16133 api_one_add_del_locator_set (vat_main_t * vam)
16135 unformat_input_t *input = vam->input;
16136 vl_api_one_add_del_locator_set_t *mp;
16138 u8 *locator_set_name = NULL;
16139 u8 locator_set_name_set = 0;
16140 vl_api_local_locator_t locator, *locators = 0;
16141 u32 sw_if_index, priority, weight;
16145 /* Parse args required to build the message */
16146 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16148 if (unformat (input, "del"))
16152 else if (unformat (input, "locator-set %s", &locator_set_name))
16154 locator_set_name_set = 1;
16156 else if (unformat (input, "sw_if_index %u p %u w %u",
16157 &sw_if_index, &priority, &weight))
16159 locator.sw_if_index = htonl (sw_if_index);
16160 locator.priority = priority;
16161 locator.weight = weight;
16162 vec_add1 (locators, locator);
16166 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
16167 &sw_if_index, &priority, &weight))
16169 locator.sw_if_index = htonl (sw_if_index);
16170 locator.priority = priority;
16171 locator.weight = weight;
16172 vec_add1 (locators, locator);
16178 if (locator_set_name_set == 0)
16180 errmsg ("missing locator-set name");
16181 vec_free (locators);
16185 if (vec_len (locator_set_name) > 64)
16187 errmsg ("locator-set name too long");
16188 vec_free (locator_set_name);
16189 vec_free (locators);
16192 vec_add1 (locator_set_name, 0);
16194 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
16196 /* Construct the API message */
16197 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
16199 mp->is_add = is_add;
16200 clib_memcpy (mp->locator_set_name, locator_set_name,
16201 vec_len (locator_set_name));
16202 vec_free (locator_set_name);
16204 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
16206 clib_memcpy (mp->locators, locators, data_len);
16207 vec_free (locators);
16212 /* Wait for a reply... */
16217 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
16220 api_one_add_del_locator (vat_main_t * vam)
16222 unformat_input_t *input = vam->input;
16223 vl_api_one_add_del_locator_t *mp;
16224 u32 tmp_if_index = ~0;
16225 u32 sw_if_index = ~0;
16226 u8 sw_if_index_set = 0;
16227 u8 sw_if_index_if_name_set = 0;
16229 u8 priority_set = 0;
16233 u8 *locator_set_name = NULL;
16234 u8 locator_set_name_set = 0;
16237 /* Parse args required to build the message */
16238 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16240 if (unformat (input, "del"))
16244 else if (unformat (input, "locator-set %s", &locator_set_name))
16246 locator_set_name_set = 1;
16248 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
16251 sw_if_index_if_name_set = 1;
16252 sw_if_index = tmp_if_index;
16254 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
16256 sw_if_index_set = 1;
16257 sw_if_index = tmp_if_index;
16259 else if (unformat (input, "p %d", &priority))
16263 else if (unformat (input, "w %d", &weight))
16271 if (locator_set_name_set == 0)
16273 errmsg ("missing locator-set name");
16277 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
16279 errmsg ("missing sw_if_index");
16280 vec_free (locator_set_name);
16284 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
16286 errmsg ("cannot use both params interface name and sw_if_index");
16287 vec_free (locator_set_name);
16291 if (priority_set == 0)
16293 errmsg ("missing locator-set priority");
16294 vec_free (locator_set_name);
16298 if (weight_set == 0)
16300 errmsg ("missing locator-set weight");
16301 vec_free (locator_set_name);
16305 if (vec_len (locator_set_name) > 64)
16307 errmsg ("locator-set name too long");
16308 vec_free (locator_set_name);
16311 vec_add1 (locator_set_name, 0);
16313 /* Construct the API message */
16314 M (ONE_ADD_DEL_LOCATOR, mp);
16316 mp->is_add = is_add;
16317 mp->sw_if_index = ntohl (sw_if_index);
16318 mp->priority = priority;
16319 mp->weight = weight;
16320 clib_memcpy (mp->locator_set_name, locator_set_name,
16321 vec_len (locator_set_name));
16322 vec_free (locator_set_name);
16327 /* Wait for a reply... */
16332 #define api_lisp_add_del_locator api_one_add_del_locator
16335 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
16337 u32 *key_id = va_arg (*args, u32 *);
16340 if (unformat (input, "%s", &s))
16342 if (!strcmp ((char *) s, "sha1"))
16343 key_id[0] = HMAC_SHA_1_96;
16344 else if (!strcmp ((char *) s, "sha256"))
16345 key_id[0] = HMAC_SHA_256_128;
16348 clib_warning ("invalid key_id: '%s'", s);
16349 key_id[0] = HMAC_NO_KEY;
16360 api_one_add_del_local_eid (vat_main_t * vam)
16362 unformat_input_t *input = vam->input;
16363 vl_api_one_add_del_local_eid_t *mp;
16366 lisp_eid_vat_t _eid, *eid = &_eid;
16367 u8 *locator_set_name = 0;
16368 u8 locator_set_name_set = 0;
16374 /* Parse args required to build the message */
16375 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16377 if (unformat (input, "del"))
16381 else if (unformat (input, "vni %d", &vni))
16385 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
16389 else if (unformat (input, "locator-set %s", &locator_set_name))
16391 locator_set_name_set = 1;
16393 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
16395 else if (unformat (input, "secret-key %_%v%_", &key))
16401 if (locator_set_name_set == 0)
16403 errmsg ("missing locator-set name");
16409 errmsg ("EID address not set!");
16410 vec_free (locator_set_name);
16414 if (key && (0 == key_id))
16416 errmsg ("invalid key_id!");
16420 if (vec_len (key) > 64)
16422 errmsg ("key too long");
16427 if (vec_len (locator_set_name) > 64)
16429 errmsg ("locator-set name too long");
16430 vec_free (locator_set_name);
16433 vec_add1 (locator_set_name, 0);
16435 /* Construct the API message */
16436 M (ONE_ADD_DEL_LOCAL_EID, mp);
16438 mp->is_add = is_add;
16439 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
16440 mp->eid_type = eid->type;
16441 mp->prefix_len = eid->len;
16442 mp->vni = clib_host_to_net_u32 (vni);
16443 mp->key_id = clib_host_to_net_u16 (key_id);
16444 clib_memcpy (mp->locator_set_name, locator_set_name,
16445 vec_len (locator_set_name));
16446 clib_memcpy (mp->key, key, vec_len (key));
16448 vec_free (locator_set_name);
16454 /* Wait for a reply... */
16459 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
16462 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
16464 u32 dp_table = 0, vni = 0;;
16465 unformat_input_t *input = vam->input;
16466 vl_api_gpe_add_del_fwd_entry_t *mp;
16468 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
16469 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
16470 u8 rmt_eid_set = 0, lcl_eid_set = 0;
16471 u32 action = ~0, w;
16472 ip4_address_t rmt_rloc4, lcl_rloc4;
16473 ip6_address_t rmt_rloc6, lcl_rloc6;
16474 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
16477 memset (&rloc, 0, sizeof (rloc));
16479 /* Parse args required to build the message */
16480 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16482 if (unformat (input, "del"))
16484 else if (unformat (input, "add"))
16486 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
16490 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
16494 else if (unformat (input, "vrf %d", &dp_table))
16496 else if (unformat (input, "bd %d", &dp_table))
16498 else if (unformat (input, "vni %d", &vni))
16500 else if (unformat (input, "w %d", &w))
16504 errmsg ("No RLOC configured for setting priority/weight!");
16507 curr_rloc->weight = w;
16509 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
16510 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
16514 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
16516 vec_add1 (lcl_locs, rloc);
16518 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
16519 vec_add1 (rmt_locs, rloc);
16520 /* weight saved in rmt loc */
16521 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
16523 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
16524 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
16527 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
16529 vec_add1 (lcl_locs, rloc);
16531 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
16532 vec_add1 (rmt_locs, rloc);
16533 /* weight saved in rmt loc */
16534 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
16536 else if (unformat (input, "action %d", &action))
16542 clib_warning ("parse error '%U'", format_unformat_error, input);
16549 errmsg ("remote eid addresses not set");
16553 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
16555 errmsg ("eid types don't match");
16559 if (0 == rmt_locs && (u32) ~ 0 == action)
16561 errmsg ("action not set for negative mapping");
16565 /* Construct the API message */
16566 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
16567 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
16569 mp->is_add = is_add;
16570 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
16571 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
16572 mp->eid_type = rmt_eid->type;
16573 mp->dp_table = clib_host_to_net_u32 (dp_table);
16574 mp->vni = clib_host_to_net_u32 (vni);
16575 mp->rmt_len = rmt_eid->len;
16576 mp->lcl_len = lcl_eid->len;
16577 mp->action = action;
16579 if (0 != rmt_locs && 0 != lcl_locs)
16581 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
16582 clib_memcpy (mp->locs, lcl_locs,
16583 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
16585 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
16586 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
16587 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
16589 vec_free (lcl_locs);
16590 vec_free (rmt_locs);
16595 /* Wait for a reply... */
16601 api_one_add_del_map_server (vat_main_t * vam)
16603 unformat_input_t *input = vam->input;
16604 vl_api_one_add_del_map_server_t *mp;
16608 ip4_address_t ipv4;
16609 ip6_address_t ipv6;
16612 /* Parse args required to build the message */
16613 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16615 if (unformat (input, "del"))
16619 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
16623 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
16631 if (ipv4_set && ipv6_set)
16633 errmsg ("both eid v4 and v6 addresses set");
16637 if (!ipv4_set && !ipv6_set)
16639 errmsg ("eid addresses not set");
16643 /* Construct the API message */
16644 M (ONE_ADD_DEL_MAP_SERVER, mp);
16646 mp->is_add = is_add;
16650 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
16655 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
16661 /* Wait for a reply... */
16666 #define api_lisp_add_del_map_server api_one_add_del_map_server
16669 api_one_add_del_map_resolver (vat_main_t * vam)
16671 unformat_input_t *input = vam->input;
16672 vl_api_one_add_del_map_resolver_t *mp;
16676 ip4_address_t ipv4;
16677 ip6_address_t ipv6;
16680 /* Parse args required to build the message */
16681 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16683 if (unformat (input, "del"))
16687 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
16691 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
16699 if (ipv4_set && ipv6_set)
16701 errmsg ("both eid v4 and v6 addresses set");
16705 if (!ipv4_set && !ipv6_set)
16707 errmsg ("eid addresses not set");
16711 /* Construct the API message */
16712 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
16714 mp->is_add = is_add;
16718 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
16723 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
16729 /* Wait for a reply... */
16734 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
16737 api_lisp_gpe_enable_disable (vat_main_t * vam)
16739 unformat_input_t *input = vam->input;
16740 vl_api_gpe_enable_disable_t *mp;
16745 /* Parse args required to build the message */
16746 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16748 if (unformat (input, "enable"))
16753 else if (unformat (input, "disable"))
16764 errmsg ("Value not set");
16768 /* Construct the API message */
16769 M (GPE_ENABLE_DISABLE, mp);
16776 /* Wait for a reply... */
16782 api_one_rloc_probe_enable_disable (vat_main_t * vam)
16784 unformat_input_t *input = vam->input;
16785 vl_api_one_rloc_probe_enable_disable_t *mp;
16790 /* Parse args required to build the message */
16791 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16793 if (unformat (input, "enable"))
16798 else if (unformat (input, "disable"))
16806 errmsg ("Value not set");
16810 /* Construct the API message */
16811 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
16813 mp->is_enabled = is_en;
16818 /* Wait for a reply... */
16823 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
16826 api_one_map_register_enable_disable (vat_main_t * vam)
16828 unformat_input_t *input = vam->input;
16829 vl_api_one_map_register_enable_disable_t *mp;
16834 /* Parse args required to build the message */
16835 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16837 if (unformat (input, "enable"))
16842 else if (unformat (input, "disable"))
16850 errmsg ("Value not set");
16854 /* Construct the API message */
16855 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
16857 mp->is_enabled = is_en;
16862 /* Wait for a reply... */
16867 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
16870 api_one_enable_disable (vat_main_t * vam)
16872 unformat_input_t *input = vam->input;
16873 vl_api_one_enable_disable_t *mp;
16878 /* Parse args required to build the message */
16879 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16881 if (unformat (input, "enable"))
16886 else if (unformat (input, "disable"))
16896 errmsg ("Value not set");
16900 /* Construct the API message */
16901 M (ONE_ENABLE_DISABLE, mp);
16908 /* Wait for a reply... */
16913 #define api_lisp_enable_disable api_one_enable_disable
16916 api_one_enable_disable_xtr_mode (vat_main_t * vam)
16918 unformat_input_t *input = vam->input;
16919 vl_api_one_enable_disable_xtr_mode_t *mp;
16924 /* Parse args required to build the message */
16925 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16927 if (unformat (input, "enable"))
16932 else if (unformat (input, "disable"))
16942 errmsg ("Value not set");
16946 /* Construct the API message */
16947 M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
16954 /* Wait for a reply... */
16960 api_one_show_xtr_mode (vat_main_t * vam)
16962 vl_api_one_show_xtr_mode_t *mp;
16965 /* Construct the API message */
16966 M (ONE_SHOW_XTR_MODE, mp);
16971 /* Wait for a reply... */
16977 api_one_enable_disable_pitr_mode (vat_main_t * vam)
16979 unformat_input_t *input = vam->input;
16980 vl_api_one_enable_disable_pitr_mode_t *mp;
16985 /* Parse args required to build the message */
16986 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16988 if (unformat (input, "enable"))
16993 else if (unformat (input, "disable"))
17003 errmsg ("Value not set");
17007 /* Construct the API message */
17008 M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
17015 /* Wait for a reply... */
17021 api_one_show_pitr_mode (vat_main_t * vam)
17023 vl_api_one_show_pitr_mode_t *mp;
17026 /* Construct the API message */
17027 M (ONE_SHOW_PITR_MODE, mp);
17032 /* Wait for a reply... */
17038 api_one_enable_disable_petr_mode (vat_main_t * vam)
17040 unformat_input_t *input = vam->input;
17041 vl_api_one_enable_disable_petr_mode_t *mp;
17046 /* Parse args required to build the message */
17047 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17049 if (unformat (input, "enable"))
17054 else if (unformat (input, "disable"))
17064 errmsg ("Value not set");
17068 /* Construct the API message */
17069 M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
17076 /* Wait for a reply... */
17082 api_one_show_petr_mode (vat_main_t * vam)
17084 vl_api_one_show_petr_mode_t *mp;
17087 /* Construct the API message */
17088 M (ONE_SHOW_PETR_MODE, mp);
17093 /* Wait for a reply... */
17099 api_show_one_map_register_state (vat_main_t * vam)
17101 vl_api_show_one_map_register_state_t *mp;
17104 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
17109 /* wait for reply */
17114 #define api_show_lisp_map_register_state api_show_one_map_register_state
17117 api_show_one_rloc_probe_state (vat_main_t * vam)
17119 vl_api_show_one_rloc_probe_state_t *mp;
17122 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
17127 /* wait for reply */
17132 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
17135 api_one_add_del_ndp_entry (vat_main_t * vam)
17137 vl_api_one_add_del_ndp_entry_t *mp;
17138 unformat_input_t *input = vam->input;
17143 u8 mac[6] = { 0, };
17144 u8 ip6[16] = { 0, };
17148 /* Parse args required to build the message */
17149 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17151 if (unformat (input, "del"))
17153 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
17155 else if (unformat (input, "ip %U", unformat_ip6_address, ip6))
17157 else if (unformat (input, "bd %d", &bd))
17161 errmsg ("parse error '%U'", format_unformat_error, input);
17166 if (!bd_set || !ip_set || (!mac_set && is_add))
17168 errmsg ("Missing BD, IP or MAC!");
17172 M (ONE_ADD_DEL_NDP_ENTRY, mp);
17173 mp->is_add = is_add;
17174 clib_memcpy (mp->mac, mac, 6);
17175 mp->bd = clib_host_to_net_u32 (bd);
17176 clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
17181 /* wait for reply */
17187 api_one_add_del_l2_arp_entry (vat_main_t * vam)
17189 vl_api_one_add_del_l2_arp_entry_t *mp;
17190 unformat_input_t *input = vam->input;
17195 u8 mac[6] = { 0, };
17196 u32 ip4 = 0, bd = ~0;
17199 /* Parse args required to build the message */
17200 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17202 if (unformat (input, "del"))
17204 else if (unformat (input, "mac %U", unformat_ethernet_address, mac))
17206 else if (unformat (input, "ip %U", unformat_ip4_address, &ip4))
17208 else if (unformat (input, "bd %d", &bd))
17212 errmsg ("parse error '%U'", format_unformat_error, input);
17217 if (!bd_set || !ip_set || (!mac_set && is_add))
17219 errmsg ("Missing BD, IP or MAC!");
17223 M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
17224 mp->is_add = is_add;
17225 clib_memcpy (mp->mac, mac, 6);
17226 mp->bd = clib_host_to_net_u32 (bd);
17232 /* wait for reply */
17238 api_one_ndp_bd_get (vat_main_t * vam)
17240 vl_api_one_ndp_bd_get_t *mp;
17243 M (ONE_NDP_BD_GET, mp);
17248 /* wait for reply */
17254 api_one_ndp_entries_get (vat_main_t * vam)
17256 vl_api_one_ndp_entries_get_t *mp;
17257 unformat_input_t *input = vam->input;
17262 /* Parse args required to build the message */
17263 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17265 if (unformat (input, "bd %d", &bd))
17269 errmsg ("parse error '%U'", format_unformat_error, input);
17276 errmsg ("Expected bridge domain!");
17280 M (ONE_NDP_ENTRIES_GET, mp);
17281 mp->bd = clib_host_to_net_u32 (bd);
17286 /* wait for reply */
17292 api_one_l2_arp_bd_get (vat_main_t * vam)
17294 vl_api_one_l2_arp_bd_get_t *mp;
17297 M (ONE_L2_ARP_BD_GET, mp);
17302 /* wait for reply */
17308 api_one_l2_arp_entries_get (vat_main_t * vam)
17310 vl_api_one_l2_arp_entries_get_t *mp;
17311 unformat_input_t *input = vam->input;
17316 /* Parse args required to build the message */
17317 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17319 if (unformat (input, "bd %d", &bd))
17323 errmsg ("parse error '%U'", format_unformat_error, input);
17330 errmsg ("Expected bridge domain!");
17334 M (ONE_L2_ARP_ENTRIES_GET, mp);
17335 mp->bd = clib_host_to_net_u32 (bd);
17340 /* wait for reply */
17346 api_one_stats_enable_disable (vat_main_t * vam)
17348 vl_api_one_stats_enable_disable_t *mp;
17349 unformat_input_t *input = vam->input;
17354 /* Parse args required to build the message */
17355 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17357 if (unformat (input, "enable"))
17362 else if (unformat (input, "disable"))
17372 errmsg ("Value not set");
17376 M (ONE_STATS_ENABLE_DISABLE, mp);
17382 /* wait for reply */
17388 api_show_one_stats_enable_disable (vat_main_t * vam)
17390 vl_api_show_one_stats_enable_disable_t *mp;
17393 M (SHOW_ONE_STATS_ENABLE_DISABLE, mp);
17398 /* wait for reply */
17404 api_show_one_map_request_mode (vat_main_t * vam)
17406 vl_api_show_one_map_request_mode_t *mp;
17409 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
17414 /* wait for reply */
17419 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
17422 api_one_map_request_mode (vat_main_t * vam)
17424 unformat_input_t *input = vam->input;
17425 vl_api_one_map_request_mode_t *mp;
17429 /* Parse args required to build the message */
17430 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17432 if (unformat (input, "dst-only"))
17434 else if (unformat (input, "src-dst"))
17438 errmsg ("parse error '%U'", format_unformat_error, input);
17443 M (ONE_MAP_REQUEST_MODE, mp);
17450 /* wait for reply */
17455 #define api_lisp_map_request_mode api_one_map_request_mode
17458 * Enable/disable ONE proxy ITR.
17460 * @param vam vpp API test context
17461 * @return return code
17464 api_one_pitr_set_locator_set (vat_main_t * vam)
17466 u8 ls_name_set = 0;
17467 unformat_input_t *input = vam->input;
17468 vl_api_one_pitr_set_locator_set_t *mp;
17473 /* Parse args required to build the message */
17474 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17476 if (unformat (input, "del"))
17478 else if (unformat (input, "locator-set %s", &ls_name))
17482 errmsg ("parse error '%U'", format_unformat_error, input);
17489 errmsg ("locator-set name not set!");
17493 M (ONE_PITR_SET_LOCATOR_SET, mp);
17495 mp->is_add = is_add;
17496 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
17497 vec_free (ls_name);
17502 /* wait for reply */
17507 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
17510 api_one_nsh_set_locator_set (vat_main_t * vam)
17512 u8 ls_name_set = 0;
17513 unformat_input_t *input = vam->input;
17514 vl_api_one_nsh_set_locator_set_t *mp;
17519 /* Parse args required to build the message */
17520 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17522 if (unformat (input, "del"))
17524 else if (unformat (input, "ls %s", &ls_name))
17528 errmsg ("parse error '%U'", format_unformat_error, input);
17533 if (!ls_name_set && is_add)
17535 errmsg ("locator-set name not set!");
17539 M (ONE_NSH_SET_LOCATOR_SET, mp);
17541 mp->is_add = is_add;
17542 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
17543 vec_free (ls_name);
17548 /* wait for reply */
17554 api_show_one_pitr (vat_main_t * vam)
17556 vl_api_show_one_pitr_t *mp;
17559 if (!vam->json_output)
17561 print (vam->ofp, "%=20s", "lisp status:");
17564 M (SHOW_ONE_PITR, mp);
17568 /* Wait for a reply... */
17573 #define api_show_lisp_pitr api_show_one_pitr
17576 api_one_use_petr (vat_main_t * vam)
17578 unformat_input_t *input = vam->input;
17579 vl_api_one_use_petr_t *mp;
17584 memset (&ip, 0, sizeof (ip));
17586 /* Parse args required to build the message */
17587 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17589 if (unformat (input, "disable"))
17592 if (unformat (input, "%U", unformat_ip4_address, &ip_addr_v4 (&ip)))
17595 ip_addr_version (&ip) = IP4;
17598 if (unformat (input, "%U", unformat_ip6_address, &ip_addr_v6 (&ip)))
17601 ip_addr_version (&ip) = IP6;
17605 errmsg ("parse error '%U'", format_unformat_error, input);
17610 M (ONE_USE_PETR, mp);
17612 mp->is_add = is_add;
17615 mp->is_ip4 = ip_addr_version (&ip) == IP4 ? 1 : 0;
17617 clib_memcpy (mp->address, &ip, 4);
17619 clib_memcpy (mp->address, &ip, 16);
17625 /* wait for reply */
17630 #define api_lisp_use_petr api_one_use_petr
17633 api_show_one_nsh_mapping (vat_main_t * vam)
17635 vl_api_show_one_use_petr_t *mp;
17638 if (!vam->json_output)
17640 print (vam->ofp, "%=20s", "local ONE NSH mapping:");
17643 M (SHOW_ONE_NSH_MAPPING, mp);
17647 /* Wait for a reply... */
17653 api_show_one_use_petr (vat_main_t * vam)
17655 vl_api_show_one_use_petr_t *mp;
17658 if (!vam->json_output)
17660 print (vam->ofp, "%=20s", "Proxy-ETR status:");
17663 M (SHOW_ONE_USE_PETR, mp);
17667 /* Wait for a reply... */
17672 #define api_show_lisp_use_petr api_show_one_use_petr
17675 * Add/delete mapping between vni and vrf
17678 api_one_eid_table_add_del_map (vat_main_t * vam)
17680 unformat_input_t *input = vam->input;
17681 vl_api_one_eid_table_add_del_map_t *mp;
17682 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
17683 u32 vni, vrf, bd_index;
17686 /* Parse args required to build the message */
17687 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17689 if (unformat (input, "del"))
17691 else if (unformat (input, "vrf %d", &vrf))
17693 else if (unformat (input, "bd_index %d", &bd_index))
17695 else if (unformat (input, "vni %d", &vni))
17701 if (!vni_set || (!vrf_set && !bd_index_set))
17703 errmsg ("missing arguments!");
17707 if (vrf_set && bd_index_set)
17709 errmsg ("error: both vrf and bd entered!");
17713 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
17715 mp->is_add = is_add;
17716 mp->vni = htonl (vni);
17717 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
17718 mp->is_l2 = bd_index_set;
17723 /* wait for reply */
17728 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
17731 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
17733 u32 *action = va_arg (*args, u32 *);
17736 if (unformat (input, "%s", &s))
17738 if (!strcmp ((char *) s, "no-action"))
17740 else if (!strcmp ((char *) s, "natively-forward"))
17742 else if (!strcmp ((char *) s, "send-map-request"))
17744 else if (!strcmp ((char *) s, "drop"))
17748 clib_warning ("invalid action: '%s'", s);
17760 * Add/del remote mapping to/from ONE control plane
17762 * @param vam vpp API test context
17763 * @return return code
17766 api_one_add_del_remote_mapping (vat_main_t * vam)
17768 unformat_input_t *input = vam->input;
17769 vl_api_one_add_del_remote_mapping_t *mp;
17771 lisp_eid_vat_t _eid, *eid = &_eid;
17772 lisp_eid_vat_t _seid, *seid = &_seid;
17773 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
17774 u32 action = ~0, p, w, data_len;
17775 ip4_address_t rloc4;
17776 ip6_address_t rloc6;
17777 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
17780 memset (&rloc, 0, sizeof (rloc));
17782 /* Parse args required to build the message */
17783 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17785 if (unformat (input, "del-all"))
17789 else if (unformat (input, "del"))
17793 else if (unformat (input, "add"))
17797 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
17801 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
17805 else if (unformat (input, "vni %d", &vni))
17809 else if (unformat (input, "p %d w %d", &p, &w))
17813 errmsg ("No RLOC configured for setting priority/weight!");
17816 curr_rloc->priority = p;
17817 curr_rloc->weight = w;
17819 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
17822 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
17823 vec_add1 (rlocs, rloc);
17824 curr_rloc = &rlocs[vec_len (rlocs) - 1];
17826 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
17829 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
17830 vec_add1 (rlocs, rloc);
17831 curr_rloc = &rlocs[vec_len (rlocs) - 1];
17833 else if (unformat (input, "action %U",
17834 unformat_negative_mapping_action, &action))
17840 clib_warning ("parse error '%U'", format_unformat_error, input);
17847 errmsg ("missing params!");
17851 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
17853 errmsg ("no action set for negative map-reply!");
17857 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
17859 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
17860 mp->is_add = is_add;
17861 mp->vni = htonl (vni);
17862 mp->action = (u8) action;
17863 mp->is_src_dst = seid_set;
17864 mp->eid_len = eid->len;
17865 mp->seid_len = seid->len;
17866 mp->del_all = del_all;
17867 mp->eid_type = eid->type;
17868 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
17869 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
17871 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
17872 clib_memcpy (mp->rlocs, rlocs, data_len);
17878 /* Wait for a reply... */
17883 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
17886 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
17887 * forwarding entries in data-plane accordingly.
17889 * @param vam vpp API test context
17890 * @return return code
17893 api_one_add_del_adjacency (vat_main_t * vam)
17895 unformat_input_t *input = vam->input;
17896 vl_api_one_add_del_adjacency_t *mp;
17898 ip4_address_t leid4, reid4;
17899 ip6_address_t leid6, reid6;
17900 u8 reid_mac[6] = { 0 };
17901 u8 leid_mac[6] = { 0 };
17902 u8 reid_type, leid_type;
17903 u32 leid_len = 0, reid_len = 0, len;
17907 leid_type = reid_type = (u8) ~ 0;
17909 /* Parse args required to build the message */
17910 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17912 if (unformat (input, "del"))
17916 else if (unformat (input, "add"))
17920 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
17923 reid_type = 0; /* ipv4 */
17926 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
17929 reid_type = 1; /* ipv6 */
17932 else if (unformat (input, "reid %U", unformat_ethernet_address,
17935 reid_type = 2; /* mac */
17937 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
17940 leid_type = 0; /* ipv4 */
17943 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
17946 leid_type = 1; /* ipv6 */
17949 else if (unformat (input, "leid %U", unformat_ethernet_address,
17952 leid_type = 2; /* mac */
17954 else if (unformat (input, "vni %d", &vni))
17960 errmsg ("parse error '%U'", format_unformat_error, input);
17965 if ((u8) ~ 0 == reid_type)
17967 errmsg ("missing params!");
17971 if (leid_type != reid_type)
17973 errmsg ("remote and local EIDs are of different types!");
17977 M (ONE_ADD_DEL_ADJACENCY, mp);
17978 mp->is_add = is_add;
17979 mp->vni = htonl (vni);
17980 mp->leid_len = leid_len;
17981 mp->reid_len = reid_len;
17982 mp->eid_type = reid_type;
17984 switch (mp->eid_type)
17987 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
17988 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
17991 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
17992 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
17995 clib_memcpy (mp->leid, leid_mac, 6);
17996 clib_memcpy (mp->reid, reid_mac, 6);
17999 errmsg ("unknown EID type %d!", mp->eid_type);
18006 /* Wait for a reply... */
18011 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
18014 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
18016 u32 *mode = va_arg (*args, u32 *);
18018 if (unformat (input, "lisp"))
18020 else if (unformat (input, "vxlan"))
18029 api_gpe_get_encap_mode (vat_main_t * vam)
18031 vl_api_gpe_get_encap_mode_t *mp;
18034 /* Construct the API message */
18035 M (GPE_GET_ENCAP_MODE, mp);
18040 /* Wait for a reply... */
18046 api_gpe_set_encap_mode (vat_main_t * vam)
18048 unformat_input_t *input = vam->input;
18049 vl_api_gpe_set_encap_mode_t *mp;
18053 /* Parse args required to build the message */
18054 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18056 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
18062 /* Construct the API message */
18063 M (GPE_SET_ENCAP_MODE, mp);
18070 /* Wait for a reply... */
18076 api_lisp_gpe_add_del_iface (vat_main_t * vam)
18078 unformat_input_t *input = vam->input;
18079 vl_api_gpe_add_del_iface_t *mp;
18080 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
18081 u32 dp_table = 0, vni = 0;
18084 /* Parse args required to build the message */
18085 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18087 if (unformat (input, "up"))
18092 else if (unformat (input, "down"))
18097 else if (unformat (input, "table_id %d", &dp_table))
18101 else if (unformat (input, "bd_id %d", &dp_table))
18106 else if (unformat (input, "vni %d", &vni))
18114 if (action_set == 0)
18116 errmsg ("Action not set");
18119 if (dp_table_set == 0 || vni_set == 0)
18121 errmsg ("vni and dp_table must be set");
18125 /* Construct the API message */
18126 M (GPE_ADD_DEL_IFACE, mp);
18128 mp->is_add = is_add;
18129 mp->dp_table = clib_host_to_net_u32 (dp_table);
18131 mp->vni = clib_host_to_net_u32 (vni);
18136 /* Wait for a reply... */
18142 api_one_map_register_fallback_threshold (vat_main_t * vam)
18144 unformat_input_t *input = vam->input;
18145 vl_api_one_map_register_fallback_threshold_t *mp;
18150 /* Parse args required to build the message */
18151 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18153 if (unformat (input, "%u", &value))
18157 clib_warning ("parse error '%U'", format_unformat_error, input);
18164 errmsg ("fallback threshold value is missing!");
18168 M (ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
18169 mp->value = clib_host_to_net_u32 (value);
18174 /* Wait for a reply... */
18180 api_show_one_map_register_fallback_threshold (vat_main_t * vam)
18182 vl_api_show_one_map_register_fallback_threshold_t *mp;
18185 M (SHOW_ONE_MAP_REGISTER_FALLBACK_THRESHOLD, mp);
18190 /* Wait for a reply... */
18196 unformat_lisp_transport_protocol (unformat_input_t * input, va_list * args)
18198 u32 *proto = va_arg (*args, u32 *);
18200 if (unformat (input, "udp"))
18202 else if (unformat (input, "api"))
18211 api_one_set_transport_protocol (vat_main_t * vam)
18213 unformat_input_t *input = vam->input;
18214 vl_api_one_set_transport_protocol_t *mp;
18219 /* Parse args required to build the message */
18220 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18222 if (unformat (input, "%U", unformat_lisp_transport_protocol, &protocol))
18226 clib_warning ("parse error '%U'", format_unformat_error, input);
18233 errmsg ("Transport protocol missing!");
18237 M (ONE_SET_TRANSPORT_PROTOCOL, mp);
18238 mp->protocol = (u8) protocol;
18243 /* Wait for a reply... */
18249 api_one_get_transport_protocol (vat_main_t * vam)
18251 vl_api_one_get_transport_protocol_t *mp;
18254 M (ONE_GET_TRANSPORT_PROTOCOL, mp);
18259 /* Wait for a reply... */
18265 api_one_map_register_set_ttl (vat_main_t * vam)
18267 unformat_input_t *input = vam->input;
18268 vl_api_one_map_register_set_ttl_t *mp;
18273 /* Parse args required to build the message */
18274 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18276 if (unformat (input, "%u", &ttl))
18280 clib_warning ("parse error '%U'", format_unformat_error, input);
18287 errmsg ("TTL value missing!");
18291 M (ONE_MAP_REGISTER_SET_TTL, mp);
18292 mp->ttl = clib_host_to_net_u32 (ttl);
18297 /* Wait for a reply... */
18303 api_show_one_map_register_ttl (vat_main_t * vam)
18305 vl_api_show_one_map_register_ttl_t *mp;
18308 M (SHOW_ONE_MAP_REGISTER_TTL, mp);
18313 /* Wait for a reply... */
18319 * Add/del map request itr rlocs from ONE control plane and updates
18321 * @param vam vpp API test context
18322 * @return return code
18325 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
18327 unformat_input_t *input = vam->input;
18328 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
18329 u8 *locator_set_name = 0;
18330 u8 locator_set_name_set = 0;
18334 /* Parse args required to build the message */
18335 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18337 if (unformat (input, "del"))
18341 else if (unformat (input, "%_%v%_", &locator_set_name))
18343 locator_set_name_set = 1;
18347 clib_warning ("parse error '%U'", format_unformat_error, input);
18352 if (is_add && !locator_set_name_set)
18354 errmsg ("itr-rloc is not set!");
18358 if (is_add && vec_len (locator_set_name) > 64)
18360 errmsg ("itr-rloc locator-set name too long");
18361 vec_free (locator_set_name);
18365 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
18366 mp->is_add = is_add;
18369 clib_memcpy (mp->locator_set_name, locator_set_name,
18370 vec_len (locator_set_name));
18374 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
18376 vec_free (locator_set_name);
18381 /* Wait for a reply... */
18386 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
18389 api_one_locator_dump (vat_main_t * vam)
18391 unformat_input_t *input = vam->input;
18392 vl_api_one_locator_dump_t *mp;
18393 vl_api_control_ping_t *mp_ping;
18394 u8 is_index_set = 0, is_name_set = 0;
18399 /* Parse args required to build the message */
18400 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18402 if (unformat (input, "ls_name %_%v%_", &ls_name))
18406 else if (unformat (input, "ls_index %d", &ls_index))
18412 errmsg ("parse error '%U'", format_unformat_error, input);
18417 if (!is_index_set && !is_name_set)
18419 errmsg ("error: expected one of index or name!");
18423 if (is_index_set && is_name_set)
18425 errmsg ("error: only one param expected!");
18429 if (vec_len (ls_name) > 62)
18431 errmsg ("error: locator set name too long!");
18435 if (!vam->json_output)
18437 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
18440 M (ONE_LOCATOR_DUMP, mp);
18441 mp->is_index_set = is_index_set;
18444 mp->ls_index = clib_host_to_net_u32 (ls_index);
18447 vec_add1 (ls_name, 0);
18448 strncpy ((char *) mp->ls_name, (char *) ls_name,
18449 sizeof (mp->ls_name) - 1);
18455 /* Use a control ping for synchronization */
18456 MPING (CONTROL_PING, mp_ping);
18459 /* Wait for a reply... */
18464 #define api_lisp_locator_dump api_one_locator_dump
18467 api_one_locator_set_dump (vat_main_t * vam)
18469 vl_api_one_locator_set_dump_t *mp;
18470 vl_api_control_ping_t *mp_ping;
18471 unformat_input_t *input = vam->input;
18475 /* Parse args required to build the message */
18476 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18478 if (unformat (input, "local"))
18482 else if (unformat (input, "remote"))
18488 errmsg ("parse error '%U'", format_unformat_error, input);
18493 if (!vam->json_output)
18495 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
18498 M (ONE_LOCATOR_SET_DUMP, mp);
18500 mp->filter = filter;
18505 /* Use a control ping for synchronization */
18506 MPING (CONTROL_PING, mp_ping);
18509 /* Wait for a reply... */
18514 #define api_lisp_locator_set_dump api_one_locator_set_dump
18517 api_one_eid_table_map_dump (vat_main_t * vam)
18521 unformat_input_t *input = vam->input;
18522 vl_api_one_eid_table_map_dump_t *mp;
18523 vl_api_control_ping_t *mp_ping;
18526 /* Parse args required to build the message */
18527 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
18529 if (unformat (input, "l2"))
18534 else if (unformat (input, "l3"))
18541 errmsg ("parse error '%U'", format_unformat_error, input);
18548 errmsg ("expected one of 'l2' or 'l3' parameter!");
18552 if (!vam->json_output)
18554 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
18557 M (ONE_EID_TABLE_MAP_DUMP, mp);
18563 /* Use a control ping for synchronization */
18564 MPING (CONTROL_PING, mp_ping);
18567 /* Wait for a reply... */
18572 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
18575 api_one_eid_table_vni_dump (vat_main_t * vam)
18577 vl_api_one_eid_table_vni_dump_t *mp;
18578 vl_api_control_ping_t *mp_ping;
18581 if (!vam->json_output)
18583 print (vam->ofp, "VNI");
18586 M (ONE_EID_TABLE_VNI_DUMP, mp);
18591 /* Use a control ping for synchronization */
18592 MPING (CONTROL_PING, mp_ping);
18595 /* Wait for a reply... */
18600 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
18603 api_one_eid_table_dump (vat_main_t * vam)
18605 unformat_input_t *i = vam->input;
18606 vl_api_one_eid_table_dump_t *mp;
18607 vl_api_control_ping_t *mp_ping;
18608 struct in_addr ip4;
18609 struct in6_addr ip6;
18611 u8 eid_type = ~0, eid_set = 0;
18612 u32 prefix_length = ~0, t, vni = 0;
18615 lisp_nsh_api_t nsh;
18617 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18619 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
18625 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
18631 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
18636 else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
18641 else if (unformat (i, "vni %d", &t))
18645 else if (unformat (i, "local"))
18649 else if (unformat (i, "remote"))
18655 errmsg ("parse error '%U'", format_unformat_error, i);
18660 if (!vam->json_output)
18662 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
18663 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
18666 M (ONE_EID_TABLE_DUMP, mp);
18668 mp->filter = filter;
18672 mp->vni = htonl (vni);
18673 mp->eid_type = eid_type;
18677 mp->prefix_length = prefix_length;
18678 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
18681 mp->prefix_length = prefix_length;
18682 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
18685 clib_memcpy (mp->eid, mac, sizeof (mac));
18688 clib_memcpy (mp->eid, &nsh, sizeof (nsh));
18691 errmsg ("unknown EID type %d!", eid_type);
18699 /* Use a control ping for synchronization */
18700 MPING (CONTROL_PING, mp_ping);
18703 /* Wait for a reply... */
18708 #define api_lisp_eid_table_dump api_one_eid_table_dump
18711 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
18713 unformat_input_t *i = vam->input;
18714 vl_api_gpe_fwd_entries_get_t *mp;
18719 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18721 if (unformat (i, "vni %d", &vni))
18727 errmsg ("parse error '%U'", format_unformat_error, i);
18734 errmsg ("vni not set!");
18738 if (!vam->json_output)
18740 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
18744 M (GPE_FWD_ENTRIES_GET, mp);
18745 mp->vni = clib_host_to_net_u32 (vni);
18750 /* Wait for a reply... */
18755 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_endian vl_noop_handler
18756 #define vl_api_gpe_native_fwd_rpaths_get_reply_t_print vl_noop_handler
18757 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_endian vl_noop_handler
18758 #define vl_api_gpe_fwd_entry_vnis_get_reply_t_print vl_noop_handler
18759 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
18760 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
18761 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
18762 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
18765 api_one_adjacencies_get (vat_main_t * vam)
18767 unformat_input_t *i = vam->input;
18768 vl_api_one_adjacencies_get_t *mp;
18773 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18775 if (unformat (i, "vni %d", &vni))
18781 errmsg ("parse error '%U'", format_unformat_error, i);
18788 errmsg ("vni not set!");
18792 if (!vam->json_output)
18794 print (vam->ofp, "%s %40s", "leid", "reid");
18797 M (ONE_ADJACENCIES_GET, mp);
18798 mp->vni = clib_host_to_net_u32 (vni);
18803 /* Wait for a reply... */
18808 #define api_lisp_adjacencies_get api_one_adjacencies_get
18811 api_gpe_native_fwd_rpaths_get (vat_main_t * vam)
18813 unformat_input_t *i = vam->input;
18814 vl_api_gpe_native_fwd_rpaths_get_t *mp;
18816 u8 ip_family_set = 0, is_ip4 = 1;
18818 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18820 if (unformat (i, "ip4"))
18825 else if (unformat (i, "ip6"))
18832 errmsg ("parse error '%U'", format_unformat_error, i);
18837 if (!ip_family_set)
18839 errmsg ("ip family not set!");
18843 M (GPE_NATIVE_FWD_RPATHS_GET, mp);
18844 mp->is_ip4 = is_ip4;
18849 /* Wait for a reply... */
18855 api_gpe_fwd_entry_vnis_get (vat_main_t * vam)
18857 vl_api_gpe_fwd_entry_vnis_get_t *mp;
18860 if (!vam->json_output)
18862 print (vam->ofp, "VNIs");
18865 M (GPE_FWD_ENTRY_VNIS_GET, mp);
18870 /* Wait for a reply... */
18876 api_gpe_add_del_native_fwd_rpath (vat_main_t * vam)
18878 unformat_input_t *i = vam->input;
18879 vl_api_gpe_add_del_native_fwd_rpath_t *mp;
18881 u8 is_add = 1, ip_set = 0, is_ip4 = 1;
18882 struct in_addr ip4;
18883 struct in6_addr ip6;
18884 u32 table_id = 0, nh_sw_if_index = ~0;
18886 memset (&ip4, 0, sizeof (ip4));
18887 memset (&ip6, 0, sizeof (ip6));
18889 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
18891 if (unformat (i, "del"))
18893 else if (unformat (i, "via %U %U", unformat_ip4_address, &ip4,
18894 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18899 else if (unformat (i, "via %U %U", unformat_ip6_address, &ip6,
18900 api_unformat_sw_if_index, vam, &nh_sw_if_index))
18905 else if (unformat (i, "via %U", unformat_ip4_address, &ip4))
18909 nh_sw_if_index = ~0;
18911 else if (unformat (i, "via %U", unformat_ip6_address, &ip6))
18915 nh_sw_if_index = ~0;
18917 else if (unformat (i, "table %d", &table_id))
18921 errmsg ("parse error '%U'", format_unformat_error, i);
18928 errmsg ("nh addr not set!");
18932 M (GPE_ADD_DEL_NATIVE_FWD_RPATH, mp);
18933 mp->is_add = is_add;
18934 mp->table_id = clib_host_to_net_u32 (table_id);
18935 mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
18936 mp->is_ip4 = is_ip4;
18938 clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
18940 clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
18945 /* Wait for a reply... */
18951 api_one_map_server_dump (vat_main_t * vam)
18953 vl_api_one_map_server_dump_t *mp;
18954 vl_api_control_ping_t *mp_ping;
18957 if (!vam->json_output)
18959 print (vam->ofp, "%=20s", "Map server");
18962 M (ONE_MAP_SERVER_DUMP, mp);
18966 /* Use a control ping for synchronization */
18967 MPING (CONTROL_PING, mp_ping);
18970 /* Wait for a reply... */
18975 #define api_lisp_map_server_dump api_one_map_server_dump
18978 api_one_map_resolver_dump (vat_main_t * vam)
18980 vl_api_one_map_resolver_dump_t *mp;
18981 vl_api_control_ping_t *mp_ping;
18984 if (!vam->json_output)
18986 print (vam->ofp, "%=20s", "Map resolver");
18989 M (ONE_MAP_RESOLVER_DUMP, mp);
18993 /* Use a control ping for synchronization */
18994 MPING (CONTROL_PING, mp_ping);
18997 /* Wait for a reply... */
19002 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
19005 api_one_stats_flush (vat_main_t * vam)
19007 vl_api_one_stats_flush_t *mp;
19010 M (ONE_STATS_FLUSH, mp);
19017 api_one_stats_dump (vat_main_t * vam)
19019 vl_api_one_stats_dump_t *mp;
19020 vl_api_control_ping_t *mp_ping;
19023 M (ONE_STATS_DUMP, mp);
19027 /* Use a control ping for synchronization */
19028 MPING (CONTROL_PING, mp_ping);
19031 /* Wait for a reply... */
19037 api_show_one_status (vat_main_t * vam)
19039 vl_api_show_one_status_t *mp;
19042 if (!vam->json_output)
19044 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
19047 M (SHOW_ONE_STATUS, mp);
19050 /* Wait for a reply... */
19055 #define api_show_lisp_status api_show_one_status
19058 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
19060 vl_api_gpe_fwd_entry_path_dump_t *mp;
19061 vl_api_control_ping_t *mp_ping;
19062 unformat_input_t *i = vam->input;
19063 u32 fwd_entry_index = ~0;
19066 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19068 if (unformat (i, "index %d", &fwd_entry_index))
19074 if (~0 == fwd_entry_index)
19076 errmsg ("no index specified!");
19080 if (!vam->json_output)
19082 print (vam->ofp, "first line");
19085 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
19089 /* Use a control ping for synchronization */
19090 MPING (CONTROL_PING, mp_ping);
19093 /* Wait for a reply... */
19099 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
19101 vl_api_one_get_map_request_itr_rlocs_t *mp;
19104 if (!vam->json_output)
19106 print (vam->ofp, "%=20s", "itr-rlocs:");
19109 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
19112 /* Wait for a reply... */
19117 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
19120 api_af_packet_create (vat_main_t * vam)
19122 unformat_input_t *i = vam->input;
19123 vl_api_af_packet_create_t *mp;
19124 u8 *host_if_name = 0;
19126 u8 random_hw_addr = 1;
19129 memset (hw_addr, 0, sizeof (hw_addr));
19131 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19133 if (unformat (i, "name %s", &host_if_name))
19134 vec_add1 (host_if_name, 0);
19135 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
19136 random_hw_addr = 0;
19141 if (!vec_len (host_if_name))
19143 errmsg ("host-interface name must be specified");
19147 if (vec_len (host_if_name) > 64)
19149 errmsg ("host-interface name too long");
19153 M (AF_PACKET_CREATE, mp);
19155 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
19156 clib_memcpy (mp->hw_addr, hw_addr, 6);
19157 mp->use_random_hw_addr = random_hw_addr;
19158 vec_free (host_if_name);
19166 fprintf (vam->ofp ? vam->ofp : stderr,
19167 " new sw_if_index = %d\n", vam->sw_if_index);
19174 api_af_packet_delete (vat_main_t * vam)
19176 unformat_input_t *i = vam->input;
19177 vl_api_af_packet_delete_t *mp;
19178 u8 *host_if_name = 0;
19181 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19183 if (unformat (i, "name %s", &host_if_name))
19184 vec_add1 (host_if_name, 0);
19189 if (!vec_len (host_if_name))
19191 errmsg ("host-interface name must be specified");
19195 if (vec_len (host_if_name) > 64)
19197 errmsg ("host-interface name too long");
19201 M (AF_PACKET_DELETE, mp);
19203 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
19204 vec_free (host_if_name);
19212 api_policer_add_del (vat_main_t * vam)
19214 unformat_input_t *i = vam->input;
19215 vl_api_policer_add_del_t *mp;
19225 u8 color_aware = 0;
19226 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
19229 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
19230 conform_action.dscp = 0;
19231 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
19232 exceed_action.dscp = 0;
19233 violate_action.action_type = SSE2_QOS_ACTION_DROP;
19234 violate_action.dscp = 0;
19236 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19238 if (unformat (i, "del"))
19240 else if (unformat (i, "name %s", &name))
19241 vec_add1 (name, 0);
19242 else if (unformat (i, "cir %u", &cir))
19244 else if (unformat (i, "eir %u", &eir))
19246 else if (unformat (i, "cb %u", &cb))
19248 else if (unformat (i, "eb %u", &eb))
19250 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
19253 else if (unformat (i, "round_type %U", unformat_policer_round_type,
19256 else if (unformat (i, "type %U", unformat_policer_type, &type))
19258 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
19261 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
19264 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
19267 else if (unformat (i, "color-aware"))
19273 if (!vec_len (name))
19275 errmsg ("policer name must be specified");
19279 if (vec_len (name) > 64)
19281 errmsg ("policer name too long");
19285 M (POLICER_ADD_DEL, mp);
19287 clib_memcpy (mp->name, name, vec_len (name));
19289 mp->is_add = is_add;
19290 mp->cir = ntohl (cir);
19291 mp->eir = ntohl (eir);
19292 mp->cb = clib_net_to_host_u64 (cb);
19293 mp->eb = clib_net_to_host_u64 (eb);
19294 mp->rate_type = rate_type;
19295 mp->round_type = round_type;
19297 mp->conform_action_type = conform_action.action_type;
19298 mp->conform_dscp = conform_action.dscp;
19299 mp->exceed_action_type = exceed_action.action_type;
19300 mp->exceed_dscp = exceed_action.dscp;
19301 mp->violate_action_type = violate_action.action_type;
19302 mp->violate_dscp = violate_action.dscp;
19303 mp->color_aware = color_aware;
19311 api_policer_dump (vat_main_t * vam)
19313 unformat_input_t *i = vam->input;
19314 vl_api_policer_dump_t *mp;
19315 vl_api_control_ping_t *mp_ping;
19316 u8 *match_name = 0;
19317 u8 match_name_valid = 0;
19320 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19322 if (unformat (i, "name %s", &match_name))
19324 vec_add1 (match_name, 0);
19325 match_name_valid = 1;
19331 M (POLICER_DUMP, mp);
19332 mp->match_name_valid = match_name_valid;
19333 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
19334 vec_free (match_name);
19338 /* Use a control ping for synchronization */
19339 MPING (CONTROL_PING, mp_ping);
19342 /* Wait for a reply... */
19348 api_policer_classify_set_interface (vat_main_t * vam)
19350 unformat_input_t *i = vam->input;
19351 vl_api_policer_classify_set_interface_t *mp;
19353 int sw_if_index_set;
19354 u32 ip4_table_index = ~0;
19355 u32 ip6_table_index = ~0;
19356 u32 l2_table_index = ~0;
19360 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19362 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19363 sw_if_index_set = 1;
19364 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19365 sw_if_index_set = 1;
19366 else if (unformat (i, "del"))
19368 else if (unformat (i, "ip4-table %d", &ip4_table_index))
19370 else if (unformat (i, "ip6-table %d", &ip6_table_index))
19372 else if (unformat (i, "l2-table %d", &l2_table_index))
19376 clib_warning ("parse error '%U'", format_unformat_error, i);
19381 if (sw_if_index_set == 0)
19383 errmsg ("missing interface name or sw_if_index");
19387 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
19389 mp->sw_if_index = ntohl (sw_if_index);
19390 mp->ip4_table_index = ntohl (ip4_table_index);
19391 mp->ip6_table_index = ntohl (ip6_table_index);
19392 mp->l2_table_index = ntohl (l2_table_index);
19393 mp->is_add = is_add;
19401 api_policer_classify_dump (vat_main_t * vam)
19403 unformat_input_t *i = vam->input;
19404 vl_api_policer_classify_dump_t *mp;
19405 vl_api_control_ping_t *mp_ping;
19406 u8 type = POLICER_CLASSIFY_N_TABLES;
19409 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
19413 errmsg ("classify table type must be specified");
19417 if (!vam->json_output)
19419 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
19422 M (POLICER_CLASSIFY_DUMP, mp);
19427 /* Use a control ping for synchronization */
19428 MPING (CONTROL_PING, mp_ping);
19431 /* Wait for a reply... */
19437 api_netmap_create (vat_main_t * vam)
19439 unformat_input_t *i = vam->input;
19440 vl_api_netmap_create_t *mp;
19443 u8 random_hw_addr = 1;
19448 memset (hw_addr, 0, sizeof (hw_addr));
19450 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19452 if (unformat (i, "name %s", &if_name))
19453 vec_add1 (if_name, 0);
19454 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
19455 random_hw_addr = 0;
19456 else if (unformat (i, "pipe"))
19458 else if (unformat (i, "master"))
19460 else if (unformat (i, "slave"))
19466 if (!vec_len (if_name))
19468 errmsg ("interface name must be specified");
19472 if (vec_len (if_name) > 64)
19474 errmsg ("interface name too long");
19478 M (NETMAP_CREATE, mp);
19480 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
19481 clib_memcpy (mp->hw_addr, hw_addr, 6);
19482 mp->use_random_hw_addr = random_hw_addr;
19483 mp->is_pipe = is_pipe;
19484 mp->is_master = is_master;
19485 vec_free (if_name);
19493 api_netmap_delete (vat_main_t * vam)
19495 unformat_input_t *i = vam->input;
19496 vl_api_netmap_delete_t *mp;
19500 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19502 if (unformat (i, "name %s", &if_name))
19503 vec_add1 (if_name, 0);
19508 if (!vec_len (if_name))
19510 errmsg ("interface name must be specified");
19514 if (vec_len (if_name) > 64)
19516 errmsg ("interface name too long");
19520 M (NETMAP_DELETE, mp);
19522 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
19523 vec_free (if_name);
19531 vl_api_mpls_fib_path_print (vat_main_t * vam, vl_api_fib_path2_t * fp)
19533 if (fp->afi == IP46_TYPE_IP6)
19535 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19536 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19537 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19538 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19539 format_ip6_address, fp->next_hop);
19540 else if (fp->afi == IP46_TYPE_IP4)
19542 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19543 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19544 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19545 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19546 format_ip4_address, fp->next_hop);
19550 vl_api_mpls_fib_path_json_print (vat_json_node_t * node,
19551 vl_api_fib_path2_t * fp)
19553 struct in_addr ip4;
19554 struct in6_addr ip6;
19556 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19557 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19558 vat_json_object_add_uint (node, "is_local", fp->is_local);
19559 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19560 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19561 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19562 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19563 if (fp->afi == IP46_TYPE_IP4)
19565 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19566 vat_json_object_add_ip4 (node, "next_hop", ip4);
19568 else if (fp->afi == IP46_TYPE_IP6)
19570 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19571 vat_json_object_add_ip6 (node, "next_hop", ip6);
19576 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_tunnel_details_t * mp)
19578 vat_main_t *vam = &vat_main;
19579 int count = ntohl (mp->mt_count);
19580 vl_api_fib_path2_t *fp;
19583 print (vam->ofp, "[%d]: sw_if_index %d via:",
19584 ntohl (mp->mt_tunnel_index), ntohl (mp->mt_sw_if_index));
19586 for (i = 0; i < count; i++)
19588 vl_api_mpls_fib_path_print (vam, fp);
19592 print (vam->ofp, "");
19595 #define vl_api_mpls_tunnel_details_t_endian vl_noop_handler
19596 #define vl_api_mpls_tunnel_details_t_print vl_noop_handler
19599 vl_api_mpls_tunnel_details_t_handler_json (vl_api_mpls_tunnel_details_t * mp)
19601 vat_main_t *vam = &vat_main;
19602 vat_json_node_t *node = NULL;
19603 int count = ntohl (mp->mt_count);
19604 vl_api_fib_path2_t *fp;
19607 if (VAT_JSON_ARRAY != vam->json_tree.type)
19609 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19610 vat_json_init_array (&vam->json_tree);
19612 node = vat_json_array_add (&vam->json_tree);
19614 vat_json_init_object (node);
19615 vat_json_object_add_uint (node, "tunnel_index",
19616 ntohl (mp->mt_tunnel_index));
19617 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->mt_sw_if_index));
19619 vat_json_object_add_uint (node, "l2_only", mp->mt_l2_only);
19622 for (i = 0; i < count; i++)
19624 vl_api_mpls_fib_path_json_print (node, fp);
19630 api_mpls_tunnel_dump (vat_main_t * vam)
19632 vl_api_mpls_tunnel_dump_t *mp;
19633 vl_api_control_ping_t *mp_ping;
19637 /* Parse args required to build the message */
19638 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
19640 if (!unformat (vam->input, "tunnel_index %d", &index))
19647 print (vam->ofp, " tunnel_index %d", index);
19649 M (MPLS_TUNNEL_DUMP, mp);
19650 mp->tunnel_index = htonl (index);
19653 /* Use a control ping for synchronization */
19654 MPING (CONTROL_PING, mp_ping);
19661 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
19662 #define vl_api_mpls_fib_details_t_print vl_noop_handler
19666 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
19668 vat_main_t *vam = &vat_main;
19669 int count = ntohl (mp->count);
19670 vl_api_fib_path2_t *fp;
19674 "table-id %d, label %u, ess_bit %u",
19675 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
19677 for (i = 0; i < count; i++)
19679 vl_api_mpls_fib_path_print (vam, fp);
19684 static void vl_api_mpls_fib_details_t_handler_json
19685 (vl_api_mpls_fib_details_t * mp)
19687 vat_main_t *vam = &vat_main;
19688 int count = ntohl (mp->count);
19689 vat_json_node_t *node = NULL;
19690 vl_api_fib_path2_t *fp;
19693 if (VAT_JSON_ARRAY != vam->json_tree.type)
19695 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19696 vat_json_init_array (&vam->json_tree);
19698 node = vat_json_array_add (&vam->json_tree);
19700 vat_json_init_object (node);
19701 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19702 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
19703 vat_json_object_add_uint (node, "label", ntohl (mp->label));
19704 vat_json_object_add_uint (node, "path_count", count);
19706 for (i = 0; i < count; i++)
19708 vl_api_mpls_fib_path_json_print (node, fp);
19714 api_mpls_fib_dump (vat_main_t * vam)
19716 vl_api_mpls_fib_dump_t *mp;
19717 vl_api_control_ping_t *mp_ping;
19720 M (MPLS_FIB_DUMP, mp);
19723 /* Use a control ping for synchronization */
19724 MPING (CONTROL_PING, mp_ping);
19731 #define vl_api_ip_fib_details_t_endian vl_noop_handler
19732 #define vl_api_ip_fib_details_t_print vl_noop_handler
19735 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
19737 vat_main_t *vam = &vat_main;
19738 int count = ntohl (mp->count);
19739 vl_api_fib_path_t *fp;
19743 "table-id %d, prefix %U/%d",
19744 ntohl (mp->table_id), format_ip4_address, mp->address,
19745 mp->address_length);
19747 for (i = 0; i < count; i++)
19749 if (fp->afi == IP46_TYPE_IP6)
19751 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19752 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19753 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19754 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19755 format_ip6_address, fp->next_hop);
19756 else if (fp->afi == IP46_TYPE_IP4)
19758 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19759 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19760 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19761 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19762 format_ip4_address, fp->next_hop);
19767 static void vl_api_ip_fib_details_t_handler_json
19768 (vl_api_ip_fib_details_t * mp)
19770 vat_main_t *vam = &vat_main;
19771 int count = ntohl (mp->count);
19772 vat_json_node_t *node = NULL;
19773 struct in_addr ip4;
19774 struct in6_addr ip6;
19775 vl_api_fib_path_t *fp;
19778 if (VAT_JSON_ARRAY != vam->json_tree.type)
19780 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19781 vat_json_init_array (&vam->json_tree);
19783 node = vat_json_array_add (&vam->json_tree);
19785 vat_json_init_object (node);
19786 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19787 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
19788 vat_json_object_add_ip4 (node, "prefix", ip4);
19789 vat_json_object_add_uint (node, "mask_length", mp->address_length);
19790 vat_json_object_add_uint (node, "path_count", count);
19792 for (i = 0; i < count; i++)
19794 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
19795 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
19796 vat_json_object_add_uint (node, "is_local", fp->is_local);
19797 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
19798 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
19799 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
19800 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
19801 if (fp->afi == IP46_TYPE_IP4)
19803 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
19804 vat_json_object_add_ip4 (node, "next_hop", ip4);
19806 else if (fp->afi == IP46_TYPE_IP6)
19808 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
19809 vat_json_object_add_ip6 (node, "next_hop", ip6);
19815 api_ip_fib_dump (vat_main_t * vam)
19817 vl_api_ip_fib_dump_t *mp;
19818 vl_api_control_ping_t *mp_ping;
19821 M (IP_FIB_DUMP, mp);
19824 /* Use a control ping for synchronization */
19825 MPING (CONTROL_PING, mp_ping);
19833 api_ip_mfib_dump (vat_main_t * vam)
19835 vl_api_ip_mfib_dump_t *mp;
19836 vl_api_control_ping_t *mp_ping;
19839 M (IP_MFIB_DUMP, mp);
19842 /* Use a control ping for synchronization */
19843 MPING (CONTROL_PING, mp_ping);
19850 static void vl_api_ip_neighbor_details_t_handler
19851 (vl_api_ip_neighbor_details_t * mp)
19853 vat_main_t *vam = &vat_main;
19855 print (vam->ofp, "%c %U %U",
19856 (mp->is_static) ? 'S' : 'D',
19857 format_ethernet_address, &mp->mac_address,
19858 (mp->is_ipv6) ? format_ip6_address : format_ip4_address,
19862 static void vl_api_ip_neighbor_details_t_handler_json
19863 (vl_api_ip_neighbor_details_t * mp)
19866 vat_main_t *vam = &vat_main;
19867 vat_json_node_t *node;
19868 struct in_addr ip4;
19869 struct in6_addr ip6;
19871 if (VAT_JSON_ARRAY != vam->json_tree.type)
19873 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19874 vat_json_init_array (&vam->json_tree);
19876 node = vat_json_array_add (&vam->json_tree);
19878 vat_json_init_object (node);
19879 vat_json_object_add_string_copy (node, "flag",
19880 (mp->is_static) ? (u8 *) "static" : (u8 *)
19883 vat_json_object_add_string_copy (node, "link_layer",
19884 format (0, "%U", format_ethernet_address,
19885 &mp->mac_address));
19889 clib_memcpy (&ip6, &mp->ip_address, sizeof (ip6));
19890 vat_json_object_add_ip6 (node, "ip_address", ip6);
19894 clib_memcpy (&ip4, &mp->ip_address, sizeof (ip4));
19895 vat_json_object_add_ip4 (node, "ip_address", ip4);
19900 api_ip_neighbor_dump (vat_main_t * vam)
19902 unformat_input_t *i = vam->input;
19903 vl_api_ip_neighbor_dump_t *mp;
19904 vl_api_control_ping_t *mp_ping;
19906 u32 sw_if_index = ~0;
19909 /* Parse args required to build the message */
19910 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
19912 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
19914 else if (unformat (i, "sw_if_index %d", &sw_if_index))
19916 else if (unformat (i, "ip6"))
19922 if (sw_if_index == ~0)
19924 errmsg ("missing interface name or sw_if_index");
19928 M (IP_NEIGHBOR_DUMP, mp);
19929 mp->is_ipv6 = (u8) is_ipv6;
19930 mp->sw_if_index = ntohl (sw_if_index);
19933 /* Use a control ping for synchronization */
19934 MPING (CONTROL_PING, mp_ping);
19941 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
19942 #define vl_api_ip6_fib_details_t_print vl_noop_handler
19945 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
19947 vat_main_t *vam = &vat_main;
19948 int count = ntohl (mp->count);
19949 vl_api_fib_path_t *fp;
19953 "table-id %d, prefix %U/%d",
19954 ntohl (mp->table_id), format_ip6_address, mp->address,
19955 mp->address_length);
19957 for (i = 0; i < count; i++)
19959 if (fp->afi == IP46_TYPE_IP6)
19961 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19962 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19963 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19964 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19965 format_ip6_address, fp->next_hop);
19966 else if (fp->afi == IP46_TYPE_IP4)
19968 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
19969 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
19970 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
19971 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
19972 format_ip4_address, fp->next_hop);
19977 static void vl_api_ip6_fib_details_t_handler_json
19978 (vl_api_ip6_fib_details_t * mp)
19980 vat_main_t *vam = &vat_main;
19981 int count = ntohl (mp->count);
19982 vat_json_node_t *node = NULL;
19983 struct in_addr ip4;
19984 struct in6_addr ip6;
19985 vl_api_fib_path_t *fp;
19988 if (VAT_JSON_ARRAY != vam->json_tree.type)
19990 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
19991 vat_json_init_array (&vam->json_tree);
19993 node = vat_json_array_add (&vam->json_tree);
19995 vat_json_init_object (node);
19996 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
19997 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
19998 vat_json_object_add_ip6 (node, "prefix", ip6);
19999 vat_json_object_add_uint (node, "mask_length", mp->address_length);
20000 vat_json_object_add_uint (node, "path_count", count);
20002 for (i = 0; i < count; i++)
20004 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
20005 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
20006 vat_json_object_add_uint (node, "is_local", fp->is_local);
20007 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
20008 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
20009 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
20010 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
20011 if (fp->afi == IP46_TYPE_IP4)
20013 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
20014 vat_json_object_add_ip4 (node, "next_hop", ip4);
20016 else if (fp->afi == IP46_TYPE_IP6)
20018 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
20019 vat_json_object_add_ip6 (node, "next_hop", ip6);
20025 api_ip6_fib_dump (vat_main_t * vam)
20027 vl_api_ip6_fib_dump_t *mp;
20028 vl_api_control_ping_t *mp_ping;
20031 M (IP6_FIB_DUMP, mp);
20034 /* Use a control ping for synchronization */
20035 MPING (CONTROL_PING, mp_ping);
20043 api_ip6_mfib_dump (vat_main_t * vam)
20045 vl_api_ip6_mfib_dump_t *mp;
20046 vl_api_control_ping_t *mp_ping;
20049 M (IP6_MFIB_DUMP, mp);
20052 /* Use a control ping for synchronization */
20053 MPING (CONTROL_PING, mp_ping);
20061 api_classify_table_ids (vat_main_t * vam)
20063 vl_api_classify_table_ids_t *mp;
20066 /* Construct the API message */
20067 M (CLASSIFY_TABLE_IDS, mp);
20076 api_classify_table_by_interface (vat_main_t * vam)
20078 unformat_input_t *input = vam->input;
20079 vl_api_classify_table_by_interface_t *mp;
20081 u32 sw_if_index = ~0;
20083 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20085 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20087 else if (unformat (input, "sw_if_index %d", &sw_if_index))
20092 if (sw_if_index == ~0)
20094 errmsg ("missing interface name or sw_if_index");
20098 /* Construct the API message */
20099 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
20101 mp->sw_if_index = ntohl (sw_if_index);
20109 api_classify_table_info (vat_main_t * vam)
20111 unformat_input_t *input = vam->input;
20112 vl_api_classify_table_info_t *mp;
20116 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20118 if (unformat (input, "table_id %d", &table_id))
20123 if (table_id == ~0)
20125 errmsg ("missing table id");
20129 /* Construct the API message */
20130 M (CLASSIFY_TABLE_INFO, mp);
20132 mp->table_id = ntohl (table_id);
20140 api_classify_session_dump (vat_main_t * vam)
20142 unformat_input_t *input = vam->input;
20143 vl_api_classify_session_dump_t *mp;
20144 vl_api_control_ping_t *mp_ping;
20148 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20150 if (unformat (input, "table_id %d", &table_id))
20155 if (table_id == ~0)
20157 errmsg ("missing table id");
20161 /* Construct the API message */
20162 M (CLASSIFY_SESSION_DUMP, mp);
20164 mp->table_id = ntohl (table_id);
20167 /* Use a control ping for synchronization */
20168 MPING (CONTROL_PING, mp_ping);
20176 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
20178 vat_main_t *vam = &vat_main;
20180 print (vam->ofp, "collector_address %U, collector_port %d, "
20181 "src_address %U, vrf_id %d, path_mtu %u, "
20182 "template_interval %u, udp_checksum %d",
20183 format_ip4_address, mp->collector_address,
20184 ntohs (mp->collector_port),
20185 format_ip4_address, mp->src_address,
20186 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
20187 ntohl (mp->template_interval), mp->udp_checksum);
20190 vam->result_ready = 1;
20194 vl_api_ipfix_exporter_details_t_handler_json
20195 (vl_api_ipfix_exporter_details_t * mp)
20197 vat_main_t *vam = &vat_main;
20198 vat_json_node_t node;
20199 struct in_addr collector_address;
20200 struct in_addr src_address;
20202 vat_json_init_object (&node);
20203 clib_memcpy (&collector_address, &mp->collector_address,
20204 sizeof (collector_address));
20205 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
20206 vat_json_object_add_uint (&node, "collector_port",
20207 ntohs (mp->collector_port));
20208 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
20209 vat_json_object_add_ip4 (&node, "src_address", src_address);
20210 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
20211 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
20212 vat_json_object_add_uint (&node, "template_interval",
20213 ntohl (mp->template_interval));
20214 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
20216 vat_json_print (vam->ofp, &node);
20217 vat_json_free (&node);
20219 vam->result_ready = 1;
20223 api_ipfix_exporter_dump (vat_main_t * vam)
20225 vl_api_ipfix_exporter_dump_t *mp;
20228 /* Construct the API message */
20229 M (IPFIX_EXPORTER_DUMP, mp);
20238 api_ipfix_classify_stream_dump (vat_main_t * vam)
20240 vl_api_ipfix_classify_stream_dump_t *mp;
20243 /* Construct the API message */
20244 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
20255 vl_api_ipfix_classify_stream_details_t_handler
20256 (vl_api_ipfix_classify_stream_details_t * mp)
20258 vat_main_t *vam = &vat_main;
20259 print (vam->ofp, "domain_id %d, src_port %d",
20260 ntohl (mp->domain_id), ntohs (mp->src_port));
20262 vam->result_ready = 1;
20266 vl_api_ipfix_classify_stream_details_t_handler_json
20267 (vl_api_ipfix_classify_stream_details_t * mp)
20269 vat_main_t *vam = &vat_main;
20270 vat_json_node_t node;
20272 vat_json_init_object (&node);
20273 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
20274 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
20276 vat_json_print (vam->ofp, &node);
20277 vat_json_free (&node);
20279 vam->result_ready = 1;
20283 api_ipfix_classify_table_dump (vat_main_t * vam)
20285 vl_api_ipfix_classify_table_dump_t *mp;
20286 vl_api_control_ping_t *mp_ping;
20289 if (!vam->json_output)
20291 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
20292 "transport_protocol");
20295 /* Construct the API message */
20296 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
20301 /* Use a control ping for synchronization */
20302 MPING (CONTROL_PING, mp_ping);
20310 vl_api_ipfix_classify_table_details_t_handler
20311 (vl_api_ipfix_classify_table_details_t * mp)
20313 vat_main_t *vam = &vat_main;
20314 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
20315 mp->transport_protocol);
20319 vl_api_ipfix_classify_table_details_t_handler_json
20320 (vl_api_ipfix_classify_table_details_t * mp)
20322 vat_json_node_t *node = NULL;
20323 vat_main_t *vam = &vat_main;
20325 if (VAT_JSON_ARRAY != vam->json_tree.type)
20327 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20328 vat_json_init_array (&vam->json_tree);
20331 node = vat_json_array_add (&vam->json_tree);
20332 vat_json_init_object (node);
20334 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
20335 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
20336 vat_json_object_add_uint (node, "transport_protocol",
20337 mp->transport_protocol);
20341 api_sw_interface_span_enable_disable (vat_main_t * vam)
20343 unformat_input_t *i = vam->input;
20344 vl_api_sw_interface_span_enable_disable_t *mp;
20345 u32 src_sw_if_index = ~0;
20346 u32 dst_sw_if_index = ~0;
20351 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20354 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
20356 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
20360 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
20362 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
20364 else if (unformat (i, "disable"))
20366 else if (unformat (i, "rx"))
20368 else if (unformat (i, "tx"))
20370 else if (unformat (i, "both"))
20372 else if (unformat (i, "l2"))
20378 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
20380 mp->sw_if_index_from = htonl (src_sw_if_index);
20381 mp->sw_if_index_to = htonl (dst_sw_if_index);
20391 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
20394 vat_main_t *vam = &vat_main;
20395 u8 *sw_if_from_name = 0;
20396 u8 *sw_if_to_name = 0;
20397 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
20398 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
20399 char *states[] = { "none", "rx", "tx", "both" };
20403 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
20405 if ((u32) p->value[0] == sw_if_index_from)
20407 sw_if_from_name = (u8 *)(p->key);
20411 if ((u32) p->value[0] == sw_if_index_to)
20413 sw_if_to_name = (u8 *)(p->key);
20414 if (sw_if_from_name)
20419 print (vam->ofp, "%20s => %20s (%s)",
20420 sw_if_from_name, sw_if_to_name, states[mp->state]);
20424 vl_api_sw_interface_span_details_t_handler_json
20425 (vl_api_sw_interface_span_details_t * mp)
20427 vat_main_t *vam = &vat_main;
20428 vat_json_node_t *node = NULL;
20429 u8 *sw_if_from_name = 0;
20430 u8 *sw_if_to_name = 0;
20431 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
20432 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
20436 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
20438 if ((u32) p->value[0] == sw_if_index_from)
20440 sw_if_from_name = (u8 *)(p->key);
20444 if ((u32) p->value[0] == sw_if_index_to)
20446 sw_if_to_name = (u8 *)(p->key);
20447 if (sw_if_from_name)
20453 if (VAT_JSON_ARRAY != vam->json_tree.type)
20455 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20456 vat_json_init_array (&vam->json_tree);
20458 node = vat_json_array_add (&vam->json_tree);
20460 vat_json_init_object (node);
20461 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
20462 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
20463 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
20464 if (0 != sw_if_to_name)
20466 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
20468 vat_json_object_add_uint (node, "state", mp->state);
20472 api_sw_interface_span_dump (vat_main_t * vam)
20474 unformat_input_t *input = vam->input;
20475 vl_api_sw_interface_span_dump_t *mp;
20476 vl_api_control_ping_t *mp_ping;
20480 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20482 if (unformat (input, "l2"))
20488 M (SW_INTERFACE_SPAN_DUMP, mp);
20492 /* Use a control ping for synchronization */
20493 MPING (CONTROL_PING, mp_ping);
20501 api_pg_create_interface (vat_main_t * vam)
20503 unformat_input_t *input = vam->input;
20504 vl_api_pg_create_interface_t *mp;
20508 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20510 if (unformat (input, "if_id %d", &if_id))
20517 errmsg ("missing pg interface index");
20521 /* Construct the API message */
20522 M (PG_CREATE_INTERFACE, mp);
20524 mp->interface_id = ntohl (if_id);
20532 api_pg_capture (vat_main_t * vam)
20534 unformat_input_t *input = vam->input;
20535 vl_api_pg_capture_t *mp;
20540 u8 pcap_file_set = 0;
20543 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20545 if (unformat (input, "if_id %d", &if_id))
20547 else if (unformat (input, "pcap %s", &pcap_file))
20549 else if (unformat (input, "count %d", &count))
20551 else if (unformat (input, "disable"))
20558 errmsg ("missing pg interface index");
20561 if (pcap_file_set > 0)
20563 if (vec_len (pcap_file) > 255)
20565 errmsg ("pcap file name is too long");
20570 u32 name_len = vec_len (pcap_file);
20571 /* Construct the API message */
20572 M (PG_CAPTURE, mp);
20574 mp->interface_id = ntohl (if_id);
20575 mp->is_enabled = enable;
20576 mp->count = ntohl (count);
20577 mp->pcap_name_length = ntohl (name_len);
20578 if (pcap_file_set != 0)
20580 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
20582 vec_free (pcap_file);
20590 api_pg_enable_disable (vat_main_t * vam)
20592 unformat_input_t *input = vam->input;
20593 vl_api_pg_enable_disable_t *mp;
20596 u8 stream_name_set = 0;
20597 u8 *stream_name = 0;
20599 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20601 if (unformat (input, "stream %s", &stream_name))
20602 stream_name_set = 1;
20603 else if (unformat (input, "disable"))
20609 if (stream_name_set > 0)
20611 if (vec_len (stream_name) > 255)
20613 errmsg ("stream name too long");
20618 u32 name_len = vec_len (stream_name);
20619 /* Construct the API message */
20620 M (PG_ENABLE_DISABLE, mp);
20622 mp->is_enabled = enable;
20623 if (stream_name_set != 0)
20625 mp->stream_name_length = ntohl (name_len);
20626 clib_memcpy (mp->stream_name, stream_name, name_len);
20628 vec_free (stream_name);
20636 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
20638 unformat_input_t *input = vam->input;
20639 vl_api_ip_source_and_port_range_check_add_del_t *mp;
20641 u16 *low_ports = 0;
20642 u16 *high_ports = 0;
20645 ip4_address_t ip4_addr;
20646 ip6_address_t ip6_addr;
20655 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20657 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
20663 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
20668 else if (unformat (input, "vrf %d", &vrf_id))
20670 else if (unformat (input, "del"))
20672 else if (unformat (input, "port %d", &tmp))
20674 if (tmp == 0 || tmp > 65535)
20676 errmsg ("port %d out of range", tmp);
20680 this_hi = this_low + 1;
20681 vec_add1 (low_ports, this_low);
20682 vec_add1 (high_ports, this_hi);
20684 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
20686 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
20688 errmsg ("incorrect range parameters");
20692 /* Note: in debug CLI +1 is added to high before
20693 passing to real fn that does "the work"
20694 (ip_source_and_port_range_check_add_del).
20695 This fn is a wrapper around the binary API fn a
20696 control plane will call, which expects this increment
20697 to have occurred. Hence letting the binary API control
20698 plane fn do the increment for consistency between VAT
20699 and other control planes.
20702 vec_add1 (low_ports, this_low);
20703 vec_add1 (high_ports, this_hi);
20709 if (prefix_set == 0)
20711 errmsg ("<address>/<mask> not specified");
20717 errmsg ("VRF ID required, not specified");
20724 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
20728 if (vec_len (low_ports) == 0)
20730 errmsg ("At least one port or port range required");
20734 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
20736 mp->is_add = is_add;
20741 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
20746 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
20749 mp->mask_length = length;
20750 mp->number_of_ranges = vec_len (low_ports);
20752 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
20753 vec_free (low_ports);
20755 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
20756 vec_free (high_ports);
20758 mp->vrf_id = ntohl (vrf_id);
20766 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
20768 unformat_input_t *input = vam->input;
20769 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
20770 u32 sw_if_index = ~0;
20772 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
20773 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
20777 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
20779 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
20781 else if (unformat (input, "sw_if_index %d", &sw_if_index))
20783 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
20785 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
20787 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
20789 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
20791 else if (unformat (input, "del"))
20797 if (sw_if_index == ~0)
20799 errmsg ("Interface required but not specified");
20805 errmsg ("VRF ID required but not specified");
20809 if (tcp_out_vrf_id == 0
20810 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
20813 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
20817 /* Construct the API message */
20818 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
20820 mp->sw_if_index = ntohl (sw_if_index);
20821 mp->is_add = is_add;
20822 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
20823 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
20824 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
20825 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
20830 /* Wait for a reply... */
20836 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
20838 unformat_input_t *i = vam->input;
20839 vl_api_ipsec_gre_add_del_tunnel_t *mp;
20840 u32 local_sa_id = 0;
20841 u32 remote_sa_id = 0;
20842 ip4_address_t src_address;
20843 ip4_address_t dst_address;
20847 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20849 if (unformat (i, "local_sa %d", &local_sa_id))
20851 else if (unformat (i, "remote_sa %d", &remote_sa_id))
20853 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
20855 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
20857 else if (unformat (i, "del"))
20861 clib_warning ("parse error '%U'", format_unformat_error, i);
20866 M (IPSEC_GRE_ADD_DEL_TUNNEL, mp);
20868 mp->local_sa_id = ntohl (local_sa_id);
20869 mp->remote_sa_id = ntohl (remote_sa_id);
20870 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
20871 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
20872 mp->is_add = is_add;
20880 api_punt (vat_main_t * vam)
20882 unformat_input_t *i = vam->input;
20890 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20892 if (unformat (i, "ip %d", &ipv))
20894 else if (unformat (i, "protocol %d", &protocol))
20896 else if (unformat (i, "port %d", &port))
20898 else if (unformat (i, "del"))
20902 clib_warning ("parse error '%U'", format_unformat_error, i);
20909 mp->is_add = (u8) is_add;
20910 mp->ipv = (u8) ipv;
20911 mp->l4_protocol = (u8) protocol;
20912 mp->l4_port = htons ((u16) port);
20919 static void vl_api_ipsec_gre_tunnel_details_t_handler
20920 (vl_api_ipsec_gre_tunnel_details_t * mp)
20922 vat_main_t *vam = &vat_main;
20924 print (vam->ofp, "%11d%15U%15U%14d%14d",
20925 ntohl (mp->sw_if_index),
20926 format_ip4_address, &mp->src_address,
20927 format_ip4_address, &mp->dst_address,
20928 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
20931 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
20932 (vl_api_ipsec_gre_tunnel_details_t * mp)
20934 vat_main_t *vam = &vat_main;
20935 vat_json_node_t *node = NULL;
20936 struct in_addr ip4;
20938 if (VAT_JSON_ARRAY != vam->json_tree.type)
20940 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
20941 vat_json_init_array (&vam->json_tree);
20943 node = vat_json_array_add (&vam->json_tree);
20945 vat_json_init_object (node);
20946 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
20947 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
20948 vat_json_object_add_ip4 (node, "src_address", ip4);
20949 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
20950 vat_json_object_add_ip4 (node, "dst_address", ip4);
20951 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
20952 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
20956 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
20958 unformat_input_t *i = vam->input;
20959 vl_api_ipsec_gre_tunnel_dump_t *mp;
20960 vl_api_control_ping_t *mp_ping;
20962 u8 sw_if_index_set = 0;
20965 /* Parse args required to build the message */
20966 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
20968 if (unformat (i, "sw_if_index %d", &sw_if_index))
20969 sw_if_index_set = 1;
20974 if (sw_if_index_set == 0)
20979 if (!vam->json_output)
20981 print (vam->ofp, "%11s%15s%15s%14s%14s",
20982 "sw_if_index", "src_address", "dst_address",
20983 "local_sa_id", "remote_sa_id");
20986 /* Get list of gre-tunnel interfaces */
20987 M (IPSEC_GRE_TUNNEL_DUMP, mp);
20989 mp->sw_if_index = htonl (sw_if_index);
20993 /* Use a control ping for synchronization */
20994 MPING (CONTROL_PING, mp_ping);
21002 api_delete_subif (vat_main_t * vam)
21004 unformat_input_t *i = vam->input;
21005 vl_api_delete_subif_t *mp;
21006 u32 sw_if_index = ~0;
21009 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21011 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21013 if (unformat (i, "sw_if_index %d", &sw_if_index))
21019 if (sw_if_index == ~0)
21021 errmsg ("missing sw_if_index");
21025 /* Construct the API message */
21026 M (DELETE_SUBIF, mp);
21027 mp->sw_if_index = ntohl (sw_if_index);
21034 #define foreach_pbb_vtr_op \
21035 _("disable", L2_VTR_DISABLED) \
21036 _("pop", L2_VTR_POP_2) \
21037 _("push", L2_VTR_PUSH_2)
21040 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
21042 unformat_input_t *i = vam->input;
21043 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
21044 u32 sw_if_index = ~0, vtr_op = ~0;
21045 u16 outer_tag = ~0;
21046 u8 dmac[6], smac[6];
21047 u8 dmac_set = 0, smac_set = 0;
21053 /* Shut up coverity */
21054 memset (dmac, 0, sizeof (dmac));
21055 memset (smac, 0, sizeof (smac));
21057 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21059 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21061 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21063 else if (unformat (i, "vtr_op %d", &vtr_op))
21065 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
21068 else if (unformat (i, "translate_pbb_stag"))
21070 if (unformat (i, "%d", &tmp))
21072 vtr_op = L2_VTR_TRANSLATE_2_1;
21078 ("translate_pbb_stag operation requires outer tag definition");
21082 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
21084 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
21086 else if (unformat (i, "sid %d", &sid))
21088 else if (unformat (i, "vlanid %d", &tmp))
21092 clib_warning ("parse error '%U'", format_unformat_error, i);
21097 if ((sw_if_index == ~0) || (vtr_op == ~0))
21099 errmsg ("missing sw_if_index or vtr operation");
21102 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
21103 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
21106 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
21110 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
21111 mp->sw_if_index = ntohl (sw_if_index);
21112 mp->vtr_op = ntohl (vtr_op);
21113 mp->outer_tag = ntohs (outer_tag);
21114 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
21115 clib_memcpy (mp->b_smac, smac, sizeof (smac));
21116 mp->b_vlanid = ntohs (vlanid);
21117 mp->i_sid = ntohl (sid);
21125 api_flow_classify_set_interface (vat_main_t * vam)
21127 unformat_input_t *i = vam->input;
21128 vl_api_flow_classify_set_interface_t *mp;
21130 int sw_if_index_set;
21131 u32 ip4_table_index = ~0;
21132 u32 ip6_table_index = ~0;
21136 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21138 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21139 sw_if_index_set = 1;
21140 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21141 sw_if_index_set = 1;
21142 else if (unformat (i, "del"))
21144 else if (unformat (i, "ip4-table %d", &ip4_table_index))
21146 else if (unformat (i, "ip6-table %d", &ip6_table_index))
21150 clib_warning ("parse error '%U'", format_unformat_error, i);
21155 if (sw_if_index_set == 0)
21157 errmsg ("missing interface name or sw_if_index");
21161 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
21163 mp->sw_if_index = ntohl (sw_if_index);
21164 mp->ip4_table_index = ntohl (ip4_table_index);
21165 mp->ip6_table_index = ntohl (ip6_table_index);
21166 mp->is_add = is_add;
21174 api_flow_classify_dump (vat_main_t * vam)
21176 unformat_input_t *i = vam->input;
21177 vl_api_flow_classify_dump_t *mp;
21178 vl_api_control_ping_t *mp_ping;
21179 u8 type = FLOW_CLASSIFY_N_TABLES;
21182 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
21186 errmsg ("classify table type must be specified");
21190 if (!vam->json_output)
21192 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
21195 M (FLOW_CLASSIFY_DUMP, mp);
21200 /* Use a control ping for synchronization */
21201 MPING (CONTROL_PING, mp_ping);
21204 /* Wait for a reply... */
21210 api_feature_enable_disable (vat_main_t * vam)
21212 unformat_input_t *i = vam->input;
21213 vl_api_feature_enable_disable_t *mp;
21215 u8 *feature_name = 0;
21216 u32 sw_if_index = ~0;
21220 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21222 if (unformat (i, "arc_name %s", &arc_name))
21224 else if (unformat (i, "feature_name %s", &feature_name))
21227 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21229 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21231 else if (unformat (i, "disable"))
21239 errmsg ("missing arc name");
21242 if (vec_len (arc_name) > 63)
21244 errmsg ("arc name too long");
21247 if (feature_name == 0)
21249 errmsg ("missing feature name");
21252 if (vec_len (feature_name) > 63)
21254 errmsg ("feature name too long");
21257 if (sw_if_index == ~0)
21259 errmsg ("missing interface name or sw_if_index");
21263 /* Construct the API message */
21264 M (FEATURE_ENABLE_DISABLE, mp);
21265 mp->sw_if_index = ntohl (sw_if_index);
21266 mp->enable = enable;
21267 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
21268 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
21269 vec_free (arc_name);
21270 vec_free (feature_name);
21278 api_sw_interface_tag_add_del (vat_main_t * vam)
21280 unformat_input_t *i = vam->input;
21281 vl_api_sw_interface_tag_add_del_t *mp;
21282 u32 sw_if_index = ~0;
21287 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21289 if (unformat (i, "tag %s", &tag))
21291 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21293 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21295 else if (unformat (i, "del"))
21301 if (sw_if_index == ~0)
21303 errmsg ("missing interface name or sw_if_index");
21307 if (enable && (tag == 0))
21309 errmsg ("no tag specified");
21313 /* Construct the API message */
21314 M (SW_INTERFACE_TAG_ADD_DEL, mp);
21315 mp->sw_if_index = ntohl (sw_if_index);
21316 mp->is_add = enable;
21318 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
21326 static void vl_api_l2_xconnect_details_t_handler
21327 (vl_api_l2_xconnect_details_t * mp)
21329 vat_main_t *vam = &vat_main;
21331 print (vam->ofp, "%15d%15d",
21332 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
21335 static void vl_api_l2_xconnect_details_t_handler_json
21336 (vl_api_l2_xconnect_details_t * mp)
21338 vat_main_t *vam = &vat_main;
21339 vat_json_node_t *node = NULL;
21341 if (VAT_JSON_ARRAY != vam->json_tree.type)
21343 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
21344 vat_json_init_array (&vam->json_tree);
21346 node = vat_json_array_add (&vam->json_tree);
21348 vat_json_init_object (node);
21349 vat_json_object_add_uint (node, "rx_sw_if_index",
21350 ntohl (mp->rx_sw_if_index));
21351 vat_json_object_add_uint (node, "tx_sw_if_index",
21352 ntohl (mp->tx_sw_if_index));
21356 api_l2_xconnect_dump (vat_main_t * vam)
21358 vl_api_l2_xconnect_dump_t *mp;
21359 vl_api_control_ping_t *mp_ping;
21362 if (!vam->json_output)
21364 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
21367 M (L2_XCONNECT_DUMP, mp);
21371 /* Use a control ping for synchronization */
21372 MPING (CONTROL_PING, mp_ping);
21380 api_sw_interface_set_mtu (vat_main_t * vam)
21382 unformat_input_t *i = vam->input;
21383 vl_api_sw_interface_set_mtu_t *mp;
21384 u32 sw_if_index = ~0;
21388 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21390 if (unformat (i, "mtu %d", &mtu))
21392 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21394 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21400 if (sw_if_index == ~0)
21402 errmsg ("missing interface name or sw_if_index");
21408 errmsg ("no mtu specified");
21412 /* Construct the API message */
21413 M (SW_INTERFACE_SET_MTU, mp);
21414 mp->sw_if_index = ntohl (sw_if_index);
21415 mp->mtu = ntohs ((u16) mtu);
21423 api_p2p_ethernet_add (vat_main_t * vam)
21425 unformat_input_t *i = vam->input;
21426 vl_api_p2p_ethernet_add_t *mp;
21427 u32 parent_if_index = ~0;
21433 memset (remote_mac, 0, sizeof (remote_mac));
21434 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21436 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
21438 else if (unformat (i, "sw_if_index %d", &parent_if_index))
21442 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
21444 else if (unformat (i, "sub_id %d", &sub_id))
21448 clib_warning ("parse error '%U'", format_unformat_error, i);
21453 if (parent_if_index == ~0)
21455 errmsg ("missing interface name or sw_if_index");
21460 errmsg ("missing remote mac address");
21465 errmsg ("missing sub-interface id");
21469 M (P2P_ETHERNET_ADD, mp);
21470 mp->parent_if_index = ntohl (parent_if_index);
21471 mp->subif_id = ntohl (sub_id);
21472 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
21480 api_p2p_ethernet_del (vat_main_t * vam)
21482 unformat_input_t *i = vam->input;
21483 vl_api_p2p_ethernet_del_t *mp;
21484 u32 parent_if_index = ~0;
21489 memset (remote_mac, 0, sizeof (remote_mac));
21490 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21492 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &parent_if_index))
21494 else if (unformat (i, "sw_if_index %d", &parent_if_index))
21498 (i, "remote_mac %U", unformat_ethernet_address, remote_mac))
21502 clib_warning ("parse error '%U'", format_unformat_error, i);
21507 if (parent_if_index == ~0)
21509 errmsg ("missing interface name or sw_if_index");
21514 errmsg ("missing remote mac address");
21518 M (P2P_ETHERNET_DEL, mp);
21519 mp->parent_if_index = ntohl (parent_if_index);
21520 clib_memcpy (mp->remote_mac, remote_mac, sizeof (remote_mac));
21528 api_lldp_config (vat_main_t * vam)
21530 unformat_input_t *i = vam->input;
21531 vl_api_lldp_config_t *mp;
21533 int tx_interval = 0;
21534 u8 *sys_name = NULL;
21537 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21539 if (unformat (i, "system-name %s", &sys_name))
21541 else if (unformat (i, "tx-hold %d", &tx_hold))
21543 else if (unformat (i, "tx-interval %d", &tx_interval))
21547 clib_warning ("parse error '%U'", format_unformat_error, i);
21552 vec_add1 (sys_name, 0);
21554 M (LLDP_CONFIG, mp);
21555 mp->tx_hold = htonl (tx_hold);
21556 mp->tx_interval = htonl (tx_interval);
21557 clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
21558 vec_free (sys_name);
21566 api_sw_interface_set_lldp (vat_main_t * vam)
21568 unformat_input_t *i = vam->input;
21569 vl_api_sw_interface_set_lldp_t *mp;
21570 u32 sw_if_index = ~0;
21572 u8 *port_desc = NULL, *mgmt_oid = NULL;
21573 ip4_address_t ip4_addr;
21574 ip6_address_t ip6_addr;
21577 memset (&ip4_addr, 0, sizeof (ip4_addr));
21578 memset (&ip6_addr, 0, sizeof (ip6_addr));
21580 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21582 if (unformat (i, "disable"))
21585 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
21587 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21589 else if (unformat (i, "port-desc %s", &port_desc))
21591 else if (unformat (i, "mgmt-ip4 %U", unformat_ip4_address, &ip4_addr))
21593 else if (unformat (i, "mgmt-ip6 %U", unformat_ip6_address, &ip6_addr))
21595 else if (unformat (i, "mgmt-oid %s", &mgmt_oid))
21601 if (sw_if_index == ~0)
21603 errmsg ("missing interface name or sw_if_index");
21607 /* Construct the API message */
21608 vec_add1 (port_desc, 0);
21609 vec_add1 (mgmt_oid, 0);
21610 M (SW_INTERFACE_SET_LLDP, mp);
21611 mp->sw_if_index = ntohl (sw_if_index);
21612 mp->enable = enable;
21613 clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
21614 clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
21615 clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
21616 clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
21617 vec_free (port_desc);
21618 vec_free (mgmt_oid);
21626 api_tcp_configure_src_addresses (vat_main_t * vam)
21628 vl_api_tcp_configure_src_addresses_t *mp;
21629 unformat_input_t *i = vam->input;
21630 ip4_address_t v4first, v4last;
21631 ip6_address_t v6first, v6last;
21636 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21638 if (unformat (i, "%U - %U",
21639 unformat_ip4_address, &v4first,
21640 unformat_ip4_address, &v4last))
21644 errmsg ("one range per message (range already set)");
21649 else if (unformat (i, "%U - %U",
21650 unformat_ip6_address, &v6first,
21651 unformat_ip6_address, &v6last))
21655 errmsg ("one range per message (range already set)");
21660 else if (unformat (i, "vrf %d", &vrf_id))
21666 if (range_set == 0)
21668 errmsg ("address range not set");
21672 M (TCP_CONFIGURE_SRC_ADDRESSES, mp);
21673 mp->vrf_id = ntohl (vrf_id);
21675 if (range_set == 2)
21678 clib_memcpy (mp->first_address, &v6first, sizeof (v6first));
21679 clib_memcpy (mp->last_address, &v6last, sizeof (v6last));
21684 clib_memcpy (mp->first_address, &v4first, sizeof (v4first));
21685 clib_memcpy (mp->last_address, &v4last, sizeof (v4last));
21692 static void vl_api_app_namespace_add_del_reply_t_handler
21693 (vl_api_app_namespace_add_del_reply_t * mp)
21695 vat_main_t *vam = &vat_main;
21696 i32 retval = ntohl (mp->retval);
21697 if (vam->async_mode)
21699 vam->async_errors += (retval < 0);
21703 vam->retval = retval;
21705 errmsg ("app ns index %d\n", ntohl (mp->appns_index));
21706 vam->result_ready = 1;
21710 static void vl_api_app_namespace_add_del_reply_t_handler_json
21711 (vl_api_app_namespace_add_del_reply_t * mp)
21713 vat_main_t *vam = &vat_main;
21714 vat_json_node_t node;
21716 vat_json_init_object (&node);
21717 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
21718 vat_json_object_add_uint (&node, "appns_index", ntohl (mp->appns_index));
21720 vat_json_print (vam->ofp, &node);
21721 vat_json_free (&node);
21723 vam->retval = ntohl (mp->retval);
21724 vam->result_ready = 1;
21728 api_app_namespace_add_del (vat_main_t * vam)
21730 vl_api_app_namespace_add_del_t *mp;
21731 unformat_input_t *i = vam->input;
21732 u8 *ns_id = 0, secret_set = 0, sw_if_index_set = 0;
21733 u32 sw_if_index, ip4_fib_id, ip6_fib_id;
21737 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21739 if (unformat (i, "id %_%v%_", &ns_id))
21741 else if (unformat (i, "secret %lu", &secret))
21743 else if (unformat (i, "sw_if_index %d", &sw_if_index))
21744 sw_if_index_set = 1;
21745 else if (unformat (i, "ip4_fib_id %d", &ip4_fib_id))
21747 else if (unformat (i, "ip6_fib_id %d", &ip6_fib_id))
21752 if (!ns_id || !secret_set || !sw_if_index_set)
21754 errmsg ("namespace id, secret and sw_if_index must be set");
21757 if (vec_len (ns_id) > 64)
21759 errmsg ("namespace id too long");
21762 M (APP_NAMESPACE_ADD_DEL, mp);
21764 clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
21765 mp->namespace_id_len = vec_len (ns_id);
21766 mp->secret = clib_host_to_net_u64 (secret);
21767 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
21768 mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
21769 mp->ip6_fib_id = clib_host_to_net_u32 (ip6_fib_id);
21777 api_memfd_segment_create (vat_main_t * vam)
21779 #if VPP_API_TEST_BUILTIN == 0
21780 unformat_input_t *i = vam->input;
21781 vl_api_memfd_segment_create_t *mp;
21782 u64 size = 64 << 20;
21785 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21787 if (unformat (i, "size %U", unformat_memory_size, &size))
21793 M (MEMFD_SEGMENT_CREATE, mp);
21794 mp->requested_size = size;
21800 errmsg ("memfd_segment_create (builtin) not supported");
21806 api_dns_enable_disable (vat_main_t * vam)
21808 unformat_input_t *line_input = vam->input;
21809 vl_api_dns_enable_disable_t *mp;
21810 u8 enable_disable = 1;
21813 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21815 if (unformat (line_input, "disable"))
21816 enable_disable = 0;
21817 if (unformat (line_input, "enable"))
21818 enable_disable = 1;
21823 /* Construct the API message */
21824 M (DNS_ENABLE_DISABLE, mp);
21825 mp->enable = enable_disable;
21829 /* Wait for the reply */
21835 api_dns_resolve_name (vat_main_t * vam)
21837 unformat_input_t *line_input = vam->input;
21838 vl_api_dns_resolve_name_t *mp;
21842 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21844 if (unformat (line_input, "%s", &name))
21850 if (vec_len (name) > 127)
21852 errmsg ("name too long");
21856 /* Construct the API message */
21857 M (DNS_RESOLVE_NAME, mp);
21858 memcpy (mp->name, name, vec_len (name));
21863 /* Wait for the reply */
21869 api_dns_resolve_ip (vat_main_t * vam)
21871 unformat_input_t *line_input = vam->input;
21872 vl_api_dns_resolve_ip_t *mp;
21874 ip4_address_t addr4;
21875 ip6_address_t addr6;
21878 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
21880 if (unformat (line_input, "%U", unformat_ip6_address, &addr6))
21882 else if (unformat (line_input, "%U", unformat_ip4_address, &addr4))
21890 errmsg ("missing address");
21894 /* Construct the API message */
21895 M (DNS_RESOLVE_IP, mp);
21896 mp->is_ip6 = is_ip6;
21898 memcpy (mp->address, &addr6, sizeof (addr6));
21900 memcpy (mp->address, &addr4, sizeof (addr4));
21904 /* Wait for the reply */
21910 api_dns_name_server_add_del (vat_main_t * vam)
21912 unformat_input_t *i = vam->input;
21913 vl_api_dns_name_server_add_del_t *mp;
21915 ip6_address_t ip6_server;
21916 ip4_address_t ip4_server;
21921 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
21923 if (unformat (i, "%U", unformat_ip6_address, &ip6_server))
21925 else if (unformat (i, "%U", unformat_ip4_address, &ip4_server))
21927 else if (unformat (i, "del"))
21931 clib_warning ("parse error '%U'", format_unformat_error, i);
21936 if (ip4_set && ip6_set)
21938 errmsg ("Only one server address allowed per message");
21941 if ((ip4_set + ip6_set) == 0)
21943 errmsg ("Server address required");
21947 /* Construct the API message */
21948 M (DNS_NAME_SERVER_ADD_DEL, mp);
21952 memcpy (mp->server_address, &ip6_server, sizeof (ip6_address_t));
21957 memcpy (mp->server_address, &ip4_server, sizeof (ip4_address_t));
21961 mp->is_add = is_add;
21966 /* Wait for a reply, return good/bad news */
21972 vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
21974 vat_main_t *vam = &vat_main;
21979 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
21980 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
21981 mp->scope, format_ip4_address, &mp->lcl_ip, mp->lcl_plen,
21982 clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
21983 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
21984 clib_net_to_host_u32 (mp->action_index), mp->tag);
21989 "appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
21990 clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
21991 mp->scope, format_ip6_address, &mp->lcl_ip, mp->lcl_plen,
21992 clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
21993 &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
21994 clib_net_to_host_u32 (mp->action_index), mp->tag);
21999 vl_api_session_rules_details_t_handler_json (vl_api_session_rules_details_t *
22002 vat_main_t *vam = &vat_main;
22003 vat_json_node_t *node = NULL;
22004 struct in6_addr ip6;
22005 struct in_addr ip4;
22007 if (VAT_JSON_ARRAY != vam->json_tree.type)
22009 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
22010 vat_json_init_array (&vam->json_tree);
22012 node = vat_json_array_add (&vam->json_tree);
22013 vat_json_init_object (node);
22015 vat_json_object_add_uint (node, "is_ip4", mp->is_ip4 ? 1 : 0);
22016 vat_json_object_add_uint (node, "appns_index",
22017 clib_net_to_host_u32 (mp->appns_index));
22018 vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
22019 vat_json_object_add_uint (node, "scope", mp->scope);
22020 vat_json_object_add_uint (node, "action_index",
22021 clib_net_to_host_u32 (mp->action_index));
22022 vat_json_object_add_uint (node, "lcl_port",
22023 clib_net_to_host_u16 (mp->lcl_port));
22024 vat_json_object_add_uint (node, "rmt_port",
22025 clib_net_to_host_u16 (mp->rmt_port));
22026 vat_json_object_add_uint (node, "lcl_plen", mp->lcl_plen);
22027 vat_json_object_add_uint (node, "rmt_plen", mp->rmt_plen);
22028 vat_json_object_add_string_copy (node, "tag", mp->tag);
22031 clib_memcpy (&ip4, mp->lcl_ip, sizeof (ip4));
22032 vat_json_object_add_ip4 (node, "lcl_ip", ip4);
22033 clib_memcpy (&ip4, mp->rmt_ip, sizeof (ip4));
22034 vat_json_object_add_ip4 (node, "rmt_ip", ip4);
22038 clib_memcpy (&ip6, mp->lcl_ip, sizeof (ip6));
22039 vat_json_object_add_ip6 (node, "lcl_ip", ip6);
22040 clib_memcpy (&ip6, mp->rmt_ip, sizeof (ip6));
22041 vat_json_object_add_ip6 (node, "rmt_ip", ip6);
22046 api_session_rule_add_del (vat_main_t * vam)
22048 vl_api_session_rule_add_del_t *mp;
22049 unformat_input_t *i = vam->input;
22050 u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
22051 u32 appns_index = 0, scope = 0;
22052 ip4_address_t lcl_ip4, rmt_ip4;
22053 ip6_address_t lcl_ip6, rmt_ip6;
22054 u8 is_ip4 = 1, conn_set = 0;
22055 u8 is_add = 1, *tag = 0;
22058 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22060 if (unformat (i, "del"))
22062 else if (unformat (i, "add"))
22064 else if (unformat (i, "proto tcp"))
22066 else if (unformat (i, "proto udp"))
22068 else if (unformat (i, "appns %d", &appns_index))
22070 else if (unformat (i, "scope %d", &scope))
22072 else if (unformat (i, "tag %_%v%_", &tag))
22076 (i, "%U/%d %d %U/%d %d", unformat_ip4_address, &lcl_ip4,
22077 &lcl_plen, &lcl_port, unformat_ip4_address, &rmt_ip4, &rmt_plen,
22085 (i, "%U/%d %d %U/%d %d", unformat_ip6_address, &lcl_ip6,
22086 &lcl_plen, &lcl_port, unformat_ip6_address, &rmt_ip6, &rmt_plen,
22092 else if (unformat (i, "action %d", &action))
22097 if (proto == ~0 || !conn_set || action == ~0)
22099 errmsg ("transport proto, connection and action must be set");
22105 errmsg ("scope should be 0-3");
22109 M (SESSION_RULE_ADD_DEL, mp);
22111 mp->is_ip4 = is_ip4;
22112 mp->transport_proto = proto;
22113 mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
22114 mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
22115 mp->lcl_plen = lcl_plen;
22116 mp->rmt_plen = rmt_plen;
22117 mp->action_index = clib_host_to_net_u32 (action);
22118 mp->appns_index = clib_host_to_net_u32 (appns_index);
22120 mp->is_add = is_add;
22123 clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
22124 clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
22128 clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
22129 clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
22133 clib_memcpy (mp->tag, tag, vec_len (tag));
22143 api_session_rules_dump (vat_main_t * vam)
22145 vl_api_session_rules_dump_t *mp;
22146 vl_api_control_ping_t *mp_ping;
22149 if (!vam->json_output)
22151 print (vam->ofp, "%=20s", "Session Rules");
22154 M (SESSION_RULES_DUMP, mp);
22158 /* Use a control ping for synchronization */
22159 MPING (CONTROL_PING, mp_ping);
22162 /* Wait for a reply... */
22168 api_ip_container_proxy_add_del (vat_main_t * vam)
22170 vl_api_ip_container_proxy_add_del_t *mp;
22171 unformat_input_t *i = vam->input;
22172 u32 plen = ~0, sw_if_index = ~0;
22179 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
22181 if (unformat (i, "del"))
22183 else if (unformat (i, "add"))
22185 if (unformat (i, "%U", unformat_ip4_address, &ip4))
22190 else if (unformat (i, "%U", unformat_ip6_address, &ip6))
22195 else if (unformat (i, "sw_if_index %u", &sw_if_index))
22200 if (sw_if_index == ~0 || plen == ~0)
22202 errmsg ("address and sw_if_index must be set");
22206 M (IP_CONTAINER_PROXY_ADD_DEL, mp);
22208 mp->is_ip4 = is_ip4;
22209 mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
22211 mp->is_add = is_add;
22213 clib_memcpy (mp->ip, &ip4, sizeof (ip4));
22215 clib_memcpy (mp->ip, &ip6, sizeof (ip6));
22223 q_or_quit (vat_main_t * vam)
22225 #if VPP_API_TEST_BUILTIN == 0
22226 longjmp (vam->jump_buf, 1);
22228 return 0; /* not so much */
22232 q (vat_main_t * vam)
22234 return q_or_quit (vam);
22238 quit (vat_main_t * vam)
22240 return q_or_quit (vam);
22244 comment (vat_main_t * vam)
22250 cmd_cmp (void *a1, void *a2)
22255 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
22259 help (vat_main_t * vam)
22264 unformat_input_t *i = vam->input;
22267 if (unformat (i, "%s", &name))
22271 vec_add1 (name, 0);
22273 hs = hash_get_mem (vam->help_by_name, name);
22275 print (vam->ofp, "usage: %s %s", name, hs[0]);
22277 print (vam->ofp, "No such msg / command '%s'", name);
22282 print (vam->ofp, "Help is available for the following:");
22285 hash_foreach_pair (p, vam->function_by_name,
22287 vec_add1 (cmds, (u8 *)(p->key));
22291 vec_sort_with_function (cmds, cmd_cmp);
22293 for (j = 0; j < vec_len (cmds); j++)
22294 print (vam->ofp, "%s", cmds[j]);
22301 set (vat_main_t * vam)
22303 u8 *name = 0, *value = 0;
22304 unformat_input_t *i = vam->input;
22306 if (unformat (i, "%s", &name))
22308 /* The input buffer is a vector, not a string. */
22309 value = vec_dup (i->buffer);
22310 vec_delete (value, i->index, 0);
22311 /* Almost certainly has a trailing newline */
22312 if (value[vec_len (value) - 1] == '\n')
22313 value[vec_len (value) - 1] = 0;
22314 /* Make sure it's a proper string, one way or the other */
22315 vec_add1 (value, 0);
22316 (void) clib_macro_set_value (&vam->macro_main,
22317 (char *) name, (char *) value);
22320 errmsg ("usage: set <name> <value>");
22328 unset (vat_main_t * vam)
22332 if (unformat (vam->input, "%s", &name))
22333 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
22334 errmsg ("unset: %s wasn't set", name);
22347 macro_sort_cmp (void *a1, void *a2)
22349 macro_sort_t *s1 = a1;
22350 macro_sort_t *s2 = a2;
22352 return strcmp ((char *) (s1->name), (char *) (s2->name));
22356 dump_macro_table (vat_main_t * vam)
22358 macro_sort_t *sort_me = 0, *sm;
22363 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
22365 vec_add2 (sort_me, sm, 1);
22366 sm->name = (u8 *)(p->key);
22367 sm->value = (u8 *) (p->value[0]);
22371 vec_sort_with_function (sort_me, macro_sort_cmp);
22373 if (vec_len (sort_me))
22374 print (vam->ofp, "%-15s%s", "Name", "Value");
22376 print (vam->ofp, "The macro table is empty...");
22378 for (i = 0; i < vec_len (sort_me); i++)
22379 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
22384 dump_node_table (vat_main_t * vam)
22387 vlib_node_t *node, *next_node;
22389 if (vec_len (vam->graph_nodes) == 0)
22391 print (vam->ofp, "Node table empty, issue get_node_graph...");
22395 for (i = 0; i < vec_len (vam->graph_nodes); i++)
22397 node = vam->graph_nodes[i];
22398 print (vam->ofp, "[%d] %s", i, node->name);
22399 for (j = 0; j < vec_len (node->next_nodes); j++)
22401 if (node->next_nodes[j] != ~0)
22403 next_node = vam->graph_nodes[node->next_nodes[j]];
22404 print (vam->ofp, " [%d] %s", j, next_node->name);
22412 value_sort_cmp (void *a1, void *a2)
22414 name_sort_t *n1 = a1;
22415 name_sort_t *n2 = a2;
22417 if (n1->value < n2->value)
22419 if (n1->value > n2->value)
22426 dump_msg_api_table (vat_main_t * vam)
22428 api_main_t *am = &api_main;
22429 name_sort_t *nses = 0, *ns;
22434 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
22436 vec_add2 (nses, ns, 1);
22437 ns->name = (u8 *)(hp->key);
22438 ns->value = (u32) hp->value[0];
22442 vec_sort_with_function (nses, value_sort_cmp);
22444 for (i = 0; i < vec_len (nses); i++)
22445 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
22451 get_msg_id (vat_main_t * vam)
22456 if (unformat (vam->input, "%s", &name_and_crc))
22458 message_index = vl_api_get_msg_index (name_and_crc);
22459 if (message_index == ~0)
22461 print (vam->ofp, " '%s' not found", name_and_crc);
22464 print (vam->ofp, " '%s' has message index %d",
22465 name_and_crc, message_index);
22468 errmsg ("name_and_crc required...");
22473 search_node_table (vat_main_t * vam)
22475 unformat_input_t *line_input = vam->input;
22478 vlib_node_t *node, *next_node;
22481 if (vam->graph_node_index_by_name == 0)
22483 print (vam->ofp, "Node table empty, issue get_node_graph...");
22487 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
22489 if (unformat (line_input, "%s", &node_to_find))
22491 vec_add1 (node_to_find, 0);
22492 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
22495 print (vam->ofp, "%s not found...", node_to_find);
22498 node = vam->graph_nodes[p[0]];
22499 print (vam->ofp, "[%d] %s", p[0], node->name);
22500 for (j = 0; j < vec_len (node->next_nodes); j++)
22502 if (node->next_nodes[j] != ~0)
22504 next_node = vam->graph_nodes[node->next_nodes[j]];
22505 print (vam->ofp, " [%d] %s", j, next_node->name);
22512 clib_warning ("parse error '%U'", format_unformat_error,
22518 vec_free (node_to_find);
22527 script (vat_main_t * vam)
22529 #if (VPP_API_TEST_BUILTIN==0)
22531 char *save_current_file;
22532 unformat_input_t save_input;
22533 jmp_buf save_jump_buf;
22534 u32 save_line_number;
22536 FILE *new_fp, *save_ifp;
22538 if (unformat (vam->input, "%s", &s))
22540 new_fp = fopen ((char *) s, "r");
22543 errmsg ("Couldn't open script file %s", s);
22550 errmsg ("Missing script name");
22554 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
22555 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
22556 save_ifp = vam->ifp;
22557 save_line_number = vam->input_line_number;
22558 save_current_file = (char *) vam->current_file;
22560 vam->input_line_number = 0;
22562 vam->current_file = s;
22565 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
22566 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
22567 vam->ifp = save_ifp;
22568 vam->input_line_number = save_line_number;
22569 vam->current_file = (u8 *) save_current_file;
22574 clib_warning ("use the exec command...");
22580 echo (vat_main_t * vam)
22582 print (vam->ofp, "%v", vam->input->buffer);
22586 /* List of API message constructors, CLI names map to api_xxx */
22587 #define foreach_vpe_api_msg \
22588 _(create_loopback,"[mac <mac-addr>] [instance <instance>]") \
22589 _(sw_interface_dump,"") \
22590 _(sw_interface_set_flags, \
22591 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
22592 _(sw_interface_add_del_address, \
22593 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
22594 _(sw_interface_set_rx_mode, \
22595 "<intfc> | sw_if_index <id> [queue <id>] <polling | interrupt | adaptive>") \
22596 _(sw_interface_set_table, \
22597 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
22598 _(sw_interface_set_mpls_enable, \
22599 "<intfc> | sw_if_index [disable | dis]") \
22600 _(sw_interface_set_vpath, \
22601 "<intfc> | sw_if_index <id> enable | disable") \
22602 _(sw_interface_set_vxlan_bypass, \
22603 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
22604 _(sw_interface_set_geneve_bypass, \
22605 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
22606 _(sw_interface_set_l2_xconnect, \
22607 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
22608 "enable | disable") \
22609 _(sw_interface_set_l2_bridge, \
22610 "{<intfc> | sw_if_index <id>} bd_id <bridge-domain-id>\n" \
22611 "[shg <split-horizon-group>] [bvi]\n" \
22612 "enable | disable") \
22613 _(bridge_domain_set_mac_age, "bd_id <bridge-domain-id> mac-age 0-255") \
22614 _(bridge_domain_add_del, \
22615 "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") \
22616 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
22618 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
22619 _(l2fib_flush_bd, "bd_id <bridge-domain-id>") \
22620 _(l2fib_flush_int, "<intfc> | sw_if_index <id>") \
22622 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
22624 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
22626 "tapname <name> mac <mac-addr> | random-mac [tag <string>]") \
22628 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
22630 "<vpp-if-name> | sw_if_index <id>") \
22631 _(sw_interface_tap_dump, "") \
22633 "name <name> [hw-addr <mac-addr>] [host-ns <name>] [rx-ring-size <num> [tx-ring-size <num>]") \
22635 "<vpp-if-name> | sw_if_index <id>") \
22636 _(sw_interface_tap_v2_dump, "") \
22637 _(ip_table_add_del, \
22638 "table-id <n> [ipv6]\n") \
22639 _(ip_add_del_route, \
22640 "<addr>/<mask> via <addr> [table-id <n>]\n" \
22641 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
22642 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
22643 "[multipath] [count <n>]") \
22644 _(ip_mroute_add_del, \
22645 "<src> <grp>/<mask> [table-id <n>]\n" \
22646 "[<intfc> | sw_if_index <id>] [local] [del]") \
22647 _(mpls_table_add_del, \
22648 "table-id <n>\n") \
22649 _(mpls_route_add_del, \
22650 "<label> <eos> via <addr> [table-id <n>]\n" \
22651 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
22652 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
22653 "[multipath] [count <n>]") \
22654 _(mpls_ip_bind_unbind, \
22655 "<label> <addr/len>") \
22656 _(mpls_tunnel_add_del, \
22657 " via <addr> [table-id <n>]\n" \
22658 "sw_if_index <id>] [l2] [del]") \
22659 _(bier_table_add_del, \
22660 "<label> <sub-domain> <set> <bsl> [del]") \
22661 _(bier_route_add_del, \
22662 "<bit-position> <sub-domain> <set> <bsl> via <addr> [table-id <n>]\n" \
22663 "[<intfc> | sw_if_index <id>]" \
22664 "[weight <n>] [del] [multipath]") \
22665 _(proxy_arp_add_del, \
22666 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
22667 _(proxy_arp_intfc_enable_disable, \
22668 "<intfc> | sw_if_index <id> enable | disable") \
22669 _(sw_interface_set_unnumbered, \
22670 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
22671 _(ip_neighbor_add_del, \
22672 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
22673 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
22674 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
22675 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
22676 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
22677 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
22678 "[outer_vlan_id_any][inner_vlan_id_any]") \
22679 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
22680 _(reset_fib, "vrf <n> [ipv6]") \
22681 _(dhcp_proxy_config, \
22682 "svr <v46-address> src <v46-address>\n" \
22683 "rx_vrf_id <nn> server_vrf_id <nn> [del]") \
22684 _(dhcp_proxy_set_vss, \
22685 "tbl_id <n> [fib_id <n> oui <n> | vpn_ascii_id <text>] [ipv6] [del]") \
22686 _(dhcp_proxy_dump, "ip6") \
22687 _(dhcp_client_config, \
22688 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
22689 _(set_ip_flow_hash, \
22690 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
22691 _(sw_interface_ip6_enable_disable, \
22692 "<intfc> | sw_if_index <id> enable | disable") \
22693 _(sw_interface_ip6_set_link_local_address, \
22694 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
22695 _(ip6nd_proxy_add_del, \
22696 "<intfc> | sw_if_index <id> <ip6-address>") \
22697 _(ip6nd_proxy_dump, "") \
22698 _(sw_interface_ip6nd_ra_prefix, \
22699 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
22700 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
22701 "[nolink] [isno]") \
22702 _(sw_interface_ip6nd_ra_config, \
22703 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
22704 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
22705 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
22706 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
22707 _(l2_patch_add_del, \
22708 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
22709 "enable | disable") \
22710 _(sr_localsid_add_del, \
22711 "(del) address <addr> next_hop <addr> behavior <beh>\n" \
22712 "fib-table <num> (end.psp) sw_if_index <num>") \
22713 _(classify_add_del_table, \
22714 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
22715 " [del] [del-chain] mask <mask-value>\n" \
22716 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
22717 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
22718 _(classify_add_del_session, \
22719 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
22720 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
22721 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
22722 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
22723 _(classify_set_interface_ip_table, \
22724 "<intfc> | sw_if_index <nn> table <nn>") \
22725 _(classify_set_interface_l2_tables, \
22726 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22727 " [other-table <nn>]") \
22728 _(get_node_index, "node <node-name") \
22729 _(add_node_next, "node <node-name> next <next-node-name>") \
22730 _(l2tpv3_create_tunnel, \
22731 "client_address <ip6-addr> our_address <ip6-addr>\n" \
22732 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
22733 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
22734 _(l2tpv3_set_tunnel_cookies, \
22735 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
22736 "[new_remote_cookie <nn>]\n") \
22737 _(l2tpv3_interface_enable_disable, \
22738 "<intfc> | sw_if_index <nn> enable | disable") \
22739 _(l2tpv3_set_lookup_key, \
22740 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
22741 _(sw_if_l2tpv3_tunnel_dump, "") \
22742 _(vxlan_add_del_tunnel, \
22743 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
22744 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22745 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
22746 _(geneve_add_del_tunnel, \
22747 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
22748 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22749 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
22750 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22751 _(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22752 _(gre_add_del_tunnel, \
22753 "src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [teb] [del]\n") \
22754 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22755 _(l2_fib_clear_table, "") \
22756 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
22757 _(l2_interface_vlan_tag_rewrite, \
22758 "<intfc> | sw_if_index <nn> \n" \
22759 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
22760 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
22761 _(create_vhost_user_if, \
22762 "socket <filename> [server] [renumber <dev_instance>] " \
22763 "[mac <mac_address>]") \
22764 _(modify_vhost_user_if, \
22765 "<intfc> | sw_if_index <nn> socket <filename>\n" \
22766 "[server] [renumber <dev_instance>]") \
22767 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
22768 _(sw_interface_vhost_user_dump, "") \
22769 _(show_version, "") \
22770 _(vxlan_gpe_add_del_tunnel, \
22771 "local <addr> remote <addr> | group <mcast-ip-addr>\n" \
22772 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
22773 "vni <nn> [encap-vrf-id <nn>] [decap-vrf-id <nn>]\n" \
22774 "[next-ip4][next-ip6][next-ethernet] [next-nsh] [del]\n") \
22775 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
22776 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
22777 _(interface_name_renumber, \
22778 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
22779 _(input_acl_set_interface, \
22780 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22781 " [l2-table <nn>] [del]") \
22782 _(want_ip4_arp_events, "address <ip4-address> [del]") \
22783 _(want_ip6_nd_events, "address <ip6-address> [del]") \
22784 _(want_l2_macs_events, "[disable] [learn-limit <n>] [scan-delay <n>] [max-entries <n>]") \
22785 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
22786 _(ip_dump, "ipv4 | ipv6") \
22787 _(ipsec_spd_add_del, "spd_id <n> [del]") \
22788 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
22790 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
22791 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
22792 " integ_alg <alg> integ_key <hex>") \
22793 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
22794 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
22795 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
22796 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
22797 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
22798 _(ipsec_tunnel_if_add_del, "local_spi <n> remote_spi <n>\n" \
22799 " crypto_alg <alg> local_crypto_key <hex> remote_crypto_key <hex>\n" \
22800 " integ_alg <alg> local_integ_key <hex> remote_integ_key <hex>\n" \
22801 " local_ip <addr> remote_ip <addr> [esn] [anti_replay] [del]\n") \
22802 _(ipsec_sa_dump, "[sa_id <n>]") \
22803 _(ipsec_tunnel_if_set_key, "<intfc> <local|remote> <crypto|integ>\n" \
22804 " <alg> <hex>\n") \
22805 _(ipsec_tunnel_if_set_sa, "<intfc> sa_id <n> <inbound|outbound>\n") \
22806 _(ikev2_profile_add_del, "name <profile_name> [del]") \
22807 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
22808 "(auth_data 0x<data> | auth_data <data>)") \
22809 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
22810 "(id_data 0x<data> | id_data <data>) (local|remote)") \
22811 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
22812 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
22813 "(local|remote)") \
22814 _(ikev2_set_local_key, "file <absolute_file_path>") \
22815 _(ikev2_set_responder, "<profile_name> interface <interface> address <addr>") \
22816 _(ikev2_set_ike_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
22817 _(ikev2_set_esp_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
22818 _(ikev2_set_sa_lifetime, "<profile_name> <seconds> <jitter> <handover> <max bytes>") \
22819 _(ikev2_initiate_sa_init, "<profile_name>") \
22820 _(ikev2_initiate_del_ike_sa, "<ispi>") \
22821 _(ikev2_initiate_del_child_sa, "<ispi>") \
22822 _(ikev2_initiate_rekey_child_sa, "<ispi>") \
22823 _(delete_loopback,"sw_if_index <nn>") \
22824 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
22825 _(map_add_domain, \
22826 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
22827 "ip6-src <ip6addr> " \
22828 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
22829 _(map_del_domain, "index <n>") \
22830 _(map_add_del_rule, \
22831 "index <n> psid <n> dst <ip6addr> [del]") \
22832 _(map_domain_dump, "") \
22833 _(map_rule_dump, "index <map-domain>") \
22834 _(want_interface_events, "enable|disable") \
22835 _(want_stats,"enable|disable") \
22836 _(get_first_msg_id, "client <name>") \
22837 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
22838 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
22839 "fib-id <nn> [ip4][ip6][default]") \
22840 _(get_node_graph, " ") \
22841 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
22842 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
22843 _(ioam_disable, "") \
22844 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
22845 " sw_if_index <sw_if_index> p <priority> " \
22846 "w <weight>] [del]") \
22847 _(one_add_del_locator, "locator-set <locator_name> " \
22848 "iface <intf> | sw_if_index <sw_if_index> " \
22849 "p <priority> w <weight> [del]") \
22850 _(one_add_del_local_eid,"vni <vni> eid " \
22851 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22852 "locator-set <locator_name> [del]" \
22853 "[key-id sha1|sha256 secret-key <secret-key>]")\
22854 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
22855 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
22856 _(one_enable_disable, "enable|disable") \
22857 _(one_map_register_enable_disable, "enable|disable") \
22858 _(one_map_register_fallback_threshold, "<value>") \
22859 _(one_rloc_probe_enable_disable, "enable|disable") \
22860 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22862 "rloc <locator> p <prio> " \
22863 "w <weight> [rloc <loc> ... ] " \
22864 "action <action> [del-all]") \
22865 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22867 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22868 _(one_use_petr, "ip-address> | disable") \
22869 _(one_map_request_mode, "src-dst|dst-only") \
22870 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22871 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22872 _(one_locator_set_dump, "[local | remote]") \
22873 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
22874 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22875 "[local] | [remote]") \
22876 _(one_add_del_ndp_entry, "[del] mac <mac> bd <bd> ip6 <ip6>") \
22877 _(one_ndp_bd_get, "") \
22878 _(one_ndp_entries_get, "bd <bridge-domain>") \
22879 _(one_add_del_l2_arp_entry, "[del] mac <mac> bd <bd> ip4 <ip4>") \
22880 _(one_l2_arp_bd_get, "") \
22881 _(one_l2_arp_entries_get, "bd <bridge-domain>") \
22882 _(one_stats_enable_disable, "enable|disalbe") \
22883 _(show_one_stats_enable_disable, "") \
22884 _(one_eid_table_vni_dump, "") \
22885 _(one_eid_table_map_dump, "l2|l3") \
22886 _(one_map_resolver_dump, "") \
22887 _(one_map_server_dump, "") \
22888 _(one_adjacencies_get, "vni <vni>") \
22889 _(one_nsh_set_locator_set, "[del] ls <locator-set-name>") \
22890 _(show_one_rloc_probe_state, "") \
22891 _(show_one_map_register_state, "") \
22892 _(show_one_status, "") \
22893 _(one_stats_dump, "") \
22894 _(one_stats_flush, "") \
22895 _(one_get_map_request_itr_rlocs, "") \
22896 _(one_map_register_set_ttl, "<ttl>") \
22897 _(one_set_transport_protocol, "udp|api") \
22898 _(one_get_transport_protocol, "") \
22899 _(one_enable_disable_xtr_mode, "enable|disable") \
22900 _(one_show_xtr_mode, "") \
22901 _(one_enable_disable_pitr_mode, "enable|disable") \
22902 _(one_show_pitr_mode, "") \
22903 _(one_enable_disable_petr_mode, "enable|disable") \
22904 _(one_show_petr_mode, "") \
22905 _(show_one_nsh_mapping, "") \
22906 _(show_one_pitr, "") \
22907 _(show_one_use_petr, "") \
22908 _(show_one_map_request_mode, "") \
22909 _(show_one_map_register_ttl, "") \
22910 _(show_one_map_register_fallback_threshold, "") \
22911 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
22912 " sw_if_index <sw_if_index> p <priority> " \
22913 "w <weight>] [del]") \
22914 _(lisp_add_del_locator, "locator-set <locator_name> " \
22915 "iface <intf> | sw_if_index <sw_if_index> " \
22916 "p <priority> w <weight> [del]") \
22917 _(lisp_add_del_local_eid,"vni <vni> eid " \
22918 "<ipv4|ipv6>/<prefix> | <L2 address> " \
22919 "locator-set <locator_name> [del]" \
22920 "[key-id sha1|sha256 secret-key <secret-key>]") \
22921 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
22922 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
22923 _(lisp_enable_disable, "enable|disable") \
22924 _(lisp_map_register_enable_disable, "enable|disable") \
22925 _(lisp_rloc_probe_enable_disable, "enable|disable") \
22926 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
22928 "rloc <locator> p <prio> " \
22929 "w <weight> [rloc <loc> ... ] " \
22930 "action <action> [del-all]") \
22931 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
22933 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
22934 _(lisp_use_petr, "<ip-address> | disable") \
22935 _(lisp_map_request_mode, "src-dst|dst-only") \
22936 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
22937 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
22938 _(lisp_locator_set_dump, "[local | remote]") \
22939 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
22940 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
22941 "[local] | [remote]") \
22942 _(lisp_eid_table_vni_dump, "") \
22943 _(lisp_eid_table_map_dump, "l2|l3") \
22944 _(lisp_map_resolver_dump, "") \
22945 _(lisp_map_server_dump, "") \
22946 _(lisp_adjacencies_get, "vni <vni>") \
22947 _(gpe_fwd_entry_vnis_get, "") \
22948 _(gpe_native_fwd_rpaths_get, "ip4 | ip6") \
22949 _(gpe_add_del_native_fwd_rpath, "[del] via <nh-ip-addr> [iface] " \
22950 "[table <table-id>]") \
22951 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
22952 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
22953 _(gpe_set_encap_mode, "lisp|vxlan") \
22954 _(gpe_get_encap_mode, "") \
22955 _(lisp_gpe_add_del_iface, "up|down") \
22956 _(lisp_gpe_enable_disable, "enable|disable") \
22957 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
22958 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
22959 _(show_lisp_rloc_probe_state, "") \
22960 _(show_lisp_map_register_state, "") \
22961 _(show_lisp_status, "") \
22962 _(lisp_get_map_request_itr_rlocs, "") \
22963 _(show_lisp_pitr, "") \
22964 _(show_lisp_use_petr, "") \
22965 _(show_lisp_map_request_mode, "") \
22966 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
22967 _(af_packet_delete, "name <host interface name>") \
22968 _(policer_add_del, "name <policer name> <params> [del]") \
22969 _(policer_dump, "[name <policer name>]") \
22970 _(policer_classify_set_interface, \
22971 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
22972 " [l2-table <nn>] [del]") \
22973 _(policer_classify_dump, "type [ip4|ip6|l2]") \
22974 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
22975 "[master|slave]") \
22976 _(netmap_delete, "name <interface name>") \
22977 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
22978 _(mpls_fib_dump, "") \
22979 _(classify_table_ids, "") \
22980 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
22981 _(classify_table_info, "table_id <nn>") \
22982 _(classify_session_dump, "table_id <nn>") \
22983 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
22984 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
22985 "[template_interval <nn>] [udp_checksum]") \
22986 _(ipfix_exporter_dump, "") \
22987 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
22988 _(ipfix_classify_stream_dump, "") \
22989 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
22990 _(ipfix_classify_table_dump, "") \
22991 _(sw_interface_span_enable_disable, "[l2] [src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
22992 _(sw_interface_span_dump, "[l2]") \
22993 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
22994 _(pg_create_interface, "if_id <nn>") \
22995 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
22996 _(pg_enable_disable, "[stream <id>] disable") \
22997 _(ip_source_and_port_range_check_add_del, \
22998 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
22999 _(ip_source_and_port_range_check_interface_add_del, \
23000 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
23001 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
23002 _(ipsec_gre_add_del_tunnel, \
23003 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
23004 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
23005 _(delete_subif,"<intfc> | sw_if_index <nn>") \
23006 _(l2_interface_pbb_tag_rewrite, \
23007 "<intfc> | sw_if_index <nn> \n" \
23008 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
23009 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
23010 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
23011 _(flow_classify_set_interface, \
23012 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
23013 _(flow_classify_dump, "type [ip4|ip6]") \
23014 _(ip_fib_dump, "") \
23015 _(ip_mfib_dump, "") \
23016 _(ip6_fib_dump, "") \
23017 _(ip6_mfib_dump, "") \
23018 _(feature_enable_disable, "arc_name <arc_name> " \
23019 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
23020 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
23022 _(l2_xconnect_dump, "") \
23023 _(sw_interface_set_mtu, "<intfc> | sw_if_index <nn> mtu <nn>") \
23024 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
23025 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]") \
23026 _(p2p_ethernet_add, "<intfc> | sw_if_index <nn> remote_mac <mac-address> sub_id <id>") \
23027 _(p2p_ethernet_del, "<intfc> | sw_if_index <nn> remote_mac <mac-address>") \
23028 _(lldp_config, "system-name <name> tx-hold <nn> tx-interval <nn>") \
23029 _(sw_interface_set_lldp, "<intfc> | sw_if_index <nn> [port-desc <description>]\n" \
23030 " [mgmt-ip4 <ip4>] [mgmt-ip6 <ip6>] [mgmt-oid <object id>] [disable]") \
23031 _(tcp_configure_src_addresses, "<ip4|6>first-<ip4|6>last [vrf <id>]") \
23032 _(memfd_segment_create,"size <nnn>") \
23033 _(app_namespace_add_del, "[add] id <ns-id> secret <nn> sw_if_index <nn>")\
23034 _(dns_enable_disable, "[enable][disable]") \
23035 _(dns_name_server_add_del, "<ip-address> [del]") \
23036 _(dns_resolve_name, "<hostname>") \
23037 _(dns_resolve_ip, "<ip4|ip6>") \
23038 _(dns_name_server_add_del, "<ip-address> [del]") \
23039 _(dns_resolve_name, "<hostname>") \
23040 _(session_rule_add_del, "[add|del] proto <tcp/udp> <lcl-ip>/<plen> " \
23041 "<lcl-port> <rmt-ip>/<plen> <rmt-port> action <nn>") \
23042 _(session_rules_dump, "") \
23043 _(ip_container_proxy_add_del, "[add|del] <address> <sw_if_index>") \
23045 /* List of command functions, CLI names map directly to functions */
23046 #define foreach_cli_function \
23047 _(comment, "usage: comment <ignore-rest-of-line>") \
23048 _(dump_interface_table, "usage: dump_interface_table") \
23049 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
23050 _(dump_ipv4_table, "usage: dump_ipv4_table") \
23051 _(dump_ipv6_table, "usage: dump_ipv6_table") \
23052 _(dump_stats_table, "usage: dump_stats_table") \
23053 _(dump_macro_table, "usage: dump_macro_table ") \
23054 _(dump_node_table, "usage: dump_node_table") \
23055 _(dump_msg_api_table, "usage: dump_msg_api_table") \
23056 _(get_msg_id, "usage: get_msg_id name_and_crc") \
23057 _(echo, "usage: echo <message>") \
23058 _(exec, "usage: exec <vpe-debug-CLI-command>") \
23059 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
23060 _(help, "usage: help") \
23061 _(q, "usage: quit") \
23062 _(quit, "usage: quit") \
23063 _(search_node_table, "usage: search_node_table <name>...") \
23064 _(set, "usage: set <variable-name> <value>") \
23065 _(script, "usage: script <file-name>") \
23066 _(unset, "usage: unset <variable-name>")
23068 static void vl_api_##n##_t_handler_uni \
23069 (vl_api_##n##_t * mp) \
23071 vat_main_t * vam = &vat_main; \
23072 if (vam->json_output) { \
23073 vl_api_##n##_t_handler_json(mp); \
23075 vl_api_##n##_t_handler(mp); \
23078 foreach_vpe_api_reply_msg;
23079 #if VPP_API_TEST_BUILTIN == 0
23080 foreach_standalone_reply_msg;
23085 vat_api_hookup (vat_main_t * vam)
23088 vl_msg_api_set_handlers(VL_API_##N, #n, \
23089 vl_api_##n##_t_handler_uni, \
23091 vl_api_##n##_t_endian, \
23092 vl_api_##n##_t_print, \
23093 sizeof(vl_api_##n##_t), 1);
23094 foreach_vpe_api_reply_msg;
23095 #if VPP_API_TEST_BUILTIN == 0
23096 foreach_standalone_reply_msg;
23100 #if (VPP_API_TEST_BUILTIN==0)
23101 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
23103 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
23105 vam->function_by_name = hash_create_string (0, sizeof (uword));
23107 vam->help_by_name = hash_create_string (0, sizeof (uword));
23110 /* API messages we can send */
23111 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
23112 foreach_vpe_api_msg;
23116 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
23117 foreach_vpe_api_msg;
23120 /* CLI functions */
23121 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
23122 foreach_cli_function;
23126 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
23127 foreach_cli_function;
23131 #if VPP_API_TEST_BUILTIN
23132 static clib_error_t *
23133 vat_api_hookup_shim (vlib_main_t * vm)
23135 vat_api_hookup (&vat_main);
23139 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
23143 * fd.io coding-style-patch-verification: ON
23146 * eval: (c-set-style "gnu")