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 <vlibapi/api.h>
22 #include <vlibmemory/api.h>
23 #include <vlibsocket/api.h>
24 #include <vnet/ip/ip.h>
25 #include <vnet/sr/sr_packet.h>
26 #include <vnet/l2/l2_input.h>
27 #include <vnet/l2tp/l2tp.h>
28 #include <vnet/vxlan/vxlan.h>
29 #include <vnet/gre/gre.h>
30 #include <vnet/vxlan-gpe/vxlan_gpe.h>
31 #include <vnet/lisp-gpe/lisp_gpe.h>
33 #include <vpp/api/vpe_msg_enum.h>
34 #include <vnet/l2/l2_classify.h>
35 #include <vnet/l2/l2_vtr.h>
36 #include <vnet/classify/input_acl.h>
37 #include <vnet/classify/policer_classify.h>
38 #include <vnet/classify/flow_classify.h>
39 #include <vnet/mpls/mpls.h>
40 #include <vnet/ipsec/ipsec.h>
41 #include <vnet/ipsec/ikev2.h>
43 #include <vnet/map/map.h>
44 #include <vnet/cop/cop.h>
45 #include <vnet/ip/ip6_hop_by_hop.h>
46 #include <vnet/ip/ip_source_and_port_range_check.h>
47 #include <vnet/policer/xlate.h>
48 #include <vnet/span/span.h>
49 #include <vnet/policer/policer.h>
50 #include <vnet/policer/police.h>
51 #include <vnet/mfib/mfib_types.h>
53 #include "vat/json_format.h"
58 #define vl_typedefs /* define message structures */
59 #include <vpp/api/vpe_all_api_h.h>
62 /* declare message handlers for each api */
64 #define vl_endianfun /* define message structures */
65 #include <vpp/api/vpe_all_api_h.h>
68 /* instantiate all the print functions we know about */
69 #define vl_print(handle, ...)
71 #include <vpp/api/vpe_all_api_h.h>
74 #define __plugin_msg_base 0
75 #include <vlibapi/vat_helper_macros.h>
78 vat_time_now (vat_main_t * vam)
80 #if VPP_API_TEST_BUILTIN
81 return vlib_time_now (vam->vlib_main);
83 return clib_time_now (&vam->clib_time);
88 errmsg (char *fmt, ...)
90 vat_main_t *vam = &vat_main;
95 s = va_format (0, fmt, &va);
100 #if VPP_API_TEST_BUILTIN
101 vlib_cli_output (vam->vlib_main, (char *) s);
104 if (vam->ifp != stdin)
105 fformat (vam->ofp, "%s(%d): \n", vam->current_file,
106 vam->input_line_number);
107 fformat (vam->ofp, (char *) s);
115 #if VPP_API_TEST_BUILTIN == 0
117 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
119 vat_main_t *vam = va_arg (*args, vat_main_t *);
120 u32 *result = va_arg (*args, u32 *);
124 if (!unformat (input, "%s", &if_name))
127 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
134 /* Parse an IP4 address %d.%d.%d.%d. */
136 unformat_ip4_address (unformat_input_t * input, va_list * args)
138 u8 *result = va_arg (*args, u8 *);
141 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
144 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
156 unformat_ethernet_address (unformat_input_t * input, va_list * args)
158 u8 *result = va_arg (*args, u8 *);
161 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
162 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
166 for (i = 0; i < 6; i++)
167 if (a[i] >= (1 << 8))
170 for (i = 0; i < 6; i++)
176 /* Returns ethernet type as an int in host byte order. */
178 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
181 u16 *result = va_arg (*args, u16 *);
185 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
187 if (type >= (1 << 16))
195 /* Parse an IP6 address. */
197 unformat_ip6_address (unformat_input_t * input, va_list * args)
199 ip6_address_t *result = va_arg (*args, ip6_address_t *);
201 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
202 uword c, n_colon, double_colon_index;
204 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
205 double_colon_index = ARRAY_LEN (hex_quads);
206 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
209 if (c >= '0' && c <= '9')
211 else if (c >= 'a' && c <= 'f')
212 hex_digit = c + 10 - 'a';
213 else if (c >= 'A' && c <= 'F')
214 hex_digit = c + 10 - 'A';
215 else if (c == ':' && n_colon < 2)
219 unformat_put_input (input);
223 /* Too many hex quads. */
224 if (n_hex_quads >= ARRAY_LEN (hex_quads))
229 hex_quad = (hex_quad << 4) | hex_digit;
231 /* Hex quad must fit in 16 bits. */
232 if (n_hex_digits >= 4)
239 /* Save position of :: */
242 /* More than one :: ? */
243 if (double_colon_index < ARRAY_LEN (hex_quads))
245 double_colon_index = n_hex_quads;
248 if (n_colon > 0 && n_hex_digits > 0)
250 hex_quads[n_hex_quads++] = hex_quad;
256 if (n_hex_digits > 0)
257 hex_quads[n_hex_quads++] = hex_quad;
262 /* Expand :: to appropriate number of zero hex quads. */
263 if (double_colon_index < ARRAY_LEN (hex_quads))
265 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
267 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
268 hex_quads[n_zero + i] = hex_quads[i];
270 for (i = 0; i < n_zero; i++)
271 hex_quads[double_colon_index + i] = 0;
273 n_hex_quads = ARRAY_LEN (hex_quads);
276 /* Too few hex quads given. */
277 if (n_hex_quads < ARRAY_LEN (hex_quads))
280 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
281 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
288 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
290 u32 *r = va_arg (*args, u32 *);
293 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
294 foreach_ipsec_policy_action
302 unformat_ipsec_crypto_alg (unformat_input_t * input, va_list * args)
304 u32 *r = va_arg (*args, u32 *);
307 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_CRYPTO_ALG_##f;
308 foreach_ipsec_crypto_alg
316 format_ipsec_crypto_alg (u8 * s, va_list * args)
318 u32 i = va_arg (*args, u32);
323 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
324 foreach_ipsec_crypto_alg
327 return format (s, "unknown");
329 return format (s, "%s", t);
333 unformat_ipsec_integ_alg (unformat_input_t * input, va_list * args)
335 u32 *r = va_arg (*args, u32 *);
338 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_INTEG_ALG_##f;
339 foreach_ipsec_integ_alg
347 format_ipsec_integ_alg (u8 * s, va_list * args)
349 u32 i = va_arg (*args, u32);
354 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
355 foreach_ipsec_integ_alg
358 return format (s, "unknown");
360 return format (s, "%s", t);
364 unformat_ikev2_auth_method (unformat_input_t * input, va_list * args)
366 u32 *r = va_arg (*args, u32 *);
369 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_AUTH_METHOD_##f;
370 foreach_ikev2_auth_method
378 unformat_ikev2_id_type (unformat_input_t * input, va_list * args)
380 u32 *r = va_arg (*args, u32 *);
383 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_ID_TYPE_##f;
384 foreach_ikev2_id_type
390 #else /* VPP_API_TEST_BUILTIN == 1 */
392 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
394 vat_main_t *vam __attribute__ ((unused)) = va_arg (*args, vat_main_t *);
395 vnet_main_t *vnm = vnet_get_main ();
396 u32 *result = va_arg (*args, u32 *);
399 if (!unformat (input, "%U", unformat_vnet_sw_interface, vnm, &sw_if_index))
402 *result = sw_if_index;
405 #endif /* VPP_API_TEST_BUILTIN */
408 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
410 u8 *r = va_arg (*args, u8 *);
412 if (unformat (input, "kbps"))
413 *r = SSE2_QOS_RATE_KBPS;
414 else if (unformat (input, "pps"))
415 *r = SSE2_QOS_RATE_PPS;
422 unformat_policer_round_type (unformat_input_t * input, va_list * args)
424 u8 *r = va_arg (*args, u8 *);
426 if (unformat (input, "closest"))
427 *r = SSE2_QOS_ROUND_TO_CLOSEST;
428 else if (unformat (input, "up"))
429 *r = SSE2_QOS_ROUND_TO_UP;
430 else if (unformat (input, "down"))
431 *r = SSE2_QOS_ROUND_TO_DOWN;
438 unformat_policer_type (unformat_input_t * input, va_list * args)
440 u8 *r = va_arg (*args, u8 *);
442 if (unformat (input, "1r2c"))
443 *r = SSE2_QOS_POLICER_TYPE_1R2C;
444 else if (unformat (input, "1r3c"))
445 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
446 else if (unformat (input, "2r3c-2698"))
447 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
448 else if (unformat (input, "2r3c-4115"))
449 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
450 else if (unformat (input, "2r3c-mef5cf1"))
451 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
458 unformat_dscp (unformat_input_t * input, va_list * va)
460 u8 *r = va_arg (*va, u8 *);
463 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
472 unformat_policer_action_type (unformat_input_t * input, va_list * va)
474 sse2_qos_pol_action_params_st *a
475 = va_arg (*va, sse2_qos_pol_action_params_st *);
477 if (unformat (input, "drop"))
478 a->action_type = SSE2_QOS_ACTION_DROP;
479 else if (unformat (input, "transmit"))
480 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
481 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
482 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
489 unformat_policer_classify_table_type (unformat_input_t * input, va_list * va)
491 u32 *r = va_arg (*va, u32 *);
494 if (unformat (input, "ip4"))
495 tid = POLICER_CLASSIFY_TABLE_IP4;
496 else if (unformat (input, "ip6"))
497 tid = POLICER_CLASSIFY_TABLE_IP6;
498 else if (unformat (input, "l2"))
499 tid = POLICER_CLASSIFY_TABLE_L2;
508 unformat_flow_classify_table_type (unformat_input_t * input, va_list * va)
510 u32 *r = va_arg (*va, u32 *);
513 if (unformat (input, "ip4"))
514 tid = FLOW_CLASSIFY_TABLE_IP4;
515 else if (unformat (input, "ip6"))
516 tid = FLOW_CLASSIFY_TABLE_IP6;
524 static const char *mfib_flag_names[] = MFIB_ENTRY_NAMES_SHORT;
525 static const char *mfib_flag_long_names[] = MFIB_ENTRY_NAMES_LONG;
526 static const char *mfib_itf_flag_long_names[] = MFIB_ITF_NAMES_LONG;
527 static const char *mfib_itf_flag_names[] = MFIB_ITF_NAMES_SHORT;
529 #if (VPP_API_TEST_BUILTIN==0)
531 unformat_mfib_itf_flags (unformat_input_t * input, va_list * args)
533 mfib_itf_flags_t old, *iflags = va_arg (*args, mfib_itf_flags_t *);
534 mfib_itf_attribute_t attr;
537 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
539 if (unformat (input, mfib_itf_flag_long_names[attr]))
540 *iflags |= (1 << attr);
542 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
544 if (unformat (input, mfib_itf_flag_names[attr]))
545 *iflags |= (1 << attr);
548 return (old == *iflags ? 0 : 1);
552 unformat_mfib_entry_flags (unformat_input_t * input, va_list * args)
554 mfib_entry_flags_t old, *eflags = va_arg (*args, mfib_entry_flags_t *);
555 mfib_entry_attribute_t attr;
558 FOR_EACH_MFIB_ATTRIBUTE (attr)
560 if (unformat (input, mfib_flag_long_names[attr]))
561 *eflags |= (1 << attr);
563 FOR_EACH_MFIB_ATTRIBUTE (attr)
565 if (unformat (input, mfib_flag_names[attr]))
566 *eflags |= (1 << attr);
569 return (old == *eflags ? 0 : 1);
573 format_ip4_address (u8 * s, va_list * args)
575 u8 *a = va_arg (*args, u8 *);
576 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
580 format_ip6_address (u8 * s, va_list * args)
582 ip6_address_t *a = va_arg (*args, ip6_address_t *);
583 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
585 i_max_n_zero = ARRAY_LEN (a->as_u16);
587 i_first_zero = i_max_n_zero;
589 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
591 u32 is_zero = a->as_u16[i] == 0;
592 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
598 if ((!is_zero && n_zeros > max_n_zeros)
599 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
601 i_max_n_zero = i_first_zero;
602 max_n_zeros = n_zeros;
603 i_first_zero = ARRAY_LEN (a->as_u16);
608 last_double_colon = 0;
609 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
611 if (i == i_max_n_zero && max_n_zeros > 1)
613 s = format (s, "::");
614 i += max_n_zeros - 1;
615 last_double_colon = 1;
619 s = format (s, "%s%x",
620 (last_double_colon || i == 0) ? "" : ":",
621 clib_net_to_host_u16 (a->as_u16[i]));
622 last_double_colon = 0;
629 /* Format an IP46 address. */
631 format_ip46_address (u8 * s, va_list * args)
633 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
634 ip46_type_t type = va_arg (*args, ip46_type_t);
640 is_ip4 = ip46_address_is_ip4 (ip46);
651 format (s, "%U", format_ip4_address, &ip46->ip4) :
652 format (s, "%U", format_ip6_address, &ip46->ip6);
656 format_ethernet_address (u8 * s, va_list * args)
658 u8 *a = va_arg (*args, u8 *);
660 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
661 a[0], a[1], a[2], a[3], a[4], a[5]);
666 increment_v4_address (ip4_address_t * a)
670 v = ntohl (a->as_u32) + 1;
671 a->as_u32 = ntohl (v);
675 increment_v6_address (ip6_address_t * a)
679 v0 = clib_net_to_host_u64 (a->as_u64[0]);
680 v1 = clib_net_to_host_u64 (a->as_u64[1]);
685 a->as_u64[0] = clib_net_to_host_u64 (v0);
686 a->as_u64[1] = clib_net_to_host_u64 (v1);
690 increment_mac_address (u64 * mac)
694 tmp = clib_net_to_host_u64 (tmp);
695 tmp += 1 << 16; /* skip unused (least significant) octets */
696 tmp = clib_host_to_net_u64 (tmp);
700 static void vl_api_create_loopback_reply_t_handler
701 (vl_api_create_loopback_reply_t * mp)
703 vat_main_t *vam = &vat_main;
704 i32 retval = ntohl (mp->retval);
706 vam->retval = retval;
707 vam->regenerate_interface_table = 1;
708 vam->sw_if_index = ntohl (mp->sw_if_index);
709 vam->result_ready = 1;
712 static void vl_api_create_loopback_reply_t_handler_json
713 (vl_api_create_loopback_reply_t * mp)
715 vat_main_t *vam = &vat_main;
716 vat_json_node_t node;
718 vat_json_init_object (&node);
719 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
720 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
722 vat_json_print (vam->ofp, &node);
723 vat_json_free (&node);
724 vam->retval = ntohl (mp->retval);
725 vam->result_ready = 1;
728 static void vl_api_af_packet_create_reply_t_handler
729 (vl_api_af_packet_create_reply_t * mp)
731 vat_main_t *vam = &vat_main;
732 i32 retval = ntohl (mp->retval);
734 vam->retval = retval;
735 vam->regenerate_interface_table = 1;
736 vam->sw_if_index = ntohl (mp->sw_if_index);
737 vam->result_ready = 1;
740 static void vl_api_af_packet_create_reply_t_handler_json
741 (vl_api_af_packet_create_reply_t * mp)
743 vat_main_t *vam = &vat_main;
744 vat_json_node_t node;
746 vat_json_init_object (&node);
747 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
748 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
750 vat_json_print (vam->ofp, &node);
751 vat_json_free (&node);
753 vam->retval = ntohl (mp->retval);
754 vam->result_ready = 1;
757 static void vl_api_create_vlan_subif_reply_t_handler
758 (vl_api_create_vlan_subif_reply_t * mp)
760 vat_main_t *vam = &vat_main;
761 i32 retval = ntohl (mp->retval);
763 vam->retval = retval;
764 vam->regenerate_interface_table = 1;
765 vam->sw_if_index = ntohl (mp->sw_if_index);
766 vam->result_ready = 1;
769 static void vl_api_create_vlan_subif_reply_t_handler_json
770 (vl_api_create_vlan_subif_reply_t * mp)
772 vat_main_t *vam = &vat_main;
773 vat_json_node_t node;
775 vat_json_init_object (&node);
776 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
777 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
779 vat_json_print (vam->ofp, &node);
780 vat_json_free (&node);
782 vam->retval = ntohl (mp->retval);
783 vam->result_ready = 1;
786 static void vl_api_create_subif_reply_t_handler
787 (vl_api_create_subif_reply_t * mp)
789 vat_main_t *vam = &vat_main;
790 i32 retval = ntohl (mp->retval);
792 vam->retval = retval;
793 vam->regenerate_interface_table = 1;
794 vam->sw_if_index = ntohl (mp->sw_if_index);
795 vam->result_ready = 1;
798 static void vl_api_create_subif_reply_t_handler_json
799 (vl_api_create_subif_reply_t * mp)
801 vat_main_t *vam = &vat_main;
802 vat_json_node_t node;
804 vat_json_init_object (&node);
805 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
806 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
808 vat_json_print (vam->ofp, &node);
809 vat_json_free (&node);
811 vam->retval = ntohl (mp->retval);
812 vam->result_ready = 1;
815 static void vl_api_interface_name_renumber_reply_t_handler
816 (vl_api_interface_name_renumber_reply_t * mp)
818 vat_main_t *vam = &vat_main;
819 i32 retval = ntohl (mp->retval);
821 vam->retval = retval;
822 vam->regenerate_interface_table = 1;
823 vam->result_ready = 1;
826 static void vl_api_interface_name_renumber_reply_t_handler_json
827 (vl_api_interface_name_renumber_reply_t * mp)
829 vat_main_t *vam = &vat_main;
830 vat_json_node_t node;
832 vat_json_init_object (&node);
833 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
835 vat_json_print (vam->ofp, &node);
836 vat_json_free (&node);
838 vam->retval = ntohl (mp->retval);
839 vam->result_ready = 1;
843 * Special-case: build the interface table, maintain
844 * the next loopback sw_if_index vbl.
846 static void vl_api_sw_interface_details_t_handler
847 (vl_api_sw_interface_details_t * mp)
849 vat_main_t *vam = &vat_main;
850 u8 *s = format (0, "%s%c", mp->interface_name, 0);
852 hash_set_mem (vam->sw_if_index_by_interface_name, s,
853 ntohl (mp->sw_if_index));
855 /* In sub interface case, fill the sub interface table entry */
856 if (mp->sw_if_index != mp->sup_sw_if_index)
858 sw_interface_subif_t *sub = NULL;
860 vec_add2 (vam->sw_if_subif_table, sub, 1);
862 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
863 strncpy ((char *) sub->interface_name, (char *) s,
864 vec_len (sub->interface_name));
865 sub->sw_if_index = ntohl (mp->sw_if_index);
866 sub->sub_id = ntohl (mp->sub_id);
868 sub->sub_dot1ad = mp->sub_dot1ad;
869 sub->sub_number_of_tags = mp->sub_number_of_tags;
870 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
871 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
872 sub->sub_exact_match = mp->sub_exact_match;
873 sub->sub_default = mp->sub_default;
874 sub->sub_outer_vlan_id_any = mp->sub_outer_vlan_id_any;
875 sub->sub_inner_vlan_id_any = mp->sub_inner_vlan_id_any;
877 /* vlan tag rewrite */
878 sub->vtr_op = ntohl (mp->vtr_op);
879 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
880 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
881 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
885 static void vl_api_sw_interface_details_t_handler_json
886 (vl_api_sw_interface_details_t * mp)
888 vat_main_t *vam = &vat_main;
889 vat_json_node_t *node = NULL;
891 if (VAT_JSON_ARRAY != vam->json_tree.type)
893 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
894 vat_json_init_array (&vam->json_tree);
896 node = vat_json_array_add (&vam->json_tree);
898 vat_json_init_object (node);
899 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
900 vat_json_object_add_uint (node, "sup_sw_if_index",
901 ntohl (mp->sup_sw_if_index));
902 vat_json_object_add_uint (node, "l2_address_length",
903 ntohl (mp->l2_address_length));
904 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
905 sizeof (mp->l2_address));
906 vat_json_object_add_string_copy (node, "interface_name",
908 vat_json_object_add_uint (node, "admin_up_down", mp->admin_up_down);
909 vat_json_object_add_uint (node, "link_up_down", mp->link_up_down);
910 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
911 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
912 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
913 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
914 vat_json_object_add_uint (node, "sub_dot1ad", mp->sub_dot1ad);
915 vat_json_object_add_uint (node, "sub_number_of_tags",
916 mp->sub_number_of_tags);
917 vat_json_object_add_uint (node, "sub_outer_vlan_id",
918 ntohs (mp->sub_outer_vlan_id));
919 vat_json_object_add_uint (node, "sub_inner_vlan_id",
920 ntohs (mp->sub_inner_vlan_id));
921 vat_json_object_add_uint (node, "sub_exact_match", mp->sub_exact_match);
922 vat_json_object_add_uint (node, "sub_default", mp->sub_default);
923 vat_json_object_add_uint (node, "sub_outer_vlan_id_any",
924 mp->sub_outer_vlan_id_any);
925 vat_json_object_add_uint (node, "sub_inner_vlan_id_any",
926 mp->sub_inner_vlan_id_any);
927 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
928 vat_json_object_add_uint (node, "vtr_push_dot1q",
929 ntohl (mp->vtr_push_dot1q));
930 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
931 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
934 vat_json_object_add_string_copy (node, "pbb_vtr_dmac",
936 format_ethernet_address,
938 vat_json_object_add_string_copy (node, "pbb_vtr_smac",
940 format_ethernet_address,
942 vat_json_object_add_uint (node, "pbb_vtr_b_vlanid", mp->b_vlanid);
943 vat_json_object_add_uint (node, "pbb_vtr_i_sid", mp->i_sid);
947 #if VPP_API_TEST_BUILTIN == 0
948 static void vl_api_sw_interface_set_flags_t_handler
949 (vl_api_sw_interface_set_flags_t * mp)
951 vat_main_t *vam = &vat_main;
952 if (vam->interface_event_display)
953 errmsg ("interface flags: sw_if_index %d %s %s",
954 ntohl (mp->sw_if_index),
955 mp->admin_up_down ? "admin-up" : "admin-down",
956 mp->link_up_down ? "link-up" : "link-down");
960 static void vl_api_sw_interface_set_flags_t_handler_json
961 (vl_api_sw_interface_set_flags_t * mp)
963 /* JSON output not supported */
967 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
969 vat_main_t *vam = &vat_main;
970 i32 retval = ntohl (mp->retval);
972 vam->retval = retval;
973 vam->shmem_result = (u8 *) mp->reply_in_shmem;
974 vam->result_ready = 1;
978 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
980 vat_main_t *vam = &vat_main;
981 vat_json_node_t node;
982 api_main_t *am = &api_main;
986 vat_json_init_object (&node);
987 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
988 vat_json_object_add_uint (&node, "reply_in_shmem",
989 ntohl (mp->reply_in_shmem));
990 /* Toss the shared-memory original... */
991 pthread_mutex_lock (&am->vlib_rp->mutex);
992 oldheap = svm_push_data_heap (am->vlib_rp);
994 reply = (u8 *) (mp->reply_in_shmem);
997 svm_pop_heap (oldheap);
998 pthread_mutex_unlock (&am->vlib_rp->mutex);
1000 vat_json_print (vam->ofp, &node);
1001 vat_json_free (&node);
1003 vam->retval = ntohl (mp->retval);
1004 vam->result_ready = 1;
1008 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
1010 vat_main_t *vam = &vat_main;
1011 i32 retval = ntohl (mp->retval);
1013 vam->retval = retval;
1014 vam->cmd_reply = mp->reply;
1015 vam->result_ready = 1;
1019 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
1021 vat_main_t *vam = &vat_main;
1022 vat_json_node_t node;
1024 vat_json_init_object (&node);
1025 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1026 vat_json_object_add_string_copy (&node, "reply", mp->reply);
1028 vat_json_print (vam->ofp, &node);
1029 vat_json_free (&node);
1031 vam->retval = ntohl (mp->retval);
1032 vam->result_ready = 1;
1035 static void vl_api_classify_add_del_table_reply_t_handler
1036 (vl_api_classify_add_del_table_reply_t * mp)
1038 vat_main_t *vam = &vat_main;
1039 i32 retval = ntohl (mp->retval);
1040 if (vam->async_mode)
1042 vam->async_errors += (retval < 0);
1046 vam->retval = retval;
1048 ((mp->new_table_index != 0xFFFFFFFF) ||
1049 (mp->skip_n_vectors != 0xFFFFFFFF) ||
1050 (mp->match_n_vectors != 0xFFFFFFFF)))
1052 * Note: this is just barely thread-safe, depends on
1053 * the main thread spinning waiting for an answer...
1055 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d",
1056 ntohl (mp->new_table_index),
1057 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
1058 vam->result_ready = 1;
1062 static void vl_api_classify_add_del_table_reply_t_handler_json
1063 (vl_api_classify_add_del_table_reply_t * mp)
1065 vat_main_t *vam = &vat_main;
1066 vat_json_node_t node;
1068 vat_json_init_object (&node);
1069 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1070 vat_json_object_add_uint (&node, "new_table_index",
1071 ntohl (mp->new_table_index));
1072 vat_json_object_add_uint (&node, "skip_n_vectors",
1073 ntohl (mp->skip_n_vectors));
1074 vat_json_object_add_uint (&node, "match_n_vectors",
1075 ntohl (mp->match_n_vectors));
1077 vat_json_print (vam->ofp, &node);
1078 vat_json_free (&node);
1080 vam->retval = ntohl (mp->retval);
1081 vam->result_ready = 1;
1084 static void vl_api_get_node_index_reply_t_handler
1085 (vl_api_get_node_index_reply_t * mp)
1087 vat_main_t *vam = &vat_main;
1088 i32 retval = ntohl (mp->retval);
1089 if (vam->async_mode)
1091 vam->async_errors += (retval < 0);
1095 vam->retval = retval;
1097 errmsg ("node index %d", ntohl (mp->node_index));
1098 vam->result_ready = 1;
1102 static void vl_api_get_node_index_reply_t_handler_json
1103 (vl_api_get_node_index_reply_t * mp)
1105 vat_main_t *vam = &vat_main;
1106 vat_json_node_t node;
1108 vat_json_init_object (&node);
1109 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1110 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1112 vat_json_print (vam->ofp, &node);
1113 vat_json_free (&node);
1115 vam->retval = ntohl (mp->retval);
1116 vam->result_ready = 1;
1119 static void vl_api_get_next_index_reply_t_handler
1120 (vl_api_get_next_index_reply_t * mp)
1122 vat_main_t *vam = &vat_main;
1123 i32 retval = ntohl (mp->retval);
1124 if (vam->async_mode)
1126 vam->async_errors += (retval < 0);
1130 vam->retval = retval;
1132 errmsg ("next node index %d", ntohl (mp->next_index));
1133 vam->result_ready = 1;
1137 static void vl_api_get_next_index_reply_t_handler_json
1138 (vl_api_get_next_index_reply_t * mp)
1140 vat_main_t *vam = &vat_main;
1141 vat_json_node_t node;
1143 vat_json_init_object (&node);
1144 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1145 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
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_add_node_next_reply_t_handler
1155 (vl_api_add_node_next_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 ("next index %d", ntohl (mp->next_index));
1168 vam->result_ready = 1;
1172 static void vl_api_add_node_next_reply_t_handler_json
1173 (vl_api_add_node_next_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, "next_index", ntohl (mp->next_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_show_version_reply_t_handler
1190 (vl_api_show_version_reply_t * mp)
1192 vat_main_t *vam = &vat_main;
1193 i32 retval = ntohl (mp->retval);
1197 errmsg (" program: %s", mp->program);
1198 errmsg (" version: %s", mp->version);
1199 errmsg (" build date: %s", mp->build_date);
1200 errmsg ("build directory: %s", mp->build_directory);
1202 vam->retval = retval;
1203 vam->result_ready = 1;
1206 static void vl_api_show_version_reply_t_handler_json
1207 (vl_api_show_version_reply_t * mp)
1209 vat_main_t *vam = &vat_main;
1210 vat_json_node_t node;
1212 vat_json_init_object (&node);
1213 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1214 vat_json_object_add_string_copy (&node, "program", mp->program);
1215 vat_json_object_add_string_copy (&node, "version", mp->version);
1216 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1217 vat_json_object_add_string_copy (&node, "build_directory",
1218 mp->build_directory);
1220 vat_json_print (vam->ofp, &node);
1221 vat_json_free (&node);
1223 vam->retval = ntohl (mp->retval);
1224 vam->result_ready = 1;
1228 vl_api_ip4_arp_event_t_handler (vl_api_ip4_arp_event_t * mp)
1230 errmsg ("arp %s event: address %U new mac %U sw_if_index %d",
1231 mp->mac_ip ? "mac/ip binding" : "address resolution",
1232 format_ip4_address, &mp->address,
1233 format_ethernet_address, mp->new_mac, mp->sw_if_index);
1237 vl_api_ip4_arp_event_t_handler_json (vl_api_ip4_arp_event_t * mp)
1239 /* JSON output not supported */
1243 vl_api_ip6_nd_event_t_handler (vl_api_ip6_nd_event_t * mp)
1245 errmsg ("ip6 nd %s event: address %U new mac %U sw_if_index %d",
1246 mp->mac_ip ? "mac/ip binding" : "address resolution",
1247 format_ip6_address, mp->address,
1248 format_ethernet_address, mp->new_mac, mp->sw_if_index);
1252 vl_api_ip6_nd_event_t_handler_json (vl_api_ip6_nd_event_t * mp)
1254 /* JSON output not supported */
1258 * Special-case: build the bridge domain table, maintain
1259 * the next bd id vbl.
1261 static void vl_api_bridge_domain_details_t_handler
1262 (vl_api_bridge_domain_details_t * mp)
1264 vat_main_t *vam = &vat_main;
1265 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1267 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-3s",
1268 " ID", "LRN", "FWD", "FLD", "BVI", "#IF");
1270 print (vam->ofp, "%3d %3d %3d %3d %3d %3d",
1271 ntohl (mp->bd_id), mp->learn, mp->forward,
1272 mp->flood, ntohl (mp->bvi_sw_if_index), n_sw_ifs);
1275 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG", "Interface Name");
1278 static void vl_api_bridge_domain_details_t_handler_json
1279 (vl_api_bridge_domain_details_t * mp)
1281 vat_main_t *vam = &vat_main;
1282 vat_json_node_t *node, *array = NULL;
1284 if (VAT_JSON_ARRAY != vam->json_tree.type)
1286 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1287 vat_json_init_array (&vam->json_tree);
1289 node = vat_json_array_add (&vam->json_tree);
1291 vat_json_init_object (node);
1292 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1293 vat_json_object_add_uint (node, "flood", mp->flood);
1294 vat_json_object_add_uint (node, "forward", mp->forward);
1295 vat_json_object_add_uint (node, "learn", mp->learn);
1296 vat_json_object_add_uint (node, "bvi_sw_if_index",
1297 ntohl (mp->bvi_sw_if_index));
1298 vat_json_object_add_uint (node, "n_sw_ifs", ntohl (mp->n_sw_ifs));
1299 array = vat_json_object_add (node, "sw_if");
1300 vat_json_init_array (array);
1304 * Special-case: build the bridge domain sw if table.
1306 static void vl_api_bridge_domain_sw_if_details_t_handler
1307 (vl_api_bridge_domain_sw_if_details_t * mp)
1309 vat_main_t *vam = &vat_main;
1314 sw_if_index = ntohl (mp->sw_if_index);
1316 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1318 if ((u32) p->value[0] == sw_if_index)
1320 sw_if_name = (u8 *)(p->key);
1326 print (vam->ofp, "%7d %3d %s", sw_if_index,
1327 mp->shg, sw_if_name ? (char *) sw_if_name :
1328 "sw_if_index not found!");
1331 static void vl_api_bridge_domain_sw_if_details_t_handler_json
1332 (vl_api_bridge_domain_sw_if_details_t * mp)
1334 vat_main_t *vam = &vat_main;
1335 vat_json_node_t *node = NULL;
1336 uword last_index = 0;
1338 ASSERT (VAT_JSON_ARRAY == vam->json_tree.type);
1339 ASSERT (vec_len (vam->json_tree.array) >= 1);
1340 last_index = vec_len (vam->json_tree.array) - 1;
1341 node = &vam->json_tree.array[last_index];
1342 node = vat_json_object_get_element (node, "sw_if");
1343 ASSERT (NULL != node);
1344 node = vat_json_array_add (node);
1346 vat_json_init_object (node);
1347 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1348 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
1349 vat_json_object_add_uint (node, "shg", mp->shg);
1352 static void vl_api_control_ping_reply_t_handler
1353 (vl_api_control_ping_reply_t * mp)
1355 vat_main_t *vam = &vat_main;
1356 i32 retval = ntohl (mp->retval);
1357 if (vam->async_mode)
1359 vam->async_errors += (retval < 0);
1363 vam->retval = retval;
1364 vam->result_ready = 1;
1368 static void vl_api_control_ping_reply_t_handler_json
1369 (vl_api_control_ping_reply_t * mp)
1371 vat_main_t *vam = &vat_main;
1372 i32 retval = ntohl (mp->retval);
1374 if (VAT_JSON_NONE != vam->json_tree.type)
1376 vat_json_print (vam->ofp, &vam->json_tree);
1377 vat_json_free (&vam->json_tree);
1378 vam->json_tree.type = VAT_JSON_NONE;
1383 vat_json_init_array (&vam->json_tree);
1384 vat_json_print (vam->ofp, &vam->json_tree);
1385 vam->json_tree.type = VAT_JSON_NONE;
1388 vam->retval = retval;
1389 vam->result_ready = 1;
1393 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1395 vat_main_t *vam = &vat_main;
1396 i32 retval = ntohl (mp->retval);
1397 if (vam->async_mode)
1399 vam->async_errors += (retval < 0);
1403 vam->retval = retval;
1404 vam->result_ready = 1;
1408 static void vl_api_l2_flags_reply_t_handler_json
1409 (vl_api_l2_flags_reply_t * mp)
1411 vat_main_t *vam = &vat_main;
1412 vat_json_node_t node;
1414 vat_json_init_object (&node);
1415 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1416 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1417 ntohl (mp->resulting_feature_bitmap));
1419 vat_json_print (vam->ofp, &node);
1420 vat_json_free (&node);
1422 vam->retval = ntohl (mp->retval);
1423 vam->result_ready = 1;
1426 static void vl_api_bridge_flags_reply_t_handler
1427 (vl_api_bridge_flags_reply_t * mp)
1429 vat_main_t *vam = &vat_main;
1430 i32 retval = ntohl (mp->retval);
1431 if (vam->async_mode)
1433 vam->async_errors += (retval < 0);
1437 vam->retval = retval;
1438 vam->result_ready = 1;
1442 static void vl_api_bridge_flags_reply_t_handler_json
1443 (vl_api_bridge_flags_reply_t * mp)
1445 vat_main_t *vam = &vat_main;
1446 vat_json_node_t node;
1448 vat_json_init_object (&node);
1449 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1450 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1451 ntohl (mp->resulting_feature_bitmap));
1453 vat_json_print (vam->ofp, &node);
1454 vat_json_free (&node);
1456 vam->retval = ntohl (mp->retval);
1457 vam->result_ready = 1;
1460 static void vl_api_tap_connect_reply_t_handler
1461 (vl_api_tap_connect_reply_t * mp)
1463 vat_main_t *vam = &vat_main;
1464 i32 retval = ntohl (mp->retval);
1465 if (vam->async_mode)
1467 vam->async_errors += (retval < 0);
1471 vam->retval = retval;
1472 vam->sw_if_index = ntohl (mp->sw_if_index);
1473 vam->result_ready = 1;
1478 static void vl_api_tap_connect_reply_t_handler_json
1479 (vl_api_tap_connect_reply_t * mp)
1481 vat_main_t *vam = &vat_main;
1482 vat_json_node_t node;
1484 vat_json_init_object (&node);
1485 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1486 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1488 vat_json_print (vam->ofp, &node);
1489 vat_json_free (&node);
1491 vam->retval = ntohl (mp->retval);
1492 vam->result_ready = 1;
1497 vl_api_tap_modify_reply_t_handler (vl_api_tap_modify_reply_t * mp)
1499 vat_main_t *vam = &vat_main;
1500 i32 retval = ntohl (mp->retval);
1501 if (vam->async_mode)
1503 vam->async_errors += (retval < 0);
1507 vam->retval = retval;
1508 vam->sw_if_index = ntohl (mp->sw_if_index);
1509 vam->result_ready = 1;
1513 static void vl_api_tap_modify_reply_t_handler_json
1514 (vl_api_tap_modify_reply_t * mp)
1516 vat_main_t *vam = &vat_main;
1517 vat_json_node_t node;
1519 vat_json_init_object (&node);
1520 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1521 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1523 vat_json_print (vam->ofp, &node);
1524 vat_json_free (&node);
1526 vam->retval = ntohl (mp->retval);
1527 vam->result_ready = 1;
1531 vl_api_tap_delete_reply_t_handler (vl_api_tap_delete_reply_t * mp)
1533 vat_main_t *vam = &vat_main;
1534 i32 retval = ntohl (mp->retval);
1535 if (vam->async_mode)
1537 vam->async_errors += (retval < 0);
1541 vam->retval = retval;
1542 vam->result_ready = 1;
1546 static void vl_api_tap_delete_reply_t_handler_json
1547 (vl_api_tap_delete_reply_t * mp)
1549 vat_main_t *vam = &vat_main;
1550 vat_json_node_t node;
1552 vat_json_init_object (&node);
1553 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1555 vat_json_print (vam->ofp, &node);
1556 vat_json_free (&node);
1558 vam->retval = ntohl (mp->retval);
1559 vam->result_ready = 1;
1562 static void vl_api_mpls_tunnel_add_del_reply_t_handler
1563 (vl_api_mpls_tunnel_add_del_reply_t * mp)
1565 vat_main_t *vam = &vat_main;
1566 i32 retval = ntohl (mp->retval);
1567 if (vam->async_mode)
1569 vam->async_errors += (retval < 0);
1573 vam->retval = retval;
1574 vam->result_ready = 1;
1578 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
1579 (vl_api_mpls_tunnel_add_del_reply_t * mp)
1581 vat_main_t *vam = &vat_main;
1582 vat_json_node_t node;
1584 vat_json_init_object (&node);
1585 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1586 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
1587 ntohl (mp->sw_if_index));
1589 vat_json_print (vam->ofp, &node);
1590 vat_json_free (&node);
1592 vam->retval = ntohl (mp->retval);
1593 vam->result_ready = 1;
1596 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
1597 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1599 vat_main_t *vam = &vat_main;
1600 i32 retval = ntohl (mp->retval);
1601 if (vam->async_mode)
1603 vam->async_errors += (retval < 0);
1607 vam->retval = retval;
1608 vam->sw_if_index = ntohl (mp->sw_if_index);
1609 vam->result_ready = 1;
1613 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
1614 (vl_api_l2tpv3_create_tunnel_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;
1631 static void vl_api_one_add_del_locator_set_reply_t_handler
1632 (vl_api_one_add_del_locator_set_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->result_ready = 1;
1647 static void vl_api_one_add_del_locator_set_reply_t_handler_json
1648 (vl_api_one_add_del_locator_set_reply_t * mp)
1650 vat_main_t *vam = &vat_main;
1651 vat_json_node_t node;
1653 vat_json_init_object (&node);
1654 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1655 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
1657 vat_json_print (vam->ofp, &node);
1658 vat_json_free (&node);
1660 vam->retval = ntohl (mp->retval);
1661 vam->result_ready = 1;
1664 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
1665 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1667 vat_main_t *vam = &vat_main;
1668 i32 retval = ntohl (mp->retval);
1669 if (vam->async_mode)
1671 vam->async_errors += (retval < 0);
1675 vam->retval = retval;
1676 vam->sw_if_index = ntohl (mp->sw_if_index);
1677 vam->result_ready = 1;
1681 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
1682 (vl_api_vxlan_add_del_tunnel_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));
1689 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1691 vat_json_print (vam->ofp, &node);
1692 vat_json_free (&node);
1694 vam->retval = ntohl (mp->retval);
1695 vam->result_ready = 1;
1698 static void vl_api_gre_add_del_tunnel_reply_t_handler
1699 (vl_api_gre_add_del_tunnel_reply_t * mp)
1701 vat_main_t *vam = &vat_main;
1702 i32 retval = ntohl (mp->retval);
1703 if (vam->async_mode)
1705 vam->async_errors += (retval < 0);
1709 vam->retval = retval;
1710 vam->sw_if_index = ntohl (mp->sw_if_index);
1711 vam->result_ready = 1;
1715 static void vl_api_gre_add_del_tunnel_reply_t_handler_json
1716 (vl_api_gre_add_del_tunnel_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;
1732 static void vl_api_create_vhost_user_if_reply_t_handler
1733 (vl_api_create_vhost_user_if_reply_t * mp)
1735 vat_main_t *vam = &vat_main;
1736 i32 retval = ntohl (mp->retval);
1737 if (vam->async_mode)
1739 vam->async_errors += (retval < 0);
1743 vam->retval = retval;
1744 vam->sw_if_index = ntohl (mp->sw_if_index);
1745 vam->result_ready = 1;
1749 static void vl_api_create_vhost_user_if_reply_t_handler_json
1750 (vl_api_create_vhost_user_if_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));
1757 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1759 vat_json_print (vam->ofp, &node);
1760 vat_json_free (&node);
1762 vam->retval = ntohl (mp->retval);
1763 vam->result_ready = 1;
1766 static void vl_api_ip_address_details_t_handler
1767 (vl_api_ip_address_details_t * mp)
1769 vat_main_t *vam = &vat_main;
1770 static ip_address_details_t empty_ip_address_details = { {0} };
1771 ip_address_details_t *address = NULL;
1772 ip_details_t *current_ip_details = NULL;
1773 ip_details_t *details = NULL;
1775 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
1777 if (!details || vam->current_sw_if_index >= vec_len (details)
1778 || !details[vam->current_sw_if_index].present)
1780 errmsg ("ip address details arrived but not stored");
1781 errmsg ("ip_dump should be called first");
1785 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
1787 #define addresses (current_ip_details->addr)
1789 vec_validate_init_empty (addresses, vec_len (addresses),
1790 empty_ip_address_details);
1792 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
1794 clib_memcpy (&address->ip, &mp->ip, sizeof (address->ip));
1795 address->prefix_length = mp->prefix_length;
1799 static void vl_api_ip_address_details_t_handler_json
1800 (vl_api_ip_address_details_t * mp)
1802 vat_main_t *vam = &vat_main;
1803 vat_json_node_t *node = NULL;
1804 struct in6_addr ip6;
1807 if (VAT_JSON_ARRAY != vam->json_tree.type)
1809 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1810 vat_json_init_array (&vam->json_tree);
1812 node = vat_json_array_add (&vam->json_tree);
1814 vat_json_init_object (node);
1817 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
1818 vat_json_object_add_ip6 (node, "ip", ip6);
1822 clib_memcpy (&ip4, mp->ip, sizeof (ip4));
1823 vat_json_object_add_ip4 (node, "ip", ip4);
1825 vat_json_object_add_uint (node, "prefix_length", mp->prefix_length);
1829 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
1831 vat_main_t *vam = &vat_main;
1832 static ip_details_t empty_ip_details = { 0 };
1833 ip_details_t *ip = NULL;
1834 u32 sw_if_index = ~0;
1836 sw_if_index = ntohl (mp->sw_if_index);
1838 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1839 sw_if_index, empty_ip_details);
1841 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1848 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
1850 vat_main_t *vam = &vat_main;
1852 if (VAT_JSON_ARRAY != vam->json_tree.type)
1854 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1855 vat_json_init_array (&vam->json_tree);
1857 vat_json_array_add_uint (&vam->json_tree,
1858 clib_net_to_host_u32 (mp->sw_if_index));
1861 static void vl_api_map_domain_details_t_handler_json
1862 (vl_api_map_domain_details_t * mp)
1864 vat_json_node_t *node = NULL;
1865 vat_main_t *vam = &vat_main;
1866 struct in6_addr ip6;
1869 if (VAT_JSON_ARRAY != vam->json_tree.type)
1871 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1872 vat_json_init_array (&vam->json_tree);
1875 node = vat_json_array_add (&vam->json_tree);
1876 vat_json_init_object (node);
1878 vat_json_object_add_uint (node, "domain_index",
1879 clib_net_to_host_u32 (mp->domain_index));
1880 clib_memcpy (&ip6, mp->ip6_prefix, sizeof (ip6));
1881 vat_json_object_add_ip6 (node, "ip6_prefix", ip6);
1882 clib_memcpy (&ip4, mp->ip4_prefix, sizeof (ip4));
1883 vat_json_object_add_ip4 (node, "ip4_prefix", ip4);
1884 clib_memcpy (&ip6, mp->ip6_src, sizeof (ip6));
1885 vat_json_object_add_ip6 (node, "ip6_src", ip6);
1886 vat_json_object_add_int (node, "ip6_prefix_len", mp->ip6_prefix_len);
1887 vat_json_object_add_int (node, "ip4_prefix_len", mp->ip4_prefix_len);
1888 vat_json_object_add_int (node, "ip6_src_len", mp->ip6_src_len);
1889 vat_json_object_add_int (node, "ea_bits_len", mp->ea_bits_len);
1890 vat_json_object_add_int (node, "psid_offset", mp->psid_offset);
1891 vat_json_object_add_int (node, "psid_length", mp->psid_length);
1892 vat_json_object_add_uint (node, "flags", mp->flags);
1893 vat_json_object_add_uint (node, "mtu", clib_net_to_host_u16 (mp->mtu));
1894 vat_json_object_add_int (node, "is_translation", mp->is_translation);
1897 static void vl_api_map_domain_details_t_handler
1898 (vl_api_map_domain_details_t * mp)
1900 vat_main_t *vam = &vat_main;
1902 if (mp->is_translation)
1905 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U/%d (ip6-src) index: %u",
1906 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1907 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1908 format_ip6_address, mp->ip6_src, mp->ip6_src_len,
1909 clib_net_to_host_u32 (mp->domain_index));
1914 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U (ip6-src) index: %u",
1915 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1916 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1917 format_ip6_address, mp->ip6_src,
1918 clib_net_to_host_u32 (mp->domain_index));
1920 print (vam->ofp, " ea-len %d psid-offset %d psid-len %d mtu %d %s",
1921 mp->ea_bits_len, mp->psid_offset, mp->psid_length, mp->mtu,
1922 mp->is_translation ? "map-t" : "");
1925 static void vl_api_map_rule_details_t_handler_json
1926 (vl_api_map_rule_details_t * mp)
1928 struct in6_addr ip6;
1929 vat_json_node_t *node = NULL;
1930 vat_main_t *vam = &vat_main;
1932 if (VAT_JSON_ARRAY != vam->json_tree.type)
1934 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1935 vat_json_init_array (&vam->json_tree);
1938 node = vat_json_array_add (&vam->json_tree);
1939 vat_json_init_object (node);
1941 vat_json_object_add_uint (node, "psid", clib_net_to_host_u16 (mp->psid));
1942 clib_memcpy (&ip6, mp->ip6_dst, sizeof (ip6));
1943 vat_json_object_add_ip6 (node, "ip6_dst", ip6);
1947 vl_api_map_rule_details_t_handler (vl_api_map_rule_details_t * mp)
1949 vat_main_t *vam = &vat_main;
1950 print (vam->ofp, " %d (psid) %U (ip6-dst)",
1951 clib_net_to_host_u16 (mp->psid), format_ip6_address, mp->ip6_dst);
1955 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
1957 errmsg ("DHCP compl event: pid %d %s hostname %s host_addr %U "
1958 "router_addr %U host_mac %U",
1959 mp->pid, mp->is_ipv6 ? "ipv6" : "ipv4", mp->hostname,
1960 format_ip4_address, &mp->host_address,
1961 format_ip4_address, &mp->router_address,
1962 format_ethernet_address, mp->host_mac);
1965 static void vl_api_dhcp_compl_event_t_handler_json
1966 (vl_api_dhcp_compl_event_t * mp)
1968 /* JSON output not supported */
1972 set_simple_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1975 vat_main_t *vam = &vat_main;
1976 static u64 default_counter = 0;
1978 vec_validate_init_empty (vam->simple_interface_counters, vnet_counter_type,
1980 vec_validate_init_empty (vam->simple_interface_counters[vnet_counter_type],
1981 sw_if_index, default_counter);
1982 vam->simple_interface_counters[vnet_counter_type][sw_if_index] = counter;
1986 set_combined_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1987 interface_counter_t counter)
1989 vat_main_t *vam = &vat_main;
1990 static interface_counter_t default_counter = { 0, };
1992 vec_validate_init_empty (vam->combined_interface_counters,
1993 vnet_counter_type, NULL);
1994 vec_validate_init_empty (vam->combined_interface_counters
1995 [vnet_counter_type], sw_if_index, default_counter);
1996 vam->combined_interface_counters[vnet_counter_type][sw_if_index] = counter;
1999 static void vl_api_vnet_interface_counters_t_handler
2000 (vl_api_vnet_interface_counters_t * mp)
2005 static void vl_api_vnet_interface_counters_t_handler_json
2006 (vl_api_vnet_interface_counters_t * mp)
2008 interface_counter_t counter;
2013 u32 first_sw_if_index;
2016 count = ntohl (mp->count);
2017 first_sw_if_index = ntohl (mp->first_sw_if_index);
2019 if (!mp->is_combined)
2021 v_packets = (u64 *) & mp->data;
2022 for (i = 0; i < count; i++)
2025 clib_net_to_host_u64 (clib_mem_unaligned (v_packets, u64));
2026 set_simple_interface_counter (mp->vnet_counter_type,
2027 first_sw_if_index + i, packets);
2033 v = (vlib_counter_t *) & mp->data;
2034 for (i = 0; i < count; i++)
2037 clib_net_to_host_u64 (clib_mem_unaligned (&v->packets, u64));
2039 clib_net_to_host_u64 (clib_mem_unaligned (&v->bytes, u64));
2040 set_combined_interface_counter (mp->vnet_counter_type,
2041 first_sw_if_index + i, counter);
2048 ip4_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
2050 vat_main_t *vam = &vat_main;
2053 for (i = 0; i < vec_len (vam->ip4_fib_counters_vrf_id_by_index); i++)
2055 if (vam->ip4_fib_counters_vrf_id_by_index[i] == vrf_id)
2064 ip6_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
2066 vat_main_t *vam = &vat_main;
2069 for (i = 0; i < vec_len (vam->ip6_fib_counters_vrf_id_by_index); i++)
2071 if (vam->ip6_fib_counters_vrf_id_by_index[i] == vrf_id)
2079 static void vl_api_vnet_ip4_fib_counters_t_handler
2080 (vl_api_vnet_ip4_fib_counters_t * mp)
2085 static void vl_api_vnet_ip4_fib_counters_t_handler_json
2086 (vl_api_vnet_ip4_fib_counters_t * mp)
2088 vat_main_t *vam = &vat_main;
2089 vl_api_ip4_fib_counter_t *v;
2090 ip4_fib_counter_t *counter;
2097 vrf_id = ntohl (mp->vrf_id);
2098 vrf_index = ip4_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2099 if (~0 == vrf_index)
2101 vrf_index = vec_len (vam->ip4_fib_counters_vrf_id_by_index);
2102 vec_validate (vam->ip4_fib_counters_vrf_id_by_index, vrf_index);
2103 vam->ip4_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2104 vec_validate (vam->ip4_fib_counters, vrf_index);
2105 vam->ip4_fib_counters[vrf_index] = NULL;
2108 vec_free (vam->ip4_fib_counters[vrf_index]);
2109 v = (vl_api_ip4_fib_counter_t *) & mp->c;
2110 count = ntohl (mp->count);
2111 for (i = 0; i < count; i++)
2113 vec_validate (vam->ip4_fib_counters[vrf_index], i);
2114 counter = &vam->ip4_fib_counters[vrf_index][i];
2115 clib_memcpy (&ip4, &v->address, sizeof (ip4));
2116 counter->address = ip4;
2117 counter->address_length = v->address_length;
2118 counter->packets = clib_net_to_host_u64 (v->packets);
2119 counter->bytes = clib_net_to_host_u64 (v->bytes);
2124 static void vl_api_vnet_ip4_nbr_counters_t_handler
2125 (vl_api_vnet_ip4_nbr_counters_t * mp)
2130 static void vl_api_vnet_ip4_nbr_counters_t_handler_json
2131 (vl_api_vnet_ip4_nbr_counters_t * mp)
2133 vat_main_t *vam = &vat_main;
2134 vl_api_ip4_nbr_counter_t *v;
2135 ip4_nbr_counter_t *counter;
2140 sw_if_index = ntohl (mp->sw_if_index);
2141 count = ntohl (mp->count);
2142 vec_validate (vam->ip4_nbr_counters, sw_if_index);
2145 vec_free (vam->ip4_nbr_counters[sw_if_index]);
2147 v = (vl_api_ip4_nbr_counter_t *) & mp->c;
2148 for (i = 0; i < count; i++)
2150 vec_validate (vam->ip4_nbr_counters[sw_if_index], i);
2151 counter = &vam->ip4_nbr_counters[sw_if_index][i];
2152 counter->address.s_addr = v->address;
2153 counter->packets = clib_net_to_host_u64 (v->packets);
2154 counter->bytes = clib_net_to_host_u64 (v->bytes);
2155 counter->linkt = v->link_type;
2160 static void vl_api_vnet_ip6_fib_counters_t_handler
2161 (vl_api_vnet_ip6_fib_counters_t * mp)
2166 static void vl_api_vnet_ip6_fib_counters_t_handler_json
2167 (vl_api_vnet_ip6_fib_counters_t * mp)
2169 vat_main_t *vam = &vat_main;
2170 vl_api_ip6_fib_counter_t *v;
2171 ip6_fib_counter_t *counter;
2172 struct in6_addr ip6;
2178 vrf_id = ntohl (mp->vrf_id);
2179 vrf_index = ip6_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2180 if (~0 == vrf_index)
2182 vrf_index = vec_len (vam->ip6_fib_counters_vrf_id_by_index);
2183 vec_validate (vam->ip6_fib_counters_vrf_id_by_index, vrf_index);
2184 vam->ip6_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2185 vec_validate (vam->ip6_fib_counters, vrf_index);
2186 vam->ip6_fib_counters[vrf_index] = NULL;
2189 vec_free (vam->ip6_fib_counters[vrf_index]);
2190 v = (vl_api_ip6_fib_counter_t *) & mp->c;
2191 count = ntohl (mp->count);
2192 for (i = 0; i < count; i++)
2194 vec_validate (vam->ip6_fib_counters[vrf_index], i);
2195 counter = &vam->ip6_fib_counters[vrf_index][i];
2196 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2197 counter->address = ip6;
2198 counter->address_length = v->address_length;
2199 counter->packets = clib_net_to_host_u64 (v->packets);
2200 counter->bytes = clib_net_to_host_u64 (v->bytes);
2205 static void vl_api_vnet_ip6_nbr_counters_t_handler
2206 (vl_api_vnet_ip6_nbr_counters_t * mp)
2211 static void vl_api_vnet_ip6_nbr_counters_t_handler_json
2212 (vl_api_vnet_ip6_nbr_counters_t * mp)
2214 vat_main_t *vam = &vat_main;
2215 vl_api_ip6_nbr_counter_t *v;
2216 ip6_nbr_counter_t *counter;
2217 struct in6_addr ip6;
2222 sw_if_index = ntohl (mp->sw_if_index);
2223 count = ntohl (mp->count);
2224 vec_validate (vam->ip6_nbr_counters, sw_if_index);
2227 vec_free (vam->ip6_nbr_counters[sw_if_index]);
2229 v = (vl_api_ip6_nbr_counter_t *) & mp->c;
2230 for (i = 0; i < count; i++)
2232 vec_validate (vam->ip6_nbr_counters[sw_if_index], i);
2233 counter = &vam->ip6_nbr_counters[sw_if_index][i];
2234 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2235 counter->address = ip6;
2236 counter->packets = clib_net_to_host_u64 (v->packets);
2237 counter->bytes = clib_net_to_host_u64 (v->bytes);
2242 static void vl_api_get_first_msg_id_reply_t_handler
2243 (vl_api_get_first_msg_id_reply_t * mp)
2245 vat_main_t *vam = &vat_main;
2246 i32 retval = ntohl (mp->retval);
2248 if (vam->async_mode)
2250 vam->async_errors += (retval < 0);
2254 vam->retval = retval;
2255 vam->result_ready = 1;
2259 errmsg ("first message id %d", ntohs (mp->first_msg_id));
2263 static void vl_api_get_first_msg_id_reply_t_handler_json
2264 (vl_api_get_first_msg_id_reply_t * mp)
2266 vat_main_t *vam = &vat_main;
2267 vat_json_node_t node;
2269 vat_json_init_object (&node);
2270 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2271 vat_json_object_add_uint (&node, "first_msg_id",
2272 (uint) ntohs (mp->first_msg_id));
2274 vat_json_print (vam->ofp, &node);
2275 vat_json_free (&node);
2277 vam->retval = ntohl (mp->retval);
2278 vam->result_ready = 1;
2281 static void vl_api_get_node_graph_reply_t_handler
2282 (vl_api_get_node_graph_reply_t * mp)
2284 vat_main_t *vam = &vat_main;
2285 api_main_t *am = &api_main;
2286 i32 retval = ntohl (mp->retval);
2287 u8 *pvt_copy, *reply;
2292 if (vam->async_mode)
2294 vam->async_errors += (retval < 0);
2298 vam->retval = retval;
2299 vam->result_ready = 1;
2302 /* "Should never happen..." */
2306 reply = (u8 *) (mp->reply_in_shmem);
2307 pvt_copy = vec_dup (reply);
2309 /* Toss the shared-memory original... */
2310 pthread_mutex_lock (&am->vlib_rp->mutex);
2311 oldheap = svm_push_data_heap (am->vlib_rp);
2315 svm_pop_heap (oldheap);
2316 pthread_mutex_unlock (&am->vlib_rp->mutex);
2318 if (vam->graph_nodes)
2320 hash_free (vam->graph_node_index_by_name);
2322 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2324 node = vam->graph_nodes[i];
2325 vec_free (node->name);
2326 vec_free (node->next_nodes);
2329 vec_free (vam->graph_nodes);
2332 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2333 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2334 vec_free (pvt_copy);
2336 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2338 node = vam->graph_nodes[i];
2339 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2343 static void vl_api_get_node_graph_reply_t_handler_json
2344 (vl_api_get_node_graph_reply_t * mp)
2346 vat_main_t *vam = &vat_main;
2347 api_main_t *am = &api_main;
2349 vat_json_node_t node;
2352 /* $$$$ make this real? */
2353 vat_json_init_object (&node);
2354 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2355 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2357 reply = (u8 *) (mp->reply_in_shmem);
2359 /* Toss the shared-memory original... */
2360 pthread_mutex_lock (&am->vlib_rp->mutex);
2361 oldheap = svm_push_data_heap (am->vlib_rp);
2365 svm_pop_heap (oldheap);
2366 pthread_mutex_unlock (&am->vlib_rp->mutex);
2368 vat_json_print (vam->ofp, &node);
2369 vat_json_free (&node);
2371 vam->retval = ntohl (mp->retval);
2372 vam->result_ready = 1;
2376 vl_api_one_locator_details_t_handler (vl_api_one_locator_details_t * mp)
2378 vat_main_t *vam = &vat_main;
2383 s = format (s, "%=16d%=16d%=16d",
2384 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2388 s = format (s, "%=16U%=16d%=16d",
2389 mp->is_ipv6 ? format_ip6_address :
2391 mp->ip_address, mp->priority, mp->weight);
2394 print (vam->ofp, "%v", s);
2399 vl_api_one_locator_details_t_handler_json (vl_api_one_locator_details_t * mp)
2401 vat_main_t *vam = &vat_main;
2402 vat_json_node_t *node = NULL;
2403 struct in6_addr ip6;
2406 if (VAT_JSON_ARRAY != vam->json_tree.type)
2408 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2409 vat_json_init_array (&vam->json_tree);
2411 node = vat_json_array_add (&vam->json_tree);
2412 vat_json_init_object (node);
2414 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2415 vat_json_object_add_uint (node, "priority", mp->priority);
2416 vat_json_object_add_uint (node, "weight", mp->weight);
2419 vat_json_object_add_uint (node, "sw_if_index",
2420 clib_net_to_host_u32 (mp->sw_if_index));
2425 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2426 vat_json_object_add_ip6 (node, "address", ip6);
2430 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2431 vat_json_object_add_ip4 (node, "address", ip4);
2437 vl_api_one_locator_set_details_t_handler (vl_api_one_locator_set_details_t *
2440 vat_main_t *vam = &vat_main;
2443 ls_name = format (0, "%s", mp->ls_name);
2445 print (vam->ofp, "%=10d%=15v", clib_net_to_host_u32 (mp->ls_index),
2451 vl_api_one_locator_set_details_t_handler_json
2452 (vl_api_one_locator_set_details_t * mp)
2454 vat_main_t *vam = &vat_main;
2455 vat_json_node_t *node = 0;
2458 ls_name = format (0, "%s", mp->ls_name);
2459 vec_add1 (ls_name, 0);
2461 if (VAT_JSON_ARRAY != vam->json_tree.type)
2463 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2464 vat_json_init_array (&vam->json_tree);
2466 node = vat_json_array_add (&vam->json_tree);
2468 vat_json_init_object (node);
2469 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2470 vat_json_object_add_uint (node, "ls_index",
2471 clib_net_to_host_u32 (mp->ls_index));
2476 format_lisp_flat_eid (u8 * s, va_list * args)
2478 u32 type = va_arg (*args, u32);
2479 u8 *eid = va_arg (*args, u8 *);
2480 u32 eid_len = va_arg (*args, u32);
2485 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
2487 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
2489 return format (s, "%U", format_ethernet_address, eid);
2495 format_lisp_eid_vat (u8 * s, va_list * args)
2497 u32 type = va_arg (*args, u32);
2498 u8 *eid = va_arg (*args, u8 *);
2499 u32 eid_len = va_arg (*args, u32);
2500 u8 *seid = va_arg (*args, u8 *);
2501 u32 seid_len = va_arg (*args, u32);
2502 u32 is_src_dst = va_arg (*args, u32);
2505 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
2507 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
2513 vl_api_one_eid_table_details_t_handler (vl_api_one_eid_table_details_t * mp)
2515 vat_main_t *vam = &vat_main;
2516 u8 *s = 0, *eid = 0;
2518 if (~0 == mp->locator_set_index)
2519 s = format (0, "action: %d", mp->action);
2521 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
2523 eid = format (0, "%U", format_lisp_eid_vat,
2527 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2530 print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
2531 clib_net_to_host_u32 (mp->vni),
2533 mp->is_local ? "local" : "remote",
2534 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
2535 clib_net_to_host_u16 (mp->key_id), mp->key);
2542 vl_api_one_eid_table_details_t_handler_json (vl_api_one_eid_table_details_t
2545 vat_main_t *vam = &vat_main;
2546 vat_json_node_t *node = 0;
2549 if (VAT_JSON_ARRAY != vam->json_tree.type)
2551 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2552 vat_json_init_array (&vam->json_tree);
2554 node = vat_json_array_add (&vam->json_tree);
2556 vat_json_init_object (node);
2557 if (~0 == mp->locator_set_index)
2558 vat_json_object_add_uint (node, "action", mp->action);
2560 vat_json_object_add_uint (node, "locator_set_index",
2561 clib_net_to_host_u32 (mp->locator_set_index));
2563 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
2564 eid = format (0, "%U", format_lisp_eid_vat,
2568 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2570 vat_json_object_add_string_copy (node, "eid", eid);
2571 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2572 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
2573 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
2577 vat_json_object_add_uint (node, "key_id",
2578 clib_net_to_host_u16 (mp->key_id));
2579 vat_json_object_add_string_copy (node, "key", mp->key);
2585 vl_api_one_eid_table_map_details_t_handler
2586 (vl_api_one_eid_table_map_details_t * mp)
2588 vat_main_t *vam = &vat_main;
2590 u8 *line = format (0, "%=10d%=10d",
2591 clib_net_to_host_u32 (mp->vni),
2592 clib_net_to_host_u32 (mp->dp_table));
2593 print (vam->ofp, "%v", line);
2598 vl_api_one_eid_table_map_details_t_handler_json
2599 (vl_api_one_eid_table_map_details_t * mp)
2601 vat_main_t *vam = &vat_main;
2602 vat_json_node_t *node = NULL;
2604 if (VAT_JSON_ARRAY != vam->json_tree.type)
2606 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2607 vat_json_init_array (&vam->json_tree);
2609 node = vat_json_array_add (&vam->json_tree);
2610 vat_json_init_object (node);
2611 vat_json_object_add_uint (node, "dp_table",
2612 clib_net_to_host_u32 (mp->dp_table));
2613 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2617 vl_api_one_eid_table_vni_details_t_handler
2618 (vl_api_one_eid_table_vni_details_t * mp)
2620 vat_main_t *vam = &vat_main;
2622 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
2623 print (vam->ofp, "%v", line);
2628 vl_api_one_eid_table_vni_details_t_handler_json
2629 (vl_api_one_eid_table_vni_details_t * mp)
2631 vat_main_t *vam = &vat_main;
2632 vat_json_node_t *node = NULL;
2634 if (VAT_JSON_ARRAY != vam->json_tree.type)
2636 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2637 vat_json_init_array (&vam->json_tree);
2639 node = vat_json_array_add (&vam->json_tree);
2640 vat_json_init_object (node);
2641 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2645 vl_api_show_one_map_register_state_reply_t_handler
2646 (vl_api_show_one_map_register_state_reply_t * mp)
2648 vat_main_t *vam = &vat_main;
2649 int retval = clib_net_to_host_u32 (mp->retval);
2651 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
2653 vam->retval = retval;
2654 vam->result_ready = 1;
2658 vl_api_show_one_map_register_state_reply_t_handler_json
2659 (vl_api_show_one_map_register_state_reply_t * mp)
2661 vat_main_t *vam = &vat_main;
2662 vat_json_node_t _node, *node = &_node;
2663 int retval = clib_net_to_host_u32 (mp->retval);
2665 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
2667 vat_json_init_object (node);
2668 vat_json_object_add_string_copy (node, "state", s);
2670 vat_json_print (vam->ofp, node);
2671 vat_json_free (node);
2673 vam->retval = retval;
2674 vam->result_ready = 1;
2679 vl_api_show_one_rloc_probe_state_reply_t_handler
2680 (vl_api_show_one_rloc_probe_state_reply_t * mp)
2682 vat_main_t *vam = &vat_main;
2683 int retval = clib_net_to_host_u32 (mp->retval);
2688 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
2690 vam->retval = retval;
2691 vam->result_ready = 1;
2695 vl_api_show_one_rloc_probe_state_reply_t_handler_json
2696 (vl_api_show_one_rloc_probe_state_reply_t * mp)
2698 vat_main_t *vam = &vat_main;
2699 vat_json_node_t _node, *node = &_node;
2700 int retval = clib_net_to_host_u32 (mp->retval);
2702 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
2703 vat_json_init_object (node);
2704 vat_json_object_add_string_copy (node, "state", s);
2706 vat_json_print (vam->ofp, node);
2707 vat_json_free (node);
2709 vam->retval = retval;
2710 vam->result_ready = 1;
2715 api_gpe_fwd_entry_net_to_host (vl_api_gpe_fwd_entry_t * e)
2717 e->dp_table = clib_net_to_host_u32 (e->dp_table);
2718 e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
2722 gpe_fwd_entries_get_reply_t_net_to_host
2723 (vl_api_gpe_fwd_entries_get_reply_t * mp)
2727 mp->count = clib_net_to_host_u32 (mp->count);
2728 for (i = 0; i < mp->count; i++)
2730 api_gpe_fwd_entry_net_to_host (&mp->entries[i]);
2735 format_gpe_encap_mode (u8 * s, va_list * args)
2737 u32 mode = va_arg (*args, u32);
2742 return format (s, "lisp");
2744 return format (s, "vxlan");
2750 vl_api_gpe_get_encap_mode_reply_t_handler
2751 (vl_api_gpe_get_encap_mode_reply_t * mp)
2753 vat_main_t *vam = &vat_main;
2755 print (vam->ofp, "gpe mode: %U", format_gpe_encap_mode, mp->encap_mode);
2756 vam->retval = ntohl (mp->retval);
2757 vam->result_ready = 1;
2761 vl_api_gpe_get_encap_mode_reply_t_handler_json
2762 (vl_api_gpe_get_encap_mode_reply_t * mp)
2764 vat_main_t *vam = &vat_main;
2765 vat_json_node_t node;
2767 u8 *encap_mode = format (0, "%U", format_gpe_encap_mode, mp->encap_mode);
2768 vec_add1 (encap_mode, 0);
2770 vat_json_init_object (&node);
2771 vat_json_object_add_string_copy (&node, "gpe_mode", encap_mode);
2773 vec_free (encap_mode);
2774 vat_json_print (vam->ofp, &node);
2775 vat_json_free (&node);
2777 vam->retval = ntohl (mp->retval);
2778 vam->result_ready = 1;
2782 vl_api_gpe_fwd_entry_path_details_t_handler
2783 (vl_api_gpe_fwd_entry_path_details_t * mp)
2785 vat_main_t *vam = &vat_main;
2786 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
2788 if (mp->lcl_loc.is_ip4)
2789 format_ip_address_fcn = format_ip4_address;
2791 format_ip_address_fcn = format_ip6_address;
2793 print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
2794 format_ip_address_fcn, &mp->lcl_loc,
2795 format_ip_address_fcn, &mp->rmt_loc);
2799 lisp_fill_locator_node (vat_json_node_t * n, vl_api_gpe_locator_t * loc)
2801 struct in6_addr ip6;
2806 clib_memcpy (&ip4, loc->addr, sizeof (ip4));
2807 vat_json_object_add_ip4 (n, "address", ip4);
2811 clib_memcpy (&ip6, loc->addr, sizeof (ip6));
2812 vat_json_object_add_ip6 (n, "address", ip6);
2814 vat_json_object_add_uint (n, "weight", loc->weight);
2818 vl_api_gpe_fwd_entry_path_details_t_handler_json
2819 (vl_api_gpe_fwd_entry_path_details_t * mp)
2821 vat_main_t *vam = &vat_main;
2822 vat_json_node_t *node = NULL;
2823 vat_json_node_t *loc_node;
2825 if (VAT_JSON_ARRAY != vam->json_tree.type)
2827 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2828 vat_json_init_array (&vam->json_tree);
2830 node = vat_json_array_add (&vam->json_tree);
2831 vat_json_init_object (node);
2833 loc_node = vat_json_object_add (node, "local_locator");
2834 vat_json_init_object (loc_node);
2835 lisp_fill_locator_node (loc_node, &mp->lcl_loc);
2837 loc_node = vat_json_object_add (node, "remote_locator");
2838 vat_json_init_object (loc_node);
2839 lisp_fill_locator_node (loc_node, &mp->rmt_loc);
2843 vl_api_gpe_fwd_entries_get_reply_t_handler
2844 (vl_api_gpe_fwd_entries_get_reply_t * mp)
2846 vat_main_t *vam = &vat_main;
2848 int retval = clib_net_to_host_u32 (mp->retval);
2849 vl_api_gpe_fwd_entry_t *e;
2854 gpe_fwd_entries_get_reply_t_net_to_host (mp);
2856 for (i = 0; i < mp->count; i++)
2858 e = &mp->entries[i];
2859 print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
2860 format_lisp_flat_eid, e->eid_type, e->leid, e->leid_prefix_len,
2861 format_lisp_flat_eid, e->eid_type, e->reid, e->reid_prefix_len);
2865 vam->retval = retval;
2866 vam->result_ready = 1;
2870 vl_api_gpe_fwd_entries_get_reply_t_handler_json
2871 (vl_api_gpe_fwd_entries_get_reply_t * mp)
2874 vat_main_t *vam = &vat_main;
2875 vat_json_node_t *e = 0, root;
2877 int retval = clib_net_to_host_u32 (mp->retval);
2878 vl_api_gpe_fwd_entry_t *fwd;
2883 gpe_fwd_entries_get_reply_t_net_to_host (mp);
2884 vat_json_init_array (&root);
2886 for (i = 0; i < mp->count; i++)
2888 e = vat_json_array_add (&root);
2889 fwd = &mp->entries[i];
2891 vat_json_init_object (e);
2892 vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
2893 vat_json_object_add_int (e, "dp_table", fwd->dp_table);
2895 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->leid,
2896 fwd->leid_prefix_len);
2898 vat_json_object_add_string_copy (e, "leid", s);
2901 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->reid,
2902 fwd->reid_prefix_len);
2904 vat_json_object_add_string_copy (e, "reid", s);
2908 vat_json_print (vam->ofp, &root);
2909 vat_json_free (&root);
2912 vam->retval = retval;
2913 vam->result_ready = 1;
2917 vl_api_one_adjacencies_get_reply_t_handler
2918 (vl_api_one_adjacencies_get_reply_t * mp)
2920 vat_main_t *vam = &vat_main;
2922 int retval = clib_net_to_host_u32 (mp->retval);
2923 vl_api_one_adjacency_t *a;
2928 n = clib_net_to_host_u32 (mp->count);
2930 for (i = 0; i < n; i++)
2932 a = &mp->adjacencies[i];
2933 print (vam->ofp, "%U %40U",
2934 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
2935 format_lisp_flat_eid, a->eid_type, a->reid, a->reid_prefix_len);
2939 vam->retval = retval;
2940 vam->result_ready = 1;
2944 vl_api_one_adjacencies_get_reply_t_handler_json
2945 (vl_api_one_adjacencies_get_reply_t * mp)
2948 vat_main_t *vam = &vat_main;
2949 vat_json_node_t *e = 0, root;
2951 int retval = clib_net_to_host_u32 (mp->retval);
2952 vl_api_one_adjacency_t *a;
2957 n = clib_net_to_host_u32 (mp->count);
2958 vat_json_init_array (&root);
2960 for (i = 0; i < n; i++)
2962 e = vat_json_array_add (&root);
2963 a = &mp->adjacencies[i];
2965 vat_json_init_object (e);
2966 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
2967 a->leid_prefix_len);
2969 vat_json_object_add_string_copy (e, "leid", s);
2972 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
2973 a->reid_prefix_len);
2975 vat_json_object_add_string_copy (e, "reid", s);
2979 vat_json_print (vam->ofp, &root);
2980 vat_json_free (&root);
2983 vam->retval = retval;
2984 vam->result_ready = 1;
2988 vl_api_one_map_server_details_t_handler (vl_api_one_map_server_details_t * mp)
2990 vat_main_t *vam = &vat_main;
2992 print (vam->ofp, "%=20U",
2993 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2998 vl_api_one_map_server_details_t_handler_json
2999 (vl_api_one_map_server_details_t * mp)
3001 vat_main_t *vam = &vat_main;
3002 vat_json_node_t *node = NULL;
3003 struct in6_addr ip6;
3006 if (VAT_JSON_ARRAY != vam->json_tree.type)
3008 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3009 vat_json_init_array (&vam->json_tree);
3011 node = vat_json_array_add (&vam->json_tree);
3013 vat_json_init_object (node);
3016 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
3017 vat_json_object_add_ip6 (node, "map-server", ip6);
3021 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
3022 vat_json_object_add_ip4 (node, "map-server", ip4);
3027 vl_api_one_map_resolver_details_t_handler (vl_api_one_map_resolver_details_t
3030 vat_main_t *vam = &vat_main;
3032 print (vam->ofp, "%=20U",
3033 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
3038 vl_api_one_map_resolver_details_t_handler_json
3039 (vl_api_one_map_resolver_details_t * mp)
3041 vat_main_t *vam = &vat_main;
3042 vat_json_node_t *node = NULL;
3043 struct in6_addr ip6;
3046 if (VAT_JSON_ARRAY != vam->json_tree.type)
3048 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3049 vat_json_init_array (&vam->json_tree);
3051 node = vat_json_array_add (&vam->json_tree);
3053 vat_json_init_object (node);
3056 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
3057 vat_json_object_add_ip6 (node, "map resolver", ip6);
3061 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
3062 vat_json_object_add_ip4 (node, "map resolver", ip4);
3067 vl_api_show_one_status_reply_t_handler (vl_api_show_one_status_reply_t * mp)
3069 vat_main_t *vam = &vat_main;
3070 i32 retval = ntohl (mp->retval);
3074 print (vam->ofp, "feature: %s\ngpe: %s",
3075 mp->feature_status ? "enabled" : "disabled",
3076 mp->gpe_status ? "enabled" : "disabled");
3079 vam->retval = retval;
3080 vam->result_ready = 1;
3084 vl_api_show_one_status_reply_t_handler_json
3085 (vl_api_show_one_status_reply_t * mp)
3087 vat_main_t *vam = &vat_main;
3088 vat_json_node_t node;
3089 u8 *gpe_status = NULL;
3090 u8 *feature_status = NULL;
3092 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
3093 feature_status = format (0, "%s",
3094 mp->feature_status ? "enabled" : "disabled");
3095 vec_add1 (gpe_status, 0);
3096 vec_add1 (feature_status, 0);
3098 vat_json_init_object (&node);
3099 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
3100 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
3102 vec_free (gpe_status);
3103 vec_free (feature_status);
3105 vat_json_print (vam->ofp, &node);
3106 vat_json_free (&node);
3108 vam->retval = ntohl (mp->retval);
3109 vam->result_ready = 1;
3113 vl_api_one_get_map_request_itr_rlocs_reply_t_handler
3114 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
3116 vat_main_t *vam = &vat_main;
3117 i32 retval = ntohl (mp->retval);
3121 print (vam->ofp, "%=20s", mp->locator_set_name);
3124 vam->retval = retval;
3125 vam->result_ready = 1;
3129 vl_api_one_get_map_request_itr_rlocs_reply_t_handler_json
3130 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
3132 vat_main_t *vam = &vat_main;
3133 vat_json_node_t *node = NULL;
3135 if (VAT_JSON_ARRAY != vam->json_tree.type)
3137 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3138 vat_json_init_array (&vam->json_tree);
3140 node = vat_json_array_add (&vam->json_tree);
3142 vat_json_init_object (node);
3143 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
3145 vat_json_print (vam->ofp, node);
3146 vat_json_free (node);
3148 vam->retval = ntohl (mp->retval);
3149 vam->result_ready = 1;
3153 format_lisp_map_request_mode (u8 * s, va_list * args)
3155 u32 mode = va_arg (*args, u32);
3160 return format (0, "dst-only");
3162 return format (0, "src-dst");
3168 vl_api_show_one_map_request_mode_reply_t_handler
3169 (vl_api_show_one_map_request_mode_reply_t * mp)
3171 vat_main_t *vam = &vat_main;
3172 i32 retval = ntohl (mp->retval);
3176 u32 mode = mp->mode;
3177 print (vam->ofp, "map_request_mode: %U",
3178 format_lisp_map_request_mode, mode);
3181 vam->retval = retval;
3182 vam->result_ready = 1;
3186 vl_api_show_one_map_request_mode_reply_t_handler_json
3187 (vl_api_show_one_map_request_mode_reply_t * mp)
3189 vat_main_t *vam = &vat_main;
3190 vat_json_node_t node;
3195 s = format (0, "%U", format_lisp_map_request_mode, mode);
3198 vat_json_init_object (&node);
3199 vat_json_object_add_string_copy (&node, "map_request_mode", s);
3200 vat_json_print (vam->ofp, &node);
3201 vat_json_free (&node);
3204 vam->retval = ntohl (mp->retval);
3205 vam->result_ready = 1;
3209 vl_api_show_one_pitr_reply_t_handler (vl_api_show_one_pitr_reply_t * mp)
3211 vat_main_t *vam = &vat_main;
3212 i32 retval = ntohl (mp->retval);
3216 print (vam->ofp, "%-20s%-16s",
3217 mp->status ? "enabled" : "disabled",
3218 mp->status ? (char *) mp->locator_set_name : "");
3221 vam->retval = retval;
3222 vam->result_ready = 1;
3226 vl_api_show_one_pitr_reply_t_handler_json (vl_api_show_one_pitr_reply_t * mp)
3228 vat_main_t *vam = &vat_main;
3229 vat_json_node_t node;
3232 status = format (0, "%s", mp->status ? "enabled" : "disabled");
3233 vec_add1 (status, 0);
3235 vat_json_init_object (&node);
3236 vat_json_object_add_string_copy (&node, "status", status);
3239 vat_json_object_add_string_copy (&node, "locator_set",
3240 mp->locator_set_name);
3245 vat_json_print (vam->ofp, &node);
3246 vat_json_free (&node);
3248 vam->retval = ntohl (mp->retval);
3249 vam->result_ready = 1;
3253 format_policer_type (u8 * s, va_list * va)
3255 u32 i = va_arg (*va, u32);
3257 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
3258 s = format (s, "1r2c");
3259 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
3260 s = format (s, "1r3c");
3261 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
3262 s = format (s, "2r3c-2698");
3263 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
3264 s = format (s, "2r3c-4115");
3265 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
3266 s = format (s, "2r3c-mef5cf1");
3268 s = format (s, "ILLEGAL");
3273 format_policer_rate_type (u8 * s, va_list * va)
3275 u32 i = va_arg (*va, u32);
3277 if (i == SSE2_QOS_RATE_KBPS)
3278 s = format (s, "kbps");
3279 else if (i == SSE2_QOS_RATE_PPS)
3280 s = format (s, "pps");
3282 s = format (s, "ILLEGAL");
3287 format_policer_round_type (u8 * s, va_list * va)
3289 u32 i = va_arg (*va, u32);
3291 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
3292 s = format (s, "closest");
3293 else if (i == SSE2_QOS_ROUND_TO_UP)
3294 s = format (s, "up");
3295 else if (i == SSE2_QOS_ROUND_TO_DOWN)
3296 s = format (s, "down");
3298 s = format (s, "ILLEGAL");
3303 format_policer_action_type (u8 * s, va_list * va)
3305 u32 i = va_arg (*va, u32);
3307 if (i == SSE2_QOS_ACTION_DROP)
3308 s = format (s, "drop");
3309 else if (i == SSE2_QOS_ACTION_TRANSMIT)
3310 s = format (s, "transmit");
3311 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3312 s = format (s, "mark-and-transmit");
3314 s = format (s, "ILLEGAL");
3319 format_dscp (u8 * s, va_list * va)
3321 u32 i = va_arg (*va, u32);
3326 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
3330 return format (s, "ILLEGAL");
3332 s = format (s, "%s", t);
3337 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
3339 vat_main_t *vam = &vat_main;
3340 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
3342 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3343 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
3345 conform_dscp_str = format (0, "");
3347 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3348 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
3350 exceed_dscp_str = format (0, "");
3352 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3353 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
3355 violate_dscp_str = format (0, "");
3357 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
3358 "rate type %U, round type %U, %s rate, %s color-aware, "
3359 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
3360 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
3361 "conform action %U%s, exceed action %U%s, violate action %U%s",
3363 format_policer_type, mp->type,
3366 clib_net_to_host_u64 (mp->cb),
3367 clib_net_to_host_u64 (mp->eb),
3368 format_policer_rate_type, mp->rate_type,
3369 format_policer_round_type, mp->round_type,
3370 mp->single_rate ? "single" : "dual",
3371 mp->color_aware ? "is" : "not",
3372 ntohl (mp->cir_tokens_per_period),
3373 ntohl (mp->pir_tokens_per_period),
3375 ntohl (mp->current_limit),
3376 ntohl (mp->current_bucket),
3377 ntohl (mp->extended_limit),
3378 ntohl (mp->extended_bucket),
3379 clib_net_to_host_u64 (mp->last_update_time),
3380 format_policer_action_type, mp->conform_action_type,
3382 format_policer_action_type, mp->exceed_action_type,
3384 format_policer_action_type, mp->violate_action_type,
3387 vec_free (conform_dscp_str);
3388 vec_free (exceed_dscp_str);
3389 vec_free (violate_dscp_str);
3392 static void vl_api_policer_details_t_handler_json
3393 (vl_api_policer_details_t * mp)
3395 vat_main_t *vam = &vat_main;
3396 vat_json_node_t *node;
3397 u8 *rate_type_str, *round_type_str, *type_str;
3398 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
3400 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
3402 format (0, "%U", format_policer_round_type, mp->round_type);
3403 type_str = format (0, "%U", format_policer_type, mp->type);
3404 conform_action_str = format (0, "%U", format_policer_action_type,
3405 mp->conform_action_type);
3406 exceed_action_str = format (0, "%U", format_policer_action_type,
3407 mp->exceed_action_type);
3408 violate_action_str = format (0, "%U", format_policer_action_type,
3409 mp->violate_action_type);
3411 if (VAT_JSON_ARRAY != vam->json_tree.type)
3413 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3414 vat_json_init_array (&vam->json_tree);
3416 node = vat_json_array_add (&vam->json_tree);
3418 vat_json_init_object (node);
3419 vat_json_object_add_string_copy (node, "name", mp->name);
3420 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
3421 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
3422 vat_json_object_add_uint (node, "cb", ntohl (mp->cb));
3423 vat_json_object_add_uint (node, "eb", ntohl (mp->eb));
3424 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
3425 vat_json_object_add_string_copy (node, "round_type", round_type_str);
3426 vat_json_object_add_string_copy (node, "type", type_str);
3427 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
3428 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
3429 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
3430 vat_json_object_add_uint (node, "cir_tokens_per_period",
3431 ntohl (mp->cir_tokens_per_period));
3432 vat_json_object_add_uint (node, "eir_tokens_per_period",
3433 ntohl (mp->pir_tokens_per_period));
3434 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
3435 vat_json_object_add_uint (node, "current_bucket",
3436 ntohl (mp->current_bucket));
3437 vat_json_object_add_uint (node, "extended_limit",
3438 ntohl (mp->extended_limit));
3439 vat_json_object_add_uint (node, "extended_bucket",
3440 ntohl (mp->extended_bucket));
3441 vat_json_object_add_uint (node, "last_update_time",
3442 ntohl (mp->last_update_time));
3443 vat_json_object_add_string_copy (node, "conform_action",
3444 conform_action_str);
3445 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3447 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
3448 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
3449 vec_free (dscp_str);
3451 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
3452 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3454 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
3455 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
3456 vec_free (dscp_str);
3458 vat_json_object_add_string_copy (node, "violate_action",
3459 violate_action_str);
3460 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3462 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
3463 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
3464 vec_free (dscp_str);
3467 vec_free (rate_type_str);
3468 vec_free (round_type_str);
3469 vec_free (type_str);
3470 vec_free (conform_action_str);
3471 vec_free (exceed_action_str);
3472 vec_free (violate_action_str);
3476 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
3479 vat_main_t *vam = &vat_main;
3480 int i, count = ntohl (mp->count);
3483 print (vam->ofp, "classify table ids (%d) : ", count);
3484 for (i = 0; i < count; i++)
3486 print (vam->ofp, "%d", ntohl (mp->ids[i]));
3487 print (vam->ofp, (i < count - 1) ? "," : "");
3489 vam->retval = ntohl (mp->retval);
3490 vam->result_ready = 1;
3494 vl_api_classify_table_ids_reply_t_handler_json
3495 (vl_api_classify_table_ids_reply_t * mp)
3497 vat_main_t *vam = &vat_main;
3498 int i, count = ntohl (mp->count);
3502 vat_json_node_t node;
3504 vat_json_init_object (&node);
3505 for (i = 0; i < count; i++)
3507 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
3509 vat_json_print (vam->ofp, &node);
3510 vat_json_free (&node);
3512 vam->retval = ntohl (mp->retval);
3513 vam->result_ready = 1;
3517 vl_api_classify_table_by_interface_reply_t_handler
3518 (vl_api_classify_table_by_interface_reply_t * mp)
3520 vat_main_t *vam = &vat_main;
3523 table_id = ntohl (mp->l2_table_id);
3525 print (vam->ofp, "l2 table id : %d", table_id);
3527 print (vam->ofp, "l2 table id : No input ACL tables configured");
3528 table_id = ntohl (mp->ip4_table_id);
3530 print (vam->ofp, "ip4 table id : %d", table_id);
3532 print (vam->ofp, "ip4 table id : No input ACL tables configured");
3533 table_id = ntohl (mp->ip6_table_id);
3535 print (vam->ofp, "ip6 table id : %d", table_id);
3537 print (vam->ofp, "ip6 table id : No input ACL tables configured");
3538 vam->retval = ntohl (mp->retval);
3539 vam->result_ready = 1;
3543 vl_api_classify_table_by_interface_reply_t_handler_json
3544 (vl_api_classify_table_by_interface_reply_t * mp)
3546 vat_main_t *vam = &vat_main;
3547 vat_json_node_t node;
3549 vat_json_init_object (&node);
3551 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
3552 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
3553 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
3555 vat_json_print (vam->ofp, &node);
3556 vat_json_free (&node);
3558 vam->retval = ntohl (mp->retval);
3559 vam->result_ready = 1;
3562 static void vl_api_policer_add_del_reply_t_handler
3563 (vl_api_policer_add_del_reply_t * mp)
3565 vat_main_t *vam = &vat_main;
3566 i32 retval = ntohl (mp->retval);
3567 if (vam->async_mode)
3569 vam->async_errors += (retval < 0);
3573 vam->retval = retval;
3574 vam->result_ready = 1;
3575 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
3577 * Note: this is just barely thread-safe, depends on
3578 * the main thread spinning waiting for an answer...
3580 errmsg ("policer index %d", ntohl (mp->policer_index));
3584 static void vl_api_policer_add_del_reply_t_handler_json
3585 (vl_api_policer_add_del_reply_t * mp)
3587 vat_main_t *vam = &vat_main;
3588 vat_json_node_t node;
3590 vat_json_init_object (&node);
3591 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3592 vat_json_object_add_uint (&node, "policer_index",
3593 ntohl (mp->policer_index));
3595 vat_json_print (vam->ofp, &node);
3596 vat_json_free (&node);
3598 vam->retval = ntohl (mp->retval);
3599 vam->result_ready = 1;
3602 /* Format hex dump. */
3604 format_hex_bytes (u8 * s, va_list * va)
3606 u8 *bytes = va_arg (*va, u8 *);
3607 int n_bytes = va_arg (*va, int);
3610 /* Print short or long form depending on byte count. */
3611 uword short_form = n_bytes <= 32;
3612 uword indent = format_get_indent (s);
3617 for (i = 0; i < n_bytes; i++)
3619 if (!short_form && (i % 32) == 0)
3620 s = format (s, "%08x: ", i);
3621 s = format (s, "%02x", bytes[i]);
3622 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
3623 s = format (s, "\n%U", format_white_space, indent);
3630 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
3633 vat_main_t *vam = &vat_main;
3634 i32 retval = ntohl (mp->retval);
3637 print (vam->ofp, "classify table info :");
3638 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
3639 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
3640 ntohl (mp->miss_next_index));
3641 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
3642 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
3643 ntohl (mp->match_n_vectors));
3644 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
3645 ntohl (mp->mask_length));
3647 vam->retval = retval;
3648 vam->result_ready = 1;
3652 vl_api_classify_table_info_reply_t_handler_json
3653 (vl_api_classify_table_info_reply_t * mp)
3655 vat_main_t *vam = &vat_main;
3656 vat_json_node_t node;
3658 i32 retval = ntohl (mp->retval);
3661 vat_json_init_object (&node);
3663 vat_json_object_add_int (&node, "sessions",
3664 ntohl (mp->active_sessions));
3665 vat_json_object_add_int (&node, "nexttbl",
3666 ntohl (mp->next_table_index));
3667 vat_json_object_add_int (&node, "nextnode",
3668 ntohl (mp->miss_next_index));
3669 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
3670 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
3671 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
3672 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
3673 ntohl (mp->mask_length), 0);
3674 vat_json_object_add_string_copy (&node, "mask", s);
3676 vat_json_print (vam->ofp, &node);
3677 vat_json_free (&node);
3679 vam->retval = ntohl (mp->retval);
3680 vam->result_ready = 1;
3684 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
3687 vat_main_t *vam = &vat_main;
3689 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
3690 ntohl (mp->hit_next_index), ntohl (mp->advance),
3691 ntohl (mp->opaque_index));
3692 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
3693 ntohl (mp->match_length));
3697 vl_api_classify_session_details_t_handler_json
3698 (vl_api_classify_session_details_t * mp)
3700 vat_main_t *vam = &vat_main;
3701 vat_json_node_t *node = NULL;
3703 if (VAT_JSON_ARRAY != vam->json_tree.type)
3705 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3706 vat_json_init_array (&vam->json_tree);
3708 node = vat_json_array_add (&vam->json_tree);
3710 vat_json_init_object (node);
3711 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
3712 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
3713 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
3715 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
3717 vat_json_object_add_string_copy (node, "match", s);
3720 static void vl_api_pg_create_interface_reply_t_handler
3721 (vl_api_pg_create_interface_reply_t * mp)
3723 vat_main_t *vam = &vat_main;
3725 vam->retval = ntohl (mp->retval);
3726 vam->result_ready = 1;
3729 static void vl_api_pg_create_interface_reply_t_handler_json
3730 (vl_api_pg_create_interface_reply_t * mp)
3732 vat_main_t *vam = &vat_main;
3733 vat_json_node_t node;
3735 i32 retval = ntohl (mp->retval);
3738 vat_json_init_object (&node);
3740 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
3742 vat_json_print (vam->ofp, &node);
3743 vat_json_free (&node);
3745 vam->retval = ntohl (mp->retval);
3746 vam->result_ready = 1;
3749 static void vl_api_policer_classify_details_t_handler
3750 (vl_api_policer_classify_details_t * mp)
3752 vat_main_t *vam = &vat_main;
3754 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
3755 ntohl (mp->table_index));
3758 static void vl_api_policer_classify_details_t_handler_json
3759 (vl_api_policer_classify_details_t * mp)
3761 vat_main_t *vam = &vat_main;
3762 vat_json_node_t *node;
3764 if (VAT_JSON_ARRAY != vam->json_tree.type)
3766 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3767 vat_json_init_array (&vam->json_tree);
3769 node = vat_json_array_add (&vam->json_tree);
3771 vat_json_init_object (node);
3772 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
3773 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
3776 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler
3777 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3779 vat_main_t *vam = &vat_main;
3780 i32 retval = ntohl (mp->retval);
3781 if (vam->async_mode)
3783 vam->async_errors += (retval < 0);
3787 vam->retval = retval;
3788 vam->sw_if_index = ntohl (mp->sw_if_index);
3789 vam->result_ready = 1;
3793 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler_json
3794 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3796 vat_main_t *vam = &vat_main;
3797 vat_json_node_t node;
3799 vat_json_init_object (&node);
3800 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3801 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
3803 vat_json_print (vam->ofp, &node);
3804 vat_json_free (&node);
3806 vam->retval = ntohl (mp->retval);
3807 vam->result_ready = 1;
3810 static void vl_api_flow_classify_details_t_handler
3811 (vl_api_flow_classify_details_t * mp)
3813 vat_main_t *vam = &vat_main;
3815 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
3816 ntohl (mp->table_index));
3819 static void vl_api_flow_classify_details_t_handler_json
3820 (vl_api_flow_classify_details_t * mp)
3822 vat_main_t *vam = &vat_main;
3823 vat_json_node_t *node;
3825 if (VAT_JSON_ARRAY != vam->json_tree.type)
3827 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3828 vat_json_init_array (&vam->json_tree);
3830 node = vat_json_array_add (&vam->json_tree);
3832 vat_json_init_object (node);
3833 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
3834 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
3839 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
3840 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
3841 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
3842 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
3843 #define vl_api_vnet_ip4_nbr_counters_t_endian vl_noop_handler
3844 #define vl_api_vnet_ip4_nbr_counters_t_print vl_noop_handler
3845 #define vl_api_vnet_ip6_nbr_counters_t_endian vl_noop_handler
3846 #define vl_api_vnet_ip6_nbr_counters_t_print vl_noop_handler
3847 #define vl_api_one_adjacencies_get_reply_t_endian vl_noop_handler
3848 #define vl_api_one_adjacencies_get_reply_t_print vl_noop_handler
3851 * Generate boilerplate reply handlers, which
3852 * dig the return value out of the xxx_reply_t API message,
3853 * stick it into vam->retval, and set vam->result_ready
3855 * Could also do this by pointing N message decode slots at
3856 * a single function, but that could break in subtle ways.
3859 #define foreach_standard_reply_retval_handler \
3860 _(sw_interface_set_flags_reply) \
3861 _(sw_interface_add_del_address_reply) \
3862 _(sw_interface_set_table_reply) \
3863 _(sw_interface_set_mpls_enable_reply) \
3864 _(sw_interface_set_vpath_reply) \
3865 _(sw_interface_set_vxlan_bypass_reply) \
3866 _(sw_interface_set_l2_bridge_reply) \
3867 _(bridge_domain_add_del_reply) \
3868 _(sw_interface_set_l2_xconnect_reply) \
3869 _(l2fib_add_del_reply) \
3870 _(ip_add_del_route_reply) \
3871 _(ip_mroute_add_del_reply) \
3872 _(mpls_route_add_del_reply) \
3873 _(mpls_ip_bind_unbind_reply) \
3874 _(proxy_arp_add_del_reply) \
3875 _(proxy_arp_intfc_enable_disable_reply) \
3876 _(sw_interface_set_unnumbered_reply) \
3877 _(ip_neighbor_add_del_reply) \
3878 _(reset_vrf_reply) \
3879 _(oam_add_del_reply) \
3880 _(reset_fib_reply) \
3881 _(dhcp_proxy_config_reply) \
3882 _(dhcp_proxy_set_vss_reply) \
3883 _(dhcp_client_config_reply) \
3884 _(set_ip_flow_hash_reply) \
3885 _(sw_interface_ip6_enable_disable_reply) \
3886 _(sw_interface_ip6_set_link_local_address_reply) \
3887 _(sw_interface_ip6nd_ra_prefix_reply) \
3888 _(sw_interface_ip6nd_ra_config_reply) \
3889 _(set_arp_neighbor_limit_reply) \
3890 _(l2_patch_add_del_reply) \
3891 _(sr_tunnel_add_del_reply) \
3892 _(sr_policy_add_del_reply) \
3893 _(sr_multicast_map_add_del_reply) \
3894 _(classify_add_del_session_reply) \
3895 _(classify_set_interface_ip_table_reply) \
3896 _(classify_set_interface_l2_tables_reply) \
3897 _(l2tpv3_set_tunnel_cookies_reply) \
3898 _(l2tpv3_interface_enable_disable_reply) \
3899 _(l2tpv3_set_lookup_key_reply) \
3900 _(l2_fib_clear_table_reply) \
3901 _(l2_interface_efp_filter_reply) \
3902 _(l2_interface_vlan_tag_rewrite_reply) \
3903 _(modify_vhost_user_if_reply) \
3904 _(delete_vhost_user_if_reply) \
3905 _(want_ip4_arp_events_reply) \
3906 _(want_ip6_nd_events_reply) \
3907 _(input_acl_set_interface_reply) \
3908 _(ipsec_spd_add_del_reply) \
3909 _(ipsec_interface_add_del_spd_reply) \
3910 _(ipsec_spd_add_del_entry_reply) \
3911 _(ipsec_sad_add_del_entry_reply) \
3912 _(ipsec_sa_set_key_reply) \
3913 _(ikev2_profile_add_del_reply) \
3914 _(ikev2_profile_set_auth_reply) \
3915 _(ikev2_profile_set_id_reply) \
3916 _(ikev2_profile_set_ts_reply) \
3917 _(ikev2_set_local_key_reply) \
3918 _(ikev2_set_responder_reply) \
3919 _(ikev2_set_ike_transforms_reply) \
3920 _(ikev2_set_esp_transforms_reply) \
3921 _(ikev2_set_sa_lifetime_reply) \
3922 _(ikev2_initiate_sa_init_reply) \
3923 _(ikev2_initiate_del_ike_sa_reply) \
3924 _(ikev2_initiate_del_child_sa_reply) \
3925 _(ikev2_initiate_rekey_child_sa_reply) \
3926 _(delete_loopback_reply) \
3927 _(bd_ip_mac_add_del_reply) \
3928 _(map_del_domain_reply) \
3929 _(map_add_del_rule_reply) \
3930 _(want_interface_events_reply) \
3931 _(want_stats_reply) \
3932 _(cop_interface_enable_disable_reply) \
3933 _(cop_whitelist_enable_disable_reply) \
3934 _(sw_interface_clear_stats_reply) \
3935 _(ioam_enable_reply) \
3936 _(ioam_disable_reply) \
3937 _(one_add_del_locator_reply) \
3938 _(one_add_del_local_eid_reply) \
3939 _(one_add_del_remote_mapping_reply) \
3940 _(one_add_del_adjacency_reply) \
3941 _(one_add_del_map_resolver_reply) \
3942 _(one_add_del_map_server_reply) \
3943 _(one_enable_disable_reply) \
3944 _(one_rloc_probe_enable_disable_reply) \
3945 _(one_map_register_enable_disable_reply) \
3946 _(one_pitr_set_locator_set_reply) \
3947 _(one_map_request_mode_reply) \
3948 _(one_add_del_map_request_itr_rlocs_reply) \
3949 _(one_eid_table_add_del_map_reply) \
3950 _(gpe_add_del_fwd_entry_reply) \
3951 _(gpe_enable_disable_reply) \
3952 _(gpe_set_encap_mode_reply) \
3953 _(gpe_add_del_iface_reply) \
3954 _(vxlan_gpe_add_del_tunnel_reply) \
3955 _(af_packet_delete_reply) \
3956 _(policer_classify_set_interface_reply) \
3957 _(netmap_create_reply) \
3958 _(netmap_delete_reply) \
3959 _(set_ipfix_exporter_reply) \
3960 _(set_ipfix_classify_stream_reply) \
3961 _(ipfix_classify_table_add_del_reply) \
3962 _(flow_classify_set_interface_reply) \
3963 _(sw_interface_span_enable_disable_reply) \
3964 _(pg_capture_reply) \
3965 _(pg_enable_disable_reply) \
3966 _(ip_source_and_port_range_check_add_del_reply) \
3967 _(ip_source_and_port_range_check_interface_add_del_reply)\
3968 _(delete_subif_reply) \
3969 _(l2_interface_pbb_tag_rewrite_reply) \
3971 _(feature_enable_disable_reply) \
3972 _(sw_interface_tag_add_del_reply) \
3973 _(sw_interface_set_mtu_reply)
3976 static void vl_api_##n##_t_handler \
3977 (vl_api_##n##_t * mp) \
3979 vat_main_t * vam = &vat_main; \
3980 i32 retval = ntohl(mp->retval); \
3981 if (vam->async_mode) { \
3982 vam->async_errors += (retval < 0); \
3984 vam->retval = retval; \
3985 vam->result_ready = 1; \
3988 foreach_standard_reply_retval_handler;
3992 static void vl_api_##n##_t_handler_json \
3993 (vl_api_##n##_t * mp) \
3995 vat_main_t * vam = &vat_main; \
3996 vat_json_node_t node; \
3997 vat_json_init_object(&node); \
3998 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
3999 vat_json_print(vam->ofp, &node); \
4000 vam->retval = ntohl(mp->retval); \
4001 vam->result_ready = 1; \
4003 foreach_standard_reply_retval_handler;
4007 * Table of message reply handlers, must include boilerplate handlers
4011 #define foreach_vpe_api_reply_msg \
4012 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
4013 _(SW_INTERFACE_DETAILS, sw_interface_details) \
4014 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
4015 _(CONTROL_PING_REPLY, control_ping_reply) \
4016 _(CLI_REPLY, cli_reply) \
4017 _(CLI_INBAND_REPLY, cli_inband_reply) \
4018 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
4019 sw_interface_add_del_address_reply) \
4020 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
4021 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
4022 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
4023 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
4024 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
4025 sw_interface_set_l2_xconnect_reply) \
4026 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
4027 sw_interface_set_l2_bridge_reply) \
4028 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
4029 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
4030 _(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
4031 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
4032 _(L2_FLAGS_REPLY, l2_flags_reply) \
4033 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
4034 _(TAP_CONNECT_REPLY, tap_connect_reply) \
4035 _(TAP_MODIFY_REPLY, tap_modify_reply) \
4036 _(TAP_DELETE_REPLY, tap_delete_reply) \
4037 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
4038 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
4039 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
4040 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
4041 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
4042 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
4043 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
4044 proxy_arp_intfc_enable_disable_reply) \
4045 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
4046 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
4047 sw_interface_set_unnumbered_reply) \
4048 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
4049 _(RESET_VRF_REPLY, reset_vrf_reply) \
4050 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
4051 _(CREATE_SUBIF_REPLY, create_subif_reply) \
4052 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
4053 _(RESET_FIB_REPLY, reset_fib_reply) \
4054 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
4055 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
4056 _(DHCP_PROXY_DETAILS, dhcp_proxy_details) \
4057 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
4058 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
4059 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
4060 sw_interface_ip6_enable_disable_reply) \
4061 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
4062 sw_interface_ip6_set_link_local_address_reply) \
4063 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
4064 sw_interface_ip6nd_ra_prefix_reply) \
4065 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
4066 sw_interface_ip6nd_ra_config_reply) \
4067 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
4068 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
4069 _(SR_TUNNEL_ADD_DEL_REPLY, sr_tunnel_add_del_reply) \
4070 _(SR_POLICY_ADD_DEL_REPLY, sr_policy_add_del_reply) \
4071 _(SR_MULTICAST_MAP_ADD_DEL_REPLY, sr_multicast_map_add_del_reply) \
4072 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
4073 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
4074 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
4075 classify_set_interface_ip_table_reply) \
4076 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
4077 classify_set_interface_l2_tables_reply) \
4078 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
4079 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
4080 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
4081 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
4082 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
4083 l2tpv3_interface_enable_disable_reply) \
4084 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
4085 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
4086 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
4087 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
4088 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
4089 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
4090 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
4091 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
4092 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
4093 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
4094 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
4095 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
4096 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
4097 _(SHOW_VERSION_REPLY, show_version_reply) \
4098 _(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
4099 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
4100 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
4101 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
4102 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
4103 _(IP4_ARP_EVENT, ip4_arp_event) \
4104 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
4105 _(IP6_ND_EVENT, ip6_nd_event) \
4106 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
4107 _(IP_ADDRESS_DETAILS, ip_address_details) \
4108 _(IP_DETAILS, ip_details) \
4109 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
4110 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
4111 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
4112 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
4113 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
4114 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
4115 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
4116 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
4117 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
4118 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
4119 _(IKEV2_SET_RESPONDER_REPLY, ikev2_set_responder_reply) \
4120 _(IKEV2_SET_IKE_TRANSFORMS_REPLY, ikev2_set_ike_transforms_reply) \
4121 _(IKEV2_SET_ESP_TRANSFORMS_REPLY, ikev2_set_esp_transforms_reply) \
4122 _(IKEV2_SET_SA_LIFETIME_REPLY, ikev2_set_sa_lifetime_reply) \
4123 _(IKEV2_INITIATE_SA_INIT_REPLY, ikev2_initiate_sa_init_reply) \
4124 _(IKEV2_INITIATE_DEL_IKE_SA_REPLY, ikev2_initiate_del_ike_sa_reply) \
4125 _(IKEV2_INITIATE_DEL_CHILD_SA_REPLY, ikev2_initiate_del_child_sa_reply) \
4126 _(IKEV2_INITIATE_REKEY_CHILD_SA_REPLY, ikev2_initiate_rekey_child_sa_reply) \
4127 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
4128 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
4129 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
4130 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
4131 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
4132 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
4133 _(MAP_DOMAIN_DETAILS, map_domain_details) \
4134 _(MAP_RULE_DETAILS, map_rule_details) \
4135 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
4136 _(WANT_STATS_REPLY, want_stats_reply) \
4137 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
4138 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
4139 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
4140 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
4141 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
4142 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
4143 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
4144 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
4145 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
4146 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
4147 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
4148 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
4149 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
4150 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
4151 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
4152 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
4153 one_map_register_enable_disable_reply) \
4154 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
4155 one_rloc_probe_enable_disable_reply) \
4156 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
4157 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
4158 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
4159 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
4160 _(ONE_LOCATOR_DETAILS, one_locator_details) \
4161 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
4162 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
4163 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
4164 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
4165 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
4166 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
4167 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
4168 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
4169 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
4170 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
4171 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
4172 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
4173 _(GPE_FWD_ENTRY_PATH_DETAILS, \
4174 gpe_fwd_entry_path_details) \
4175 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
4176 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
4177 one_add_del_map_request_itr_rlocs_reply) \
4178 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
4179 one_get_map_request_itr_rlocs_reply) \
4180 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
4181 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
4182 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
4183 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
4184 show_one_map_register_state_reply) \
4185 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
4186 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
4187 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
4188 _(POLICER_DETAILS, policer_details) \
4189 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
4190 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
4191 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
4192 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
4193 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
4194 _(MPLS_FIB_DETAILS, mpls_fib_details) \
4195 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
4196 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
4197 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
4198 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
4199 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
4200 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
4201 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
4202 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
4203 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
4204 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
4205 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
4206 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
4207 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
4208 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
4209 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
4210 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
4211 _(PG_CAPTURE_REPLY, pg_capture_reply) \
4212 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
4213 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
4214 ip_source_and_port_range_check_add_del_reply) \
4215 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
4216 ip_source_and_port_range_check_interface_add_del_reply) \
4217 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
4218 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
4219 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
4220 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
4221 _(PUNT_REPLY, punt_reply) \
4222 _(IP_FIB_DETAILS, ip_fib_details) \
4223 _(IP6_FIB_DETAILS, ip6_fib_details) \
4224 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
4225 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
4226 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
4227 _(SW_INTERFACE_SET_MTU_REPLY, sw_interface_set_mtu_reply) \
4228 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
4229 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply)
4231 #define foreach_standalone_reply_msg \
4232 _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
4233 _(VNET_INTERFACE_COUNTERS, vnet_interface_counters) \
4234 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
4235 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
4236 _(VNET_IP4_NBR_COUNTERS, vnet_ip4_nbr_counters) \
4237 _(VNET_IP6_NBR_COUNTERS, vnet_ip6_nbr_counters)
4246 #define STR_VTR_OP_CASE(op) \
4247 case L2_VTR_ ## op: \
4251 str_vtr_op (u32 vtr_op)
4255 STR_VTR_OP_CASE (DISABLED);
4256 STR_VTR_OP_CASE (PUSH_1);
4257 STR_VTR_OP_CASE (PUSH_2);
4258 STR_VTR_OP_CASE (POP_1);
4259 STR_VTR_OP_CASE (POP_2);
4260 STR_VTR_OP_CASE (TRANSLATE_1_1);
4261 STR_VTR_OP_CASE (TRANSLATE_1_2);
4262 STR_VTR_OP_CASE (TRANSLATE_2_1);
4263 STR_VTR_OP_CASE (TRANSLATE_2_2);
4270 dump_sub_interface_table (vat_main_t * vam)
4272 const sw_interface_subif_t *sub = NULL;
4274 if (vam->json_output)
4277 ("JSON output supported only for VPE API calls and dump_stats_table");
4282 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
4283 "Interface", "sw_if_index",
4284 "sub id", "dot1ad", "tags", "outer id",
4285 "inner id", "exact", "default", "outer any", "inner any");
4287 vec_foreach (sub, vam->sw_if_subif_table)
4290 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
4291 sub->interface_name,
4293 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
4294 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
4295 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
4296 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
4297 if (sub->vtr_op != L2_VTR_DISABLED)
4300 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
4301 "tag1: %d tag2: %d ]",
4302 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
4303 sub->vtr_tag1, sub->vtr_tag2);
4311 name_sort_cmp (void *a1, void *a2)
4313 name_sort_t *n1 = a1;
4314 name_sort_t *n2 = a2;
4316 return strcmp ((char *) n1->name, (char *) n2->name);
4320 dump_interface_table (vat_main_t * vam)
4323 name_sort_t *nses = 0, *ns;
4325 if (vam->json_output)
4328 ("JSON output supported only for VPE API calls and dump_stats_table");
4333 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4335 vec_add2 (nses, ns, 1);
4336 ns->name = (u8 *)(p->key);
4337 ns->value = (u32) p->value[0];
4341 vec_sort_with_function (nses, name_sort_cmp);
4343 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
4344 vec_foreach (ns, nses)
4346 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
4353 dump_ip_table (vat_main_t * vam, int is_ipv6)
4355 const ip_details_t *det = NULL;
4356 const ip_address_details_t *address = NULL;
4359 print (vam->ofp, "%-12s", "sw_if_index");
4361 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
4368 print (vam->ofp, "%-12d", i);
4369 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
4374 vec_foreach (address, det->addr)
4378 is_ipv6 ? format_ip6_address : format_ip4_address,
4379 address->ip, address->prefix_length);
4387 dump_ipv4_table (vat_main_t * vam)
4389 if (vam->json_output)
4392 ("JSON output supported only for VPE API calls and dump_stats_table");
4396 return dump_ip_table (vam, 0);
4400 dump_ipv6_table (vat_main_t * vam)
4402 if (vam->json_output)
4405 ("JSON output supported only for VPE API calls and dump_stats_table");
4409 return dump_ip_table (vam, 1);
4413 counter_type_to_str (u8 counter_type, u8 is_combined)
4417 switch (counter_type)
4419 case VNET_INTERFACE_COUNTER_DROP:
4421 case VNET_INTERFACE_COUNTER_PUNT:
4423 case VNET_INTERFACE_COUNTER_IP4:
4425 case VNET_INTERFACE_COUNTER_IP6:
4427 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
4429 case VNET_INTERFACE_COUNTER_RX_MISS:
4431 case VNET_INTERFACE_COUNTER_RX_ERROR:
4433 case VNET_INTERFACE_COUNTER_TX_ERROR:
4436 return "INVALID-COUNTER-TYPE";
4441 switch (counter_type)
4443 case VNET_INTERFACE_COUNTER_RX:
4445 case VNET_INTERFACE_COUNTER_TX:
4448 return "INVALID-COUNTER-TYPE";
4454 dump_stats_table (vat_main_t * vam)
4456 vat_json_node_t node;
4457 vat_json_node_t *msg_array;
4458 vat_json_node_t *msg;
4459 vat_json_node_t *counter_array;
4460 vat_json_node_t *counter;
4461 interface_counter_t c;
4463 ip4_fib_counter_t *c4;
4464 ip6_fib_counter_t *c6;
4465 ip4_nbr_counter_t *n4;
4466 ip6_nbr_counter_t *n6;
4469 if (!vam->json_output)
4471 clib_warning ("dump_stats_table supported only in JSON format");
4475 vat_json_init_object (&node);
4477 /* interface counters */
4478 msg_array = vat_json_object_add (&node, "interface_counters");
4479 vat_json_init_array (msg_array);
4480 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
4482 msg = vat_json_array_add (msg_array);
4483 vat_json_init_object (msg);
4484 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4485 (u8 *) counter_type_to_str (i, 0));
4486 vat_json_object_add_int (msg, "is_combined", 0);
4487 counter_array = vat_json_object_add (msg, "data");
4488 vat_json_init_array (counter_array);
4489 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
4491 packets = vam->simple_interface_counters[i][j];
4492 vat_json_array_add_uint (counter_array, packets);
4495 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
4497 msg = vat_json_array_add (msg_array);
4498 vat_json_init_object (msg);
4499 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4500 (u8 *) counter_type_to_str (i, 1));
4501 vat_json_object_add_int (msg, "is_combined", 1);
4502 counter_array = vat_json_object_add (msg, "data");
4503 vat_json_init_array (counter_array);
4504 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
4506 c = vam->combined_interface_counters[i][j];
4507 counter = vat_json_array_add (counter_array);
4508 vat_json_init_object (counter);
4509 vat_json_object_add_uint (counter, "packets", c.packets);
4510 vat_json_object_add_uint (counter, "bytes", c.bytes);
4514 /* ip4 fib counters */
4515 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
4516 vat_json_init_array (msg_array);
4517 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
4519 msg = vat_json_array_add (msg_array);
4520 vat_json_init_object (msg);
4521 vat_json_object_add_uint (msg, "vrf_id",
4522 vam->ip4_fib_counters_vrf_id_by_index[i]);
4523 counter_array = vat_json_object_add (msg, "c");
4524 vat_json_init_array (counter_array);
4525 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
4527 counter = vat_json_array_add (counter_array);
4528 vat_json_init_object (counter);
4529 c4 = &vam->ip4_fib_counters[i][j];
4530 vat_json_object_add_ip4 (counter, "address", c4->address);
4531 vat_json_object_add_uint (counter, "address_length",
4532 c4->address_length);
4533 vat_json_object_add_uint (counter, "packets", c4->packets);
4534 vat_json_object_add_uint (counter, "bytes", c4->bytes);
4538 /* ip6 fib counters */
4539 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
4540 vat_json_init_array (msg_array);
4541 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
4543 msg = vat_json_array_add (msg_array);
4544 vat_json_init_object (msg);
4545 vat_json_object_add_uint (msg, "vrf_id",
4546 vam->ip6_fib_counters_vrf_id_by_index[i]);
4547 counter_array = vat_json_object_add (msg, "c");
4548 vat_json_init_array (counter_array);
4549 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
4551 counter = vat_json_array_add (counter_array);
4552 vat_json_init_object (counter);
4553 c6 = &vam->ip6_fib_counters[i][j];
4554 vat_json_object_add_ip6 (counter, "address", c6->address);
4555 vat_json_object_add_uint (counter, "address_length",
4556 c6->address_length);
4557 vat_json_object_add_uint (counter, "packets", c6->packets);
4558 vat_json_object_add_uint (counter, "bytes", c6->bytes);
4562 /* ip4 nbr counters */
4563 msg_array = vat_json_object_add (&node, "ip4_nbr_counters");
4564 vat_json_init_array (msg_array);
4565 for (i = 0; i < vec_len (vam->ip4_nbr_counters); i++)
4567 msg = vat_json_array_add (msg_array);
4568 vat_json_init_object (msg);
4569 vat_json_object_add_uint (msg, "sw_if_index", i);
4570 counter_array = vat_json_object_add (msg, "c");
4571 vat_json_init_array (counter_array);
4572 for (j = 0; j < vec_len (vam->ip4_nbr_counters[i]); j++)
4574 counter = vat_json_array_add (counter_array);
4575 vat_json_init_object (counter);
4576 n4 = &vam->ip4_nbr_counters[i][j];
4577 vat_json_object_add_ip4 (counter, "address", n4->address);
4578 vat_json_object_add_uint (counter, "link-type", n4->linkt);
4579 vat_json_object_add_uint (counter, "packets", n4->packets);
4580 vat_json_object_add_uint (counter, "bytes", n4->bytes);
4584 /* ip6 nbr counters */
4585 msg_array = vat_json_object_add (&node, "ip6_nbr_counters");
4586 vat_json_init_array (msg_array);
4587 for (i = 0; i < vec_len (vam->ip6_nbr_counters); i++)
4589 msg = vat_json_array_add (msg_array);
4590 vat_json_init_object (msg);
4591 vat_json_object_add_uint (msg, "sw_if_index", i);
4592 counter_array = vat_json_object_add (msg, "c");
4593 vat_json_init_array (counter_array);
4594 for (j = 0; j < vec_len (vam->ip6_nbr_counters[i]); j++)
4596 counter = vat_json_array_add (counter_array);
4597 vat_json_init_object (counter);
4598 n6 = &vam->ip6_nbr_counters[i][j];
4599 vat_json_object_add_ip6 (counter, "address", n6->address);
4600 vat_json_object_add_uint (counter, "packets", n6->packets);
4601 vat_json_object_add_uint (counter, "bytes", n6->bytes);
4605 vat_json_print (vam->ofp, &node);
4606 vat_json_free (&node);
4612 exec (vat_main_t * vam)
4614 api_main_t *am = &api_main;
4615 vl_api_cli_request_t *mp;
4619 unformat_input_t *i = vam->input;
4621 if (vec_len (i->buffer) == 0)
4624 if (vam->exec_mode == 0 && unformat (i, "mode"))
4629 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4636 M (CLI_REQUEST, mp);
4639 * Copy cmd into shared memory.
4640 * In order for the CLI command to work, it
4641 * must be a vector ending in \n, not a C-string ending
4644 pthread_mutex_lock (&am->vlib_rp->mutex);
4645 oldheap = svm_push_data_heap (am->vlib_rp);
4647 vec_validate (cmd, vec_len (vam->input->buffer) - 1);
4648 clib_memcpy (cmd, vam->input->buffer, vec_len (vam->input->buffer));
4650 svm_pop_heap (oldheap);
4651 pthread_mutex_unlock (&am->vlib_rp->mutex);
4653 mp->cmd_in_shmem = (u64) cmd;
4655 timeout = vat_time_now (vam) + 10.0;
4657 while (vat_time_now (vam) < timeout)
4659 if (vam->result_ready == 1)
4662 if (vam->shmem_result != NULL)
4663 print (vam->ofp, "%s", vam->shmem_result);
4664 pthread_mutex_lock (&am->vlib_rp->mutex);
4665 oldheap = svm_push_data_heap (am->vlib_rp);
4667 free_me = (u8 *) vam->shmem_result;
4670 svm_pop_heap (oldheap);
4671 pthread_mutex_unlock (&am->vlib_rp->mutex);
4679 * Future replacement of exec() that passes CLI buffers directly in
4680 * the API messages instead of an additional shared memory area.
4683 exec_inband (vat_main_t * vam)
4685 vl_api_cli_inband_t *mp;
4686 unformat_input_t *i = vam->input;
4689 if (vec_len (i->buffer) == 0)
4692 if (vam->exec_mode == 0 && unformat (i, "mode"))
4697 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4704 * In order for the CLI command to work, it
4705 * must be a vector ending in \n, not a C-string ending
4708 u32 len = vec_len (vam->input->buffer);
4709 M2 (CLI_INBAND, mp, len);
4710 clib_memcpy (mp->cmd, vam->input->buffer, len);
4711 mp->length = htonl (len);
4714 W2 (ret, print (vam->ofp, "%s", vam->cmd_reply));
4719 api_create_loopback (vat_main_t * vam)
4721 unformat_input_t *i = vam->input;
4722 vl_api_create_loopback_t *mp;
4727 memset (mac_address, 0, sizeof (mac_address));
4729 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4731 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
4737 /* Construct the API message */
4738 M (CREATE_LOOPBACK, mp);
4740 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
4748 api_delete_loopback (vat_main_t * vam)
4750 unformat_input_t *i = vam->input;
4751 vl_api_delete_loopback_t *mp;
4752 u32 sw_if_index = ~0;
4755 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4757 if (unformat (i, "sw_if_index %d", &sw_if_index))
4763 if (sw_if_index == ~0)
4765 errmsg ("missing sw_if_index");
4769 /* Construct the API message */
4770 M (DELETE_LOOPBACK, mp);
4771 mp->sw_if_index = ntohl (sw_if_index);
4779 api_want_stats (vat_main_t * vam)
4781 unformat_input_t *i = vam->input;
4782 vl_api_want_stats_t *mp;
4786 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4788 if (unformat (i, "enable"))
4790 else if (unformat (i, "disable"))
4798 errmsg ("missing enable|disable");
4803 mp->enable_disable = enable;
4811 api_want_interface_events (vat_main_t * vam)
4813 unformat_input_t *i = vam->input;
4814 vl_api_want_interface_events_t *mp;
4818 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4820 if (unformat (i, "enable"))
4822 else if (unformat (i, "disable"))
4830 errmsg ("missing enable|disable");
4834 M (WANT_INTERFACE_EVENTS, mp);
4835 mp->enable_disable = enable;
4837 vam->interface_event_display = enable;
4845 /* Note: non-static, called once to set up the initial intfc table */
4847 api_sw_interface_dump (vat_main_t * vam)
4849 vl_api_sw_interface_dump_t *mp;
4850 vl_api_control_ping_t *mp_ping;
4852 name_sort_t *nses = 0, *ns;
4853 sw_interface_subif_t *sub = NULL;
4856 /* Toss the old name table */
4858 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4860 vec_add2 (nses, ns, 1);
4861 ns->name = (u8 *)(p->key);
4862 ns->value = (u32) p->value[0];
4866 hash_free (vam->sw_if_index_by_interface_name);
4868 vec_foreach (ns, nses) vec_free (ns->name);
4872 vec_foreach (sub, vam->sw_if_subif_table)
4874 vec_free (sub->interface_name);
4876 vec_free (vam->sw_if_subif_table);
4878 /* recreate the interface name hash table */
4879 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
4881 /* Get list of ethernets */
4882 M (SW_INTERFACE_DUMP, mp);
4883 mp->name_filter_valid = 1;
4884 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
4887 /* and local / loopback interfaces */
4888 M (SW_INTERFACE_DUMP, mp);
4889 mp->name_filter_valid = 1;
4890 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
4893 /* and packet-generator interfaces */
4894 M (SW_INTERFACE_DUMP, mp);
4895 mp->name_filter_valid = 1;
4896 strncpy ((char *) mp->name_filter, "pg", sizeof (mp->name_filter) - 1);
4899 /* and vxlan-gpe tunnel interfaces */
4900 M (SW_INTERFACE_DUMP, mp);
4901 mp->name_filter_valid = 1;
4902 strncpy ((char *) mp->name_filter, "vxlan_gpe",
4903 sizeof (mp->name_filter) - 1);
4906 /* and vxlan tunnel interfaces */
4907 M (SW_INTERFACE_DUMP, mp);
4908 mp->name_filter_valid = 1;
4909 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
4912 /* and host (af_packet) interfaces */
4913 M (SW_INTERFACE_DUMP, mp);
4914 mp->name_filter_valid = 1;
4915 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
4918 /* and l2tpv3 tunnel interfaces */
4919 M (SW_INTERFACE_DUMP, mp);
4920 mp->name_filter_valid = 1;
4921 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
4922 sizeof (mp->name_filter) - 1);
4925 /* and GRE tunnel interfaces */
4926 M (SW_INTERFACE_DUMP, mp);
4927 mp->name_filter_valid = 1;
4928 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
4931 /* and LISP-GPE interfaces */
4932 M (SW_INTERFACE_DUMP, mp);
4933 mp->name_filter_valid = 1;
4934 strncpy ((char *) mp->name_filter, "lisp_gpe",
4935 sizeof (mp->name_filter) - 1);
4938 /* and IPSEC tunnel interfaces */
4939 M (SW_INTERFACE_DUMP, mp);
4940 mp->name_filter_valid = 1;
4941 strncpy ((char *) mp->name_filter, "ipsec", sizeof (mp->name_filter) - 1);
4944 /* Use a control ping for synchronization */
4945 M (CONTROL_PING, mp_ping);
4953 api_sw_interface_set_flags (vat_main_t * vam)
4955 unformat_input_t *i = vam->input;
4956 vl_api_sw_interface_set_flags_t *mp;
4958 u8 sw_if_index_set = 0;
4959 u8 admin_up = 0, link_up = 0;
4962 /* Parse args required to build the message */
4963 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4965 if (unformat (i, "admin-up"))
4967 else if (unformat (i, "admin-down"))
4969 else if (unformat (i, "link-up"))
4971 else if (unformat (i, "link-down"))
4974 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4975 sw_if_index_set = 1;
4976 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4977 sw_if_index_set = 1;
4982 if (sw_if_index_set == 0)
4984 errmsg ("missing interface name or sw_if_index");
4988 /* Construct the API message */
4989 M (SW_INTERFACE_SET_FLAGS, mp);
4990 mp->sw_if_index = ntohl (sw_if_index);
4991 mp->admin_up_down = admin_up;
4992 mp->link_up_down = link_up;
4997 /* Wait for a reply, return the good/bad news... */
5003 api_sw_interface_clear_stats (vat_main_t * vam)
5005 unformat_input_t *i = vam->input;
5006 vl_api_sw_interface_clear_stats_t *mp;
5008 u8 sw_if_index_set = 0;
5011 /* Parse args required to build the message */
5012 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5014 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5015 sw_if_index_set = 1;
5016 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5017 sw_if_index_set = 1;
5022 /* Construct the API message */
5023 M (SW_INTERFACE_CLEAR_STATS, mp);
5025 if (sw_if_index_set == 1)
5026 mp->sw_if_index = ntohl (sw_if_index);
5028 mp->sw_if_index = ~0;
5033 /* Wait for a reply, return the good/bad news... */
5039 api_sw_interface_add_del_address (vat_main_t * vam)
5041 unformat_input_t *i = vam->input;
5042 vl_api_sw_interface_add_del_address_t *mp;
5044 u8 sw_if_index_set = 0;
5045 u8 is_add = 1, del_all = 0;
5046 u32 address_length = 0;
5047 u8 v4_address_set = 0;
5048 u8 v6_address_set = 0;
5049 ip4_address_t v4address;
5050 ip6_address_t v6address;
5053 /* Parse args required to build the message */
5054 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5056 if (unformat (i, "del-all"))
5058 else if (unformat (i, "del"))
5061 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5062 sw_if_index_set = 1;
5063 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5064 sw_if_index_set = 1;
5065 else if (unformat (i, "%U/%d",
5066 unformat_ip4_address, &v4address, &address_length))
5068 else if (unformat (i, "%U/%d",
5069 unformat_ip6_address, &v6address, &address_length))
5075 if (sw_if_index_set == 0)
5077 errmsg ("missing interface name or sw_if_index");
5080 if (v4_address_set && v6_address_set)
5082 errmsg ("both v4 and v6 addresses set");
5085 if (!v4_address_set && !v6_address_set && !del_all)
5087 errmsg ("no addresses set");
5091 /* Construct the API message */
5092 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
5094 mp->sw_if_index = ntohl (sw_if_index);
5095 mp->is_add = is_add;
5096 mp->del_all = del_all;
5100 clib_memcpy (mp->address, &v6address, sizeof (v6address));
5104 clib_memcpy (mp->address, &v4address, sizeof (v4address));
5106 mp->address_length = address_length;
5111 /* Wait for a reply, return good/bad news */
5117 api_sw_interface_set_mpls_enable (vat_main_t * vam)
5119 unformat_input_t *i = vam->input;
5120 vl_api_sw_interface_set_mpls_enable_t *mp;
5122 u8 sw_if_index_set = 0;
5126 /* Parse args required to build the message */
5127 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5129 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5130 sw_if_index_set = 1;
5131 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5132 sw_if_index_set = 1;
5133 else if (unformat (i, "disable"))
5135 else if (unformat (i, "dis"))
5141 if (sw_if_index_set == 0)
5143 errmsg ("missing interface name or sw_if_index");
5147 /* Construct the API message */
5148 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
5150 mp->sw_if_index = ntohl (sw_if_index);
5151 mp->enable = enable;
5156 /* Wait for a reply... */
5162 api_sw_interface_set_table (vat_main_t * vam)
5164 unformat_input_t *i = vam->input;
5165 vl_api_sw_interface_set_table_t *mp;
5166 u32 sw_if_index, vrf_id = 0;
5167 u8 sw_if_index_set = 0;
5171 /* Parse args required to build the message */
5172 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5174 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5175 sw_if_index_set = 1;
5176 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5177 sw_if_index_set = 1;
5178 else if (unformat (i, "vrf %d", &vrf_id))
5180 else if (unformat (i, "ipv6"))
5186 if (sw_if_index_set == 0)
5188 errmsg ("missing interface name or sw_if_index");
5192 /* Construct the API message */
5193 M (SW_INTERFACE_SET_TABLE, mp);
5195 mp->sw_if_index = ntohl (sw_if_index);
5196 mp->is_ipv6 = is_ipv6;
5197 mp->vrf_id = ntohl (vrf_id);
5202 /* Wait for a reply... */
5207 static void vl_api_sw_interface_get_table_reply_t_handler
5208 (vl_api_sw_interface_get_table_reply_t * mp)
5210 vat_main_t *vam = &vat_main;
5212 print (vam->ofp, "%d", ntohl (mp->vrf_id));
5214 vam->retval = ntohl (mp->retval);
5215 vam->result_ready = 1;
5219 static void vl_api_sw_interface_get_table_reply_t_handler_json
5220 (vl_api_sw_interface_get_table_reply_t * mp)
5222 vat_main_t *vam = &vat_main;
5223 vat_json_node_t node;
5225 vat_json_init_object (&node);
5226 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
5227 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
5229 vat_json_print (vam->ofp, &node);
5230 vat_json_free (&node);
5232 vam->retval = ntohl (mp->retval);
5233 vam->result_ready = 1;
5237 api_sw_interface_get_table (vat_main_t * vam)
5239 unformat_input_t *i = vam->input;
5240 vl_api_sw_interface_get_table_t *mp;
5242 u8 sw_if_index_set = 0;
5246 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5248 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5249 sw_if_index_set = 1;
5250 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5251 sw_if_index_set = 1;
5252 else if (unformat (i, "ipv6"))
5258 if (sw_if_index_set == 0)
5260 errmsg ("missing interface name or sw_if_index");
5264 M (SW_INTERFACE_GET_TABLE, mp);
5265 mp->sw_if_index = htonl (sw_if_index);
5266 mp->is_ipv6 = is_ipv6;
5274 api_sw_interface_set_vpath (vat_main_t * vam)
5276 unformat_input_t *i = vam->input;
5277 vl_api_sw_interface_set_vpath_t *mp;
5278 u32 sw_if_index = 0;
5279 u8 sw_if_index_set = 0;
5283 /* Parse args required to build the message */
5284 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5286 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5287 sw_if_index_set = 1;
5288 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5289 sw_if_index_set = 1;
5290 else if (unformat (i, "enable"))
5292 else if (unformat (i, "disable"))
5298 if (sw_if_index_set == 0)
5300 errmsg ("missing interface name or sw_if_index");
5304 /* Construct the API message */
5305 M (SW_INTERFACE_SET_VPATH, mp);
5307 mp->sw_if_index = ntohl (sw_if_index);
5308 mp->enable = is_enable;
5313 /* Wait for a reply... */
5319 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
5321 unformat_input_t *i = vam->input;
5322 vl_api_sw_interface_set_vxlan_bypass_t *mp;
5323 u32 sw_if_index = 0;
5324 u8 sw_if_index_set = 0;
5329 /* Parse args required to build the message */
5330 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5332 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5333 sw_if_index_set = 1;
5334 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5335 sw_if_index_set = 1;
5336 else if (unformat (i, "enable"))
5338 else if (unformat (i, "disable"))
5340 else if (unformat (i, "ip4"))
5342 else if (unformat (i, "ip6"))
5348 if (sw_if_index_set == 0)
5350 errmsg ("missing interface name or sw_if_index");
5354 /* Construct the API message */
5355 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
5357 mp->sw_if_index = ntohl (sw_if_index);
5358 mp->enable = is_enable;
5359 mp->is_ipv6 = is_ipv6;
5364 /* Wait for a reply... */
5370 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
5372 unformat_input_t *i = vam->input;
5373 vl_api_sw_interface_set_l2_xconnect_t *mp;
5375 u8 rx_sw_if_index_set = 0;
5377 u8 tx_sw_if_index_set = 0;
5381 /* Parse args required to build the message */
5382 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5384 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
5385 rx_sw_if_index_set = 1;
5386 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5387 tx_sw_if_index_set = 1;
5388 else if (unformat (i, "rx"))
5390 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5392 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
5394 rx_sw_if_index_set = 1;
5399 else if (unformat (i, "tx"))
5401 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5403 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
5405 tx_sw_if_index_set = 1;
5410 else if (unformat (i, "enable"))
5412 else if (unformat (i, "disable"))
5418 if (rx_sw_if_index_set == 0)
5420 errmsg ("missing rx interface name or rx_sw_if_index");
5424 if (enable && (tx_sw_if_index_set == 0))
5426 errmsg ("missing tx interface name or tx_sw_if_index");
5430 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
5432 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5433 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
5434 mp->enable = enable;
5442 api_sw_interface_set_l2_bridge (vat_main_t * vam)
5444 unformat_input_t *i = vam->input;
5445 vl_api_sw_interface_set_l2_bridge_t *mp;
5447 u8 rx_sw_if_index_set = 0;
5455 /* Parse args required to build the message */
5456 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5458 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
5459 rx_sw_if_index_set = 1;
5460 else if (unformat (i, "bd_id %d", &bd_id))
5464 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
5465 rx_sw_if_index_set = 1;
5466 else if (unformat (i, "shg %d", &shg))
5468 else if (unformat (i, "bvi"))
5470 else if (unformat (i, "enable"))
5472 else if (unformat (i, "disable"))
5478 if (rx_sw_if_index_set == 0)
5480 errmsg ("missing rx interface name or sw_if_index");
5484 if (enable && (bd_id_set == 0))
5486 errmsg ("missing bridge domain");
5490 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
5492 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5493 mp->bd_id = ntohl (bd_id);
5496 mp->enable = enable;
5504 api_bridge_domain_dump (vat_main_t * vam)
5506 unformat_input_t *i = vam->input;
5507 vl_api_bridge_domain_dump_t *mp;
5508 vl_api_control_ping_t *mp_ping;
5512 /* Parse args required to build the message */
5513 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5515 if (unformat (i, "bd_id %d", &bd_id))
5521 M (BRIDGE_DOMAIN_DUMP, mp);
5522 mp->bd_id = ntohl (bd_id);
5525 /* Use a control ping for synchronization */
5526 M (CONTROL_PING, mp_ping);
5534 api_bridge_domain_add_del (vat_main_t * vam)
5536 unformat_input_t *i = vam->input;
5537 vl_api_bridge_domain_add_del_t *mp;
5540 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
5544 /* Parse args required to build the message */
5545 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5547 if (unformat (i, "bd_id %d", &bd_id))
5549 else if (unformat (i, "flood %d", &flood))
5551 else if (unformat (i, "uu-flood %d", &uu_flood))
5553 else if (unformat (i, "forward %d", &forward))
5555 else if (unformat (i, "learn %d", &learn))
5557 else if (unformat (i, "arp-term %d", &arp_term))
5559 else if (unformat (i, "mac-age %d", &mac_age))
5561 else if (unformat (i, "del"))
5564 flood = uu_flood = forward = learn = 0;
5572 errmsg ("missing bridge domain");
5578 errmsg ("mac age must be less than 256 ");
5582 M (BRIDGE_DOMAIN_ADD_DEL, mp);
5584 mp->bd_id = ntohl (bd_id);
5586 mp->uu_flood = uu_flood;
5587 mp->forward = forward;
5589 mp->arp_term = arp_term;
5590 mp->is_add = is_add;
5591 mp->mac_age = (u8) mac_age;
5599 api_l2fib_add_del (vat_main_t * vam)
5601 unformat_input_t *i = vam->input;
5602 vl_api_l2fib_add_del_t *mp;
5608 u32 sw_if_index = ~0;
5609 u8 sw_if_index_set = 0;
5618 /* Parse args required to build the message */
5619 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5621 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
5623 else if (unformat (i, "bd_id %d", &bd_id))
5625 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5626 sw_if_index_set = 1;
5627 else if (unformat (i, "sw_if"))
5629 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5632 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5633 sw_if_index_set = 1;
5638 else if (unformat (i, "static"))
5640 else if (unformat (i, "filter"))
5645 else if (unformat (i, "bvi"))
5650 else if (unformat (i, "del"))
5652 else if (unformat (i, "count %d", &count))
5660 errmsg ("missing mac address");
5666 errmsg ("missing bridge domain");
5670 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
5672 errmsg ("missing interface name or sw_if_index");
5678 /* Turn on async mode */
5679 vam->async_mode = 1;
5680 vam->async_errors = 0;
5681 before = vat_time_now (vam);
5684 for (j = 0; j < count; j++)
5686 M (L2FIB_ADD_DEL, mp);
5689 mp->bd_id = ntohl (bd_id);
5690 mp->is_add = is_add;
5694 mp->sw_if_index = ntohl (sw_if_index);
5695 mp->static_mac = static_mac;
5696 mp->filter_mac = filter_mac;
5697 mp->bvi_mac = bvi_mac;
5699 increment_mac_address (&mac);
5706 vl_api_control_ping_t *mp_ping;
5709 /* Shut off async mode */
5710 vam->async_mode = 0;
5712 M (CONTROL_PING, mp_ping);
5715 timeout = vat_time_now (vam) + 1.0;
5716 while (vat_time_now (vam) < timeout)
5717 if (vam->result_ready == 1)
5722 if (vam->retval == -99)
5725 if (vam->async_errors > 0)
5727 errmsg ("%d asynchronous errors", vam->async_errors);
5730 vam->async_errors = 0;
5731 after = vat_time_now (vam);
5733 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
5734 count, after - before, count / (after - before));
5740 /* Wait for a reply... */
5744 /* Return the good/bad news */
5745 return (vam->retval);
5749 api_l2_flags (vat_main_t * vam)
5751 unformat_input_t *i = vam->input;
5752 vl_api_l2_flags_t *mp;
5754 u32 feature_bitmap = 0;
5755 u8 sw_if_index_set = 0;
5758 /* Parse args required to build the message */
5759 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5761 if (unformat (i, "sw_if_index %d", &sw_if_index))
5762 sw_if_index_set = 1;
5763 else if (unformat (i, "sw_if"))
5765 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5768 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5769 sw_if_index_set = 1;
5774 else if (unformat (i, "learn"))
5775 feature_bitmap |= L2INPUT_FEAT_LEARN;
5776 else if (unformat (i, "forward"))
5777 feature_bitmap |= L2INPUT_FEAT_FWD;
5778 else if (unformat (i, "flood"))
5779 feature_bitmap |= L2INPUT_FEAT_FLOOD;
5780 else if (unformat (i, "uu-flood"))
5781 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
5786 if (sw_if_index_set == 0)
5788 errmsg ("missing interface name or sw_if_index");
5794 mp->sw_if_index = ntohl (sw_if_index);
5795 mp->feature_bitmap = ntohl (feature_bitmap);
5803 api_bridge_flags (vat_main_t * vam)
5805 unformat_input_t *i = vam->input;
5806 vl_api_bridge_flags_t *mp;
5813 /* Parse args required to build the message */
5814 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5816 if (unformat (i, "bd_id %d", &bd_id))
5818 else if (unformat (i, "learn"))
5820 else if (unformat (i, "forward"))
5822 else if (unformat (i, "flood"))
5824 else if (unformat (i, "uu-flood"))
5825 flags |= L2_UU_FLOOD;
5826 else if (unformat (i, "arp-term"))
5827 flags |= L2_ARP_TERM;
5828 else if (unformat (i, "off"))
5830 else if (unformat (i, "disable"))
5838 errmsg ("missing bridge domain");
5842 M (BRIDGE_FLAGS, mp);
5844 mp->bd_id = ntohl (bd_id);
5845 mp->feature_bitmap = ntohl (flags);
5846 mp->is_set = is_set;
5854 api_bd_ip_mac_add_del (vat_main_t * vam)
5856 unformat_input_t *i = vam->input;
5857 vl_api_bd_ip_mac_add_del_t *mp;
5864 ip4_address_t v4addr;
5865 ip6_address_t v6addr;
5870 /* Parse args required to build the message */
5871 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5873 if (unformat (i, "bd_id %d", &bd_id))
5877 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
5881 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
5886 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
5890 else if (unformat (i, "del"))
5898 errmsg ("missing bridge domain");
5901 else if (ip_set == 0)
5903 errmsg ("missing IP address");
5906 else if (mac_set == 0)
5908 errmsg ("missing MAC address");
5912 M (BD_IP_MAC_ADD_DEL, mp);
5914 mp->bd_id = ntohl (bd_id);
5915 mp->is_ipv6 = is_ipv6;
5916 mp->is_add = is_add;
5918 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
5920 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
5921 clib_memcpy (mp->mac_address, macaddr, 6);
5928 api_tap_connect (vat_main_t * vam)
5930 unformat_input_t *i = vam->input;
5931 vl_api_tap_connect_t *mp;
5937 ip4_address_t ip4_address;
5939 int ip4_address_set = 0;
5940 ip6_address_t ip6_address;
5942 int ip6_address_set = 0;
5945 memset (mac_address, 0, sizeof (mac_address));
5947 /* Parse args required to build the message */
5948 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5950 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5954 else if (unformat (i, "random-mac"))
5956 else if (unformat (i, "tapname %s", &tap_name))
5958 else if (unformat (i, "tag %s", &tag))
5960 else if (unformat (i, "address %U/%d",
5961 unformat_ip4_address, &ip4_address, &ip4_mask_width))
5962 ip4_address_set = 1;
5963 else if (unformat (i, "address %U/%d",
5964 unformat_ip6_address, &ip6_address, &ip6_mask_width))
5965 ip6_address_set = 1;
5972 errmsg ("missing tap name");
5975 if (vec_len (tap_name) > 63)
5977 errmsg ("tap name too long");
5980 vec_add1 (tap_name, 0);
5982 if (vec_len (tag) > 63)
5984 errmsg ("tag too long");
5988 /* Construct the API message */
5989 M (TAP_CONNECT, mp);
5991 mp->use_random_mac = random_mac;
5992 clib_memcpy (mp->mac_address, mac_address, 6);
5993 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5995 clib_memcpy (mp->tag, tag, vec_len (tag));
5997 if (ip4_address_set)
5999 mp->ip4_address_set = 1;
6000 clib_memcpy (mp->ip4_address, &ip4_address, sizeof (mp->ip4_address));
6001 mp->ip4_mask_width = ip4_mask_width;
6003 if (ip6_address_set)
6005 mp->ip6_address_set = 1;
6006 clib_memcpy (mp->ip6_address, &ip6_address, sizeof (mp->ip6_address));
6007 mp->ip6_mask_width = ip6_mask_width;
6010 vec_free (tap_name);
6016 /* Wait for a reply... */
6022 api_tap_modify (vat_main_t * vam)
6024 unformat_input_t *i = vam->input;
6025 vl_api_tap_modify_t *mp;
6030 u32 sw_if_index = ~0;
6031 u8 sw_if_index_set = 0;
6034 memset (mac_address, 0, sizeof (mac_address));
6036 /* Parse args required to build the message */
6037 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6039 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6040 sw_if_index_set = 1;
6041 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6042 sw_if_index_set = 1;
6043 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6047 else if (unformat (i, "random-mac"))
6049 else if (unformat (i, "tapname %s", &tap_name))
6055 if (sw_if_index_set == 0)
6057 errmsg ("missing vpp interface name");
6062 errmsg ("missing tap name");
6065 if (vec_len (tap_name) > 63)
6067 errmsg ("tap name too long");
6069 vec_add1 (tap_name, 0);
6071 /* Construct the API message */
6074 mp->use_random_mac = random_mac;
6075 mp->sw_if_index = ntohl (sw_if_index);
6076 clib_memcpy (mp->mac_address, mac_address, 6);
6077 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
6078 vec_free (tap_name);
6083 /* Wait for a reply... */
6089 api_tap_delete (vat_main_t * vam)
6091 unformat_input_t *i = vam->input;
6092 vl_api_tap_delete_t *mp;
6093 u32 sw_if_index = ~0;
6094 u8 sw_if_index_set = 0;
6097 /* Parse args required to build the message */
6098 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6100 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6101 sw_if_index_set = 1;
6102 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6103 sw_if_index_set = 1;
6108 if (sw_if_index_set == 0)
6110 errmsg ("missing vpp interface name");
6114 /* Construct the API message */
6117 mp->sw_if_index = ntohl (sw_if_index);
6122 /* Wait for a reply... */
6128 api_ip_add_del_route (vat_main_t * vam)
6130 unformat_input_t *i = vam->input;
6131 vl_api_ip_add_del_route_t *mp;
6132 u32 sw_if_index = ~0, vrf_id = 0;
6134 u8 is_local = 0, is_drop = 0;
6135 u8 is_unreach = 0, is_prohibit = 0;
6136 u8 create_vrf_if_needed = 0;
6138 u32 next_hop_weight = 1;
6140 u8 is_multipath = 0;
6142 u8 address_length_set = 0;
6143 u32 next_hop_table_id = 0;
6144 u32 resolve_attempts = 0;
6145 u32 dst_address_length = 0;
6146 u8 next_hop_set = 0;
6147 ip4_address_t v4_dst_address, v4_next_hop_address;
6148 ip6_address_t v6_dst_address, v6_next_hop_address;
6152 u32 random_add_del = 0;
6153 u32 *random_vector = 0;
6155 u32 random_seed = 0xdeaddabe;
6156 u32 classify_table_index = ~0;
6158 u8 resolve_host = 0, resolve_attached = 0;
6159 mpls_label_t *next_hop_out_label_stack = NULL;
6160 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6161 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
6163 /* Parse args required to build the message */
6164 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6166 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6168 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6170 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
6175 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
6180 else if (unformat (i, "/%d", &dst_address_length))
6182 address_length_set = 1;
6185 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
6186 &v4_next_hop_address))
6190 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
6191 &v6_next_hop_address))
6195 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
6197 else if (unformat (i, "weight %d", &next_hop_weight))
6199 else if (unformat (i, "drop"))
6203 else if (unformat (i, "null-send-unreach"))
6207 else if (unformat (i, "null-send-prohibit"))
6211 else if (unformat (i, "local"))
6215 else if (unformat (i, "classify %d", &classify_table_index))
6219 else if (unformat (i, "del"))
6221 else if (unformat (i, "add"))
6223 else if (unformat (i, "not-last"))
6225 else if (unformat (i, "resolve-via-host"))
6227 else if (unformat (i, "resolve-via-attached"))
6228 resolve_attached = 1;
6229 else if (unformat (i, "multipath"))
6231 else if (unformat (i, "vrf %d", &vrf_id))
6233 else if (unformat (i, "create-vrf"))
6234 create_vrf_if_needed = 1;
6235 else if (unformat (i, "count %d", &count))
6237 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
6239 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6241 else if (unformat (i, "out-label %d", &next_hop_out_label))
6242 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
6243 else if (unformat (i, "via-label %d", &next_hop_via_label))
6245 else if (unformat (i, "random"))
6247 else if (unformat (i, "seed %d", &random_seed))
6251 clib_warning ("parse error '%U'", format_unformat_error, i);
6256 if (!next_hop_set && !is_drop && !is_local &&
6257 !is_classify && !is_unreach && !is_prohibit &&
6258 MPLS_LABEL_INVALID == next_hop_via_label)
6261 ("next hop / local / drop / unreach / prohibit / classify not set");
6265 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
6267 errmsg ("next hop and next-hop via label set");
6270 if (address_set == 0)
6272 errmsg ("missing addresses");
6276 if (address_length_set == 0)
6278 errmsg ("missing address length");
6282 /* Generate a pile of unique, random routes */
6285 u32 this_random_address;
6286 random_hash = hash_create (count, sizeof (uword));
6288 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
6289 for (j = 0; j <= count; j++)
6293 this_random_address = random_u32 (&random_seed);
6294 this_random_address =
6295 clib_host_to_net_u32 (this_random_address);
6297 while (hash_get (random_hash, this_random_address));
6298 vec_add1 (random_vector, this_random_address);
6299 hash_set (random_hash, this_random_address, 1);
6301 hash_free (random_hash);
6302 v4_dst_address.as_u32 = random_vector[0];
6307 /* Turn on async mode */
6308 vam->async_mode = 1;
6309 vam->async_errors = 0;
6310 before = vat_time_now (vam);
6313 for (j = 0; j < count; j++)
6315 /* Construct the API message */
6316 M2 (IP_ADD_DEL_ROUTE, mp,
6317 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
6319 mp->next_hop_sw_if_index = ntohl (sw_if_index);
6320 mp->table_id = ntohl (vrf_id);
6321 mp->create_vrf_if_needed = create_vrf_if_needed;
6323 mp->is_add = is_add;
6324 mp->is_drop = is_drop;
6325 mp->is_unreach = is_unreach;
6326 mp->is_prohibit = is_prohibit;
6327 mp->is_ipv6 = is_ipv6;
6328 mp->is_local = is_local;
6329 mp->is_classify = is_classify;
6330 mp->is_multipath = is_multipath;
6331 mp->is_resolve_host = resolve_host;
6332 mp->is_resolve_attached = resolve_attached;
6333 mp->not_last = not_last;
6334 mp->next_hop_weight = next_hop_weight;
6335 mp->dst_address_length = dst_address_length;
6336 mp->next_hop_table_id = ntohl (next_hop_table_id);
6337 mp->classify_table_index = ntohl (classify_table_index);
6338 mp->next_hop_via_label = ntohl (next_hop_via_label);
6339 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
6340 if (0 != mp->next_hop_n_out_labels)
6342 memcpy (mp->next_hop_out_label_stack,
6343 next_hop_out_label_stack,
6344 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
6345 vec_free (next_hop_out_label_stack);
6350 clib_memcpy (mp->dst_address, &v6_dst_address,
6351 sizeof (v6_dst_address));
6353 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
6354 sizeof (v6_next_hop_address));
6355 increment_v6_address (&v6_dst_address);
6359 clib_memcpy (mp->dst_address, &v4_dst_address,
6360 sizeof (v4_dst_address));
6362 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
6363 sizeof (v4_next_hop_address));
6365 v4_dst_address.as_u32 = random_vector[j + 1];
6367 increment_v4_address (&v4_dst_address);
6371 /* If we receive SIGTERM, stop now... */
6376 /* When testing multiple add/del ops, use a control-ping to sync */
6379 vl_api_control_ping_t *mp_ping;
6383 /* Shut off async mode */
6384 vam->async_mode = 0;
6386 M (CONTROL_PING, mp_ping);
6389 timeout = vat_time_now (vam) + 1.0;
6390 while (vat_time_now (vam) < timeout)
6391 if (vam->result_ready == 1)
6396 if (vam->retval == -99)
6399 if (vam->async_errors > 0)
6401 errmsg ("%d asynchronous errors", vam->async_errors);
6404 vam->async_errors = 0;
6405 after = vat_time_now (vam);
6407 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6411 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6412 count, after - before, count / (after - before));
6418 /* Wait for a reply... */
6423 /* Return the good/bad news */
6424 return (vam->retval);
6428 api_ip_mroute_add_del (vat_main_t * vam)
6430 unformat_input_t *i = vam->input;
6431 vl_api_ip_mroute_add_del_t *mp;
6432 u32 sw_if_index = ~0, vrf_id = 0;
6435 u8 create_vrf_if_needed = 0;
6438 u32 grp_address_length = 0;
6439 ip4_address_t v4_grp_address, v4_src_address;
6440 ip6_address_t v6_grp_address, v6_src_address;
6441 mfib_itf_flags_t iflags = 0;
6442 mfib_entry_flags_t eflags = 0;
6445 /* Parse args required to build the message */
6446 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6448 if (unformat (i, "sw_if_index %d", &sw_if_index))
6450 else if (unformat (i, "%U %U",
6451 unformat_ip4_address, &v4_src_address,
6452 unformat_ip4_address, &v4_grp_address))
6454 grp_address_length = 64;
6458 else if (unformat (i, "%U %U",
6459 unformat_ip6_address, &v6_src_address,
6460 unformat_ip6_address, &v6_grp_address))
6462 grp_address_length = 256;
6466 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
6468 memset (&v4_src_address, 0, sizeof (v4_src_address));
6469 grp_address_length = 32;
6473 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
6475 memset (&v6_src_address, 0, sizeof (v6_src_address));
6476 grp_address_length = 128;
6480 else if (unformat (i, "/%d", &grp_address_length))
6482 else if (unformat (i, "local"))
6486 else if (unformat (i, "del"))
6488 else if (unformat (i, "add"))
6490 else if (unformat (i, "vrf %d", &vrf_id))
6492 else if (unformat (i, "create-vrf"))
6493 create_vrf_if_needed = 1;
6494 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
6496 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
6500 clib_warning ("parse error '%U'", format_unformat_error, i);
6505 if (address_set == 0)
6507 errmsg ("missing addresses\n");
6511 /* Construct the API message */
6512 M (IP_MROUTE_ADD_DEL, mp);
6514 mp->next_hop_sw_if_index = ntohl (sw_if_index);
6515 mp->table_id = ntohl (vrf_id);
6516 mp->create_vrf_if_needed = create_vrf_if_needed;
6518 mp->is_add = is_add;
6519 mp->is_ipv6 = is_ipv6;
6520 mp->is_local = is_local;
6521 mp->itf_flags = ntohl (iflags);
6522 mp->entry_flags = ntohl (eflags);
6523 mp->grp_address_length = grp_address_length;
6524 mp->grp_address_length = ntohs (mp->grp_address_length);
6528 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
6529 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
6533 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
6534 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
6540 /* Wait for a reply... */
6546 api_mpls_route_add_del (vat_main_t * vam)
6548 unformat_input_t *i = vam->input;
6549 vl_api_mpls_route_add_del_t *mp;
6550 u32 sw_if_index = ~0, table_id = 0;
6551 u8 create_table_if_needed = 0;
6553 u32 next_hop_weight = 1;
6554 u8 is_multipath = 0;
6555 u32 next_hop_table_id = 0;
6556 u8 next_hop_set = 0;
6557 ip4_address_t v4_next_hop_address = {
6560 ip6_address_t v6_next_hop_address = { {0} };
6564 u32 classify_table_index = ~0;
6566 u8 resolve_host = 0, resolve_attached = 0;
6567 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
6568 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6569 mpls_label_t *next_hop_out_label_stack = NULL;
6570 mpls_label_t local_label = MPLS_LABEL_INVALID;
6572 u8 next_hop_proto_is_ip4 = 1;
6574 /* Parse args required to build the message */
6575 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6577 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6579 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6581 else if (unformat (i, "%d", &local_label))
6583 else if (unformat (i, "eos"))
6585 else if (unformat (i, "non-eos"))
6587 else if (unformat (i, "via %U", unformat_ip4_address,
6588 &v4_next_hop_address))
6591 next_hop_proto_is_ip4 = 1;
6593 else if (unformat (i, "via %U", unformat_ip6_address,
6594 &v6_next_hop_address))
6597 next_hop_proto_is_ip4 = 0;
6599 else if (unformat (i, "weight %d", &next_hop_weight))
6601 else if (unformat (i, "create-table"))
6602 create_table_if_needed = 1;
6603 else if (unformat (i, "classify %d", &classify_table_index))
6607 else if (unformat (i, "del"))
6609 else if (unformat (i, "add"))
6611 else if (unformat (i, "resolve-via-host"))
6613 else if (unformat (i, "resolve-via-attached"))
6614 resolve_attached = 1;
6615 else if (unformat (i, "multipath"))
6617 else if (unformat (i, "count %d", &count))
6619 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
6622 next_hop_proto_is_ip4 = 1;
6624 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
6627 next_hop_proto_is_ip4 = 0;
6629 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6631 else if (unformat (i, "via-label %d", &next_hop_via_label))
6633 else if (unformat (i, "out-label %d", &next_hop_out_label))
6634 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
6637 clib_warning ("parse error '%U'", format_unformat_error, i);
6642 if (!next_hop_set && !is_classify)
6644 errmsg ("next hop / classify not set");
6648 if (MPLS_LABEL_INVALID == local_label)
6650 errmsg ("missing label");
6656 /* Turn on async mode */
6657 vam->async_mode = 1;
6658 vam->async_errors = 0;
6659 before = vat_time_now (vam);
6662 for (j = 0; j < count; j++)
6664 /* Construct the API message */
6665 M2 (MPLS_ROUTE_ADD_DEL, mp,
6666 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
6668 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
6669 mp->mr_table_id = ntohl (table_id);
6670 mp->mr_create_table_if_needed = create_table_if_needed;
6672 mp->mr_is_add = is_add;
6673 mp->mr_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
6674 mp->mr_is_classify = is_classify;
6675 mp->mr_is_multipath = is_multipath;
6676 mp->mr_is_resolve_host = resolve_host;
6677 mp->mr_is_resolve_attached = resolve_attached;
6678 mp->mr_next_hop_weight = next_hop_weight;
6679 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
6680 mp->mr_classify_table_index = ntohl (classify_table_index);
6681 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
6682 mp->mr_label = ntohl (local_label);
6683 mp->mr_eos = is_eos;
6685 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
6686 if (0 != mp->mr_next_hop_n_out_labels)
6688 memcpy (mp->mr_next_hop_out_label_stack,
6689 next_hop_out_label_stack,
6690 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
6691 vec_free (next_hop_out_label_stack);
6696 if (next_hop_proto_is_ip4)
6698 clib_memcpy (mp->mr_next_hop,
6699 &v4_next_hop_address,
6700 sizeof (v4_next_hop_address));
6704 clib_memcpy (mp->mr_next_hop,
6705 &v6_next_hop_address,
6706 sizeof (v6_next_hop_address));
6713 /* If we receive SIGTERM, stop now... */
6718 /* When testing multiple add/del ops, use a control-ping to sync */
6721 vl_api_control_ping_t *mp_ping;
6725 /* Shut off async mode */
6726 vam->async_mode = 0;
6728 M (CONTROL_PING, mp_ping);
6731 timeout = vat_time_now (vam) + 1.0;
6732 while (vat_time_now (vam) < timeout)
6733 if (vam->result_ready == 1)
6738 if (vam->retval == -99)
6741 if (vam->async_errors > 0)
6743 errmsg ("%d asynchronous errors", vam->async_errors);
6746 vam->async_errors = 0;
6747 after = vat_time_now (vam);
6749 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6753 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6754 count, after - before, count / (after - before));
6760 /* Wait for a reply... */
6765 /* Return the good/bad news */
6766 return (vam->retval);
6770 api_mpls_ip_bind_unbind (vat_main_t * vam)
6772 unformat_input_t *i = vam->input;
6773 vl_api_mpls_ip_bind_unbind_t *mp;
6774 u32 ip_table_id = 0;
6775 u8 create_table_if_needed = 0;
6778 ip4_address_t v4_address;
6779 ip6_address_t v6_address;
6782 mpls_label_t local_label = MPLS_LABEL_INVALID;
6785 /* Parse args required to build the message */
6786 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6788 if (unformat (i, "%U/%d", unformat_ip4_address,
6789 &v4_address, &address_length))
6794 else if (unformat (i, "%U/%d", unformat_ip6_address,
6795 &v6_address, &address_length))
6800 else if (unformat (i, "%d", &local_label))
6802 else if (unformat (i, "create-table"))
6803 create_table_if_needed = 1;
6804 else if (unformat (i, "table-id %d", &ip_table_id))
6806 else if (unformat (i, "unbind"))
6808 else if (unformat (i, "bind"))
6812 clib_warning ("parse error '%U'", format_unformat_error, i);
6819 errmsg ("IP addres not set");
6823 if (MPLS_LABEL_INVALID == local_label)
6825 errmsg ("missing label");
6829 /* Construct the API message */
6830 M (MPLS_IP_BIND_UNBIND, mp);
6832 mp->mb_create_table_if_needed = create_table_if_needed;
6833 mp->mb_is_bind = is_bind;
6834 mp->mb_is_ip4 = is_ip4;
6835 mp->mb_ip_table_id = ntohl (ip_table_id);
6836 mp->mb_mpls_table_id = 0;
6837 mp->mb_label = ntohl (local_label);
6838 mp->mb_address_length = address_length;
6841 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
6843 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
6848 /* Wait for a reply... */
6854 api_proxy_arp_add_del (vat_main_t * vam)
6856 unformat_input_t *i = vam->input;
6857 vl_api_proxy_arp_add_del_t *mp;
6860 ip4_address_t lo, hi;
6864 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6866 if (unformat (i, "vrf %d", &vrf_id))
6868 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
6869 unformat_ip4_address, &hi))
6871 else if (unformat (i, "del"))
6875 clib_warning ("parse error '%U'", format_unformat_error, i);
6882 errmsg ("address range not set");
6886 M (PROXY_ARP_ADD_DEL, mp);
6888 mp->vrf_id = ntohl (vrf_id);
6889 mp->is_add = is_add;
6890 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
6891 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
6899 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
6901 unformat_input_t *i = vam->input;
6902 vl_api_proxy_arp_intfc_enable_disable_t *mp;
6905 u8 sw_if_index_set = 0;
6908 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6910 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6911 sw_if_index_set = 1;
6912 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6913 sw_if_index_set = 1;
6914 else if (unformat (i, "enable"))
6916 else if (unformat (i, "disable"))
6920 clib_warning ("parse error '%U'", format_unformat_error, i);
6925 if (sw_if_index_set == 0)
6927 errmsg ("missing interface name or sw_if_index");
6931 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
6933 mp->sw_if_index = ntohl (sw_if_index);
6934 mp->enable_disable = enable;
6942 api_mpls_tunnel_add_del (vat_main_t * vam)
6944 unformat_input_t *i = vam->input;
6945 vl_api_mpls_tunnel_add_del_t *mp;
6949 u32 sw_if_index = ~0;
6950 u32 next_hop_sw_if_index = ~0;
6951 u32 next_hop_proto_is_ip4 = 1;
6953 u32 next_hop_table_id = 0;
6954 ip4_address_t v4_next_hop_address = {
6957 ip6_address_t v6_next_hop_address = { {0} };
6958 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID, *labels = NULL;
6961 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6963 if (unformat (i, "add"))
6965 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
6967 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
6969 else if (unformat (i, "via %U",
6970 unformat_ip4_address, &v4_next_hop_address))
6972 next_hop_proto_is_ip4 = 1;
6974 else if (unformat (i, "via %U",
6975 unformat_ip6_address, &v6_next_hop_address))
6977 next_hop_proto_is_ip4 = 0;
6979 else if (unformat (i, "l2-only"))
6981 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6983 else if (unformat (i, "out-label %d", &next_hop_out_label))
6984 vec_add1 (labels, ntohl (next_hop_out_label));
6987 clib_warning ("parse error '%U'", format_unformat_error, i);
6992 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (mpls_label_t) * vec_len (labels));
6994 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
6995 mp->mt_sw_if_index = ntohl (sw_if_index);
6996 mp->mt_is_add = is_add;
6997 mp->mt_l2_only = l2_only;
6998 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
6999 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
7001 mp->mt_next_hop_n_out_labels = vec_len (labels);
7003 if (0 != mp->mt_next_hop_n_out_labels)
7005 clib_memcpy (mp->mt_next_hop_out_label_stack, labels,
7006 sizeof (mpls_label_t) * mp->mt_next_hop_n_out_labels);
7010 if (next_hop_proto_is_ip4)
7012 clib_memcpy (mp->mt_next_hop,
7013 &v4_next_hop_address, sizeof (v4_next_hop_address));
7017 clib_memcpy (mp->mt_next_hop,
7018 &v6_next_hop_address, sizeof (v6_next_hop_address));
7027 api_sw_interface_set_unnumbered (vat_main_t * vam)
7029 unformat_input_t *i = vam->input;
7030 vl_api_sw_interface_set_unnumbered_t *mp;
7032 u32 unnum_sw_index = ~0;
7034 u8 sw_if_index_set = 0;
7037 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7039 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7040 sw_if_index_set = 1;
7041 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7042 sw_if_index_set = 1;
7043 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
7045 else if (unformat (i, "del"))
7049 clib_warning ("parse error '%U'", format_unformat_error, i);
7054 if (sw_if_index_set == 0)
7056 errmsg ("missing interface name or sw_if_index");
7060 M (SW_INTERFACE_SET_UNNUMBERED, mp);
7062 mp->sw_if_index = ntohl (sw_if_index);
7063 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
7064 mp->is_add = is_add;
7072 api_ip_neighbor_add_del (vat_main_t * vam)
7074 unformat_input_t *i = vam->input;
7075 vl_api_ip_neighbor_add_del_t *mp;
7077 u8 sw_if_index_set = 0;
7082 u8 v4_address_set = 0;
7083 u8 v6_address_set = 0;
7084 ip4_address_t v4address;
7085 ip6_address_t v6address;
7088 memset (mac_address, 0, sizeof (mac_address));
7090 /* Parse args required to build the message */
7091 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7093 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
7097 else if (unformat (i, "del"))
7100 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7101 sw_if_index_set = 1;
7102 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7103 sw_if_index_set = 1;
7104 else if (unformat (i, "is_static"))
7106 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
7108 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
7112 clib_warning ("parse error '%U'", format_unformat_error, i);
7117 if (sw_if_index_set == 0)
7119 errmsg ("missing interface name or sw_if_index");
7122 if (v4_address_set && v6_address_set)
7124 errmsg ("both v4 and v6 addresses set");
7127 if (!v4_address_set && !v6_address_set)
7129 errmsg ("no address set");
7133 /* Construct the API message */
7134 M (IP_NEIGHBOR_ADD_DEL, mp);
7136 mp->sw_if_index = ntohl (sw_if_index);
7137 mp->is_add = is_add;
7138 mp->is_static = is_static;
7140 clib_memcpy (mp->mac_address, mac_address, 6);
7144 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
7148 /* mp->is_ipv6 = 0; via memset in M macro above */
7149 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
7155 /* Wait for a reply, return good/bad news */
7161 api_reset_vrf (vat_main_t * vam)
7163 unformat_input_t *i = vam->input;
7164 vl_api_reset_vrf_t *mp;
7170 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7172 if (unformat (i, "vrf %d", &vrf_id))
7174 else if (unformat (i, "ipv6"))
7178 clib_warning ("parse error '%U'", format_unformat_error, i);
7183 if (vrf_id_set == 0)
7185 errmsg ("missing vrf id");
7191 mp->vrf_id = ntohl (vrf_id);
7192 mp->is_ipv6 = is_ipv6;
7200 api_create_vlan_subif (vat_main_t * vam)
7202 unformat_input_t *i = vam->input;
7203 vl_api_create_vlan_subif_t *mp;
7205 u8 sw_if_index_set = 0;
7210 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7212 if (unformat (i, "sw_if_index %d", &sw_if_index))
7213 sw_if_index_set = 1;
7215 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7216 sw_if_index_set = 1;
7217 else if (unformat (i, "vlan %d", &vlan_id))
7221 clib_warning ("parse error '%U'", format_unformat_error, i);
7226 if (sw_if_index_set == 0)
7228 errmsg ("missing interface name or sw_if_index");
7232 if (vlan_id_set == 0)
7234 errmsg ("missing vlan_id");
7237 M (CREATE_VLAN_SUBIF, mp);
7239 mp->sw_if_index = ntohl (sw_if_index);
7240 mp->vlan_id = ntohl (vlan_id);
7247 #define foreach_create_subif_bit \
7254 _(outer_vlan_id_any) \
7255 _(inner_vlan_id_any)
7258 api_create_subif (vat_main_t * vam)
7260 unformat_input_t *i = vam->input;
7261 vl_api_create_subif_t *mp;
7263 u8 sw_if_index_set = 0;
7270 u32 exact_match = 0;
7271 u32 default_sub = 0;
7272 u32 outer_vlan_id_any = 0;
7273 u32 inner_vlan_id_any = 0;
7275 u16 outer_vlan_id = 0;
7276 u16 inner_vlan_id = 0;
7279 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7281 if (unformat (i, "sw_if_index %d", &sw_if_index))
7282 sw_if_index_set = 1;
7284 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7285 sw_if_index_set = 1;
7286 else if (unformat (i, "sub_id %d", &sub_id))
7288 else if (unformat (i, "outer_vlan_id %d", &tmp))
7289 outer_vlan_id = tmp;
7290 else if (unformat (i, "inner_vlan_id %d", &tmp))
7291 inner_vlan_id = tmp;
7293 #define _(a) else if (unformat (i, #a)) a = 1 ;
7294 foreach_create_subif_bit
7298 clib_warning ("parse error '%U'", format_unformat_error, i);
7303 if (sw_if_index_set == 0)
7305 errmsg ("missing interface name or sw_if_index");
7309 if (sub_id_set == 0)
7311 errmsg ("missing sub_id");
7314 M (CREATE_SUBIF, mp);
7316 mp->sw_if_index = ntohl (sw_if_index);
7317 mp->sub_id = ntohl (sub_id);
7319 #define _(a) mp->a = a;
7320 foreach_create_subif_bit;
7323 mp->outer_vlan_id = ntohs (outer_vlan_id);
7324 mp->inner_vlan_id = ntohs (inner_vlan_id);
7332 api_oam_add_del (vat_main_t * vam)
7334 unformat_input_t *i = vam->input;
7335 vl_api_oam_add_del_t *mp;
7338 ip4_address_t src, dst;
7343 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7345 if (unformat (i, "vrf %d", &vrf_id))
7347 else if (unformat (i, "src %U", unformat_ip4_address, &src))
7349 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
7351 else if (unformat (i, "del"))
7355 clib_warning ("parse error '%U'", format_unformat_error, i);
7362 errmsg ("missing src addr");
7368 errmsg ("missing dst addr");
7372 M (OAM_ADD_DEL, mp);
7374 mp->vrf_id = ntohl (vrf_id);
7375 mp->is_add = is_add;
7376 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
7377 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
7385 api_reset_fib (vat_main_t * vam)
7387 unformat_input_t *i = vam->input;
7388 vl_api_reset_fib_t *mp;
7394 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7396 if (unformat (i, "vrf %d", &vrf_id))
7398 else if (unformat (i, "ipv6"))
7402 clib_warning ("parse error '%U'", format_unformat_error, i);
7407 if (vrf_id_set == 0)
7409 errmsg ("missing vrf id");
7415 mp->vrf_id = ntohl (vrf_id);
7416 mp->is_ipv6 = is_ipv6;
7424 api_dhcp_proxy_config (vat_main_t * vam)
7426 unformat_input_t *i = vam->input;
7427 vl_api_dhcp_proxy_config_t *mp;
7429 u32 server_vrf_id = 0;
7431 u8 v4_address_set = 0;
7432 u8 v6_address_set = 0;
7433 ip4_address_t v4address;
7434 ip6_address_t v6address;
7435 u8 v4_src_address_set = 0;
7436 u8 v6_src_address_set = 0;
7437 ip4_address_t v4srcaddress;
7438 ip6_address_t v6srcaddress;
7441 /* Parse args required to build the message */
7442 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7444 if (unformat (i, "del"))
7446 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
7448 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
7450 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
7452 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
7454 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
7455 v4_src_address_set = 1;
7456 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
7457 v6_src_address_set = 1;
7462 if (v4_address_set && v6_address_set)
7464 errmsg ("both v4 and v6 server addresses set");
7467 if (!v4_address_set && !v6_address_set)
7469 errmsg ("no server addresses set");
7473 if (v4_src_address_set && v6_src_address_set)
7475 errmsg ("both v4 and v6 src addresses set");
7478 if (!v4_src_address_set && !v6_src_address_set)
7480 errmsg ("no src addresses set");
7484 if (!(v4_src_address_set && v4_address_set) &&
7485 !(v6_src_address_set && v6_address_set))
7487 errmsg ("no matching server and src addresses set");
7491 /* Construct the API message */
7492 M (DHCP_PROXY_CONFIG, mp);
7494 mp->is_add = is_add;
7495 mp->rx_vrf_id = ntohl (rx_vrf_id);
7496 mp->server_vrf_id = ntohl (server_vrf_id);
7500 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
7501 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
7505 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
7506 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
7512 /* Wait for a reply, return good/bad news */
7517 #define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
7518 #define vl_api_dhcp_proxy_details_t_print vl_noop_handler
7521 vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
7523 vat_main_t *vam = &vat_main;
7527 "RX Table-ID %d, Server Table-ID %d, Server Address %U, Source Address %U, VSS FIB-ID %d, VSS OUI %d",
7528 ntohl (mp->rx_vrf_id),
7529 ntohl (mp->server_vrf_id),
7530 format_ip6_address, mp->dhcp_server,
7531 format_ip6_address, mp->dhcp_src_address,
7532 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
7535 "RX Table-ID %d, Server Table-ID %d, Server Address %U, Source Address %U, VSS FIB-ID %d, VSS OUI %d",
7536 ntohl (mp->rx_vrf_id),
7537 ntohl (mp->server_vrf_id),
7538 format_ip4_address, mp->dhcp_server,
7539 format_ip4_address, mp->dhcp_src_address,
7540 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
7543 static void vl_api_dhcp_proxy_details_t_handler_json
7544 (vl_api_dhcp_proxy_details_t * mp)
7546 vat_main_t *vam = &vat_main;
7547 vat_json_node_t *node = NULL;
7549 struct in6_addr ip6;
7551 if (VAT_JSON_ARRAY != vam->json_tree.type)
7553 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7554 vat_json_init_array (&vam->json_tree);
7556 node = vat_json_array_add (&vam->json_tree);
7558 vat_json_init_object (node);
7559 vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
7560 vat_json_object_add_uint (node, "server-table-id",
7561 ntohl (mp->server_vrf_id));
7564 clib_memcpy (&ip6, &mp->dhcp_server, sizeof (ip6));
7565 vat_json_object_add_ip6 (node, "server_address", ip6);
7566 clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
7567 vat_json_object_add_ip6 (node, "src_address", ip6);
7571 clib_memcpy (&ip4, &mp->dhcp_server, sizeof (ip4));
7572 vat_json_object_add_ip4 (node, "server_address", ip4);
7573 clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
7574 vat_json_object_add_ip4 (node, "src_address", ip4);
7576 vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
7577 vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
7581 api_dhcp_proxy_dump (vat_main_t * vam)
7583 unformat_input_t *i = vam->input;
7584 vl_api_control_ping_t *mp_ping;
7585 vl_api_dhcp_proxy_dump_t *mp;
7589 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7591 if (unformat (i, "ipv6"))
7595 clib_warning ("parse error '%U'", format_unformat_error, i);
7600 M (DHCP_PROXY_DUMP, mp);
7602 mp->is_ip6 = is_ipv6;
7605 /* Use a control ping for synchronization */
7606 M (CONTROL_PING, mp_ping);
7614 api_dhcp_proxy_set_vss (vat_main_t * vam)
7616 unformat_input_t *i = vam->input;
7617 vl_api_dhcp_proxy_set_vss_t *mp;
7628 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7630 if (unformat (i, "tbl_id %d", &tbl_id))
7632 if (unformat (i, "fib_id %d", &fib_id))
7634 if (unformat (i, "oui %d", &oui))
7636 else if (unformat (i, "ipv6"))
7638 else if (unformat (i, "del"))
7642 clib_warning ("parse error '%U'", format_unformat_error, i);
7647 if (tbl_id_set == 0)
7649 errmsg ("missing tbl id");
7653 if (fib_id_set == 0)
7655 errmsg ("missing fib id");
7660 errmsg ("missing oui");
7664 M (DHCP_PROXY_SET_VSS, mp);
7665 mp->tbl_id = ntohl (tbl_id);
7666 mp->fib_id = ntohl (fib_id);
7667 mp->oui = ntohl (oui);
7668 mp->is_ipv6 = is_ipv6;
7669 mp->is_add = is_add;
7677 api_dhcp_client_config (vat_main_t * vam)
7679 unformat_input_t *i = vam->input;
7680 vl_api_dhcp_client_config_t *mp;
7682 u8 sw_if_index_set = 0;
7685 u8 disable_event = 0;
7688 /* Parse args required to build the message */
7689 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7691 if (unformat (i, "del"))
7694 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7695 sw_if_index_set = 1;
7696 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7697 sw_if_index_set = 1;
7698 else if (unformat (i, "hostname %s", &hostname))
7700 else if (unformat (i, "disable_event"))
7706 if (sw_if_index_set == 0)
7708 errmsg ("missing interface name or sw_if_index");
7712 if (vec_len (hostname) > 63)
7714 errmsg ("hostname too long");
7716 vec_add1 (hostname, 0);
7718 /* Construct the API message */
7719 M (DHCP_CLIENT_CONFIG, mp);
7721 mp->sw_if_index = ntohl (sw_if_index);
7722 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
7723 vec_free (hostname);
7724 mp->is_add = is_add;
7725 mp->want_dhcp_event = disable_event ? 0 : 1;
7726 mp->pid = getpid ();
7731 /* Wait for a reply, return good/bad news */
7737 api_set_ip_flow_hash (vat_main_t * vam)
7739 unformat_input_t *i = vam->input;
7740 vl_api_set_ip_flow_hash_t *mp;
7752 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7754 if (unformat (i, "vrf %d", &vrf_id))
7756 else if (unformat (i, "ipv6"))
7758 else if (unformat (i, "src"))
7760 else if (unformat (i, "dst"))
7762 else if (unformat (i, "sport"))
7764 else if (unformat (i, "dport"))
7766 else if (unformat (i, "proto"))
7768 else if (unformat (i, "reverse"))
7773 clib_warning ("parse error '%U'", format_unformat_error, i);
7778 if (vrf_id_set == 0)
7780 errmsg ("missing vrf id");
7784 M (SET_IP_FLOW_HASH, mp);
7790 mp->reverse = reverse;
7791 mp->vrf_id = ntohl (vrf_id);
7792 mp->is_ipv6 = is_ipv6;
7800 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
7802 unformat_input_t *i = vam->input;
7803 vl_api_sw_interface_ip6_enable_disable_t *mp;
7805 u8 sw_if_index_set = 0;
7809 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7811 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7812 sw_if_index_set = 1;
7813 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7814 sw_if_index_set = 1;
7815 else if (unformat (i, "enable"))
7817 else if (unformat (i, "disable"))
7821 clib_warning ("parse error '%U'", format_unformat_error, i);
7826 if (sw_if_index_set == 0)
7828 errmsg ("missing interface name or sw_if_index");
7832 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
7834 mp->sw_if_index = ntohl (sw_if_index);
7835 mp->enable = enable;
7843 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
7845 unformat_input_t *i = vam->input;
7846 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
7848 u8 sw_if_index_set = 0;
7849 u8 v6_address_set = 0;
7850 ip6_address_t v6address;
7853 /* Parse args required to build the message */
7854 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7856 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7857 sw_if_index_set = 1;
7858 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7859 sw_if_index_set = 1;
7860 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
7866 if (sw_if_index_set == 0)
7868 errmsg ("missing interface name or sw_if_index");
7871 if (!v6_address_set)
7873 errmsg ("no address set");
7877 /* Construct the API message */
7878 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, mp);
7880 mp->sw_if_index = ntohl (sw_if_index);
7881 clib_memcpy (mp->address, &v6address, sizeof (v6address));
7886 /* Wait for a reply, return good/bad news */
7893 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
7895 unformat_input_t *i = vam->input;
7896 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
7898 u8 sw_if_index_set = 0;
7899 u32 address_length = 0;
7900 u8 v6_address_set = 0;
7901 ip6_address_t v6address;
7903 u8 no_advertise = 0;
7905 u8 no_autoconfig = 0;
7908 u32 val_lifetime = 0;
7909 u32 pref_lifetime = 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;
7919 else if (unformat (i, "%U/%d",
7920 unformat_ip6_address, &v6address, &address_length))
7922 else if (unformat (i, "val_life %d", &val_lifetime))
7924 else if (unformat (i, "pref_life %d", &pref_lifetime))
7926 else if (unformat (i, "def"))
7928 else if (unformat (i, "noadv"))
7930 else if (unformat (i, "offl"))
7932 else if (unformat (i, "noauto"))
7934 else if (unformat (i, "nolink"))
7936 else if (unformat (i, "isno"))
7940 clib_warning ("parse error '%U'", format_unformat_error, i);
7945 if (sw_if_index_set == 0)
7947 errmsg ("missing interface name or sw_if_index");
7950 if (!v6_address_set)
7952 errmsg ("no address set");
7956 /* Construct the API message */
7957 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
7959 mp->sw_if_index = ntohl (sw_if_index);
7960 clib_memcpy (mp->address, &v6address, sizeof (v6address));
7961 mp->address_length = address_length;
7962 mp->use_default = use_default;
7963 mp->no_advertise = no_advertise;
7964 mp->off_link = off_link;
7965 mp->no_autoconfig = no_autoconfig;
7966 mp->no_onlink = no_onlink;
7968 mp->val_lifetime = ntohl (val_lifetime);
7969 mp->pref_lifetime = ntohl (pref_lifetime);
7974 /* Wait for a reply, return good/bad news */
7980 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
7982 unformat_input_t *i = vam->input;
7983 vl_api_sw_interface_ip6nd_ra_config_t *mp;
7985 u8 sw_if_index_set = 0;
7990 u8 send_unicast = 0;
7993 u8 default_router = 0;
7994 u32 max_interval = 0;
7995 u32 min_interval = 0;
7997 u32 initial_count = 0;
7998 u32 initial_interval = 0;
8002 /* Parse args required to build the message */
8003 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8005 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8006 sw_if_index_set = 1;
8007 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8008 sw_if_index_set = 1;
8009 else if (unformat (i, "maxint %d", &max_interval))
8011 else if (unformat (i, "minint %d", &min_interval))
8013 else if (unformat (i, "life %d", &lifetime))
8015 else if (unformat (i, "count %d", &initial_count))
8017 else if (unformat (i, "interval %d", &initial_interval))
8019 else if (unformat (i, "suppress") || unformat (i, "surpress"))
8021 else if (unformat (i, "managed"))
8023 else if (unformat (i, "other"))
8025 else if (unformat (i, "ll"))
8027 else if (unformat (i, "send"))
8029 else if (unformat (i, "cease"))
8031 else if (unformat (i, "isno"))
8033 else if (unformat (i, "def"))
8037 clib_warning ("parse error '%U'", format_unformat_error, i);
8042 if (sw_if_index_set == 0)
8044 errmsg ("missing interface name or sw_if_index");
8048 /* Construct the API message */
8049 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
8051 mp->sw_if_index = ntohl (sw_if_index);
8052 mp->max_interval = ntohl (max_interval);
8053 mp->min_interval = ntohl (min_interval);
8054 mp->lifetime = ntohl (lifetime);
8055 mp->initial_count = ntohl (initial_count);
8056 mp->initial_interval = ntohl (initial_interval);
8057 mp->suppress = suppress;
8058 mp->managed = managed;
8060 mp->ll_option = ll_option;
8061 mp->send_unicast = send_unicast;
8064 mp->default_router = default_router;
8069 /* Wait for a reply, return good/bad news */
8075 api_set_arp_neighbor_limit (vat_main_t * vam)
8077 unformat_input_t *i = vam->input;
8078 vl_api_set_arp_neighbor_limit_t *mp;
8084 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8086 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
8088 else if (unformat (i, "ipv6"))
8092 clib_warning ("parse error '%U'", format_unformat_error, i);
8099 errmsg ("missing limit value");
8103 M (SET_ARP_NEIGHBOR_LIMIT, mp);
8105 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
8106 mp->is_ipv6 = is_ipv6;
8114 api_l2_patch_add_del (vat_main_t * vam)
8116 unformat_input_t *i = vam->input;
8117 vl_api_l2_patch_add_del_t *mp;
8119 u8 rx_sw_if_index_set = 0;
8121 u8 tx_sw_if_index_set = 0;
8125 /* Parse args required to build the message */
8126 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8128 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
8129 rx_sw_if_index_set = 1;
8130 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
8131 tx_sw_if_index_set = 1;
8132 else if (unformat (i, "rx"))
8134 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8136 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
8138 rx_sw_if_index_set = 1;
8143 else if (unformat (i, "tx"))
8145 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8147 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
8149 tx_sw_if_index_set = 1;
8154 else if (unformat (i, "del"))
8160 if (rx_sw_if_index_set == 0)
8162 errmsg ("missing rx interface name or rx_sw_if_index");
8166 if (tx_sw_if_index_set == 0)
8168 errmsg ("missing tx interface name or tx_sw_if_index");
8172 M (L2_PATCH_ADD_DEL, mp);
8174 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
8175 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
8176 mp->is_add = is_add;
8184 api_ioam_enable (vat_main_t * vam)
8186 unformat_input_t *input = vam->input;
8187 vl_api_ioam_enable_t *mp;
8189 int has_trace_option = 0;
8190 int has_pot_option = 0;
8191 int has_seqno_option = 0;
8192 int has_analyse_option = 0;
8195 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8197 if (unformat (input, "trace"))
8198 has_trace_option = 1;
8199 else if (unformat (input, "pot"))
8201 else if (unformat (input, "seqno"))
8202 has_seqno_option = 1;
8203 else if (unformat (input, "analyse"))
8204 has_analyse_option = 1;
8208 M (IOAM_ENABLE, mp);
8209 mp->id = htons (id);
8210 mp->seqno = has_seqno_option;
8211 mp->analyse = has_analyse_option;
8212 mp->pot_enable = has_pot_option;
8213 mp->trace_enable = has_trace_option;
8222 api_ioam_disable (vat_main_t * vam)
8224 vl_api_ioam_disable_t *mp;
8227 M (IOAM_DISABLE, mp);
8234 api_sr_tunnel_add_del (vat_main_t * vam)
8236 unformat_input_t *i = vam->input;
8237 vl_api_sr_tunnel_add_del_t *mp;
8240 ip6_address_t src_address;
8241 int src_address_set = 0;
8242 ip6_address_t dst_address;
8244 int dst_address_set = 0;
8246 u32 rx_table_id = 0;
8247 u32 tx_table_id = 0;
8248 ip6_address_t *segments = 0;
8249 ip6_address_t *this_seg;
8250 ip6_address_t *tags = 0;
8251 ip6_address_t *this_tag;
8252 ip6_address_t next_address, tag;
8254 u8 *policy_name = 0;
8257 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8259 if (unformat (i, "del"))
8261 else if (unformat (i, "name %s", &name))
8263 else if (unformat (i, "policy %s", &policy_name))
8265 else if (unformat (i, "rx_fib_id %d", &rx_table_id))
8267 else if (unformat (i, "tx_fib_id %d", &tx_table_id))
8269 else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
8270 src_address_set = 1;
8271 else if (unformat (i, "dst %U/%d",
8272 unformat_ip6_address, &dst_address, &dst_mask_width))
8273 dst_address_set = 1;
8274 else if (unformat (i, "next %U", unformat_ip6_address, &next_address))
8276 vec_add2 (segments, this_seg, 1);
8277 clib_memcpy (this_seg->as_u8, next_address.as_u8,
8278 sizeof (*this_seg));
8280 else if (unformat (i, "tag %U", unformat_ip6_address, &tag))
8282 vec_add2 (tags, this_tag, 1);
8283 clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
8285 else if (unformat (i, "clean"))
8286 flags |= IP6_SR_HEADER_FLAG_CLEANUP;
8287 else if (unformat (i, "protected"))
8288 flags |= IP6_SR_HEADER_FLAG_PROTECTED;
8289 else if (unformat (i, "InPE %d", &pl_index))
8291 if (pl_index <= 0 || pl_index > 4)
8293 pl_index_range_error:
8294 errmsg ("pl index %d out of range", pl_index);
8298 IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE << (3 * (pl_index - 1));
8300 else if (unformat (i, "EgPE %d", &pl_index))
8302 if (pl_index <= 0 || pl_index > 4)
8303 goto pl_index_range_error;
8305 IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE << (3 * (pl_index - 1));
8307 else if (unformat (i, "OrgSrc %d", &pl_index))
8309 if (pl_index <= 0 || pl_index > 4)
8310 goto pl_index_range_error;
8312 IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3 * (pl_index - 1));
8318 if (!src_address_set)
8320 errmsg ("src address required");
8324 if (!dst_address_set)
8326 errmsg ("dst address required");
8332 errmsg ("at least one sr segment required");
8336 M2 (SR_TUNNEL_ADD_DEL, mp,
8337 vec_len (segments) * sizeof (ip6_address_t)
8338 + vec_len (tags) * sizeof (ip6_address_t));
8340 clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
8341 clib_memcpy (mp->dst_address, &dst_address, sizeof (mp->dst_address));
8342 mp->dst_mask_width = dst_mask_width;
8343 mp->flags_net_byte_order = clib_host_to_net_u16 (flags);
8344 mp->n_segments = vec_len (segments);
8345 mp->n_tags = vec_len (tags);
8346 mp->is_add = is_del == 0;
8347 clib_memcpy (mp->segs_and_tags, segments,
8348 vec_len (segments) * sizeof (ip6_address_t));
8349 clib_memcpy (mp->segs_and_tags +
8350 vec_len (segments) * sizeof (ip6_address_t), tags,
8351 vec_len (tags) * sizeof (ip6_address_t));
8353 mp->outer_vrf_id = ntohl (rx_table_id);
8354 mp->inner_vrf_id = ntohl (tx_table_id);
8355 memcpy (mp->name, name, vec_len (name));
8356 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
8358 vec_free (segments);
8367 api_sr_policy_add_del (vat_main_t * vam)
8369 unformat_input_t *input = vam->input;
8370 vl_api_sr_policy_add_del_t *mp;
8373 u8 *tunnel_name = 0;
8374 u8 **tunnel_names = 0;
8379 int tunnel_names_length = 1; // Init to 1 to offset the #tunnel_names counter byte
8380 int tun_name_len = 0; // Different naming convention used as confusing these would be "bad" (TM)
8383 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8385 if (unformat (input, "del"))
8387 else if (unformat (input, "name %s", &name))
8389 else if (unformat (input, "tunnel %s", &tunnel_name))
8393 vec_add1 (tunnel_names, tunnel_name);
8395 - length = #bytes to store in serial vector
8396 - +1 = byte to store that length
8398 tunnel_names_length += (vec_len (tunnel_name) + 1);
8409 errmsg ("policy name required");
8413 if ((!tunnel_set) && (!is_del))
8415 errmsg ("tunnel name required");
8419 M2 (SR_POLICY_ADD_DEL, mp, tunnel_names_length);
8423 mp->is_add = !is_del;
8425 memcpy (mp->name, name, vec_len (name));
8426 // Since mp->tunnel_names is of type u8[0] and not a u8 *, u8 ** needs to be serialized
8427 u8 *serial_orig = 0;
8428 vec_validate (serial_orig, tunnel_names_length);
8429 *serial_orig = vec_len (tunnel_names); // Store the number of tunnels as length in first byte of serialized vector
8430 serial_orig += 1; // Move along one byte to store the length of first tunnel_name
8432 for (j = 0; j < vec_len (tunnel_names); j++)
8434 tun_name_len = vec_len (tunnel_names[j]);
8435 *serial_orig = tun_name_len; // Store length of tunnel name in first byte of Length/Value pair
8436 serial_orig += 1; // Move along one byte to store the actual tunnel name
8437 memcpy (serial_orig, tunnel_names[j], tun_name_len);
8438 serial_orig += tun_name_len; // Advance past the copy
8440 memcpy (mp->tunnel_names, serial_orig - tunnel_names_length, tunnel_names_length); // Regress serial_orig to head then copy fwd
8442 vec_free (tunnel_names);
8443 vec_free (tunnel_name);
8451 api_sr_multicast_map_add_del (vat_main_t * vam)
8453 unformat_input_t *input = vam->input;
8454 vl_api_sr_multicast_map_add_del_t *mp;
8456 ip6_address_t multicast_address;
8457 u8 *policy_name = 0;
8458 int multicast_address_set = 0;
8461 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8463 if (unformat (input, "del"))
8467 (input, "address %U", unformat_ip6_address, &multicast_address))
8468 multicast_address_set = 1;
8469 else if (unformat (input, "sr-policy %s", &policy_name))
8475 if (!is_del && !policy_name)
8477 errmsg ("sr-policy name required");
8482 if (!multicast_address_set)
8484 errmsg ("address required");
8488 M (SR_MULTICAST_MAP_ADD_DEL, mp);
8490 mp->is_add = !is_del;
8491 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
8492 clib_memcpy (mp->multicast_address, &multicast_address,
8493 sizeof (mp->multicast_address));
8496 vec_free (policy_name);
8504 #define foreach_tcp_proto_field \
8508 #define foreach_udp_proto_field \
8512 #define foreach_ip4_proto_field \
8524 u16 src_port, dst_port;
8527 #if VPP_API_TEST_BUILTIN == 0
8529 unformat_tcp_mask (unformat_input_t * input, va_list * args)
8531 u8 **maskp = va_arg (*args, u8 **);
8533 u8 found_something = 0;
8536 #define _(a) u8 a=0;
8537 foreach_tcp_proto_field;
8540 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8543 #define _(a) else if (unformat (input, #a)) a=1;
8544 foreach_tcp_proto_field
8550 #define _(a) found_something += a;
8551 foreach_tcp_proto_field;
8554 if (found_something == 0)
8557 vec_validate (mask, sizeof (*tcp) - 1);
8559 tcp = (tcp_header_t *) mask;
8561 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
8562 foreach_tcp_proto_field;
8570 unformat_udp_mask (unformat_input_t * input, va_list * args)
8572 u8 **maskp = va_arg (*args, u8 **);
8574 u8 found_something = 0;
8577 #define _(a) u8 a=0;
8578 foreach_udp_proto_field;
8581 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8584 #define _(a) else if (unformat (input, #a)) a=1;
8585 foreach_udp_proto_field
8591 #define _(a) found_something += a;
8592 foreach_udp_proto_field;
8595 if (found_something == 0)
8598 vec_validate (mask, sizeof (*udp) - 1);
8600 udp = (udp_header_t *) mask;
8602 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
8603 foreach_udp_proto_field;
8611 unformat_l4_mask (unformat_input_t * input, va_list * args)
8613 u8 **maskp = va_arg (*args, u8 **);
8614 u16 src_port = 0, dst_port = 0;
8615 tcpudp_header_t *tcpudp;
8617 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8619 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
8621 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
8623 else if (unformat (input, "src_port"))
8625 else if (unformat (input, "dst_port"))
8631 if (!src_port && !dst_port)
8635 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
8637 tcpudp = (tcpudp_header_t *) mask;
8638 tcpudp->src_port = src_port;
8639 tcpudp->dst_port = dst_port;
8647 unformat_ip4_mask (unformat_input_t * input, va_list * args)
8649 u8 **maskp = va_arg (*args, u8 **);
8651 u8 found_something = 0;
8654 #define _(a) u8 a=0;
8655 foreach_ip4_proto_field;
8661 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8663 if (unformat (input, "version"))
8665 else if (unformat (input, "hdr_length"))
8667 else if (unformat (input, "src"))
8669 else if (unformat (input, "dst"))
8671 else if (unformat (input, "proto"))
8674 #define _(a) else if (unformat (input, #a)) a=1;
8675 foreach_ip4_proto_field
8681 #define _(a) found_something += a;
8682 foreach_ip4_proto_field;
8685 if (found_something == 0)
8688 vec_validate (mask, sizeof (*ip) - 1);
8690 ip = (ip4_header_t *) mask;
8692 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
8693 foreach_ip4_proto_field;
8696 ip->ip_version_and_header_length = 0;
8699 ip->ip_version_and_header_length |= 0xF0;
8702 ip->ip_version_and_header_length |= 0x0F;
8708 #define foreach_ip6_proto_field \
8716 unformat_ip6_mask (unformat_input_t * input, va_list * args)
8718 u8 **maskp = va_arg (*args, u8 **);
8720 u8 found_something = 0;
8722 u32 ip_version_traffic_class_and_flow_label;
8724 #define _(a) u8 a=0;
8725 foreach_ip6_proto_field;
8728 u8 traffic_class = 0;
8731 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8733 if (unformat (input, "version"))
8735 else if (unformat (input, "traffic-class"))
8737 else if (unformat (input, "flow-label"))
8739 else if (unformat (input, "src"))
8741 else if (unformat (input, "dst"))
8743 else if (unformat (input, "proto"))
8746 #define _(a) else if (unformat (input, #a)) a=1;
8747 foreach_ip6_proto_field
8753 #define _(a) found_something += a;
8754 foreach_ip6_proto_field;
8757 if (found_something == 0)
8760 vec_validate (mask, sizeof (*ip) - 1);
8762 ip = (ip6_header_t *) mask;
8764 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
8765 foreach_ip6_proto_field;
8768 ip_version_traffic_class_and_flow_label = 0;
8771 ip_version_traffic_class_and_flow_label |= 0xF0000000;
8774 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
8777 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
8779 ip->ip_version_traffic_class_and_flow_label =
8780 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
8787 unformat_l3_mask (unformat_input_t * input, va_list * args)
8789 u8 **maskp = va_arg (*args, u8 **);
8791 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8793 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
8795 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
8804 unformat_l2_mask (unformat_input_t * input, va_list * args)
8806 u8 **maskp = va_arg (*args, u8 **);
8821 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8823 if (unformat (input, "src"))
8825 else if (unformat (input, "dst"))
8827 else if (unformat (input, "proto"))
8829 else if (unformat (input, "tag1"))
8831 else if (unformat (input, "tag2"))
8833 else if (unformat (input, "ignore-tag1"))
8835 else if (unformat (input, "ignore-tag2"))
8837 else if (unformat (input, "cos1"))
8839 else if (unformat (input, "cos2"))
8841 else if (unformat (input, "dot1q"))
8843 else if (unformat (input, "dot1ad"))
8848 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
8849 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
8852 if (tag1 || ignore_tag1 || cos1 || dot1q)
8854 if (tag2 || ignore_tag2 || cos2 || dot1ad)
8857 vec_validate (mask, len - 1);
8860 memset (mask, 0xff, 6);
8863 memset (mask + 6, 0xff, 6);
8867 /* inner vlan tag */
8876 mask[21] = mask[20] = 0xff;
8897 mask[16] = mask[17] = 0xff;
8907 mask[12] = mask[13] = 0xff;
8914 unformat_classify_mask (unformat_input_t * input, va_list * args)
8916 u8 **maskp = va_arg (*args, u8 **);
8917 u32 *skipp = va_arg (*args, u32 *);
8918 u32 *matchp = va_arg (*args, u32 *);
8926 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8928 if (unformat (input, "hex %U", unformat_hex_string, &mask))
8930 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
8932 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
8934 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
8948 if (mask || l2 || l3 || l4)
8952 /* "With a free Ethernet header in every package" */
8954 vec_validate (l2, 13);
8958 vec_append (mask, l3);
8963 vec_append (mask, l4);
8968 /* Scan forward looking for the first significant mask octet */
8969 for (i = 0; i < vec_len (mask); i++)
8973 /* compute (skip, match) params */
8974 *skipp = i / sizeof (u32x4);
8975 vec_delete (mask, *skipp * sizeof (u32x4), 0);
8977 /* Pad mask to an even multiple of the vector size */
8978 while (vec_len (mask) % sizeof (u32x4))
8981 match = vec_len (mask) / sizeof (u32x4);
8983 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
8985 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
8986 if (*tmp || *(tmp + 1))
8991 clib_warning ("BUG: match 0");
8993 _vec_len (mask) = match * sizeof (u32x4);
9003 #endif /* VPP_API_TEST_BUILTIN */
9005 #define foreach_l2_next \
9007 _(ethernet, ETHERNET_INPUT) \
9012 unformat_l2_next_index (unformat_input_t * input, va_list * args)
9014 u32 *miss_next_indexp = va_arg (*args, u32 *);
9019 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
9023 if (unformat (input, "%d", &tmp))
9032 *miss_next_indexp = next_index;
9036 #define foreach_ip_next \
9042 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
9044 u32 *miss_next_indexp = va_arg (*args, u32 *);
9049 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
9053 if (unformat (input, "%d", &tmp))
9062 *miss_next_indexp = next_index;
9066 #define foreach_acl_next \
9070 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
9072 u32 *miss_next_indexp = va_arg (*args, u32 *);
9077 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
9081 if (unformat (input, "permit"))
9086 else if (unformat (input, "%d", &tmp))
9095 *miss_next_indexp = next_index;
9100 unformat_policer_precolor (unformat_input_t * input, va_list * args)
9102 u32 *r = va_arg (*args, u32 *);
9104 if (unformat (input, "conform-color"))
9105 *r = POLICE_CONFORM;
9106 else if (unformat (input, "exceed-color"))
9115 api_classify_add_del_table (vat_main_t * vam)
9117 unformat_input_t *i = vam->input;
9118 vl_api_classify_add_del_table_t *mp;
9125 u32 table_index = ~0;
9126 u32 next_table_index = ~0;
9127 u32 miss_next_index = ~0;
9128 u32 memory_size = 32 << 20;
9130 u32 current_data_flag = 0;
9131 int current_data_offset = 0;
9134 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9136 if (unformat (i, "del"))
9138 else if (unformat (i, "del-chain"))
9143 else if (unformat (i, "buckets %d", &nbuckets))
9145 else if (unformat (i, "memory_size %d", &memory_size))
9147 else if (unformat (i, "skip %d", &skip))
9149 else if (unformat (i, "match %d", &match))
9151 else if (unformat (i, "table %d", &table_index))
9153 else if (unformat (i, "mask %U", unformat_classify_mask,
9154 &mask, &skip, &match))
9156 else if (unformat (i, "next-table %d", &next_table_index))
9158 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
9161 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
9164 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
9167 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
9169 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
9175 if (is_add && mask == 0)
9177 errmsg ("Mask required");
9181 if (is_add && skip == ~0)
9183 errmsg ("skip count required");
9187 if (is_add && match == ~0)
9189 errmsg ("match count required");
9193 if (!is_add && table_index == ~0)
9195 errmsg ("table index required for delete");
9199 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
9201 mp->is_add = is_add;
9202 mp->del_chain = del_chain;
9203 mp->table_index = ntohl (table_index);
9204 mp->nbuckets = ntohl (nbuckets);
9205 mp->memory_size = ntohl (memory_size);
9206 mp->skip_n_vectors = ntohl (skip);
9207 mp->match_n_vectors = ntohl (match);
9208 mp->next_table_index = ntohl (next_table_index);
9209 mp->miss_next_index = ntohl (miss_next_index);
9210 mp->current_data_flag = ntohl (current_data_flag);
9211 mp->current_data_offset = ntohl (current_data_offset);
9212 clib_memcpy (mp->mask, mask, vec_len (mask));
9221 #if VPP_API_TEST_BUILTIN == 0
9223 unformat_l4_match (unformat_input_t * input, va_list * args)
9225 u8 **matchp = va_arg (*args, u8 **);
9227 u8 *proto_header = 0;
9233 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9235 if (unformat (input, "src_port %d", &src_port))
9237 else if (unformat (input, "dst_port %d", &dst_port))
9243 h.src_port = clib_host_to_net_u16 (src_port);
9244 h.dst_port = clib_host_to_net_u16 (dst_port);
9245 vec_validate (proto_header, sizeof (h) - 1);
9246 memcpy (proto_header, &h, sizeof (h));
9248 *matchp = proto_header;
9254 unformat_ip4_match (unformat_input_t * input, va_list * args)
9256 u8 **matchp = va_arg (*args, u8 **);
9263 int src = 0, dst = 0;
9264 ip4_address_t src_val, dst_val;
9271 int fragment_id = 0;
9272 u32 fragment_id_val;
9278 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9280 if (unformat (input, "version %d", &version_val))
9282 else if (unformat (input, "hdr_length %d", &hdr_length_val))
9284 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
9286 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
9288 else if (unformat (input, "proto %d", &proto_val))
9290 else if (unformat (input, "tos %d", &tos_val))
9292 else if (unformat (input, "length %d", &length_val))
9294 else if (unformat (input, "fragment_id %d", &fragment_id_val))
9296 else if (unformat (input, "ttl %d", &ttl_val))
9298 else if (unformat (input, "checksum %d", &checksum_val))
9304 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
9305 + ttl + checksum == 0)
9309 * Aligned because we use the real comparison functions
9311 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
9313 ip = (ip4_header_t *) match;
9315 /* These are realistically matched in practice */
9317 ip->src_address.as_u32 = src_val.as_u32;
9320 ip->dst_address.as_u32 = dst_val.as_u32;
9323 ip->protocol = proto_val;
9326 /* These are not, but they're included for completeness */
9328 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
9331 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
9337 ip->length = clib_host_to_net_u16 (length_val);
9343 ip->checksum = clib_host_to_net_u16 (checksum_val);
9350 unformat_ip6_match (unformat_input_t * input, va_list * args)
9352 u8 **matchp = va_arg (*args, u8 **);
9357 u8 traffic_class = 0;
9358 u32 traffic_class_val = 0;
9361 int src = 0, dst = 0;
9362 ip6_address_t src_val, dst_val;
9365 int payload_length = 0;
9366 u32 payload_length_val;
9369 u32 ip_version_traffic_class_and_flow_label;
9371 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9373 if (unformat (input, "version %d", &version_val))
9375 else if (unformat (input, "traffic_class %d", &traffic_class_val))
9377 else if (unformat (input, "flow_label %d", &flow_label_val))
9379 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
9381 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
9383 else if (unformat (input, "proto %d", &proto_val))
9385 else if (unformat (input, "payload_length %d", &payload_length_val))
9387 else if (unformat (input, "hop_limit %d", &hop_limit_val))
9393 if (version + traffic_class + flow_label + src + dst + proto +
9394 payload_length + hop_limit == 0)
9398 * Aligned because we use the real comparison functions
9400 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
9402 ip = (ip6_header_t *) match;
9405 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
9408 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
9411 ip->protocol = proto_val;
9413 ip_version_traffic_class_and_flow_label = 0;
9416 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
9419 ip_version_traffic_class_and_flow_label |=
9420 (traffic_class_val & 0xFF) << 20;
9423 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
9425 ip->ip_version_traffic_class_and_flow_label =
9426 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9429 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
9432 ip->hop_limit = hop_limit_val;
9439 unformat_l3_match (unformat_input_t * input, va_list * args)
9441 u8 **matchp = va_arg (*args, u8 **);
9443 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9445 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
9447 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
9456 unformat_vlan_tag (unformat_input_t * input, va_list * args)
9458 u8 *tagp = va_arg (*args, u8 *);
9461 if (unformat (input, "%d", &tag))
9463 tagp[0] = (tag >> 8) & 0x0F;
9464 tagp[1] = tag & 0xFF;
9472 unformat_l2_match (unformat_input_t * input, va_list * args)
9474 u8 **matchp = va_arg (*args, u8 **);
9494 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9496 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
9499 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
9501 else if (unformat (input, "proto %U",
9502 unformat_ethernet_type_host_byte_order, &proto_val))
9504 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
9506 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
9508 else if (unformat (input, "ignore-tag1"))
9510 else if (unformat (input, "ignore-tag2"))
9512 else if (unformat (input, "cos1 %d", &cos1_val))
9514 else if (unformat (input, "cos2 %d", &cos2_val))
9519 if ((src + dst + proto + tag1 + tag2 +
9520 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9523 if (tag1 || ignore_tag1 || cos1)
9525 if (tag2 || ignore_tag2 || cos2)
9528 vec_validate_aligned (match, len - 1, sizeof (u32x4));
9531 clib_memcpy (match, dst_val, 6);
9534 clib_memcpy (match + 6, src_val, 6);
9538 /* inner vlan tag */
9539 match[19] = tag2_val[1];
9540 match[18] = tag2_val[0];
9542 match[18] |= (cos2_val & 0x7) << 5;
9545 match[21] = proto_val & 0xff;
9546 match[20] = proto_val >> 8;
9550 match[15] = tag1_val[1];
9551 match[14] = tag1_val[0];
9554 match[14] |= (cos1_val & 0x7) << 5;
9560 match[15] = tag1_val[1];
9561 match[14] = tag1_val[0];
9564 match[17] = proto_val & 0xff;
9565 match[16] = proto_val >> 8;
9568 match[14] |= (cos1_val & 0x7) << 5;
9574 match[18] |= (cos2_val & 0x7) << 5;
9576 match[14] |= (cos1_val & 0x7) << 5;
9579 match[13] = proto_val & 0xff;
9580 match[12] = proto_val >> 8;
9589 api_unformat_classify_match (unformat_input_t * input, va_list * args)
9591 u8 **matchp = va_arg (*args, u8 **);
9592 u32 skip_n_vectors = va_arg (*args, u32);
9593 u32 match_n_vectors = va_arg (*args, u32);
9600 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9602 if (unformat (input, "hex %U", unformat_hex_string, &match))
9604 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
9606 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
9608 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
9622 if (match || l2 || l3 || l4)
9626 /* "Win a free Ethernet header in every packet" */
9628 vec_validate_aligned (l2, 13, sizeof (u32x4));
9632 vec_append_aligned (match, l3, sizeof (u32x4));
9637 vec_append_aligned (match, l4, sizeof (u32x4));
9642 /* Make sure the vector is big enough even if key is all 0's */
9643 vec_validate_aligned
9644 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
9647 /* Set size, include skipped vectors */
9648 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
9659 api_classify_add_del_session (vat_main_t * vam)
9661 unformat_input_t *i = vam->input;
9662 vl_api_classify_add_del_session_t *mp;
9664 u32 table_index = ~0;
9665 u32 hit_next_index = ~0;
9666 u32 opaque_index = ~0;
9669 u32 skip_n_vectors = 0;
9670 u32 match_n_vectors = 0;
9676 * Warning: you have to supply skip_n and match_n
9677 * because the API client cant simply look at the classify
9681 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9683 if (unformat (i, "del"))
9685 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
9688 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
9691 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
9694 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
9696 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
9698 else if (unformat (i, "opaque-index %d", &opaque_index))
9700 else if (unformat (i, "skip_n %d", &skip_n_vectors))
9702 else if (unformat (i, "match_n %d", &match_n_vectors))
9704 else if (unformat (i, "match %U", api_unformat_classify_match,
9705 &match, skip_n_vectors, match_n_vectors))
9707 else if (unformat (i, "advance %d", &advance))
9709 else if (unformat (i, "table-index %d", &table_index))
9711 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
9713 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
9715 else if (unformat (i, "action %d", &action))
9717 else if (unformat (i, "metadata %d", &metadata))
9723 if (table_index == ~0)
9725 errmsg ("Table index required");
9729 if (is_add && match == 0)
9731 errmsg ("Match value required");
9735 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
9737 mp->is_add = is_add;
9738 mp->table_index = ntohl (table_index);
9739 mp->hit_next_index = ntohl (hit_next_index);
9740 mp->opaque_index = ntohl (opaque_index);
9741 mp->advance = ntohl (advance);
9742 mp->action = action;
9743 mp->metadata = ntohl (metadata);
9744 clib_memcpy (mp->match, match, vec_len (match));
9753 api_classify_set_interface_ip_table (vat_main_t * vam)
9755 unformat_input_t *i = vam->input;
9756 vl_api_classify_set_interface_ip_table_t *mp;
9758 int sw_if_index_set;
9759 u32 table_index = ~0;
9763 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9765 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9766 sw_if_index_set = 1;
9767 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9768 sw_if_index_set = 1;
9769 else if (unformat (i, "table %d", &table_index))
9773 clib_warning ("parse error '%U'", format_unformat_error, i);
9778 if (sw_if_index_set == 0)
9780 errmsg ("missing interface name or sw_if_index");
9785 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
9787 mp->sw_if_index = ntohl (sw_if_index);
9788 mp->table_index = ntohl (table_index);
9789 mp->is_ipv6 = is_ipv6;
9797 api_classify_set_interface_l2_tables (vat_main_t * vam)
9799 unformat_input_t *i = vam->input;
9800 vl_api_classify_set_interface_l2_tables_t *mp;
9802 int sw_if_index_set;
9803 u32 ip4_table_index = ~0;
9804 u32 ip6_table_index = ~0;
9805 u32 other_table_index = ~0;
9809 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9811 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9812 sw_if_index_set = 1;
9813 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9814 sw_if_index_set = 1;
9815 else if (unformat (i, "ip4-table %d", &ip4_table_index))
9817 else if (unformat (i, "ip6-table %d", &ip6_table_index))
9819 else if (unformat (i, "other-table %d", &other_table_index))
9821 else if (unformat (i, "is-input %d", &is_input))
9825 clib_warning ("parse error '%U'", format_unformat_error, i);
9830 if (sw_if_index_set == 0)
9832 errmsg ("missing interface name or sw_if_index");
9837 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
9839 mp->sw_if_index = ntohl (sw_if_index);
9840 mp->ip4_table_index = ntohl (ip4_table_index);
9841 mp->ip6_table_index = ntohl (ip6_table_index);
9842 mp->other_table_index = ntohl (other_table_index);
9843 mp->is_input = (u8) is_input;
9851 api_set_ipfix_exporter (vat_main_t * vam)
9853 unformat_input_t *i = vam->input;
9854 vl_api_set_ipfix_exporter_t *mp;
9855 ip4_address_t collector_address;
9856 u8 collector_address_set = 0;
9857 u32 collector_port = ~0;
9858 ip4_address_t src_address;
9859 u8 src_address_set = 0;
9862 u32 template_interval = ~0;
9863 u8 udp_checksum = 0;
9866 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9868 if (unformat (i, "collector_address %U", unformat_ip4_address,
9869 &collector_address))
9870 collector_address_set = 1;
9871 else if (unformat (i, "collector_port %d", &collector_port))
9873 else if (unformat (i, "src_address %U", unformat_ip4_address,
9875 src_address_set = 1;
9876 else if (unformat (i, "vrf_id %d", &vrf_id))
9878 else if (unformat (i, "path_mtu %d", &path_mtu))
9880 else if (unformat (i, "template_interval %d", &template_interval))
9882 else if (unformat (i, "udp_checksum"))
9888 if (collector_address_set == 0)
9890 errmsg ("collector_address required");
9894 if (src_address_set == 0)
9896 errmsg ("src_address required");
9900 M (SET_IPFIX_EXPORTER, mp);
9902 memcpy (mp->collector_address, collector_address.data,
9903 sizeof (collector_address.data));
9904 mp->collector_port = htons ((u16) collector_port);
9905 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
9906 mp->vrf_id = htonl (vrf_id);
9907 mp->path_mtu = htonl (path_mtu);
9908 mp->template_interval = htonl (template_interval);
9909 mp->udp_checksum = udp_checksum;
9917 api_set_ipfix_classify_stream (vat_main_t * vam)
9919 unformat_input_t *i = vam->input;
9920 vl_api_set_ipfix_classify_stream_t *mp;
9922 u32 src_port = UDP_DST_PORT_ipfix;
9925 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9927 if (unformat (i, "domain %d", &domain_id))
9929 else if (unformat (i, "src_port %d", &src_port))
9933 errmsg ("unknown input `%U'", format_unformat_error, i);
9938 M (SET_IPFIX_CLASSIFY_STREAM, mp);
9940 mp->domain_id = htonl (domain_id);
9941 mp->src_port = htons ((u16) src_port);
9949 api_ipfix_classify_table_add_del (vat_main_t * vam)
9951 unformat_input_t *i = vam->input;
9952 vl_api_ipfix_classify_table_add_del_t *mp;
9954 u32 classify_table_index = ~0;
9956 u8 transport_protocol = 255;
9959 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9961 if (unformat (i, "add"))
9963 else if (unformat (i, "del"))
9965 else if (unformat (i, "table %d", &classify_table_index))
9967 else if (unformat (i, "ip4"))
9969 else if (unformat (i, "ip6"))
9971 else if (unformat (i, "tcp"))
9972 transport_protocol = 6;
9973 else if (unformat (i, "udp"))
9974 transport_protocol = 17;
9977 errmsg ("unknown input `%U'", format_unformat_error, i);
9984 errmsg ("expecting: add|del");
9987 if (classify_table_index == ~0)
9989 errmsg ("classifier table not specified");
9992 if (ip_version == 0)
9994 errmsg ("IP version not specified");
9998 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
10000 mp->is_add = is_add;
10001 mp->table_id = htonl (classify_table_index);
10002 mp->ip_version = ip_version;
10003 mp->transport_protocol = transport_protocol;
10011 api_get_node_index (vat_main_t * vam)
10013 unformat_input_t *i = vam->input;
10014 vl_api_get_node_index_t *mp;
10018 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10020 if (unformat (i, "node %s", &name))
10027 errmsg ("node name required");
10030 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10032 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10036 M (GET_NODE_INDEX, mp);
10037 clib_memcpy (mp->node_name, name, vec_len (name));
10046 api_get_next_index (vat_main_t * vam)
10048 unformat_input_t *i = vam->input;
10049 vl_api_get_next_index_t *mp;
10050 u8 *node_name = 0, *next_node_name = 0;
10053 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10055 if (unformat (i, "node-name %s", &node_name))
10057 else if (unformat (i, "next-node-name %s", &next_node_name))
10061 if (node_name == 0)
10063 errmsg ("node name required");
10066 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
10068 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10072 if (next_node_name == 0)
10074 errmsg ("next node name required");
10077 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
10079 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
10083 M (GET_NEXT_INDEX, mp);
10084 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
10085 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
10086 vec_free (node_name);
10087 vec_free (next_node_name);
10095 api_add_node_next (vat_main_t * vam)
10097 unformat_input_t *i = vam->input;
10098 vl_api_add_node_next_t *mp;
10103 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10105 if (unformat (i, "node %s", &name))
10107 else if (unformat (i, "next %s", &next))
10114 errmsg ("node name required");
10117 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10119 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10124 errmsg ("next node required");
10127 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
10129 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
10133 M (ADD_NODE_NEXT, mp);
10134 clib_memcpy (mp->node_name, name, vec_len (name));
10135 clib_memcpy (mp->next_name, next, vec_len (next));
10145 api_l2tpv3_create_tunnel (vat_main_t * vam)
10147 unformat_input_t *i = vam->input;
10148 ip6_address_t client_address, our_address;
10149 int client_address_set = 0;
10150 int our_address_set = 0;
10151 u32 local_session_id = 0;
10152 u32 remote_session_id = 0;
10153 u64 local_cookie = 0;
10154 u64 remote_cookie = 0;
10155 u8 l2_sublayer_present = 0;
10156 vl_api_l2tpv3_create_tunnel_t *mp;
10159 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10161 if (unformat (i, "client_address %U", unformat_ip6_address,
10163 client_address_set = 1;
10164 else if (unformat (i, "our_address %U", unformat_ip6_address,
10166 our_address_set = 1;
10167 else if (unformat (i, "local_session_id %d", &local_session_id))
10169 else if (unformat (i, "remote_session_id %d", &remote_session_id))
10171 else if (unformat (i, "local_cookie %lld", &local_cookie))
10173 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
10175 else if (unformat (i, "l2-sublayer-present"))
10176 l2_sublayer_present = 1;
10181 if (client_address_set == 0)
10183 errmsg ("client_address required");
10187 if (our_address_set == 0)
10189 errmsg ("our_address required");
10193 M (L2TPV3_CREATE_TUNNEL, mp);
10195 clib_memcpy (mp->client_address, client_address.as_u8,
10196 sizeof (mp->client_address));
10198 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
10200 mp->local_session_id = ntohl (local_session_id);
10201 mp->remote_session_id = ntohl (remote_session_id);
10202 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
10203 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
10204 mp->l2_sublayer_present = l2_sublayer_present;
10213 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
10215 unformat_input_t *i = vam->input;
10217 u8 sw_if_index_set = 0;
10218 u64 new_local_cookie = 0;
10219 u64 new_remote_cookie = 0;
10220 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
10223 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10225 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10226 sw_if_index_set = 1;
10227 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10228 sw_if_index_set = 1;
10229 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
10231 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
10237 if (sw_if_index_set == 0)
10239 errmsg ("missing interface name or sw_if_index");
10243 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
10245 mp->sw_if_index = ntohl (sw_if_index);
10246 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
10247 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
10255 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
10257 unformat_input_t *i = vam->input;
10258 vl_api_l2tpv3_interface_enable_disable_t *mp;
10260 u8 sw_if_index_set = 0;
10261 u8 enable_disable = 1;
10264 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10266 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10267 sw_if_index_set = 1;
10268 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10269 sw_if_index_set = 1;
10270 else if (unformat (i, "enable"))
10271 enable_disable = 1;
10272 else if (unformat (i, "disable"))
10273 enable_disable = 0;
10278 if (sw_if_index_set == 0)
10280 errmsg ("missing interface name or sw_if_index");
10284 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
10286 mp->sw_if_index = ntohl (sw_if_index);
10287 mp->enable_disable = enable_disable;
10295 api_l2tpv3_set_lookup_key (vat_main_t * vam)
10297 unformat_input_t *i = vam->input;
10298 vl_api_l2tpv3_set_lookup_key_t *mp;
10302 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10304 if (unformat (i, "lookup_v6_src"))
10305 key = L2T_LOOKUP_SRC_ADDRESS;
10306 else if (unformat (i, "lookup_v6_dst"))
10307 key = L2T_LOOKUP_DST_ADDRESS;
10308 else if (unformat (i, "lookup_session_id"))
10309 key = L2T_LOOKUP_SESSION_ID;
10314 if (key == (u8) ~ 0)
10316 errmsg ("l2tp session lookup key unset");
10320 M (L2TPV3_SET_LOOKUP_KEY, mp);
10329 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
10330 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
10332 vat_main_t *vam = &vat_main;
10334 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
10335 format_ip6_address, mp->our_address,
10336 format_ip6_address, mp->client_address,
10337 clib_net_to_host_u32 (mp->sw_if_index));
10340 " local cookies %016llx %016llx remote cookie %016llx",
10341 clib_net_to_host_u64 (mp->local_cookie[0]),
10342 clib_net_to_host_u64 (mp->local_cookie[1]),
10343 clib_net_to_host_u64 (mp->remote_cookie));
10345 print (vam->ofp, " local session-id %d remote session-id %d",
10346 clib_net_to_host_u32 (mp->local_session_id),
10347 clib_net_to_host_u32 (mp->remote_session_id));
10349 print (vam->ofp, " l2 specific sublayer %s\n",
10350 mp->l2_sublayer_present ? "preset" : "absent");
10354 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
10355 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
10357 vat_main_t *vam = &vat_main;
10358 vat_json_node_t *node = NULL;
10359 struct in6_addr addr;
10361 if (VAT_JSON_ARRAY != vam->json_tree.type)
10363 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10364 vat_json_init_array (&vam->json_tree);
10366 node = vat_json_array_add (&vam->json_tree);
10368 vat_json_init_object (node);
10370 clib_memcpy (&addr, mp->our_address, sizeof (addr));
10371 vat_json_object_add_ip6 (node, "our_address", addr);
10372 clib_memcpy (&addr, mp->client_address, sizeof (addr));
10373 vat_json_object_add_ip6 (node, "client_address", addr);
10375 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
10376 vat_json_init_array (lc);
10377 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
10378 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
10379 vat_json_object_add_uint (node, "remote_cookie",
10380 clib_net_to_host_u64 (mp->remote_cookie));
10382 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
10383 vat_json_object_add_uint (node, "local_session_id",
10384 clib_net_to_host_u32 (mp->local_session_id));
10385 vat_json_object_add_uint (node, "remote_session_id",
10386 clib_net_to_host_u32 (mp->remote_session_id));
10387 vat_json_object_add_string_copy (node, "l2_sublayer",
10388 mp->l2_sublayer_present ? (u8 *) "present"
10389 : (u8 *) "absent");
10393 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
10395 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
10396 vl_api_control_ping_t *mp_ping;
10399 /* Get list of l2tpv3-tunnel interfaces */
10400 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
10403 /* Use a control ping for synchronization */
10404 M (CONTROL_PING, mp_ping);
10412 static void vl_api_sw_interface_tap_details_t_handler
10413 (vl_api_sw_interface_tap_details_t * mp)
10415 vat_main_t *vam = &vat_main;
10417 print (vam->ofp, "%-16s %d",
10418 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
10421 static void vl_api_sw_interface_tap_details_t_handler_json
10422 (vl_api_sw_interface_tap_details_t * mp)
10424 vat_main_t *vam = &vat_main;
10425 vat_json_node_t *node = NULL;
10427 if (VAT_JSON_ARRAY != vam->json_tree.type)
10429 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10430 vat_json_init_array (&vam->json_tree);
10432 node = vat_json_array_add (&vam->json_tree);
10434 vat_json_init_object (node);
10435 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10436 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
10440 api_sw_interface_tap_dump (vat_main_t * vam)
10442 vl_api_sw_interface_tap_dump_t *mp;
10443 vl_api_control_ping_t *mp_ping;
10446 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
10447 /* Get list of tap interfaces */
10448 M (SW_INTERFACE_TAP_DUMP, mp);
10451 /* Use a control ping for synchronization */
10452 M (CONTROL_PING, mp_ping);
10459 static uword unformat_vxlan_decap_next
10460 (unformat_input_t * input, va_list * args)
10462 u32 *result = va_arg (*args, u32 *);
10465 if (unformat (input, "l2"))
10466 *result = VXLAN_INPUT_NEXT_L2_INPUT;
10467 else if (unformat (input, "%d", &tmp))
10475 api_vxlan_add_del_tunnel (vat_main_t * vam)
10477 unformat_input_t *line_input = vam->input;
10478 vl_api_vxlan_add_del_tunnel_t *mp;
10479 ip46_address_t src, dst;
10481 u8 ipv4_set = 0, ipv6_set = 0;
10485 u32 mcast_sw_if_index = ~0;
10486 u32 encap_vrf_id = 0;
10487 u32 decap_next_index = ~0;
10491 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
10492 memset (&src, 0, sizeof src);
10493 memset (&dst, 0, sizeof dst);
10495 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10497 if (unformat (line_input, "del"))
10500 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
10506 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
10512 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
10518 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
10523 else if (unformat (line_input, "group %U %U",
10524 unformat_ip4_address, &dst.ip4,
10525 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
10527 grp_set = dst_set = 1;
10530 else if (unformat (line_input, "group %U",
10531 unformat_ip4_address, &dst.ip4))
10533 grp_set = dst_set = 1;
10536 else if (unformat (line_input, "group %U %U",
10537 unformat_ip6_address, &dst.ip6,
10538 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
10540 grp_set = dst_set = 1;
10543 else if (unformat (line_input, "group %U",
10544 unformat_ip6_address, &dst.ip6))
10546 grp_set = dst_set = 1;
10550 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
10552 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
10554 else if (unformat (line_input, "decap-next %U",
10555 unformat_vxlan_decap_next, &decap_next_index))
10557 else if (unformat (line_input, "vni %d", &vni))
10561 errmsg ("parse error '%U'", format_unformat_error, line_input);
10568 errmsg ("tunnel src address not specified");
10573 errmsg ("tunnel dst address not specified");
10577 if (grp_set && !ip46_address_is_multicast (&dst))
10579 errmsg ("tunnel group address not multicast");
10582 if (grp_set && mcast_sw_if_index == ~0)
10584 errmsg ("tunnel nonexistent multicast device");
10587 if (grp_set == 0 && ip46_address_is_multicast (&dst))
10589 errmsg ("tunnel dst address must be unicast");
10594 if (ipv4_set && ipv6_set)
10596 errmsg ("both IPv4 and IPv6 addresses specified");
10600 if ((vni == 0) || (vni >> 24))
10602 errmsg ("vni not specified or out of range");
10606 M (VXLAN_ADD_DEL_TUNNEL, mp);
10610 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
10611 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
10615 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
10616 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
10618 mp->encap_vrf_id = ntohl (encap_vrf_id);
10619 mp->decap_next_index = ntohl (decap_next_index);
10620 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
10621 mp->vni = ntohl (vni);
10622 mp->is_add = is_add;
10623 mp->is_ipv6 = ipv6_set;
10630 static void vl_api_vxlan_tunnel_details_t_handler
10631 (vl_api_vxlan_tunnel_details_t * mp)
10633 vat_main_t *vam = &vat_main;
10634 ip46_address_t src, dst;
10636 ip46_from_addr_buf (mp->is_ipv6, mp->src_address, &src);
10637 ip46_from_addr_buf (mp->is_ipv6, mp->dst_address, &dst);
10639 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
10640 ntohl (mp->sw_if_index),
10641 format_ip46_address, &src, IP46_TYPE_ANY,
10642 format_ip46_address, &dst, IP46_TYPE_ANY,
10643 ntohl (mp->encap_vrf_id),
10644 ntohl (mp->decap_next_index), ntohl (mp->vni),
10645 ntohl (mp->mcast_sw_if_index));
10648 static void vl_api_vxlan_tunnel_details_t_handler_json
10649 (vl_api_vxlan_tunnel_details_t * mp)
10651 vat_main_t *vam = &vat_main;
10652 vat_json_node_t *node = NULL;
10654 if (VAT_JSON_ARRAY != vam->json_tree.type)
10656 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10657 vat_json_init_array (&vam->json_tree);
10659 node = vat_json_array_add (&vam->json_tree);
10661 vat_json_init_object (node);
10662 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10665 struct in6_addr ip6;
10667 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
10668 vat_json_object_add_ip6 (node, "src_address", ip6);
10669 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
10670 vat_json_object_add_ip6 (node, "dst_address", ip6);
10674 struct in_addr ip4;
10676 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
10677 vat_json_object_add_ip4 (node, "src_address", ip4);
10678 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
10679 vat_json_object_add_ip4 (node, "dst_address", ip4);
10681 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
10682 vat_json_object_add_uint (node, "decap_next_index",
10683 ntohl (mp->decap_next_index));
10684 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
10685 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
10686 vat_json_object_add_uint (node, "mcast_sw_if_index",
10687 ntohl (mp->mcast_sw_if_index));
10691 api_vxlan_tunnel_dump (vat_main_t * vam)
10693 unformat_input_t *i = vam->input;
10694 vl_api_vxlan_tunnel_dump_t *mp;
10695 vl_api_control_ping_t *mp_ping;
10697 u8 sw_if_index_set = 0;
10700 /* Parse args required to build the message */
10701 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10703 if (unformat (i, "sw_if_index %d", &sw_if_index))
10704 sw_if_index_set = 1;
10709 if (sw_if_index_set == 0)
10714 if (!vam->json_output)
10716 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
10717 "sw_if_index", "src_address", "dst_address",
10718 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
10721 /* Get list of vxlan-tunnel interfaces */
10722 M (VXLAN_TUNNEL_DUMP, mp);
10724 mp->sw_if_index = htonl (sw_if_index);
10728 /* Use a control ping for synchronization */
10729 M (CONTROL_PING, mp_ping);
10737 api_gre_add_del_tunnel (vat_main_t * vam)
10739 unformat_input_t *line_input = vam->input;
10740 vl_api_gre_add_del_tunnel_t *mp;
10741 ip4_address_t src4, dst4;
10746 u32 outer_fib_id = 0;
10749 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10751 if (unformat (line_input, "del"))
10753 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
10755 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
10757 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
10759 else if (unformat (line_input, "teb"))
10763 errmsg ("parse error '%U'", format_unformat_error, line_input);
10770 errmsg ("tunnel src address not specified");
10775 errmsg ("tunnel dst address not specified");
10780 M (GRE_ADD_DEL_TUNNEL, mp);
10782 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
10783 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
10784 mp->outer_fib_id = ntohl (outer_fib_id);
10785 mp->is_add = is_add;
10793 static void vl_api_gre_tunnel_details_t_handler
10794 (vl_api_gre_tunnel_details_t * mp)
10796 vat_main_t *vam = &vat_main;
10798 print (vam->ofp, "%11d%15U%15U%6d%14d",
10799 ntohl (mp->sw_if_index),
10800 format_ip4_address, &mp->src_address,
10801 format_ip4_address, &mp->dst_address,
10802 mp->teb, ntohl (mp->outer_fib_id));
10805 static void vl_api_gre_tunnel_details_t_handler_json
10806 (vl_api_gre_tunnel_details_t * mp)
10808 vat_main_t *vam = &vat_main;
10809 vat_json_node_t *node = NULL;
10810 struct in_addr ip4;
10812 if (VAT_JSON_ARRAY != vam->json_tree.type)
10814 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10815 vat_json_init_array (&vam->json_tree);
10817 node = vat_json_array_add (&vam->json_tree);
10819 vat_json_init_object (node);
10820 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10821 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
10822 vat_json_object_add_ip4 (node, "src_address", ip4);
10823 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
10824 vat_json_object_add_ip4 (node, "dst_address", ip4);
10825 vat_json_object_add_uint (node, "teb", mp->teb);
10826 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
10830 api_gre_tunnel_dump (vat_main_t * vam)
10832 unformat_input_t *i = vam->input;
10833 vl_api_gre_tunnel_dump_t *mp;
10834 vl_api_control_ping_t *mp_ping;
10836 u8 sw_if_index_set = 0;
10839 /* Parse args required to build the message */
10840 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10842 if (unformat (i, "sw_if_index %d", &sw_if_index))
10843 sw_if_index_set = 1;
10848 if (sw_if_index_set == 0)
10853 if (!vam->json_output)
10855 print (vam->ofp, "%11s%15s%15s%6s%14s",
10856 "sw_if_index", "src_address", "dst_address", "teb",
10860 /* Get list of gre-tunnel interfaces */
10861 M (GRE_TUNNEL_DUMP, mp);
10863 mp->sw_if_index = htonl (sw_if_index);
10867 /* Use a control ping for synchronization */
10868 M (CONTROL_PING, mp_ping);
10876 api_l2_fib_clear_table (vat_main_t * vam)
10878 // unformat_input_t * i = vam->input;
10879 vl_api_l2_fib_clear_table_t *mp;
10882 M (L2_FIB_CLEAR_TABLE, mp);
10890 api_l2_interface_efp_filter (vat_main_t * vam)
10892 unformat_input_t *i = vam->input;
10893 vl_api_l2_interface_efp_filter_t *mp;
10896 u8 sw_if_index_set = 0;
10899 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10901 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10902 sw_if_index_set = 1;
10903 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10904 sw_if_index_set = 1;
10905 else if (unformat (i, "enable"))
10907 else if (unformat (i, "disable"))
10911 clib_warning ("parse error '%U'", format_unformat_error, i);
10916 if (sw_if_index_set == 0)
10918 errmsg ("missing sw_if_index");
10922 M (L2_INTERFACE_EFP_FILTER, mp);
10924 mp->sw_if_index = ntohl (sw_if_index);
10925 mp->enable_disable = enable;
10932 #define foreach_vtr_op \
10933 _("disable", L2_VTR_DISABLED) \
10934 _("push-1", L2_VTR_PUSH_1) \
10935 _("push-2", L2_VTR_PUSH_2) \
10936 _("pop-1", L2_VTR_POP_1) \
10937 _("pop-2", L2_VTR_POP_2) \
10938 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
10939 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
10940 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
10941 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
10944 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
10946 unformat_input_t *i = vam->input;
10947 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
10949 u8 sw_if_index_set = 0;
10952 u32 push_dot1q = 1;
10957 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10959 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10960 sw_if_index_set = 1;
10961 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10962 sw_if_index_set = 1;
10963 else if (unformat (i, "vtr_op %d", &vtr_op))
10965 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
10968 else if (unformat (i, "push_dot1q %d", &push_dot1q))
10970 else if (unformat (i, "tag1 %d", &tag1))
10972 else if (unformat (i, "tag2 %d", &tag2))
10976 clib_warning ("parse error '%U'", format_unformat_error, i);
10981 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
10983 errmsg ("missing vtr operation or sw_if_index");
10987 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
10988 mp->sw_if_index = ntohl (sw_if_index);
10989 mp->vtr_op = ntohl (vtr_op);
10990 mp->push_dot1q = ntohl (push_dot1q);
10991 mp->tag1 = ntohl (tag1);
10992 mp->tag2 = ntohl (tag2);
11000 api_create_vhost_user_if (vat_main_t * vam)
11002 unformat_input_t *i = vam->input;
11003 vl_api_create_vhost_user_if_t *mp;
11006 u8 file_name_set = 0;
11007 u32 custom_dev_instance = ~0;
11009 u8 use_custom_mac = 0;
11013 /* Shut up coverity */
11014 memset (hwaddr, 0, sizeof (hwaddr));
11016 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11018 if (unformat (i, "socket %s", &file_name))
11022 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
11024 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
11025 use_custom_mac = 1;
11026 else if (unformat (i, "server"))
11028 else if (unformat (i, "tag %s", &tag))
11034 if (file_name_set == 0)
11036 errmsg ("missing socket file name");
11040 if (vec_len (file_name) > 255)
11042 errmsg ("socket file name too long");
11045 vec_add1 (file_name, 0);
11047 M (CREATE_VHOST_USER_IF, mp);
11049 mp->is_server = is_server;
11050 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
11051 vec_free (file_name);
11052 if (custom_dev_instance != ~0)
11055 mp->custom_dev_instance = ntohl (custom_dev_instance);
11057 mp->use_custom_mac = use_custom_mac;
11058 clib_memcpy (mp->mac_address, hwaddr, 6);
11060 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
11069 api_modify_vhost_user_if (vat_main_t * vam)
11071 unformat_input_t *i = vam->input;
11072 vl_api_modify_vhost_user_if_t *mp;
11075 u8 file_name_set = 0;
11076 u32 custom_dev_instance = ~0;
11077 u8 sw_if_index_set = 0;
11078 u32 sw_if_index = (u32) ~ 0;
11081 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11083 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11084 sw_if_index_set = 1;
11085 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11086 sw_if_index_set = 1;
11087 else if (unformat (i, "socket %s", &file_name))
11091 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
11093 else if (unformat (i, "server"))
11099 if (sw_if_index_set == 0)
11101 errmsg ("missing sw_if_index or interface name");
11105 if (file_name_set == 0)
11107 errmsg ("missing socket file name");
11111 if (vec_len (file_name) > 255)
11113 errmsg ("socket file name too long");
11116 vec_add1 (file_name, 0);
11118 M (MODIFY_VHOST_USER_IF, mp);
11120 mp->sw_if_index = ntohl (sw_if_index);
11121 mp->is_server = is_server;
11122 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
11123 vec_free (file_name);
11124 if (custom_dev_instance != ~0)
11127 mp->custom_dev_instance = ntohl (custom_dev_instance);
11136 api_delete_vhost_user_if (vat_main_t * vam)
11138 unformat_input_t *i = vam->input;
11139 vl_api_delete_vhost_user_if_t *mp;
11140 u32 sw_if_index = ~0;
11141 u8 sw_if_index_set = 0;
11144 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11146 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11147 sw_if_index_set = 1;
11148 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11149 sw_if_index_set = 1;
11154 if (sw_if_index_set == 0)
11156 errmsg ("missing sw_if_index or interface name");
11161 M (DELETE_VHOST_USER_IF, mp);
11163 mp->sw_if_index = ntohl (sw_if_index);
11170 static void vl_api_sw_interface_vhost_user_details_t_handler
11171 (vl_api_sw_interface_vhost_user_details_t * mp)
11173 vat_main_t *vam = &vat_main;
11175 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
11176 (char *) mp->interface_name,
11177 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
11178 clib_net_to_host_u64 (mp->features), mp->is_server,
11179 ntohl (mp->num_regions), (char *) mp->sock_filename);
11180 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
11183 static void vl_api_sw_interface_vhost_user_details_t_handler_json
11184 (vl_api_sw_interface_vhost_user_details_t * mp)
11186 vat_main_t *vam = &vat_main;
11187 vat_json_node_t *node = NULL;
11189 if (VAT_JSON_ARRAY != vam->json_tree.type)
11191 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11192 vat_json_init_array (&vam->json_tree);
11194 node = vat_json_array_add (&vam->json_tree);
11196 vat_json_init_object (node);
11197 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11198 vat_json_object_add_string_copy (node, "interface_name",
11199 mp->interface_name);
11200 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
11201 ntohl (mp->virtio_net_hdr_sz));
11202 vat_json_object_add_uint (node, "features",
11203 clib_net_to_host_u64 (mp->features));
11204 vat_json_object_add_uint (node, "is_server", mp->is_server);
11205 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
11206 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
11207 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
11211 api_sw_interface_vhost_user_dump (vat_main_t * vam)
11213 vl_api_sw_interface_vhost_user_dump_t *mp;
11214 vl_api_control_ping_t *mp_ping;
11217 "Interface name idx hdr_sz features server regions filename");
11219 /* Get list of vhost-user interfaces */
11220 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
11223 /* Use a control ping for synchronization */
11224 M (CONTROL_PING, mp_ping);
11232 api_show_version (vat_main_t * vam)
11234 vl_api_show_version_t *mp;
11237 M (SHOW_VERSION, mp);
11246 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
11248 unformat_input_t *line_input = vam->input;
11249 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
11250 ip4_address_t local4, remote4;
11251 ip6_address_t local6, remote6;
11253 u8 ipv4_set = 0, ipv6_set = 0;
11256 u32 encap_vrf_id = 0;
11257 u32 decap_vrf_id = 0;
11263 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11265 if (unformat (line_input, "del"))
11267 else if (unformat (line_input, "local %U",
11268 unformat_ip4_address, &local4))
11273 else if (unformat (line_input, "remote %U",
11274 unformat_ip4_address, &remote4))
11279 else if (unformat (line_input, "local %U",
11280 unformat_ip6_address, &local6))
11285 else if (unformat (line_input, "remote %U",
11286 unformat_ip6_address, &remote6))
11291 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11293 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
11295 else if (unformat (line_input, "vni %d", &vni))
11297 else if (unformat (line_input, "next-ip4"))
11299 else if (unformat (line_input, "next-ip6"))
11301 else if (unformat (line_input, "next-ethernet"))
11303 else if (unformat (line_input, "next-nsh"))
11307 errmsg ("parse error '%U'", format_unformat_error, line_input);
11312 if (local_set == 0)
11314 errmsg ("tunnel local address not specified");
11317 if (remote_set == 0)
11319 errmsg ("tunnel remote address not specified");
11322 if (ipv4_set && ipv6_set)
11324 errmsg ("both IPv4 and IPv6 addresses specified");
11330 errmsg ("vni not specified");
11334 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
11339 clib_memcpy (&mp->local, &local6, sizeof (local6));
11340 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
11344 clib_memcpy (&mp->local, &local4, sizeof (local4));
11345 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
11348 mp->encap_vrf_id = ntohl (encap_vrf_id);
11349 mp->decap_vrf_id = ntohl (decap_vrf_id);
11350 mp->protocol = protocol;
11351 mp->vni = ntohl (vni);
11352 mp->is_add = is_add;
11353 mp->is_ipv6 = ipv6_set;
11360 static void vl_api_vxlan_gpe_tunnel_details_t_handler
11361 (vl_api_vxlan_gpe_tunnel_details_t * mp)
11363 vat_main_t *vam = &vat_main;
11365 print (vam->ofp, "%11d%24U%24U%13d%12d%14d%14d",
11366 ntohl (mp->sw_if_index),
11367 format_ip46_address, &(mp->local[0]),
11368 format_ip46_address, &(mp->remote[0]),
11370 ntohl (mp->protocol),
11371 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
11374 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
11375 (vl_api_vxlan_gpe_tunnel_details_t * mp)
11377 vat_main_t *vam = &vat_main;
11378 vat_json_node_t *node = NULL;
11379 struct in_addr ip4;
11380 struct in6_addr ip6;
11382 if (VAT_JSON_ARRAY != vam->json_tree.type)
11384 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11385 vat_json_init_array (&vam->json_tree);
11387 node = vat_json_array_add (&vam->json_tree);
11389 vat_json_init_object (node);
11390 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11393 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
11394 vat_json_object_add_ip6 (node, "local", ip6);
11395 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
11396 vat_json_object_add_ip6 (node, "remote", ip6);
11400 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
11401 vat_json_object_add_ip4 (node, "local", ip4);
11402 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
11403 vat_json_object_add_ip4 (node, "remote", ip4);
11405 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
11406 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
11407 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
11408 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
11409 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
11413 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
11415 unformat_input_t *i = vam->input;
11416 vl_api_vxlan_gpe_tunnel_dump_t *mp;
11417 vl_api_control_ping_t *mp_ping;
11419 u8 sw_if_index_set = 0;
11422 /* Parse args required to build the message */
11423 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11425 if (unformat (i, "sw_if_index %d", &sw_if_index))
11426 sw_if_index_set = 1;
11431 if (sw_if_index_set == 0)
11436 if (!vam->json_output)
11438 print (vam->ofp, "%11s%24s%24s%13s%15s%14s%14s",
11439 "sw_if_index", "local", "remote", "vni",
11440 "protocol", "encap_vrf_id", "decap_vrf_id");
11443 /* Get list of vxlan-tunnel interfaces */
11444 M (VXLAN_GPE_TUNNEL_DUMP, mp);
11446 mp->sw_if_index = htonl (sw_if_index);
11450 /* Use a control ping for synchronization */
11451 M (CONTROL_PING, mp_ping);
11459 format_l2_fib_mac_address (u8 * s, va_list * args)
11461 u8 *a = va_arg (*args, u8 *);
11463 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
11464 a[2], a[3], a[4], a[5], a[6], a[7]);
11467 static void vl_api_l2_fib_table_entry_t_handler
11468 (vl_api_l2_fib_table_entry_t * mp)
11470 vat_main_t *vam = &vat_main;
11472 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
11474 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
11475 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
11479 static void vl_api_l2_fib_table_entry_t_handler_json
11480 (vl_api_l2_fib_table_entry_t * mp)
11482 vat_main_t *vam = &vat_main;
11483 vat_json_node_t *node = NULL;
11485 if (VAT_JSON_ARRAY != vam->json_tree.type)
11487 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11488 vat_json_init_array (&vam->json_tree);
11490 node = vat_json_array_add (&vam->json_tree);
11492 vat_json_init_object (node);
11493 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
11494 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
11495 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11496 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
11497 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
11498 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
11502 api_l2_fib_table_dump (vat_main_t * vam)
11504 unformat_input_t *i = vam->input;
11505 vl_api_l2_fib_table_dump_t *mp;
11506 vl_api_control_ping_t *mp_ping;
11511 /* Parse args required to build the message */
11512 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11514 if (unformat (i, "bd_id %d", &bd_id))
11520 if (bd_id_set == 0)
11522 errmsg ("missing bridge domain");
11526 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
11528 /* Get list of l2 fib entries */
11529 M (L2_FIB_TABLE_DUMP, mp);
11531 mp->bd_id = ntohl (bd_id);
11534 /* Use a control ping for synchronization */
11535 M (CONTROL_PING, mp_ping);
11544 api_interface_name_renumber (vat_main_t * vam)
11546 unformat_input_t *line_input = vam->input;
11547 vl_api_interface_name_renumber_t *mp;
11548 u32 sw_if_index = ~0;
11549 u32 new_show_dev_instance = ~0;
11552 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11554 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
11557 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11559 else if (unformat (line_input, "new_show_dev_instance %d",
11560 &new_show_dev_instance))
11566 if (sw_if_index == ~0)
11568 errmsg ("missing interface name or sw_if_index");
11572 if (new_show_dev_instance == ~0)
11574 errmsg ("missing new_show_dev_instance");
11578 M (INTERFACE_NAME_RENUMBER, mp);
11580 mp->sw_if_index = ntohl (sw_if_index);
11581 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
11589 api_want_ip4_arp_events (vat_main_t * vam)
11591 unformat_input_t *line_input = vam->input;
11592 vl_api_want_ip4_arp_events_t *mp;
11593 ip4_address_t address;
11594 int address_set = 0;
11595 u32 enable_disable = 1;
11598 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11600 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
11602 else if (unformat (line_input, "del"))
11603 enable_disable = 0;
11608 if (address_set == 0)
11610 errmsg ("missing addresses");
11614 M (WANT_IP4_ARP_EVENTS, mp);
11615 mp->enable_disable = enable_disable;
11616 mp->pid = getpid ();
11617 mp->address = address.as_u32;
11625 api_want_ip6_nd_events (vat_main_t * vam)
11627 unformat_input_t *line_input = vam->input;
11628 vl_api_want_ip6_nd_events_t *mp;
11629 ip6_address_t address;
11630 int address_set = 0;
11631 u32 enable_disable = 1;
11634 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11636 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
11638 else if (unformat (line_input, "del"))
11639 enable_disable = 0;
11644 if (address_set == 0)
11646 errmsg ("missing addresses");
11650 M (WANT_IP6_ND_EVENTS, mp);
11651 mp->enable_disable = enable_disable;
11652 mp->pid = getpid ();
11653 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
11661 api_input_acl_set_interface (vat_main_t * vam)
11663 unformat_input_t *i = vam->input;
11664 vl_api_input_acl_set_interface_t *mp;
11666 int sw_if_index_set;
11667 u32 ip4_table_index = ~0;
11668 u32 ip6_table_index = ~0;
11669 u32 l2_table_index = ~0;
11673 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11675 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11676 sw_if_index_set = 1;
11677 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11678 sw_if_index_set = 1;
11679 else if (unformat (i, "del"))
11681 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11683 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11685 else if (unformat (i, "l2-table %d", &l2_table_index))
11689 clib_warning ("parse error '%U'", format_unformat_error, i);
11694 if (sw_if_index_set == 0)
11696 errmsg ("missing interface name or sw_if_index");
11700 M (INPUT_ACL_SET_INTERFACE, mp);
11702 mp->sw_if_index = ntohl (sw_if_index);
11703 mp->ip4_table_index = ntohl (ip4_table_index);
11704 mp->ip6_table_index = ntohl (ip6_table_index);
11705 mp->l2_table_index = ntohl (l2_table_index);
11706 mp->is_add = is_add;
11714 api_ip_address_dump (vat_main_t * vam)
11716 unformat_input_t *i = vam->input;
11717 vl_api_ip_address_dump_t *mp;
11718 vl_api_control_ping_t *mp_ping;
11719 u32 sw_if_index = ~0;
11720 u8 sw_if_index_set = 0;
11725 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11727 if (unformat (i, "sw_if_index %d", &sw_if_index))
11728 sw_if_index_set = 1;
11730 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11731 sw_if_index_set = 1;
11732 else if (unformat (i, "ipv4"))
11734 else if (unformat (i, "ipv6"))
11740 if (ipv4_set && ipv6_set)
11742 errmsg ("ipv4 and ipv6 flags cannot be both set");
11746 if ((!ipv4_set) && (!ipv6_set))
11748 errmsg ("no ipv4 nor ipv6 flag set");
11752 if (sw_if_index_set == 0)
11754 errmsg ("missing interface name or sw_if_index");
11758 vam->current_sw_if_index = sw_if_index;
11759 vam->is_ipv6 = ipv6_set;
11761 M (IP_ADDRESS_DUMP, mp);
11762 mp->sw_if_index = ntohl (sw_if_index);
11763 mp->is_ipv6 = ipv6_set;
11766 /* Use a control ping for synchronization */
11767 M (CONTROL_PING, mp_ping);
11775 api_ip_dump (vat_main_t * vam)
11777 vl_api_ip_dump_t *mp;
11778 vl_api_control_ping_t *mp_ping;
11779 unformat_input_t *in = vam->input;
11786 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
11788 if (unformat (in, "ipv4"))
11790 else if (unformat (in, "ipv6"))
11796 if (ipv4_set && ipv6_set)
11798 errmsg ("ipv4 and ipv6 flags cannot be both set");
11802 if ((!ipv4_set) && (!ipv6_set))
11804 errmsg ("no ipv4 nor ipv6 flag set");
11808 is_ipv6 = ipv6_set;
11809 vam->is_ipv6 = is_ipv6;
11811 /* free old data */
11812 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
11814 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
11816 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
11819 mp->is_ipv6 = ipv6_set;
11822 /* Use a control ping for synchronization */
11823 M (CONTROL_PING, mp_ping);
11831 api_ipsec_spd_add_del (vat_main_t * vam)
11833 unformat_input_t *i = vam->input;
11834 vl_api_ipsec_spd_add_del_t *mp;
11839 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11841 if (unformat (i, "spd_id %d", &spd_id))
11843 else if (unformat (i, "del"))
11847 clib_warning ("parse error '%U'", format_unformat_error, i);
11853 errmsg ("spd_id must be set");
11857 M (IPSEC_SPD_ADD_DEL, mp);
11859 mp->spd_id = ntohl (spd_id);
11860 mp->is_add = is_add;
11868 api_ipsec_interface_add_del_spd (vat_main_t * vam)
11870 unformat_input_t *i = vam->input;
11871 vl_api_ipsec_interface_add_del_spd_t *mp;
11873 u8 sw_if_index_set = 0;
11874 u32 spd_id = (u32) ~ 0;
11878 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11880 if (unformat (i, "del"))
11882 else if (unformat (i, "spd_id %d", &spd_id))
11885 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11886 sw_if_index_set = 1;
11887 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11888 sw_if_index_set = 1;
11891 clib_warning ("parse error '%U'", format_unformat_error, i);
11897 if (spd_id == (u32) ~ 0)
11899 errmsg ("spd_id must be set");
11903 if (sw_if_index_set == 0)
11905 errmsg ("missing interface name or sw_if_index");
11909 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
11911 mp->spd_id = ntohl (spd_id);
11912 mp->sw_if_index = ntohl (sw_if_index);
11913 mp->is_add = is_add;
11921 api_ipsec_spd_add_del_entry (vat_main_t * vam)
11923 unformat_input_t *i = vam->input;
11924 vl_api_ipsec_spd_add_del_entry_t *mp;
11925 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
11926 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
11928 u32 rport_start = 0, rport_stop = (u32) ~ 0;
11929 u32 lport_start = 0, lport_stop = (u32) ~ 0;
11930 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
11931 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
11934 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
11935 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
11936 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
11937 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
11938 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
11939 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
11941 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11943 if (unformat (i, "del"))
11945 if (unformat (i, "outbound"))
11947 if (unformat (i, "inbound"))
11949 else if (unformat (i, "spd_id %d", &spd_id))
11951 else if (unformat (i, "sa_id %d", &sa_id))
11953 else if (unformat (i, "priority %d", &priority))
11955 else if (unformat (i, "protocol %d", &protocol))
11957 else if (unformat (i, "lport_start %d", &lport_start))
11959 else if (unformat (i, "lport_stop %d", &lport_stop))
11961 else if (unformat (i, "rport_start %d", &rport_start))
11963 else if (unformat (i, "rport_stop %d", &rport_stop))
11967 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
11973 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
11980 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
11986 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
11993 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
11999 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
12006 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
12012 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
12018 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
12020 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
12022 clib_warning ("unsupported action: 'resolve'");
12028 clib_warning ("parse error '%U'", format_unformat_error, i);
12034 M (IPSEC_SPD_ADD_DEL_ENTRY, mp);
12036 mp->spd_id = ntohl (spd_id);
12037 mp->priority = ntohl (priority);
12038 mp->is_outbound = is_outbound;
12040 mp->is_ipv6 = is_ipv6;
12041 if (is_ipv6 || is_ip_any)
12043 clib_memcpy (mp->remote_address_start, &raddr6_start,
12044 sizeof (ip6_address_t));
12045 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
12046 sizeof (ip6_address_t));
12047 clib_memcpy (mp->local_address_start, &laddr6_start,
12048 sizeof (ip6_address_t));
12049 clib_memcpy (mp->local_address_stop, &laddr6_stop,
12050 sizeof (ip6_address_t));
12054 clib_memcpy (mp->remote_address_start, &raddr4_start,
12055 sizeof (ip4_address_t));
12056 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
12057 sizeof (ip4_address_t));
12058 clib_memcpy (mp->local_address_start, &laddr4_start,
12059 sizeof (ip4_address_t));
12060 clib_memcpy (mp->local_address_stop, &laddr4_stop,
12061 sizeof (ip4_address_t));
12063 mp->protocol = (u8) protocol;
12064 mp->local_port_start = ntohs ((u16) lport_start);
12065 mp->local_port_stop = ntohs ((u16) lport_stop);
12066 mp->remote_port_start = ntohs ((u16) rport_start);
12067 mp->remote_port_stop = ntohs ((u16) rport_stop);
12068 mp->policy = (u8) policy;
12069 mp->sa_id = ntohl (sa_id);
12070 mp->is_add = is_add;
12071 mp->is_ip_any = is_ip_any;
12078 api_ipsec_sad_add_del_entry (vat_main_t * vam)
12080 unformat_input_t *i = vam->input;
12081 vl_api_ipsec_sad_add_del_entry_t *mp;
12082 u32 sad_id = 0, spi = 0;
12083 u8 *ck = 0, *ik = 0;
12086 u8 protocol = IPSEC_PROTOCOL_AH;
12087 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
12088 u32 crypto_alg = 0, integ_alg = 0;
12089 ip4_address_t tun_src4;
12090 ip4_address_t tun_dst4;
12091 ip6_address_t tun_src6;
12092 ip6_address_t tun_dst6;
12095 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12097 if (unformat (i, "del"))
12099 else if (unformat (i, "sad_id %d", &sad_id))
12101 else if (unformat (i, "spi %d", &spi))
12103 else if (unformat (i, "esp"))
12104 protocol = IPSEC_PROTOCOL_ESP;
12105 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
12108 is_tunnel_ipv6 = 0;
12110 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
12113 is_tunnel_ipv6 = 0;
12115 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
12118 is_tunnel_ipv6 = 1;
12120 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
12123 is_tunnel_ipv6 = 1;
12127 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
12129 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
12130 crypto_alg >= IPSEC_CRYPTO_N_ALG)
12132 clib_warning ("unsupported crypto-alg: '%U'",
12133 format_ipsec_crypto_alg, crypto_alg);
12137 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
12141 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
12143 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
12144 integ_alg >= IPSEC_INTEG_N_ALG)
12146 clib_warning ("unsupported integ-alg: '%U'",
12147 format_ipsec_integ_alg, integ_alg);
12151 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
12155 clib_warning ("parse error '%U'", format_unformat_error, i);
12161 M (IPSEC_SAD_ADD_DEL_ENTRY, mp);
12163 mp->sad_id = ntohl (sad_id);
12164 mp->is_add = is_add;
12165 mp->protocol = protocol;
12166 mp->spi = ntohl (spi);
12167 mp->is_tunnel = is_tunnel;
12168 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
12169 mp->crypto_algorithm = crypto_alg;
12170 mp->integrity_algorithm = integ_alg;
12171 mp->crypto_key_length = vec_len (ck);
12172 mp->integrity_key_length = vec_len (ik);
12174 if (mp->crypto_key_length > sizeof (mp->crypto_key))
12175 mp->crypto_key_length = sizeof (mp->crypto_key);
12177 if (mp->integrity_key_length > sizeof (mp->integrity_key))
12178 mp->integrity_key_length = sizeof (mp->integrity_key);
12181 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
12183 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
12187 if (is_tunnel_ipv6)
12189 clib_memcpy (mp->tunnel_src_address, &tun_src6,
12190 sizeof (ip6_address_t));
12191 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
12192 sizeof (ip6_address_t));
12196 clib_memcpy (mp->tunnel_src_address, &tun_src4,
12197 sizeof (ip4_address_t));
12198 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
12199 sizeof (ip4_address_t));
12209 api_ipsec_sa_set_key (vat_main_t * vam)
12211 unformat_input_t *i = vam->input;
12212 vl_api_ipsec_sa_set_key_t *mp;
12214 u8 *ck = 0, *ik = 0;
12217 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12219 if (unformat (i, "sa_id %d", &sa_id))
12221 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
12223 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
12227 clib_warning ("parse error '%U'", format_unformat_error, i);
12232 M (IPSEC_SA_SET_KEY, mp);
12234 mp->sa_id = ntohl (sa_id);
12235 mp->crypto_key_length = vec_len (ck);
12236 mp->integrity_key_length = vec_len (ik);
12238 if (mp->crypto_key_length > sizeof (mp->crypto_key))
12239 mp->crypto_key_length = sizeof (mp->crypto_key);
12241 if (mp->integrity_key_length > sizeof (mp->integrity_key))
12242 mp->integrity_key_length = sizeof (mp->integrity_key);
12245 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
12247 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
12255 api_ikev2_profile_add_del (vat_main_t * vam)
12257 unformat_input_t *i = vam->input;
12258 vl_api_ikev2_profile_add_del_t *mp;
12263 const char *valid_chars = "a-zA-Z0-9_";
12265 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12267 if (unformat (i, "del"))
12269 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12270 vec_add1 (name, 0);
12273 errmsg ("parse error '%U'", format_unformat_error, i);
12278 if (!vec_len (name))
12280 errmsg ("profile name must be specified");
12284 if (vec_len (name) > 64)
12286 errmsg ("profile name too long");
12290 M (IKEV2_PROFILE_ADD_DEL, mp);
12292 clib_memcpy (mp->name, name, vec_len (name));
12293 mp->is_add = is_add;
12302 api_ikev2_profile_set_auth (vat_main_t * vam)
12304 unformat_input_t *i = vam->input;
12305 vl_api_ikev2_profile_set_auth_t *mp;
12308 u32 auth_method = 0;
12312 const char *valid_chars = "a-zA-Z0-9_";
12314 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12316 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12317 vec_add1 (name, 0);
12318 else if (unformat (i, "auth_method %U",
12319 unformat_ikev2_auth_method, &auth_method))
12321 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
12323 else if (unformat (i, "auth_data %v", &data))
12327 errmsg ("parse error '%U'", format_unformat_error, i);
12332 if (!vec_len (name))
12334 errmsg ("profile name must be specified");
12338 if (vec_len (name) > 64)
12340 errmsg ("profile name too long");
12344 if (!vec_len (data))
12346 errmsg ("auth_data must be specified");
12352 errmsg ("auth_method must be specified");
12356 M (IKEV2_PROFILE_SET_AUTH, mp);
12358 mp->is_hex = is_hex;
12359 mp->auth_method = (u8) auth_method;
12360 mp->data_len = vec_len (data);
12361 clib_memcpy (mp->name, name, vec_len (name));
12362 clib_memcpy (mp->data, data, vec_len (data));
12372 api_ikev2_profile_set_id (vat_main_t * vam)
12374 unformat_input_t *i = vam->input;
12375 vl_api_ikev2_profile_set_id_t *mp;
12383 const char *valid_chars = "a-zA-Z0-9_";
12385 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12387 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12388 vec_add1 (name, 0);
12389 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
12391 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
12393 data = vec_new (u8, 4);
12394 clib_memcpy (data, ip4.as_u8, 4);
12396 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
12398 else if (unformat (i, "id_data %v", &data))
12400 else if (unformat (i, "local"))
12402 else if (unformat (i, "remote"))
12406 errmsg ("parse error '%U'", format_unformat_error, i);
12411 if (!vec_len (name))
12413 errmsg ("profile name must be specified");
12417 if (vec_len (name) > 64)
12419 errmsg ("profile name too long");
12423 if (!vec_len (data))
12425 errmsg ("id_data must be specified");
12431 errmsg ("id_type must be specified");
12435 M (IKEV2_PROFILE_SET_ID, mp);
12437 mp->is_local = is_local;
12438 mp->id_type = (u8) id_type;
12439 mp->data_len = vec_len (data);
12440 clib_memcpy (mp->name, name, vec_len (name));
12441 clib_memcpy (mp->data, data, vec_len (data));
12451 api_ikev2_profile_set_ts (vat_main_t * vam)
12453 unformat_input_t *i = vam->input;
12454 vl_api_ikev2_profile_set_ts_t *mp;
12457 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
12458 ip4_address_t start_addr, end_addr;
12460 const char *valid_chars = "a-zA-Z0-9_";
12463 start_addr.as_u32 = 0;
12464 end_addr.as_u32 = (u32) ~ 0;
12466 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12468 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12469 vec_add1 (name, 0);
12470 else if (unformat (i, "protocol %d", &proto))
12472 else if (unformat (i, "start_port %d", &start_port))
12474 else if (unformat (i, "end_port %d", &end_port))
12477 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
12479 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
12481 else if (unformat (i, "local"))
12483 else if (unformat (i, "remote"))
12487 errmsg ("parse error '%U'", format_unformat_error, i);
12492 if (!vec_len (name))
12494 errmsg ("profile name must be specified");
12498 if (vec_len (name) > 64)
12500 errmsg ("profile name too long");
12504 M (IKEV2_PROFILE_SET_TS, mp);
12506 mp->is_local = is_local;
12507 mp->proto = (u8) proto;
12508 mp->start_port = (u16) start_port;
12509 mp->end_port = (u16) end_port;
12510 mp->start_addr = start_addr.as_u32;
12511 mp->end_addr = end_addr.as_u32;
12512 clib_memcpy (mp->name, name, vec_len (name));
12521 api_ikev2_set_local_key (vat_main_t * vam)
12523 unformat_input_t *i = vam->input;
12524 vl_api_ikev2_set_local_key_t *mp;
12528 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12530 if (unformat (i, "file %v", &file))
12531 vec_add1 (file, 0);
12534 errmsg ("parse error '%U'", format_unformat_error, i);
12539 if (!vec_len (file))
12541 errmsg ("RSA key file must be specified");
12545 if (vec_len (file) > 256)
12547 errmsg ("file name too long");
12551 M (IKEV2_SET_LOCAL_KEY, mp);
12553 clib_memcpy (mp->key_file, file, vec_len (file));
12562 api_ikev2_set_responder (vat_main_t * vam)
12564 unformat_input_t *i = vam->input;
12565 vl_api_ikev2_set_responder_t *mp;
12568 u32 sw_if_index = ~0;
12569 ip4_address_t address;
12571 const char *valid_chars = "a-zA-Z0-9_";
12573 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12576 (i, "%U interface %d address %U", unformat_token, valid_chars,
12577 &name, &sw_if_index, unformat_ip4_address, &address))
12578 vec_add1 (name, 0);
12581 errmsg ("parse error '%U'", format_unformat_error, i);
12586 if (!vec_len (name))
12588 errmsg ("profile name must be specified");
12592 if (vec_len (name) > 64)
12594 errmsg ("profile name too long");
12598 M (IKEV2_SET_RESPONDER, mp);
12600 clib_memcpy (mp->name, name, vec_len (name));
12603 mp->sw_if_index = sw_if_index;
12604 clib_memcpy (mp->address, &address, sizeof (address));
12612 api_ikev2_set_ike_transforms (vat_main_t * vam)
12614 unformat_input_t *i = vam->input;
12615 vl_api_ikev2_set_ike_transforms_t *mp;
12618 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
12620 const char *valid_chars = "a-zA-Z0-9_";
12622 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12624 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
12625 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
12626 vec_add1 (name, 0);
12629 errmsg ("parse error '%U'", format_unformat_error, i);
12634 if (!vec_len (name))
12636 errmsg ("profile name must be specified");
12640 if (vec_len (name) > 64)
12642 errmsg ("profile name too long");
12646 M (IKEV2_SET_IKE_TRANSFORMS, mp);
12648 clib_memcpy (mp->name, name, vec_len (name));
12650 mp->crypto_alg = crypto_alg;
12651 mp->crypto_key_size = crypto_key_size;
12652 mp->integ_alg = integ_alg;
12653 mp->dh_group = dh_group;
12662 api_ikev2_set_esp_transforms (vat_main_t * vam)
12664 unformat_input_t *i = vam->input;
12665 vl_api_ikev2_set_esp_transforms_t *mp;
12668 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
12670 const char *valid_chars = "a-zA-Z0-9_";
12672 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12674 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
12675 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
12676 vec_add1 (name, 0);
12679 errmsg ("parse error '%U'", format_unformat_error, i);
12684 if (!vec_len (name))
12686 errmsg ("profile name must be specified");
12690 if (vec_len (name) > 64)
12692 errmsg ("profile name too long");
12696 M (IKEV2_SET_ESP_TRANSFORMS, mp);
12698 clib_memcpy (mp->name, name, vec_len (name));
12700 mp->crypto_alg = crypto_alg;
12701 mp->crypto_key_size = crypto_key_size;
12702 mp->integ_alg = integ_alg;
12703 mp->dh_group = dh_group;
12711 api_ikev2_set_sa_lifetime (vat_main_t * vam)
12713 unformat_input_t *i = vam->input;
12714 vl_api_ikev2_set_sa_lifetime_t *mp;
12717 u64 lifetime, lifetime_maxdata;
12718 u32 lifetime_jitter, handover;
12720 const char *valid_chars = "a-zA-Z0-9_";
12722 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12724 if (unformat (i, "%U %lu %u %u %lu", unformat_token, valid_chars, &name,
12725 &lifetime, &lifetime_jitter, &handover,
12726 &lifetime_maxdata))
12727 vec_add1 (name, 0);
12730 errmsg ("parse error '%U'", format_unformat_error, i);
12735 if (!vec_len (name))
12737 errmsg ("profile name must be specified");
12741 if (vec_len (name) > 64)
12743 errmsg ("profile name too long");
12747 M (IKEV2_SET_SA_LIFETIME, mp);
12749 clib_memcpy (mp->name, name, vec_len (name));
12751 mp->lifetime = lifetime;
12752 mp->lifetime_jitter = lifetime_jitter;
12753 mp->handover = handover;
12754 mp->lifetime_maxdata = lifetime_maxdata;
12762 api_ikev2_initiate_sa_init (vat_main_t * vam)
12764 unformat_input_t *i = vam->input;
12765 vl_api_ikev2_initiate_sa_init_t *mp;
12769 const char *valid_chars = "a-zA-Z0-9_";
12771 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12773 if (unformat (i, "%U", unformat_token, valid_chars, &name))
12774 vec_add1 (name, 0);
12777 errmsg ("parse error '%U'", format_unformat_error, i);
12782 if (!vec_len (name))
12784 errmsg ("profile name must be specified");
12788 if (vec_len (name) > 64)
12790 errmsg ("profile name too long");
12794 M (IKEV2_INITIATE_SA_INIT, mp);
12796 clib_memcpy (mp->name, name, vec_len (name));
12805 api_ikev2_initiate_del_ike_sa (vat_main_t * vam)
12807 unformat_input_t *i = vam->input;
12808 vl_api_ikev2_initiate_del_ike_sa_t *mp;
12813 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12815 if (unformat (i, "%lx", &ispi))
12819 errmsg ("parse error '%U'", format_unformat_error, i);
12824 M (IKEV2_INITIATE_DEL_IKE_SA, mp);
12834 api_ikev2_initiate_del_child_sa (vat_main_t * vam)
12836 unformat_input_t *i = vam->input;
12837 vl_api_ikev2_initiate_del_child_sa_t *mp;
12842 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12844 if (unformat (i, "%x", &ispi))
12848 errmsg ("parse error '%U'", format_unformat_error, i);
12853 M (IKEV2_INITIATE_DEL_CHILD_SA, mp);
12863 api_ikev2_initiate_rekey_child_sa (vat_main_t * vam)
12865 unformat_input_t *i = vam->input;
12866 vl_api_ikev2_initiate_rekey_child_sa_t *mp;
12871 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12873 if (unformat (i, "%x", &ispi))
12877 errmsg ("parse error '%U'", format_unformat_error, i);
12882 M (IKEV2_INITIATE_REKEY_CHILD_SA, mp);
12895 api_map_add_domain (vat_main_t * vam)
12897 unformat_input_t *i = vam->input;
12898 vl_api_map_add_domain_t *mp;
12900 ip4_address_t ip4_prefix;
12901 ip6_address_t ip6_prefix;
12902 ip6_address_t ip6_src;
12903 u32 num_m_args = 0;
12904 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
12905 0, psid_length = 0;
12906 u8 is_translation = 0;
12908 u32 ip6_src_len = 128;
12911 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12913 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
12914 &ip4_prefix, &ip4_prefix_len))
12916 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
12917 &ip6_prefix, &ip6_prefix_len))
12921 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
12924 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
12926 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
12928 else if (unformat (i, "psid-offset %d", &psid_offset))
12930 else if (unformat (i, "psid-len %d", &psid_length))
12932 else if (unformat (i, "mtu %d", &mtu))
12934 else if (unformat (i, "map-t"))
12935 is_translation = 1;
12938 clib_warning ("parse error '%U'", format_unformat_error, i);
12943 if (num_m_args < 3)
12945 errmsg ("mandatory argument(s) missing");
12949 /* Construct the API message */
12950 M (MAP_ADD_DOMAIN, mp);
12952 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
12953 mp->ip4_prefix_len = ip4_prefix_len;
12955 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
12956 mp->ip6_prefix_len = ip6_prefix_len;
12958 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
12959 mp->ip6_src_prefix_len = ip6_src_len;
12961 mp->ea_bits_len = ea_bits_len;
12962 mp->psid_offset = psid_offset;
12963 mp->psid_length = psid_length;
12964 mp->is_translation = is_translation;
12965 mp->mtu = htons (mtu);
12970 /* Wait for a reply, return good/bad news */
12976 api_map_del_domain (vat_main_t * vam)
12978 unformat_input_t *i = vam->input;
12979 vl_api_map_del_domain_t *mp;
12981 u32 num_m_args = 0;
12985 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12987 if (unformat (i, "index %d", &index))
12991 clib_warning ("parse error '%U'", format_unformat_error, i);
12996 if (num_m_args != 1)
12998 errmsg ("mandatory argument(s) missing");
13002 /* Construct the API message */
13003 M (MAP_DEL_DOMAIN, mp);
13005 mp->index = ntohl (index);
13010 /* Wait for a reply, return good/bad news */
13016 api_map_add_del_rule (vat_main_t * vam)
13018 unformat_input_t *i = vam->input;
13019 vl_api_map_add_del_rule_t *mp;
13021 ip6_address_t ip6_dst;
13022 u32 num_m_args = 0, index, psid = 0;
13025 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13027 if (unformat (i, "index %d", &index))
13029 else if (unformat (i, "psid %d", &psid))
13031 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
13033 else if (unformat (i, "del"))
13039 clib_warning ("parse error '%U'", format_unformat_error, i);
13044 /* Construct the API message */
13045 M (MAP_ADD_DEL_RULE, mp);
13047 mp->index = ntohl (index);
13048 mp->is_add = is_add;
13049 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
13050 mp->psid = ntohs (psid);
13055 /* Wait for a reply, return good/bad news */
13061 api_map_domain_dump (vat_main_t * vam)
13063 vl_api_map_domain_dump_t *mp;
13064 vl_api_control_ping_t *mp_ping;
13067 /* Construct the API message */
13068 M (MAP_DOMAIN_DUMP, mp);
13073 /* Use a control ping for synchronization */
13074 M (CONTROL_PING, mp_ping);
13082 api_map_rule_dump (vat_main_t * vam)
13084 unformat_input_t *i = vam->input;
13085 vl_api_map_rule_dump_t *mp;
13086 vl_api_control_ping_t *mp_ping;
13087 u32 domain_index = ~0;
13090 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13092 if (unformat (i, "index %u", &domain_index))
13098 if (domain_index == ~0)
13100 clib_warning ("parse error: domain index expected");
13104 /* Construct the API message */
13105 M (MAP_RULE_DUMP, mp);
13107 mp->domain_index = htonl (domain_index);
13112 /* Use a control ping for synchronization */
13113 M (CONTROL_PING, mp_ping);
13120 static void vl_api_map_add_domain_reply_t_handler
13121 (vl_api_map_add_domain_reply_t * mp)
13123 vat_main_t *vam = &vat_main;
13124 i32 retval = ntohl (mp->retval);
13126 if (vam->async_mode)
13128 vam->async_errors += (retval < 0);
13132 vam->retval = retval;
13133 vam->result_ready = 1;
13137 static void vl_api_map_add_domain_reply_t_handler_json
13138 (vl_api_map_add_domain_reply_t * mp)
13140 vat_main_t *vam = &vat_main;
13141 vat_json_node_t node;
13143 vat_json_init_object (&node);
13144 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
13145 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
13147 vat_json_print (vam->ofp, &node);
13148 vat_json_free (&node);
13150 vam->retval = ntohl (mp->retval);
13151 vam->result_ready = 1;
13155 api_get_first_msg_id (vat_main_t * vam)
13157 vl_api_get_first_msg_id_t *mp;
13158 unformat_input_t *i = vam->input;
13163 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13165 if (unformat (i, "client %s", &name))
13173 errmsg ("missing client name");
13176 vec_add1 (name, 0);
13178 if (vec_len (name) > 63)
13180 errmsg ("client name too long");
13184 M (GET_FIRST_MSG_ID, mp);
13185 clib_memcpy (mp->name, name, vec_len (name));
13192 api_cop_interface_enable_disable (vat_main_t * vam)
13194 unformat_input_t *line_input = vam->input;
13195 vl_api_cop_interface_enable_disable_t *mp;
13196 u32 sw_if_index = ~0;
13197 u8 enable_disable = 1;
13200 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13202 if (unformat (line_input, "disable"))
13203 enable_disable = 0;
13204 if (unformat (line_input, "enable"))
13205 enable_disable = 1;
13206 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
13207 vam, &sw_if_index))
13209 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13215 if (sw_if_index == ~0)
13217 errmsg ("missing interface name or sw_if_index");
13221 /* Construct the API message */
13222 M (COP_INTERFACE_ENABLE_DISABLE, mp);
13223 mp->sw_if_index = ntohl (sw_if_index);
13224 mp->enable_disable = enable_disable;
13228 /* Wait for the reply */
13234 api_cop_whitelist_enable_disable (vat_main_t * vam)
13236 unformat_input_t *line_input = vam->input;
13237 vl_api_cop_whitelist_enable_disable_t *mp;
13238 u32 sw_if_index = ~0;
13239 u8 ip4 = 0, ip6 = 0, default_cop = 0;
13243 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13245 if (unformat (line_input, "ip4"))
13247 else if (unformat (line_input, "ip6"))
13249 else if (unformat (line_input, "default"))
13251 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
13252 vam, &sw_if_index))
13254 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13256 else if (unformat (line_input, "fib-id %d", &fib_id))
13262 if (sw_if_index == ~0)
13264 errmsg ("missing interface name or sw_if_index");
13268 /* Construct the API message */
13269 M (COP_WHITELIST_ENABLE_DISABLE, mp);
13270 mp->sw_if_index = ntohl (sw_if_index);
13271 mp->fib_id = ntohl (fib_id);
13274 mp->default_cop = default_cop;
13278 /* Wait for the reply */
13284 api_get_node_graph (vat_main_t * vam)
13286 vl_api_get_node_graph_t *mp;
13289 M (GET_NODE_GRAPH, mp);
13293 /* Wait for the reply */
13299 /** Used for parsing LISP eids */
13300 typedef CLIB_PACKED(struct{
13301 u8 addr[16]; /**< eid address */
13302 u32 len; /**< prefix length if IP */
13303 u8 type; /**< type of eid */
13308 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
13310 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
13312 memset (a, 0, sizeof (a[0]));
13314 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
13316 a->type = 0; /* ipv4 type */
13318 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
13320 a->type = 1; /* ipv6 type */
13322 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
13324 a->type = 2; /* mac type */
13331 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
13340 lisp_eid_size_vat (u8 type)
13355 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
13357 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
13361 api_one_add_del_locator_set (vat_main_t * vam)
13363 unformat_input_t *input = vam->input;
13364 vl_api_one_add_del_locator_set_t *mp;
13366 u8 *locator_set_name = NULL;
13367 u8 locator_set_name_set = 0;
13368 vl_api_local_locator_t locator, *locators = 0;
13369 u32 sw_if_index, priority, weight;
13373 /* Parse args required to build the message */
13374 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13376 if (unformat (input, "del"))
13380 else if (unformat (input, "locator-set %s", &locator_set_name))
13382 locator_set_name_set = 1;
13384 else if (unformat (input, "sw_if_index %u p %u w %u",
13385 &sw_if_index, &priority, &weight))
13387 locator.sw_if_index = htonl (sw_if_index);
13388 locator.priority = priority;
13389 locator.weight = weight;
13390 vec_add1 (locators, locator);
13394 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
13395 &sw_if_index, &priority, &weight))
13397 locator.sw_if_index = htonl (sw_if_index);
13398 locator.priority = priority;
13399 locator.weight = weight;
13400 vec_add1 (locators, locator);
13406 if (locator_set_name_set == 0)
13408 errmsg ("missing locator-set name");
13409 vec_free (locators);
13413 if (vec_len (locator_set_name) > 64)
13415 errmsg ("locator-set name too long");
13416 vec_free (locator_set_name);
13417 vec_free (locators);
13420 vec_add1 (locator_set_name, 0);
13422 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
13424 /* Construct the API message */
13425 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
13427 mp->is_add = is_add;
13428 clib_memcpy (mp->locator_set_name, locator_set_name,
13429 vec_len (locator_set_name));
13430 vec_free (locator_set_name);
13432 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
13434 clib_memcpy (mp->locators, locators, data_len);
13435 vec_free (locators);
13440 /* Wait for a reply... */
13445 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
13448 api_one_add_del_locator (vat_main_t * vam)
13450 unformat_input_t *input = vam->input;
13451 vl_api_one_add_del_locator_t *mp;
13452 u32 tmp_if_index = ~0;
13453 u32 sw_if_index = ~0;
13454 u8 sw_if_index_set = 0;
13455 u8 sw_if_index_if_name_set = 0;
13457 u8 priority_set = 0;
13461 u8 *locator_set_name = NULL;
13462 u8 locator_set_name_set = 0;
13465 /* Parse args required to build the message */
13466 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13468 if (unformat (input, "del"))
13472 else if (unformat (input, "locator-set %s", &locator_set_name))
13474 locator_set_name_set = 1;
13476 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
13479 sw_if_index_if_name_set = 1;
13480 sw_if_index = tmp_if_index;
13482 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
13484 sw_if_index_set = 1;
13485 sw_if_index = tmp_if_index;
13487 else if (unformat (input, "p %d", &priority))
13491 else if (unformat (input, "w %d", &weight))
13499 if (locator_set_name_set == 0)
13501 errmsg ("missing locator-set name");
13505 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
13507 errmsg ("missing sw_if_index");
13508 vec_free (locator_set_name);
13512 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
13514 errmsg ("cannot use both params interface name and sw_if_index");
13515 vec_free (locator_set_name);
13519 if (priority_set == 0)
13521 errmsg ("missing locator-set priority");
13522 vec_free (locator_set_name);
13526 if (weight_set == 0)
13528 errmsg ("missing locator-set weight");
13529 vec_free (locator_set_name);
13533 if (vec_len (locator_set_name) > 64)
13535 errmsg ("locator-set name too long");
13536 vec_free (locator_set_name);
13539 vec_add1 (locator_set_name, 0);
13541 /* Construct the API message */
13542 M (ONE_ADD_DEL_LOCATOR, mp);
13544 mp->is_add = is_add;
13545 mp->sw_if_index = ntohl (sw_if_index);
13546 mp->priority = priority;
13547 mp->weight = weight;
13548 clib_memcpy (mp->locator_set_name, locator_set_name,
13549 vec_len (locator_set_name));
13550 vec_free (locator_set_name);
13555 /* Wait for a reply... */
13560 #define api_lisp_add_del_locator api_one_add_del_locator
13563 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
13565 u32 *key_id = va_arg (*args, u32 *);
13568 if (unformat (input, "%s", &s))
13570 if (!strcmp ((char *) s, "sha1"))
13571 key_id[0] = HMAC_SHA_1_96;
13572 else if (!strcmp ((char *) s, "sha256"))
13573 key_id[0] = HMAC_SHA_256_128;
13576 clib_warning ("invalid key_id: '%s'", s);
13577 key_id[0] = HMAC_NO_KEY;
13588 api_one_add_del_local_eid (vat_main_t * vam)
13590 unformat_input_t *input = vam->input;
13591 vl_api_one_add_del_local_eid_t *mp;
13594 lisp_eid_vat_t _eid, *eid = &_eid;
13595 u8 *locator_set_name = 0;
13596 u8 locator_set_name_set = 0;
13602 /* Parse args required to build the message */
13603 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13605 if (unformat (input, "del"))
13609 else if (unformat (input, "vni %d", &vni))
13613 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
13617 else if (unformat (input, "locator-set %s", &locator_set_name))
13619 locator_set_name_set = 1;
13621 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
13623 else if (unformat (input, "secret-key %_%v%_", &key))
13629 if (locator_set_name_set == 0)
13631 errmsg ("missing locator-set name");
13637 errmsg ("EID address not set!");
13638 vec_free (locator_set_name);
13642 if (key && (0 == key_id))
13644 errmsg ("invalid key_id!");
13648 if (vec_len (key) > 64)
13650 errmsg ("key too long");
13655 if (vec_len (locator_set_name) > 64)
13657 errmsg ("locator-set name too long");
13658 vec_free (locator_set_name);
13661 vec_add1 (locator_set_name, 0);
13663 /* Construct the API message */
13664 M (ONE_ADD_DEL_LOCAL_EID, mp);
13666 mp->is_add = is_add;
13667 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
13668 mp->eid_type = eid->type;
13669 mp->prefix_len = eid->len;
13670 mp->vni = clib_host_to_net_u32 (vni);
13671 mp->key_id = clib_host_to_net_u16 (key_id);
13672 clib_memcpy (mp->locator_set_name, locator_set_name,
13673 vec_len (locator_set_name));
13674 clib_memcpy (mp->key, key, vec_len (key));
13676 vec_free (locator_set_name);
13682 /* Wait for a reply... */
13687 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
13690 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
13692 u32 dp_table = 0, vni = 0;;
13693 unformat_input_t *input = vam->input;
13694 vl_api_gpe_add_del_fwd_entry_t *mp;
13696 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
13697 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
13698 u8 rmt_eid_set = 0, lcl_eid_set = 0;
13699 u32 action = ~0, w;
13700 ip4_address_t rmt_rloc4, lcl_rloc4;
13701 ip6_address_t rmt_rloc6, lcl_rloc6;
13702 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
13705 memset (&rloc, 0, sizeof (rloc));
13707 /* Parse args required to build the message */
13708 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13710 if (unformat (input, "del"))
13712 else if (unformat (input, "add"))
13714 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
13718 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
13722 else if (unformat (input, "vrf %d", &dp_table))
13724 else if (unformat (input, "bd %d", &dp_table))
13726 else if (unformat (input, "vni %d", &vni))
13728 else if (unformat (input, "w %d", &w))
13732 errmsg ("No RLOC configured for setting priority/weight!");
13735 curr_rloc->weight = w;
13737 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
13738 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
13742 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
13744 vec_add1 (lcl_locs, rloc);
13746 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
13747 vec_add1 (rmt_locs, rloc);
13748 /* weight saved in rmt loc */
13749 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
13751 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
13752 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
13755 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
13757 vec_add1 (lcl_locs, rloc);
13759 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
13760 vec_add1 (rmt_locs, rloc);
13761 /* weight saved in rmt loc */
13762 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
13764 else if (unformat (input, "action %d", &action))
13770 clib_warning ("parse error '%U'", format_unformat_error, input);
13777 errmsg ("remote eid addresses not set");
13781 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
13783 errmsg ("eid types don't match");
13787 if (0 == rmt_locs && (u32) ~ 0 == action)
13789 errmsg ("action not set for negative mapping");
13793 /* Construct the API message */
13794 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
13795 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
13797 mp->is_add = is_add;
13798 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
13799 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
13800 mp->eid_type = rmt_eid->type;
13801 mp->dp_table = clib_host_to_net_u32 (dp_table);
13802 mp->vni = clib_host_to_net_u32 (vni);
13803 mp->rmt_len = rmt_eid->len;
13804 mp->lcl_len = lcl_eid->len;
13805 mp->action = action;
13807 if (0 != rmt_locs && 0 != lcl_locs)
13809 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
13810 clib_memcpy (mp->locs, lcl_locs,
13811 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
13813 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
13814 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
13815 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
13817 vec_free (lcl_locs);
13818 vec_free (rmt_locs);
13823 /* Wait for a reply... */
13829 api_one_add_del_map_server (vat_main_t * vam)
13831 unformat_input_t *input = vam->input;
13832 vl_api_one_add_del_map_server_t *mp;
13836 ip4_address_t ipv4;
13837 ip6_address_t ipv6;
13840 /* Parse args required to build the message */
13841 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13843 if (unformat (input, "del"))
13847 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
13851 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
13859 if (ipv4_set && ipv6_set)
13861 errmsg ("both eid v4 and v6 addresses set");
13865 if (!ipv4_set && !ipv6_set)
13867 errmsg ("eid addresses not set");
13871 /* Construct the API message */
13872 M (ONE_ADD_DEL_MAP_SERVER, mp);
13874 mp->is_add = is_add;
13878 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
13883 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
13889 /* Wait for a reply... */
13894 #define api_lisp_add_del_map_server api_one_add_del_map_server
13897 api_one_add_del_map_resolver (vat_main_t * vam)
13899 unformat_input_t *input = vam->input;
13900 vl_api_one_add_del_map_resolver_t *mp;
13904 ip4_address_t ipv4;
13905 ip6_address_t ipv6;
13908 /* Parse args required to build the message */
13909 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13911 if (unformat (input, "del"))
13915 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
13919 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
13927 if (ipv4_set && ipv6_set)
13929 errmsg ("both eid v4 and v6 addresses set");
13933 if (!ipv4_set && !ipv6_set)
13935 errmsg ("eid addresses not set");
13939 /* Construct the API message */
13940 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
13942 mp->is_add = is_add;
13946 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
13951 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
13957 /* Wait for a reply... */
13962 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
13965 api_lisp_gpe_enable_disable (vat_main_t * vam)
13967 unformat_input_t *input = vam->input;
13968 vl_api_gpe_enable_disable_t *mp;
13973 /* Parse args required to build the message */
13974 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13976 if (unformat (input, "enable"))
13981 else if (unformat (input, "disable"))
13992 errmsg ("Value not set");
13996 /* Construct the API message */
13997 M (GPE_ENABLE_DISABLE, mp);
14004 /* Wait for a reply... */
14010 api_one_rloc_probe_enable_disable (vat_main_t * vam)
14012 unformat_input_t *input = vam->input;
14013 vl_api_one_rloc_probe_enable_disable_t *mp;
14018 /* Parse args required to build the message */
14019 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14021 if (unformat (input, "enable"))
14026 else if (unformat (input, "disable"))
14034 errmsg ("Value not set");
14038 /* Construct the API message */
14039 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
14041 mp->is_enabled = is_en;
14046 /* Wait for a reply... */
14051 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
14054 api_one_map_register_enable_disable (vat_main_t * vam)
14056 unformat_input_t *input = vam->input;
14057 vl_api_one_map_register_enable_disable_t *mp;
14062 /* Parse args required to build the message */
14063 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14065 if (unformat (input, "enable"))
14070 else if (unformat (input, "disable"))
14078 errmsg ("Value not set");
14082 /* Construct the API message */
14083 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
14085 mp->is_enabled = is_en;
14090 /* Wait for a reply... */
14095 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
14098 api_one_enable_disable (vat_main_t * vam)
14100 unformat_input_t *input = vam->input;
14101 vl_api_one_enable_disable_t *mp;
14106 /* Parse args required to build the message */
14107 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14109 if (unformat (input, "enable"))
14114 else if (unformat (input, "disable"))
14124 errmsg ("Value not set");
14128 /* Construct the API message */
14129 M (ONE_ENABLE_DISABLE, mp);
14136 /* Wait for a reply... */
14141 #define api_lisp_enable_disable api_one_enable_disable
14144 api_show_one_map_register_state (vat_main_t * vam)
14146 vl_api_show_one_map_register_state_t *mp;
14149 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
14154 /* wait for reply */
14159 #define api_show_lisp_map_register_state api_show_one_map_register_state
14162 api_show_one_rloc_probe_state (vat_main_t * vam)
14164 vl_api_show_one_rloc_probe_state_t *mp;
14167 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
14172 /* wait for reply */
14177 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
14180 api_show_one_map_request_mode (vat_main_t * vam)
14182 vl_api_show_one_map_request_mode_t *mp;
14185 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
14190 /* wait for reply */
14195 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
14198 api_one_map_request_mode (vat_main_t * vam)
14200 unformat_input_t *input = vam->input;
14201 vl_api_one_map_request_mode_t *mp;
14205 /* Parse args required to build the message */
14206 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14208 if (unformat (input, "dst-only"))
14210 else if (unformat (input, "src-dst"))
14214 errmsg ("parse error '%U'", format_unformat_error, input);
14219 M (ONE_MAP_REQUEST_MODE, mp);
14226 /* wait for reply */
14231 #define api_lisp_map_request_mode api_one_map_request_mode
14234 * Enable/disable ONE proxy ITR.
14236 * @param vam vpp API test context
14237 * @return return code
14240 api_one_pitr_set_locator_set (vat_main_t * vam)
14242 u8 ls_name_set = 0;
14243 unformat_input_t *input = vam->input;
14244 vl_api_one_pitr_set_locator_set_t *mp;
14249 /* Parse args required to build the message */
14250 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14252 if (unformat (input, "del"))
14254 else if (unformat (input, "locator-set %s", &ls_name))
14258 errmsg ("parse error '%U'", format_unformat_error, input);
14265 errmsg ("locator-set name not set!");
14269 M (ONE_PITR_SET_LOCATOR_SET, mp);
14271 mp->is_add = is_add;
14272 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
14273 vec_free (ls_name);
14278 /* wait for reply */
14283 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
14286 api_show_one_pitr (vat_main_t * vam)
14288 vl_api_show_one_pitr_t *mp;
14291 if (!vam->json_output)
14293 print (vam->ofp, "%=20s", "lisp status:");
14296 M (SHOW_ONE_PITR, mp);
14300 /* Wait for a reply... */
14305 #define api_show_lisp_pitr api_show_one_pitr
14308 * Add/delete mapping between vni and vrf
14311 api_one_eid_table_add_del_map (vat_main_t * vam)
14313 unformat_input_t *input = vam->input;
14314 vl_api_one_eid_table_add_del_map_t *mp;
14315 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
14316 u32 vni, vrf, bd_index;
14319 /* Parse args required to build the message */
14320 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14322 if (unformat (input, "del"))
14324 else if (unformat (input, "vrf %d", &vrf))
14326 else if (unformat (input, "bd_index %d", &bd_index))
14328 else if (unformat (input, "vni %d", &vni))
14334 if (!vni_set || (!vrf_set && !bd_index_set))
14336 errmsg ("missing arguments!");
14340 if (vrf_set && bd_index_set)
14342 errmsg ("error: both vrf and bd entered!");
14346 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
14348 mp->is_add = is_add;
14349 mp->vni = htonl (vni);
14350 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
14351 mp->is_l2 = bd_index_set;
14356 /* wait for reply */
14361 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
14364 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
14366 u32 *action = va_arg (*args, u32 *);
14369 if (unformat (input, "%s", &s))
14371 if (!strcmp ((char *) s, "no-action"))
14373 else if (!strcmp ((char *) s, "natively-forward"))
14375 else if (!strcmp ((char *) s, "send-map-request"))
14377 else if (!strcmp ((char *) s, "drop"))
14381 clib_warning ("invalid action: '%s'", s);
14393 * Add/del remote mapping to/from ONE control plane
14395 * @param vam vpp API test context
14396 * @return return code
14399 api_one_add_del_remote_mapping (vat_main_t * vam)
14401 unformat_input_t *input = vam->input;
14402 vl_api_one_add_del_remote_mapping_t *mp;
14404 lisp_eid_vat_t _eid, *eid = &_eid;
14405 lisp_eid_vat_t _seid, *seid = &_seid;
14406 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
14407 u32 action = ~0, p, w, data_len;
14408 ip4_address_t rloc4;
14409 ip6_address_t rloc6;
14410 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
14413 memset (&rloc, 0, sizeof (rloc));
14415 /* Parse args required to build the message */
14416 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14418 if (unformat (input, "del-all"))
14422 else if (unformat (input, "del"))
14426 else if (unformat (input, "add"))
14430 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
14434 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
14438 else if (unformat (input, "vni %d", &vni))
14442 else if (unformat (input, "p %d w %d", &p, &w))
14446 errmsg ("No RLOC configured for setting priority/weight!");
14449 curr_rloc->priority = p;
14450 curr_rloc->weight = w;
14452 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
14455 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
14456 vec_add1 (rlocs, rloc);
14457 curr_rloc = &rlocs[vec_len (rlocs) - 1];
14459 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
14462 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
14463 vec_add1 (rlocs, rloc);
14464 curr_rloc = &rlocs[vec_len (rlocs) - 1];
14466 else if (unformat (input, "action %U",
14467 unformat_negative_mapping_action, &action))
14473 clib_warning ("parse error '%U'", format_unformat_error, input);
14480 errmsg ("missing params!");
14484 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
14486 errmsg ("no action set for negative map-reply!");
14490 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
14492 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
14493 mp->is_add = is_add;
14494 mp->vni = htonl (vni);
14495 mp->action = (u8) action;
14496 mp->is_src_dst = seid_set;
14497 mp->eid_len = eid->len;
14498 mp->seid_len = seid->len;
14499 mp->del_all = del_all;
14500 mp->eid_type = eid->type;
14501 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
14502 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
14504 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
14505 clib_memcpy (mp->rlocs, rlocs, data_len);
14511 /* Wait for a reply... */
14516 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
14519 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
14520 * forwarding entries in data-plane accordingly.
14522 * @param vam vpp API test context
14523 * @return return code
14526 api_one_add_del_adjacency (vat_main_t * vam)
14528 unformat_input_t *input = vam->input;
14529 vl_api_one_add_del_adjacency_t *mp;
14531 ip4_address_t leid4, reid4;
14532 ip6_address_t leid6, reid6;
14533 u8 reid_mac[6] = { 0 };
14534 u8 leid_mac[6] = { 0 };
14535 u8 reid_type, leid_type;
14536 u32 leid_len = 0, reid_len = 0, len;
14540 leid_type = reid_type = (u8) ~ 0;
14542 /* Parse args required to build the message */
14543 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14545 if (unformat (input, "del"))
14549 else if (unformat (input, "add"))
14553 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
14556 reid_type = 0; /* ipv4 */
14559 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
14562 reid_type = 1; /* ipv6 */
14565 else if (unformat (input, "reid %U", unformat_ethernet_address,
14568 reid_type = 2; /* mac */
14570 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
14573 leid_type = 0; /* ipv4 */
14576 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
14579 leid_type = 1; /* ipv6 */
14582 else if (unformat (input, "leid %U", unformat_ethernet_address,
14585 leid_type = 2; /* mac */
14587 else if (unformat (input, "vni %d", &vni))
14593 errmsg ("parse error '%U'", format_unformat_error, input);
14598 if ((u8) ~ 0 == reid_type)
14600 errmsg ("missing params!");
14604 if (leid_type != reid_type)
14606 errmsg ("remote and local EIDs are of different types!");
14610 M (ONE_ADD_DEL_ADJACENCY, mp);
14611 mp->is_add = is_add;
14612 mp->vni = htonl (vni);
14613 mp->leid_len = leid_len;
14614 mp->reid_len = reid_len;
14615 mp->eid_type = reid_type;
14617 switch (mp->eid_type)
14620 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
14621 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
14624 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
14625 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
14628 clib_memcpy (mp->leid, leid_mac, 6);
14629 clib_memcpy (mp->reid, reid_mac, 6);
14632 errmsg ("unknown EID type %d!", mp->eid_type);
14639 /* Wait for a reply... */
14644 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
14647 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
14649 u32 *mode = va_arg (*args, u32 *);
14651 if (unformat (input, "lisp"))
14653 else if (unformat (input, "vxlan"))
14662 api_gpe_get_encap_mode (vat_main_t * vam)
14664 vl_api_gpe_get_encap_mode_t *mp;
14667 /* Construct the API message */
14668 M (GPE_GET_ENCAP_MODE, mp);
14673 /* Wait for a reply... */
14679 api_gpe_set_encap_mode (vat_main_t * vam)
14681 unformat_input_t *input = vam->input;
14682 vl_api_gpe_set_encap_mode_t *mp;
14686 /* Parse args required to build the message */
14687 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14689 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
14695 /* Construct the API message */
14696 M (GPE_SET_ENCAP_MODE, mp);
14703 /* Wait for a reply... */
14709 api_lisp_gpe_add_del_iface (vat_main_t * vam)
14711 unformat_input_t *input = vam->input;
14712 vl_api_gpe_add_del_iface_t *mp;
14713 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
14714 u32 dp_table = 0, vni = 0;
14717 /* Parse args required to build the message */
14718 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14720 if (unformat (input, "up"))
14725 else if (unformat (input, "down"))
14730 else if (unformat (input, "table_id %d", &dp_table))
14734 else if (unformat (input, "bd_id %d", &dp_table))
14739 else if (unformat (input, "vni %d", &vni))
14747 if (action_set == 0)
14749 errmsg ("Action not set");
14752 if (dp_table_set == 0 || vni_set == 0)
14754 errmsg ("vni and dp_table must be set");
14758 /* Construct the API message */
14759 M (GPE_ADD_DEL_IFACE, mp);
14761 mp->is_add = is_add;
14762 mp->dp_table = dp_table;
14769 /* Wait for a reply... */
14775 * Add/del map request itr rlocs from ONE control plane and updates
14777 * @param vam vpp API test context
14778 * @return return code
14781 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
14783 unformat_input_t *input = vam->input;
14784 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
14785 u8 *locator_set_name = 0;
14786 u8 locator_set_name_set = 0;
14790 /* Parse args required to build the message */
14791 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14793 if (unformat (input, "del"))
14797 else if (unformat (input, "%_%v%_", &locator_set_name))
14799 locator_set_name_set = 1;
14803 clib_warning ("parse error '%U'", format_unformat_error, input);
14808 if (is_add && !locator_set_name_set)
14810 errmsg ("itr-rloc is not set!");
14814 if (is_add && vec_len (locator_set_name) > 64)
14816 errmsg ("itr-rloc locator-set name too long");
14817 vec_free (locator_set_name);
14821 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
14822 mp->is_add = is_add;
14825 clib_memcpy (mp->locator_set_name, locator_set_name,
14826 vec_len (locator_set_name));
14830 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
14832 vec_free (locator_set_name);
14837 /* Wait for a reply... */
14842 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
14845 api_one_locator_dump (vat_main_t * vam)
14847 unformat_input_t *input = vam->input;
14848 vl_api_one_locator_dump_t *mp;
14849 vl_api_control_ping_t *mp_ping;
14850 u8 is_index_set = 0, is_name_set = 0;
14855 /* Parse args required to build the message */
14856 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14858 if (unformat (input, "ls_name %_%v%_", &ls_name))
14862 else if (unformat (input, "ls_index %d", &ls_index))
14868 errmsg ("parse error '%U'", format_unformat_error, input);
14873 if (!is_index_set && !is_name_set)
14875 errmsg ("error: expected one of index or name!");
14879 if (is_index_set && is_name_set)
14881 errmsg ("error: only one param expected!");
14885 if (vec_len (ls_name) > 62)
14887 errmsg ("error: locator set name too long!");
14891 if (!vam->json_output)
14893 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
14896 M (ONE_LOCATOR_DUMP, mp);
14897 mp->is_index_set = is_index_set;
14900 mp->ls_index = clib_host_to_net_u32 (ls_index);
14903 vec_add1 (ls_name, 0);
14904 strncpy ((char *) mp->ls_name, (char *) ls_name,
14905 sizeof (mp->ls_name) - 1);
14911 /* Use a control ping for synchronization */
14912 M (CONTROL_PING, mp_ping);
14915 /* Wait for a reply... */
14920 #define api_lisp_locator_dump api_one_locator_dump
14923 api_one_locator_set_dump (vat_main_t * vam)
14925 vl_api_one_locator_set_dump_t *mp;
14926 vl_api_control_ping_t *mp_ping;
14927 unformat_input_t *input = vam->input;
14931 /* Parse args required to build the message */
14932 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14934 if (unformat (input, "local"))
14938 else if (unformat (input, "remote"))
14944 errmsg ("parse error '%U'", format_unformat_error, input);
14949 if (!vam->json_output)
14951 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
14954 M (ONE_LOCATOR_SET_DUMP, mp);
14956 mp->filter = filter;
14961 /* Use a control ping for synchronization */
14962 M (CONTROL_PING, mp_ping);
14965 /* Wait for a reply... */
14970 #define api_lisp_locator_set_dump api_one_locator_set_dump
14973 api_one_eid_table_map_dump (vat_main_t * vam)
14977 unformat_input_t *input = vam->input;
14978 vl_api_one_eid_table_map_dump_t *mp;
14979 vl_api_control_ping_t *mp_ping;
14982 /* Parse args required to build the message */
14983 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14985 if (unformat (input, "l2"))
14990 else if (unformat (input, "l3"))
14997 errmsg ("parse error '%U'", format_unformat_error, input);
15004 errmsg ("expected one of 'l2' or 'l3' parameter!");
15008 if (!vam->json_output)
15010 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
15013 M (ONE_EID_TABLE_MAP_DUMP, mp);
15019 /* Use a control ping for synchronization */
15020 M (CONTROL_PING, mp_ping);
15023 /* Wait for a reply... */
15028 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
15031 api_one_eid_table_vni_dump (vat_main_t * vam)
15033 vl_api_one_eid_table_vni_dump_t *mp;
15034 vl_api_control_ping_t *mp_ping;
15037 if (!vam->json_output)
15039 print (vam->ofp, "VNI");
15042 M (ONE_EID_TABLE_VNI_DUMP, mp);
15047 /* Use a control ping for synchronization */
15048 M (CONTROL_PING, mp_ping);
15051 /* Wait for a reply... */
15056 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
15059 api_one_eid_table_dump (vat_main_t * vam)
15061 unformat_input_t *i = vam->input;
15062 vl_api_one_eid_table_dump_t *mp;
15063 vl_api_control_ping_t *mp_ping;
15064 struct in_addr ip4;
15065 struct in6_addr ip6;
15067 u8 eid_type = ~0, eid_set = 0;
15068 u32 prefix_length = ~0, t, vni = 0;
15072 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15074 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
15080 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
15086 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
15091 else if (unformat (i, "vni %d", &t))
15095 else if (unformat (i, "local"))
15099 else if (unformat (i, "remote"))
15105 errmsg ("parse error '%U'", format_unformat_error, i);
15110 if (!vam->json_output)
15112 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
15113 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
15116 M (ONE_EID_TABLE_DUMP, mp);
15118 mp->filter = filter;
15122 mp->vni = htonl (vni);
15123 mp->eid_type = eid_type;
15127 mp->prefix_length = prefix_length;
15128 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
15131 mp->prefix_length = prefix_length;
15132 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
15135 clib_memcpy (mp->eid, mac, sizeof (mac));
15138 errmsg ("unknown EID type %d!", eid_type);
15146 /* Use a control ping for synchronization */
15147 M (CONTROL_PING, mp_ping);
15150 /* Wait for a reply... */
15155 #define api_lisp_eid_table_dump api_one_eid_table_dump
15158 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
15160 unformat_input_t *i = vam->input;
15161 vl_api_gpe_fwd_entries_get_t *mp;
15166 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15168 if (unformat (i, "vni %d", &vni))
15174 errmsg ("parse error '%U'", format_unformat_error, i);
15181 errmsg ("vni not set!");
15185 if (!vam->json_output)
15187 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
15191 M (GPE_FWD_ENTRIES_GET, mp);
15192 mp->vni = clib_host_to_net_u32 (vni);
15197 /* Wait for a reply... */
15202 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
15203 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
15204 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
15205 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
15208 api_one_adjacencies_get (vat_main_t * vam)
15210 unformat_input_t *i = vam->input;
15211 vl_api_one_adjacencies_get_t *mp;
15216 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15218 if (unformat (i, "vni %d", &vni))
15224 errmsg ("parse error '%U'", format_unformat_error, i);
15231 errmsg ("vni not set!");
15235 if (!vam->json_output)
15237 print (vam->ofp, "%s %40s", "leid", "reid");
15240 M (ONE_ADJACENCIES_GET, mp);
15241 mp->vni = clib_host_to_net_u32 (vni);
15246 /* Wait for a reply... */
15251 #define api_lisp_adjacencies_get api_one_adjacencies_get
15254 api_one_map_server_dump (vat_main_t * vam)
15256 vl_api_one_map_server_dump_t *mp;
15257 vl_api_control_ping_t *mp_ping;
15260 if (!vam->json_output)
15262 print (vam->ofp, "%=20s", "Map server");
15265 M (ONE_MAP_SERVER_DUMP, mp);
15269 /* Use a control ping for synchronization */
15270 M (CONTROL_PING, mp_ping);
15273 /* Wait for a reply... */
15278 #define api_lisp_map_server_dump api_one_map_server_dump
15281 api_one_map_resolver_dump (vat_main_t * vam)
15283 vl_api_one_map_resolver_dump_t *mp;
15284 vl_api_control_ping_t *mp_ping;
15287 if (!vam->json_output)
15289 print (vam->ofp, "%=20s", "Map resolver");
15292 M (ONE_MAP_RESOLVER_DUMP, mp);
15296 /* Use a control ping for synchronization */
15297 M (CONTROL_PING, mp_ping);
15300 /* Wait for a reply... */
15305 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
15308 api_show_one_status (vat_main_t * vam)
15310 vl_api_show_one_status_t *mp;
15313 if (!vam->json_output)
15315 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
15318 M (SHOW_ONE_STATUS, mp);
15321 /* Wait for a reply... */
15326 #define api_show_lisp_status api_show_one_status
15329 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
15331 vl_api_gpe_fwd_entry_path_dump_t *mp;
15332 vl_api_control_ping_t *mp_ping;
15333 unformat_input_t *i = vam->input;
15334 u32 fwd_entry_index = ~0;
15337 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15339 if (unformat (i, "index %d", &fwd_entry_index))
15345 if (~0 == fwd_entry_index)
15347 errmsg ("no index specified!");
15351 if (!vam->json_output)
15353 print (vam->ofp, "first line");
15356 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
15360 /* Use a control ping for synchronization */
15361 M (CONTROL_PING, mp_ping);
15364 /* Wait for a reply... */
15370 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
15372 vl_api_one_get_map_request_itr_rlocs_t *mp;
15375 if (!vam->json_output)
15377 print (vam->ofp, "%=20s", "itr-rlocs:");
15380 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
15383 /* Wait for a reply... */
15388 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
15391 api_af_packet_create (vat_main_t * vam)
15393 unformat_input_t *i = vam->input;
15394 vl_api_af_packet_create_t *mp;
15395 u8 *host_if_name = 0;
15397 u8 random_hw_addr = 1;
15400 memset (hw_addr, 0, sizeof (hw_addr));
15402 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15404 if (unformat (i, "name %s", &host_if_name))
15405 vec_add1 (host_if_name, 0);
15406 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
15407 random_hw_addr = 0;
15412 if (!vec_len (host_if_name))
15414 errmsg ("host-interface name must be specified");
15418 if (vec_len (host_if_name) > 64)
15420 errmsg ("host-interface name too long");
15424 M (AF_PACKET_CREATE, mp);
15426 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
15427 clib_memcpy (mp->hw_addr, hw_addr, 6);
15428 mp->use_random_hw_addr = random_hw_addr;
15429 vec_free (host_if_name);
15437 fprintf (vam->ofp ? vam->ofp : stderr,
15438 " new sw_if_index = %d\n", vam->sw_if_index);
15445 api_af_packet_delete (vat_main_t * vam)
15447 unformat_input_t *i = vam->input;
15448 vl_api_af_packet_delete_t *mp;
15449 u8 *host_if_name = 0;
15452 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15454 if (unformat (i, "name %s", &host_if_name))
15455 vec_add1 (host_if_name, 0);
15460 if (!vec_len (host_if_name))
15462 errmsg ("host-interface name must be specified");
15466 if (vec_len (host_if_name) > 64)
15468 errmsg ("host-interface name too long");
15472 M (AF_PACKET_DELETE, mp);
15474 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
15475 vec_free (host_if_name);
15483 api_policer_add_del (vat_main_t * vam)
15485 unformat_input_t *i = vam->input;
15486 vl_api_policer_add_del_t *mp;
15496 u8 color_aware = 0;
15497 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
15500 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
15501 conform_action.dscp = 0;
15502 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
15503 exceed_action.dscp = 0;
15504 violate_action.action_type = SSE2_QOS_ACTION_DROP;
15505 violate_action.dscp = 0;
15507 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15509 if (unformat (i, "del"))
15511 else if (unformat (i, "name %s", &name))
15512 vec_add1 (name, 0);
15513 else if (unformat (i, "cir %u", &cir))
15515 else if (unformat (i, "eir %u", &eir))
15517 else if (unformat (i, "cb %u", &cb))
15519 else if (unformat (i, "eb %u", &eb))
15521 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
15524 else if (unformat (i, "round_type %U", unformat_policer_round_type,
15527 else if (unformat (i, "type %U", unformat_policer_type, &type))
15529 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
15532 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
15535 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
15538 else if (unformat (i, "color-aware"))
15544 if (!vec_len (name))
15546 errmsg ("policer name must be specified");
15550 if (vec_len (name) > 64)
15552 errmsg ("policer name too long");
15556 M (POLICER_ADD_DEL, mp);
15558 clib_memcpy (mp->name, name, vec_len (name));
15560 mp->is_add = is_add;
15565 mp->rate_type = rate_type;
15566 mp->round_type = round_type;
15568 mp->conform_action_type = conform_action.action_type;
15569 mp->conform_dscp = conform_action.dscp;
15570 mp->exceed_action_type = exceed_action.action_type;
15571 mp->exceed_dscp = exceed_action.dscp;
15572 mp->violate_action_type = violate_action.action_type;
15573 mp->violate_dscp = violate_action.dscp;
15574 mp->color_aware = color_aware;
15582 api_policer_dump (vat_main_t * vam)
15584 unformat_input_t *i = vam->input;
15585 vl_api_policer_dump_t *mp;
15586 vl_api_control_ping_t *mp_ping;
15587 u8 *match_name = 0;
15588 u8 match_name_valid = 0;
15591 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15593 if (unformat (i, "name %s", &match_name))
15595 vec_add1 (match_name, 0);
15596 match_name_valid = 1;
15602 M (POLICER_DUMP, mp);
15603 mp->match_name_valid = match_name_valid;
15604 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
15605 vec_free (match_name);
15609 /* Use a control ping for synchronization */
15610 M (CONTROL_PING, mp_ping);
15613 /* Wait for a reply... */
15619 api_policer_classify_set_interface (vat_main_t * vam)
15621 unformat_input_t *i = vam->input;
15622 vl_api_policer_classify_set_interface_t *mp;
15624 int sw_if_index_set;
15625 u32 ip4_table_index = ~0;
15626 u32 ip6_table_index = ~0;
15627 u32 l2_table_index = ~0;
15631 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15633 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15634 sw_if_index_set = 1;
15635 else if (unformat (i, "sw_if_index %d", &sw_if_index))
15636 sw_if_index_set = 1;
15637 else if (unformat (i, "del"))
15639 else if (unformat (i, "ip4-table %d", &ip4_table_index))
15641 else if (unformat (i, "ip6-table %d", &ip6_table_index))
15643 else if (unformat (i, "l2-table %d", &l2_table_index))
15647 clib_warning ("parse error '%U'", format_unformat_error, i);
15652 if (sw_if_index_set == 0)
15654 errmsg ("missing interface name or sw_if_index");
15658 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
15660 mp->sw_if_index = ntohl (sw_if_index);
15661 mp->ip4_table_index = ntohl (ip4_table_index);
15662 mp->ip6_table_index = ntohl (ip6_table_index);
15663 mp->l2_table_index = ntohl (l2_table_index);
15664 mp->is_add = is_add;
15672 api_policer_classify_dump (vat_main_t * vam)
15674 unformat_input_t *i = vam->input;
15675 vl_api_policer_classify_dump_t *mp;
15676 vl_api_control_ping_t *mp_ping;
15677 u8 type = POLICER_CLASSIFY_N_TABLES;
15680 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
15684 errmsg ("classify table type must be specified");
15688 if (!vam->json_output)
15690 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
15693 M (POLICER_CLASSIFY_DUMP, mp);
15698 /* Use a control ping for synchronization */
15699 M (CONTROL_PING, mp_ping);
15702 /* Wait for a reply... */
15708 api_netmap_create (vat_main_t * vam)
15710 unformat_input_t *i = vam->input;
15711 vl_api_netmap_create_t *mp;
15714 u8 random_hw_addr = 1;
15719 memset (hw_addr, 0, sizeof (hw_addr));
15721 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15723 if (unformat (i, "name %s", &if_name))
15724 vec_add1 (if_name, 0);
15725 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
15726 random_hw_addr = 0;
15727 else if (unformat (i, "pipe"))
15729 else if (unformat (i, "master"))
15731 else if (unformat (i, "slave"))
15737 if (!vec_len (if_name))
15739 errmsg ("interface name must be specified");
15743 if (vec_len (if_name) > 64)
15745 errmsg ("interface name too long");
15749 M (NETMAP_CREATE, mp);
15751 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
15752 clib_memcpy (mp->hw_addr, hw_addr, 6);
15753 mp->use_random_hw_addr = random_hw_addr;
15754 mp->is_pipe = is_pipe;
15755 mp->is_master = is_master;
15756 vec_free (if_name);
15764 api_netmap_delete (vat_main_t * vam)
15766 unformat_input_t *i = vam->input;
15767 vl_api_netmap_delete_t *mp;
15771 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15773 if (unformat (i, "name %s", &if_name))
15774 vec_add1 (if_name, 0);
15779 if (!vec_len (if_name))
15781 errmsg ("interface name must be specified");
15785 if (vec_len (if_name) > 64)
15787 errmsg ("interface name too long");
15791 M (NETMAP_DELETE, mp);
15793 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
15794 vec_free (if_name);
15801 static void vl_api_mpls_tunnel_details_t_handler
15802 (vl_api_mpls_tunnel_details_t * mp)
15804 vat_main_t *vam = &vat_main;
15805 i32 len = mp->mt_next_hop_n_labels;
15808 print (vam->ofp, "[%d]: via %U %d labels ",
15810 format_ip4_address, mp->mt_next_hop,
15811 ntohl (mp->mt_next_hop_sw_if_index));
15812 for (i = 0; i < len; i++)
15814 print (vam->ofp, "%u ", ntohl (mp->mt_next_hop_out_labels[i]));
15816 print (vam->ofp, "");
15819 static void vl_api_mpls_tunnel_details_t_handler_json
15820 (vl_api_mpls_tunnel_details_t * mp)
15822 vat_main_t *vam = &vat_main;
15823 vat_json_node_t *node = NULL;
15824 struct in_addr ip4;
15826 i32 len = mp->mt_next_hop_n_labels;
15828 if (VAT_JSON_ARRAY != vam->json_tree.type)
15830 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15831 vat_json_init_array (&vam->json_tree);
15833 node = vat_json_array_add (&vam->json_tree);
15835 vat_json_init_object (node);
15836 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
15837 clib_memcpy (&ip4, &(mp->mt_next_hop), sizeof (ip4));
15838 vat_json_object_add_ip4 (node, "next_hop", ip4);
15839 vat_json_object_add_uint (node, "next_hop_sw_if_index",
15840 ntohl (mp->mt_next_hop_sw_if_index));
15841 vat_json_object_add_uint (node, "l2_only", ntohl (mp->mt_l2_only));
15842 vat_json_object_add_uint (node, "label_count", len);
15843 for (i = 0; i < len; i++)
15845 vat_json_object_add_uint (node, "label",
15846 ntohl (mp->mt_next_hop_out_labels[i]));
15851 api_mpls_tunnel_dump (vat_main_t * vam)
15853 vl_api_mpls_tunnel_dump_t *mp;
15854 vl_api_control_ping_t *mp_ping;
15858 /* Parse args required to build the message */
15859 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
15861 if (!unformat (vam->input, "tunnel_index %d", &index))
15868 print (vam->ofp, " tunnel_index %d", index);
15870 M (MPLS_TUNNEL_DUMP, mp);
15871 mp->tunnel_index = htonl (index);
15874 /* Use a control ping for synchronization */
15875 M (CONTROL_PING, mp_ping);
15882 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
15883 #define vl_api_mpls_fib_details_t_print vl_noop_handler
15886 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
15888 vat_main_t *vam = &vat_main;
15889 int count = ntohl (mp->count);
15890 vl_api_fib_path2_t *fp;
15894 "table-id %d, label %u, ess_bit %u",
15895 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
15897 for (i = 0; i < count; i++)
15899 if (fp->afi == IP46_TYPE_IP6)
15901 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15902 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15903 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15904 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15905 format_ip6_address, fp->next_hop);
15906 else if (fp->afi == IP46_TYPE_IP4)
15908 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15909 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15910 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15911 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15912 format_ip4_address, fp->next_hop);
15917 static void vl_api_mpls_fib_details_t_handler_json
15918 (vl_api_mpls_fib_details_t * mp)
15920 vat_main_t *vam = &vat_main;
15921 int count = ntohl (mp->count);
15922 vat_json_node_t *node = NULL;
15923 struct in_addr ip4;
15924 struct in6_addr ip6;
15925 vl_api_fib_path2_t *fp;
15928 if (VAT_JSON_ARRAY != vam->json_tree.type)
15930 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15931 vat_json_init_array (&vam->json_tree);
15933 node = vat_json_array_add (&vam->json_tree);
15935 vat_json_init_object (node);
15936 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
15937 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
15938 vat_json_object_add_uint (node, "label", ntohl (mp->label));
15939 vat_json_object_add_uint (node, "path_count", count);
15941 for (i = 0; i < count; i++)
15943 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
15944 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
15945 vat_json_object_add_uint (node, "is_local", fp->is_local);
15946 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
15947 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
15948 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
15949 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
15950 if (fp->afi == IP46_TYPE_IP4)
15952 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
15953 vat_json_object_add_ip4 (node, "next_hop", ip4);
15955 else if (fp->afi == IP46_TYPE_IP6)
15957 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
15958 vat_json_object_add_ip6 (node, "next_hop", ip6);
15964 api_mpls_fib_dump (vat_main_t * vam)
15966 vl_api_mpls_fib_dump_t *mp;
15967 vl_api_control_ping_t *mp_ping;
15970 M (MPLS_FIB_DUMP, mp);
15973 /* Use a control ping for synchronization */
15974 M (CONTROL_PING, mp_ping);
15981 #define vl_api_ip_fib_details_t_endian vl_noop_handler
15982 #define vl_api_ip_fib_details_t_print vl_noop_handler
15985 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
15987 vat_main_t *vam = &vat_main;
15988 int count = ntohl (mp->count);
15989 vl_api_fib_path_t *fp;
15993 "table-id %d, prefix %U/%d",
15994 ntohl (mp->table_id), format_ip4_address, mp->address,
15995 mp->address_length);
15997 for (i = 0; i < count; i++)
15999 if (fp->afi == IP46_TYPE_IP6)
16001 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16002 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16003 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16004 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16005 format_ip6_address, fp->next_hop);
16006 else if (fp->afi == IP46_TYPE_IP4)
16008 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16009 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16010 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16011 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16012 format_ip4_address, fp->next_hop);
16017 static void vl_api_ip_fib_details_t_handler_json
16018 (vl_api_ip_fib_details_t * mp)
16020 vat_main_t *vam = &vat_main;
16021 int count = ntohl (mp->count);
16022 vat_json_node_t *node = NULL;
16023 struct in_addr ip4;
16024 struct in6_addr ip6;
16025 vl_api_fib_path_t *fp;
16028 if (VAT_JSON_ARRAY != vam->json_tree.type)
16030 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16031 vat_json_init_array (&vam->json_tree);
16033 node = vat_json_array_add (&vam->json_tree);
16035 vat_json_init_object (node);
16036 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
16037 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
16038 vat_json_object_add_ip4 (node, "prefix", ip4);
16039 vat_json_object_add_uint (node, "mask_length", mp->address_length);
16040 vat_json_object_add_uint (node, "path_count", count);
16042 for (i = 0; i < count; i++)
16044 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
16045 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
16046 vat_json_object_add_uint (node, "is_local", fp->is_local);
16047 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
16048 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
16049 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
16050 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
16051 if (fp->afi == IP46_TYPE_IP4)
16053 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
16054 vat_json_object_add_ip4 (node, "next_hop", ip4);
16056 else if (fp->afi == IP46_TYPE_IP6)
16058 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
16059 vat_json_object_add_ip6 (node, "next_hop", ip6);
16065 api_ip_fib_dump (vat_main_t * vam)
16067 vl_api_ip_fib_dump_t *mp;
16068 vl_api_control_ping_t *mp_ping;
16071 M (IP_FIB_DUMP, mp);
16074 /* Use a control ping for synchronization */
16075 M (CONTROL_PING, mp_ping);
16083 api_ip_mfib_dump (vat_main_t * vam)
16085 vl_api_ip_mfib_dump_t *mp;
16086 vl_api_control_ping_t *mp_ping;
16089 M (IP_MFIB_DUMP, mp);
16092 /* Use a control ping for synchronization */
16093 M (CONTROL_PING, mp_ping);
16100 static void vl_api_ip_neighbor_details_t_handler
16101 (vl_api_ip_neighbor_details_t * mp)
16103 vat_main_t *vam = &vat_main;
16105 print (vam->ofp, "%c %U %U",
16106 (mp->is_static) ? 'S' : 'D',
16107 format_ethernet_address, &mp->mac_address,
16108 (mp->is_ipv6) ? format_ip6_address : format_ip4_address,
16112 static void vl_api_ip_neighbor_details_t_handler_json
16113 (vl_api_ip_neighbor_details_t * mp)
16116 vat_main_t *vam = &vat_main;
16117 vat_json_node_t *node;
16118 struct in_addr ip4;
16119 struct in6_addr ip6;
16121 if (VAT_JSON_ARRAY != vam->json_tree.type)
16123 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16124 vat_json_init_array (&vam->json_tree);
16126 node = vat_json_array_add (&vam->json_tree);
16128 vat_json_init_object (node);
16129 vat_json_object_add_string_copy (node, "flag",
16130 (mp->is_static) ? (u8 *) "static" : (u8 *)
16133 vat_json_object_add_string_copy (node, "link_layer",
16134 format (0, "%U", format_ethernet_address,
16135 &mp->mac_address));
16139 clib_memcpy (&ip6, &mp->ip_address, sizeof (ip6));
16140 vat_json_object_add_ip6 (node, "ip_address", ip6);
16144 clib_memcpy (&ip4, &mp->ip_address, sizeof (ip4));
16145 vat_json_object_add_ip4 (node, "ip_address", ip4);
16150 api_ip_neighbor_dump (vat_main_t * vam)
16152 unformat_input_t *i = vam->input;
16153 vl_api_ip_neighbor_dump_t *mp;
16154 vl_api_control_ping_t *mp_ping;
16156 u32 sw_if_index = ~0;
16159 /* Parse args required to build the message */
16160 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16162 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16164 else if (unformat (i, "sw_if_index %d", &sw_if_index))
16166 else if (unformat (i, "ip6"))
16172 if (sw_if_index == ~0)
16174 errmsg ("missing interface name or sw_if_index");
16178 M (IP_NEIGHBOR_DUMP, mp);
16179 mp->is_ipv6 = (u8) is_ipv6;
16180 mp->sw_if_index = ntohl (sw_if_index);
16183 /* Use a control ping for synchronization */
16184 M (CONTROL_PING, mp_ping);
16191 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
16192 #define vl_api_ip6_fib_details_t_print vl_noop_handler
16195 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
16197 vat_main_t *vam = &vat_main;
16198 int count = ntohl (mp->count);
16199 vl_api_fib_path_t *fp;
16203 "table-id %d, prefix %U/%d",
16204 ntohl (mp->table_id), format_ip6_address, mp->address,
16205 mp->address_length);
16207 for (i = 0; i < count; i++)
16209 if (fp->afi == IP46_TYPE_IP6)
16211 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16212 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16213 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16214 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16215 format_ip6_address, fp->next_hop);
16216 else if (fp->afi == IP46_TYPE_IP4)
16218 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16219 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16220 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16221 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16222 format_ip4_address, fp->next_hop);
16227 static void vl_api_ip6_fib_details_t_handler_json
16228 (vl_api_ip6_fib_details_t * mp)
16230 vat_main_t *vam = &vat_main;
16231 int count = ntohl (mp->count);
16232 vat_json_node_t *node = NULL;
16233 struct in_addr ip4;
16234 struct in6_addr ip6;
16235 vl_api_fib_path_t *fp;
16238 if (VAT_JSON_ARRAY != vam->json_tree.type)
16240 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16241 vat_json_init_array (&vam->json_tree);
16243 node = vat_json_array_add (&vam->json_tree);
16245 vat_json_init_object (node);
16246 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
16247 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
16248 vat_json_object_add_ip6 (node, "prefix", ip6);
16249 vat_json_object_add_uint (node, "mask_length", mp->address_length);
16250 vat_json_object_add_uint (node, "path_count", count);
16252 for (i = 0; i < count; i++)
16254 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
16255 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
16256 vat_json_object_add_uint (node, "is_local", fp->is_local);
16257 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
16258 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
16259 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
16260 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
16261 if (fp->afi == IP46_TYPE_IP4)
16263 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
16264 vat_json_object_add_ip4 (node, "next_hop", ip4);
16266 else if (fp->afi == IP46_TYPE_IP6)
16268 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
16269 vat_json_object_add_ip6 (node, "next_hop", ip6);
16275 api_ip6_fib_dump (vat_main_t * vam)
16277 vl_api_ip6_fib_dump_t *mp;
16278 vl_api_control_ping_t *mp_ping;
16281 M (IP6_FIB_DUMP, mp);
16284 /* Use a control ping for synchronization */
16285 M (CONTROL_PING, mp_ping);
16293 api_ip6_mfib_dump (vat_main_t * vam)
16295 vl_api_ip6_mfib_dump_t *mp;
16296 vl_api_control_ping_t *mp_ping;
16299 M (IP6_MFIB_DUMP, mp);
16302 /* Use a control ping for synchronization */
16303 M (CONTROL_PING, mp_ping);
16311 api_classify_table_ids (vat_main_t * vam)
16313 vl_api_classify_table_ids_t *mp;
16316 /* Construct the API message */
16317 M (CLASSIFY_TABLE_IDS, mp);
16326 api_classify_table_by_interface (vat_main_t * vam)
16328 unformat_input_t *input = vam->input;
16329 vl_api_classify_table_by_interface_t *mp;
16331 u32 sw_if_index = ~0;
16333 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16335 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16337 else if (unformat (input, "sw_if_index %d", &sw_if_index))
16342 if (sw_if_index == ~0)
16344 errmsg ("missing interface name or sw_if_index");
16348 /* Construct the API message */
16349 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
16351 mp->sw_if_index = ntohl (sw_if_index);
16359 api_classify_table_info (vat_main_t * vam)
16361 unformat_input_t *input = vam->input;
16362 vl_api_classify_table_info_t *mp;
16366 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16368 if (unformat (input, "table_id %d", &table_id))
16373 if (table_id == ~0)
16375 errmsg ("missing table id");
16379 /* Construct the API message */
16380 M (CLASSIFY_TABLE_INFO, mp);
16382 mp->table_id = ntohl (table_id);
16390 api_classify_session_dump (vat_main_t * vam)
16392 unformat_input_t *input = vam->input;
16393 vl_api_classify_session_dump_t *mp;
16394 vl_api_control_ping_t *mp_ping;
16398 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16400 if (unformat (input, "table_id %d", &table_id))
16405 if (table_id == ~0)
16407 errmsg ("missing table id");
16411 /* Construct the API message */
16412 M (CLASSIFY_SESSION_DUMP, mp);
16414 mp->table_id = ntohl (table_id);
16417 /* Use a control ping for synchronization */
16418 M (CONTROL_PING, mp_ping);
16426 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
16428 vat_main_t *vam = &vat_main;
16430 print (vam->ofp, "collector_address %U, collector_port %d, "
16431 "src_address %U, vrf_id %d, path_mtu %u, "
16432 "template_interval %u, udp_checksum %d",
16433 format_ip4_address, mp->collector_address,
16434 ntohs (mp->collector_port),
16435 format_ip4_address, mp->src_address,
16436 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
16437 ntohl (mp->template_interval), mp->udp_checksum);
16440 vam->result_ready = 1;
16444 vl_api_ipfix_exporter_details_t_handler_json
16445 (vl_api_ipfix_exporter_details_t * mp)
16447 vat_main_t *vam = &vat_main;
16448 vat_json_node_t node;
16449 struct in_addr collector_address;
16450 struct in_addr src_address;
16452 vat_json_init_object (&node);
16453 clib_memcpy (&collector_address, &mp->collector_address,
16454 sizeof (collector_address));
16455 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
16456 vat_json_object_add_uint (&node, "collector_port",
16457 ntohs (mp->collector_port));
16458 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
16459 vat_json_object_add_ip4 (&node, "src_address", src_address);
16460 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
16461 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
16462 vat_json_object_add_uint (&node, "template_interval",
16463 ntohl (mp->template_interval));
16464 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
16466 vat_json_print (vam->ofp, &node);
16467 vat_json_free (&node);
16469 vam->result_ready = 1;
16473 api_ipfix_exporter_dump (vat_main_t * vam)
16475 vl_api_ipfix_exporter_dump_t *mp;
16478 /* Construct the API message */
16479 M (IPFIX_EXPORTER_DUMP, mp);
16488 api_ipfix_classify_stream_dump (vat_main_t * vam)
16490 vl_api_ipfix_classify_stream_dump_t *mp;
16493 /* Construct the API message */
16494 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
16505 vl_api_ipfix_classify_stream_details_t_handler
16506 (vl_api_ipfix_classify_stream_details_t * mp)
16508 vat_main_t *vam = &vat_main;
16509 print (vam->ofp, "domain_id %d, src_port %d",
16510 ntohl (mp->domain_id), ntohs (mp->src_port));
16512 vam->result_ready = 1;
16516 vl_api_ipfix_classify_stream_details_t_handler_json
16517 (vl_api_ipfix_classify_stream_details_t * mp)
16519 vat_main_t *vam = &vat_main;
16520 vat_json_node_t node;
16522 vat_json_init_object (&node);
16523 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
16524 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
16526 vat_json_print (vam->ofp, &node);
16527 vat_json_free (&node);
16529 vam->result_ready = 1;
16533 api_ipfix_classify_table_dump (vat_main_t * vam)
16535 vl_api_ipfix_classify_table_dump_t *mp;
16536 vl_api_control_ping_t *mp_ping;
16539 if (!vam->json_output)
16541 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
16542 "transport_protocol");
16545 /* Construct the API message */
16546 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
16551 /* Use a control ping for synchronization */
16552 M (CONTROL_PING, mp_ping);
16560 vl_api_ipfix_classify_table_details_t_handler
16561 (vl_api_ipfix_classify_table_details_t * mp)
16563 vat_main_t *vam = &vat_main;
16564 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
16565 mp->transport_protocol);
16569 vl_api_ipfix_classify_table_details_t_handler_json
16570 (vl_api_ipfix_classify_table_details_t * mp)
16572 vat_json_node_t *node = NULL;
16573 vat_main_t *vam = &vat_main;
16575 if (VAT_JSON_ARRAY != vam->json_tree.type)
16577 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16578 vat_json_init_array (&vam->json_tree);
16581 node = vat_json_array_add (&vam->json_tree);
16582 vat_json_init_object (node);
16584 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
16585 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
16586 vat_json_object_add_uint (node, "transport_protocol",
16587 mp->transport_protocol);
16591 api_sw_interface_span_enable_disable (vat_main_t * vam)
16593 unformat_input_t *i = vam->input;
16594 vl_api_sw_interface_span_enable_disable_t *mp;
16595 u32 src_sw_if_index = ~0;
16596 u32 dst_sw_if_index = ~0;
16600 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16603 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
16605 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
16609 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
16611 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
16613 else if (unformat (i, "disable"))
16615 else if (unformat (i, "rx"))
16617 else if (unformat (i, "tx"))
16619 else if (unformat (i, "both"))
16625 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
16627 mp->sw_if_index_from = htonl (src_sw_if_index);
16628 mp->sw_if_index_to = htonl (dst_sw_if_index);
16637 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
16640 vat_main_t *vam = &vat_main;
16641 u8 *sw_if_from_name = 0;
16642 u8 *sw_if_to_name = 0;
16643 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
16644 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
16645 char *states[] = { "none", "rx", "tx", "both" };
16649 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
16651 if ((u32) p->value[0] == sw_if_index_from)
16653 sw_if_from_name = (u8 *)(p->key);
16657 if ((u32) p->value[0] == sw_if_index_to)
16659 sw_if_to_name = (u8 *)(p->key);
16660 if (sw_if_from_name)
16665 print (vam->ofp, "%20s => %20s (%s)",
16666 sw_if_from_name, sw_if_to_name, states[mp->state]);
16670 vl_api_sw_interface_span_details_t_handler_json
16671 (vl_api_sw_interface_span_details_t * mp)
16673 vat_main_t *vam = &vat_main;
16674 vat_json_node_t *node = NULL;
16675 u8 *sw_if_from_name = 0;
16676 u8 *sw_if_to_name = 0;
16677 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
16678 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
16682 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
16684 if ((u32) p->value[0] == sw_if_index_from)
16686 sw_if_from_name = (u8 *)(p->key);
16690 if ((u32) p->value[0] == sw_if_index_to)
16692 sw_if_to_name = (u8 *)(p->key);
16693 if (sw_if_from_name)
16699 if (VAT_JSON_ARRAY != vam->json_tree.type)
16701 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16702 vat_json_init_array (&vam->json_tree);
16704 node = vat_json_array_add (&vam->json_tree);
16706 vat_json_init_object (node);
16707 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
16708 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
16709 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
16710 if (0 != sw_if_to_name)
16712 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
16714 vat_json_object_add_uint (node, "state", mp->state);
16718 api_sw_interface_span_dump (vat_main_t * vam)
16720 vl_api_sw_interface_span_dump_t *mp;
16721 vl_api_control_ping_t *mp_ping;
16724 M (SW_INTERFACE_SPAN_DUMP, mp);
16727 /* Use a control ping for synchronization */
16728 M (CONTROL_PING, mp_ping);
16736 api_pg_create_interface (vat_main_t * vam)
16738 unformat_input_t *input = vam->input;
16739 vl_api_pg_create_interface_t *mp;
16743 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16745 if (unformat (input, "if_id %d", &if_id))
16752 errmsg ("missing pg interface index");
16756 /* Construct the API message */
16757 M (PG_CREATE_INTERFACE, mp);
16759 mp->interface_id = ntohl (if_id);
16767 api_pg_capture (vat_main_t * vam)
16769 unformat_input_t *input = vam->input;
16770 vl_api_pg_capture_t *mp;
16775 u8 pcap_file_set = 0;
16778 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16780 if (unformat (input, "if_id %d", &if_id))
16782 else if (unformat (input, "pcap %s", &pcap_file))
16784 else if (unformat (input, "count %d", &count))
16786 else if (unformat (input, "disable"))
16793 errmsg ("missing pg interface index");
16796 if (pcap_file_set > 0)
16798 if (vec_len (pcap_file) > 255)
16800 errmsg ("pcap file name is too long");
16805 u32 name_len = vec_len (pcap_file);
16806 /* Construct the API message */
16807 M (PG_CAPTURE, mp);
16809 mp->interface_id = ntohl (if_id);
16810 mp->is_enabled = enable;
16811 mp->count = ntohl (count);
16812 mp->pcap_name_length = ntohl (name_len);
16813 if (pcap_file_set != 0)
16815 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
16817 vec_free (pcap_file);
16825 api_pg_enable_disable (vat_main_t * vam)
16827 unformat_input_t *input = vam->input;
16828 vl_api_pg_enable_disable_t *mp;
16831 u8 stream_name_set = 0;
16832 u8 *stream_name = 0;
16834 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16836 if (unformat (input, "stream %s", &stream_name))
16837 stream_name_set = 1;
16838 else if (unformat (input, "disable"))
16844 if (stream_name_set > 0)
16846 if (vec_len (stream_name) > 255)
16848 errmsg ("stream name too long");
16853 u32 name_len = vec_len (stream_name);
16854 /* Construct the API message */
16855 M (PG_ENABLE_DISABLE, mp);
16857 mp->is_enabled = enable;
16858 if (stream_name_set != 0)
16860 mp->stream_name_length = ntohl (name_len);
16861 clib_memcpy (mp->stream_name, stream_name, name_len);
16863 vec_free (stream_name);
16871 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
16873 unformat_input_t *input = vam->input;
16874 vl_api_ip_source_and_port_range_check_add_del_t *mp;
16876 u16 *low_ports = 0;
16877 u16 *high_ports = 0;
16880 ip4_address_t ip4_addr;
16881 ip6_address_t ip6_addr;
16890 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16892 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
16898 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
16903 else if (unformat (input, "vrf %d", &vrf_id))
16905 else if (unformat (input, "del"))
16907 else if (unformat (input, "port %d", &tmp))
16909 if (tmp == 0 || tmp > 65535)
16911 errmsg ("port %d out of range", tmp);
16915 this_hi = this_low + 1;
16916 vec_add1 (low_ports, this_low);
16917 vec_add1 (high_ports, this_hi);
16919 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
16921 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
16923 errmsg ("incorrect range parameters");
16927 /* Note: in debug CLI +1 is added to high before
16928 passing to real fn that does "the work"
16929 (ip_source_and_port_range_check_add_del).
16930 This fn is a wrapper around the binary API fn a
16931 control plane will call, which expects this increment
16932 to have occurred. Hence letting the binary API control
16933 plane fn do the increment for consistency between VAT
16934 and other control planes.
16937 vec_add1 (low_ports, this_low);
16938 vec_add1 (high_ports, this_hi);
16944 if (prefix_set == 0)
16946 errmsg ("<address>/<mask> not specified");
16952 errmsg ("VRF ID required, not specified");
16959 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
16963 if (vec_len (low_ports) == 0)
16965 errmsg ("At least one port or port range required");
16969 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
16971 mp->is_add = is_add;
16976 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
16981 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
16984 mp->mask_length = length;
16985 mp->number_of_ranges = vec_len (low_ports);
16987 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
16988 vec_free (low_ports);
16990 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
16991 vec_free (high_ports);
16993 mp->vrf_id = ntohl (vrf_id);
17001 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
17003 unformat_input_t *input = vam->input;
17004 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
17005 u32 sw_if_index = ~0;
17007 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
17008 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
17012 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17014 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17016 else if (unformat (input, "sw_if_index %d", &sw_if_index))
17018 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
17020 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
17022 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
17024 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
17026 else if (unformat (input, "del"))
17032 if (sw_if_index == ~0)
17034 errmsg ("Interface required but not specified");
17040 errmsg ("VRF ID required but not specified");
17044 if (tcp_out_vrf_id == 0
17045 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
17048 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
17052 /* Construct the API message */
17053 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
17055 mp->sw_if_index = ntohl (sw_if_index);
17056 mp->is_add = is_add;
17057 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
17058 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
17059 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
17060 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
17065 /* Wait for a reply... */
17071 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
17073 unformat_input_t *i = vam->input;
17074 vl_api_ipsec_gre_add_del_tunnel_t *mp;
17075 u32 local_sa_id = 0;
17076 u32 remote_sa_id = 0;
17077 ip4_address_t src_address;
17078 ip4_address_t dst_address;
17082 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17084 if (unformat (i, "local_sa %d", &local_sa_id))
17086 else if (unformat (i, "remote_sa %d", &remote_sa_id))
17088 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
17090 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
17092 else if (unformat (i, "del"))
17096 clib_warning ("parse error '%U'", format_unformat_error, i);
17101 M (IPSEC_GRE_ADD_DEL_TUNNEL, mp);
17103 mp->local_sa_id = ntohl (local_sa_id);
17104 mp->remote_sa_id = ntohl (remote_sa_id);
17105 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
17106 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
17107 mp->is_add = is_add;
17115 api_punt (vat_main_t * vam)
17117 unformat_input_t *i = vam->input;
17125 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17127 if (unformat (i, "ip %d", &ipv))
17129 else if (unformat (i, "protocol %d", &protocol))
17131 else if (unformat (i, "port %d", &port))
17133 else if (unformat (i, "del"))
17137 clib_warning ("parse error '%U'", format_unformat_error, i);
17144 mp->is_add = (u8) is_add;
17145 mp->ipv = (u8) ipv;
17146 mp->l4_protocol = (u8) protocol;
17147 mp->l4_port = htons ((u16) port);
17154 static void vl_api_ipsec_gre_tunnel_details_t_handler
17155 (vl_api_ipsec_gre_tunnel_details_t * mp)
17157 vat_main_t *vam = &vat_main;
17159 print (vam->ofp, "%11d%15U%15U%14d%14d",
17160 ntohl (mp->sw_if_index),
17161 format_ip4_address, &mp->src_address,
17162 format_ip4_address, &mp->dst_address,
17163 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
17166 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
17167 (vl_api_ipsec_gre_tunnel_details_t * mp)
17169 vat_main_t *vam = &vat_main;
17170 vat_json_node_t *node = NULL;
17171 struct in_addr ip4;
17173 if (VAT_JSON_ARRAY != vam->json_tree.type)
17175 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17176 vat_json_init_array (&vam->json_tree);
17178 node = vat_json_array_add (&vam->json_tree);
17180 vat_json_init_object (node);
17181 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
17182 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
17183 vat_json_object_add_ip4 (node, "src_address", ip4);
17184 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
17185 vat_json_object_add_ip4 (node, "dst_address", ip4);
17186 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
17187 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
17191 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
17193 unformat_input_t *i = vam->input;
17194 vl_api_ipsec_gre_tunnel_dump_t *mp;
17195 vl_api_control_ping_t *mp_ping;
17197 u8 sw_if_index_set = 0;
17200 /* Parse args required to build the message */
17201 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17203 if (unformat (i, "sw_if_index %d", &sw_if_index))
17204 sw_if_index_set = 1;
17209 if (sw_if_index_set == 0)
17214 if (!vam->json_output)
17216 print (vam->ofp, "%11s%15s%15s%14s%14s",
17217 "sw_if_index", "src_address", "dst_address",
17218 "local_sa_id", "remote_sa_id");
17221 /* Get list of gre-tunnel interfaces */
17222 M (IPSEC_GRE_TUNNEL_DUMP, mp);
17224 mp->sw_if_index = htonl (sw_if_index);
17228 /* Use a control ping for synchronization */
17229 M (CONTROL_PING, mp_ping);
17237 api_delete_subif (vat_main_t * vam)
17239 unformat_input_t *i = vam->input;
17240 vl_api_delete_subif_t *mp;
17241 u32 sw_if_index = ~0;
17244 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17246 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17248 if (unformat (i, "sw_if_index %d", &sw_if_index))
17254 if (sw_if_index == ~0)
17256 errmsg ("missing sw_if_index");
17260 /* Construct the API message */
17261 M (DELETE_SUBIF, mp);
17262 mp->sw_if_index = ntohl (sw_if_index);
17269 #define foreach_pbb_vtr_op \
17270 _("disable", L2_VTR_DISABLED) \
17271 _("pop", L2_VTR_POP_2) \
17272 _("push", L2_VTR_PUSH_2)
17275 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
17277 unformat_input_t *i = vam->input;
17278 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
17279 u32 sw_if_index = ~0, vtr_op = ~0;
17280 u16 outer_tag = ~0;
17281 u8 dmac[6], smac[6];
17282 u8 dmac_set = 0, smac_set = 0;
17288 /* Shut up coverity */
17289 memset (dmac, 0, sizeof (dmac));
17290 memset (smac, 0, sizeof (smac));
17292 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17294 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17296 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17298 else if (unformat (i, "vtr_op %d", &vtr_op))
17300 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
17303 else if (unformat (i, "translate_pbb_stag"))
17305 if (unformat (i, "%d", &tmp))
17307 vtr_op = L2_VTR_TRANSLATE_2_1;
17313 ("translate_pbb_stag operation requires outer tag definition");
17317 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
17319 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
17321 else if (unformat (i, "sid %d", &sid))
17323 else if (unformat (i, "vlanid %d", &tmp))
17327 clib_warning ("parse error '%U'", format_unformat_error, i);
17332 if ((sw_if_index == ~0) || (vtr_op == ~0))
17334 errmsg ("missing sw_if_index or vtr operation");
17337 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
17338 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
17341 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
17345 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
17346 mp->sw_if_index = ntohl (sw_if_index);
17347 mp->vtr_op = ntohl (vtr_op);
17348 mp->outer_tag = ntohs (outer_tag);
17349 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
17350 clib_memcpy (mp->b_smac, smac, sizeof (smac));
17351 mp->b_vlanid = ntohs (vlanid);
17352 mp->i_sid = ntohl (sid);
17360 api_flow_classify_set_interface (vat_main_t * vam)
17362 unformat_input_t *i = vam->input;
17363 vl_api_flow_classify_set_interface_t *mp;
17365 int sw_if_index_set;
17366 u32 ip4_table_index = ~0;
17367 u32 ip6_table_index = ~0;
17371 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17373 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17374 sw_if_index_set = 1;
17375 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17376 sw_if_index_set = 1;
17377 else if (unformat (i, "del"))
17379 else if (unformat (i, "ip4-table %d", &ip4_table_index))
17381 else if (unformat (i, "ip6-table %d", &ip6_table_index))
17385 clib_warning ("parse error '%U'", format_unformat_error, i);
17390 if (sw_if_index_set == 0)
17392 errmsg ("missing interface name or sw_if_index");
17396 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
17398 mp->sw_if_index = ntohl (sw_if_index);
17399 mp->ip4_table_index = ntohl (ip4_table_index);
17400 mp->ip6_table_index = ntohl (ip6_table_index);
17401 mp->is_add = is_add;
17409 api_flow_classify_dump (vat_main_t * vam)
17411 unformat_input_t *i = vam->input;
17412 vl_api_flow_classify_dump_t *mp;
17413 vl_api_control_ping_t *mp_ping;
17414 u8 type = FLOW_CLASSIFY_N_TABLES;
17417 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
17421 errmsg ("classify table type must be specified");
17425 if (!vam->json_output)
17427 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
17430 M (FLOW_CLASSIFY_DUMP, mp);
17435 /* Use a control ping for synchronization */
17436 M (CONTROL_PING, mp_ping);
17439 /* Wait for a reply... */
17445 api_feature_enable_disable (vat_main_t * vam)
17447 unformat_input_t *i = vam->input;
17448 vl_api_feature_enable_disable_t *mp;
17450 u8 *feature_name = 0;
17451 u32 sw_if_index = ~0;
17455 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17457 if (unformat (i, "arc_name %s", &arc_name))
17459 else if (unformat (i, "feature_name %s", &feature_name))
17462 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17464 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17466 else if (unformat (i, "disable"))
17474 errmsg ("missing arc name");
17477 if (vec_len (arc_name) > 63)
17479 errmsg ("arc name too long");
17482 if (feature_name == 0)
17484 errmsg ("missing feature name");
17487 if (vec_len (feature_name) > 63)
17489 errmsg ("feature name too long");
17492 if (sw_if_index == ~0)
17494 errmsg ("missing interface name or sw_if_index");
17498 /* Construct the API message */
17499 M (FEATURE_ENABLE_DISABLE, mp);
17500 mp->sw_if_index = ntohl (sw_if_index);
17501 mp->enable = enable;
17502 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
17503 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
17504 vec_free (arc_name);
17505 vec_free (feature_name);
17513 api_sw_interface_tag_add_del (vat_main_t * vam)
17515 unformat_input_t *i = vam->input;
17516 vl_api_sw_interface_tag_add_del_t *mp;
17517 u32 sw_if_index = ~0;
17522 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17524 if (unformat (i, "tag %s", &tag))
17526 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17528 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17530 else if (unformat (i, "del"))
17536 if (sw_if_index == ~0)
17538 errmsg ("missing interface name or sw_if_index");
17542 if (enable && (tag == 0))
17544 errmsg ("no tag specified");
17548 /* Construct the API message */
17549 M (SW_INTERFACE_TAG_ADD_DEL, mp);
17550 mp->sw_if_index = ntohl (sw_if_index);
17551 mp->is_add = enable;
17553 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
17561 static void vl_api_l2_xconnect_details_t_handler
17562 (vl_api_l2_xconnect_details_t * mp)
17564 vat_main_t *vam = &vat_main;
17566 print (vam->ofp, "%15d%15d",
17567 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
17570 static void vl_api_l2_xconnect_details_t_handler_json
17571 (vl_api_l2_xconnect_details_t * mp)
17573 vat_main_t *vam = &vat_main;
17574 vat_json_node_t *node = NULL;
17576 if (VAT_JSON_ARRAY != vam->json_tree.type)
17578 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17579 vat_json_init_array (&vam->json_tree);
17581 node = vat_json_array_add (&vam->json_tree);
17583 vat_json_init_object (node);
17584 vat_json_object_add_uint (node, "rx_sw_if_index",
17585 ntohl (mp->rx_sw_if_index));
17586 vat_json_object_add_uint (node, "tx_sw_if_index",
17587 ntohl (mp->tx_sw_if_index));
17591 api_l2_xconnect_dump (vat_main_t * vam)
17593 vl_api_l2_xconnect_dump_t *mp;
17594 vl_api_control_ping_t *mp_ping;
17597 if (!vam->json_output)
17599 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
17602 M (L2_XCONNECT_DUMP, mp);
17606 /* Use a control ping for synchronization */
17607 M (CONTROL_PING, mp_ping);
17615 api_sw_interface_set_mtu (vat_main_t * vam)
17617 unformat_input_t *i = vam->input;
17618 vl_api_sw_interface_set_mtu_t *mp;
17619 u32 sw_if_index = ~0;
17623 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17625 if (unformat (i, "mtu %d", &mtu))
17627 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17629 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17635 if (sw_if_index == ~0)
17637 errmsg ("missing interface name or sw_if_index");
17643 errmsg ("no mtu specified");
17647 /* Construct the API message */
17648 M (SW_INTERFACE_SET_MTU, mp);
17649 mp->sw_if_index = ntohl (sw_if_index);
17650 mp->mtu = ntohs ((u16) mtu);
17659 q_or_quit (vat_main_t * vam)
17661 #if VPP_API_TEST_BUILTIN == 0
17662 longjmp (vam->jump_buf, 1);
17664 return 0; /* not so much */
17668 q (vat_main_t * vam)
17670 return q_or_quit (vam);
17674 quit (vat_main_t * vam)
17676 return q_or_quit (vam);
17680 comment (vat_main_t * vam)
17686 cmd_cmp (void *a1, void *a2)
17691 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
17695 help (vat_main_t * vam)
17700 unformat_input_t *i = vam->input;
17703 if (unformat (i, "%s", &name))
17707 vec_add1 (name, 0);
17709 hs = hash_get_mem (vam->help_by_name, name);
17711 print (vam->ofp, "usage: %s %s", name, hs[0]);
17713 print (vam->ofp, "No such msg / command '%s'", name);
17718 print (vam->ofp, "Help is available for the following:");
17721 hash_foreach_pair (p, vam->function_by_name,
17723 vec_add1 (cmds, (u8 *)(p->key));
17727 vec_sort_with_function (cmds, cmd_cmp);
17729 for (j = 0; j < vec_len (cmds); j++)
17730 print (vam->ofp, "%s", cmds[j]);
17737 set (vat_main_t * vam)
17739 u8 *name = 0, *value = 0;
17740 unformat_input_t *i = vam->input;
17742 if (unformat (i, "%s", &name))
17744 /* The input buffer is a vector, not a string. */
17745 value = vec_dup (i->buffer);
17746 vec_delete (value, i->index, 0);
17747 /* Almost certainly has a trailing newline */
17748 if (value[vec_len (value) - 1] == '\n')
17749 value[vec_len (value) - 1] = 0;
17750 /* Make sure it's a proper string, one way or the other */
17751 vec_add1 (value, 0);
17752 (void) clib_macro_set_value (&vam->macro_main,
17753 (char *) name, (char *) value);
17756 errmsg ("usage: set <name> <value>");
17764 unset (vat_main_t * vam)
17768 if (unformat (vam->input, "%s", &name))
17769 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
17770 errmsg ("unset: %s wasn't set", name);
17783 macro_sort_cmp (void *a1, void *a2)
17785 macro_sort_t *s1 = a1;
17786 macro_sort_t *s2 = a2;
17788 return strcmp ((char *) (s1->name), (char *) (s2->name));
17792 dump_macro_table (vat_main_t * vam)
17794 macro_sort_t *sort_me = 0, *sm;
17799 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
17801 vec_add2 (sort_me, sm, 1);
17802 sm->name = (u8 *)(p->key);
17803 sm->value = (u8 *) (p->value[0]);
17807 vec_sort_with_function (sort_me, macro_sort_cmp);
17809 if (vec_len (sort_me))
17810 print (vam->ofp, "%-15s%s", "Name", "Value");
17812 print (vam->ofp, "The macro table is empty...");
17814 for (i = 0; i < vec_len (sort_me); i++)
17815 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
17820 dump_node_table (vat_main_t * vam)
17823 vlib_node_t *node, *next_node;
17825 if (vec_len (vam->graph_nodes) == 0)
17827 print (vam->ofp, "Node table empty, issue get_node_graph...");
17831 for (i = 0; i < vec_len (vam->graph_nodes); i++)
17833 node = vam->graph_nodes[i];
17834 print (vam->ofp, "[%d] %s", i, node->name);
17835 for (j = 0; j < vec_len (node->next_nodes); j++)
17837 if (node->next_nodes[j] != ~0)
17839 next_node = vam->graph_nodes[node->next_nodes[j]];
17840 print (vam->ofp, " [%d] %s", j, next_node->name);
17848 value_sort_cmp (void *a1, void *a2)
17850 name_sort_t *n1 = a1;
17851 name_sort_t *n2 = a2;
17853 if (n1->value < n2->value)
17855 if (n1->value > n2->value)
17862 dump_msg_api_table (vat_main_t * vam)
17864 api_main_t *am = &api_main;
17865 name_sort_t *nses = 0, *ns;
17870 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
17872 vec_add2 (nses, ns, 1);
17873 ns->name = (u8 *)(hp->key);
17874 ns->value = (u32) hp->value[0];
17878 vec_sort_with_function (nses, value_sort_cmp);
17880 for (i = 0; i < vec_len (nses); i++)
17881 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
17887 get_msg_id (vat_main_t * vam)
17892 if (unformat (vam->input, "%s", &name_and_crc))
17894 message_index = vl_api_get_msg_index (name_and_crc);
17895 if (message_index == ~0)
17897 print (vam->ofp, " '%s' not found", name_and_crc);
17900 print (vam->ofp, " '%s' has message index %d",
17901 name_and_crc, message_index);
17904 errmsg ("name_and_crc required...");
17909 search_node_table (vat_main_t * vam)
17911 unformat_input_t *line_input = vam->input;
17914 vlib_node_t *node, *next_node;
17917 if (vam->graph_node_index_by_name == 0)
17919 print (vam->ofp, "Node table empty, issue get_node_graph...");
17923 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
17925 if (unformat (line_input, "%s", &node_to_find))
17927 vec_add1 (node_to_find, 0);
17928 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
17931 print (vam->ofp, "%s not found...", node_to_find);
17934 node = vam->graph_nodes[p[0]];
17935 print (vam->ofp, "[%d] %s", p[0], node->name);
17936 for (j = 0; j < vec_len (node->next_nodes); j++)
17938 if (node->next_nodes[j] != ~0)
17940 next_node = vam->graph_nodes[node->next_nodes[j]];
17941 print (vam->ofp, " [%d] %s", j, next_node->name);
17948 clib_warning ("parse error '%U'", format_unformat_error,
17954 vec_free (node_to_find);
17963 script (vat_main_t * vam)
17965 #if (VPP_API_TEST_BUILTIN==0)
17967 char *save_current_file;
17968 unformat_input_t save_input;
17969 jmp_buf save_jump_buf;
17970 u32 save_line_number;
17972 FILE *new_fp, *save_ifp;
17974 if (unformat (vam->input, "%s", &s))
17976 new_fp = fopen ((char *) s, "r");
17979 errmsg ("Couldn't open script file %s", s);
17986 errmsg ("Missing script name");
17990 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
17991 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
17992 save_ifp = vam->ifp;
17993 save_line_number = vam->input_line_number;
17994 save_current_file = (char *) vam->current_file;
17996 vam->input_line_number = 0;
17998 vam->current_file = s;
18001 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
18002 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
18003 vam->ifp = save_ifp;
18004 vam->input_line_number = save_line_number;
18005 vam->current_file = (u8 *) save_current_file;
18010 clib_warning ("use the exec command...");
18016 echo (vat_main_t * vam)
18018 print (vam->ofp, "%v", vam->input->buffer);
18022 /* List of API message constructors, CLI names map to api_xxx */
18023 #define foreach_vpe_api_msg \
18024 _(create_loopback,"[mac <mac-addr>]") \
18025 _(sw_interface_dump,"") \
18026 _(sw_interface_set_flags, \
18027 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
18028 _(sw_interface_add_del_address, \
18029 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
18030 _(sw_interface_set_table, \
18031 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
18032 _(sw_interface_set_mpls_enable, \
18033 "<intfc> | sw_if_index [disable | dis]") \
18034 _(sw_interface_set_vpath, \
18035 "<intfc> | sw_if_index <id> enable | disable") \
18036 _(sw_interface_set_vxlan_bypass, \
18037 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
18038 _(sw_interface_set_l2_xconnect, \
18039 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
18040 "enable | disable") \
18041 _(sw_interface_set_l2_bridge, \
18042 "<intfc> | sw_if_index <id> bd_id <bridge-domain-id>\n" \
18043 "[shg <split-horizon-group>] [bvi]\n" \
18044 "enable | disable") \
18045 _(bridge_domain_add_del, \
18046 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n") \
18047 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
18049 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
18051 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
18053 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
18055 "tapname <name> mac <mac-addr> | random-mac [tag <string>]") \
18057 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
18059 "<vpp-if-name> | sw_if_index <id>") \
18060 _(sw_interface_tap_dump, "") \
18061 _(ip_add_del_route, \
18062 "<addr>/<mask> via <addr> [table-id <n>]\n" \
18063 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
18064 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
18065 "[multipath] [count <n>]") \
18066 _(ip_mroute_add_del, \
18067 "<src> <grp>/<mask> [table-id <n>]\n" \
18068 "[<intfc> | sw_if_index <id>] [local] [del]") \
18069 _(mpls_route_add_del, \
18070 "<label> <eos> via <addr> [table-id <n>]\n" \
18071 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
18072 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
18073 "[multipath] [count <n>]") \
18074 _(mpls_ip_bind_unbind, \
18075 "<label> <addr/len>") \
18076 _(mpls_tunnel_add_del, \
18077 " via <addr> [table-id <n>]\n" \
18078 "sw_if_index <id>] [l2] [del]") \
18079 _(proxy_arp_add_del, \
18080 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
18081 _(proxy_arp_intfc_enable_disable, \
18082 "<intfc> | sw_if_index <id> enable | disable") \
18083 _(sw_interface_set_unnumbered, \
18084 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
18085 _(ip_neighbor_add_del, \
18086 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
18087 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
18088 _(reset_vrf, "vrf <id> [ipv6]") \
18089 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
18090 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
18091 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
18092 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
18093 "[outer_vlan_id_any][inner_vlan_id_any]") \
18094 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
18095 _(reset_fib, "vrf <n> [ipv6]") \
18096 _(dhcp_proxy_config, \
18097 "svr <v46-address> src <v46-address>\n" \
18098 "rx_vrf_id <nn> server_vrf_id <nn> [del]") \
18099 _(dhcp_proxy_set_vss, \
18100 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
18101 _(dhcp_proxy_dump, "ip6") \
18102 _(dhcp_client_config, \
18103 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
18104 _(set_ip_flow_hash, \
18105 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
18106 _(sw_interface_ip6_enable_disable, \
18107 "<intfc> | sw_if_index <id> enable | disable") \
18108 _(sw_interface_ip6_set_link_local_address, \
18109 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
18110 _(sw_interface_ip6nd_ra_prefix, \
18111 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
18112 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
18113 "[nolink] [isno]") \
18114 _(sw_interface_ip6nd_ra_config, \
18115 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
18116 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
18117 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
18118 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
18119 _(l2_patch_add_del, \
18120 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
18121 "enable | disable") \
18122 _(sr_tunnel_add_del, \
18123 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
18124 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
18125 "[policy <policy_name>]") \
18126 _(sr_policy_add_del, \
18127 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
18128 _(sr_multicast_map_add_del, \
18129 "address [ip6 multicast address] sr-policy [policy name] [del]") \
18130 _(classify_add_del_table, \
18131 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
18132 " [del] [del-chain] mask <mask-value>\n" \
18133 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
18134 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
18135 _(classify_add_del_session, \
18136 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
18137 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
18138 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
18139 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
18140 _(classify_set_interface_ip_table, \
18141 "<intfc> | sw_if_index <nn> table <nn>") \
18142 _(classify_set_interface_l2_tables, \
18143 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
18144 " [other-table <nn>]") \
18145 _(get_node_index, "node <node-name") \
18146 _(add_node_next, "node <node-name> next <next-node-name>") \
18147 _(l2tpv3_create_tunnel, \
18148 "client_address <ip6-addr> our_address <ip6-addr>\n" \
18149 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
18150 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
18151 _(l2tpv3_set_tunnel_cookies, \
18152 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
18153 "[new_remote_cookie <nn>]\n") \
18154 _(l2tpv3_interface_enable_disable, \
18155 "<intfc> | sw_if_index <nn> enable | disable") \
18156 _(l2tpv3_set_lookup_key, \
18157 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
18158 _(sw_if_l2tpv3_tunnel_dump, "") \
18159 _(vxlan_add_del_tunnel, \
18160 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
18161 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
18162 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
18163 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
18164 _(gre_add_del_tunnel, \
18165 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [teb] [del]\n") \
18166 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
18167 _(l2_fib_clear_table, "") \
18168 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
18169 _(l2_interface_vlan_tag_rewrite, \
18170 "<intfc> | sw_if_index <nn> \n" \
18171 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
18172 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
18173 _(create_vhost_user_if, \
18174 "socket <filename> [server] [renumber <dev_instance>] " \
18175 "[mac <mac_address>]") \
18176 _(modify_vhost_user_if, \
18177 "<intfc> | sw_if_index <nn> socket <filename>\n" \
18178 "[server] [renumber <dev_instance>]") \
18179 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
18180 _(sw_interface_vhost_user_dump, "") \
18181 _(show_version, "") \
18182 _(vxlan_gpe_add_del_tunnel, \
18183 "local <addr> remote <addr> vni <nn>\n" \
18184 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
18185 "[next-ethernet] [next-nsh]\n") \
18186 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
18187 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
18188 _(interface_name_renumber, \
18189 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
18190 _(input_acl_set_interface, \
18191 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
18192 " [l2-table <nn>] [del]") \
18193 _(want_ip4_arp_events, "address <ip4-address> [del]") \
18194 _(want_ip6_nd_events, "address <ip6-address> [del]") \
18195 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
18196 _(ip_dump, "ipv4 | ipv6") \
18197 _(ipsec_spd_add_del, "spd_id <n> [del]") \
18198 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
18200 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
18201 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
18202 " integ_alg <alg> integ_key <hex>") \
18203 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
18204 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
18205 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
18206 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
18207 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
18208 _(ikev2_profile_add_del, "name <profile_name> [del]") \
18209 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
18210 "(auth_data 0x<data> | auth_data <data>)") \
18211 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
18212 "(id_data 0x<data> | id_data <data>) (local|remote)") \
18213 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
18214 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
18215 "(local|remote)") \
18216 _(ikev2_set_local_key, "file <absolute_file_path>") \
18217 _(ikev2_set_responder, "<profile_name> interface <interface> address <addr>") \
18218 _(ikev2_set_ike_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
18219 _(ikev2_set_esp_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
18220 _(ikev2_set_sa_lifetime, "<profile_name> <seconds> <jitter> <handover> <max bytes>") \
18221 _(ikev2_initiate_sa_init, "<profile_name>") \
18222 _(ikev2_initiate_del_ike_sa, "<ispi>") \
18223 _(ikev2_initiate_del_child_sa, "<ispi>") \
18224 _(ikev2_initiate_rekey_child_sa, "<ispi>") \
18225 _(delete_loopback,"sw_if_index <nn>") \
18226 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
18227 _(map_add_domain, \
18228 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
18229 "ip6-src <ip6addr> " \
18230 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
18231 _(map_del_domain, "index <n>") \
18232 _(map_add_del_rule, \
18233 "index <n> psid <n> dst <ip6addr> [del]") \
18234 _(map_domain_dump, "") \
18235 _(map_rule_dump, "index <map-domain>") \
18236 _(want_interface_events, "enable|disable") \
18237 _(want_stats,"enable|disable") \
18238 _(get_first_msg_id, "client <name>") \
18239 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
18240 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
18241 "fib-id <nn> [ip4][ip6][default]") \
18242 _(get_node_graph, " ") \
18243 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
18244 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
18245 _(ioam_disable, "") \
18246 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
18247 " sw_if_index <sw_if_index> p <priority> " \
18248 "w <weight>] [del]") \
18249 _(one_add_del_locator, "locator-set <locator_name> " \
18250 "iface <intf> | sw_if_index <sw_if_index> " \
18251 "p <priority> w <weight> [del]") \
18252 _(one_add_del_local_eid,"vni <vni> eid " \
18253 "<ipv4|ipv6>/<prefix> | <L2 address> " \
18254 "locator-set <locator_name> [del]" \
18255 "[key-id sha1|sha256 secret-key <secret-key>]")\
18256 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
18257 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
18258 _(one_enable_disable, "enable|disable") \
18259 _(one_map_register_enable_disable, "enable|disable") \
18260 _(one_rloc_probe_enable_disable, "enable|disable") \
18261 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
18263 "rloc <locator> p <prio> " \
18264 "w <weight> [rloc <loc> ... ] " \
18265 "action <action> [del-all]") \
18266 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
18268 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
18269 _(one_map_request_mode, "src-dst|dst-only") \
18270 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
18271 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
18272 _(one_locator_set_dump, "[local | remote]") \
18273 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
18274 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
18275 "[local] | [remote]") \
18276 _(one_eid_table_vni_dump, "") \
18277 _(one_eid_table_map_dump, "l2|l3") \
18278 _(one_map_resolver_dump, "") \
18279 _(one_map_server_dump, "") \
18280 _(one_adjacencies_get, "vni <vni>") \
18281 _(show_one_rloc_probe_state, "") \
18282 _(show_one_map_register_state, "") \
18283 _(show_one_status, "") \
18284 _(one_get_map_request_itr_rlocs, "") \
18285 _(show_one_pitr, "") \
18286 _(show_one_map_request_mode, "") \
18287 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
18288 " sw_if_index <sw_if_index> p <priority> " \
18289 "w <weight>] [del]") \
18290 _(lisp_add_del_locator, "locator-set <locator_name> " \
18291 "iface <intf> | sw_if_index <sw_if_index> " \
18292 "p <priority> w <weight> [del]") \
18293 _(lisp_add_del_local_eid,"vni <vni> eid " \
18294 "<ipv4|ipv6>/<prefix> | <L2 address> " \
18295 "locator-set <locator_name> [del]" \
18296 "[key-id sha1|sha256 secret-key <secret-key>]") \
18297 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
18298 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
18299 _(lisp_enable_disable, "enable|disable") \
18300 _(lisp_map_register_enable_disable, "enable|disable") \
18301 _(lisp_rloc_probe_enable_disable, "enable|disable") \
18302 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
18304 "rloc <locator> p <prio> " \
18305 "w <weight> [rloc <loc> ... ] " \
18306 "action <action> [del-all]") \
18307 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
18309 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
18310 _(lisp_map_request_mode, "src-dst|dst-only") \
18311 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
18312 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
18313 _(lisp_locator_set_dump, "[local | remote]") \
18314 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
18315 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
18316 "[local] | [remote]") \
18317 _(lisp_eid_table_vni_dump, "") \
18318 _(lisp_eid_table_map_dump, "l2|l3") \
18319 _(lisp_map_resolver_dump, "") \
18320 _(lisp_map_server_dump, "") \
18321 _(lisp_adjacencies_get, "vni <vni>") \
18322 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
18323 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
18324 _(gpe_set_encap_mode, "lisp|vxlan") \
18325 _(gpe_get_encap_mode, "") \
18326 _(lisp_gpe_add_del_iface, "up|down") \
18327 _(lisp_gpe_enable_disable, "enable|disable") \
18328 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
18329 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
18330 _(show_lisp_rloc_probe_state, "") \
18331 _(show_lisp_map_register_state, "") \
18332 _(show_lisp_status, "") \
18333 _(lisp_get_map_request_itr_rlocs, "") \
18334 _(show_lisp_pitr, "") \
18335 _(show_lisp_map_request_mode, "") \
18336 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
18337 _(af_packet_delete, "name <host interface name>") \
18338 _(policer_add_del, "name <policer name> <params> [del]") \
18339 _(policer_dump, "[name <policer name>]") \
18340 _(policer_classify_set_interface, \
18341 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
18342 " [l2-table <nn>] [del]") \
18343 _(policer_classify_dump, "type [ip4|ip6|l2]") \
18344 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
18345 "[master|slave]") \
18346 _(netmap_delete, "name <interface name>") \
18347 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
18348 _(mpls_fib_dump, "") \
18349 _(classify_table_ids, "") \
18350 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
18351 _(classify_table_info, "table_id <nn>") \
18352 _(classify_session_dump, "table_id <nn>") \
18353 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
18354 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
18355 "[template_interval <nn>] [udp_checksum]") \
18356 _(ipfix_exporter_dump, "") \
18357 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
18358 _(ipfix_classify_stream_dump, "") \
18359 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
18360 _(ipfix_classify_table_dump, "") \
18361 _(sw_interface_span_enable_disable, "[src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
18362 _(sw_interface_span_dump, "") \
18363 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
18364 _(pg_create_interface, "if_id <nn>") \
18365 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
18366 _(pg_enable_disable, "[stream <id>] disable") \
18367 _(ip_source_and_port_range_check_add_del, \
18368 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
18369 _(ip_source_and_port_range_check_interface_add_del, \
18370 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
18371 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
18372 _(ipsec_gre_add_del_tunnel, \
18373 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
18374 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
18375 _(delete_subif,"<intfc> | sw_if_index <nn>") \
18376 _(l2_interface_pbb_tag_rewrite, \
18377 "<intfc> | sw_if_index <nn> \n" \
18378 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
18379 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
18380 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
18381 _(flow_classify_set_interface, \
18382 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
18383 _(flow_classify_dump, "type [ip4|ip6]") \
18384 _(ip_fib_dump, "") \
18385 _(ip_mfib_dump, "") \
18386 _(ip6_fib_dump, "") \
18387 _(ip6_mfib_dump, "") \
18388 _(feature_enable_disable, "arc_name <arc_name> " \
18389 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
18390 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
18392 _(l2_xconnect_dump, "") \
18393 _(sw_interface_set_mtu, "<intfc> | sw_if_index <nn> mtu <nn>") \
18394 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
18395 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]")
18397 /* List of command functions, CLI names map directly to functions */
18398 #define foreach_cli_function \
18399 _(comment, "usage: comment <ignore-rest-of-line>") \
18400 _(dump_interface_table, "usage: dump_interface_table") \
18401 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
18402 _(dump_ipv4_table, "usage: dump_ipv4_table") \
18403 _(dump_ipv6_table, "usage: dump_ipv6_table") \
18404 _(dump_stats_table, "usage: dump_stats_table") \
18405 _(dump_macro_table, "usage: dump_macro_table ") \
18406 _(dump_node_table, "usage: dump_node_table") \
18407 _(dump_msg_api_table, "usage: dump_msg_api_table") \
18408 _(get_msg_id, "usage: get_msg_id name_and_crc") \
18409 _(echo, "usage: echo <message>") \
18410 _(exec, "usage: exec <vpe-debug-CLI-command>") \
18411 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
18412 _(help, "usage: help") \
18413 _(q, "usage: quit") \
18414 _(quit, "usage: quit") \
18415 _(search_node_table, "usage: search_node_table <name>...") \
18416 _(set, "usage: set <variable-name> <value>") \
18417 _(script, "usage: script <file-name>") \
18418 _(unset, "usage: unset <variable-name>")
18421 static void vl_api_##n##_t_handler_uni \
18422 (vl_api_##n##_t * mp) \
18424 vat_main_t * vam = &vat_main; \
18425 if (vam->json_output) { \
18426 vl_api_##n##_t_handler_json(mp); \
18428 vl_api_##n##_t_handler(mp); \
18431 foreach_vpe_api_reply_msg;
18432 #if VPP_API_TEST_BUILTIN == 0
18433 foreach_standalone_reply_msg;
18438 vat_api_hookup (vat_main_t * vam)
18441 vl_msg_api_set_handlers(VL_API_##N, #n, \
18442 vl_api_##n##_t_handler_uni, \
18444 vl_api_##n##_t_endian, \
18445 vl_api_##n##_t_print, \
18446 sizeof(vl_api_##n##_t), 1);
18447 foreach_vpe_api_reply_msg;
18448 #if VPP_API_TEST_BUILTIN == 0
18449 foreach_standalone_reply_msg;
18453 #if (VPP_API_TEST_BUILTIN==0)
18454 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
18457 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
18459 vam->function_by_name = hash_create_string (0, sizeof (uword));
18461 vam->help_by_name = hash_create_string (0, sizeof (uword));
18463 /* API messages we can send */
18464 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
18465 foreach_vpe_api_msg;
18469 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
18470 foreach_vpe_api_msg;
18473 /* CLI functions */
18474 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
18475 foreach_cli_function;
18479 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
18480 foreach_cli_function;
18484 #if VPP_API_TEST_BUILTIN
18485 static clib_error_t *
18486 vat_api_hookup_shim (vlib_main_t * vm)
18488 vat_api_hookup (&vat_main);
18492 VLIB_API_INIT_FUNCTION (vat_api_hookup_shim);
18496 * fd.io coding-style-patch-verification: ON
18499 * eval: (c-set-style "gnu")