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 static void vl_api_sw_interface_set_flags_t_handler
948 (vl_api_sw_interface_set_flags_t * mp)
950 vat_main_t *vam = &vat_main;
951 if (vam->interface_event_display)
952 errmsg ("interface flags: sw_if_index %d %s %s",
953 ntohl (mp->sw_if_index),
954 mp->admin_up_down ? "admin-up" : "admin-down",
955 mp->link_up_down ? "link-up" : "link-down");
958 static void vl_api_sw_interface_set_flags_t_handler_json
959 (vl_api_sw_interface_set_flags_t * mp)
961 /* JSON output not supported */
965 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
967 vat_main_t *vam = &vat_main;
968 i32 retval = ntohl (mp->retval);
970 vam->retval = retval;
971 vam->shmem_result = (u8 *) mp->reply_in_shmem;
972 vam->result_ready = 1;
976 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
978 vat_main_t *vam = &vat_main;
979 vat_json_node_t node;
980 api_main_t *am = &api_main;
984 vat_json_init_object (&node);
985 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
986 vat_json_object_add_uint (&node, "reply_in_shmem",
987 ntohl (mp->reply_in_shmem));
988 /* Toss the shared-memory original... */
989 pthread_mutex_lock (&am->vlib_rp->mutex);
990 oldheap = svm_push_data_heap (am->vlib_rp);
992 reply = (u8 *) (mp->reply_in_shmem);
995 svm_pop_heap (oldheap);
996 pthread_mutex_unlock (&am->vlib_rp->mutex);
998 vat_json_print (vam->ofp, &node);
999 vat_json_free (&node);
1001 vam->retval = ntohl (mp->retval);
1002 vam->result_ready = 1;
1006 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
1008 vat_main_t *vam = &vat_main;
1009 i32 retval = ntohl (mp->retval);
1011 vam->retval = retval;
1012 vam->cmd_reply = mp->reply;
1013 vam->result_ready = 1;
1017 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
1019 vat_main_t *vam = &vat_main;
1020 vat_json_node_t node;
1022 vat_json_init_object (&node);
1023 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1024 vat_json_object_add_string_copy (&node, "reply", mp->reply);
1026 vat_json_print (vam->ofp, &node);
1027 vat_json_free (&node);
1029 vam->retval = ntohl (mp->retval);
1030 vam->result_ready = 1;
1033 static void vl_api_classify_add_del_table_reply_t_handler
1034 (vl_api_classify_add_del_table_reply_t * mp)
1036 vat_main_t *vam = &vat_main;
1037 i32 retval = ntohl (mp->retval);
1038 if (vam->async_mode)
1040 vam->async_errors += (retval < 0);
1044 vam->retval = retval;
1046 ((mp->new_table_index != 0xFFFFFFFF) ||
1047 (mp->skip_n_vectors != 0xFFFFFFFF) ||
1048 (mp->match_n_vectors != 0xFFFFFFFF)))
1050 * Note: this is just barely thread-safe, depends on
1051 * the main thread spinning waiting for an answer...
1053 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d",
1054 ntohl (mp->new_table_index),
1055 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
1056 vam->result_ready = 1;
1060 static void vl_api_classify_add_del_table_reply_t_handler_json
1061 (vl_api_classify_add_del_table_reply_t * mp)
1063 vat_main_t *vam = &vat_main;
1064 vat_json_node_t node;
1066 vat_json_init_object (&node);
1067 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1068 vat_json_object_add_uint (&node, "new_table_index",
1069 ntohl (mp->new_table_index));
1070 vat_json_object_add_uint (&node, "skip_n_vectors",
1071 ntohl (mp->skip_n_vectors));
1072 vat_json_object_add_uint (&node, "match_n_vectors",
1073 ntohl (mp->match_n_vectors));
1075 vat_json_print (vam->ofp, &node);
1076 vat_json_free (&node);
1078 vam->retval = ntohl (mp->retval);
1079 vam->result_ready = 1;
1082 static void vl_api_get_node_index_reply_t_handler
1083 (vl_api_get_node_index_reply_t * mp)
1085 vat_main_t *vam = &vat_main;
1086 i32 retval = ntohl (mp->retval);
1087 if (vam->async_mode)
1089 vam->async_errors += (retval < 0);
1093 vam->retval = retval;
1095 errmsg ("node index %d", ntohl (mp->node_index));
1096 vam->result_ready = 1;
1100 static void vl_api_get_node_index_reply_t_handler_json
1101 (vl_api_get_node_index_reply_t * mp)
1103 vat_main_t *vam = &vat_main;
1104 vat_json_node_t node;
1106 vat_json_init_object (&node);
1107 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1108 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1110 vat_json_print (vam->ofp, &node);
1111 vat_json_free (&node);
1113 vam->retval = ntohl (mp->retval);
1114 vam->result_ready = 1;
1117 static void vl_api_get_next_index_reply_t_handler
1118 (vl_api_get_next_index_reply_t * mp)
1120 vat_main_t *vam = &vat_main;
1121 i32 retval = ntohl (mp->retval);
1122 if (vam->async_mode)
1124 vam->async_errors += (retval < 0);
1128 vam->retval = retval;
1130 errmsg ("next node index %d", ntohl (mp->next_index));
1131 vam->result_ready = 1;
1135 static void vl_api_get_next_index_reply_t_handler_json
1136 (vl_api_get_next_index_reply_t * mp)
1138 vat_main_t *vam = &vat_main;
1139 vat_json_node_t node;
1141 vat_json_init_object (&node);
1142 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1143 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1145 vat_json_print (vam->ofp, &node);
1146 vat_json_free (&node);
1148 vam->retval = ntohl (mp->retval);
1149 vam->result_ready = 1;
1152 static void vl_api_add_node_next_reply_t_handler
1153 (vl_api_add_node_next_reply_t * mp)
1155 vat_main_t *vam = &vat_main;
1156 i32 retval = ntohl (mp->retval);
1157 if (vam->async_mode)
1159 vam->async_errors += (retval < 0);
1163 vam->retval = retval;
1165 errmsg ("next index %d", ntohl (mp->next_index));
1166 vam->result_ready = 1;
1170 static void vl_api_add_node_next_reply_t_handler_json
1171 (vl_api_add_node_next_reply_t * mp)
1173 vat_main_t *vam = &vat_main;
1174 vat_json_node_t node;
1176 vat_json_init_object (&node);
1177 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1178 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1180 vat_json_print (vam->ofp, &node);
1181 vat_json_free (&node);
1183 vam->retval = ntohl (mp->retval);
1184 vam->result_ready = 1;
1187 static void vl_api_show_version_reply_t_handler
1188 (vl_api_show_version_reply_t * mp)
1190 vat_main_t *vam = &vat_main;
1191 i32 retval = ntohl (mp->retval);
1195 errmsg (" program: %s", mp->program);
1196 errmsg (" version: %s", mp->version);
1197 errmsg (" build date: %s", mp->build_date);
1198 errmsg ("build directory: %s", mp->build_directory);
1200 vam->retval = retval;
1201 vam->result_ready = 1;
1204 static void vl_api_show_version_reply_t_handler_json
1205 (vl_api_show_version_reply_t * mp)
1207 vat_main_t *vam = &vat_main;
1208 vat_json_node_t node;
1210 vat_json_init_object (&node);
1211 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1212 vat_json_object_add_string_copy (&node, "program", mp->program);
1213 vat_json_object_add_string_copy (&node, "version", mp->version);
1214 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1215 vat_json_object_add_string_copy (&node, "build_directory",
1216 mp->build_directory);
1218 vat_json_print (vam->ofp, &node);
1219 vat_json_free (&node);
1221 vam->retval = ntohl (mp->retval);
1222 vam->result_ready = 1;
1226 vl_api_ip4_arp_event_t_handler (vl_api_ip4_arp_event_t * mp)
1228 errmsg ("arp %s event: address %U new mac %U sw_if_index %d",
1229 mp->mac_ip ? "mac/ip binding" : "address resolution",
1230 format_ip4_address, &mp->address,
1231 format_ethernet_address, mp->new_mac, mp->sw_if_index);
1235 vl_api_ip4_arp_event_t_handler_json (vl_api_ip4_arp_event_t * mp)
1237 /* JSON output not supported */
1241 vl_api_ip6_nd_event_t_handler (vl_api_ip6_nd_event_t * mp)
1243 errmsg ("ip6 nd %s event: address %U new mac %U sw_if_index %d",
1244 mp->mac_ip ? "mac/ip binding" : "address resolution",
1245 format_ip6_address, mp->address,
1246 format_ethernet_address, mp->new_mac, mp->sw_if_index);
1250 vl_api_ip6_nd_event_t_handler_json (vl_api_ip6_nd_event_t * mp)
1252 /* JSON output not supported */
1256 * Special-case: build the bridge domain table, maintain
1257 * the next bd id vbl.
1259 static void vl_api_bridge_domain_details_t_handler
1260 (vl_api_bridge_domain_details_t * mp)
1262 vat_main_t *vam = &vat_main;
1263 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1265 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-3s",
1266 " ID", "LRN", "FWD", "FLD", "BVI", "#IF");
1268 print (vam->ofp, "%3d %3d %3d %3d %3d %3d",
1269 ntohl (mp->bd_id), mp->learn, mp->forward,
1270 mp->flood, ntohl (mp->bvi_sw_if_index), n_sw_ifs);
1273 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG", "Interface Name");
1276 static void vl_api_bridge_domain_details_t_handler_json
1277 (vl_api_bridge_domain_details_t * mp)
1279 vat_main_t *vam = &vat_main;
1280 vat_json_node_t *node, *array = NULL;
1282 if (VAT_JSON_ARRAY != vam->json_tree.type)
1284 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1285 vat_json_init_array (&vam->json_tree);
1287 node = vat_json_array_add (&vam->json_tree);
1289 vat_json_init_object (node);
1290 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1291 vat_json_object_add_uint (node, "flood", mp->flood);
1292 vat_json_object_add_uint (node, "forward", mp->forward);
1293 vat_json_object_add_uint (node, "learn", mp->learn);
1294 vat_json_object_add_uint (node, "bvi_sw_if_index",
1295 ntohl (mp->bvi_sw_if_index));
1296 vat_json_object_add_uint (node, "n_sw_ifs", ntohl (mp->n_sw_ifs));
1297 array = vat_json_object_add (node, "sw_if");
1298 vat_json_init_array (array);
1302 * Special-case: build the bridge domain sw if table.
1304 static void vl_api_bridge_domain_sw_if_details_t_handler
1305 (vl_api_bridge_domain_sw_if_details_t * mp)
1307 vat_main_t *vam = &vat_main;
1312 sw_if_index = ntohl (mp->sw_if_index);
1314 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1316 if ((u32) p->value[0] == sw_if_index)
1318 sw_if_name = (u8 *)(p->key);
1324 print (vam->ofp, "%7d %3d %s", sw_if_index,
1325 mp->shg, sw_if_name ? (char *) sw_if_name :
1326 "sw_if_index not found!");
1329 static void vl_api_bridge_domain_sw_if_details_t_handler_json
1330 (vl_api_bridge_domain_sw_if_details_t * mp)
1332 vat_main_t *vam = &vat_main;
1333 vat_json_node_t *node = NULL;
1334 uword last_index = 0;
1336 ASSERT (VAT_JSON_ARRAY == vam->json_tree.type);
1337 ASSERT (vec_len (vam->json_tree.array) >= 1);
1338 last_index = vec_len (vam->json_tree.array) - 1;
1339 node = &vam->json_tree.array[last_index];
1340 node = vat_json_object_get_element (node, "sw_if");
1341 ASSERT (NULL != node);
1342 node = vat_json_array_add (node);
1344 vat_json_init_object (node);
1345 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1346 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
1347 vat_json_object_add_uint (node, "shg", mp->shg);
1350 static void vl_api_control_ping_reply_t_handler
1351 (vl_api_control_ping_reply_t * mp)
1353 vat_main_t *vam = &vat_main;
1354 i32 retval = ntohl (mp->retval);
1355 if (vam->async_mode)
1357 vam->async_errors += (retval < 0);
1361 vam->retval = retval;
1362 vam->result_ready = 1;
1366 static void vl_api_control_ping_reply_t_handler_json
1367 (vl_api_control_ping_reply_t * mp)
1369 vat_main_t *vam = &vat_main;
1370 i32 retval = ntohl (mp->retval);
1372 if (VAT_JSON_NONE != vam->json_tree.type)
1374 vat_json_print (vam->ofp, &vam->json_tree);
1375 vat_json_free (&vam->json_tree);
1376 vam->json_tree.type = VAT_JSON_NONE;
1381 vat_json_init_array (&vam->json_tree);
1382 vat_json_print (vam->ofp, &vam->json_tree);
1383 vam->json_tree.type = VAT_JSON_NONE;
1386 vam->retval = retval;
1387 vam->result_ready = 1;
1391 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1393 vat_main_t *vam = &vat_main;
1394 i32 retval = ntohl (mp->retval);
1395 if (vam->async_mode)
1397 vam->async_errors += (retval < 0);
1401 vam->retval = retval;
1402 vam->result_ready = 1;
1406 static void vl_api_l2_flags_reply_t_handler_json
1407 (vl_api_l2_flags_reply_t * mp)
1409 vat_main_t *vam = &vat_main;
1410 vat_json_node_t node;
1412 vat_json_init_object (&node);
1413 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1414 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1415 ntohl (mp->resulting_feature_bitmap));
1417 vat_json_print (vam->ofp, &node);
1418 vat_json_free (&node);
1420 vam->retval = ntohl (mp->retval);
1421 vam->result_ready = 1;
1424 static void vl_api_bridge_flags_reply_t_handler
1425 (vl_api_bridge_flags_reply_t * mp)
1427 vat_main_t *vam = &vat_main;
1428 i32 retval = ntohl (mp->retval);
1429 if (vam->async_mode)
1431 vam->async_errors += (retval < 0);
1435 vam->retval = retval;
1436 vam->result_ready = 1;
1440 static void vl_api_bridge_flags_reply_t_handler_json
1441 (vl_api_bridge_flags_reply_t * mp)
1443 vat_main_t *vam = &vat_main;
1444 vat_json_node_t node;
1446 vat_json_init_object (&node);
1447 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1448 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1449 ntohl (mp->resulting_feature_bitmap));
1451 vat_json_print (vam->ofp, &node);
1452 vat_json_free (&node);
1454 vam->retval = ntohl (mp->retval);
1455 vam->result_ready = 1;
1458 static void vl_api_tap_connect_reply_t_handler
1459 (vl_api_tap_connect_reply_t * mp)
1461 vat_main_t *vam = &vat_main;
1462 i32 retval = ntohl (mp->retval);
1463 if (vam->async_mode)
1465 vam->async_errors += (retval < 0);
1469 vam->retval = retval;
1470 vam->sw_if_index = ntohl (mp->sw_if_index);
1471 vam->result_ready = 1;
1476 static void vl_api_tap_connect_reply_t_handler_json
1477 (vl_api_tap_connect_reply_t * mp)
1479 vat_main_t *vam = &vat_main;
1480 vat_json_node_t node;
1482 vat_json_init_object (&node);
1483 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1484 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1486 vat_json_print (vam->ofp, &node);
1487 vat_json_free (&node);
1489 vam->retval = ntohl (mp->retval);
1490 vam->result_ready = 1;
1495 vl_api_tap_modify_reply_t_handler (vl_api_tap_modify_reply_t * mp)
1497 vat_main_t *vam = &vat_main;
1498 i32 retval = ntohl (mp->retval);
1499 if (vam->async_mode)
1501 vam->async_errors += (retval < 0);
1505 vam->retval = retval;
1506 vam->sw_if_index = ntohl (mp->sw_if_index);
1507 vam->result_ready = 1;
1511 static void vl_api_tap_modify_reply_t_handler_json
1512 (vl_api_tap_modify_reply_t * mp)
1514 vat_main_t *vam = &vat_main;
1515 vat_json_node_t node;
1517 vat_json_init_object (&node);
1518 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1519 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1521 vat_json_print (vam->ofp, &node);
1522 vat_json_free (&node);
1524 vam->retval = ntohl (mp->retval);
1525 vam->result_ready = 1;
1529 vl_api_tap_delete_reply_t_handler (vl_api_tap_delete_reply_t * mp)
1531 vat_main_t *vam = &vat_main;
1532 i32 retval = ntohl (mp->retval);
1533 if (vam->async_mode)
1535 vam->async_errors += (retval < 0);
1539 vam->retval = retval;
1540 vam->result_ready = 1;
1544 static void vl_api_tap_delete_reply_t_handler_json
1545 (vl_api_tap_delete_reply_t * mp)
1547 vat_main_t *vam = &vat_main;
1548 vat_json_node_t node;
1550 vat_json_init_object (&node);
1551 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1553 vat_json_print (vam->ofp, &node);
1554 vat_json_free (&node);
1556 vam->retval = ntohl (mp->retval);
1557 vam->result_ready = 1;
1560 static void vl_api_mpls_tunnel_add_del_reply_t_handler
1561 (vl_api_mpls_tunnel_add_del_reply_t * mp)
1563 vat_main_t *vam = &vat_main;
1564 i32 retval = ntohl (mp->retval);
1565 if (vam->async_mode)
1567 vam->async_errors += (retval < 0);
1571 vam->retval = retval;
1572 vam->result_ready = 1;
1576 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
1577 (vl_api_mpls_tunnel_add_del_reply_t * mp)
1579 vat_main_t *vam = &vat_main;
1580 vat_json_node_t node;
1582 vat_json_init_object (&node);
1583 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1584 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
1585 ntohl (mp->sw_if_index));
1587 vat_json_print (vam->ofp, &node);
1588 vat_json_free (&node);
1590 vam->retval = ntohl (mp->retval);
1591 vam->result_ready = 1;
1594 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
1595 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1597 vat_main_t *vam = &vat_main;
1598 i32 retval = ntohl (mp->retval);
1599 if (vam->async_mode)
1601 vam->async_errors += (retval < 0);
1605 vam->retval = retval;
1606 vam->sw_if_index = ntohl (mp->sw_if_index);
1607 vam->result_ready = 1;
1611 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
1612 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1614 vat_main_t *vam = &vat_main;
1615 vat_json_node_t node;
1617 vat_json_init_object (&node);
1618 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1619 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1621 vat_json_print (vam->ofp, &node);
1622 vat_json_free (&node);
1624 vam->retval = ntohl (mp->retval);
1625 vam->result_ready = 1;
1629 static void vl_api_one_add_del_locator_set_reply_t_handler
1630 (vl_api_one_add_del_locator_set_reply_t * mp)
1632 vat_main_t *vam = &vat_main;
1633 i32 retval = ntohl (mp->retval);
1634 if (vam->async_mode)
1636 vam->async_errors += (retval < 0);
1640 vam->retval = retval;
1641 vam->result_ready = 1;
1645 static void vl_api_one_add_del_locator_set_reply_t_handler_json
1646 (vl_api_one_add_del_locator_set_reply_t * mp)
1648 vat_main_t *vam = &vat_main;
1649 vat_json_node_t node;
1651 vat_json_init_object (&node);
1652 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1653 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
1655 vat_json_print (vam->ofp, &node);
1656 vat_json_free (&node);
1658 vam->retval = ntohl (mp->retval);
1659 vam->result_ready = 1;
1662 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
1663 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1665 vat_main_t *vam = &vat_main;
1666 i32 retval = ntohl (mp->retval);
1667 if (vam->async_mode)
1669 vam->async_errors += (retval < 0);
1673 vam->retval = retval;
1674 vam->sw_if_index = ntohl (mp->sw_if_index);
1675 vam->result_ready = 1;
1679 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
1680 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1682 vat_main_t *vam = &vat_main;
1683 vat_json_node_t node;
1685 vat_json_init_object (&node);
1686 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1687 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1689 vat_json_print (vam->ofp, &node);
1690 vat_json_free (&node);
1692 vam->retval = ntohl (mp->retval);
1693 vam->result_ready = 1;
1696 static void vl_api_gre_add_del_tunnel_reply_t_handler
1697 (vl_api_gre_add_del_tunnel_reply_t * mp)
1699 vat_main_t *vam = &vat_main;
1700 i32 retval = ntohl (mp->retval);
1701 if (vam->async_mode)
1703 vam->async_errors += (retval < 0);
1707 vam->retval = retval;
1708 vam->sw_if_index = ntohl (mp->sw_if_index);
1709 vam->result_ready = 1;
1713 static void vl_api_gre_add_del_tunnel_reply_t_handler_json
1714 (vl_api_gre_add_del_tunnel_reply_t * mp)
1716 vat_main_t *vam = &vat_main;
1717 vat_json_node_t node;
1719 vat_json_init_object (&node);
1720 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1721 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1723 vat_json_print (vam->ofp, &node);
1724 vat_json_free (&node);
1726 vam->retval = ntohl (mp->retval);
1727 vam->result_ready = 1;
1730 static void vl_api_create_vhost_user_if_reply_t_handler
1731 (vl_api_create_vhost_user_if_reply_t * mp)
1733 vat_main_t *vam = &vat_main;
1734 i32 retval = ntohl (mp->retval);
1735 if (vam->async_mode)
1737 vam->async_errors += (retval < 0);
1741 vam->retval = retval;
1742 vam->sw_if_index = ntohl (mp->sw_if_index);
1743 vam->result_ready = 1;
1747 static void vl_api_create_vhost_user_if_reply_t_handler_json
1748 (vl_api_create_vhost_user_if_reply_t * mp)
1750 vat_main_t *vam = &vat_main;
1751 vat_json_node_t node;
1753 vat_json_init_object (&node);
1754 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1755 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1757 vat_json_print (vam->ofp, &node);
1758 vat_json_free (&node);
1760 vam->retval = ntohl (mp->retval);
1761 vam->result_ready = 1;
1764 static void vl_api_ip_address_details_t_handler
1765 (vl_api_ip_address_details_t * mp)
1767 vat_main_t *vam = &vat_main;
1768 static ip_address_details_t empty_ip_address_details = { {0} };
1769 ip_address_details_t *address = NULL;
1770 ip_details_t *current_ip_details = NULL;
1771 ip_details_t *details = NULL;
1773 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
1775 if (!details || vam->current_sw_if_index >= vec_len (details)
1776 || !details[vam->current_sw_if_index].present)
1778 errmsg ("ip address details arrived but not stored");
1779 errmsg ("ip_dump should be called first");
1783 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
1785 #define addresses (current_ip_details->addr)
1787 vec_validate_init_empty (addresses, vec_len (addresses),
1788 empty_ip_address_details);
1790 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
1792 clib_memcpy (&address->ip, &mp->ip, sizeof (address->ip));
1793 address->prefix_length = mp->prefix_length;
1797 static void vl_api_ip_address_details_t_handler_json
1798 (vl_api_ip_address_details_t * mp)
1800 vat_main_t *vam = &vat_main;
1801 vat_json_node_t *node = NULL;
1802 struct in6_addr ip6;
1805 if (VAT_JSON_ARRAY != vam->json_tree.type)
1807 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1808 vat_json_init_array (&vam->json_tree);
1810 node = vat_json_array_add (&vam->json_tree);
1812 vat_json_init_object (node);
1815 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
1816 vat_json_object_add_ip6 (node, "ip", ip6);
1820 clib_memcpy (&ip4, mp->ip, sizeof (ip4));
1821 vat_json_object_add_ip4 (node, "ip", ip4);
1823 vat_json_object_add_uint (node, "prefix_length", mp->prefix_length);
1827 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
1829 vat_main_t *vam = &vat_main;
1830 static ip_details_t empty_ip_details = { 0 };
1831 ip_details_t *ip = NULL;
1832 u32 sw_if_index = ~0;
1834 sw_if_index = ntohl (mp->sw_if_index);
1836 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1837 sw_if_index, empty_ip_details);
1839 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1846 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
1848 vat_main_t *vam = &vat_main;
1850 if (VAT_JSON_ARRAY != vam->json_tree.type)
1852 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1853 vat_json_init_array (&vam->json_tree);
1855 vat_json_array_add_uint (&vam->json_tree,
1856 clib_net_to_host_u32 (mp->sw_if_index));
1859 static void vl_api_map_domain_details_t_handler_json
1860 (vl_api_map_domain_details_t * mp)
1862 vat_json_node_t *node = NULL;
1863 vat_main_t *vam = &vat_main;
1864 struct in6_addr ip6;
1867 if (VAT_JSON_ARRAY != vam->json_tree.type)
1869 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1870 vat_json_init_array (&vam->json_tree);
1873 node = vat_json_array_add (&vam->json_tree);
1874 vat_json_init_object (node);
1876 vat_json_object_add_uint (node, "domain_index",
1877 clib_net_to_host_u32 (mp->domain_index));
1878 clib_memcpy (&ip6, mp->ip6_prefix, sizeof (ip6));
1879 vat_json_object_add_ip6 (node, "ip6_prefix", ip6);
1880 clib_memcpy (&ip4, mp->ip4_prefix, sizeof (ip4));
1881 vat_json_object_add_ip4 (node, "ip4_prefix", ip4);
1882 clib_memcpy (&ip6, mp->ip6_src, sizeof (ip6));
1883 vat_json_object_add_ip6 (node, "ip6_src", ip6);
1884 vat_json_object_add_int (node, "ip6_prefix_len", mp->ip6_prefix_len);
1885 vat_json_object_add_int (node, "ip4_prefix_len", mp->ip4_prefix_len);
1886 vat_json_object_add_int (node, "ip6_src_len", mp->ip6_src_len);
1887 vat_json_object_add_int (node, "ea_bits_len", mp->ea_bits_len);
1888 vat_json_object_add_int (node, "psid_offset", mp->psid_offset);
1889 vat_json_object_add_int (node, "psid_length", mp->psid_length);
1890 vat_json_object_add_uint (node, "flags", mp->flags);
1891 vat_json_object_add_uint (node, "mtu", clib_net_to_host_u16 (mp->mtu));
1892 vat_json_object_add_int (node, "is_translation", mp->is_translation);
1895 static void vl_api_map_domain_details_t_handler
1896 (vl_api_map_domain_details_t * mp)
1898 vat_main_t *vam = &vat_main;
1900 if (mp->is_translation)
1903 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U/%d (ip6-src) index: %u",
1904 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1905 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1906 format_ip6_address, mp->ip6_src, mp->ip6_src_len,
1907 clib_net_to_host_u32 (mp->domain_index));
1912 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U (ip6-src) index: %u",
1913 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1914 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1915 format_ip6_address, mp->ip6_src,
1916 clib_net_to_host_u32 (mp->domain_index));
1918 print (vam->ofp, " ea-len %d psid-offset %d psid-len %d mtu %d %s",
1919 mp->ea_bits_len, mp->psid_offset, mp->psid_length, mp->mtu,
1920 mp->is_translation ? "map-t" : "");
1923 static void vl_api_map_rule_details_t_handler_json
1924 (vl_api_map_rule_details_t * mp)
1926 struct in6_addr ip6;
1927 vat_json_node_t *node = NULL;
1928 vat_main_t *vam = &vat_main;
1930 if (VAT_JSON_ARRAY != vam->json_tree.type)
1932 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1933 vat_json_init_array (&vam->json_tree);
1936 node = vat_json_array_add (&vam->json_tree);
1937 vat_json_init_object (node);
1939 vat_json_object_add_uint (node, "psid", clib_net_to_host_u16 (mp->psid));
1940 clib_memcpy (&ip6, mp->ip6_dst, sizeof (ip6));
1941 vat_json_object_add_ip6 (node, "ip6_dst", ip6);
1945 vl_api_map_rule_details_t_handler (vl_api_map_rule_details_t * mp)
1947 vat_main_t *vam = &vat_main;
1948 print (vam->ofp, " %d (psid) %U (ip6-dst)",
1949 clib_net_to_host_u16 (mp->psid), format_ip6_address, mp->ip6_dst);
1953 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
1955 errmsg ("DHCP compl event: pid %d %s hostname %s host_addr %U "
1956 "router_addr %U host_mac %U",
1957 mp->pid, mp->is_ipv6 ? "ipv6" : "ipv4", mp->hostname,
1958 format_ip4_address, &mp->host_address,
1959 format_ip4_address, &mp->router_address,
1960 format_ethernet_address, mp->host_mac);
1963 static void vl_api_dhcp_compl_event_t_handler_json
1964 (vl_api_dhcp_compl_event_t * mp)
1966 /* JSON output not supported */
1970 set_simple_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1973 vat_main_t *vam = &vat_main;
1974 static u64 default_counter = 0;
1976 vec_validate_init_empty (vam->simple_interface_counters, vnet_counter_type,
1978 vec_validate_init_empty (vam->simple_interface_counters[vnet_counter_type],
1979 sw_if_index, default_counter);
1980 vam->simple_interface_counters[vnet_counter_type][sw_if_index] = counter;
1984 set_combined_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1985 interface_counter_t counter)
1987 vat_main_t *vam = &vat_main;
1988 static interface_counter_t default_counter = { 0, };
1990 vec_validate_init_empty (vam->combined_interface_counters,
1991 vnet_counter_type, NULL);
1992 vec_validate_init_empty (vam->combined_interface_counters
1993 [vnet_counter_type], sw_if_index, default_counter);
1994 vam->combined_interface_counters[vnet_counter_type][sw_if_index] = counter;
1997 static void vl_api_vnet_interface_counters_t_handler
1998 (vl_api_vnet_interface_counters_t * mp)
2003 static void vl_api_vnet_interface_counters_t_handler_json
2004 (vl_api_vnet_interface_counters_t * mp)
2006 interface_counter_t counter;
2011 u32 first_sw_if_index;
2014 count = ntohl (mp->count);
2015 first_sw_if_index = ntohl (mp->first_sw_if_index);
2017 if (!mp->is_combined)
2019 v_packets = (u64 *) & mp->data;
2020 for (i = 0; i < count; i++)
2023 clib_net_to_host_u64 (clib_mem_unaligned (v_packets, u64));
2024 set_simple_interface_counter (mp->vnet_counter_type,
2025 first_sw_if_index + i, packets);
2031 v = (vlib_counter_t *) & mp->data;
2032 for (i = 0; i < count; i++)
2035 clib_net_to_host_u64 (clib_mem_unaligned (&v->packets, u64));
2037 clib_net_to_host_u64 (clib_mem_unaligned (&v->bytes, u64));
2038 set_combined_interface_counter (mp->vnet_counter_type,
2039 first_sw_if_index + i, counter);
2046 ip4_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
2048 vat_main_t *vam = &vat_main;
2051 for (i = 0; i < vec_len (vam->ip4_fib_counters_vrf_id_by_index); i++)
2053 if (vam->ip4_fib_counters_vrf_id_by_index[i] == vrf_id)
2062 ip6_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
2064 vat_main_t *vam = &vat_main;
2067 for (i = 0; i < vec_len (vam->ip6_fib_counters_vrf_id_by_index); i++)
2069 if (vam->ip6_fib_counters_vrf_id_by_index[i] == vrf_id)
2077 static void vl_api_vnet_ip4_fib_counters_t_handler
2078 (vl_api_vnet_ip4_fib_counters_t * mp)
2083 static void vl_api_vnet_ip4_fib_counters_t_handler_json
2084 (vl_api_vnet_ip4_fib_counters_t * mp)
2086 vat_main_t *vam = &vat_main;
2087 vl_api_ip4_fib_counter_t *v;
2088 ip4_fib_counter_t *counter;
2095 vrf_id = ntohl (mp->vrf_id);
2096 vrf_index = ip4_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2097 if (~0 == vrf_index)
2099 vrf_index = vec_len (vam->ip4_fib_counters_vrf_id_by_index);
2100 vec_validate (vam->ip4_fib_counters_vrf_id_by_index, vrf_index);
2101 vam->ip4_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2102 vec_validate (vam->ip4_fib_counters, vrf_index);
2103 vam->ip4_fib_counters[vrf_index] = NULL;
2106 vec_free (vam->ip4_fib_counters[vrf_index]);
2107 v = (vl_api_ip4_fib_counter_t *) & mp->c;
2108 count = ntohl (mp->count);
2109 for (i = 0; i < count; i++)
2111 vec_validate (vam->ip4_fib_counters[vrf_index], i);
2112 counter = &vam->ip4_fib_counters[vrf_index][i];
2113 clib_memcpy (&ip4, &v->address, sizeof (ip4));
2114 counter->address = ip4;
2115 counter->address_length = v->address_length;
2116 counter->packets = clib_net_to_host_u64 (v->packets);
2117 counter->bytes = clib_net_to_host_u64 (v->bytes);
2122 static void vl_api_vnet_ip4_nbr_counters_t_handler
2123 (vl_api_vnet_ip4_nbr_counters_t * mp)
2128 static void vl_api_vnet_ip4_nbr_counters_t_handler_json
2129 (vl_api_vnet_ip4_nbr_counters_t * mp)
2131 vat_main_t *vam = &vat_main;
2132 vl_api_ip4_nbr_counter_t *v;
2133 ip4_nbr_counter_t *counter;
2138 sw_if_index = ntohl (mp->sw_if_index);
2139 count = ntohl (mp->count);
2140 vec_validate (vam->ip4_nbr_counters, sw_if_index);
2143 vec_free (vam->ip4_nbr_counters[sw_if_index]);
2145 v = (vl_api_ip4_nbr_counter_t *) & mp->c;
2146 for (i = 0; i < count; i++)
2148 vec_validate (vam->ip4_nbr_counters[sw_if_index], i);
2149 counter = &vam->ip4_nbr_counters[sw_if_index][i];
2150 counter->address.s_addr = v->address;
2151 counter->packets = clib_net_to_host_u64 (v->packets);
2152 counter->bytes = clib_net_to_host_u64 (v->bytes);
2153 counter->linkt = v->link_type;
2158 static void vl_api_vnet_ip6_fib_counters_t_handler
2159 (vl_api_vnet_ip6_fib_counters_t * mp)
2164 static void vl_api_vnet_ip6_fib_counters_t_handler_json
2165 (vl_api_vnet_ip6_fib_counters_t * mp)
2167 vat_main_t *vam = &vat_main;
2168 vl_api_ip6_fib_counter_t *v;
2169 ip6_fib_counter_t *counter;
2170 struct in6_addr ip6;
2176 vrf_id = ntohl (mp->vrf_id);
2177 vrf_index = ip6_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2178 if (~0 == vrf_index)
2180 vrf_index = vec_len (vam->ip6_fib_counters_vrf_id_by_index);
2181 vec_validate (vam->ip6_fib_counters_vrf_id_by_index, vrf_index);
2182 vam->ip6_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2183 vec_validate (vam->ip6_fib_counters, vrf_index);
2184 vam->ip6_fib_counters[vrf_index] = NULL;
2187 vec_free (vam->ip6_fib_counters[vrf_index]);
2188 v = (vl_api_ip6_fib_counter_t *) & mp->c;
2189 count = ntohl (mp->count);
2190 for (i = 0; i < count; i++)
2192 vec_validate (vam->ip6_fib_counters[vrf_index], i);
2193 counter = &vam->ip6_fib_counters[vrf_index][i];
2194 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2195 counter->address = ip6;
2196 counter->address_length = v->address_length;
2197 counter->packets = clib_net_to_host_u64 (v->packets);
2198 counter->bytes = clib_net_to_host_u64 (v->bytes);
2203 static void vl_api_vnet_ip6_nbr_counters_t_handler
2204 (vl_api_vnet_ip6_nbr_counters_t * mp)
2209 static void vl_api_vnet_ip6_nbr_counters_t_handler_json
2210 (vl_api_vnet_ip6_nbr_counters_t * mp)
2212 vat_main_t *vam = &vat_main;
2213 vl_api_ip6_nbr_counter_t *v;
2214 ip6_nbr_counter_t *counter;
2215 struct in6_addr ip6;
2220 sw_if_index = ntohl (mp->sw_if_index);
2221 count = ntohl (mp->count);
2222 vec_validate (vam->ip6_nbr_counters, sw_if_index);
2225 vec_free (vam->ip6_nbr_counters[sw_if_index]);
2227 v = (vl_api_ip6_nbr_counter_t *) & mp->c;
2228 for (i = 0; i < count; i++)
2230 vec_validate (vam->ip6_nbr_counters[sw_if_index], i);
2231 counter = &vam->ip6_nbr_counters[sw_if_index][i];
2232 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2233 counter->address = ip6;
2234 counter->packets = clib_net_to_host_u64 (v->packets);
2235 counter->bytes = clib_net_to_host_u64 (v->bytes);
2240 static void vl_api_get_first_msg_id_reply_t_handler
2241 (vl_api_get_first_msg_id_reply_t * mp)
2243 vat_main_t *vam = &vat_main;
2244 i32 retval = ntohl (mp->retval);
2246 if (vam->async_mode)
2248 vam->async_errors += (retval < 0);
2252 vam->retval = retval;
2253 vam->result_ready = 1;
2257 errmsg ("first message id %d", ntohs (mp->first_msg_id));
2261 static void vl_api_get_first_msg_id_reply_t_handler_json
2262 (vl_api_get_first_msg_id_reply_t * mp)
2264 vat_main_t *vam = &vat_main;
2265 vat_json_node_t node;
2267 vat_json_init_object (&node);
2268 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2269 vat_json_object_add_uint (&node, "first_msg_id",
2270 (uint) ntohs (mp->first_msg_id));
2272 vat_json_print (vam->ofp, &node);
2273 vat_json_free (&node);
2275 vam->retval = ntohl (mp->retval);
2276 vam->result_ready = 1;
2279 static void vl_api_get_node_graph_reply_t_handler
2280 (vl_api_get_node_graph_reply_t * mp)
2282 vat_main_t *vam = &vat_main;
2283 api_main_t *am = &api_main;
2284 i32 retval = ntohl (mp->retval);
2285 u8 *pvt_copy, *reply;
2290 if (vam->async_mode)
2292 vam->async_errors += (retval < 0);
2296 vam->retval = retval;
2297 vam->result_ready = 1;
2300 /* "Should never happen..." */
2304 reply = (u8 *) (mp->reply_in_shmem);
2305 pvt_copy = vec_dup (reply);
2307 /* Toss the shared-memory original... */
2308 pthread_mutex_lock (&am->vlib_rp->mutex);
2309 oldheap = svm_push_data_heap (am->vlib_rp);
2313 svm_pop_heap (oldheap);
2314 pthread_mutex_unlock (&am->vlib_rp->mutex);
2316 if (vam->graph_nodes)
2318 hash_free (vam->graph_node_index_by_name);
2320 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2322 node = vam->graph_nodes[i];
2323 vec_free (node->name);
2324 vec_free (node->next_nodes);
2327 vec_free (vam->graph_nodes);
2330 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2331 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2332 vec_free (pvt_copy);
2334 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2336 node = vam->graph_nodes[i];
2337 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2341 static void vl_api_get_node_graph_reply_t_handler_json
2342 (vl_api_get_node_graph_reply_t * mp)
2344 vat_main_t *vam = &vat_main;
2345 api_main_t *am = &api_main;
2347 vat_json_node_t node;
2350 /* $$$$ make this real? */
2351 vat_json_init_object (&node);
2352 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2353 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2355 reply = (u8 *) (mp->reply_in_shmem);
2357 /* Toss the shared-memory original... */
2358 pthread_mutex_lock (&am->vlib_rp->mutex);
2359 oldheap = svm_push_data_heap (am->vlib_rp);
2363 svm_pop_heap (oldheap);
2364 pthread_mutex_unlock (&am->vlib_rp->mutex);
2366 vat_json_print (vam->ofp, &node);
2367 vat_json_free (&node);
2369 vam->retval = ntohl (mp->retval);
2370 vam->result_ready = 1;
2374 vl_api_one_locator_details_t_handler (vl_api_one_locator_details_t * mp)
2376 vat_main_t *vam = &vat_main;
2381 s = format (s, "%=16d%=16d%=16d",
2382 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2386 s = format (s, "%=16U%=16d%=16d",
2387 mp->is_ipv6 ? format_ip6_address :
2389 mp->ip_address, mp->priority, mp->weight);
2392 print (vam->ofp, "%v", s);
2397 vl_api_one_locator_details_t_handler_json (vl_api_one_locator_details_t * mp)
2399 vat_main_t *vam = &vat_main;
2400 vat_json_node_t *node = NULL;
2401 struct in6_addr ip6;
2404 if (VAT_JSON_ARRAY != vam->json_tree.type)
2406 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2407 vat_json_init_array (&vam->json_tree);
2409 node = vat_json_array_add (&vam->json_tree);
2410 vat_json_init_object (node);
2412 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2413 vat_json_object_add_uint (node, "priority", mp->priority);
2414 vat_json_object_add_uint (node, "weight", mp->weight);
2417 vat_json_object_add_uint (node, "sw_if_index",
2418 clib_net_to_host_u32 (mp->sw_if_index));
2423 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2424 vat_json_object_add_ip6 (node, "address", ip6);
2428 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2429 vat_json_object_add_ip4 (node, "address", ip4);
2435 vl_api_one_locator_set_details_t_handler (vl_api_one_locator_set_details_t *
2438 vat_main_t *vam = &vat_main;
2441 ls_name = format (0, "%s", mp->ls_name);
2443 print (vam->ofp, "%=10d%=15v", clib_net_to_host_u32 (mp->ls_index),
2449 vl_api_one_locator_set_details_t_handler_json
2450 (vl_api_one_locator_set_details_t * mp)
2452 vat_main_t *vam = &vat_main;
2453 vat_json_node_t *node = 0;
2456 ls_name = format (0, "%s", mp->ls_name);
2457 vec_add1 (ls_name, 0);
2459 if (VAT_JSON_ARRAY != vam->json_tree.type)
2461 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2462 vat_json_init_array (&vam->json_tree);
2464 node = vat_json_array_add (&vam->json_tree);
2466 vat_json_init_object (node);
2467 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2468 vat_json_object_add_uint (node, "ls_index",
2469 clib_net_to_host_u32 (mp->ls_index));
2474 format_lisp_flat_eid (u8 * s, va_list * args)
2476 u32 type = va_arg (*args, u32);
2477 u8 *eid = va_arg (*args, u8 *);
2478 u32 eid_len = va_arg (*args, u32);
2483 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
2485 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
2487 return format (s, "%U", format_ethernet_address, eid);
2493 format_lisp_eid_vat (u8 * s, va_list * args)
2495 u32 type = va_arg (*args, u32);
2496 u8 *eid = va_arg (*args, u8 *);
2497 u32 eid_len = va_arg (*args, u32);
2498 u8 *seid = va_arg (*args, u8 *);
2499 u32 seid_len = va_arg (*args, u32);
2500 u32 is_src_dst = va_arg (*args, u32);
2503 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
2505 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
2511 vl_api_one_eid_table_details_t_handler (vl_api_one_eid_table_details_t * mp)
2513 vat_main_t *vam = &vat_main;
2514 u8 *s = 0, *eid = 0;
2516 if (~0 == mp->locator_set_index)
2517 s = format (0, "action: %d", mp->action);
2519 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
2521 eid = format (0, "%U", format_lisp_eid_vat,
2525 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2528 print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
2529 clib_net_to_host_u32 (mp->vni),
2531 mp->is_local ? "local" : "remote",
2532 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
2533 clib_net_to_host_u16 (mp->key_id), mp->key);
2540 vl_api_one_eid_table_details_t_handler_json (vl_api_one_eid_table_details_t
2543 vat_main_t *vam = &vat_main;
2544 vat_json_node_t *node = 0;
2547 if (VAT_JSON_ARRAY != vam->json_tree.type)
2549 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2550 vat_json_init_array (&vam->json_tree);
2552 node = vat_json_array_add (&vam->json_tree);
2554 vat_json_init_object (node);
2555 if (~0 == mp->locator_set_index)
2556 vat_json_object_add_uint (node, "action", mp->action);
2558 vat_json_object_add_uint (node, "locator_set_index",
2559 clib_net_to_host_u32 (mp->locator_set_index));
2561 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
2562 eid = format (0, "%U", format_lisp_eid_vat,
2566 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2568 vat_json_object_add_string_copy (node, "eid", eid);
2569 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2570 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
2571 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
2575 vat_json_object_add_uint (node, "key_id",
2576 clib_net_to_host_u16 (mp->key_id));
2577 vat_json_object_add_string_copy (node, "key", mp->key);
2583 vl_api_one_eid_table_map_details_t_handler
2584 (vl_api_one_eid_table_map_details_t * mp)
2586 vat_main_t *vam = &vat_main;
2588 u8 *line = format (0, "%=10d%=10d",
2589 clib_net_to_host_u32 (mp->vni),
2590 clib_net_to_host_u32 (mp->dp_table));
2591 print (vam->ofp, "%v", line);
2596 vl_api_one_eid_table_map_details_t_handler_json
2597 (vl_api_one_eid_table_map_details_t * mp)
2599 vat_main_t *vam = &vat_main;
2600 vat_json_node_t *node = NULL;
2602 if (VAT_JSON_ARRAY != vam->json_tree.type)
2604 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2605 vat_json_init_array (&vam->json_tree);
2607 node = vat_json_array_add (&vam->json_tree);
2608 vat_json_init_object (node);
2609 vat_json_object_add_uint (node, "dp_table",
2610 clib_net_to_host_u32 (mp->dp_table));
2611 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2615 vl_api_one_eid_table_vni_details_t_handler
2616 (vl_api_one_eid_table_vni_details_t * mp)
2618 vat_main_t *vam = &vat_main;
2620 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
2621 print (vam->ofp, "%v", line);
2626 vl_api_one_eid_table_vni_details_t_handler_json
2627 (vl_api_one_eid_table_vni_details_t * mp)
2629 vat_main_t *vam = &vat_main;
2630 vat_json_node_t *node = NULL;
2632 if (VAT_JSON_ARRAY != vam->json_tree.type)
2634 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2635 vat_json_init_array (&vam->json_tree);
2637 node = vat_json_array_add (&vam->json_tree);
2638 vat_json_init_object (node);
2639 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2643 vl_api_show_one_map_register_state_reply_t_handler
2644 (vl_api_show_one_map_register_state_reply_t * mp)
2646 vat_main_t *vam = &vat_main;
2647 int retval = clib_net_to_host_u32 (mp->retval);
2649 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
2651 vam->retval = retval;
2652 vam->result_ready = 1;
2656 vl_api_show_one_map_register_state_reply_t_handler_json
2657 (vl_api_show_one_map_register_state_reply_t * mp)
2659 vat_main_t *vam = &vat_main;
2660 vat_json_node_t _node, *node = &_node;
2661 int retval = clib_net_to_host_u32 (mp->retval);
2663 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
2665 vat_json_init_object (node);
2666 vat_json_object_add_string_copy (node, "state", s);
2668 vat_json_print (vam->ofp, node);
2669 vat_json_free (node);
2671 vam->retval = retval;
2672 vam->result_ready = 1;
2677 vl_api_show_one_rloc_probe_state_reply_t_handler
2678 (vl_api_show_one_rloc_probe_state_reply_t * mp)
2680 vat_main_t *vam = &vat_main;
2681 int retval = clib_net_to_host_u32 (mp->retval);
2686 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
2688 vam->retval = retval;
2689 vam->result_ready = 1;
2693 vl_api_show_one_rloc_probe_state_reply_t_handler_json
2694 (vl_api_show_one_rloc_probe_state_reply_t * mp)
2696 vat_main_t *vam = &vat_main;
2697 vat_json_node_t _node, *node = &_node;
2698 int retval = clib_net_to_host_u32 (mp->retval);
2700 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
2701 vat_json_init_object (node);
2702 vat_json_object_add_string_copy (node, "state", s);
2704 vat_json_print (vam->ofp, node);
2705 vat_json_free (node);
2707 vam->retval = retval;
2708 vam->result_ready = 1;
2713 api_gpe_fwd_entry_net_to_host (vl_api_gpe_fwd_entry_t * e)
2715 e->dp_table = clib_net_to_host_u32 (e->dp_table);
2716 e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
2720 gpe_fwd_entries_get_reply_t_net_to_host
2721 (vl_api_gpe_fwd_entries_get_reply_t * mp)
2725 mp->count = clib_net_to_host_u32 (mp->count);
2726 for (i = 0; i < mp->count; i++)
2728 api_gpe_fwd_entry_net_to_host (&mp->entries[i]);
2733 format_gpe_encap_mode (u8 * s, va_list * args)
2735 u32 mode = va_arg (*args, u32);
2740 return format (s, "lisp");
2742 return format (s, "vxlan");
2748 vl_api_gpe_get_encap_mode_reply_t_handler
2749 (vl_api_gpe_get_encap_mode_reply_t * mp)
2751 vat_main_t *vam = &vat_main;
2753 print (vam->ofp, "gpe mode: %U", format_gpe_encap_mode, mp->encap_mode);
2754 vam->retval = ntohl (mp->retval);
2755 vam->result_ready = 1;
2759 vl_api_gpe_get_encap_mode_reply_t_handler_json
2760 (vl_api_gpe_get_encap_mode_reply_t * mp)
2762 vat_main_t *vam = &vat_main;
2763 vat_json_node_t node;
2765 u8 *encap_mode = format (0, "%U", format_gpe_encap_mode, mp->encap_mode);
2766 vec_add1 (encap_mode, 0);
2768 vat_json_init_object (&node);
2769 vat_json_object_add_string_copy (&node, "gpe_mode", encap_mode);
2771 vec_free (encap_mode);
2772 vat_json_print (vam->ofp, &node);
2773 vat_json_free (&node);
2775 vam->retval = ntohl (mp->retval);
2776 vam->result_ready = 1;
2780 vl_api_gpe_fwd_entry_path_details_t_handler
2781 (vl_api_gpe_fwd_entry_path_details_t * mp)
2783 vat_main_t *vam = &vat_main;
2784 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
2786 if (mp->lcl_loc.is_ip4)
2787 format_ip_address_fcn = format_ip4_address;
2789 format_ip_address_fcn = format_ip6_address;
2791 print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
2792 format_ip_address_fcn, &mp->lcl_loc,
2793 format_ip_address_fcn, &mp->rmt_loc);
2797 lisp_fill_locator_node (vat_json_node_t * n, vl_api_gpe_locator_t * loc)
2799 struct in6_addr ip6;
2804 clib_memcpy (&ip4, loc->addr, sizeof (ip4));
2805 vat_json_object_add_ip4 (n, "address", ip4);
2809 clib_memcpy (&ip6, loc->addr, sizeof (ip6));
2810 vat_json_object_add_ip6 (n, "address", ip6);
2812 vat_json_object_add_uint (n, "weight", loc->weight);
2816 vl_api_gpe_fwd_entry_path_details_t_handler_json
2817 (vl_api_gpe_fwd_entry_path_details_t * mp)
2819 vat_main_t *vam = &vat_main;
2820 vat_json_node_t *node = NULL;
2821 vat_json_node_t *loc_node;
2823 if (VAT_JSON_ARRAY != vam->json_tree.type)
2825 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2826 vat_json_init_array (&vam->json_tree);
2828 node = vat_json_array_add (&vam->json_tree);
2829 vat_json_init_object (node);
2831 loc_node = vat_json_object_add (node, "local_locator");
2832 vat_json_init_object (loc_node);
2833 lisp_fill_locator_node (loc_node, &mp->lcl_loc);
2835 loc_node = vat_json_object_add (node, "remote_locator");
2836 vat_json_init_object (loc_node);
2837 lisp_fill_locator_node (loc_node, &mp->rmt_loc);
2841 vl_api_gpe_fwd_entries_get_reply_t_handler
2842 (vl_api_gpe_fwd_entries_get_reply_t * mp)
2844 vat_main_t *vam = &vat_main;
2846 int retval = clib_net_to_host_u32 (mp->retval);
2847 vl_api_gpe_fwd_entry_t *e;
2852 gpe_fwd_entries_get_reply_t_net_to_host (mp);
2854 for (i = 0; i < mp->count; i++)
2856 e = &mp->entries[i];
2857 print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
2858 format_lisp_flat_eid, e->eid_type, e->leid, e->leid_prefix_len,
2859 format_lisp_flat_eid, e->eid_type, e->reid, e->reid_prefix_len);
2863 vam->retval = retval;
2864 vam->result_ready = 1;
2868 vl_api_gpe_fwd_entries_get_reply_t_handler_json
2869 (vl_api_gpe_fwd_entries_get_reply_t * mp)
2872 vat_main_t *vam = &vat_main;
2873 vat_json_node_t *e = 0, root;
2875 int retval = clib_net_to_host_u32 (mp->retval);
2876 vl_api_gpe_fwd_entry_t *fwd;
2881 gpe_fwd_entries_get_reply_t_net_to_host (mp);
2882 vat_json_init_array (&root);
2884 for (i = 0; i < mp->count; i++)
2886 e = vat_json_array_add (&root);
2887 fwd = &mp->entries[i];
2889 vat_json_init_object (e);
2890 vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
2891 vat_json_object_add_int (e, "dp_table", fwd->dp_table);
2893 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->leid,
2894 fwd->leid_prefix_len);
2896 vat_json_object_add_string_copy (e, "leid", s);
2899 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->reid,
2900 fwd->reid_prefix_len);
2902 vat_json_object_add_string_copy (e, "reid", s);
2906 vat_json_print (vam->ofp, &root);
2907 vat_json_free (&root);
2910 vam->retval = retval;
2911 vam->result_ready = 1;
2915 vl_api_one_adjacencies_get_reply_t_handler
2916 (vl_api_one_adjacencies_get_reply_t * mp)
2918 vat_main_t *vam = &vat_main;
2920 int retval = clib_net_to_host_u32 (mp->retval);
2921 vl_api_one_adjacency_t *a;
2926 n = clib_net_to_host_u32 (mp->count);
2928 for (i = 0; i < n; i++)
2930 a = &mp->adjacencies[i];
2931 print (vam->ofp, "%U %40U",
2932 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
2933 format_lisp_flat_eid, a->eid_type, a->reid, a->reid_prefix_len);
2937 vam->retval = retval;
2938 vam->result_ready = 1;
2942 vl_api_one_adjacencies_get_reply_t_handler_json
2943 (vl_api_one_adjacencies_get_reply_t * mp)
2946 vat_main_t *vam = &vat_main;
2947 vat_json_node_t *e = 0, root;
2949 int retval = clib_net_to_host_u32 (mp->retval);
2950 vl_api_one_adjacency_t *a;
2955 n = clib_net_to_host_u32 (mp->count);
2956 vat_json_init_array (&root);
2958 for (i = 0; i < n; i++)
2960 e = vat_json_array_add (&root);
2961 a = &mp->adjacencies[i];
2963 vat_json_init_object (e);
2964 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
2965 a->leid_prefix_len);
2967 vat_json_object_add_string_copy (e, "leid", s);
2970 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
2971 a->reid_prefix_len);
2973 vat_json_object_add_string_copy (e, "reid", s);
2977 vat_json_print (vam->ofp, &root);
2978 vat_json_free (&root);
2981 vam->retval = retval;
2982 vam->result_ready = 1;
2986 vl_api_one_map_server_details_t_handler (vl_api_one_map_server_details_t * mp)
2988 vat_main_t *vam = &vat_main;
2990 print (vam->ofp, "%=20U",
2991 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2996 vl_api_one_map_server_details_t_handler_json
2997 (vl_api_one_map_server_details_t * mp)
2999 vat_main_t *vam = &vat_main;
3000 vat_json_node_t *node = NULL;
3001 struct in6_addr ip6;
3004 if (VAT_JSON_ARRAY != vam->json_tree.type)
3006 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3007 vat_json_init_array (&vam->json_tree);
3009 node = vat_json_array_add (&vam->json_tree);
3011 vat_json_init_object (node);
3014 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
3015 vat_json_object_add_ip6 (node, "map-server", ip6);
3019 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
3020 vat_json_object_add_ip4 (node, "map-server", ip4);
3025 vl_api_one_map_resolver_details_t_handler (vl_api_one_map_resolver_details_t
3028 vat_main_t *vam = &vat_main;
3030 print (vam->ofp, "%=20U",
3031 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
3036 vl_api_one_map_resolver_details_t_handler_json
3037 (vl_api_one_map_resolver_details_t * mp)
3039 vat_main_t *vam = &vat_main;
3040 vat_json_node_t *node = NULL;
3041 struct in6_addr ip6;
3044 if (VAT_JSON_ARRAY != vam->json_tree.type)
3046 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3047 vat_json_init_array (&vam->json_tree);
3049 node = vat_json_array_add (&vam->json_tree);
3051 vat_json_init_object (node);
3054 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
3055 vat_json_object_add_ip6 (node, "map resolver", ip6);
3059 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
3060 vat_json_object_add_ip4 (node, "map resolver", ip4);
3065 vl_api_show_one_status_reply_t_handler (vl_api_show_one_status_reply_t * mp)
3067 vat_main_t *vam = &vat_main;
3068 i32 retval = ntohl (mp->retval);
3072 print (vam->ofp, "feature: %s\ngpe: %s",
3073 mp->feature_status ? "enabled" : "disabled",
3074 mp->gpe_status ? "enabled" : "disabled");
3077 vam->retval = retval;
3078 vam->result_ready = 1;
3082 vl_api_show_one_status_reply_t_handler_json
3083 (vl_api_show_one_status_reply_t * mp)
3085 vat_main_t *vam = &vat_main;
3086 vat_json_node_t node;
3087 u8 *gpe_status = NULL;
3088 u8 *feature_status = NULL;
3090 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
3091 feature_status = format (0, "%s",
3092 mp->feature_status ? "enabled" : "disabled");
3093 vec_add1 (gpe_status, 0);
3094 vec_add1 (feature_status, 0);
3096 vat_json_init_object (&node);
3097 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
3098 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
3100 vec_free (gpe_status);
3101 vec_free (feature_status);
3103 vat_json_print (vam->ofp, &node);
3104 vat_json_free (&node);
3106 vam->retval = ntohl (mp->retval);
3107 vam->result_ready = 1;
3111 vl_api_one_get_map_request_itr_rlocs_reply_t_handler
3112 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
3114 vat_main_t *vam = &vat_main;
3115 i32 retval = ntohl (mp->retval);
3119 print (vam->ofp, "%=20s", mp->locator_set_name);
3122 vam->retval = retval;
3123 vam->result_ready = 1;
3127 vl_api_one_get_map_request_itr_rlocs_reply_t_handler_json
3128 (vl_api_one_get_map_request_itr_rlocs_reply_t * mp)
3130 vat_main_t *vam = &vat_main;
3131 vat_json_node_t *node = NULL;
3133 if (VAT_JSON_ARRAY != vam->json_tree.type)
3135 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3136 vat_json_init_array (&vam->json_tree);
3138 node = vat_json_array_add (&vam->json_tree);
3140 vat_json_init_object (node);
3141 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
3143 vat_json_print (vam->ofp, node);
3144 vat_json_free (node);
3146 vam->retval = ntohl (mp->retval);
3147 vam->result_ready = 1;
3151 format_lisp_map_request_mode (u8 * s, va_list * args)
3153 u32 mode = va_arg (*args, u32);
3158 return format (0, "dst-only");
3160 return format (0, "src-dst");
3166 vl_api_show_one_map_request_mode_reply_t_handler
3167 (vl_api_show_one_map_request_mode_reply_t * mp)
3169 vat_main_t *vam = &vat_main;
3170 i32 retval = ntohl (mp->retval);
3174 u32 mode = mp->mode;
3175 print (vam->ofp, "map_request_mode: %U",
3176 format_lisp_map_request_mode, mode);
3179 vam->retval = retval;
3180 vam->result_ready = 1;
3184 vl_api_show_one_map_request_mode_reply_t_handler_json
3185 (vl_api_show_one_map_request_mode_reply_t * mp)
3187 vat_main_t *vam = &vat_main;
3188 vat_json_node_t node;
3193 s = format (0, "%U", format_lisp_map_request_mode, mode);
3196 vat_json_init_object (&node);
3197 vat_json_object_add_string_copy (&node, "map_request_mode", s);
3198 vat_json_print (vam->ofp, &node);
3199 vat_json_free (&node);
3202 vam->retval = ntohl (mp->retval);
3203 vam->result_ready = 1;
3207 vl_api_show_one_pitr_reply_t_handler (vl_api_show_one_pitr_reply_t * mp)
3209 vat_main_t *vam = &vat_main;
3210 i32 retval = ntohl (mp->retval);
3214 print (vam->ofp, "%-20s%-16s",
3215 mp->status ? "enabled" : "disabled",
3216 mp->status ? (char *) mp->locator_set_name : "");
3219 vam->retval = retval;
3220 vam->result_ready = 1;
3224 vl_api_show_one_pitr_reply_t_handler_json (vl_api_show_one_pitr_reply_t * mp)
3226 vat_main_t *vam = &vat_main;
3227 vat_json_node_t node;
3230 status = format (0, "%s", mp->status ? "enabled" : "disabled");
3231 vec_add1 (status, 0);
3233 vat_json_init_object (&node);
3234 vat_json_object_add_string_copy (&node, "status", status);
3237 vat_json_object_add_string_copy (&node, "locator_set",
3238 mp->locator_set_name);
3243 vat_json_print (vam->ofp, &node);
3244 vat_json_free (&node);
3246 vam->retval = ntohl (mp->retval);
3247 vam->result_ready = 1;
3251 format_policer_type (u8 * s, va_list * va)
3253 u32 i = va_arg (*va, u32);
3255 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
3256 s = format (s, "1r2c");
3257 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
3258 s = format (s, "1r3c");
3259 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
3260 s = format (s, "2r3c-2698");
3261 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
3262 s = format (s, "2r3c-4115");
3263 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
3264 s = format (s, "2r3c-mef5cf1");
3266 s = format (s, "ILLEGAL");
3271 format_policer_rate_type (u8 * s, va_list * va)
3273 u32 i = va_arg (*va, u32);
3275 if (i == SSE2_QOS_RATE_KBPS)
3276 s = format (s, "kbps");
3277 else if (i == SSE2_QOS_RATE_PPS)
3278 s = format (s, "pps");
3280 s = format (s, "ILLEGAL");
3285 format_policer_round_type (u8 * s, va_list * va)
3287 u32 i = va_arg (*va, u32);
3289 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
3290 s = format (s, "closest");
3291 else if (i == SSE2_QOS_ROUND_TO_UP)
3292 s = format (s, "up");
3293 else if (i == SSE2_QOS_ROUND_TO_DOWN)
3294 s = format (s, "down");
3296 s = format (s, "ILLEGAL");
3301 format_policer_action_type (u8 * s, va_list * va)
3303 u32 i = va_arg (*va, u32);
3305 if (i == SSE2_QOS_ACTION_DROP)
3306 s = format (s, "drop");
3307 else if (i == SSE2_QOS_ACTION_TRANSMIT)
3308 s = format (s, "transmit");
3309 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3310 s = format (s, "mark-and-transmit");
3312 s = format (s, "ILLEGAL");
3317 format_dscp (u8 * s, va_list * va)
3319 u32 i = va_arg (*va, u32);
3324 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
3328 return format (s, "ILLEGAL");
3330 s = format (s, "%s", t);
3335 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
3337 vat_main_t *vam = &vat_main;
3338 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
3340 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3341 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
3343 conform_dscp_str = format (0, "");
3345 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3346 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
3348 exceed_dscp_str = format (0, "");
3350 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3351 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
3353 violate_dscp_str = format (0, "");
3355 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
3356 "rate type %U, round type %U, %s rate, %s color-aware, "
3357 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
3358 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
3359 "conform action %U%s, exceed action %U%s, violate action %U%s",
3361 format_policer_type, mp->type,
3364 clib_net_to_host_u64 (mp->cb),
3365 clib_net_to_host_u64 (mp->eb),
3366 format_policer_rate_type, mp->rate_type,
3367 format_policer_round_type, mp->round_type,
3368 mp->single_rate ? "single" : "dual",
3369 mp->color_aware ? "is" : "not",
3370 ntohl (mp->cir_tokens_per_period),
3371 ntohl (mp->pir_tokens_per_period),
3373 ntohl (mp->current_limit),
3374 ntohl (mp->current_bucket),
3375 ntohl (mp->extended_limit),
3376 ntohl (mp->extended_bucket),
3377 clib_net_to_host_u64 (mp->last_update_time),
3378 format_policer_action_type, mp->conform_action_type,
3380 format_policer_action_type, mp->exceed_action_type,
3382 format_policer_action_type, mp->violate_action_type,
3385 vec_free (conform_dscp_str);
3386 vec_free (exceed_dscp_str);
3387 vec_free (violate_dscp_str);
3390 static void vl_api_policer_details_t_handler_json
3391 (vl_api_policer_details_t * mp)
3393 vat_main_t *vam = &vat_main;
3394 vat_json_node_t *node;
3395 u8 *rate_type_str, *round_type_str, *type_str;
3396 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
3398 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
3400 format (0, "%U", format_policer_round_type, mp->round_type);
3401 type_str = format (0, "%U", format_policer_type, mp->type);
3402 conform_action_str = format (0, "%U", format_policer_action_type,
3403 mp->conform_action_type);
3404 exceed_action_str = format (0, "%U", format_policer_action_type,
3405 mp->exceed_action_type);
3406 violate_action_str = format (0, "%U", format_policer_action_type,
3407 mp->violate_action_type);
3409 if (VAT_JSON_ARRAY != vam->json_tree.type)
3411 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3412 vat_json_init_array (&vam->json_tree);
3414 node = vat_json_array_add (&vam->json_tree);
3416 vat_json_init_object (node);
3417 vat_json_object_add_string_copy (node, "name", mp->name);
3418 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
3419 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
3420 vat_json_object_add_uint (node, "cb", ntohl (mp->cb));
3421 vat_json_object_add_uint (node, "eb", ntohl (mp->eb));
3422 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
3423 vat_json_object_add_string_copy (node, "round_type", round_type_str);
3424 vat_json_object_add_string_copy (node, "type", type_str);
3425 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
3426 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
3427 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
3428 vat_json_object_add_uint (node, "cir_tokens_per_period",
3429 ntohl (mp->cir_tokens_per_period));
3430 vat_json_object_add_uint (node, "eir_tokens_per_period",
3431 ntohl (mp->pir_tokens_per_period));
3432 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
3433 vat_json_object_add_uint (node, "current_bucket",
3434 ntohl (mp->current_bucket));
3435 vat_json_object_add_uint (node, "extended_limit",
3436 ntohl (mp->extended_limit));
3437 vat_json_object_add_uint (node, "extended_bucket",
3438 ntohl (mp->extended_bucket));
3439 vat_json_object_add_uint (node, "last_update_time",
3440 ntohl (mp->last_update_time));
3441 vat_json_object_add_string_copy (node, "conform_action",
3442 conform_action_str);
3443 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3445 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
3446 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
3447 vec_free (dscp_str);
3449 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
3450 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3452 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
3453 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
3454 vec_free (dscp_str);
3456 vat_json_object_add_string_copy (node, "violate_action",
3457 violate_action_str);
3458 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3460 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
3461 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
3462 vec_free (dscp_str);
3465 vec_free (rate_type_str);
3466 vec_free (round_type_str);
3467 vec_free (type_str);
3468 vec_free (conform_action_str);
3469 vec_free (exceed_action_str);
3470 vec_free (violate_action_str);
3474 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
3477 vat_main_t *vam = &vat_main;
3478 int i, count = ntohl (mp->count);
3481 print (vam->ofp, "classify table ids (%d) : ", count);
3482 for (i = 0; i < count; i++)
3484 print (vam->ofp, "%d", ntohl (mp->ids[i]));
3485 print (vam->ofp, (i < count - 1) ? "," : "");
3487 vam->retval = ntohl (mp->retval);
3488 vam->result_ready = 1;
3492 vl_api_classify_table_ids_reply_t_handler_json
3493 (vl_api_classify_table_ids_reply_t * mp)
3495 vat_main_t *vam = &vat_main;
3496 int i, count = ntohl (mp->count);
3500 vat_json_node_t node;
3502 vat_json_init_object (&node);
3503 for (i = 0; i < count; i++)
3505 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
3507 vat_json_print (vam->ofp, &node);
3508 vat_json_free (&node);
3510 vam->retval = ntohl (mp->retval);
3511 vam->result_ready = 1;
3515 vl_api_classify_table_by_interface_reply_t_handler
3516 (vl_api_classify_table_by_interface_reply_t * mp)
3518 vat_main_t *vam = &vat_main;
3521 table_id = ntohl (mp->l2_table_id);
3523 print (vam->ofp, "l2 table id : %d", table_id);
3525 print (vam->ofp, "l2 table id : No input ACL tables configured");
3526 table_id = ntohl (mp->ip4_table_id);
3528 print (vam->ofp, "ip4 table id : %d", table_id);
3530 print (vam->ofp, "ip4 table id : No input ACL tables configured");
3531 table_id = ntohl (mp->ip6_table_id);
3533 print (vam->ofp, "ip6 table id : %d", table_id);
3535 print (vam->ofp, "ip6 table id : No input ACL tables configured");
3536 vam->retval = ntohl (mp->retval);
3537 vam->result_ready = 1;
3541 vl_api_classify_table_by_interface_reply_t_handler_json
3542 (vl_api_classify_table_by_interface_reply_t * mp)
3544 vat_main_t *vam = &vat_main;
3545 vat_json_node_t node;
3547 vat_json_init_object (&node);
3549 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
3550 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
3551 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
3553 vat_json_print (vam->ofp, &node);
3554 vat_json_free (&node);
3556 vam->retval = ntohl (mp->retval);
3557 vam->result_ready = 1;
3560 static void vl_api_policer_add_del_reply_t_handler
3561 (vl_api_policer_add_del_reply_t * mp)
3563 vat_main_t *vam = &vat_main;
3564 i32 retval = ntohl (mp->retval);
3565 if (vam->async_mode)
3567 vam->async_errors += (retval < 0);
3571 vam->retval = retval;
3572 vam->result_ready = 1;
3573 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
3575 * Note: this is just barely thread-safe, depends on
3576 * the main thread spinning waiting for an answer...
3578 errmsg ("policer index %d", ntohl (mp->policer_index));
3582 static void vl_api_policer_add_del_reply_t_handler_json
3583 (vl_api_policer_add_del_reply_t * mp)
3585 vat_main_t *vam = &vat_main;
3586 vat_json_node_t node;
3588 vat_json_init_object (&node);
3589 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3590 vat_json_object_add_uint (&node, "policer_index",
3591 ntohl (mp->policer_index));
3593 vat_json_print (vam->ofp, &node);
3594 vat_json_free (&node);
3596 vam->retval = ntohl (mp->retval);
3597 vam->result_ready = 1;
3600 /* Format hex dump. */
3602 format_hex_bytes (u8 * s, va_list * va)
3604 u8 *bytes = va_arg (*va, u8 *);
3605 int n_bytes = va_arg (*va, int);
3608 /* Print short or long form depending on byte count. */
3609 uword short_form = n_bytes <= 32;
3610 uword indent = format_get_indent (s);
3615 for (i = 0; i < n_bytes; i++)
3617 if (!short_form && (i % 32) == 0)
3618 s = format (s, "%08x: ", i);
3619 s = format (s, "%02x", bytes[i]);
3620 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
3621 s = format (s, "\n%U", format_white_space, indent);
3628 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
3631 vat_main_t *vam = &vat_main;
3632 i32 retval = ntohl (mp->retval);
3635 print (vam->ofp, "classify table info :");
3636 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
3637 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
3638 ntohl (mp->miss_next_index));
3639 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
3640 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
3641 ntohl (mp->match_n_vectors));
3642 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
3643 ntohl (mp->mask_length));
3645 vam->retval = retval;
3646 vam->result_ready = 1;
3650 vl_api_classify_table_info_reply_t_handler_json
3651 (vl_api_classify_table_info_reply_t * mp)
3653 vat_main_t *vam = &vat_main;
3654 vat_json_node_t node;
3656 i32 retval = ntohl (mp->retval);
3659 vat_json_init_object (&node);
3661 vat_json_object_add_int (&node, "sessions",
3662 ntohl (mp->active_sessions));
3663 vat_json_object_add_int (&node, "nexttbl",
3664 ntohl (mp->next_table_index));
3665 vat_json_object_add_int (&node, "nextnode",
3666 ntohl (mp->miss_next_index));
3667 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
3668 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
3669 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
3670 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
3671 ntohl (mp->mask_length), 0);
3672 vat_json_object_add_string_copy (&node, "mask", s);
3674 vat_json_print (vam->ofp, &node);
3675 vat_json_free (&node);
3677 vam->retval = ntohl (mp->retval);
3678 vam->result_ready = 1;
3682 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
3685 vat_main_t *vam = &vat_main;
3687 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
3688 ntohl (mp->hit_next_index), ntohl (mp->advance),
3689 ntohl (mp->opaque_index));
3690 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
3691 ntohl (mp->match_length));
3695 vl_api_classify_session_details_t_handler_json
3696 (vl_api_classify_session_details_t * mp)
3698 vat_main_t *vam = &vat_main;
3699 vat_json_node_t *node = NULL;
3701 if (VAT_JSON_ARRAY != vam->json_tree.type)
3703 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3704 vat_json_init_array (&vam->json_tree);
3706 node = vat_json_array_add (&vam->json_tree);
3708 vat_json_init_object (node);
3709 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
3710 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
3711 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
3713 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
3715 vat_json_object_add_string_copy (node, "match", s);
3718 static void vl_api_pg_create_interface_reply_t_handler
3719 (vl_api_pg_create_interface_reply_t * mp)
3721 vat_main_t *vam = &vat_main;
3723 vam->retval = ntohl (mp->retval);
3724 vam->result_ready = 1;
3727 static void vl_api_pg_create_interface_reply_t_handler_json
3728 (vl_api_pg_create_interface_reply_t * mp)
3730 vat_main_t *vam = &vat_main;
3731 vat_json_node_t node;
3733 i32 retval = ntohl (mp->retval);
3736 vat_json_init_object (&node);
3738 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
3740 vat_json_print (vam->ofp, &node);
3741 vat_json_free (&node);
3743 vam->retval = ntohl (mp->retval);
3744 vam->result_ready = 1;
3747 static void vl_api_policer_classify_details_t_handler
3748 (vl_api_policer_classify_details_t * mp)
3750 vat_main_t *vam = &vat_main;
3752 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
3753 ntohl (mp->table_index));
3756 static void vl_api_policer_classify_details_t_handler_json
3757 (vl_api_policer_classify_details_t * mp)
3759 vat_main_t *vam = &vat_main;
3760 vat_json_node_t *node;
3762 if (VAT_JSON_ARRAY != vam->json_tree.type)
3764 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3765 vat_json_init_array (&vam->json_tree);
3767 node = vat_json_array_add (&vam->json_tree);
3769 vat_json_init_object (node);
3770 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
3771 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
3774 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler
3775 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3777 vat_main_t *vam = &vat_main;
3778 i32 retval = ntohl (mp->retval);
3779 if (vam->async_mode)
3781 vam->async_errors += (retval < 0);
3785 vam->retval = retval;
3786 vam->sw_if_index = ntohl (mp->sw_if_index);
3787 vam->result_ready = 1;
3791 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler_json
3792 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3794 vat_main_t *vam = &vat_main;
3795 vat_json_node_t node;
3797 vat_json_init_object (&node);
3798 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3799 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
3801 vat_json_print (vam->ofp, &node);
3802 vat_json_free (&node);
3804 vam->retval = ntohl (mp->retval);
3805 vam->result_ready = 1;
3808 static void vl_api_flow_classify_details_t_handler
3809 (vl_api_flow_classify_details_t * mp)
3811 vat_main_t *vam = &vat_main;
3813 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
3814 ntohl (mp->table_index));
3817 static void vl_api_flow_classify_details_t_handler_json
3818 (vl_api_flow_classify_details_t * mp)
3820 vat_main_t *vam = &vat_main;
3821 vat_json_node_t *node;
3823 if (VAT_JSON_ARRAY != vam->json_tree.type)
3825 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3826 vat_json_init_array (&vam->json_tree);
3828 node = vat_json_array_add (&vam->json_tree);
3830 vat_json_init_object (node);
3831 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
3832 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
3837 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
3838 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
3839 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
3840 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
3841 #define vl_api_vnet_ip4_nbr_counters_t_endian vl_noop_handler
3842 #define vl_api_vnet_ip4_nbr_counters_t_print vl_noop_handler
3843 #define vl_api_vnet_ip6_nbr_counters_t_endian vl_noop_handler
3844 #define vl_api_vnet_ip6_nbr_counters_t_print vl_noop_handler
3845 #define vl_api_one_adjacencies_get_reply_t_endian vl_noop_handler
3846 #define vl_api_one_adjacencies_get_reply_t_print vl_noop_handler
3849 * Generate boilerplate reply handlers, which
3850 * dig the return value out of the xxx_reply_t API message,
3851 * stick it into vam->retval, and set vam->result_ready
3853 * Could also do this by pointing N message decode slots at
3854 * a single function, but that could break in subtle ways.
3857 #define foreach_standard_reply_retval_handler \
3858 _(sw_interface_set_flags_reply) \
3859 _(sw_interface_add_del_address_reply) \
3860 _(sw_interface_set_table_reply) \
3861 _(sw_interface_set_mpls_enable_reply) \
3862 _(sw_interface_set_vpath_reply) \
3863 _(sw_interface_set_vxlan_bypass_reply) \
3864 _(sw_interface_set_l2_bridge_reply) \
3865 _(bridge_domain_add_del_reply) \
3866 _(sw_interface_set_l2_xconnect_reply) \
3867 _(l2fib_add_del_reply) \
3868 _(ip_add_del_route_reply) \
3869 _(ip_mroute_add_del_reply) \
3870 _(mpls_route_add_del_reply) \
3871 _(mpls_ip_bind_unbind_reply) \
3872 _(proxy_arp_add_del_reply) \
3873 _(proxy_arp_intfc_enable_disable_reply) \
3874 _(sw_interface_set_unnumbered_reply) \
3875 _(ip_neighbor_add_del_reply) \
3876 _(reset_vrf_reply) \
3877 _(oam_add_del_reply) \
3878 _(reset_fib_reply) \
3879 _(dhcp_proxy_config_reply) \
3880 _(dhcp_proxy_set_vss_reply) \
3881 _(dhcp_client_config_reply) \
3882 _(set_ip_flow_hash_reply) \
3883 _(sw_interface_ip6_enable_disable_reply) \
3884 _(sw_interface_ip6_set_link_local_address_reply) \
3885 _(sw_interface_ip6nd_ra_prefix_reply) \
3886 _(sw_interface_ip6nd_ra_config_reply) \
3887 _(set_arp_neighbor_limit_reply) \
3888 _(l2_patch_add_del_reply) \
3889 _(sr_tunnel_add_del_reply) \
3890 _(sr_policy_add_del_reply) \
3891 _(sr_multicast_map_add_del_reply) \
3892 _(classify_add_del_session_reply) \
3893 _(classify_set_interface_ip_table_reply) \
3894 _(classify_set_interface_l2_tables_reply) \
3895 _(l2tpv3_set_tunnel_cookies_reply) \
3896 _(l2tpv3_interface_enable_disable_reply) \
3897 _(l2tpv3_set_lookup_key_reply) \
3898 _(l2_fib_clear_table_reply) \
3899 _(l2_interface_efp_filter_reply) \
3900 _(l2_interface_vlan_tag_rewrite_reply) \
3901 _(modify_vhost_user_if_reply) \
3902 _(delete_vhost_user_if_reply) \
3903 _(want_ip4_arp_events_reply) \
3904 _(want_ip6_nd_events_reply) \
3905 _(input_acl_set_interface_reply) \
3906 _(ipsec_spd_add_del_reply) \
3907 _(ipsec_interface_add_del_spd_reply) \
3908 _(ipsec_spd_add_del_entry_reply) \
3909 _(ipsec_sad_add_del_entry_reply) \
3910 _(ipsec_sa_set_key_reply) \
3911 _(ikev2_profile_add_del_reply) \
3912 _(ikev2_profile_set_auth_reply) \
3913 _(ikev2_profile_set_id_reply) \
3914 _(ikev2_profile_set_ts_reply) \
3915 _(ikev2_set_local_key_reply) \
3916 _(ikev2_set_responder_reply) \
3917 _(ikev2_set_ike_transforms_reply) \
3918 _(ikev2_set_esp_transforms_reply) \
3919 _(ikev2_set_sa_lifetime_reply) \
3920 _(ikev2_initiate_sa_init_reply) \
3921 _(ikev2_initiate_del_ike_sa_reply) \
3922 _(ikev2_initiate_del_child_sa_reply) \
3923 _(ikev2_initiate_rekey_child_sa_reply) \
3924 _(delete_loopback_reply) \
3925 _(bd_ip_mac_add_del_reply) \
3926 _(map_del_domain_reply) \
3927 _(map_add_del_rule_reply) \
3928 _(want_interface_events_reply) \
3929 _(want_stats_reply) \
3930 _(cop_interface_enable_disable_reply) \
3931 _(cop_whitelist_enable_disable_reply) \
3932 _(sw_interface_clear_stats_reply) \
3933 _(ioam_enable_reply) \
3934 _(ioam_disable_reply) \
3935 _(one_add_del_locator_reply) \
3936 _(one_add_del_local_eid_reply) \
3937 _(one_add_del_remote_mapping_reply) \
3938 _(one_add_del_adjacency_reply) \
3939 _(one_add_del_map_resolver_reply) \
3940 _(one_add_del_map_server_reply) \
3941 _(one_enable_disable_reply) \
3942 _(one_rloc_probe_enable_disable_reply) \
3943 _(one_map_register_enable_disable_reply) \
3944 _(one_pitr_set_locator_set_reply) \
3945 _(one_map_request_mode_reply) \
3946 _(one_add_del_map_request_itr_rlocs_reply) \
3947 _(one_eid_table_add_del_map_reply) \
3948 _(gpe_add_del_fwd_entry_reply) \
3949 _(gpe_enable_disable_reply) \
3950 _(gpe_set_encap_mode_reply) \
3951 _(gpe_add_del_iface_reply) \
3952 _(vxlan_gpe_add_del_tunnel_reply) \
3953 _(af_packet_delete_reply) \
3954 _(policer_classify_set_interface_reply) \
3955 _(netmap_create_reply) \
3956 _(netmap_delete_reply) \
3957 _(set_ipfix_exporter_reply) \
3958 _(set_ipfix_classify_stream_reply) \
3959 _(ipfix_classify_table_add_del_reply) \
3960 _(flow_classify_set_interface_reply) \
3961 _(sw_interface_span_enable_disable_reply) \
3962 _(pg_capture_reply) \
3963 _(pg_enable_disable_reply) \
3964 _(ip_source_and_port_range_check_add_del_reply) \
3965 _(ip_source_and_port_range_check_interface_add_del_reply)\
3966 _(delete_subif_reply) \
3967 _(l2_interface_pbb_tag_rewrite_reply) \
3969 _(feature_enable_disable_reply) \
3970 _(sw_interface_tag_add_del_reply) \
3971 _(sw_interface_set_mtu_reply)
3974 static void vl_api_##n##_t_handler \
3975 (vl_api_##n##_t * mp) \
3977 vat_main_t * vam = &vat_main; \
3978 i32 retval = ntohl(mp->retval); \
3979 if (vam->async_mode) { \
3980 vam->async_errors += (retval < 0); \
3982 vam->retval = retval; \
3983 vam->result_ready = 1; \
3986 foreach_standard_reply_retval_handler;
3990 static void vl_api_##n##_t_handler_json \
3991 (vl_api_##n##_t * mp) \
3993 vat_main_t * vam = &vat_main; \
3994 vat_json_node_t node; \
3995 vat_json_init_object(&node); \
3996 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
3997 vat_json_print(vam->ofp, &node); \
3998 vam->retval = ntohl(mp->retval); \
3999 vam->result_ready = 1; \
4001 foreach_standard_reply_retval_handler;
4005 * Table of message reply handlers, must include boilerplate handlers
4009 #define foreach_vpe_api_reply_msg \
4010 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
4011 _(SW_INTERFACE_DETAILS, sw_interface_details) \
4012 _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
4013 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
4014 _(CONTROL_PING_REPLY, control_ping_reply) \
4015 _(CLI_REPLY, cli_reply) \
4016 _(CLI_INBAND_REPLY, cli_inband_reply) \
4017 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
4018 sw_interface_add_del_address_reply) \
4019 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
4020 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
4021 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
4022 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
4023 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
4024 sw_interface_set_l2_xconnect_reply) \
4025 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
4026 sw_interface_set_l2_bridge_reply) \
4027 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
4028 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
4029 _(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
4030 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
4031 _(L2_FLAGS_REPLY, l2_flags_reply) \
4032 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
4033 _(TAP_CONNECT_REPLY, tap_connect_reply) \
4034 _(TAP_MODIFY_REPLY, tap_modify_reply) \
4035 _(TAP_DELETE_REPLY, tap_delete_reply) \
4036 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
4037 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
4038 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
4039 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
4040 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
4041 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
4042 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
4043 proxy_arp_intfc_enable_disable_reply) \
4044 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
4045 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
4046 sw_interface_set_unnumbered_reply) \
4047 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
4048 _(RESET_VRF_REPLY, reset_vrf_reply) \
4049 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
4050 _(CREATE_SUBIF_REPLY, create_subif_reply) \
4051 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
4052 _(RESET_FIB_REPLY, reset_fib_reply) \
4053 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
4054 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
4055 _(DHCP_PROXY_DETAILS, dhcp_proxy_details) \
4056 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
4057 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
4058 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
4059 sw_interface_ip6_enable_disable_reply) \
4060 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
4061 sw_interface_ip6_set_link_local_address_reply) \
4062 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
4063 sw_interface_ip6nd_ra_prefix_reply) \
4064 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
4065 sw_interface_ip6nd_ra_config_reply) \
4066 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
4067 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
4068 _(SR_TUNNEL_ADD_DEL_REPLY, sr_tunnel_add_del_reply) \
4069 _(SR_POLICY_ADD_DEL_REPLY, sr_policy_add_del_reply) \
4070 _(SR_MULTICAST_MAP_ADD_DEL_REPLY, sr_multicast_map_add_del_reply) \
4071 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
4072 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
4073 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
4074 classify_set_interface_ip_table_reply) \
4075 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
4076 classify_set_interface_l2_tables_reply) \
4077 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
4078 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
4079 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
4080 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
4081 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
4082 l2tpv3_interface_enable_disable_reply) \
4083 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
4084 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
4085 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
4086 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
4087 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
4088 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
4089 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
4090 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
4091 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
4092 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
4093 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
4094 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
4095 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
4096 _(SHOW_VERSION_REPLY, show_version_reply) \
4097 _(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
4098 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
4099 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
4100 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
4101 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
4102 _(IP4_ARP_EVENT, ip4_arp_event) \
4103 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
4104 _(IP6_ND_EVENT, ip6_nd_event) \
4105 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
4106 _(IP_ADDRESS_DETAILS, ip_address_details) \
4107 _(IP_DETAILS, ip_details) \
4108 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
4109 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
4110 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
4111 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
4112 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
4113 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
4114 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
4115 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
4116 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
4117 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
4118 _(IKEV2_SET_RESPONDER_REPLY, ikev2_set_responder_reply) \
4119 _(IKEV2_SET_IKE_TRANSFORMS_REPLY, ikev2_set_ike_transforms_reply) \
4120 _(IKEV2_SET_ESP_TRANSFORMS_REPLY, ikev2_set_esp_transforms_reply) \
4121 _(IKEV2_SET_SA_LIFETIME_REPLY, ikev2_set_sa_lifetime_reply) \
4122 _(IKEV2_INITIATE_SA_INIT_REPLY, ikev2_initiate_sa_init_reply) \
4123 _(IKEV2_INITIATE_DEL_IKE_SA_REPLY, ikev2_initiate_del_ike_sa_reply) \
4124 _(IKEV2_INITIATE_DEL_CHILD_SA_REPLY, ikev2_initiate_del_child_sa_reply) \
4125 _(IKEV2_INITIATE_REKEY_CHILD_SA_REPLY, ikev2_initiate_rekey_child_sa_reply) \
4126 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
4127 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
4128 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
4129 _(VNET_INTERFACE_COUNTERS, vnet_interface_counters) \
4130 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
4131 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
4132 _(VNET_IP4_NBR_COUNTERS, vnet_ip4_nbr_counters) \
4133 _(VNET_IP6_NBR_COUNTERS, vnet_ip6_nbr_counters) \
4134 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
4135 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
4136 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
4137 _(MAP_DOMAIN_DETAILS, map_domain_details) \
4138 _(MAP_RULE_DETAILS, map_rule_details) \
4139 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
4140 _(WANT_STATS_REPLY, want_stats_reply) \
4141 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
4142 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
4143 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
4144 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
4145 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
4146 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
4147 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
4148 _(ONE_ADD_DEL_LOCATOR_SET_REPLY, one_add_del_locator_set_reply) \
4149 _(ONE_ADD_DEL_LOCATOR_REPLY, one_add_del_locator_reply) \
4150 _(ONE_ADD_DEL_LOCAL_EID_REPLY, one_add_del_local_eid_reply) \
4151 _(ONE_ADD_DEL_REMOTE_MAPPING_REPLY, one_add_del_remote_mapping_reply) \
4152 _(ONE_ADD_DEL_ADJACENCY_REPLY, one_add_del_adjacency_reply) \
4153 _(ONE_ADD_DEL_MAP_RESOLVER_REPLY, one_add_del_map_resolver_reply) \
4154 _(ONE_ADD_DEL_MAP_SERVER_REPLY, one_add_del_map_server_reply) \
4155 _(ONE_ENABLE_DISABLE_REPLY, one_enable_disable_reply) \
4156 _(ONE_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
4157 one_map_register_enable_disable_reply) \
4158 _(ONE_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
4159 one_rloc_probe_enable_disable_reply) \
4160 _(ONE_PITR_SET_LOCATOR_SET_REPLY, one_pitr_set_locator_set_reply) \
4161 _(ONE_MAP_REQUEST_MODE_REPLY, one_map_request_mode_reply) \
4162 _(ONE_EID_TABLE_ADD_DEL_MAP_REPLY, one_eid_table_add_del_map_reply) \
4163 _(ONE_LOCATOR_SET_DETAILS, one_locator_set_details) \
4164 _(ONE_LOCATOR_DETAILS, one_locator_details) \
4165 _(ONE_EID_TABLE_DETAILS, one_eid_table_details) \
4166 _(ONE_EID_TABLE_MAP_DETAILS, one_eid_table_map_details) \
4167 _(ONE_EID_TABLE_VNI_DETAILS, one_eid_table_vni_details) \
4168 _(ONE_MAP_RESOLVER_DETAILS, one_map_resolver_details) \
4169 _(ONE_MAP_SERVER_DETAILS, one_map_server_details) \
4170 _(ONE_ADJACENCIES_GET_REPLY, one_adjacencies_get_reply) \
4171 _(GPE_SET_ENCAP_MODE_REPLY, gpe_set_encap_mode_reply) \
4172 _(GPE_GET_ENCAP_MODE_REPLY, gpe_get_encap_mode_reply) \
4173 _(GPE_ADD_DEL_IFACE_REPLY, gpe_add_del_iface_reply) \
4174 _(GPE_ENABLE_DISABLE_REPLY, gpe_enable_disable_reply) \
4175 _(GPE_ADD_DEL_FWD_ENTRY_REPLY, gpe_add_del_fwd_entry_reply) \
4176 _(GPE_FWD_ENTRIES_GET_REPLY, gpe_fwd_entries_get_reply) \
4177 _(GPE_FWD_ENTRY_PATH_DETAILS, \
4178 gpe_fwd_entry_path_details) \
4179 _(SHOW_ONE_STATUS_REPLY, show_one_status_reply) \
4180 _(ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
4181 one_add_del_map_request_itr_rlocs_reply) \
4182 _(ONE_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
4183 one_get_map_request_itr_rlocs_reply) \
4184 _(SHOW_ONE_PITR_REPLY, show_one_pitr_reply) \
4185 _(SHOW_ONE_MAP_REQUEST_MODE_REPLY, show_one_map_request_mode_reply) \
4186 _(SHOW_ONE_RLOC_PROBE_STATE_REPLY, show_one_rloc_probe_state_reply) \
4187 _(SHOW_ONE_MAP_REGISTER_STATE_REPLY, \
4188 show_one_map_register_state_reply) \
4189 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
4190 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
4191 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
4192 _(POLICER_DETAILS, policer_details) \
4193 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
4194 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
4195 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
4196 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
4197 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
4198 _(MPLS_FIB_DETAILS, mpls_fib_details) \
4199 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
4200 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
4201 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
4202 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
4203 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
4204 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
4205 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
4206 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
4207 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
4208 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
4209 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
4210 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
4211 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
4212 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
4213 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
4214 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
4215 _(PG_CAPTURE_REPLY, pg_capture_reply) \
4216 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
4217 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
4218 ip_source_and_port_range_check_add_del_reply) \
4219 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
4220 ip_source_and_port_range_check_interface_add_del_reply) \
4221 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
4222 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
4223 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
4224 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
4225 _(PUNT_REPLY, punt_reply) \
4226 _(IP_FIB_DETAILS, ip_fib_details) \
4227 _(IP6_FIB_DETAILS, ip6_fib_details) \
4228 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
4229 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
4230 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
4231 _(SW_INTERFACE_SET_MTU_REPLY, sw_interface_set_mtu_reply) \
4232 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
4233 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply)
4242 #define STR_VTR_OP_CASE(op) \
4243 case L2_VTR_ ## op: \
4247 str_vtr_op (u32 vtr_op)
4251 STR_VTR_OP_CASE (DISABLED);
4252 STR_VTR_OP_CASE (PUSH_1);
4253 STR_VTR_OP_CASE (PUSH_2);
4254 STR_VTR_OP_CASE (POP_1);
4255 STR_VTR_OP_CASE (POP_2);
4256 STR_VTR_OP_CASE (TRANSLATE_1_1);
4257 STR_VTR_OP_CASE (TRANSLATE_1_2);
4258 STR_VTR_OP_CASE (TRANSLATE_2_1);
4259 STR_VTR_OP_CASE (TRANSLATE_2_2);
4266 dump_sub_interface_table (vat_main_t * vam)
4268 const sw_interface_subif_t *sub = NULL;
4270 if (vam->json_output)
4273 ("JSON output supported only for VPE API calls and dump_stats_table");
4278 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
4279 "Interface", "sw_if_index",
4280 "sub id", "dot1ad", "tags", "outer id",
4281 "inner id", "exact", "default", "outer any", "inner any");
4283 vec_foreach (sub, vam->sw_if_subif_table)
4286 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
4287 sub->interface_name,
4289 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
4290 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
4291 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
4292 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
4293 if (sub->vtr_op != L2_VTR_DISABLED)
4296 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
4297 "tag1: %d tag2: %d ]",
4298 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
4299 sub->vtr_tag1, sub->vtr_tag2);
4307 name_sort_cmp (void *a1, void *a2)
4309 name_sort_t *n1 = a1;
4310 name_sort_t *n2 = a2;
4312 return strcmp ((char *) n1->name, (char *) n2->name);
4316 dump_interface_table (vat_main_t * vam)
4319 name_sort_t *nses = 0, *ns;
4321 if (vam->json_output)
4324 ("JSON output supported only for VPE API calls and dump_stats_table");
4329 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4331 vec_add2 (nses, ns, 1);
4332 ns->name = (u8 *)(p->key);
4333 ns->value = (u32) p->value[0];
4337 vec_sort_with_function (nses, name_sort_cmp);
4339 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
4340 vec_foreach (ns, nses)
4342 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
4349 dump_ip_table (vat_main_t * vam, int is_ipv6)
4351 const ip_details_t *det = NULL;
4352 const ip_address_details_t *address = NULL;
4355 print (vam->ofp, "%-12s", "sw_if_index");
4357 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
4364 print (vam->ofp, "%-12d", i);
4365 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
4370 vec_foreach (address, det->addr)
4374 is_ipv6 ? format_ip6_address : format_ip4_address,
4375 address->ip, address->prefix_length);
4383 dump_ipv4_table (vat_main_t * vam)
4385 if (vam->json_output)
4388 ("JSON output supported only for VPE API calls and dump_stats_table");
4392 return dump_ip_table (vam, 0);
4396 dump_ipv6_table (vat_main_t * vam)
4398 if (vam->json_output)
4401 ("JSON output supported only for VPE API calls and dump_stats_table");
4405 return dump_ip_table (vam, 1);
4409 counter_type_to_str (u8 counter_type, u8 is_combined)
4413 switch (counter_type)
4415 case VNET_INTERFACE_COUNTER_DROP:
4417 case VNET_INTERFACE_COUNTER_PUNT:
4419 case VNET_INTERFACE_COUNTER_IP4:
4421 case VNET_INTERFACE_COUNTER_IP6:
4423 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
4425 case VNET_INTERFACE_COUNTER_RX_MISS:
4427 case VNET_INTERFACE_COUNTER_RX_ERROR:
4429 case VNET_INTERFACE_COUNTER_TX_ERROR:
4432 return "INVALID-COUNTER-TYPE";
4437 switch (counter_type)
4439 case VNET_INTERFACE_COUNTER_RX:
4441 case VNET_INTERFACE_COUNTER_TX:
4444 return "INVALID-COUNTER-TYPE";
4450 dump_stats_table (vat_main_t * vam)
4452 vat_json_node_t node;
4453 vat_json_node_t *msg_array;
4454 vat_json_node_t *msg;
4455 vat_json_node_t *counter_array;
4456 vat_json_node_t *counter;
4457 interface_counter_t c;
4459 ip4_fib_counter_t *c4;
4460 ip6_fib_counter_t *c6;
4461 ip4_nbr_counter_t *n4;
4462 ip6_nbr_counter_t *n6;
4465 if (!vam->json_output)
4467 clib_warning ("dump_stats_table supported only in JSON format");
4471 vat_json_init_object (&node);
4473 /* interface counters */
4474 msg_array = vat_json_object_add (&node, "interface_counters");
4475 vat_json_init_array (msg_array);
4476 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
4478 msg = vat_json_array_add (msg_array);
4479 vat_json_init_object (msg);
4480 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4481 (u8 *) counter_type_to_str (i, 0));
4482 vat_json_object_add_int (msg, "is_combined", 0);
4483 counter_array = vat_json_object_add (msg, "data");
4484 vat_json_init_array (counter_array);
4485 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
4487 packets = vam->simple_interface_counters[i][j];
4488 vat_json_array_add_uint (counter_array, packets);
4491 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
4493 msg = vat_json_array_add (msg_array);
4494 vat_json_init_object (msg);
4495 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4496 (u8 *) counter_type_to_str (i, 1));
4497 vat_json_object_add_int (msg, "is_combined", 1);
4498 counter_array = vat_json_object_add (msg, "data");
4499 vat_json_init_array (counter_array);
4500 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
4502 c = vam->combined_interface_counters[i][j];
4503 counter = vat_json_array_add (counter_array);
4504 vat_json_init_object (counter);
4505 vat_json_object_add_uint (counter, "packets", c.packets);
4506 vat_json_object_add_uint (counter, "bytes", c.bytes);
4510 /* ip4 fib counters */
4511 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
4512 vat_json_init_array (msg_array);
4513 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
4515 msg = vat_json_array_add (msg_array);
4516 vat_json_init_object (msg);
4517 vat_json_object_add_uint (msg, "vrf_id",
4518 vam->ip4_fib_counters_vrf_id_by_index[i]);
4519 counter_array = vat_json_object_add (msg, "c");
4520 vat_json_init_array (counter_array);
4521 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
4523 counter = vat_json_array_add (counter_array);
4524 vat_json_init_object (counter);
4525 c4 = &vam->ip4_fib_counters[i][j];
4526 vat_json_object_add_ip4 (counter, "address", c4->address);
4527 vat_json_object_add_uint (counter, "address_length",
4528 c4->address_length);
4529 vat_json_object_add_uint (counter, "packets", c4->packets);
4530 vat_json_object_add_uint (counter, "bytes", c4->bytes);
4534 /* ip6 fib counters */
4535 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
4536 vat_json_init_array (msg_array);
4537 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
4539 msg = vat_json_array_add (msg_array);
4540 vat_json_init_object (msg);
4541 vat_json_object_add_uint (msg, "vrf_id",
4542 vam->ip6_fib_counters_vrf_id_by_index[i]);
4543 counter_array = vat_json_object_add (msg, "c");
4544 vat_json_init_array (counter_array);
4545 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
4547 counter = vat_json_array_add (counter_array);
4548 vat_json_init_object (counter);
4549 c6 = &vam->ip6_fib_counters[i][j];
4550 vat_json_object_add_ip6 (counter, "address", c6->address);
4551 vat_json_object_add_uint (counter, "address_length",
4552 c6->address_length);
4553 vat_json_object_add_uint (counter, "packets", c6->packets);
4554 vat_json_object_add_uint (counter, "bytes", c6->bytes);
4558 /* ip4 nbr counters */
4559 msg_array = vat_json_object_add (&node, "ip4_nbr_counters");
4560 vat_json_init_array (msg_array);
4561 for (i = 0; i < vec_len (vam->ip4_nbr_counters); i++)
4563 msg = vat_json_array_add (msg_array);
4564 vat_json_init_object (msg);
4565 vat_json_object_add_uint (msg, "sw_if_index", i);
4566 counter_array = vat_json_object_add (msg, "c");
4567 vat_json_init_array (counter_array);
4568 for (j = 0; j < vec_len (vam->ip4_nbr_counters[i]); j++)
4570 counter = vat_json_array_add (counter_array);
4571 vat_json_init_object (counter);
4572 n4 = &vam->ip4_nbr_counters[i][j];
4573 vat_json_object_add_ip4 (counter, "address", n4->address);
4574 vat_json_object_add_uint (counter, "link-type", n4->linkt);
4575 vat_json_object_add_uint (counter, "packets", n4->packets);
4576 vat_json_object_add_uint (counter, "bytes", n4->bytes);
4580 /* ip6 nbr counters */
4581 msg_array = vat_json_object_add (&node, "ip6_nbr_counters");
4582 vat_json_init_array (msg_array);
4583 for (i = 0; i < vec_len (vam->ip6_nbr_counters); i++)
4585 msg = vat_json_array_add (msg_array);
4586 vat_json_init_object (msg);
4587 vat_json_object_add_uint (msg, "sw_if_index", i);
4588 counter_array = vat_json_object_add (msg, "c");
4589 vat_json_init_array (counter_array);
4590 for (j = 0; j < vec_len (vam->ip6_nbr_counters[i]); j++)
4592 counter = vat_json_array_add (counter_array);
4593 vat_json_init_object (counter);
4594 n6 = &vam->ip6_nbr_counters[i][j];
4595 vat_json_object_add_ip6 (counter, "address", n6->address);
4596 vat_json_object_add_uint (counter, "packets", n6->packets);
4597 vat_json_object_add_uint (counter, "bytes", n6->bytes);
4601 vat_json_print (vam->ofp, &node);
4602 vat_json_free (&node);
4608 exec (vat_main_t * vam)
4610 api_main_t *am = &api_main;
4611 vl_api_cli_request_t *mp;
4615 unformat_input_t *i = vam->input;
4617 if (vec_len (i->buffer) == 0)
4620 if (vam->exec_mode == 0 && unformat (i, "mode"))
4625 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4632 M (CLI_REQUEST, mp);
4635 * Copy cmd into shared memory.
4636 * In order for the CLI command to work, it
4637 * must be a vector ending in \n, not a C-string ending
4640 pthread_mutex_lock (&am->vlib_rp->mutex);
4641 oldheap = svm_push_data_heap (am->vlib_rp);
4643 vec_validate (cmd, vec_len (vam->input->buffer) - 1);
4644 clib_memcpy (cmd, vam->input->buffer, vec_len (vam->input->buffer));
4646 svm_pop_heap (oldheap);
4647 pthread_mutex_unlock (&am->vlib_rp->mutex);
4649 mp->cmd_in_shmem = (u64) cmd;
4651 timeout = vat_time_now (vam) + 10.0;
4653 while (vat_time_now (vam) < timeout)
4655 if (vam->result_ready == 1)
4658 if (vam->shmem_result != NULL)
4659 print (vam->ofp, "%s", vam->shmem_result);
4660 pthread_mutex_lock (&am->vlib_rp->mutex);
4661 oldheap = svm_push_data_heap (am->vlib_rp);
4663 free_me = (u8 *) vam->shmem_result;
4666 svm_pop_heap (oldheap);
4667 pthread_mutex_unlock (&am->vlib_rp->mutex);
4675 * Future replacement of exec() that passes CLI buffers directly in
4676 * the API messages instead of an additional shared memory area.
4679 exec_inband (vat_main_t * vam)
4681 vl_api_cli_inband_t *mp;
4682 unformat_input_t *i = vam->input;
4685 if (vec_len (i->buffer) == 0)
4688 if (vam->exec_mode == 0 && unformat (i, "mode"))
4693 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4700 * In order for the CLI command to work, it
4701 * must be a vector ending in \n, not a C-string ending
4704 u32 len = vec_len (vam->input->buffer);
4705 M2 (CLI_INBAND, mp, len);
4706 clib_memcpy (mp->cmd, vam->input->buffer, len);
4707 mp->length = htonl (len);
4710 W2 (ret, print (vam->ofp, "%s", vam->cmd_reply));
4715 api_create_loopback (vat_main_t * vam)
4717 unformat_input_t *i = vam->input;
4718 vl_api_create_loopback_t *mp;
4723 memset (mac_address, 0, sizeof (mac_address));
4725 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4727 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
4733 /* Construct the API message */
4734 M (CREATE_LOOPBACK, mp);
4736 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
4744 api_delete_loopback (vat_main_t * vam)
4746 unformat_input_t *i = vam->input;
4747 vl_api_delete_loopback_t *mp;
4748 u32 sw_if_index = ~0;
4751 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4753 if (unformat (i, "sw_if_index %d", &sw_if_index))
4759 if (sw_if_index == ~0)
4761 errmsg ("missing sw_if_index");
4765 /* Construct the API message */
4766 M (DELETE_LOOPBACK, mp);
4767 mp->sw_if_index = ntohl (sw_if_index);
4775 api_want_stats (vat_main_t * vam)
4777 unformat_input_t *i = vam->input;
4778 vl_api_want_stats_t *mp;
4782 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4784 if (unformat (i, "enable"))
4786 else if (unformat (i, "disable"))
4794 errmsg ("missing enable|disable");
4799 mp->enable_disable = enable;
4807 api_want_interface_events (vat_main_t * vam)
4809 unformat_input_t *i = vam->input;
4810 vl_api_want_interface_events_t *mp;
4814 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4816 if (unformat (i, "enable"))
4818 else if (unformat (i, "disable"))
4826 errmsg ("missing enable|disable");
4830 M (WANT_INTERFACE_EVENTS, mp);
4831 mp->enable_disable = enable;
4833 vam->interface_event_display = enable;
4841 /* Note: non-static, called once to set up the initial intfc table */
4843 api_sw_interface_dump (vat_main_t * vam)
4845 vl_api_sw_interface_dump_t *mp;
4846 vl_api_control_ping_t *mp_ping;
4848 name_sort_t *nses = 0, *ns;
4849 sw_interface_subif_t *sub = NULL;
4852 /* Toss the old name table */
4854 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4856 vec_add2 (nses, ns, 1);
4857 ns->name = (u8 *)(p->key);
4858 ns->value = (u32) p->value[0];
4862 hash_free (vam->sw_if_index_by_interface_name);
4864 vec_foreach (ns, nses) vec_free (ns->name);
4868 vec_foreach (sub, vam->sw_if_subif_table)
4870 vec_free (sub->interface_name);
4872 vec_free (vam->sw_if_subif_table);
4874 /* recreate the interface name hash table */
4875 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
4877 /* Get list of ethernets */
4878 M (SW_INTERFACE_DUMP, mp);
4879 mp->name_filter_valid = 1;
4880 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
4883 /* and local / loopback interfaces */
4884 M (SW_INTERFACE_DUMP, mp);
4885 mp->name_filter_valid = 1;
4886 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
4889 /* and packet-generator interfaces */
4890 M (SW_INTERFACE_DUMP, mp);
4891 mp->name_filter_valid = 1;
4892 strncpy ((char *) mp->name_filter, "pg", sizeof (mp->name_filter) - 1);
4895 /* and vxlan-gpe tunnel interfaces */
4896 M (SW_INTERFACE_DUMP, mp);
4897 mp->name_filter_valid = 1;
4898 strncpy ((char *) mp->name_filter, "vxlan_gpe",
4899 sizeof (mp->name_filter) - 1);
4902 /* and vxlan tunnel interfaces */
4903 M (SW_INTERFACE_DUMP, mp);
4904 mp->name_filter_valid = 1;
4905 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
4908 /* and host (af_packet) interfaces */
4909 M (SW_INTERFACE_DUMP, mp);
4910 mp->name_filter_valid = 1;
4911 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
4914 /* and l2tpv3 tunnel interfaces */
4915 M (SW_INTERFACE_DUMP, mp);
4916 mp->name_filter_valid = 1;
4917 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
4918 sizeof (mp->name_filter) - 1);
4921 /* and GRE tunnel interfaces */
4922 M (SW_INTERFACE_DUMP, mp);
4923 mp->name_filter_valid = 1;
4924 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
4927 /* and LISP-GPE interfaces */
4928 M (SW_INTERFACE_DUMP, mp);
4929 mp->name_filter_valid = 1;
4930 strncpy ((char *) mp->name_filter, "lisp_gpe",
4931 sizeof (mp->name_filter) - 1);
4934 /* and IPSEC tunnel interfaces */
4935 M (SW_INTERFACE_DUMP, mp);
4936 mp->name_filter_valid = 1;
4937 strncpy ((char *) mp->name_filter, "ipsec", sizeof (mp->name_filter) - 1);
4940 /* Use a control ping for synchronization */
4941 M (CONTROL_PING, mp_ping);
4949 api_sw_interface_set_flags (vat_main_t * vam)
4951 unformat_input_t *i = vam->input;
4952 vl_api_sw_interface_set_flags_t *mp;
4954 u8 sw_if_index_set = 0;
4955 u8 admin_up = 0, link_up = 0;
4958 /* Parse args required to build the message */
4959 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4961 if (unformat (i, "admin-up"))
4963 else if (unformat (i, "admin-down"))
4965 else if (unformat (i, "link-up"))
4967 else if (unformat (i, "link-down"))
4970 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4971 sw_if_index_set = 1;
4972 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4973 sw_if_index_set = 1;
4978 if (sw_if_index_set == 0)
4980 errmsg ("missing interface name or sw_if_index");
4984 /* Construct the API message */
4985 M (SW_INTERFACE_SET_FLAGS, mp);
4986 mp->sw_if_index = ntohl (sw_if_index);
4987 mp->admin_up_down = admin_up;
4988 mp->link_up_down = link_up;
4993 /* Wait for a reply, return the good/bad news... */
4999 api_sw_interface_clear_stats (vat_main_t * vam)
5001 unformat_input_t *i = vam->input;
5002 vl_api_sw_interface_clear_stats_t *mp;
5004 u8 sw_if_index_set = 0;
5007 /* Parse args required to build the message */
5008 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5010 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5011 sw_if_index_set = 1;
5012 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5013 sw_if_index_set = 1;
5018 /* Construct the API message */
5019 M (SW_INTERFACE_CLEAR_STATS, mp);
5021 if (sw_if_index_set == 1)
5022 mp->sw_if_index = ntohl (sw_if_index);
5024 mp->sw_if_index = ~0;
5029 /* Wait for a reply, return the good/bad news... */
5035 api_sw_interface_add_del_address (vat_main_t * vam)
5037 unformat_input_t *i = vam->input;
5038 vl_api_sw_interface_add_del_address_t *mp;
5040 u8 sw_if_index_set = 0;
5041 u8 is_add = 1, del_all = 0;
5042 u32 address_length = 0;
5043 u8 v4_address_set = 0;
5044 u8 v6_address_set = 0;
5045 ip4_address_t v4address;
5046 ip6_address_t v6address;
5049 /* Parse args required to build the message */
5050 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5052 if (unformat (i, "del-all"))
5054 else if (unformat (i, "del"))
5057 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5058 sw_if_index_set = 1;
5059 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5060 sw_if_index_set = 1;
5061 else if (unformat (i, "%U/%d",
5062 unformat_ip4_address, &v4address, &address_length))
5064 else if (unformat (i, "%U/%d",
5065 unformat_ip6_address, &v6address, &address_length))
5071 if (sw_if_index_set == 0)
5073 errmsg ("missing interface name or sw_if_index");
5076 if (v4_address_set && v6_address_set)
5078 errmsg ("both v4 and v6 addresses set");
5081 if (!v4_address_set && !v6_address_set && !del_all)
5083 errmsg ("no addresses set");
5087 /* Construct the API message */
5088 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
5090 mp->sw_if_index = ntohl (sw_if_index);
5091 mp->is_add = is_add;
5092 mp->del_all = del_all;
5096 clib_memcpy (mp->address, &v6address, sizeof (v6address));
5100 clib_memcpy (mp->address, &v4address, sizeof (v4address));
5102 mp->address_length = address_length;
5107 /* Wait for a reply, return good/bad news */
5113 api_sw_interface_set_mpls_enable (vat_main_t * vam)
5115 unformat_input_t *i = vam->input;
5116 vl_api_sw_interface_set_mpls_enable_t *mp;
5118 u8 sw_if_index_set = 0;
5122 /* Parse args required to build the message */
5123 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5125 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5126 sw_if_index_set = 1;
5127 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5128 sw_if_index_set = 1;
5129 else if (unformat (i, "disable"))
5131 else if (unformat (i, "dis"))
5137 if (sw_if_index_set == 0)
5139 errmsg ("missing interface name or sw_if_index");
5143 /* Construct the API message */
5144 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
5146 mp->sw_if_index = ntohl (sw_if_index);
5147 mp->enable = enable;
5152 /* Wait for a reply... */
5158 api_sw_interface_set_table (vat_main_t * vam)
5160 unformat_input_t *i = vam->input;
5161 vl_api_sw_interface_set_table_t *mp;
5162 u32 sw_if_index, vrf_id = 0;
5163 u8 sw_if_index_set = 0;
5167 /* Parse args required to build the message */
5168 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5170 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5171 sw_if_index_set = 1;
5172 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5173 sw_if_index_set = 1;
5174 else if (unformat (i, "vrf %d", &vrf_id))
5176 else if (unformat (i, "ipv6"))
5182 if (sw_if_index_set == 0)
5184 errmsg ("missing interface name or sw_if_index");
5188 /* Construct the API message */
5189 M (SW_INTERFACE_SET_TABLE, mp);
5191 mp->sw_if_index = ntohl (sw_if_index);
5192 mp->is_ipv6 = is_ipv6;
5193 mp->vrf_id = ntohl (vrf_id);
5198 /* Wait for a reply... */
5203 static void vl_api_sw_interface_get_table_reply_t_handler
5204 (vl_api_sw_interface_get_table_reply_t * mp)
5206 vat_main_t *vam = &vat_main;
5208 print (vam->ofp, "%d", ntohl (mp->vrf_id));
5210 vam->retval = ntohl (mp->retval);
5211 vam->result_ready = 1;
5215 static void vl_api_sw_interface_get_table_reply_t_handler_json
5216 (vl_api_sw_interface_get_table_reply_t * mp)
5218 vat_main_t *vam = &vat_main;
5219 vat_json_node_t node;
5221 vat_json_init_object (&node);
5222 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
5223 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
5225 vat_json_print (vam->ofp, &node);
5226 vat_json_free (&node);
5228 vam->retval = ntohl (mp->retval);
5229 vam->result_ready = 1;
5233 api_sw_interface_get_table (vat_main_t * vam)
5235 unformat_input_t *i = vam->input;
5236 vl_api_sw_interface_get_table_t *mp;
5238 u8 sw_if_index_set = 0;
5242 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5244 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5245 sw_if_index_set = 1;
5246 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5247 sw_if_index_set = 1;
5248 else if (unformat (i, "ipv6"))
5254 if (sw_if_index_set == 0)
5256 errmsg ("missing interface name or sw_if_index");
5260 M (SW_INTERFACE_GET_TABLE, mp);
5261 mp->sw_if_index = htonl (sw_if_index);
5262 mp->is_ipv6 = is_ipv6;
5270 api_sw_interface_set_vpath (vat_main_t * vam)
5272 unformat_input_t *i = vam->input;
5273 vl_api_sw_interface_set_vpath_t *mp;
5274 u32 sw_if_index = 0;
5275 u8 sw_if_index_set = 0;
5279 /* Parse args required to build the message */
5280 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5282 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5283 sw_if_index_set = 1;
5284 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5285 sw_if_index_set = 1;
5286 else if (unformat (i, "enable"))
5288 else if (unformat (i, "disable"))
5294 if (sw_if_index_set == 0)
5296 errmsg ("missing interface name or sw_if_index");
5300 /* Construct the API message */
5301 M (SW_INTERFACE_SET_VPATH, mp);
5303 mp->sw_if_index = ntohl (sw_if_index);
5304 mp->enable = is_enable;
5309 /* Wait for a reply... */
5315 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
5317 unformat_input_t *i = vam->input;
5318 vl_api_sw_interface_set_vxlan_bypass_t *mp;
5319 u32 sw_if_index = 0;
5320 u8 sw_if_index_set = 0;
5325 /* Parse args required to build the message */
5326 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5328 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5329 sw_if_index_set = 1;
5330 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5331 sw_if_index_set = 1;
5332 else if (unformat (i, "enable"))
5334 else if (unformat (i, "disable"))
5336 else if (unformat (i, "ip4"))
5338 else if (unformat (i, "ip6"))
5344 if (sw_if_index_set == 0)
5346 errmsg ("missing interface name or sw_if_index");
5350 /* Construct the API message */
5351 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
5353 mp->sw_if_index = ntohl (sw_if_index);
5354 mp->enable = is_enable;
5355 mp->is_ipv6 = is_ipv6;
5360 /* Wait for a reply... */
5366 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
5368 unformat_input_t *i = vam->input;
5369 vl_api_sw_interface_set_l2_xconnect_t *mp;
5371 u8 rx_sw_if_index_set = 0;
5373 u8 tx_sw_if_index_set = 0;
5377 /* Parse args required to build the message */
5378 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5380 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
5381 rx_sw_if_index_set = 1;
5382 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5383 tx_sw_if_index_set = 1;
5384 else if (unformat (i, "rx"))
5386 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5388 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
5390 rx_sw_if_index_set = 1;
5395 else if (unformat (i, "tx"))
5397 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5399 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
5401 tx_sw_if_index_set = 1;
5406 else if (unformat (i, "enable"))
5408 else if (unformat (i, "disable"))
5414 if (rx_sw_if_index_set == 0)
5416 errmsg ("missing rx interface name or rx_sw_if_index");
5420 if (enable && (tx_sw_if_index_set == 0))
5422 errmsg ("missing tx interface name or tx_sw_if_index");
5426 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
5428 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5429 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
5430 mp->enable = enable;
5438 api_sw_interface_set_l2_bridge (vat_main_t * vam)
5440 unformat_input_t *i = vam->input;
5441 vl_api_sw_interface_set_l2_bridge_t *mp;
5443 u8 rx_sw_if_index_set = 0;
5451 /* Parse args required to build the message */
5452 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5454 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
5455 rx_sw_if_index_set = 1;
5456 else if (unformat (i, "bd_id %d", &bd_id))
5460 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
5461 rx_sw_if_index_set = 1;
5462 else if (unformat (i, "shg %d", &shg))
5464 else if (unformat (i, "bvi"))
5466 else if (unformat (i, "enable"))
5468 else if (unformat (i, "disable"))
5474 if (rx_sw_if_index_set == 0)
5476 errmsg ("missing rx interface name or sw_if_index");
5480 if (enable && (bd_id_set == 0))
5482 errmsg ("missing bridge domain");
5486 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
5488 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5489 mp->bd_id = ntohl (bd_id);
5492 mp->enable = enable;
5500 api_bridge_domain_dump (vat_main_t * vam)
5502 unformat_input_t *i = vam->input;
5503 vl_api_bridge_domain_dump_t *mp;
5504 vl_api_control_ping_t *mp_ping;
5508 /* Parse args required to build the message */
5509 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5511 if (unformat (i, "bd_id %d", &bd_id))
5517 M (BRIDGE_DOMAIN_DUMP, mp);
5518 mp->bd_id = ntohl (bd_id);
5521 /* Use a control ping for synchronization */
5522 M (CONTROL_PING, mp_ping);
5530 api_bridge_domain_add_del (vat_main_t * vam)
5532 unformat_input_t *i = vam->input;
5533 vl_api_bridge_domain_add_del_t *mp;
5536 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
5540 /* Parse args required to build the message */
5541 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5543 if (unformat (i, "bd_id %d", &bd_id))
5545 else if (unformat (i, "flood %d", &flood))
5547 else if (unformat (i, "uu-flood %d", &uu_flood))
5549 else if (unformat (i, "forward %d", &forward))
5551 else if (unformat (i, "learn %d", &learn))
5553 else if (unformat (i, "arp-term %d", &arp_term))
5555 else if (unformat (i, "mac-age %d", &mac_age))
5557 else if (unformat (i, "del"))
5560 flood = uu_flood = forward = learn = 0;
5568 errmsg ("missing bridge domain");
5574 errmsg ("mac age must be less than 256 ");
5578 M (BRIDGE_DOMAIN_ADD_DEL, mp);
5580 mp->bd_id = ntohl (bd_id);
5582 mp->uu_flood = uu_flood;
5583 mp->forward = forward;
5585 mp->arp_term = arp_term;
5586 mp->is_add = is_add;
5587 mp->mac_age = (u8) mac_age;
5595 api_l2fib_add_del (vat_main_t * vam)
5597 unformat_input_t *i = vam->input;
5598 vl_api_l2fib_add_del_t *mp;
5604 u32 sw_if_index = ~0;
5605 u8 sw_if_index_set = 0;
5614 /* Parse args required to build the message */
5615 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5617 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
5619 else if (unformat (i, "bd_id %d", &bd_id))
5621 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5622 sw_if_index_set = 1;
5623 else if (unformat (i, "sw_if"))
5625 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5628 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5629 sw_if_index_set = 1;
5634 else if (unformat (i, "static"))
5636 else if (unformat (i, "filter"))
5641 else if (unformat (i, "bvi"))
5646 else if (unformat (i, "del"))
5648 else if (unformat (i, "count %d", &count))
5656 errmsg ("missing mac address");
5662 errmsg ("missing bridge domain");
5666 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
5668 errmsg ("missing interface name or sw_if_index");
5674 /* Turn on async mode */
5675 vam->async_mode = 1;
5676 vam->async_errors = 0;
5677 before = vat_time_now (vam);
5680 for (j = 0; j < count; j++)
5682 M (L2FIB_ADD_DEL, mp);
5685 mp->bd_id = ntohl (bd_id);
5686 mp->is_add = is_add;
5690 mp->sw_if_index = ntohl (sw_if_index);
5691 mp->static_mac = static_mac;
5692 mp->filter_mac = filter_mac;
5693 mp->bvi_mac = bvi_mac;
5695 increment_mac_address (&mac);
5702 vl_api_control_ping_t *mp_ping;
5705 /* Shut off async mode */
5706 vam->async_mode = 0;
5708 M (CONTROL_PING, mp_ping);
5711 timeout = vat_time_now (vam) + 1.0;
5712 while (vat_time_now (vam) < timeout)
5713 if (vam->result_ready == 1)
5718 if (vam->retval == -99)
5721 if (vam->async_errors > 0)
5723 errmsg ("%d asynchronous errors", vam->async_errors);
5726 vam->async_errors = 0;
5727 after = vat_time_now (vam);
5729 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
5730 count, after - before, count / (after - before));
5736 /* Wait for a reply... */
5740 /* Return the good/bad news */
5741 return (vam->retval);
5745 api_l2_flags (vat_main_t * vam)
5747 unformat_input_t *i = vam->input;
5748 vl_api_l2_flags_t *mp;
5750 u32 feature_bitmap = 0;
5751 u8 sw_if_index_set = 0;
5754 /* Parse args required to build the message */
5755 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5757 if (unformat (i, "sw_if_index %d", &sw_if_index))
5758 sw_if_index_set = 1;
5759 else if (unformat (i, "sw_if"))
5761 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5764 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5765 sw_if_index_set = 1;
5770 else if (unformat (i, "learn"))
5771 feature_bitmap |= L2INPUT_FEAT_LEARN;
5772 else if (unformat (i, "forward"))
5773 feature_bitmap |= L2INPUT_FEAT_FWD;
5774 else if (unformat (i, "flood"))
5775 feature_bitmap |= L2INPUT_FEAT_FLOOD;
5776 else if (unformat (i, "uu-flood"))
5777 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
5782 if (sw_if_index_set == 0)
5784 errmsg ("missing interface name or sw_if_index");
5790 mp->sw_if_index = ntohl (sw_if_index);
5791 mp->feature_bitmap = ntohl (feature_bitmap);
5799 api_bridge_flags (vat_main_t * vam)
5801 unformat_input_t *i = vam->input;
5802 vl_api_bridge_flags_t *mp;
5809 /* Parse args required to build the message */
5810 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5812 if (unformat (i, "bd_id %d", &bd_id))
5814 else if (unformat (i, "learn"))
5816 else if (unformat (i, "forward"))
5818 else if (unformat (i, "flood"))
5820 else if (unformat (i, "uu-flood"))
5821 flags |= L2_UU_FLOOD;
5822 else if (unformat (i, "arp-term"))
5823 flags |= L2_ARP_TERM;
5824 else if (unformat (i, "off"))
5826 else if (unformat (i, "disable"))
5834 errmsg ("missing bridge domain");
5838 M (BRIDGE_FLAGS, mp);
5840 mp->bd_id = ntohl (bd_id);
5841 mp->feature_bitmap = ntohl (flags);
5842 mp->is_set = is_set;
5850 api_bd_ip_mac_add_del (vat_main_t * vam)
5852 unformat_input_t *i = vam->input;
5853 vl_api_bd_ip_mac_add_del_t *mp;
5860 ip4_address_t v4addr;
5861 ip6_address_t v6addr;
5866 /* Parse args required to build the message */
5867 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5869 if (unformat (i, "bd_id %d", &bd_id))
5873 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
5877 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
5882 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
5886 else if (unformat (i, "del"))
5894 errmsg ("missing bridge domain");
5897 else if (ip_set == 0)
5899 errmsg ("missing IP address");
5902 else if (mac_set == 0)
5904 errmsg ("missing MAC address");
5908 M (BD_IP_MAC_ADD_DEL, mp);
5910 mp->bd_id = ntohl (bd_id);
5911 mp->is_ipv6 = is_ipv6;
5912 mp->is_add = is_add;
5914 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
5916 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
5917 clib_memcpy (mp->mac_address, macaddr, 6);
5924 api_tap_connect (vat_main_t * vam)
5926 unformat_input_t *i = vam->input;
5927 vl_api_tap_connect_t *mp;
5933 ip4_address_t ip4_address;
5935 int ip4_address_set = 0;
5936 ip6_address_t ip6_address;
5938 int ip6_address_set = 0;
5941 memset (mac_address, 0, sizeof (mac_address));
5943 /* Parse args required to build the message */
5944 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5946 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5950 else if (unformat (i, "random-mac"))
5952 else if (unformat (i, "tapname %s", &tap_name))
5954 else if (unformat (i, "tag %s", &tag))
5956 else if (unformat (i, "address %U/%d",
5957 unformat_ip4_address, &ip4_address, &ip4_mask_width))
5958 ip4_address_set = 1;
5959 else if (unformat (i, "address %U/%d",
5960 unformat_ip6_address, &ip6_address, &ip6_mask_width))
5961 ip6_address_set = 1;
5968 errmsg ("missing tap name");
5971 if (vec_len (tap_name) > 63)
5973 errmsg ("tap name too long");
5976 vec_add1 (tap_name, 0);
5978 if (vec_len (tag) > 63)
5980 errmsg ("tag too long");
5984 /* Construct the API message */
5985 M (TAP_CONNECT, mp);
5987 mp->use_random_mac = random_mac;
5988 clib_memcpy (mp->mac_address, mac_address, 6);
5989 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5991 clib_memcpy (mp->tag, tag, vec_len (tag));
5993 if (ip4_address_set)
5995 mp->ip4_address_set = 1;
5996 clib_memcpy (mp->ip4_address, &ip4_address, sizeof (mp->ip4_address));
5997 mp->ip4_mask_width = ip4_mask_width;
5999 if (ip6_address_set)
6001 mp->ip6_address_set = 1;
6002 clib_memcpy (mp->ip6_address, &ip6_address, sizeof (mp->ip6_address));
6003 mp->ip6_mask_width = ip6_mask_width;
6006 vec_free (tap_name);
6012 /* Wait for a reply... */
6018 api_tap_modify (vat_main_t * vam)
6020 unformat_input_t *i = vam->input;
6021 vl_api_tap_modify_t *mp;
6026 u32 sw_if_index = ~0;
6027 u8 sw_if_index_set = 0;
6030 memset (mac_address, 0, sizeof (mac_address));
6032 /* Parse args required to build the message */
6033 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6035 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6036 sw_if_index_set = 1;
6037 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6038 sw_if_index_set = 1;
6039 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6043 else if (unformat (i, "random-mac"))
6045 else if (unformat (i, "tapname %s", &tap_name))
6051 if (sw_if_index_set == 0)
6053 errmsg ("missing vpp interface name");
6058 errmsg ("missing tap name");
6061 if (vec_len (tap_name) > 63)
6063 errmsg ("tap name too long");
6065 vec_add1 (tap_name, 0);
6067 /* Construct the API message */
6070 mp->use_random_mac = random_mac;
6071 mp->sw_if_index = ntohl (sw_if_index);
6072 clib_memcpy (mp->mac_address, mac_address, 6);
6073 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
6074 vec_free (tap_name);
6079 /* Wait for a reply... */
6085 api_tap_delete (vat_main_t * vam)
6087 unformat_input_t *i = vam->input;
6088 vl_api_tap_delete_t *mp;
6089 u32 sw_if_index = ~0;
6090 u8 sw_if_index_set = 0;
6093 /* Parse args required to build the message */
6094 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6096 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6097 sw_if_index_set = 1;
6098 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6099 sw_if_index_set = 1;
6104 if (sw_if_index_set == 0)
6106 errmsg ("missing vpp interface name");
6110 /* Construct the API message */
6113 mp->sw_if_index = ntohl (sw_if_index);
6118 /* Wait for a reply... */
6124 api_ip_add_del_route (vat_main_t * vam)
6126 unformat_input_t *i = vam->input;
6127 vl_api_ip_add_del_route_t *mp;
6128 u32 sw_if_index = ~0, vrf_id = 0;
6130 u8 is_local = 0, is_drop = 0;
6131 u8 is_unreach = 0, is_prohibit = 0;
6132 u8 create_vrf_if_needed = 0;
6134 u32 next_hop_weight = 1;
6136 u8 is_multipath = 0;
6138 u8 address_length_set = 0;
6139 u32 next_hop_table_id = 0;
6140 u32 resolve_attempts = 0;
6141 u32 dst_address_length = 0;
6142 u8 next_hop_set = 0;
6143 ip4_address_t v4_dst_address, v4_next_hop_address;
6144 ip6_address_t v6_dst_address, v6_next_hop_address;
6148 u32 random_add_del = 0;
6149 u32 *random_vector = 0;
6151 u32 random_seed = 0xdeaddabe;
6152 u32 classify_table_index = ~0;
6154 u8 resolve_host = 0, resolve_attached = 0;
6155 mpls_label_t *next_hop_out_label_stack = NULL;
6156 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6157 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
6159 /* Parse args required to build the message */
6160 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6162 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6164 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6166 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
6171 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
6176 else if (unformat (i, "/%d", &dst_address_length))
6178 address_length_set = 1;
6181 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
6182 &v4_next_hop_address))
6186 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
6187 &v6_next_hop_address))
6191 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
6193 else if (unformat (i, "weight %d", &next_hop_weight))
6195 else if (unformat (i, "drop"))
6199 else if (unformat (i, "null-send-unreach"))
6203 else if (unformat (i, "null-send-prohibit"))
6207 else if (unformat (i, "local"))
6211 else if (unformat (i, "classify %d", &classify_table_index))
6215 else if (unformat (i, "del"))
6217 else if (unformat (i, "add"))
6219 else if (unformat (i, "not-last"))
6221 else if (unformat (i, "resolve-via-host"))
6223 else if (unformat (i, "resolve-via-attached"))
6224 resolve_attached = 1;
6225 else if (unformat (i, "multipath"))
6227 else if (unformat (i, "vrf %d", &vrf_id))
6229 else if (unformat (i, "create-vrf"))
6230 create_vrf_if_needed = 1;
6231 else if (unformat (i, "count %d", &count))
6233 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
6235 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6237 else if (unformat (i, "out-label %d", &next_hop_out_label))
6238 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
6239 else if (unformat (i, "via-label %d", &next_hop_via_label))
6241 else if (unformat (i, "random"))
6243 else if (unformat (i, "seed %d", &random_seed))
6247 clib_warning ("parse error '%U'", format_unformat_error, i);
6252 if (!next_hop_set && !is_drop && !is_local &&
6253 !is_classify && !is_unreach && !is_prohibit &&
6254 MPLS_LABEL_INVALID == next_hop_via_label)
6257 ("next hop / local / drop / unreach / prohibit / classify not set");
6261 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
6263 errmsg ("next hop and next-hop via label set");
6266 if (address_set == 0)
6268 errmsg ("missing addresses");
6272 if (address_length_set == 0)
6274 errmsg ("missing address length");
6278 /* Generate a pile of unique, random routes */
6281 u32 this_random_address;
6282 random_hash = hash_create (count, sizeof (uword));
6284 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
6285 for (j = 0; j <= count; j++)
6289 this_random_address = random_u32 (&random_seed);
6290 this_random_address =
6291 clib_host_to_net_u32 (this_random_address);
6293 while (hash_get (random_hash, this_random_address));
6294 vec_add1 (random_vector, this_random_address);
6295 hash_set (random_hash, this_random_address, 1);
6297 hash_free (random_hash);
6298 v4_dst_address.as_u32 = random_vector[0];
6303 /* Turn on async mode */
6304 vam->async_mode = 1;
6305 vam->async_errors = 0;
6306 before = vat_time_now (vam);
6309 for (j = 0; j < count; j++)
6311 /* Construct the API message */
6312 M2 (IP_ADD_DEL_ROUTE, mp,
6313 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
6315 mp->next_hop_sw_if_index = ntohl (sw_if_index);
6316 mp->table_id = ntohl (vrf_id);
6317 mp->create_vrf_if_needed = create_vrf_if_needed;
6319 mp->is_add = is_add;
6320 mp->is_drop = is_drop;
6321 mp->is_unreach = is_unreach;
6322 mp->is_prohibit = is_prohibit;
6323 mp->is_ipv6 = is_ipv6;
6324 mp->is_local = is_local;
6325 mp->is_classify = is_classify;
6326 mp->is_multipath = is_multipath;
6327 mp->is_resolve_host = resolve_host;
6328 mp->is_resolve_attached = resolve_attached;
6329 mp->not_last = not_last;
6330 mp->next_hop_weight = next_hop_weight;
6331 mp->dst_address_length = dst_address_length;
6332 mp->next_hop_table_id = ntohl (next_hop_table_id);
6333 mp->classify_table_index = ntohl (classify_table_index);
6334 mp->next_hop_via_label = ntohl (next_hop_via_label);
6335 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
6336 if (0 != mp->next_hop_n_out_labels)
6338 memcpy (mp->next_hop_out_label_stack,
6339 next_hop_out_label_stack,
6340 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
6341 vec_free (next_hop_out_label_stack);
6346 clib_memcpy (mp->dst_address, &v6_dst_address,
6347 sizeof (v6_dst_address));
6349 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
6350 sizeof (v6_next_hop_address));
6351 increment_v6_address (&v6_dst_address);
6355 clib_memcpy (mp->dst_address, &v4_dst_address,
6356 sizeof (v4_dst_address));
6358 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
6359 sizeof (v4_next_hop_address));
6361 v4_dst_address.as_u32 = random_vector[j + 1];
6363 increment_v4_address (&v4_dst_address);
6367 /* If we receive SIGTERM, stop now... */
6372 /* When testing multiple add/del ops, use a control-ping to sync */
6375 vl_api_control_ping_t *mp_ping;
6379 /* Shut off async mode */
6380 vam->async_mode = 0;
6382 M (CONTROL_PING, mp_ping);
6385 timeout = vat_time_now (vam) + 1.0;
6386 while (vat_time_now (vam) < timeout)
6387 if (vam->result_ready == 1)
6392 if (vam->retval == -99)
6395 if (vam->async_errors > 0)
6397 errmsg ("%d asynchronous errors", vam->async_errors);
6400 vam->async_errors = 0;
6401 after = vat_time_now (vam);
6403 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6407 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6408 count, after - before, count / (after - before));
6414 /* Wait for a reply... */
6419 /* Return the good/bad news */
6420 return (vam->retval);
6424 api_ip_mroute_add_del (vat_main_t * vam)
6426 unformat_input_t *i = vam->input;
6427 vl_api_ip_mroute_add_del_t *mp;
6428 u32 sw_if_index = ~0, vrf_id = 0;
6431 u8 create_vrf_if_needed = 0;
6434 u32 grp_address_length = 0;
6435 ip4_address_t v4_grp_address, v4_src_address;
6436 ip6_address_t v6_grp_address, v6_src_address;
6437 mfib_itf_flags_t iflags = 0;
6438 mfib_entry_flags_t eflags = 0;
6441 /* Parse args required to build the message */
6442 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6444 if (unformat (i, "sw_if_index %d", &sw_if_index))
6446 else if (unformat (i, "%U %U",
6447 unformat_ip4_address, &v4_src_address,
6448 unformat_ip4_address, &v4_grp_address))
6450 grp_address_length = 64;
6454 else if (unformat (i, "%U %U",
6455 unformat_ip6_address, &v6_src_address,
6456 unformat_ip6_address, &v6_grp_address))
6458 grp_address_length = 256;
6462 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
6464 memset (&v4_src_address, 0, sizeof (v4_src_address));
6465 grp_address_length = 32;
6469 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
6471 memset (&v6_src_address, 0, sizeof (v6_src_address));
6472 grp_address_length = 128;
6476 else if (unformat (i, "/%d", &grp_address_length))
6478 else if (unformat (i, "local"))
6482 else if (unformat (i, "del"))
6484 else if (unformat (i, "add"))
6486 else if (unformat (i, "vrf %d", &vrf_id))
6488 else if (unformat (i, "create-vrf"))
6489 create_vrf_if_needed = 1;
6490 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
6492 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
6496 clib_warning ("parse error '%U'", format_unformat_error, i);
6501 if (address_set == 0)
6503 errmsg ("missing addresses\n");
6507 /* Construct the API message */
6508 M (IP_MROUTE_ADD_DEL, mp);
6510 mp->next_hop_sw_if_index = ntohl (sw_if_index);
6511 mp->table_id = ntohl (vrf_id);
6512 mp->create_vrf_if_needed = create_vrf_if_needed;
6514 mp->is_add = is_add;
6515 mp->is_ipv6 = is_ipv6;
6516 mp->is_local = is_local;
6517 mp->itf_flags = ntohl (iflags);
6518 mp->entry_flags = ntohl (eflags);
6519 mp->grp_address_length = grp_address_length;
6520 mp->grp_address_length = ntohs (mp->grp_address_length);
6524 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
6525 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
6529 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
6530 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
6536 /* Wait for a reply... */
6542 api_mpls_route_add_del (vat_main_t * vam)
6544 unformat_input_t *i = vam->input;
6545 vl_api_mpls_route_add_del_t *mp;
6546 u32 sw_if_index = ~0, table_id = 0;
6547 u8 create_table_if_needed = 0;
6549 u32 next_hop_weight = 1;
6550 u8 is_multipath = 0;
6551 u32 next_hop_table_id = 0;
6552 u8 next_hop_set = 0;
6553 ip4_address_t v4_next_hop_address = {
6556 ip6_address_t v6_next_hop_address = { {0} };
6560 u32 classify_table_index = ~0;
6562 u8 resolve_host = 0, resolve_attached = 0;
6563 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
6564 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6565 mpls_label_t *next_hop_out_label_stack = NULL;
6566 mpls_label_t local_label = MPLS_LABEL_INVALID;
6568 u8 next_hop_proto_is_ip4 = 1;
6570 /* Parse args required to build the message */
6571 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6573 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6575 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6577 else if (unformat (i, "%d", &local_label))
6579 else if (unformat (i, "eos"))
6581 else if (unformat (i, "non-eos"))
6583 else if (unformat (i, "via %U", unformat_ip4_address,
6584 &v4_next_hop_address))
6587 next_hop_proto_is_ip4 = 1;
6589 else if (unformat (i, "via %U", unformat_ip6_address,
6590 &v6_next_hop_address))
6593 next_hop_proto_is_ip4 = 0;
6595 else if (unformat (i, "weight %d", &next_hop_weight))
6597 else if (unformat (i, "create-table"))
6598 create_table_if_needed = 1;
6599 else if (unformat (i, "classify %d", &classify_table_index))
6603 else if (unformat (i, "del"))
6605 else if (unformat (i, "add"))
6607 else if (unformat (i, "resolve-via-host"))
6609 else if (unformat (i, "resolve-via-attached"))
6610 resolve_attached = 1;
6611 else if (unformat (i, "multipath"))
6613 else if (unformat (i, "count %d", &count))
6615 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
6618 next_hop_proto_is_ip4 = 1;
6620 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
6623 next_hop_proto_is_ip4 = 0;
6625 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6627 else if (unformat (i, "via-label %d", &next_hop_via_label))
6629 else if (unformat (i, "out-label %d", &next_hop_out_label))
6630 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
6633 clib_warning ("parse error '%U'", format_unformat_error, i);
6638 if (!next_hop_set && !is_classify)
6640 errmsg ("next hop / classify not set");
6644 if (MPLS_LABEL_INVALID == local_label)
6646 errmsg ("missing label");
6652 /* Turn on async mode */
6653 vam->async_mode = 1;
6654 vam->async_errors = 0;
6655 before = vat_time_now (vam);
6658 for (j = 0; j < count; j++)
6660 /* Construct the API message */
6661 M2 (MPLS_ROUTE_ADD_DEL, mp,
6662 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
6664 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
6665 mp->mr_table_id = ntohl (table_id);
6666 mp->mr_create_table_if_needed = create_table_if_needed;
6668 mp->mr_is_add = is_add;
6669 mp->mr_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
6670 mp->mr_is_classify = is_classify;
6671 mp->mr_is_multipath = is_multipath;
6672 mp->mr_is_resolve_host = resolve_host;
6673 mp->mr_is_resolve_attached = resolve_attached;
6674 mp->mr_next_hop_weight = next_hop_weight;
6675 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
6676 mp->mr_classify_table_index = ntohl (classify_table_index);
6677 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
6678 mp->mr_label = ntohl (local_label);
6679 mp->mr_eos = is_eos;
6681 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
6682 if (0 != mp->mr_next_hop_n_out_labels)
6684 memcpy (mp->mr_next_hop_out_label_stack,
6685 next_hop_out_label_stack,
6686 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
6687 vec_free (next_hop_out_label_stack);
6692 if (next_hop_proto_is_ip4)
6694 clib_memcpy (mp->mr_next_hop,
6695 &v4_next_hop_address,
6696 sizeof (v4_next_hop_address));
6700 clib_memcpy (mp->mr_next_hop,
6701 &v6_next_hop_address,
6702 sizeof (v6_next_hop_address));
6709 /* If we receive SIGTERM, stop now... */
6714 /* When testing multiple add/del ops, use a control-ping to sync */
6717 vl_api_control_ping_t *mp_ping;
6721 /* Shut off async mode */
6722 vam->async_mode = 0;
6724 M (CONTROL_PING, mp_ping);
6727 timeout = vat_time_now (vam) + 1.0;
6728 while (vat_time_now (vam) < timeout)
6729 if (vam->result_ready == 1)
6734 if (vam->retval == -99)
6737 if (vam->async_errors > 0)
6739 errmsg ("%d asynchronous errors", vam->async_errors);
6742 vam->async_errors = 0;
6743 after = vat_time_now (vam);
6745 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6749 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6750 count, after - before, count / (after - before));
6756 /* Wait for a reply... */
6761 /* Return the good/bad news */
6762 return (vam->retval);
6766 api_mpls_ip_bind_unbind (vat_main_t * vam)
6768 unformat_input_t *i = vam->input;
6769 vl_api_mpls_ip_bind_unbind_t *mp;
6770 u32 ip_table_id = 0;
6771 u8 create_table_if_needed = 0;
6774 ip4_address_t v4_address;
6775 ip6_address_t v6_address;
6778 mpls_label_t local_label = MPLS_LABEL_INVALID;
6781 /* Parse args required to build the message */
6782 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6784 if (unformat (i, "%U/%d", unformat_ip4_address,
6785 &v4_address, &address_length))
6790 else if (unformat (i, "%U/%d", unformat_ip6_address,
6791 &v6_address, &address_length))
6796 else if (unformat (i, "%d", &local_label))
6798 else if (unformat (i, "create-table"))
6799 create_table_if_needed = 1;
6800 else if (unformat (i, "table-id %d", &ip_table_id))
6802 else if (unformat (i, "unbind"))
6804 else if (unformat (i, "bind"))
6808 clib_warning ("parse error '%U'", format_unformat_error, i);
6815 errmsg ("IP addres not set");
6819 if (MPLS_LABEL_INVALID == local_label)
6821 errmsg ("missing label");
6825 /* Construct the API message */
6826 M (MPLS_IP_BIND_UNBIND, mp);
6828 mp->mb_create_table_if_needed = create_table_if_needed;
6829 mp->mb_is_bind = is_bind;
6830 mp->mb_is_ip4 = is_ip4;
6831 mp->mb_ip_table_id = ntohl (ip_table_id);
6832 mp->mb_mpls_table_id = 0;
6833 mp->mb_label = ntohl (local_label);
6834 mp->mb_address_length = address_length;
6837 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
6839 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
6844 /* Wait for a reply... */
6850 api_proxy_arp_add_del (vat_main_t * vam)
6852 unformat_input_t *i = vam->input;
6853 vl_api_proxy_arp_add_del_t *mp;
6856 ip4_address_t lo, hi;
6860 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6862 if (unformat (i, "vrf %d", &vrf_id))
6864 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
6865 unformat_ip4_address, &hi))
6867 else if (unformat (i, "del"))
6871 clib_warning ("parse error '%U'", format_unformat_error, i);
6878 errmsg ("address range not set");
6882 M (PROXY_ARP_ADD_DEL, mp);
6884 mp->vrf_id = ntohl (vrf_id);
6885 mp->is_add = is_add;
6886 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
6887 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
6895 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
6897 unformat_input_t *i = vam->input;
6898 vl_api_proxy_arp_intfc_enable_disable_t *mp;
6901 u8 sw_if_index_set = 0;
6904 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6906 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6907 sw_if_index_set = 1;
6908 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6909 sw_if_index_set = 1;
6910 else if (unformat (i, "enable"))
6912 else if (unformat (i, "disable"))
6916 clib_warning ("parse error '%U'", format_unformat_error, i);
6921 if (sw_if_index_set == 0)
6923 errmsg ("missing interface name or sw_if_index");
6927 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
6929 mp->sw_if_index = ntohl (sw_if_index);
6930 mp->enable_disable = enable;
6938 api_mpls_tunnel_add_del (vat_main_t * vam)
6940 unformat_input_t *i = vam->input;
6941 vl_api_mpls_tunnel_add_del_t *mp;
6945 u32 sw_if_index = ~0;
6946 u32 next_hop_sw_if_index = ~0;
6947 u32 next_hop_proto_is_ip4 = 1;
6949 u32 next_hop_table_id = 0;
6950 ip4_address_t v4_next_hop_address = {
6953 ip6_address_t v6_next_hop_address = { {0} };
6954 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID, *labels = NULL;
6957 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6959 if (unformat (i, "add"))
6961 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
6963 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
6965 else if (unformat (i, "via %U",
6966 unformat_ip4_address, &v4_next_hop_address))
6968 next_hop_proto_is_ip4 = 1;
6970 else if (unformat (i, "via %U",
6971 unformat_ip6_address, &v6_next_hop_address))
6973 next_hop_proto_is_ip4 = 0;
6975 else if (unformat (i, "l2-only"))
6977 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6979 else if (unformat (i, "out-label %d", &next_hop_out_label))
6980 vec_add1 (labels, ntohl (next_hop_out_label));
6983 clib_warning ("parse error '%U'", format_unformat_error, i);
6988 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (mpls_label_t) * vec_len (labels));
6990 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
6991 mp->mt_sw_if_index = ntohl (sw_if_index);
6992 mp->mt_is_add = is_add;
6993 mp->mt_l2_only = l2_only;
6994 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
6995 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
6997 mp->mt_next_hop_n_out_labels = vec_len (labels);
6999 if (0 != mp->mt_next_hop_n_out_labels)
7001 clib_memcpy (mp->mt_next_hop_out_label_stack, labels,
7002 sizeof (mpls_label_t) * mp->mt_next_hop_n_out_labels);
7006 if (next_hop_proto_is_ip4)
7008 clib_memcpy (mp->mt_next_hop,
7009 &v4_next_hop_address, sizeof (v4_next_hop_address));
7013 clib_memcpy (mp->mt_next_hop,
7014 &v6_next_hop_address, sizeof (v6_next_hop_address));
7023 api_sw_interface_set_unnumbered (vat_main_t * vam)
7025 unformat_input_t *i = vam->input;
7026 vl_api_sw_interface_set_unnumbered_t *mp;
7028 u32 unnum_sw_index = ~0;
7030 u8 sw_if_index_set = 0;
7033 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7035 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7036 sw_if_index_set = 1;
7037 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7038 sw_if_index_set = 1;
7039 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
7041 else if (unformat (i, "del"))
7045 clib_warning ("parse error '%U'", format_unformat_error, i);
7050 if (sw_if_index_set == 0)
7052 errmsg ("missing interface name or sw_if_index");
7056 M (SW_INTERFACE_SET_UNNUMBERED, mp);
7058 mp->sw_if_index = ntohl (sw_if_index);
7059 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
7060 mp->is_add = is_add;
7068 api_ip_neighbor_add_del (vat_main_t * vam)
7070 unformat_input_t *i = vam->input;
7071 vl_api_ip_neighbor_add_del_t *mp;
7073 u8 sw_if_index_set = 0;
7078 u8 v4_address_set = 0;
7079 u8 v6_address_set = 0;
7080 ip4_address_t v4address;
7081 ip6_address_t v6address;
7084 memset (mac_address, 0, sizeof (mac_address));
7086 /* Parse args required to build the message */
7087 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7089 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
7093 else if (unformat (i, "del"))
7096 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7097 sw_if_index_set = 1;
7098 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7099 sw_if_index_set = 1;
7100 else if (unformat (i, "is_static"))
7102 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
7104 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
7108 clib_warning ("parse error '%U'", format_unformat_error, i);
7113 if (sw_if_index_set == 0)
7115 errmsg ("missing interface name or sw_if_index");
7118 if (v4_address_set && v6_address_set)
7120 errmsg ("both v4 and v6 addresses set");
7123 if (!v4_address_set && !v6_address_set)
7125 errmsg ("no address set");
7129 /* Construct the API message */
7130 M (IP_NEIGHBOR_ADD_DEL, mp);
7132 mp->sw_if_index = ntohl (sw_if_index);
7133 mp->is_add = is_add;
7134 mp->is_static = is_static;
7136 clib_memcpy (mp->mac_address, mac_address, 6);
7140 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
7144 /* mp->is_ipv6 = 0; via memset in M macro above */
7145 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
7151 /* Wait for a reply, return good/bad news */
7157 api_reset_vrf (vat_main_t * vam)
7159 unformat_input_t *i = vam->input;
7160 vl_api_reset_vrf_t *mp;
7166 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7168 if (unformat (i, "vrf %d", &vrf_id))
7170 else if (unformat (i, "ipv6"))
7174 clib_warning ("parse error '%U'", format_unformat_error, i);
7179 if (vrf_id_set == 0)
7181 errmsg ("missing vrf id");
7187 mp->vrf_id = ntohl (vrf_id);
7188 mp->is_ipv6 = is_ipv6;
7196 api_create_vlan_subif (vat_main_t * vam)
7198 unformat_input_t *i = vam->input;
7199 vl_api_create_vlan_subif_t *mp;
7201 u8 sw_if_index_set = 0;
7206 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7208 if (unformat (i, "sw_if_index %d", &sw_if_index))
7209 sw_if_index_set = 1;
7211 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7212 sw_if_index_set = 1;
7213 else if (unformat (i, "vlan %d", &vlan_id))
7217 clib_warning ("parse error '%U'", format_unformat_error, i);
7222 if (sw_if_index_set == 0)
7224 errmsg ("missing interface name or sw_if_index");
7228 if (vlan_id_set == 0)
7230 errmsg ("missing vlan_id");
7233 M (CREATE_VLAN_SUBIF, mp);
7235 mp->sw_if_index = ntohl (sw_if_index);
7236 mp->vlan_id = ntohl (vlan_id);
7243 #define foreach_create_subif_bit \
7250 _(outer_vlan_id_any) \
7251 _(inner_vlan_id_any)
7254 api_create_subif (vat_main_t * vam)
7256 unformat_input_t *i = vam->input;
7257 vl_api_create_subif_t *mp;
7259 u8 sw_if_index_set = 0;
7266 u32 exact_match = 0;
7267 u32 default_sub = 0;
7268 u32 outer_vlan_id_any = 0;
7269 u32 inner_vlan_id_any = 0;
7271 u16 outer_vlan_id = 0;
7272 u16 inner_vlan_id = 0;
7275 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7277 if (unformat (i, "sw_if_index %d", &sw_if_index))
7278 sw_if_index_set = 1;
7280 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7281 sw_if_index_set = 1;
7282 else if (unformat (i, "sub_id %d", &sub_id))
7284 else if (unformat (i, "outer_vlan_id %d", &tmp))
7285 outer_vlan_id = tmp;
7286 else if (unformat (i, "inner_vlan_id %d", &tmp))
7287 inner_vlan_id = tmp;
7289 #define _(a) else if (unformat (i, #a)) a = 1 ;
7290 foreach_create_subif_bit
7294 clib_warning ("parse error '%U'", format_unformat_error, i);
7299 if (sw_if_index_set == 0)
7301 errmsg ("missing interface name or sw_if_index");
7305 if (sub_id_set == 0)
7307 errmsg ("missing sub_id");
7310 M (CREATE_SUBIF, mp);
7312 mp->sw_if_index = ntohl (sw_if_index);
7313 mp->sub_id = ntohl (sub_id);
7315 #define _(a) mp->a = a;
7316 foreach_create_subif_bit;
7319 mp->outer_vlan_id = ntohs (outer_vlan_id);
7320 mp->inner_vlan_id = ntohs (inner_vlan_id);
7328 api_oam_add_del (vat_main_t * vam)
7330 unformat_input_t *i = vam->input;
7331 vl_api_oam_add_del_t *mp;
7334 ip4_address_t src, dst;
7339 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7341 if (unformat (i, "vrf %d", &vrf_id))
7343 else if (unformat (i, "src %U", unformat_ip4_address, &src))
7345 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
7347 else if (unformat (i, "del"))
7351 clib_warning ("parse error '%U'", format_unformat_error, i);
7358 errmsg ("missing src addr");
7364 errmsg ("missing dst addr");
7368 M (OAM_ADD_DEL, mp);
7370 mp->vrf_id = ntohl (vrf_id);
7371 mp->is_add = is_add;
7372 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
7373 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
7381 api_reset_fib (vat_main_t * vam)
7383 unformat_input_t *i = vam->input;
7384 vl_api_reset_fib_t *mp;
7390 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7392 if (unformat (i, "vrf %d", &vrf_id))
7394 else if (unformat (i, "ipv6"))
7398 clib_warning ("parse error '%U'", format_unformat_error, i);
7403 if (vrf_id_set == 0)
7405 errmsg ("missing vrf id");
7411 mp->vrf_id = ntohl (vrf_id);
7412 mp->is_ipv6 = is_ipv6;
7420 api_dhcp_proxy_config (vat_main_t * vam)
7422 unformat_input_t *i = vam->input;
7423 vl_api_dhcp_proxy_config_t *mp;
7425 u32 server_vrf_id = 0;
7427 u8 v4_address_set = 0;
7428 u8 v6_address_set = 0;
7429 ip4_address_t v4address;
7430 ip6_address_t v6address;
7431 u8 v4_src_address_set = 0;
7432 u8 v6_src_address_set = 0;
7433 ip4_address_t v4srcaddress;
7434 ip6_address_t v6srcaddress;
7437 /* Parse args required to build the message */
7438 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7440 if (unformat (i, "del"))
7442 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
7444 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
7446 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
7448 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
7450 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
7451 v4_src_address_set = 1;
7452 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
7453 v6_src_address_set = 1;
7458 if (v4_address_set && v6_address_set)
7460 errmsg ("both v4 and v6 server addresses set");
7463 if (!v4_address_set && !v6_address_set)
7465 errmsg ("no server addresses set");
7469 if (v4_src_address_set && v6_src_address_set)
7471 errmsg ("both v4 and v6 src addresses set");
7474 if (!v4_src_address_set && !v6_src_address_set)
7476 errmsg ("no src addresses set");
7480 if (!(v4_src_address_set && v4_address_set) &&
7481 !(v6_src_address_set && v6_address_set))
7483 errmsg ("no matching server and src addresses set");
7487 /* Construct the API message */
7488 M (DHCP_PROXY_CONFIG, mp);
7490 mp->is_add = is_add;
7491 mp->rx_vrf_id = ntohl (rx_vrf_id);
7492 mp->server_vrf_id = ntohl (server_vrf_id);
7496 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
7497 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
7501 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
7502 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
7508 /* Wait for a reply, return good/bad news */
7513 #define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
7514 #define vl_api_dhcp_proxy_details_t_print vl_noop_handler
7517 vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
7519 vat_main_t *vam = &vat_main;
7523 "RX Table-ID %d, Server Table-ID %d, Server Address %U, Source Address %U, VSS FIB-ID %d, VSS OUI %d",
7524 ntohl (mp->rx_vrf_id),
7525 ntohl (mp->server_vrf_id),
7526 format_ip6_address, mp->dhcp_server,
7527 format_ip6_address, mp->dhcp_src_address,
7528 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
7531 "RX Table-ID %d, Server Table-ID %d, Server Address %U, Source Address %U, VSS FIB-ID %d, VSS OUI %d",
7532 ntohl (mp->rx_vrf_id),
7533 ntohl (mp->server_vrf_id),
7534 format_ip4_address, mp->dhcp_server,
7535 format_ip4_address, mp->dhcp_src_address,
7536 ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
7539 static void vl_api_dhcp_proxy_details_t_handler_json
7540 (vl_api_dhcp_proxy_details_t * mp)
7542 vat_main_t *vam = &vat_main;
7543 vat_json_node_t *node = NULL;
7545 struct in6_addr ip6;
7547 if (VAT_JSON_ARRAY != vam->json_tree.type)
7549 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
7550 vat_json_init_array (&vam->json_tree);
7552 node = vat_json_array_add (&vam->json_tree);
7554 vat_json_init_object (node);
7555 vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
7556 vat_json_object_add_uint (node, "server-table-id",
7557 ntohl (mp->server_vrf_id));
7560 clib_memcpy (&ip6, &mp->dhcp_server, sizeof (ip6));
7561 vat_json_object_add_ip6 (node, "server_address", ip6);
7562 clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
7563 vat_json_object_add_ip6 (node, "src_address", ip6);
7567 clib_memcpy (&ip4, &mp->dhcp_server, sizeof (ip4));
7568 vat_json_object_add_ip4 (node, "server_address", ip4);
7569 clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
7570 vat_json_object_add_ip4 (node, "src_address", ip4);
7572 vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
7573 vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
7577 api_dhcp_proxy_dump (vat_main_t * vam)
7579 unformat_input_t *i = vam->input;
7580 vl_api_control_ping_t *mp_ping;
7581 vl_api_dhcp_proxy_dump_t *mp;
7585 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7587 if (unformat (i, "ipv6"))
7591 clib_warning ("parse error '%U'", format_unformat_error, i);
7596 M (DHCP_PROXY_DUMP, mp);
7598 mp->is_ip6 = is_ipv6;
7601 /* Use a control ping for synchronization */
7602 M (CONTROL_PING, mp_ping);
7610 api_dhcp_proxy_set_vss (vat_main_t * vam)
7612 unformat_input_t *i = vam->input;
7613 vl_api_dhcp_proxy_set_vss_t *mp;
7624 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7626 if (unformat (i, "tbl_id %d", &tbl_id))
7628 if (unformat (i, "fib_id %d", &fib_id))
7630 if (unformat (i, "oui %d", &oui))
7632 else if (unformat (i, "ipv6"))
7634 else if (unformat (i, "del"))
7638 clib_warning ("parse error '%U'", format_unformat_error, i);
7643 if (tbl_id_set == 0)
7645 errmsg ("missing tbl id");
7649 if (fib_id_set == 0)
7651 errmsg ("missing fib id");
7656 errmsg ("missing oui");
7660 M (DHCP_PROXY_SET_VSS, mp);
7661 mp->tbl_id = ntohl (tbl_id);
7662 mp->fib_id = ntohl (fib_id);
7663 mp->oui = ntohl (oui);
7664 mp->is_ipv6 = is_ipv6;
7665 mp->is_add = is_add;
7673 api_dhcp_client_config (vat_main_t * vam)
7675 unformat_input_t *i = vam->input;
7676 vl_api_dhcp_client_config_t *mp;
7678 u8 sw_if_index_set = 0;
7681 u8 disable_event = 0;
7684 /* Parse args required to build the message */
7685 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7687 if (unformat (i, "del"))
7690 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7691 sw_if_index_set = 1;
7692 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7693 sw_if_index_set = 1;
7694 else if (unformat (i, "hostname %s", &hostname))
7696 else if (unformat (i, "disable_event"))
7702 if (sw_if_index_set == 0)
7704 errmsg ("missing interface name or sw_if_index");
7708 if (vec_len (hostname) > 63)
7710 errmsg ("hostname too long");
7712 vec_add1 (hostname, 0);
7714 /* Construct the API message */
7715 M (DHCP_CLIENT_CONFIG, mp);
7717 mp->sw_if_index = ntohl (sw_if_index);
7718 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
7719 vec_free (hostname);
7720 mp->is_add = is_add;
7721 mp->want_dhcp_event = disable_event ? 0 : 1;
7722 mp->pid = getpid ();
7727 /* Wait for a reply, return good/bad news */
7733 api_set_ip_flow_hash (vat_main_t * vam)
7735 unformat_input_t *i = vam->input;
7736 vl_api_set_ip_flow_hash_t *mp;
7748 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7750 if (unformat (i, "vrf %d", &vrf_id))
7752 else if (unformat (i, "ipv6"))
7754 else if (unformat (i, "src"))
7756 else if (unformat (i, "dst"))
7758 else if (unformat (i, "sport"))
7760 else if (unformat (i, "dport"))
7762 else if (unformat (i, "proto"))
7764 else if (unformat (i, "reverse"))
7769 clib_warning ("parse error '%U'", format_unformat_error, i);
7774 if (vrf_id_set == 0)
7776 errmsg ("missing vrf id");
7780 M (SET_IP_FLOW_HASH, mp);
7786 mp->reverse = reverse;
7787 mp->vrf_id = ntohl (vrf_id);
7788 mp->is_ipv6 = is_ipv6;
7796 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
7798 unformat_input_t *i = vam->input;
7799 vl_api_sw_interface_ip6_enable_disable_t *mp;
7801 u8 sw_if_index_set = 0;
7805 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7807 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7808 sw_if_index_set = 1;
7809 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7810 sw_if_index_set = 1;
7811 else if (unformat (i, "enable"))
7813 else if (unformat (i, "disable"))
7817 clib_warning ("parse error '%U'", format_unformat_error, i);
7822 if (sw_if_index_set == 0)
7824 errmsg ("missing interface name or sw_if_index");
7828 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
7830 mp->sw_if_index = ntohl (sw_if_index);
7831 mp->enable = enable;
7839 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
7841 unformat_input_t *i = vam->input;
7842 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
7844 u8 sw_if_index_set = 0;
7845 u8 v6_address_set = 0;
7846 ip6_address_t v6address;
7849 /* Parse args required to build the message */
7850 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7852 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7853 sw_if_index_set = 1;
7854 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7855 sw_if_index_set = 1;
7856 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
7862 if (sw_if_index_set == 0)
7864 errmsg ("missing interface name or sw_if_index");
7867 if (!v6_address_set)
7869 errmsg ("no address set");
7873 /* Construct the API message */
7874 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, mp);
7876 mp->sw_if_index = ntohl (sw_if_index);
7877 clib_memcpy (mp->address, &v6address, sizeof (v6address));
7882 /* Wait for a reply, return good/bad news */
7889 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
7891 unformat_input_t *i = vam->input;
7892 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
7894 u8 sw_if_index_set = 0;
7895 u32 address_length = 0;
7896 u8 v6_address_set = 0;
7897 ip6_address_t v6address;
7899 u8 no_advertise = 0;
7901 u8 no_autoconfig = 0;
7904 u32 val_lifetime = 0;
7905 u32 pref_lifetime = 0;
7908 /* Parse args required to build the message */
7909 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7911 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7912 sw_if_index_set = 1;
7913 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7914 sw_if_index_set = 1;
7915 else if (unformat (i, "%U/%d",
7916 unformat_ip6_address, &v6address, &address_length))
7918 else if (unformat (i, "val_life %d", &val_lifetime))
7920 else if (unformat (i, "pref_life %d", &pref_lifetime))
7922 else if (unformat (i, "def"))
7924 else if (unformat (i, "noadv"))
7926 else if (unformat (i, "offl"))
7928 else if (unformat (i, "noauto"))
7930 else if (unformat (i, "nolink"))
7932 else if (unformat (i, "isno"))
7936 clib_warning ("parse error '%U'", format_unformat_error, i);
7941 if (sw_if_index_set == 0)
7943 errmsg ("missing interface name or sw_if_index");
7946 if (!v6_address_set)
7948 errmsg ("no address set");
7952 /* Construct the API message */
7953 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
7955 mp->sw_if_index = ntohl (sw_if_index);
7956 clib_memcpy (mp->address, &v6address, sizeof (v6address));
7957 mp->address_length = address_length;
7958 mp->use_default = use_default;
7959 mp->no_advertise = no_advertise;
7960 mp->off_link = off_link;
7961 mp->no_autoconfig = no_autoconfig;
7962 mp->no_onlink = no_onlink;
7964 mp->val_lifetime = ntohl (val_lifetime);
7965 mp->pref_lifetime = ntohl (pref_lifetime);
7970 /* Wait for a reply, return good/bad news */
7976 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
7978 unformat_input_t *i = vam->input;
7979 vl_api_sw_interface_ip6nd_ra_config_t *mp;
7981 u8 sw_if_index_set = 0;
7986 u8 send_unicast = 0;
7989 u8 default_router = 0;
7990 u32 max_interval = 0;
7991 u32 min_interval = 0;
7993 u32 initial_count = 0;
7994 u32 initial_interval = 0;
7998 /* Parse args required to build the message */
7999 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8001 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8002 sw_if_index_set = 1;
8003 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8004 sw_if_index_set = 1;
8005 else if (unformat (i, "maxint %d", &max_interval))
8007 else if (unformat (i, "minint %d", &min_interval))
8009 else if (unformat (i, "life %d", &lifetime))
8011 else if (unformat (i, "count %d", &initial_count))
8013 else if (unformat (i, "interval %d", &initial_interval))
8015 else if (unformat (i, "suppress") || unformat (i, "surpress"))
8017 else if (unformat (i, "managed"))
8019 else if (unformat (i, "other"))
8021 else if (unformat (i, "ll"))
8023 else if (unformat (i, "send"))
8025 else if (unformat (i, "cease"))
8027 else if (unformat (i, "isno"))
8029 else if (unformat (i, "def"))
8033 clib_warning ("parse error '%U'", format_unformat_error, i);
8038 if (sw_if_index_set == 0)
8040 errmsg ("missing interface name or sw_if_index");
8044 /* Construct the API message */
8045 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
8047 mp->sw_if_index = ntohl (sw_if_index);
8048 mp->max_interval = ntohl (max_interval);
8049 mp->min_interval = ntohl (min_interval);
8050 mp->lifetime = ntohl (lifetime);
8051 mp->initial_count = ntohl (initial_count);
8052 mp->initial_interval = ntohl (initial_interval);
8053 mp->suppress = suppress;
8054 mp->managed = managed;
8056 mp->ll_option = ll_option;
8057 mp->send_unicast = send_unicast;
8060 mp->default_router = default_router;
8065 /* Wait for a reply, return good/bad news */
8071 api_set_arp_neighbor_limit (vat_main_t * vam)
8073 unformat_input_t *i = vam->input;
8074 vl_api_set_arp_neighbor_limit_t *mp;
8080 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8082 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
8084 else if (unformat (i, "ipv6"))
8088 clib_warning ("parse error '%U'", format_unformat_error, i);
8095 errmsg ("missing limit value");
8099 M (SET_ARP_NEIGHBOR_LIMIT, mp);
8101 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
8102 mp->is_ipv6 = is_ipv6;
8110 api_l2_patch_add_del (vat_main_t * vam)
8112 unformat_input_t *i = vam->input;
8113 vl_api_l2_patch_add_del_t *mp;
8115 u8 rx_sw_if_index_set = 0;
8117 u8 tx_sw_if_index_set = 0;
8121 /* Parse args required to build the message */
8122 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8124 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
8125 rx_sw_if_index_set = 1;
8126 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
8127 tx_sw_if_index_set = 1;
8128 else if (unformat (i, "rx"))
8130 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8132 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
8134 rx_sw_if_index_set = 1;
8139 else if (unformat (i, "tx"))
8141 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8143 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
8145 tx_sw_if_index_set = 1;
8150 else if (unformat (i, "del"))
8156 if (rx_sw_if_index_set == 0)
8158 errmsg ("missing rx interface name or rx_sw_if_index");
8162 if (tx_sw_if_index_set == 0)
8164 errmsg ("missing tx interface name or tx_sw_if_index");
8168 M (L2_PATCH_ADD_DEL, mp);
8170 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
8171 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
8172 mp->is_add = is_add;
8180 api_ioam_enable (vat_main_t * vam)
8182 unformat_input_t *input = vam->input;
8183 vl_api_ioam_enable_t *mp;
8185 int has_trace_option = 0;
8186 int has_pot_option = 0;
8187 int has_seqno_option = 0;
8188 int has_analyse_option = 0;
8191 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8193 if (unformat (input, "trace"))
8194 has_trace_option = 1;
8195 else if (unformat (input, "pot"))
8197 else if (unformat (input, "seqno"))
8198 has_seqno_option = 1;
8199 else if (unformat (input, "analyse"))
8200 has_analyse_option = 1;
8204 M (IOAM_ENABLE, mp);
8205 mp->id = htons (id);
8206 mp->seqno = has_seqno_option;
8207 mp->analyse = has_analyse_option;
8208 mp->pot_enable = has_pot_option;
8209 mp->trace_enable = has_trace_option;
8218 api_ioam_disable (vat_main_t * vam)
8220 vl_api_ioam_disable_t *mp;
8223 M (IOAM_DISABLE, mp);
8230 api_sr_tunnel_add_del (vat_main_t * vam)
8232 unformat_input_t *i = vam->input;
8233 vl_api_sr_tunnel_add_del_t *mp;
8236 ip6_address_t src_address;
8237 int src_address_set = 0;
8238 ip6_address_t dst_address;
8240 int dst_address_set = 0;
8242 u32 rx_table_id = 0;
8243 u32 tx_table_id = 0;
8244 ip6_address_t *segments = 0;
8245 ip6_address_t *this_seg;
8246 ip6_address_t *tags = 0;
8247 ip6_address_t *this_tag;
8248 ip6_address_t next_address, tag;
8250 u8 *policy_name = 0;
8253 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8255 if (unformat (i, "del"))
8257 else if (unformat (i, "name %s", &name))
8259 else if (unformat (i, "policy %s", &policy_name))
8261 else if (unformat (i, "rx_fib_id %d", &rx_table_id))
8263 else if (unformat (i, "tx_fib_id %d", &tx_table_id))
8265 else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
8266 src_address_set = 1;
8267 else if (unformat (i, "dst %U/%d",
8268 unformat_ip6_address, &dst_address, &dst_mask_width))
8269 dst_address_set = 1;
8270 else if (unformat (i, "next %U", unformat_ip6_address, &next_address))
8272 vec_add2 (segments, this_seg, 1);
8273 clib_memcpy (this_seg->as_u8, next_address.as_u8,
8274 sizeof (*this_seg));
8276 else if (unformat (i, "tag %U", unformat_ip6_address, &tag))
8278 vec_add2 (tags, this_tag, 1);
8279 clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
8281 else if (unformat (i, "clean"))
8282 flags |= IP6_SR_HEADER_FLAG_CLEANUP;
8283 else if (unformat (i, "protected"))
8284 flags |= IP6_SR_HEADER_FLAG_PROTECTED;
8285 else if (unformat (i, "InPE %d", &pl_index))
8287 if (pl_index <= 0 || pl_index > 4)
8289 pl_index_range_error:
8290 errmsg ("pl index %d out of range", pl_index);
8294 IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE << (3 * (pl_index - 1));
8296 else if (unformat (i, "EgPE %d", &pl_index))
8298 if (pl_index <= 0 || pl_index > 4)
8299 goto pl_index_range_error;
8301 IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE << (3 * (pl_index - 1));
8303 else if (unformat (i, "OrgSrc %d", &pl_index))
8305 if (pl_index <= 0 || pl_index > 4)
8306 goto pl_index_range_error;
8308 IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3 * (pl_index - 1));
8314 if (!src_address_set)
8316 errmsg ("src address required");
8320 if (!dst_address_set)
8322 errmsg ("dst address required");
8328 errmsg ("at least one sr segment required");
8332 M2 (SR_TUNNEL_ADD_DEL, mp,
8333 vec_len (segments) * sizeof (ip6_address_t)
8334 + vec_len (tags) * sizeof (ip6_address_t));
8336 clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
8337 clib_memcpy (mp->dst_address, &dst_address, sizeof (mp->dst_address));
8338 mp->dst_mask_width = dst_mask_width;
8339 mp->flags_net_byte_order = clib_host_to_net_u16 (flags);
8340 mp->n_segments = vec_len (segments);
8341 mp->n_tags = vec_len (tags);
8342 mp->is_add = is_del == 0;
8343 clib_memcpy (mp->segs_and_tags, segments,
8344 vec_len (segments) * sizeof (ip6_address_t));
8345 clib_memcpy (mp->segs_and_tags +
8346 vec_len (segments) * sizeof (ip6_address_t), tags,
8347 vec_len (tags) * sizeof (ip6_address_t));
8349 mp->outer_vrf_id = ntohl (rx_table_id);
8350 mp->inner_vrf_id = ntohl (tx_table_id);
8351 memcpy (mp->name, name, vec_len (name));
8352 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
8354 vec_free (segments);
8363 api_sr_policy_add_del (vat_main_t * vam)
8365 unformat_input_t *input = vam->input;
8366 vl_api_sr_policy_add_del_t *mp;
8369 u8 *tunnel_name = 0;
8370 u8 **tunnel_names = 0;
8375 int tunnel_names_length = 1; // Init to 1 to offset the #tunnel_names counter byte
8376 int tun_name_len = 0; // Different naming convention used as confusing these would be "bad" (TM)
8379 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8381 if (unformat (input, "del"))
8383 else if (unformat (input, "name %s", &name))
8385 else if (unformat (input, "tunnel %s", &tunnel_name))
8389 vec_add1 (tunnel_names, tunnel_name);
8391 - length = #bytes to store in serial vector
8392 - +1 = byte to store that length
8394 tunnel_names_length += (vec_len (tunnel_name) + 1);
8405 errmsg ("policy name required");
8409 if ((!tunnel_set) && (!is_del))
8411 errmsg ("tunnel name required");
8415 M2 (SR_POLICY_ADD_DEL, mp, tunnel_names_length);
8419 mp->is_add = !is_del;
8421 memcpy (mp->name, name, vec_len (name));
8422 // Since mp->tunnel_names is of type u8[0] and not a u8 *, u8 ** needs to be serialized
8423 u8 *serial_orig = 0;
8424 vec_validate (serial_orig, tunnel_names_length);
8425 *serial_orig = vec_len (tunnel_names); // Store the number of tunnels as length in first byte of serialized vector
8426 serial_orig += 1; // Move along one byte to store the length of first tunnel_name
8428 for (j = 0; j < vec_len (tunnel_names); j++)
8430 tun_name_len = vec_len (tunnel_names[j]);
8431 *serial_orig = tun_name_len; // Store length of tunnel name in first byte of Length/Value pair
8432 serial_orig += 1; // Move along one byte to store the actual tunnel name
8433 memcpy (serial_orig, tunnel_names[j], tun_name_len);
8434 serial_orig += tun_name_len; // Advance past the copy
8436 memcpy (mp->tunnel_names, serial_orig - tunnel_names_length, tunnel_names_length); // Regress serial_orig to head then copy fwd
8438 vec_free (tunnel_names);
8439 vec_free (tunnel_name);
8447 api_sr_multicast_map_add_del (vat_main_t * vam)
8449 unformat_input_t *input = vam->input;
8450 vl_api_sr_multicast_map_add_del_t *mp;
8452 ip6_address_t multicast_address;
8453 u8 *policy_name = 0;
8454 int multicast_address_set = 0;
8457 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8459 if (unformat (input, "del"))
8463 (input, "address %U", unformat_ip6_address, &multicast_address))
8464 multicast_address_set = 1;
8465 else if (unformat (input, "sr-policy %s", &policy_name))
8471 if (!is_del && !policy_name)
8473 errmsg ("sr-policy name required");
8478 if (!multicast_address_set)
8480 errmsg ("address required");
8484 M (SR_MULTICAST_MAP_ADD_DEL, mp);
8486 mp->is_add = !is_del;
8487 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
8488 clib_memcpy (mp->multicast_address, &multicast_address,
8489 sizeof (mp->multicast_address));
8492 vec_free (policy_name);
8500 #define foreach_tcp_proto_field \
8504 #define foreach_udp_proto_field \
8508 #define foreach_ip4_proto_field \
8520 u16 src_port, dst_port;
8523 #if VPP_API_TEST_BUILTIN == 0
8525 unformat_tcp_mask (unformat_input_t * input, va_list * args)
8527 u8 **maskp = va_arg (*args, u8 **);
8529 u8 found_something = 0;
8532 #define _(a) u8 a=0;
8533 foreach_tcp_proto_field;
8536 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8539 #define _(a) else if (unformat (input, #a)) a=1;
8540 foreach_tcp_proto_field
8546 #define _(a) found_something += a;
8547 foreach_tcp_proto_field;
8550 if (found_something == 0)
8553 vec_validate (mask, sizeof (*tcp) - 1);
8555 tcp = (tcp_header_t *) mask;
8557 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
8558 foreach_tcp_proto_field;
8566 unformat_udp_mask (unformat_input_t * input, va_list * args)
8568 u8 **maskp = va_arg (*args, u8 **);
8570 u8 found_something = 0;
8573 #define _(a) u8 a=0;
8574 foreach_udp_proto_field;
8577 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8580 #define _(a) else if (unformat (input, #a)) a=1;
8581 foreach_udp_proto_field
8587 #define _(a) found_something += a;
8588 foreach_udp_proto_field;
8591 if (found_something == 0)
8594 vec_validate (mask, sizeof (*udp) - 1);
8596 udp = (udp_header_t *) mask;
8598 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
8599 foreach_udp_proto_field;
8607 unformat_l4_mask (unformat_input_t * input, va_list * args)
8609 u8 **maskp = va_arg (*args, u8 **);
8610 u16 src_port = 0, dst_port = 0;
8611 tcpudp_header_t *tcpudp;
8613 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8615 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
8617 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
8619 else if (unformat (input, "src_port"))
8621 else if (unformat (input, "dst_port"))
8627 if (!src_port && !dst_port)
8631 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
8633 tcpudp = (tcpudp_header_t *) mask;
8634 tcpudp->src_port = src_port;
8635 tcpudp->dst_port = dst_port;
8643 unformat_ip4_mask (unformat_input_t * input, va_list * args)
8645 u8 **maskp = va_arg (*args, u8 **);
8647 u8 found_something = 0;
8650 #define _(a) u8 a=0;
8651 foreach_ip4_proto_field;
8657 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8659 if (unformat (input, "version"))
8661 else if (unformat (input, "hdr_length"))
8663 else if (unformat (input, "src"))
8665 else if (unformat (input, "dst"))
8667 else if (unformat (input, "proto"))
8670 #define _(a) else if (unformat (input, #a)) a=1;
8671 foreach_ip4_proto_field
8677 #define _(a) found_something += a;
8678 foreach_ip4_proto_field;
8681 if (found_something == 0)
8684 vec_validate (mask, sizeof (*ip) - 1);
8686 ip = (ip4_header_t *) mask;
8688 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
8689 foreach_ip4_proto_field;
8692 ip->ip_version_and_header_length = 0;
8695 ip->ip_version_and_header_length |= 0xF0;
8698 ip->ip_version_and_header_length |= 0x0F;
8704 #define foreach_ip6_proto_field \
8712 unformat_ip6_mask (unformat_input_t * input, va_list * args)
8714 u8 **maskp = va_arg (*args, u8 **);
8716 u8 found_something = 0;
8718 u32 ip_version_traffic_class_and_flow_label;
8720 #define _(a) u8 a=0;
8721 foreach_ip6_proto_field;
8724 u8 traffic_class = 0;
8727 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8729 if (unformat (input, "version"))
8731 else if (unformat (input, "traffic-class"))
8733 else if (unformat (input, "flow-label"))
8735 else if (unformat (input, "src"))
8737 else if (unformat (input, "dst"))
8739 else if (unformat (input, "proto"))
8742 #define _(a) else if (unformat (input, #a)) a=1;
8743 foreach_ip6_proto_field
8749 #define _(a) found_something += a;
8750 foreach_ip6_proto_field;
8753 if (found_something == 0)
8756 vec_validate (mask, sizeof (*ip) - 1);
8758 ip = (ip6_header_t *) mask;
8760 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
8761 foreach_ip6_proto_field;
8764 ip_version_traffic_class_and_flow_label = 0;
8767 ip_version_traffic_class_and_flow_label |= 0xF0000000;
8770 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
8773 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
8775 ip->ip_version_traffic_class_and_flow_label =
8776 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
8783 unformat_l3_mask (unformat_input_t * input, va_list * args)
8785 u8 **maskp = va_arg (*args, u8 **);
8787 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8789 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
8791 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
8800 unformat_l2_mask (unformat_input_t * input, va_list * args)
8802 u8 **maskp = va_arg (*args, u8 **);
8817 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8819 if (unformat (input, "src"))
8821 else if (unformat (input, "dst"))
8823 else if (unformat (input, "proto"))
8825 else if (unformat (input, "tag1"))
8827 else if (unformat (input, "tag2"))
8829 else if (unformat (input, "ignore-tag1"))
8831 else if (unformat (input, "ignore-tag2"))
8833 else if (unformat (input, "cos1"))
8835 else if (unformat (input, "cos2"))
8837 else if (unformat (input, "dot1q"))
8839 else if (unformat (input, "dot1ad"))
8844 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
8845 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
8848 if (tag1 || ignore_tag1 || cos1 || dot1q)
8850 if (tag2 || ignore_tag2 || cos2 || dot1ad)
8853 vec_validate (mask, len - 1);
8856 memset (mask, 0xff, 6);
8859 memset (mask + 6, 0xff, 6);
8863 /* inner vlan tag */
8872 mask[21] = mask[20] = 0xff;
8893 mask[16] = mask[17] = 0xff;
8903 mask[12] = mask[13] = 0xff;
8910 unformat_classify_mask (unformat_input_t * input, va_list * args)
8912 u8 **maskp = va_arg (*args, u8 **);
8913 u32 *skipp = va_arg (*args, u32 *);
8914 u32 *matchp = va_arg (*args, u32 *);
8922 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8924 if (unformat (input, "hex %U", unformat_hex_string, &mask))
8926 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
8928 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
8930 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
8944 if (mask || l2 || l3 || l4)
8948 /* "With a free Ethernet header in every package" */
8950 vec_validate (l2, 13);
8954 vec_append (mask, l3);
8959 vec_append (mask, l4);
8964 /* Scan forward looking for the first significant mask octet */
8965 for (i = 0; i < vec_len (mask); i++)
8969 /* compute (skip, match) params */
8970 *skipp = i / sizeof (u32x4);
8971 vec_delete (mask, *skipp * sizeof (u32x4), 0);
8973 /* Pad mask to an even multiple of the vector size */
8974 while (vec_len (mask) % sizeof (u32x4))
8977 match = vec_len (mask) / sizeof (u32x4);
8979 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
8981 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
8982 if (*tmp || *(tmp + 1))
8987 clib_warning ("BUG: match 0");
8989 _vec_len (mask) = match * sizeof (u32x4);
8999 #endif /* VPP_API_TEST_BUILTIN */
9001 #define foreach_l2_next \
9003 _(ethernet, ETHERNET_INPUT) \
9008 unformat_l2_next_index (unformat_input_t * input, va_list * args)
9010 u32 *miss_next_indexp = va_arg (*args, u32 *);
9015 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
9019 if (unformat (input, "%d", &tmp))
9028 *miss_next_indexp = next_index;
9032 #define foreach_ip_next \
9038 api_unformat_ip_next_index (unformat_input_t * input, va_list * args)
9040 u32 *miss_next_indexp = va_arg (*args, u32 *);
9045 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
9049 if (unformat (input, "%d", &tmp))
9058 *miss_next_indexp = next_index;
9062 #define foreach_acl_next \
9066 api_unformat_acl_next_index (unformat_input_t * input, va_list * args)
9068 u32 *miss_next_indexp = va_arg (*args, u32 *);
9073 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
9077 if (unformat (input, "permit"))
9082 else if (unformat (input, "%d", &tmp))
9091 *miss_next_indexp = next_index;
9096 unformat_policer_precolor (unformat_input_t * input, va_list * args)
9098 u32 *r = va_arg (*args, u32 *);
9100 if (unformat (input, "conform-color"))
9101 *r = POLICE_CONFORM;
9102 else if (unformat (input, "exceed-color"))
9111 api_classify_add_del_table (vat_main_t * vam)
9113 unformat_input_t *i = vam->input;
9114 vl_api_classify_add_del_table_t *mp;
9121 u32 table_index = ~0;
9122 u32 next_table_index = ~0;
9123 u32 miss_next_index = ~0;
9124 u32 memory_size = 32 << 20;
9126 u32 current_data_flag = 0;
9127 int current_data_offset = 0;
9130 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9132 if (unformat (i, "del"))
9134 else if (unformat (i, "del-chain"))
9139 else if (unformat (i, "buckets %d", &nbuckets))
9141 else if (unformat (i, "memory_size %d", &memory_size))
9143 else if (unformat (i, "skip %d", &skip))
9145 else if (unformat (i, "match %d", &match))
9147 else if (unformat (i, "table %d", &table_index))
9149 else if (unformat (i, "mask %U", unformat_classify_mask,
9150 &mask, &skip, &match))
9152 else if (unformat (i, "next-table %d", &next_table_index))
9154 else if (unformat (i, "miss-next %U", api_unformat_ip_next_index,
9157 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
9160 else if (unformat (i, "acl-miss-next %U", api_unformat_acl_next_index,
9163 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
9165 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
9171 if (is_add && mask == 0)
9173 errmsg ("Mask required");
9177 if (is_add && skip == ~0)
9179 errmsg ("skip count required");
9183 if (is_add && match == ~0)
9185 errmsg ("match count required");
9189 if (!is_add && table_index == ~0)
9191 errmsg ("table index required for delete");
9195 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
9197 mp->is_add = is_add;
9198 mp->del_chain = del_chain;
9199 mp->table_index = ntohl (table_index);
9200 mp->nbuckets = ntohl (nbuckets);
9201 mp->memory_size = ntohl (memory_size);
9202 mp->skip_n_vectors = ntohl (skip);
9203 mp->match_n_vectors = ntohl (match);
9204 mp->next_table_index = ntohl (next_table_index);
9205 mp->miss_next_index = ntohl (miss_next_index);
9206 mp->current_data_flag = ntohl (current_data_flag);
9207 mp->current_data_offset = ntohl (current_data_offset);
9208 clib_memcpy (mp->mask, mask, vec_len (mask));
9217 #if VPP_API_TEST_BUILTIN == 0
9219 unformat_l4_match (unformat_input_t * input, va_list * args)
9221 u8 **matchp = va_arg (*args, u8 **);
9223 u8 *proto_header = 0;
9229 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9231 if (unformat (input, "src_port %d", &src_port))
9233 else if (unformat (input, "dst_port %d", &dst_port))
9239 h.src_port = clib_host_to_net_u16 (src_port);
9240 h.dst_port = clib_host_to_net_u16 (dst_port);
9241 vec_validate (proto_header, sizeof (h) - 1);
9242 memcpy (proto_header, &h, sizeof (h));
9244 *matchp = proto_header;
9250 unformat_ip4_match (unformat_input_t * input, va_list * args)
9252 u8 **matchp = va_arg (*args, u8 **);
9259 int src = 0, dst = 0;
9260 ip4_address_t src_val, dst_val;
9267 int fragment_id = 0;
9268 u32 fragment_id_val;
9274 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9276 if (unformat (input, "version %d", &version_val))
9278 else if (unformat (input, "hdr_length %d", &hdr_length_val))
9280 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
9282 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
9284 else if (unformat (input, "proto %d", &proto_val))
9286 else if (unformat (input, "tos %d", &tos_val))
9288 else if (unformat (input, "length %d", &length_val))
9290 else if (unformat (input, "fragment_id %d", &fragment_id_val))
9292 else if (unformat (input, "ttl %d", &ttl_val))
9294 else if (unformat (input, "checksum %d", &checksum_val))
9300 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
9301 + ttl + checksum == 0)
9305 * Aligned because we use the real comparison functions
9307 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
9309 ip = (ip4_header_t *) match;
9311 /* These are realistically matched in practice */
9313 ip->src_address.as_u32 = src_val.as_u32;
9316 ip->dst_address.as_u32 = dst_val.as_u32;
9319 ip->protocol = proto_val;
9322 /* These are not, but they're included for completeness */
9324 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
9327 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
9333 ip->length = clib_host_to_net_u16 (length_val);
9339 ip->checksum = clib_host_to_net_u16 (checksum_val);
9346 unformat_ip6_match (unformat_input_t * input, va_list * args)
9348 u8 **matchp = va_arg (*args, u8 **);
9353 u8 traffic_class = 0;
9354 u32 traffic_class_val = 0;
9357 int src = 0, dst = 0;
9358 ip6_address_t src_val, dst_val;
9361 int payload_length = 0;
9362 u32 payload_length_val;
9365 u32 ip_version_traffic_class_and_flow_label;
9367 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9369 if (unformat (input, "version %d", &version_val))
9371 else if (unformat (input, "traffic_class %d", &traffic_class_val))
9373 else if (unformat (input, "flow_label %d", &flow_label_val))
9375 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
9377 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
9379 else if (unformat (input, "proto %d", &proto_val))
9381 else if (unformat (input, "payload_length %d", &payload_length_val))
9383 else if (unformat (input, "hop_limit %d", &hop_limit_val))
9389 if (version + traffic_class + flow_label + src + dst + proto +
9390 payload_length + hop_limit == 0)
9394 * Aligned because we use the real comparison functions
9396 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
9398 ip = (ip6_header_t *) match;
9401 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
9404 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
9407 ip->protocol = proto_val;
9409 ip_version_traffic_class_and_flow_label = 0;
9412 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
9415 ip_version_traffic_class_and_flow_label |=
9416 (traffic_class_val & 0xFF) << 20;
9419 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
9421 ip->ip_version_traffic_class_and_flow_label =
9422 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9425 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
9428 ip->hop_limit = hop_limit_val;
9435 unformat_l3_match (unformat_input_t * input, va_list * args)
9437 u8 **matchp = va_arg (*args, u8 **);
9439 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9441 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
9443 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
9452 unformat_vlan_tag (unformat_input_t * input, va_list * args)
9454 u8 *tagp = va_arg (*args, u8 *);
9457 if (unformat (input, "%d", &tag))
9459 tagp[0] = (tag >> 8) & 0x0F;
9460 tagp[1] = tag & 0xFF;
9468 unformat_l2_match (unformat_input_t * input, va_list * args)
9470 u8 **matchp = va_arg (*args, u8 **);
9490 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9492 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
9495 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
9497 else if (unformat (input, "proto %U",
9498 unformat_ethernet_type_host_byte_order, &proto_val))
9500 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
9502 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
9504 else if (unformat (input, "ignore-tag1"))
9506 else if (unformat (input, "ignore-tag2"))
9508 else if (unformat (input, "cos1 %d", &cos1_val))
9510 else if (unformat (input, "cos2 %d", &cos2_val))
9515 if ((src + dst + proto + tag1 + tag2 +
9516 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9519 if (tag1 || ignore_tag1 || cos1)
9521 if (tag2 || ignore_tag2 || cos2)
9524 vec_validate_aligned (match, len - 1, sizeof (u32x4));
9527 clib_memcpy (match, dst_val, 6);
9530 clib_memcpy (match + 6, src_val, 6);
9534 /* inner vlan tag */
9535 match[19] = tag2_val[1];
9536 match[18] = tag2_val[0];
9538 match[18] |= (cos2_val & 0x7) << 5;
9541 match[21] = proto_val & 0xff;
9542 match[20] = proto_val >> 8;
9546 match[15] = tag1_val[1];
9547 match[14] = tag1_val[0];
9550 match[14] |= (cos1_val & 0x7) << 5;
9556 match[15] = tag1_val[1];
9557 match[14] = tag1_val[0];
9560 match[17] = proto_val & 0xff;
9561 match[16] = proto_val >> 8;
9564 match[14] |= (cos1_val & 0x7) << 5;
9570 match[18] |= (cos2_val & 0x7) << 5;
9572 match[14] |= (cos1_val & 0x7) << 5;
9575 match[13] = proto_val & 0xff;
9576 match[12] = proto_val >> 8;
9585 api_unformat_classify_match (unformat_input_t * input, va_list * args)
9587 u8 **matchp = va_arg (*args, u8 **);
9588 u32 skip_n_vectors = va_arg (*args, u32);
9589 u32 match_n_vectors = va_arg (*args, u32);
9596 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9598 if (unformat (input, "hex %U", unformat_hex_string, &match))
9600 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
9602 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
9604 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
9618 if (match || l2 || l3 || l4)
9622 /* "Win a free Ethernet header in every packet" */
9624 vec_validate_aligned (l2, 13, sizeof (u32x4));
9628 vec_append_aligned (match, l3, sizeof (u32x4));
9633 vec_append_aligned (match, l4, sizeof (u32x4));
9638 /* Make sure the vector is big enough even if key is all 0's */
9639 vec_validate_aligned
9640 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
9643 /* Set size, include skipped vectors */
9644 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
9655 api_classify_add_del_session (vat_main_t * vam)
9657 unformat_input_t *i = vam->input;
9658 vl_api_classify_add_del_session_t *mp;
9660 u32 table_index = ~0;
9661 u32 hit_next_index = ~0;
9662 u32 opaque_index = ~0;
9665 u32 skip_n_vectors = 0;
9666 u32 match_n_vectors = 0;
9672 * Warning: you have to supply skip_n and match_n
9673 * because the API client cant simply look at the classify
9677 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9679 if (unformat (i, "del"))
9681 else if (unformat (i, "hit-next %U", api_unformat_ip_next_index,
9684 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
9687 else if (unformat (i, "acl-hit-next %U", api_unformat_acl_next_index,
9690 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
9692 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
9694 else if (unformat (i, "opaque-index %d", &opaque_index))
9696 else if (unformat (i, "skip_n %d", &skip_n_vectors))
9698 else if (unformat (i, "match_n %d", &match_n_vectors))
9700 else if (unformat (i, "match %U", api_unformat_classify_match,
9701 &match, skip_n_vectors, match_n_vectors))
9703 else if (unformat (i, "advance %d", &advance))
9705 else if (unformat (i, "table-index %d", &table_index))
9707 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
9709 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
9711 else if (unformat (i, "action %d", &action))
9713 else if (unformat (i, "metadata %d", &metadata))
9719 if (table_index == ~0)
9721 errmsg ("Table index required");
9725 if (is_add && match == 0)
9727 errmsg ("Match value required");
9731 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
9733 mp->is_add = is_add;
9734 mp->table_index = ntohl (table_index);
9735 mp->hit_next_index = ntohl (hit_next_index);
9736 mp->opaque_index = ntohl (opaque_index);
9737 mp->advance = ntohl (advance);
9738 mp->action = action;
9739 mp->metadata = ntohl (metadata);
9740 clib_memcpy (mp->match, match, vec_len (match));
9749 api_classify_set_interface_ip_table (vat_main_t * vam)
9751 unformat_input_t *i = vam->input;
9752 vl_api_classify_set_interface_ip_table_t *mp;
9754 int sw_if_index_set;
9755 u32 table_index = ~0;
9759 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9761 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9762 sw_if_index_set = 1;
9763 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9764 sw_if_index_set = 1;
9765 else if (unformat (i, "table %d", &table_index))
9769 clib_warning ("parse error '%U'", format_unformat_error, i);
9774 if (sw_if_index_set == 0)
9776 errmsg ("missing interface name or sw_if_index");
9781 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
9783 mp->sw_if_index = ntohl (sw_if_index);
9784 mp->table_index = ntohl (table_index);
9785 mp->is_ipv6 = is_ipv6;
9793 api_classify_set_interface_l2_tables (vat_main_t * vam)
9795 unformat_input_t *i = vam->input;
9796 vl_api_classify_set_interface_l2_tables_t *mp;
9798 int sw_if_index_set;
9799 u32 ip4_table_index = ~0;
9800 u32 ip6_table_index = ~0;
9801 u32 other_table_index = ~0;
9805 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9807 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9808 sw_if_index_set = 1;
9809 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9810 sw_if_index_set = 1;
9811 else if (unformat (i, "ip4-table %d", &ip4_table_index))
9813 else if (unformat (i, "ip6-table %d", &ip6_table_index))
9815 else if (unformat (i, "other-table %d", &other_table_index))
9817 else if (unformat (i, "is-input %d", &is_input))
9821 clib_warning ("parse error '%U'", format_unformat_error, i);
9826 if (sw_if_index_set == 0)
9828 errmsg ("missing interface name or sw_if_index");
9833 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
9835 mp->sw_if_index = ntohl (sw_if_index);
9836 mp->ip4_table_index = ntohl (ip4_table_index);
9837 mp->ip6_table_index = ntohl (ip6_table_index);
9838 mp->other_table_index = ntohl (other_table_index);
9839 mp->is_input = (u8) is_input;
9847 api_set_ipfix_exporter (vat_main_t * vam)
9849 unformat_input_t *i = vam->input;
9850 vl_api_set_ipfix_exporter_t *mp;
9851 ip4_address_t collector_address;
9852 u8 collector_address_set = 0;
9853 u32 collector_port = ~0;
9854 ip4_address_t src_address;
9855 u8 src_address_set = 0;
9858 u32 template_interval = ~0;
9859 u8 udp_checksum = 0;
9862 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9864 if (unformat (i, "collector_address %U", unformat_ip4_address,
9865 &collector_address))
9866 collector_address_set = 1;
9867 else if (unformat (i, "collector_port %d", &collector_port))
9869 else if (unformat (i, "src_address %U", unformat_ip4_address,
9871 src_address_set = 1;
9872 else if (unformat (i, "vrf_id %d", &vrf_id))
9874 else if (unformat (i, "path_mtu %d", &path_mtu))
9876 else if (unformat (i, "template_interval %d", &template_interval))
9878 else if (unformat (i, "udp_checksum"))
9884 if (collector_address_set == 0)
9886 errmsg ("collector_address required");
9890 if (src_address_set == 0)
9892 errmsg ("src_address required");
9896 M (SET_IPFIX_EXPORTER, mp);
9898 memcpy (mp->collector_address, collector_address.data,
9899 sizeof (collector_address.data));
9900 mp->collector_port = htons ((u16) collector_port);
9901 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
9902 mp->vrf_id = htonl (vrf_id);
9903 mp->path_mtu = htonl (path_mtu);
9904 mp->template_interval = htonl (template_interval);
9905 mp->udp_checksum = udp_checksum;
9913 api_set_ipfix_classify_stream (vat_main_t * vam)
9915 unformat_input_t *i = vam->input;
9916 vl_api_set_ipfix_classify_stream_t *mp;
9918 u32 src_port = UDP_DST_PORT_ipfix;
9921 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9923 if (unformat (i, "domain %d", &domain_id))
9925 else if (unformat (i, "src_port %d", &src_port))
9929 errmsg ("unknown input `%U'", format_unformat_error, i);
9934 M (SET_IPFIX_CLASSIFY_STREAM, mp);
9936 mp->domain_id = htonl (domain_id);
9937 mp->src_port = htons ((u16) src_port);
9945 api_ipfix_classify_table_add_del (vat_main_t * vam)
9947 unformat_input_t *i = vam->input;
9948 vl_api_ipfix_classify_table_add_del_t *mp;
9950 u32 classify_table_index = ~0;
9952 u8 transport_protocol = 255;
9955 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9957 if (unformat (i, "add"))
9959 else if (unformat (i, "del"))
9961 else if (unformat (i, "table %d", &classify_table_index))
9963 else if (unformat (i, "ip4"))
9965 else if (unformat (i, "ip6"))
9967 else if (unformat (i, "tcp"))
9968 transport_protocol = 6;
9969 else if (unformat (i, "udp"))
9970 transport_protocol = 17;
9973 errmsg ("unknown input `%U'", format_unformat_error, i);
9980 errmsg ("expecting: add|del");
9983 if (classify_table_index == ~0)
9985 errmsg ("classifier table not specified");
9988 if (ip_version == 0)
9990 errmsg ("IP version not specified");
9994 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
9996 mp->is_add = is_add;
9997 mp->table_id = htonl (classify_table_index);
9998 mp->ip_version = ip_version;
9999 mp->transport_protocol = transport_protocol;
10007 api_get_node_index (vat_main_t * vam)
10009 unformat_input_t *i = vam->input;
10010 vl_api_get_node_index_t *mp;
10014 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10016 if (unformat (i, "node %s", &name))
10023 errmsg ("node name required");
10026 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10028 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10032 M (GET_NODE_INDEX, mp);
10033 clib_memcpy (mp->node_name, name, vec_len (name));
10042 api_get_next_index (vat_main_t * vam)
10044 unformat_input_t *i = vam->input;
10045 vl_api_get_next_index_t *mp;
10046 u8 *node_name = 0, *next_node_name = 0;
10049 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10051 if (unformat (i, "node-name %s", &node_name))
10053 else if (unformat (i, "next-node-name %s", &next_node_name))
10057 if (node_name == 0)
10059 errmsg ("node name required");
10062 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
10064 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10068 if (next_node_name == 0)
10070 errmsg ("next node name required");
10073 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
10075 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
10079 M (GET_NEXT_INDEX, mp);
10080 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
10081 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
10082 vec_free (node_name);
10083 vec_free (next_node_name);
10091 api_add_node_next (vat_main_t * vam)
10093 unformat_input_t *i = vam->input;
10094 vl_api_add_node_next_t *mp;
10099 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10101 if (unformat (i, "node %s", &name))
10103 else if (unformat (i, "next %s", &next))
10110 errmsg ("node name required");
10113 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10115 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10120 errmsg ("next node required");
10123 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
10125 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
10129 M (ADD_NODE_NEXT, mp);
10130 clib_memcpy (mp->node_name, name, vec_len (name));
10131 clib_memcpy (mp->next_name, next, vec_len (next));
10141 api_l2tpv3_create_tunnel (vat_main_t * vam)
10143 unformat_input_t *i = vam->input;
10144 ip6_address_t client_address, our_address;
10145 int client_address_set = 0;
10146 int our_address_set = 0;
10147 u32 local_session_id = 0;
10148 u32 remote_session_id = 0;
10149 u64 local_cookie = 0;
10150 u64 remote_cookie = 0;
10151 u8 l2_sublayer_present = 0;
10152 vl_api_l2tpv3_create_tunnel_t *mp;
10155 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10157 if (unformat (i, "client_address %U", unformat_ip6_address,
10159 client_address_set = 1;
10160 else if (unformat (i, "our_address %U", unformat_ip6_address,
10162 our_address_set = 1;
10163 else if (unformat (i, "local_session_id %d", &local_session_id))
10165 else if (unformat (i, "remote_session_id %d", &remote_session_id))
10167 else if (unformat (i, "local_cookie %lld", &local_cookie))
10169 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
10171 else if (unformat (i, "l2-sublayer-present"))
10172 l2_sublayer_present = 1;
10177 if (client_address_set == 0)
10179 errmsg ("client_address required");
10183 if (our_address_set == 0)
10185 errmsg ("our_address required");
10189 M (L2TPV3_CREATE_TUNNEL, mp);
10191 clib_memcpy (mp->client_address, client_address.as_u8,
10192 sizeof (mp->client_address));
10194 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
10196 mp->local_session_id = ntohl (local_session_id);
10197 mp->remote_session_id = ntohl (remote_session_id);
10198 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
10199 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
10200 mp->l2_sublayer_present = l2_sublayer_present;
10209 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
10211 unformat_input_t *i = vam->input;
10213 u8 sw_if_index_set = 0;
10214 u64 new_local_cookie = 0;
10215 u64 new_remote_cookie = 0;
10216 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
10219 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10221 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10222 sw_if_index_set = 1;
10223 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10224 sw_if_index_set = 1;
10225 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
10227 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
10233 if (sw_if_index_set == 0)
10235 errmsg ("missing interface name or sw_if_index");
10239 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
10241 mp->sw_if_index = ntohl (sw_if_index);
10242 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
10243 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
10251 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
10253 unformat_input_t *i = vam->input;
10254 vl_api_l2tpv3_interface_enable_disable_t *mp;
10256 u8 sw_if_index_set = 0;
10257 u8 enable_disable = 1;
10260 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10262 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10263 sw_if_index_set = 1;
10264 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10265 sw_if_index_set = 1;
10266 else if (unformat (i, "enable"))
10267 enable_disable = 1;
10268 else if (unformat (i, "disable"))
10269 enable_disable = 0;
10274 if (sw_if_index_set == 0)
10276 errmsg ("missing interface name or sw_if_index");
10280 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
10282 mp->sw_if_index = ntohl (sw_if_index);
10283 mp->enable_disable = enable_disable;
10291 api_l2tpv3_set_lookup_key (vat_main_t * vam)
10293 unformat_input_t *i = vam->input;
10294 vl_api_l2tpv3_set_lookup_key_t *mp;
10298 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10300 if (unformat (i, "lookup_v6_src"))
10301 key = L2T_LOOKUP_SRC_ADDRESS;
10302 else if (unformat (i, "lookup_v6_dst"))
10303 key = L2T_LOOKUP_DST_ADDRESS;
10304 else if (unformat (i, "lookup_session_id"))
10305 key = L2T_LOOKUP_SESSION_ID;
10310 if (key == (u8) ~ 0)
10312 errmsg ("l2tp session lookup key unset");
10316 M (L2TPV3_SET_LOOKUP_KEY, mp);
10325 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
10326 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
10328 vat_main_t *vam = &vat_main;
10330 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
10331 format_ip6_address, mp->our_address,
10332 format_ip6_address, mp->client_address,
10333 clib_net_to_host_u32 (mp->sw_if_index));
10336 " local cookies %016llx %016llx remote cookie %016llx",
10337 clib_net_to_host_u64 (mp->local_cookie[0]),
10338 clib_net_to_host_u64 (mp->local_cookie[1]),
10339 clib_net_to_host_u64 (mp->remote_cookie));
10341 print (vam->ofp, " local session-id %d remote session-id %d",
10342 clib_net_to_host_u32 (mp->local_session_id),
10343 clib_net_to_host_u32 (mp->remote_session_id));
10345 print (vam->ofp, " l2 specific sublayer %s\n",
10346 mp->l2_sublayer_present ? "preset" : "absent");
10350 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
10351 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
10353 vat_main_t *vam = &vat_main;
10354 vat_json_node_t *node = NULL;
10355 struct in6_addr addr;
10357 if (VAT_JSON_ARRAY != vam->json_tree.type)
10359 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10360 vat_json_init_array (&vam->json_tree);
10362 node = vat_json_array_add (&vam->json_tree);
10364 vat_json_init_object (node);
10366 clib_memcpy (&addr, mp->our_address, sizeof (addr));
10367 vat_json_object_add_ip6 (node, "our_address", addr);
10368 clib_memcpy (&addr, mp->client_address, sizeof (addr));
10369 vat_json_object_add_ip6 (node, "client_address", addr);
10371 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
10372 vat_json_init_array (lc);
10373 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
10374 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
10375 vat_json_object_add_uint (node, "remote_cookie",
10376 clib_net_to_host_u64 (mp->remote_cookie));
10378 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
10379 vat_json_object_add_uint (node, "local_session_id",
10380 clib_net_to_host_u32 (mp->local_session_id));
10381 vat_json_object_add_uint (node, "remote_session_id",
10382 clib_net_to_host_u32 (mp->remote_session_id));
10383 vat_json_object_add_string_copy (node, "l2_sublayer",
10384 mp->l2_sublayer_present ? (u8 *) "present"
10385 : (u8 *) "absent");
10389 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
10391 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
10392 vl_api_control_ping_t *mp_ping;
10395 /* Get list of l2tpv3-tunnel interfaces */
10396 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
10399 /* Use a control ping for synchronization */
10400 M (CONTROL_PING, mp_ping);
10408 static void vl_api_sw_interface_tap_details_t_handler
10409 (vl_api_sw_interface_tap_details_t * mp)
10411 vat_main_t *vam = &vat_main;
10413 print (vam->ofp, "%-16s %d",
10414 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
10417 static void vl_api_sw_interface_tap_details_t_handler_json
10418 (vl_api_sw_interface_tap_details_t * mp)
10420 vat_main_t *vam = &vat_main;
10421 vat_json_node_t *node = NULL;
10423 if (VAT_JSON_ARRAY != vam->json_tree.type)
10425 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10426 vat_json_init_array (&vam->json_tree);
10428 node = vat_json_array_add (&vam->json_tree);
10430 vat_json_init_object (node);
10431 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10432 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
10436 api_sw_interface_tap_dump (vat_main_t * vam)
10438 vl_api_sw_interface_tap_dump_t *mp;
10439 vl_api_control_ping_t *mp_ping;
10442 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
10443 /* Get list of tap interfaces */
10444 M (SW_INTERFACE_TAP_DUMP, mp);
10447 /* Use a control ping for synchronization */
10448 M (CONTROL_PING, mp_ping);
10455 static uword unformat_vxlan_decap_next
10456 (unformat_input_t * input, va_list * args)
10458 u32 *result = va_arg (*args, u32 *);
10461 if (unformat (input, "l2"))
10462 *result = VXLAN_INPUT_NEXT_L2_INPUT;
10463 else if (unformat (input, "%d", &tmp))
10471 api_vxlan_add_del_tunnel (vat_main_t * vam)
10473 unformat_input_t *line_input = vam->input;
10474 vl_api_vxlan_add_del_tunnel_t *mp;
10475 ip46_address_t src, dst;
10477 u8 ipv4_set = 0, ipv6_set = 0;
10481 u32 mcast_sw_if_index = ~0;
10482 u32 encap_vrf_id = 0;
10483 u32 decap_next_index = ~0;
10487 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
10488 memset (&src, 0, sizeof src);
10489 memset (&dst, 0, sizeof dst);
10491 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10493 if (unformat (line_input, "del"))
10496 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
10502 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
10508 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
10514 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
10519 else if (unformat (line_input, "group %U %U",
10520 unformat_ip4_address, &dst.ip4,
10521 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
10523 grp_set = dst_set = 1;
10526 else if (unformat (line_input, "group %U",
10527 unformat_ip4_address, &dst.ip4))
10529 grp_set = dst_set = 1;
10532 else if (unformat (line_input, "group %U %U",
10533 unformat_ip6_address, &dst.ip6,
10534 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
10536 grp_set = dst_set = 1;
10539 else if (unformat (line_input, "group %U",
10540 unformat_ip6_address, &dst.ip6))
10542 grp_set = dst_set = 1;
10546 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
10548 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
10550 else if (unformat (line_input, "decap-next %U",
10551 unformat_vxlan_decap_next, &decap_next_index))
10553 else if (unformat (line_input, "vni %d", &vni))
10557 errmsg ("parse error '%U'", format_unformat_error, line_input);
10564 errmsg ("tunnel src address not specified");
10569 errmsg ("tunnel dst address not specified");
10573 if (grp_set && !ip46_address_is_multicast (&dst))
10575 errmsg ("tunnel group address not multicast");
10578 if (grp_set && mcast_sw_if_index == ~0)
10580 errmsg ("tunnel nonexistent multicast device");
10583 if (grp_set == 0 && ip46_address_is_multicast (&dst))
10585 errmsg ("tunnel dst address must be unicast");
10590 if (ipv4_set && ipv6_set)
10592 errmsg ("both IPv4 and IPv6 addresses specified");
10596 if ((vni == 0) || (vni >> 24))
10598 errmsg ("vni not specified or out of range");
10602 M (VXLAN_ADD_DEL_TUNNEL, mp);
10606 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
10607 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
10611 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
10612 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
10614 mp->encap_vrf_id = ntohl (encap_vrf_id);
10615 mp->decap_next_index = ntohl (decap_next_index);
10616 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
10617 mp->vni = ntohl (vni);
10618 mp->is_add = is_add;
10619 mp->is_ipv6 = ipv6_set;
10626 static void vl_api_vxlan_tunnel_details_t_handler
10627 (vl_api_vxlan_tunnel_details_t * mp)
10629 vat_main_t *vam = &vat_main;
10630 ip46_address_t src, dst;
10632 ip46_from_addr_buf (mp->is_ipv6, mp->src_address, &src);
10633 ip46_from_addr_buf (mp->is_ipv6, mp->dst_address, &dst);
10635 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
10636 ntohl (mp->sw_if_index),
10637 format_ip46_address, &src, IP46_TYPE_ANY,
10638 format_ip46_address, &dst, IP46_TYPE_ANY,
10639 ntohl (mp->encap_vrf_id),
10640 ntohl (mp->decap_next_index), ntohl (mp->vni),
10641 ntohl (mp->mcast_sw_if_index));
10644 static void vl_api_vxlan_tunnel_details_t_handler_json
10645 (vl_api_vxlan_tunnel_details_t * mp)
10647 vat_main_t *vam = &vat_main;
10648 vat_json_node_t *node = NULL;
10650 if (VAT_JSON_ARRAY != vam->json_tree.type)
10652 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10653 vat_json_init_array (&vam->json_tree);
10655 node = vat_json_array_add (&vam->json_tree);
10657 vat_json_init_object (node);
10658 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10661 struct in6_addr ip6;
10663 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
10664 vat_json_object_add_ip6 (node, "src_address", ip6);
10665 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
10666 vat_json_object_add_ip6 (node, "dst_address", ip6);
10670 struct in_addr ip4;
10672 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
10673 vat_json_object_add_ip4 (node, "src_address", ip4);
10674 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
10675 vat_json_object_add_ip4 (node, "dst_address", ip4);
10677 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
10678 vat_json_object_add_uint (node, "decap_next_index",
10679 ntohl (mp->decap_next_index));
10680 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
10681 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
10682 vat_json_object_add_uint (node, "mcast_sw_if_index",
10683 ntohl (mp->mcast_sw_if_index));
10687 api_vxlan_tunnel_dump (vat_main_t * vam)
10689 unformat_input_t *i = vam->input;
10690 vl_api_vxlan_tunnel_dump_t *mp;
10691 vl_api_control_ping_t *mp_ping;
10693 u8 sw_if_index_set = 0;
10696 /* Parse args required to build the message */
10697 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10699 if (unformat (i, "sw_if_index %d", &sw_if_index))
10700 sw_if_index_set = 1;
10705 if (sw_if_index_set == 0)
10710 if (!vam->json_output)
10712 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
10713 "sw_if_index", "src_address", "dst_address",
10714 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
10717 /* Get list of vxlan-tunnel interfaces */
10718 M (VXLAN_TUNNEL_DUMP, mp);
10720 mp->sw_if_index = htonl (sw_if_index);
10724 /* Use a control ping for synchronization */
10725 M (CONTROL_PING, mp_ping);
10733 api_gre_add_del_tunnel (vat_main_t * vam)
10735 unformat_input_t *line_input = vam->input;
10736 vl_api_gre_add_del_tunnel_t *mp;
10737 ip4_address_t src4, dst4;
10742 u32 outer_fib_id = 0;
10745 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10747 if (unformat (line_input, "del"))
10749 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
10751 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
10753 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
10755 else if (unformat (line_input, "teb"))
10759 errmsg ("parse error '%U'", format_unformat_error, line_input);
10766 errmsg ("tunnel src address not specified");
10771 errmsg ("tunnel dst address not specified");
10776 M (GRE_ADD_DEL_TUNNEL, mp);
10778 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
10779 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
10780 mp->outer_fib_id = ntohl (outer_fib_id);
10781 mp->is_add = is_add;
10789 static void vl_api_gre_tunnel_details_t_handler
10790 (vl_api_gre_tunnel_details_t * mp)
10792 vat_main_t *vam = &vat_main;
10794 print (vam->ofp, "%11d%15U%15U%6d%14d",
10795 ntohl (mp->sw_if_index),
10796 format_ip4_address, &mp->src_address,
10797 format_ip4_address, &mp->dst_address,
10798 mp->teb, ntohl (mp->outer_fib_id));
10801 static void vl_api_gre_tunnel_details_t_handler_json
10802 (vl_api_gre_tunnel_details_t * mp)
10804 vat_main_t *vam = &vat_main;
10805 vat_json_node_t *node = NULL;
10806 struct in_addr ip4;
10808 if (VAT_JSON_ARRAY != vam->json_tree.type)
10810 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10811 vat_json_init_array (&vam->json_tree);
10813 node = vat_json_array_add (&vam->json_tree);
10815 vat_json_init_object (node);
10816 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10817 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
10818 vat_json_object_add_ip4 (node, "src_address", ip4);
10819 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
10820 vat_json_object_add_ip4 (node, "dst_address", ip4);
10821 vat_json_object_add_uint (node, "teb", mp->teb);
10822 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
10826 api_gre_tunnel_dump (vat_main_t * vam)
10828 unformat_input_t *i = vam->input;
10829 vl_api_gre_tunnel_dump_t *mp;
10830 vl_api_control_ping_t *mp_ping;
10832 u8 sw_if_index_set = 0;
10835 /* Parse args required to build the message */
10836 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10838 if (unformat (i, "sw_if_index %d", &sw_if_index))
10839 sw_if_index_set = 1;
10844 if (sw_if_index_set == 0)
10849 if (!vam->json_output)
10851 print (vam->ofp, "%11s%15s%15s%6s%14s",
10852 "sw_if_index", "src_address", "dst_address", "teb",
10856 /* Get list of gre-tunnel interfaces */
10857 M (GRE_TUNNEL_DUMP, mp);
10859 mp->sw_if_index = htonl (sw_if_index);
10863 /* Use a control ping for synchronization */
10864 M (CONTROL_PING, mp_ping);
10872 api_l2_fib_clear_table (vat_main_t * vam)
10874 // unformat_input_t * i = vam->input;
10875 vl_api_l2_fib_clear_table_t *mp;
10878 M (L2_FIB_CLEAR_TABLE, mp);
10886 api_l2_interface_efp_filter (vat_main_t * vam)
10888 unformat_input_t *i = vam->input;
10889 vl_api_l2_interface_efp_filter_t *mp;
10892 u8 sw_if_index_set = 0;
10895 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10897 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10898 sw_if_index_set = 1;
10899 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10900 sw_if_index_set = 1;
10901 else if (unformat (i, "enable"))
10903 else if (unformat (i, "disable"))
10907 clib_warning ("parse error '%U'", format_unformat_error, i);
10912 if (sw_if_index_set == 0)
10914 errmsg ("missing sw_if_index");
10918 M (L2_INTERFACE_EFP_FILTER, mp);
10920 mp->sw_if_index = ntohl (sw_if_index);
10921 mp->enable_disable = enable;
10928 #define foreach_vtr_op \
10929 _("disable", L2_VTR_DISABLED) \
10930 _("push-1", L2_VTR_PUSH_1) \
10931 _("push-2", L2_VTR_PUSH_2) \
10932 _("pop-1", L2_VTR_POP_1) \
10933 _("pop-2", L2_VTR_POP_2) \
10934 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
10935 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
10936 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
10937 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
10940 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
10942 unformat_input_t *i = vam->input;
10943 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
10945 u8 sw_if_index_set = 0;
10948 u32 push_dot1q = 1;
10953 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10955 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10956 sw_if_index_set = 1;
10957 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10958 sw_if_index_set = 1;
10959 else if (unformat (i, "vtr_op %d", &vtr_op))
10961 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
10964 else if (unformat (i, "push_dot1q %d", &push_dot1q))
10966 else if (unformat (i, "tag1 %d", &tag1))
10968 else if (unformat (i, "tag2 %d", &tag2))
10972 clib_warning ("parse error '%U'", format_unformat_error, i);
10977 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
10979 errmsg ("missing vtr operation or sw_if_index");
10983 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
10984 mp->sw_if_index = ntohl (sw_if_index);
10985 mp->vtr_op = ntohl (vtr_op);
10986 mp->push_dot1q = ntohl (push_dot1q);
10987 mp->tag1 = ntohl (tag1);
10988 mp->tag2 = ntohl (tag2);
10996 api_create_vhost_user_if (vat_main_t * vam)
10998 unformat_input_t *i = vam->input;
10999 vl_api_create_vhost_user_if_t *mp;
11002 u8 file_name_set = 0;
11003 u32 custom_dev_instance = ~0;
11005 u8 use_custom_mac = 0;
11009 /* Shut up coverity */
11010 memset (hwaddr, 0, sizeof (hwaddr));
11012 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11014 if (unformat (i, "socket %s", &file_name))
11018 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
11020 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
11021 use_custom_mac = 1;
11022 else if (unformat (i, "server"))
11024 else if (unformat (i, "tag %s", &tag))
11030 if (file_name_set == 0)
11032 errmsg ("missing socket file name");
11036 if (vec_len (file_name) > 255)
11038 errmsg ("socket file name too long");
11041 vec_add1 (file_name, 0);
11043 M (CREATE_VHOST_USER_IF, mp);
11045 mp->is_server = is_server;
11046 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
11047 vec_free (file_name);
11048 if (custom_dev_instance != ~0)
11051 mp->custom_dev_instance = ntohl (custom_dev_instance);
11053 mp->use_custom_mac = use_custom_mac;
11054 clib_memcpy (mp->mac_address, hwaddr, 6);
11056 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
11065 api_modify_vhost_user_if (vat_main_t * vam)
11067 unformat_input_t *i = vam->input;
11068 vl_api_modify_vhost_user_if_t *mp;
11071 u8 file_name_set = 0;
11072 u32 custom_dev_instance = ~0;
11073 u8 sw_if_index_set = 0;
11074 u32 sw_if_index = (u32) ~ 0;
11077 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11079 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11080 sw_if_index_set = 1;
11081 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11082 sw_if_index_set = 1;
11083 else if (unformat (i, "socket %s", &file_name))
11087 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
11089 else if (unformat (i, "server"))
11095 if (sw_if_index_set == 0)
11097 errmsg ("missing sw_if_index or interface name");
11101 if (file_name_set == 0)
11103 errmsg ("missing socket file name");
11107 if (vec_len (file_name) > 255)
11109 errmsg ("socket file name too long");
11112 vec_add1 (file_name, 0);
11114 M (MODIFY_VHOST_USER_IF, mp);
11116 mp->sw_if_index = ntohl (sw_if_index);
11117 mp->is_server = is_server;
11118 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
11119 vec_free (file_name);
11120 if (custom_dev_instance != ~0)
11123 mp->custom_dev_instance = ntohl (custom_dev_instance);
11132 api_delete_vhost_user_if (vat_main_t * vam)
11134 unformat_input_t *i = vam->input;
11135 vl_api_delete_vhost_user_if_t *mp;
11136 u32 sw_if_index = ~0;
11137 u8 sw_if_index_set = 0;
11140 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11142 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11143 sw_if_index_set = 1;
11144 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11145 sw_if_index_set = 1;
11150 if (sw_if_index_set == 0)
11152 errmsg ("missing sw_if_index or interface name");
11157 M (DELETE_VHOST_USER_IF, mp);
11159 mp->sw_if_index = ntohl (sw_if_index);
11166 static void vl_api_sw_interface_vhost_user_details_t_handler
11167 (vl_api_sw_interface_vhost_user_details_t * mp)
11169 vat_main_t *vam = &vat_main;
11171 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
11172 (char *) mp->interface_name,
11173 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
11174 clib_net_to_host_u64 (mp->features), mp->is_server,
11175 ntohl (mp->num_regions), (char *) mp->sock_filename);
11176 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
11179 static void vl_api_sw_interface_vhost_user_details_t_handler_json
11180 (vl_api_sw_interface_vhost_user_details_t * mp)
11182 vat_main_t *vam = &vat_main;
11183 vat_json_node_t *node = NULL;
11185 if (VAT_JSON_ARRAY != vam->json_tree.type)
11187 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11188 vat_json_init_array (&vam->json_tree);
11190 node = vat_json_array_add (&vam->json_tree);
11192 vat_json_init_object (node);
11193 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11194 vat_json_object_add_string_copy (node, "interface_name",
11195 mp->interface_name);
11196 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
11197 ntohl (mp->virtio_net_hdr_sz));
11198 vat_json_object_add_uint (node, "features",
11199 clib_net_to_host_u64 (mp->features));
11200 vat_json_object_add_uint (node, "is_server", mp->is_server);
11201 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
11202 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
11203 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
11207 api_sw_interface_vhost_user_dump (vat_main_t * vam)
11209 vl_api_sw_interface_vhost_user_dump_t *mp;
11210 vl_api_control_ping_t *mp_ping;
11213 "Interface name idx hdr_sz features server regions filename");
11215 /* Get list of vhost-user interfaces */
11216 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
11219 /* Use a control ping for synchronization */
11220 M (CONTROL_PING, mp_ping);
11228 api_show_version (vat_main_t * vam)
11230 vl_api_show_version_t *mp;
11233 M (SHOW_VERSION, mp);
11242 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
11244 unformat_input_t *line_input = vam->input;
11245 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
11246 ip4_address_t local4, remote4;
11247 ip6_address_t local6, remote6;
11249 u8 ipv4_set = 0, ipv6_set = 0;
11252 u32 encap_vrf_id = 0;
11253 u32 decap_vrf_id = 0;
11259 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11261 if (unformat (line_input, "del"))
11263 else if (unformat (line_input, "local %U",
11264 unformat_ip4_address, &local4))
11269 else if (unformat (line_input, "remote %U",
11270 unformat_ip4_address, &remote4))
11275 else if (unformat (line_input, "local %U",
11276 unformat_ip6_address, &local6))
11281 else if (unformat (line_input, "remote %U",
11282 unformat_ip6_address, &remote6))
11287 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11289 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
11291 else if (unformat (line_input, "vni %d", &vni))
11293 else if (unformat (line_input, "next-ip4"))
11295 else if (unformat (line_input, "next-ip6"))
11297 else if (unformat (line_input, "next-ethernet"))
11299 else if (unformat (line_input, "next-nsh"))
11303 errmsg ("parse error '%U'", format_unformat_error, line_input);
11308 if (local_set == 0)
11310 errmsg ("tunnel local address not specified");
11313 if (remote_set == 0)
11315 errmsg ("tunnel remote address not specified");
11318 if (ipv4_set && ipv6_set)
11320 errmsg ("both IPv4 and IPv6 addresses specified");
11326 errmsg ("vni not specified");
11330 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
11335 clib_memcpy (&mp->local, &local6, sizeof (local6));
11336 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
11340 clib_memcpy (&mp->local, &local4, sizeof (local4));
11341 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
11344 mp->encap_vrf_id = ntohl (encap_vrf_id);
11345 mp->decap_vrf_id = ntohl (decap_vrf_id);
11346 mp->protocol = protocol;
11347 mp->vni = ntohl (vni);
11348 mp->is_add = is_add;
11349 mp->is_ipv6 = ipv6_set;
11356 static void vl_api_vxlan_gpe_tunnel_details_t_handler
11357 (vl_api_vxlan_gpe_tunnel_details_t * mp)
11359 vat_main_t *vam = &vat_main;
11361 print (vam->ofp, "%11d%24U%24U%13d%12d%14d%14d",
11362 ntohl (mp->sw_if_index),
11363 format_ip46_address, &(mp->local[0]),
11364 format_ip46_address, &(mp->remote[0]),
11366 ntohl (mp->protocol),
11367 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
11370 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
11371 (vl_api_vxlan_gpe_tunnel_details_t * mp)
11373 vat_main_t *vam = &vat_main;
11374 vat_json_node_t *node = NULL;
11375 struct in_addr ip4;
11376 struct in6_addr ip6;
11378 if (VAT_JSON_ARRAY != vam->json_tree.type)
11380 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11381 vat_json_init_array (&vam->json_tree);
11383 node = vat_json_array_add (&vam->json_tree);
11385 vat_json_init_object (node);
11386 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11389 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
11390 vat_json_object_add_ip6 (node, "local", ip6);
11391 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
11392 vat_json_object_add_ip6 (node, "remote", ip6);
11396 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
11397 vat_json_object_add_ip4 (node, "local", ip4);
11398 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
11399 vat_json_object_add_ip4 (node, "remote", ip4);
11401 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
11402 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
11403 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
11404 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
11405 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
11409 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
11411 unformat_input_t *i = vam->input;
11412 vl_api_vxlan_gpe_tunnel_dump_t *mp;
11413 vl_api_control_ping_t *mp_ping;
11415 u8 sw_if_index_set = 0;
11418 /* Parse args required to build the message */
11419 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11421 if (unformat (i, "sw_if_index %d", &sw_if_index))
11422 sw_if_index_set = 1;
11427 if (sw_if_index_set == 0)
11432 if (!vam->json_output)
11434 print (vam->ofp, "%11s%24s%24s%13s%15s%14s%14s",
11435 "sw_if_index", "local", "remote", "vni",
11436 "protocol", "encap_vrf_id", "decap_vrf_id");
11439 /* Get list of vxlan-tunnel interfaces */
11440 M (VXLAN_GPE_TUNNEL_DUMP, mp);
11442 mp->sw_if_index = htonl (sw_if_index);
11446 /* Use a control ping for synchronization */
11447 M (CONTROL_PING, mp_ping);
11455 format_l2_fib_mac_address (u8 * s, va_list * args)
11457 u8 *a = va_arg (*args, u8 *);
11459 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
11460 a[2], a[3], a[4], a[5], a[6], a[7]);
11463 static void vl_api_l2_fib_table_entry_t_handler
11464 (vl_api_l2_fib_table_entry_t * mp)
11466 vat_main_t *vam = &vat_main;
11468 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
11470 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
11471 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
11475 static void vl_api_l2_fib_table_entry_t_handler_json
11476 (vl_api_l2_fib_table_entry_t * mp)
11478 vat_main_t *vam = &vat_main;
11479 vat_json_node_t *node = NULL;
11481 if (VAT_JSON_ARRAY != vam->json_tree.type)
11483 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11484 vat_json_init_array (&vam->json_tree);
11486 node = vat_json_array_add (&vam->json_tree);
11488 vat_json_init_object (node);
11489 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
11490 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
11491 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11492 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
11493 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
11494 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
11498 api_l2_fib_table_dump (vat_main_t * vam)
11500 unformat_input_t *i = vam->input;
11501 vl_api_l2_fib_table_dump_t *mp;
11502 vl_api_control_ping_t *mp_ping;
11507 /* Parse args required to build the message */
11508 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11510 if (unformat (i, "bd_id %d", &bd_id))
11516 if (bd_id_set == 0)
11518 errmsg ("missing bridge domain");
11522 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
11524 /* Get list of l2 fib entries */
11525 M (L2_FIB_TABLE_DUMP, mp);
11527 mp->bd_id = ntohl (bd_id);
11530 /* Use a control ping for synchronization */
11531 M (CONTROL_PING, mp_ping);
11540 api_interface_name_renumber (vat_main_t * vam)
11542 unformat_input_t *line_input = vam->input;
11543 vl_api_interface_name_renumber_t *mp;
11544 u32 sw_if_index = ~0;
11545 u32 new_show_dev_instance = ~0;
11548 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11550 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
11553 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11555 else if (unformat (line_input, "new_show_dev_instance %d",
11556 &new_show_dev_instance))
11562 if (sw_if_index == ~0)
11564 errmsg ("missing interface name or sw_if_index");
11568 if (new_show_dev_instance == ~0)
11570 errmsg ("missing new_show_dev_instance");
11574 M (INTERFACE_NAME_RENUMBER, mp);
11576 mp->sw_if_index = ntohl (sw_if_index);
11577 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
11585 api_want_ip4_arp_events (vat_main_t * vam)
11587 unformat_input_t *line_input = vam->input;
11588 vl_api_want_ip4_arp_events_t *mp;
11589 ip4_address_t address;
11590 int address_set = 0;
11591 u32 enable_disable = 1;
11594 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11596 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
11598 else if (unformat (line_input, "del"))
11599 enable_disable = 0;
11604 if (address_set == 0)
11606 errmsg ("missing addresses");
11610 M (WANT_IP4_ARP_EVENTS, mp);
11611 mp->enable_disable = enable_disable;
11612 mp->pid = getpid ();
11613 mp->address = address.as_u32;
11621 api_want_ip6_nd_events (vat_main_t * vam)
11623 unformat_input_t *line_input = vam->input;
11624 vl_api_want_ip6_nd_events_t *mp;
11625 ip6_address_t address;
11626 int address_set = 0;
11627 u32 enable_disable = 1;
11630 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11632 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
11634 else if (unformat (line_input, "del"))
11635 enable_disable = 0;
11640 if (address_set == 0)
11642 errmsg ("missing addresses");
11646 M (WANT_IP6_ND_EVENTS, mp);
11647 mp->enable_disable = enable_disable;
11648 mp->pid = getpid ();
11649 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
11657 api_input_acl_set_interface (vat_main_t * vam)
11659 unformat_input_t *i = vam->input;
11660 vl_api_input_acl_set_interface_t *mp;
11662 int sw_if_index_set;
11663 u32 ip4_table_index = ~0;
11664 u32 ip6_table_index = ~0;
11665 u32 l2_table_index = ~0;
11669 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11671 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11672 sw_if_index_set = 1;
11673 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11674 sw_if_index_set = 1;
11675 else if (unformat (i, "del"))
11677 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11679 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11681 else if (unformat (i, "l2-table %d", &l2_table_index))
11685 clib_warning ("parse error '%U'", format_unformat_error, i);
11690 if (sw_if_index_set == 0)
11692 errmsg ("missing interface name or sw_if_index");
11696 M (INPUT_ACL_SET_INTERFACE, mp);
11698 mp->sw_if_index = ntohl (sw_if_index);
11699 mp->ip4_table_index = ntohl (ip4_table_index);
11700 mp->ip6_table_index = ntohl (ip6_table_index);
11701 mp->l2_table_index = ntohl (l2_table_index);
11702 mp->is_add = is_add;
11710 api_ip_address_dump (vat_main_t * vam)
11712 unformat_input_t *i = vam->input;
11713 vl_api_ip_address_dump_t *mp;
11714 vl_api_control_ping_t *mp_ping;
11715 u32 sw_if_index = ~0;
11716 u8 sw_if_index_set = 0;
11721 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11723 if (unformat (i, "sw_if_index %d", &sw_if_index))
11724 sw_if_index_set = 1;
11726 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11727 sw_if_index_set = 1;
11728 else if (unformat (i, "ipv4"))
11730 else if (unformat (i, "ipv6"))
11736 if (ipv4_set && ipv6_set)
11738 errmsg ("ipv4 and ipv6 flags cannot be both set");
11742 if ((!ipv4_set) && (!ipv6_set))
11744 errmsg ("no ipv4 nor ipv6 flag set");
11748 if (sw_if_index_set == 0)
11750 errmsg ("missing interface name or sw_if_index");
11754 vam->current_sw_if_index = sw_if_index;
11755 vam->is_ipv6 = ipv6_set;
11757 M (IP_ADDRESS_DUMP, mp);
11758 mp->sw_if_index = ntohl (sw_if_index);
11759 mp->is_ipv6 = ipv6_set;
11762 /* Use a control ping for synchronization */
11763 M (CONTROL_PING, mp_ping);
11771 api_ip_dump (vat_main_t * vam)
11773 vl_api_ip_dump_t *mp;
11774 vl_api_control_ping_t *mp_ping;
11775 unformat_input_t *in = vam->input;
11782 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
11784 if (unformat (in, "ipv4"))
11786 else if (unformat (in, "ipv6"))
11792 if (ipv4_set && ipv6_set)
11794 errmsg ("ipv4 and ipv6 flags cannot be both set");
11798 if ((!ipv4_set) && (!ipv6_set))
11800 errmsg ("no ipv4 nor ipv6 flag set");
11804 is_ipv6 = ipv6_set;
11805 vam->is_ipv6 = is_ipv6;
11807 /* free old data */
11808 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
11810 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
11812 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
11815 mp->is_ipv6 = ipv6_set;
11818 /* Use a control ping for synchronization */
11819 M (CONTROL_PING, mp_ping);
11827 api_ipsec_spd_add_del (vat_main_t * vam)
11829 unformat_input_t *i = vam->input;
11830 vl_api_ipsec_spd_add_del_t *mp;
11835 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11837 if (unformat (i, "spd_id %d", &spd_id))
11839 else if (unformat (i, "del"))
11843 clib_warning ("parse error '%U'", format_unformat_error, i);
11849 errmsg ("spd_id must be set");
11853 M (IPSEC_SPD_ADD_DEL, mp);
11855 mp->spd_id = ntohl (spd_id);
11856 mp->is_add = is_add;
11864 api_ipsec_interface_add_del_spd (vat_main_t * vam)
11866 unformat_input_t *i = vam->input;
11867 vl_api_ipsec_interface_add_del_spd_t *mp;
11869 u8 sw_if_index_set = 0;
11870 u32 spd_id = (u32) ~ 0;
11874 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11876 if (unformat (i, "del"))
11878 else if (unformat (i, "spd_id %d", &spd_id))
11881 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11882 sw_if_index_set = 1;
11883 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11884 sw_if_index_set = 1;
11887 clib_warning ("parse error '%U'", format_unformat_error, i);
11893 if (spd_id == (u32) ~ 0)
11895 errmsg ("spd_id must be set");
11899 if (sw_if_index_set == 0)
11901 errmsg ("missing interface name or sw_if_index");
11905 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
11907 mp->spd_id = ntohl (spd_id);
11908 mp->sw_if_index = ntohl (sw_if_index);
11909 mp->is_add = is_add;
11917 api_ipsec_spd_add_del_entry (vat_main_t * vam)
11919 unformat_input_t *i = vam->input;
11920 vl_api_ipsec_spd_add_del_entry_t *mp;
11921 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
11922 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
11924 u32 rport_start = 0, rport_stop = (u32) ~ 0;
11925 u32 lport_start = 0, lport_stop = (u32) ~ 0;
11926 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
11927 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
11930 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
11931 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
11932 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
11933 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
11934 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
11935 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
11937 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11939 if (unformat (i, "del"))
11941 if (unformat (i, "outbound"))
11943 if (unformat (i, "inbound"))
11945 else if (unformat (i, "spd_id %d", &spd_id))
11947 else if (unformat (i, "sa_id %d", &sa_id))
11949 else if (unformat (i, "priority %d", &priority))
11951 else if (unformat (i, "protocol %d", &protocol))
11953 else if (unformat (i, "lport_start %d", &lport_start))
11955 else if (unformat (i, "lport_stop %d", &lport_stop))
11957 else if (unformat (i, "rport_start %d", &rport_start))
11959 else if (unformat (i, "rport_stop %d", &rport_stop))
11963 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
11969 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
11976 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
11982 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
11989 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
11995 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
12002 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
12008 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
12014 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
12016 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
12018 clib_warning ("unsupported action: 'resolve'");
12024 clib_warning ("parse error '%U'", format_unformat_error, i);
12030 M (IPSEC_SPD_ADD_DEL_ENTRY, mp);
12032 mp->spd_id = ntohl (spd_id);
12033 mp->priority = ntohl (priority);
12034 mp->is_outbound = is_outbound;
12036 mp->is_ipv6 = is_ipv6;
12037 if (is_ipv6 || is_ip_any)
12039 clib_memcpy (mp->remote_address_start, &raddr6_start,
12040 sizeof (ip6_address_t));
12041 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
12042 sizeof (ip6_address_t));
12043 clib_memcpy (mp->local_address_start, &laddr6_start,
12044 sizeof (ip6_address_t));
12045 clib_memcpy (mp->local_address_stop, &laddr6_stop,
12046 sizeof (ip6_address_t));
12050 clib_memcpy (mp->remote_address_start, &raddr4_start,
12051 sizeof (ip4_address_t));
12052 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
12053 sizeof (ip4_address_t));
12054 clib_memcpy (mp->local_address_start, &laddr4_start,
12055 sizeof (ip4_address_t));
12056 clib_memcpy (mp->local_address_stop, &laddr4_stop,
12057 sizeof (ip4_address_t));
12059 mp->protocol = (u8) protocol;
12060 mp->local_port_start = ntohs ((u16) lport_start);
12061 mp->local_port_stop = ntohs ((u16) lport_stop);
12062 mp->remote_port_start = ntohs ((u16) rport_start);
12063 mp->remote_port_stop = ntohs ((u16) rport_stop);
12064 mp->policy = (u8) policy;
12065 mp->sa_id = ntohl (sa_id);
12066 mp->is_add = is_add;
12067 mp->is_ip_any = is_ip_any;
12074 api_ipsec_sad_add_del_entry (vat_main_t * vam)
12076 unformat_input_t *i = vam->input;
12077 vl_api_ipsec_sad_add_del_entry_t *mp;
12078 u32 sad_id = 0, spi = 0;
12079 u8 *ck = 0, *ik = 0;
12082 u8 protocol = IPSEC_PROTOCOL_AH;
12083 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
12084 u32 crypto_alg = 0, integ_alg = 0;
12085 ip4_address_t tun_src4;
12086 ip4_address_t tun_dst4;
12087 ip6_address_t tun_src6;
12088 ip6_address_t tun_dst6;
12091 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12093 if (unformat (i, "del"))
12095 else if (unformat (i, "sad_id %d", &sad_id))
12097 else if (unformat (i, "spi %d", &spi))
12099 else if (unformat (i, "esp"))
12100 protocol = IPSEC_PROTOCOL_ESP;
12101 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
12104 is_tunnel_ipv6 = 0;
12106 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
12109 is_tunnel_ipv6 = 0;
12111 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
12114 is_tunnel_ipv6 = 1;
12116 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
12119 is_tunnel_ipv6 = 1;
12123 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
12125 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
12126 crypto_alg >= IPSEC_CRYPTO_N_ALG)
12128 clib_warning ("unsupported crypto-alg: '%U'",
12129 format_ipsec_crypto_alg, crypto_alg);
12133 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
12137 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
12139 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
12140 integ_alg >= IPSEC_INTEG_N_ALG)
12142 clib_warning ("unsupported integ-alg: '%U'",
12143 format_ipsec_integ_alg, integ_alg);
12147 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
12151 clib_warning ("parse error '%U'", format_unformat_error, i);
12157 M (IPSEC_SAD_ADD_DEL_ENTRY, mp);
12159 mp->sad_id = ntohl (sad_id);
12160 mp->is_add = is_add;
12161 mp->protocol = protocol;
12162 mp->spi = ntohl (spi);
12163 mp->is_tunnel = is_tunnel;
12164 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
12165 mp->crypto_algorithm = crypto_alg;
12166 mp->integrity_algorithm = integ_alg;
12167 mp->crypto_key_length = vec_len (ck);
12168 mp->integrity_key_length = vec_len (ik);
12170 if (mp->crypto_key_length > sizeof (mp->crypto_key))
12171 mp->crypto_key_length = sizeof (mp->crypto_key);
12173 if (mp->integrity_key_length > sizeof (mp->integrity_key))
12174 mp->integrity_key_length = sizeof (mp->integrity_key);
12177 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
12179 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
12183 if (is_tunnel_ipv6)
12185 clib_memcpy (mp->tunnel_src_address, &tun_src6,
12186 sizeof (ip6_address_t));
12187 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
12188 sizeof (ip6_address_t));
12192 clib_memcpy (mp->tunnel_src_address, &tun_src4,
12193 sizeof (ip4_address_t));
12194 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
12195 sizeof (ip4_address_t));
12205 api_ipsec_sa_set_key (vat_main_t * vam)
12207 unformat_input_t *i = vam->input;
12208 vl_api_ipsec_sa_set_key_t *mp;
12210 u8 *ck = 0, *ik = 0;
12213 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12215 if (unformat (i, "sa_id %d", &sa_id))
12217 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
12219 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
12223 clib_warning ("parse error '%U'", format_unformat_error, i);
12228 M (IPSEC_SA_SET_KEY, mp);
12230 mp->sa_id = ntohl (sa_id);
12231 mp->crypto_key_length = vec_len (ck);
12232 mp->integrity_key_length = vec_len (ik);
12234 if (mp->crypto_key_length > sizeof (mp->crypto_key))
12235 mp->crypto_key_length = sizeof (mp->crypto_key);
12237 if (mp->integrity_key_length > sizeof (mp->integrity_key))
12238 mp->integrity_key_length = sizeof (mp->integrity_key);
12241 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
12243 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
12251 api_ikev2_profile_add_del (vat_main_t * vam)
12253 unformat_input_t *i = vam->input;
12254 vl_api_ikev2_profile_add_del_t *mp;
12259 const char *valid_chars = "a-zA-Z0-9_";
12261 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12263 if (unformat (i, "del"))
12265 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12266 vec_add1 (name, 0);
12269 errmsg ("parse error '%U'", format_unformat_error, i);
12274 if (!vec_len (name))
12276 errmsg ("profile name must be specified");
12280 if (vec_len (name) > 64)
12282 errmsg ("profile name too long");
12286 M (IKEV2_PROFILE_ADD_DEL, mp);
12288 clib_memcpy (mp->name, name, vec_len (name));
12289 mp->is_add = is_add;
12298 api_ikev2_profile_set_auth (vat_main_t * vam)
12300 unformat_input_t *i = vam->input;
12301 vl_api_ikev2_profile_set_auth_t *mp;
12304 u32 auth_method = 0;
12308 const char *valid_chars = "a-zA-Z0-9_";
12310 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12312 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12313 vec_add1 (name, 0);
12314 else if (unformat (i, "auth_method %U",
12315 unformat_ikev2_auth_method, &auth_method))
12317 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
12319 else if (unformat (i, "auth_data %v", &data))
12323 errmsg ("parse error '%U'", format_unformat_error, i);
12328 if (!vec_len (name))
12330 errmsg ("profile name must be specified");
12334 if (vec_len (name) > 64)
12336 errmsg ("profile name too long");
12340 if (!vec_len (data))
12342 errmsg ("auth_data must be specified");
12348 errmsg ("auth_method must be specified");
12352 M (IKEV2_PROFILE_SET_AUTH, mp);
12354 mp->is_hex = is_hex;
12355 mp->auth_method = (u8) auth_method;
12356 mp->data_len = vec_len (data);
12357 clib_memcpy (mp->name, name, vec_len (name));
12358 clib_memcpy (mp->data, data, vec_len (data));
12368 api_ikev2_profile_set_id (vat_main_t * vam)
12370 unformat_input_t *i = vam->input;
12371 vl_api_ikev2_profile_set_id_t *mp;
12379 const char *valid_chars = "a-zA-Z0-9_";
12381 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12383 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12384 vec_add1 (name, 0);
12385 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
12387 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
12389 data = vec_new (u8, 4);
12390 clib_memcpy (data, ip4.as_u8, 4);
12392 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
12394 else if (unformat (i, "id_data %v", &data))
12396 else if (unformat (i, "local"))
12398 else if (unformat (i, "remote"))
12402 errmsg ("parse error '%U'", format_unformat_error, i);
12407 if (!vec_len (name))
12409 errmsg ("profile name must be specified");
12413 if (vec_len (name) > 64)
12415 errmsg ("profile name too long");
12419 if (!vec_len (data))
12421 errmsg ("id_data must be specified");
12427 errmsg ("id_type must be specified");
12431 M (IKEV2_PROFILE_SET_ID, mp);
12433 mp->is_local = is_local;
12434 mp->id_type = (u8) id_type;
12435 mp->data_len = vec_len (data);
12436 clib_memcpy (mp->name, name, vec_len (name));
12437 clib_memcpy (mp->data, data, vec_len (data));
12447 api_ikev2_profile_set_ts (vat_main_t * vam)
12449 unformat_input_t *i = vam->input;
12450 vl_api_ikev2_profile_set_ts_t *mp;
12453 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
12454 ip4_address_t start_addr, end_addr;
12456 const char *valid_chars = "a-zA-Z0-9_";
12459 start_addr.as_u32 = 0;
12460 end_addr.as_u32 = (u32) ~ 0;
12462 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12464 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12465 vec_add1 (name, 0);
12466 else if (unformat (i, "protocol %d", &proto))
12468 else if (unformat (i, "start_port %d", &start_port))
12470 else if (unformat (i, "end_port %d", &end_port))
12473 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
12475 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
12477 else if (unformat (i, "local"))
12479 else if (unformat (i, "remote"))
12483 errmsg ("parse error '%U'", format_unformat_error, i);
12488 if (!vec_len (name))
12490 errmsg ("profile name must be specified");
12494 if (vec_len (name) > 64)
12496 errmsg ("profile name too long");
12500 M (IKEV2_PROFILE_SET_TS, mp);
12502 mp->is_local = is_local;
12503 mp->proto = (u8) proto;
12504 mp->start_port = (u16) start_port;
12505 mp->end_port = (u16) end_port;
12506 mp->start_addr = start_addr.as_u32;
12507 mp->end_addr = end_addr.as_u32;
12508 clib_memcpy (mp->name, name, vec_len (name));
12517 api_ikev2_set_local_key (vat_main_t * vam)
12519 unformat_input_t *i = vam->input;
12520 vl_api_ikev2_set_local_key_t *mp;
12524 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12526 if (unformat (i, "file %v", &file))
12527 vec_add1 (file, 0);
12530 errmsg ("parse error '%U'", format_unformat_error, i);
12535 if (!vec_len (file))
12537 errmsg ("RSA key file must be specified");
12541 if (vec_len (file) > 256)
12543 errmsg ("file name too long");
12547 M (IKEV2_SET_LOCAL_KEY, mp);
12549 clib_memcpy (mp->key_file, file, vec_len (file));
12558 api_ikev2_set_responder (vat_main_t * vam)
12560 unformat_input_t *i = vam->input;
12561 vl_api_ikev2_set_responder_t *mp;
12564 u32 sw_if_index = ~0;
12565 ip4_address_t address;
12567 const char *valid_chars = "a-zA-Z0-9_";
12569 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12572 (i, "%U interface %d address %U", unformat_token, valid_chars,
12573 &name, &sw_if_index, unformat_ip4_address, &address))
12574 vec_add1 (name, 0);
12577 errmsg ("parse error '%U'", format_unformat_error, i);
12582 if (!vec_len (name))
12584 errmsg ("profile name must be specified");
12588 if (vec_len (name) > 64)
12590 errmsg ("profile name too long");
12594 M (IKEV2_SET_RESPONDER, mp);
12596 clib_memcpy (mp->name, name, vec_len (name));
12599 mp->sw_if_index = sw_if_index;
12600 clib_memcpy (mp->address, &address, sizeof (address));
12608 api_ikev2_set_ike_transforms (vat_main_t * vam)
12610 unformat_input_t *i = vam->input;
12611 vl_api_ikev2_set_ike_transforms_t *mp;
12614 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
12616 const char *valid_chars = "a-zA-Z0-9_";
12618 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12620 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
12621 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
12622 vec_add1 (name, 0);
12625 errmsg ("parse error '%U'", format_unformat_error, i);
12630 if (!vec_len (name))
12632 errmsg ("profile name must be specified");
12636 if (vec_len (name) > 64)
12638 errmsg ("profile name too long");
12642 M (IKEV2_SET_IKE_TRANSFORMS, mp);
12644 clib_memcpy (mp->name, name, vec_len (name));
12646 mp->crypto_alg = crypto_alg;
12647 mp->crypto_key_size = crypto_key_size;
12648 mp->integ_alg = integ_alg;
12649 mp->dh_group = dh_group;
12658 api_ikev2_set_esp_transforms (vat_main_t * vam)
12660 unformat_input_t *i = vam->input;
12661 vl_api_ikev2_set_esp_transforms_t *mp;
12664 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
12666 const char *valid_chars = "a-zA-Z0-9_";
12668 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12670 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
12671 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
12672 vec_add1 (name, 0);
12675 errmsg ("parse error '%U'", format_unformat_error, i);
12680 if (!vec_len (name))
12682 errmsg ("profile name must be specified");
12686 if (vec_len (name) > 64)
12688 errmsg ("profile name too long");
12692 M (IKEV2_SET_ESP_TRANSFORMS, mp);
12694 clib_memcpy (mp->name, name, vec_len (name));
12696 mp->crypto_alg = crypto_alg;
12697 mp->crypto_key_size = crypto_key_size;
12698 mp->integ_alg = integ_alg;
12699 mp->dh_group = dh_group;
12707 api_ikev2_set_sa_lifetime (vat_main_t * vam)
12709 unformat_input_t *i = vam->input;
12710 vl_api_ikev2_set_sa_lifetime_t *mp;
12713 u64 lifetime, lifetime_maxdata;
12714 u32 lifetime_jitter, handover;
12716 const char *valid_chars = "a-zA-Z0-9_";
12718 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12720 if (unformat (i, "%U %lu %u %u %lu", unformat_token, valid_chars, &name,
12721 &lifetime, &lifetime_jitter, &handover,
12722 &lifetime_maxdata))
12723 vec_add1 (name, 0);
12726 errmsg ("parse error '%U'", format_unformat_error, i);
12731 if (!vec_len (name))
12733 errmsg ("profile name must be specified");
12737 if (vec_len (name) > 64)
12739 errmsg ("profile name too long");
12743 M (IKEV2_SET_SA_LIFETIME, mp);
12745 clib_memcpy (mp->name, name, vec_len (name));
12747 mp->lifetime = lifetime;
12748 mp->lifetime_jitter = lifetime_jitter;
12749 mp->handover = handover;
12750 mp->lifetime_maxdata = lifetime_maxdata;
12758 api_ikev2_initiate_sa_init (vat_main_t * vam)
12760 unformat_input_t *i = vam->input;
12761 vl_api_ikev2_initiate_sa_init_t *mp;
12765 const char *valid_chars = "a-zA-Z0-9_";
12767 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12769 if (unformat (i, "%U", unformat_token, valid_chars, &name))
12770 vec_add1 (name, 0);
12773 errmsg ("parse error '%U'", format_unformat_error, i);
12778 if (!vec_len (name))
12780 errmsg ("profile name must be specified");
12784 if (vec_len (name) > 64)
12786 errmsg ("profile name too long");
12790 M (IKEV2_INITIATE_SA_INIT, mp);
12792 clib_memcpy (mp->name, name, vec_len (name));
12801 api_ikev2_initiate_del_ike_sa (vat_main_t * vam)
12803 unformat_input_t *i = vam->input;
12804 vl_api_ikev2_initiate_del_ike_sa_t *mp;
12809 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12811 if (unformat (i, "%lx", &ispi))
12815 errmsg ("parse error '%U'", format_unformat_error, i);
12820 M (IKEV2_INITIATE_DEL_IKE_SA, mp);
12830 api_ikev2_initiate_del_child_sa (vat_main_t * vam)
12832 unformat_input_t *i = vam->input;
12833 vl_api_ikev2_initiate_del_child_sa_t *mp;
12838 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12840 if (unformat (i, "%x", &ispi))
12844 errmsg ("parse error '%U'", format_unformat_error, i);
12849 M (IKEV2_INITIATE_DEL_CHILD_SA, mp);
12859 api_ikev2_initiate_rekey_child_sa (vat_main_t * vam)
12861 unformat_input_t *i = vam->input;
12862 vl_api_ikev2_initiate_rekey_child_sa_t *mp;
12867 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12869 if (unformat (i, "%x", &ispi))
12873 errmsg ("parse error '%U'", format_unformat_error, i);
12878 M (IKEV2_INITIATE_REKEY_CHILD_SA, mp);
12891 api_map_add_domain (vat_main_t * vam)
12893 unformat_input_t *i = vam->input;
12894 vl_api_map_add_domain_t *mp;
12896 ip4_address_t ip4_prefix;
12897 ip6_address_t ip6_prefix;
12898 ip6_address_t ip6_src;
12899 u32 num_m_args = 0;
12900 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
12901 0, psid_length = 0;
12902 u8 is_translation = 0;
12904 u32 ip6_src_len = 128;
12907 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12909 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
12910 &ip4_prefix, &ip4_prefix_len))
12912 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
12913 &ip6_prefix, &ip6_prefix_len))
12917 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
12920 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
12922 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
12924 else if (unformat (i, "psid-offset %d", &psid_offset))
12926 else if (unformat (i, "psid-len %d", &psid_length))
12928 else if (unformat (i, "mtu %d", &mtu))
12930 else if (unformat (i, "map-t"))
12931 is_translation = 1;
12934 clib_warning ("parse error '%U'", format_unformat_error, i);
12939 if (num_m_args < 3)
12941 errmsg ("mandatory argument(s) missing");
12945 /* Construct the API message */
12946 M (MAP_ADD_DOMAIN, mp);
12948 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
12949 mp->ip4_prefix_len = ip4_prefix_len;
12951 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
12952 mp->ip6_prefix_len = ip6_prefix_len;
12954 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
12955 mp->ip6_src_prefix_len = ip6_src_len;
12957 mp->ea_bits_len = ea_bits_len;
12958 mp->psid_offset = psid_offset;
12959 mp->psid_length = psid_length;
12960 mp->is_translation = is_translation;
12961 mp->mtu = htons (mtu);
12966 /* Wait for a reply, return good/bad news */
12972 api_map_del_domain (vat_main_t * vam)
12974 unformat_input_t *i = vam->input;
12975 vl_api_map_del_domain_t *mp;
12977 u32 num_m_args = 0;
12981 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12983 if (unformat (i, "index %d", &index))
12987 clib_warning ("parse error '%U'", format_unformat_error, i);
12992 if (num_m_args != 1)
12994 errmsg ("mandatory argument(s) missing");
12998 /* Construct the API message */
12999 M (MAP_DEL_DOMAIN, mp);
13001 mp->index = ntohl (index);
13006 /* Wait for a reply, return good/bad news */
13012 api_map_add_del_rule (vat_main_t * vam)
13014 unformat_input_t *i = vam->input;
13015 vl_api_map_add_del_rule_t *mp;
13017 ip6_address_t ip6_dst;
13018 u32 num_m_args = 0, index, psid = 0;
13021 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13023 if (unformat (i, "index %d", &index))
13025 else if (unformat (i, "psid %d", &psid))
13027 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
13029 else if (unformat (i, "del"))
13035 clib_warning ("parse error '%U'", format_unformat_error, i);
13040 /* Construct the API message */
13041 M (MAP_ADD_DEL_RULE, mp);
13043 mp->index = ntohl (index);
13044 mp->is_add = is_add;
13045 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
13046 mp->psid = ntohs (psid);
13051 /* Wait for a reply, return good/bad news */
13057 api_map_domain_dump (vat_main_t * vam)
13059 vl_api_map_domain_dump_t *mp;
13060 vl_api_control_ping_t *mp_ping;
13063 /* Construct the API message */
13064 M (MAP_DOMAIN_DUMP, mp);
13069 /* Use a control ping for synchronization */
13070 M (CONTROL_PING, mp_ping);
13078 api_map_rule_dump (vat_main_t * vam)
13080 unformat_input_t *i = vam->input;
13081 vl_api_map_rule_dump_t *mp;
13082 vl_api_control_ping_t *mp_ping;
13083 u32 domain_index = ~0;
13086 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13088 if (unformat (i, "index %u", &domain_index))
13094 if (domain_index == ~0)
13096 clib_warning ("parse error: domain index expected");
13100 /* Construct the API message */
13101 M (MAP_RULE_DUMP, mp);
13103 mp->domain_index = htonl (domain_index);
13108 /* Use a control ping for synchronization */
13109 M (CONTROL_PING, mp_ping);
13116 static void vl_api_map_add_domain_reply_t_handler
13117 (vl_api_map_add_domain_reply_t * mp)
13119 vat_main_t *vam = &vat_main;
13120 i32 retval = ntohl (mp->retval);
13122 if (vam->async_mode)
13124 vam->async_errors += (retval < 0);
13128 vam->retval = retval;
13129 vam->result_ready = 1;
13133 static void vl_api_map_add_domain_reply_t_handler_json
13134 (vl_api_map_add_domain_reply_t * mp)
13136 vat_main_t *vam = &vat_main;
13137 vat_json_node_t node;
13139 vat_json_init_object (&node);
13140 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
13141 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
13143 vat_json_print (vam->ofp, &node);
13144 vat_json_free (&node);
13146 vam->retval = ntohl (mp->retval);
13147 vam->result_ready = 1;
13151 api_get_first_msg_id (vat_main_t * vam)
13153 vl_api_get_first_msg_id_t *mp;
13154 unformat_input_t *i = vam->input;
13159 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13161 if (unformat (i, "client %s", &name))
13169 errmsg ("missing client name");
13172 vec_add1 (name, 0);
13174 if (vec_len (name) > 63)
13176 errmsg ("client name too long");
13180 M (GET_FIRST_MSG_ID, mp);
13181 clib_memcpy (mp->name, name, vec_len (name));
13188 api_cop_interface_enable_disable (vat_main_t * vam)
13190 unformat_input_t *line_input = vam->input;
13191 vl_api_cop_interface_enable_disable_t *mp;
13192 u32 sw_if_index = ~0;
13193 u8 enable_disable = 1;
13196 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13198 if (unformat (line_input, "disable"))
13199 enable_disable = 0;
13200 if (unformat (line_input, "enable"))
13201 enable_disable = 1;
13202 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
13203 vam, &sw_if_index))
13205 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13211 if (sw_if_index == ~0)
13213 errmsg ("missing interface name or sw_if_index");
13217 /* Construct the API message */
13218 M (COP_INTERFACE_ENABLE_DISABLE, mp);
13219 mp->sw_if_index = ntohl (sw_if_index);
13220 mp->enable_disable = enable_disable;
13224 /* Wait for the reply */
13230 api_cop_whitelist_enable_disable (vat_main_t * vam)
13232 unformat_input_t *line_input = vam->input;
13233 vl_api_cop_whitelist_enable_disable_t *mp;
13234 u32 sw_if_index = ~0;
13235 u8 ip4 = 0, ip6 = 0, default_cop = 0;
13239 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13241 if (unformat (line_input, "ip4"))
13243 else if (unformat (line_input, "ip6"))
13245 else if (unformat (line_input, "default"))
13247 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
13248 vam, &sw_if_index))
13250 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13252 else if (unformat (line_input, "fib-id %d", &fib_id))
13258 if (sw_if_index == ~0)
13260 errmsg ("missing interface name or sw_if_index");
13264 /* Construct the API message */
13265 M (COP_WHITELIST_ENABLE_DISABLE, mp);
13266 mp->sw_if_index = ntohl (sw_if_index);
13267 mp->fib_id = ntohl (fib_id);
13270 mp->default_cop = default_cop;
13274 /* Wait for the reply */
13280 api_get_node_graph (vat_main_t * vam)
13282 vl_api_get_node_graph_t *mp;
13285 M (GET_NODE_GRAPH, mp);
13289 /* Wait for the reply */
13295 /** Used for parsing LISP eids */
13296 typedef CLIB_PACKED(struct{
13297 u8 addr[16]; /**< eid address */
13298 u32 len; /**< prefix length if IP */
13299 u8 type; /**< type of eid */
13304 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
13306 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
13308 memset (a, 0, sizeof (a[0]));
13310 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
13312 a->type = 0; /* ipv4 type */
13314 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
13316 a->type = 1; /* ipv6 type */
13318 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
13320 a->type = 2; /* mac type */
13327 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
13336 lisp_eid_size_vat (u8 type)
13351 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
13353 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
13357 api_one_add_del_locator_set (vat_main_t * vam)
13359 unformat_input_t *input = vam->input;
13360 vl_api_one_add_del_locator_set_t *mp;
13362 u8 *locator_set_name = NULL;
13363 u8 locator_set_name_set = 0;
13364 vl_api_local_locator_t locator, *locators = 0;
13365 u32 sw_if_index, priority, weight;
13369 /* Parse args required to build the message */
13370 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13372 if (unformat (input, "del"))
13376 else if (unformat (input, "locator-set %s", &locator_set_name))
13378 locator_set_name_set = 1;
13380 else if (unformat (input, "sw_if_index %u p %u w %u",
13381 &sw_if_index, &priority, &weight))
13383 locator.sw_if_index = htonl (sw_if_index);
13384 locator.priority = priority;
13385 locator.weight = weight;
13386 vec_add1 (locators, locator);
13390 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
13391 &sw_if_index, &priority, &weight))
13393 locator.sw_if_index = htonl (sw_if_index);
13394 locator.priority = priority;
13395 locator.weight = weight;
13396 vec_add1 (locators, locator);
13402 if (locator_set_name_set == 0)
13404 errmsg ("missing locator-set name");
13405 vec_free (locators);
13409 if (vec_len (locator_set_name) > 64)
13411 errmsg ("locator-set name too long");
13412 vec_free (locator_set_name);
13413 vec_free (locators);
13416 vec_add1 (locator_set_name, 0);
13418 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
13420 /* Construct the API message */
13421 M2 (ONE_ADD_DEL_LOCATOR_SET, mp, data_len);
13423 mp->is_add = is_add;
13424 clib_memcpy (mp->locator_set_name, locator_set_name,
13425 vec_len (locator_set_name));
13426 vec_free (locator_set_name);
13428 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
13430 clib_memcpy (mp->locators, locators, data_len);
13431 vec_free (locators);
13436 /* Wait for a reply... */
13441 #define api_lisp_add_del_locator_set api_one_add_del_locator_set
13444 api_one_add_del_locator (vat_main_t * vam)
13446 unformat_input_t *input = vam->input;
13447 vl_api_one_add_del_locator_t *mp;
13448 u32 tmp_if_index = ~0;
13449 u32 sw_if_index = ~0;
13450 u8 sw_if_index_set = 0;
13451 u8 sw_if_index_if_name_set = 0;
13453 u8 priority_set = 0;
13457 u8 *locator_set_name = NULL;
13458 u8 locator_set_name_set = 0;
13461 /* Parse args required to build the message */
13462 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13464 if (unformat (input, "del"))
13468 else if (unformat (input, "locator-set %s", &locator_set_name))
13470 locator_set_name_set = 1;
13472 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
13475 sw_if_index_if_name_set = 1;
13476 sw_if_index = tmp_if_index;
13478 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
13480 sw_if_index_set = 1;
13481 sw_if_index = tmp_if_index;
13483 else if (unformat (input, "p %d", &priority))
13487 else if (unformat (input, "w %d", &weight))
13495 if (locator_set_name_set == 0)
13497 errmsg ("missing locator-set name");
13501 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
13503 errmsg ("missing sw_if_index");
13504 vec_free (locator_set_name);
13508 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
13510 errmsg ("cannot use both params interface name and sw_if_index");
13511 vec_free (locator_set_name);
13515 if (priority_set == 0)
13517 errmsg ("missing locator-set priority");
13518 vec_free (locator_set_name);
13522 if (weight_set == 0)
13524 errmsg ("missing locator-set weight");
13525 vec_free (locator_set_name);
13529 if (vec_len (locator_set_name) > 64)
13531 errmsg ("locator-set name too long");
13532 vec_free (locator_set_name);
13535 vec_add1 (locator_set_name, 0);
13537 /* Construct the API message */
13538 M (ONE_ADD_DEL_LOCATOR, mp);
13540 mp->is_add = is_add;
13541 mp->sw_if_index = ntohl (sw_if_index);
13542 mp->priority = priority;
13543 mp->weight = weight;
13544 clib_memcpy (mp->locator_set_name, locator_set_name,
13545 vec_len (locator_set_name));
13546 vec_free (locator_set_name);
13551 /* Wait for a reply... */
13556 #define api_lisp_add_del_locator api_one_add_del_locator
13559 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
13561 u32 *key_id = va_arg (*args, u32 *);
13564 if (unformat (input, "%s", &s))
13566 if (!strcmp ((char *) s, "sha1"))
13567 key_id[0] = HMAC_SHA_1_96;
13568 else if (!strcmp ((char *) s, "sha256"))
13569 key_id[0] = HMAC_SHA_256_128;
13572 clib_warning ("invalid key_id: '%s'", s);
13573 key_id[0] = HMAC_NO_KEY;
13584 api_one_add_del_local_eid (vat_main_t * vam)
13586 unformat_input_t *input = vam->input;
13587 vl_api_one_add_del_local_eid_t *mp;
13590 lisp_eid_vat_t _eid, *eid = &_eid;
13591 u8 *locator_set_name = 0;
13592 u8 locator_set_name_set = 0;
13598 /* Parse args required to build the message */
13599 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13601 if (unformat (input, "del"))
13605 else if (unformat (input, "vni %d", &vni))
13609 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
13613 else if (unformat (input, "locator-set %s", &locator_set_name))
13615 locator_set_name_set = 1;
13617 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
13619 else if (unformat (input, "secret-key %_%v%_", &key))
13625 if (locator_set_name_set == 0)
13627 errmsg ("missing locator-set name");
13633 errmsg ("EID address not set!");
13634 vec_free (locator_set_name);
13638 if (key && (0 == key_id))
13640 errmsg ("invalid key_id!");
13644 if (vec_len (key) > 64)
13646 errmsg ("key too long");
13651 if (vec_len (locator_set_name) > 64)
13653 errmsg ("locator-set name too long");
13654 vec_free (locator_set_name);
13657 vec_add1 (locator_set_name, 0);
13659 /* Construct the API message */
13660 M (ONE_ADD_DEL_LOCAL_EID, mp);
13662 mp->is_add = is_add;
13663 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
13664 mp->eid_type = eid->type;
13665 mp->prefix_len = eid->len;
13666 mp->vni = clib_host_to_net_u32 (vni);
13667 mp->key_id = clib_host_to_net_u16 (key_id);
13668 clib_memcpy (mp->locator_set_name, locator_set_name,
13669 vec_len (locator_set_name));
13670 clib_memcpy (mp->key, key, vec_len (key));
13672 vec_free (locator_set_name);
13678 /* Wait for a reply... */
13683 #define api_lisp_add_del_local_eid api_one_add_del_local_eid
13686 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
13688 u32 dp_table = 0, vni = 0;;
13689 unformat_input_t *input = vam->input;
13690 vl_api_gpe_add_del_fwd_entry_t *mp;
13692 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
13693 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
13694 u8 rmt_eid_set = 0, lcl_eid_set = 0;
13695 u32 action = ~0, w;
13696 ip4_address_t rmt_rloc4, lcl_rloc4;
13697 ip6_address_t rmt_rloc6, lcl_rloc6;
13698 vl_api_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
13701 memset (&rloc, 0, sizeof (rloc));
13703 /* Parse args required to build the message */
13704 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13706 if (unformat (input, "del"))
13708 else if (unformat (input, "add"))
13710 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
13714 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
13718 else if (unformat (input, "vrf %d", &dp_table))
13720 else if (unformat (input, "bd %d", &dp_table))
13722 else if (unformat (input, "vni %d", &vni))
13724 else if (unformat (input, "w %d", &w))
13728 errmsg ("No RLOC configured for setting priority/weight!");
13731 curr_rloc->weight = w;
13733 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
13734 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
13738 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
13740 vec_add1 (lcl_locs, rloc);
13742 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
13743 vec_add1 (rmt_locs, rloc);
13744 /* weight saved in rmt loc */
13745 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
13747 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
13748 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
13751 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
13753 vec_add1 (lcl_locs, rloc);
13755 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
13756 vec_add1 (rmt_locs, rloc);
13757 /* weight saved in rmt loc */
13758 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
13760 else if (unformat (input, "action %d", &action))
13766 clib_warning ("parse error '%U'", format_unformat_error, input);
13773 errmsg ("remote eid addresses not set");
13777 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
13779 errmsg ("eid types don't match");
13783 if (0 == rmt_locs && (u32) ~ 0 == action)
13785 errmsg ("action not set for negative mapping");
13789 /* Construct the API message */
13790 M2 (GPE_ADD_DEL_FWD_ENTRY, mp,
13791 sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
13793 mp->is_add = is_add;
13794 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
13795 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
13796 mp->eid_type = rmt_eid->type;
13797 mp->dp_table = clib_host_to_net_u32 (dp_table);
13798 mp->vni = clib_host_to_net_u32 (vni);
13799 mp->rmt_len = rmt_eid->len;
13800 mp->lcl_len = lcl_eid->len;
13801 mp->action = action;
13803 if (0 != rmt_locs && 0 != lcl_locs)
13805 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
13806 clib_memcpy (mp->locs, lcl_locs,
13807 (sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs)));
13809 u32 offset = sizeof (vl_api_gpe_locator_t) * vec_len (lcl_locs);
13810 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
13811 (sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs)));
13813 vec_free (lcl_locs);
13814 vec_free (rmt_locs);
13819 /* Wait for a reply... */
13825 api_one_add_del_map_server (vat_main_t * vam)
13827 unformat_input_t *input = vam->input;
13828 vl_api_one_add_del_map_server_t *mp;
13832 ip4_address_t ipv4;
13833 ip6_address_t ipv6;
13836 /* Parse args required to build the message */
13837 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13839 if (unformat (input, "del"))
13843 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
13847 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
13855 if (ipv4_set && ipv6_set)
13857 errmsg ("both eid v4 and v6 addresses set");
13861 if (!ipv4_set && !ipv6_set)
13863 errmsg ("eid addresses not set");
13867 /* Construct the API message */
13868 M (ONE_ADD_DEL_MAP_SERVER, mp);
13870 mp->is_add = is_add;
13874 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
13879 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
13885 /* Wait for a reply... */
13890 #define api_lisp_add_del_map_server api_one_add_del_map_server
13893 api_one_add_del_map_resolver (vat_main_t * vam)
13895 unformat_input_t *input = vam->input;
13896 vl_api_one_add_del_map_resolver_t *mp;
13900 ip4_address_t ipv4;
13901 ip6_address_t ipv6;
13904 /* Parse args required to build the message */
13905 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13907 if (unformat (input, "del"))
13911 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
13915 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
13923 if (ipv4_set && ipv6_set)
13925 errmsg ("both eid v4 and v6 addresses set");
13929 if (!ipv4_set && !ipv6_set)
13931 errmsg ("eid addresses not set");
13935 /* Construct the API message */
13936 M (ONE_ADD_DEL_MAP_RESOLVER, mp);
13938 mp->is_add = is_add;
13942 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
13947 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
13953 /* Wait for a reply... */
13958 #define api_lisp_add_del_map_resolver api_one_add_del_map_resolver
13961 api_lisp_gpe_enable_disable (vat_main_t * vam)
13963 unformat_input_t *input = vam->input;
13964 vl_api_gpe_enable_disable_t *mp;
13969 /* Parse args required to build the message */
13970 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13972 if (unformat (input, "enable"))
13977 else if (unformat (input, "disable"))
13988 errmsg ("Value not set");
13992 /* Construct the API message */
13993 M (GPE_ENABLE_DISABLE, mp);
14000 /* Wait for a reply... */
14006 api_one_rloc_probe_enable_disable (vat_main_t * vam)
14008 unformat_input_t *input = vam->input;
14009 vl_api_one_rloc_probe_enable_disable_t *mp;
14014 /* Parse args required to build the message */
14015 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14017 if (unformat (input, "enable"))
14022 else if (unformat (input, "disable"))
14030 errmsg ("Value not set");
14034 /* Construct the API message */
14035 M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
14037 mp->is_enabled = is_en;
14042 /* Wait for a reply... */
14047 #define api_lisp_rloc_probe_enable_disable api_one_rloc_probe_enable_disable
14050 api_one_map_register_enable_disable (vat_main_t * vam)
14052 unformat_input_t *input = vam->input;
14053 vl_api_one_map_register_enable_disable_t *mp;
14058 /* Parse args required to build the message */
14059 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14061 if (unformat (input, "enable"))
14066 else if (unformat (input, "disable"))
14074 errmsg ("Value not set");
14078 /* Construct the API message */
14079 M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
14081 mp->is_enabled = is_en;
14086 /* Wait for a reply... */
14091 #define api_lisp_map_register_enable_disable api_one_map_register_enable_disable
14094 api_one_enable_disable (vat_main_t * vam)
14096 unformat_input_t *input = vam->input;
14097 vl_api_one_enable_disable_t *mp;
14102 /* Parse args required to build the message */
14103 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14105 if (unformat (input, "enable"))
14110 else if (unformat (input, "disable"))
14120 errmsg ("Value not set");
14124 /* Construct the API message */
14125 M (ONE_ENABLE_DISABLE, mp);
14132 /* Wait for a reply... */
14137 #define api_lisp_enable_disable api_one_enable_disable
14140 api_show_one_map_register_state (vat_main_t * vam)
14142 vl_api_show_one_map_register_state_t *mp;
14145 M (SHOW_ONE_MAP_REGISTER_STATE, mp);
14150 /* wait for reply */
14155 #define api_show_lisp_map_register_state api_show_one_map_register_state
14158 api_show_one_rloc_probe_state (vat_main_t * vam)
14160 vl_api_show_one_rloc_probe_state_t *mp;
14163 M (SHOW_ONE_RLOC_PROBE_STATE, mp);
14168 /* wait for reply */
14173 #define api_show_lisp_rloc_probe_state api_show_one_rloc_probe_state
14176 api_show_one_map_request_mode (vat_main_t * vam)
14178 vl_api_show_one_map_request_mode_t *mp;
14181 M (SHOW_ONE_MAP_REQUEST_MODE, mp);
14186 /* wait for reply */
14191 #define api_show_lisp_map_request_mode api_show_one_map_request_mode
14194 api_one_map_request_mode (vat_main_t * vam)
14196 unformat_input_t *input = vam->input;
14197 vl_api_one_map_request_mode_t *mp;
14201 /* Parse args required to build the message */
14202 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14204 if (unformat (input, "dst-only"))
14206 else if (unformat (input, "src-dst"))
14210 errmsg ("parse error '%U'", format_unformat_error, input);
14215 M (ONE_MAP_REQUEST_MODE, mp);
14222 /* wait for reply */
14227 #define api_lisp_map_request_mode api_one_map_request_mode
14230 * Enable/disable ONE proxy ITR.
14232 * @param vam vpp API test context
14233 * @return return code
14236 api_one_pitr_set_locator_set (vat_main_t * vam)
14238 u8 ls_name_set = 0;
14239 unformat_input_t *input = vam->input;
14240 vl_api_one_pitr_set_locator_set_t *mp;
14245 /* Parse args required to build the message */
14246 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14248 if (unformat (input, "del"))
14250 else if (unformat (input, "locator-set %s", &ls_name))
14254 errmsg ("parse error '%U'", format_unformat_error, input);
14261 errmsg ("locator-set name not set!");
14265 M (ONE_PITR_SET_LOCATOR_SET, mp);
14267 mp->is_add = is_add;
14268 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
14269 vec_free (ls_name);
14274 /* wait for reply */
14279 #define api_lisp_pitr_set_locator_set api_one_pitr_set_locator_set
14282 api_show_one_pitr (vat_main_t * vam)
14284 vl_api_show_one_pitr_t *mp;
14287 if (!vam->json_output)
14289 print (vam->ofp, "%=20s", "lisp status:");
14292 M (SHOW_ONE_PITR, mp);
14296 /* Wait for a reply... */
14301 #define api_show_lisp_pitr api_show_one_pitr
14304 * Add/delete mapping between vni and vrf
14307 api_one_eid_table_add_del_map (vat_main_t * vam)
14309 unformat_input_t *input = vam->input;
14310 vl_api_one_eid_table_add_del_map_t *mp;
14311 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
14312 u32 vni, vrf, bd_index;
14315 /* Parse args required to build the message */
14316 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14318 if (unformat (input, "del"))
14320 else if (unformat (input, "vrf %d", &vrf))
14322 else if (unformat (input, "bd_index %d", &bd_index))
14324 else if (unformat (input, "vni %d", &vni))
14330 if (!vni_set || (!vrf_set && !bd_index_set))
14332 errmsg ("missing arguments!");
14336 if (vrf_set && bd_index_set)
14338 errmsg ("error: both vrf and bd entered!");
14342 M (ONE_EID_TABLE_ADD_DEL_MAP, mp);
14344 mp->is_add = is_add;
14345 mp->vni = htonl (vni);
14346 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
14347 mp->is_l2 = bd_index_set;
14352 /* wait for reply */
14357 #define api_lisp_eid_table_add_del_map api_one_eid_table_add_del_map
14360 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
14362 u32 *action = va_arg (*args, u32 *);
14365 if (unformat (input, "%s", &s))
14367 if (!strcmp ((char *) s, "no-action"))
14369 else if (!strcmp ((char *) s, "natively-forward"))
14371 else if (!strcmp ((char *) s, "send-map-request"))
14373 else if (!strcmp ((char *) s, "drop"))
14377 clib_warning ("invalid action: '%s'", s);
14389 * Add/del remote mapping to/from ONE control plane
14391 * @param vam vpp API test context
14392 * @return return code
14395 api_one_add_del_remote_mapping (vat_main_t * vam)
14397 unformat_input_t *input = vam->input;
14398 vl_api_one_add_del_remote_mapping_t *mp;
14400 lisp_eid_vat_t _eid, *eid = &_eid;
14401 lisp_eid_vat_t _seid, *seid = &_seid;
14402 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
14403 u32 action = ~0, p, w, data_len;
14404 ip4_address_t rloc4;
14405 ip6_address_t rloc6;
14406 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
14409 memset (&rloc, 0, sizeof (rloc));
14411 /* Parse args required to build the message */
14412 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14414 if (unformat (input, "del-all"))
14418 else if (unformat (input, "del"))
14422 else if (unformat (input, "add"))
14426 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
14430 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
14434 else if (unformat (input, "vni %d", &vni))
14438 else if (unformat (input, "p %d w %d", &p, &w))
14442 errmsg ("No RLOC configured for setting priority/weight!");
14445 curr_rloc->priority = p;
14446 curr_rloc->weight = w;
14448 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
14451 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
14452 vec_add1 (rlocs, rloc);
14453 curr_rloc = &rlocs[vec_len (rlocs) - 1];
14455 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
14458 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
14459 vec_add1 (rlocs, rloc);
14460 curr_rloc = &rlocs[vec_len (rlocs) - 1];
14462 else if (unformat (input, "action %U",
14463 unformat_negative_mapping_action, &action))
14469 clib_warning ("parse error '%U'", format_unformat_error, input);
14476 errmsg ("missing params!");
14480 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
14482 errmsg ("no action set for negative map-reply!");
14486 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
14488 M2 (ONE_ADD_DEL_REMOTE_MAPPING, mp, data_len);
14489 mp->is_add = is_add;
14490 mp->vni = htonl (vni);
14491 mp->action = (u8) action;
14492 mp->is_src_dst = seid_set;
14493 mp->eid_len = eid->len;
14494 mp->seid_len = seid->len;
14495 mp->del_all = del_all;
14496 mp->eid_type = eid->type;
14497 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
14498 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
14500 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
14501 clib_memcpy (mp->rlocs, rlocs, data_len);
14507 /* Wait for a reply... */
14512 #define api_lisp_add_del_remote_mapping api_one_add_del_remote_mapping
14515 * Add/del ONE adjacency. Saves mapping in ONE control plane and updates
14516 * forwarding entries in data-plane accordingly.
14518 * @param vam vpp API test context
14519 * @return return code
14522 api_one_add_del_adjacency (vat_main_t * vam)
14524 unformat_input_t *input = vam->input;
14525 vl_api_one_add_del_adjacency_t *mp;
14527 ip4_address_t leid4, reid4;
14528 ip6_address_t leid6, reid6;
14529 u8 reid_mac[6] = { 0 };
14530 u8 leid_mac[6] = { 0 };
14531 u8 reid_type, leid_type;
14532 u32 leid_len = 0, reid_len = 0, len;
14536 leid_type = reid_type = (u8) ~ 0;
14538 /* Parse args required to build the message */
14539 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14541 if (unformat (input, "del"))
14545 else if (unformat (input, "add"))
14549 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
14552 reid_type = 0; /* ipv4 */
14555 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
14558 reid_type = 1; /* ipv6 */
14561 else if (unformat (input, "reid %U", unformat_ethernet_address,
14564 reid_type = 2; /* mac */
14566 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
14569 leid_type = 0; /* ipv4 */
14572 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
14575 leid_type = 1; /* ipv6 */
14578 else if (unformat (input, "leid %U", unformat_ethernet_address,
14581 leid_type = 2; /* mac */
14583 else if (unformat (input, "vni %d", &vni))
14589 errmsg ("parse error '%U'", format_unformat_error, input);
14594 if ((u8) ~ 0 == reid_type)
14596 errmsg ("missing params!");
14600 if (leid_type != reid_type)
14602 errmsg ("remote and local EIDs are of different types!");
14606 M (ONE_ADD_DEL_ADJACENCY, mp);
14607 mp->is_add = is_add;
14608 mp->vni = htonl (vni);
14609 mp->leid_len = leid_len;
14610 mp->reid_len = reid_len;
14611 mp->eid_type = reid_type;
14613 switch (mp->eid_type)
14616 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
14617 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
14620 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
14621 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
14624 clib_memcpy (mp->leid, leid_mac, 6);
14625 clib_memcpy (mp->reid, reid_mac, 6);
14628 errmsg ("unknown EID type %d!", mp->eid_type);
14635 /* Wait for a reply... */
14640 #define api_lisp_add_del_adjacency api_one_add_del_adjacency
14643 unformat_gpe_encap_mode (unformat_input_t * input, va_list * args)
14645 u32 *mode = va_arg (*args, u32 *);
14647 if (unformat (input, "lisp"))
14649 else if (unformat (input, "vxlan"))
14658 api_gpe_get_encap_mode (vat_main_t * vam)
14660 vl_api_gpe_get_encap_mode_t *mp;
14663 /* Construct the API message */
14664 M (GPE_GET_ENCAP_MODE, mp);
14669 /* Wait for a reply... */
14675 api_gpe_set_encap_mode (vat_main_t * vam)
14677 unformat_input_t *input = vam->input;
14678 vl_api_gpe_set_encap_mode_t *mp;
14682 /* Parse args required to build the message */
14683 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14685 if (unformat (input, "%U", unformat_gpe_encap_mode, &mode))
14691 /* Construct the API message */
14692 M (GPE_SET_ENCAP_MODE, mp);
14699 /* Wait for a reply... */
14705 api_lisp_gpe_add_del_iface (vat_main_t * vam)
14707 unformat_input_t *input = vam->input;
14708 vl_api_gpe_add_del_iface_t *mp;
14709 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
14710 u32 dp_table = 0, vni = 0;
14713 /* Parse args required to build the message */
14714 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14716 if (unformat (input, "up"))
14721 else if (unformat (input, "down"))
14726 else if (unformat (input, "table_id %d", &dp_table))
14730 else if (unformat (input, "bd_id %d", &dp_table))
14735 else if (unformat (input, "vni %d", &vni))
14743 if (action_set == 0)
14745 errmsg ("Action not set");
14748 if (dp_table_set == 0 || vni_set == 0)
14750 errmsg ("vni and dp_table must be set");
14754 /* Construct the API message */
14755 M (GPE_ADD_DEL_IFACE, mp);
14757 mp->is_add = is_add;
14758 mp->dp_table = dp_table;
14765 /* Wait for a reply... */
14771 * Add/del map request itr rlocs from ONE control plane and updates
14773 * @param vam vpp API test context
14774 * @return return code
14777 api_one_add_del_map_request_itr_rlocs (vat_main_t * vam)
14779 unformat_input_t *input = vam->input;
14780 vl_api_one_add_del_map_request_itr_rlocs_t *mp;
14781 u8 *locator_set_name = 0;
14782 u8 locator_set_name_set = 0;
14786 /* Parse args required to build the message */
14787 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14789 if (unformat (input, "del"))
14793 else if (unformat (input, "%_%v%_", &locator_set_name))
14795 locator_set_name_set = 1;
14799 clib_warning ("parse error '%U'", format_unformat_error, input);
14804 if (is_add && !locator_set_name_set)
14806 errmsg ("itr-rloc is not set!");
14810 if (is_add && vec_len (locator_set_name) > 64)
14812 errmsg ("itr-rloc locator-set name too long");
14813 vec_free (locator_set_name);
14817 M (ONE_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
14818 mp->is_add = is_add;
14821 clib_memcpy (mp->locator_set_name, locator_set_name,
14822 vec_len (locator_set_name));
14826 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
14828 vec_free (locator_set_name);
14833 /* Wait for a reply... */
14838 #define api_lisp_add_del_map_request_itr_rlocs api_one_add_del_map_request_itr_rlocs
14841 api_one_locator_dump (vat_main_t * vam)
14843 unformat_input_t *input = vam->input;
14844 vl_api_one_locator_dump_t *mp;
14845 vl_api_control_ping_t *mp_ping;
14846 u8 is_index_set = 0, is_name_set = 0;
14851 /* Parse args required to build the message */
14852 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14854 if (unformat (input, "ls_name %_%v%_", &ls_name))
14858 else if (unformat (input, "ls_index %d", &ls_index))
14864 errmsg ("parse error '%U'", format_unformat_error, input);
14869 if (!is_index_set && !is_name_set)
14871 errmsg ("error: expected one of index or name!");
14875 if (is_index_set && is_name_set)
14877 errmsg ("error: only one param expected!");
14881 if (vec_len (ls_name) > 62)
14883 errmsg ("error: locator set name too long!");
14887 if (!vam->json_output)
14889 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
14892 M (ONE_LOCATOR_DUMP, mp);
14893 mp->is_index_set = is_index_set;
14896 mp->ls_index = clib_host_to_net_u32 (ls_index);
14899 vec_add1 (ls_name, 0);
14900 strncpy ((char *) mp->ls_name, (char *) ls_name,
14901 sizeof (mp->ls_name) - 1);
14907 /* Use a control ping for synchronization */
14908 M (CONTROL_PING, mp_ping);
14911 /* Wait for a reply... */
14916 #define api_lisp_locator_dump api_one_locator_dump
14919 api_one_locator_set_dump (vat_main_t * vam)
14921 vl_api_one_locator_set_dump_t *mp;
14922 vl_api_control_ping_t *mp_ping;
14923 unformat_input_t *input = vam->input;
14927 /* Parse args required to build the message */
14928 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14930 if (unformat (input, "local"))
14934 else if (unformat (input, "remote"))
14940 errmsg ("parse error '%U'", format_unformat_error, input);
14945 if (!vam->json_output)
14947 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
14950 M (ONE_LOCATOR_SET_DUMP, mp);
14952 mp->filter = filter;
14957 /* Use a control ping for synchronization */
14958 M (CONTROL_PING, mp_ping);
14961 /* Wait for a reply... */
14966 #define api_lisp_locator_set_dump api_one_locator_set_dump
14969 api_one_eid_table_map_dump (vat_main_t * vam)
14973 unformat_input_t *input = vam->input;
14974 vl_api_one_eid_table_map_dump_t *mp;
14975 vl_api_control_ping_t *mp_ping;
14978 /* Parse args required to build the message */
14979 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14981 if (unformat (input, "l2"))
14986 else if (unformat (input, "l3"))
14993 errmsg ("parse error '%U'", format_unformat_error, input);
15000 errmsg ("expected one of 'l2' or 'l3' parameter!");
15004 if (!vam->json_output)
15006 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
15009 M (ONE_EID_TABLE_MAP_DUMP, mp);
15015 /* Use a control ping for synchronization */
15016 M (CONTROL_PING, mp_ping);
15019 /* Wait for a reply... */
15024 #define api_lisp_eid_table_map_dump api_one_eid_table_map_dump
15027 api_one_eid_table_vni_dump (vat_main_t * vam)
15029 vl_api_one_eid_table_vni_dump_t *mp;
15030 vl_api_control_ping_t *mp_ping;
15033 if (!vam->json_output)
15035 print (vam->ofp, "VNI");
15038 M (ONE_EID_TABLE_VNI_DUMP, mp);
15043 /* Use a control ping for synchronization */
15044 M (CONTROL_PING, mp_ping);
15047 /* Wait for a reply... */
15052 #define api_lisp_eid_table_vni_dump api_one_eid_table_vni_dump
15055 api_one_eid_table_dump (vat_main_t * vam)
15057 unformat_input_t *i = vam->input;
15058 vl_api_one_eid_table_dump_t *mp;
15059 vl_api_control_ping_t *mp_ping;
15060 struct in_addr ip4;
15061 struct in6_addr ip6;
15063 u8 eid_type = ~0, eid_set = 0;
15064 u32 prefix_length = ~0, t, vni = 0;
15068 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15070 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
15076 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
15082 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
15087 else if (unformat (i, "vni %d", &t))
15091 else if (unformat (i, "local"))
15095 else if (unformat (i, "remote"))
15101 errmsg ("parse error '%U'", format_unformat_error, i);
15106 if (!vam->json_output)
15108 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
15109 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
15112 M (ONE_EID_TABLE_DUMP, mp);
15114 mp->filter = filter;
15118 mp->vni = htonl (vni);
15119 mp->eid_type = eid_type;
15123 mp->prefix_length = prefix_length;
15124 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
15127 mp->prefix_length = prefix_length;
15128 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
15131 clib_memcpy (mp->eid, mac, sizeof (mac));
15134 errmsg ("unknown EID type %d!", eid_type);
15142 /* Use a control ping for synchronization */
15143 M (CONTROL_PING, mp_ping);
15146 /* Wait for a reply... */
15151 #define api_lisp_eid_table_dump api_one_eid_table_dump
15154 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
15156 unformat_input_t *i = vam->input;
15157 vl_api_gpe_fwd_entries_get_t *mp;
15162 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15164 if (unformat (i, "vni %d", &vni))
15170 errmsg ("parse error '%U'", format_unformat_error, i);
15177 errmsg ("vni not set!");
15181 if (!vam->json_output)
15183 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
15187 M (GPE_FWD_ENTRIES_GET, mp);
15188 mp->vni = clib_host_to_net_u32 (vni);
15193 /* Wait for a reply... */
15198 #define vl_api_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
15199 #define vl_api_gpe_fwd_entries_get_reply_t_print vl_noop_handler
15200 #define vl_api_gpe_fwd_entry_path_details_t_endian vl_noop_handler
15201 #define vl_api_gpe_fwd_entry_path_details_t_print vl_noop_handler
15204 api_one_adjacencies_get (vat_main_t * vam)
15206 unformat_input_t *i = vam->input;
15207 vl_api_one_adjacencies_get_t *mp;
15212 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15214 if (unformat (i, "vni %d", &vni))
15220 errmsg ("parse error '%U'", format_unformat_error, i);
15227 errmsg ("vni not set!");
15231 if (!vam->json_output)
15233 print (vam->ofp, "%s %40s", "leid", "reid");
15236 M (ONE_ADJACENCIES_GET, mp);
15237 mp->vni = clib_host_to_net_u32 (vni);
15242 /* Wait for a reply... */
15247 #define api_lisp_adjacencies_get api_one_adjacencies_get
15250 api_one_map_server_dump (vat_main_t * vam)
15252 vl_api_one_map_server_dump_t *mp;
15253 vl_api_control_ping_t *mp_ping;
15256 if (!vam->json_output)
15258 print (vam->ofp, "%=20s", "Map server");
15261 M (ONE_MAP_SERVER_DUMP, mp);
15265 /* Use a control ping for synchronization */
15266 M (CONTROL_PING, mp_ping);
15269 /* Wait for a reply... */
15274 #define api_lisp_map_server_dump api_one_map_server_dump
15277 api_one_map_resolver_dump (vat_main_t * vam)
15279 vl_api_one_map_resolver_dump_t *mp;
15280 vl_api_control_ping_t *mp_ping;
15283 if (!vam->json_output)
15285 print (vam->ofp, "%=20s", "Map resolver");
15288 M (ONE_MAP_RESOLVER_DUMP, mp);
15292 /* Use a control ping for synchronization */
15293 M (CONTROL_PING, mp_ping);
15296 /* Wait for a reply... */
15301 #define api_lisp_map_resolver_dump api_one_map_resolver_dump
15304 api_show_one_status (vat_main_t * vam)
15306 vl_api_show_one_status_t *mp;
15309 if (!vam->json_output)
15311 print (vam->ofp, "%-20s%-16s", "ONE status", "locator-set");
15314 M (SHOW_ONE_STATUS, mp);
15317 /* Wait for a reply... */
15322 #define api_show_lisp_status api_show_one_status
15325 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
15327 vl_api_gpe_fwd_entry_path_dump_t *mp;
15328 vl_api_control_ping_t *mp_ping;
15329 unformat_input_t *i = vam->input;
15330 u32 fwd_entry_index = ~0;
15333 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15335 if (unformat (i, "index %d", &fwd_entry_index))
15341 if (~0 == fwd_entry_index)
15343 errmsg ("no index specified!");
15347 if (!vam->json_output)
15349 print (vam->ofp, "first line");
15352 M (GPE_FWD_ENTRY_PATH_DUMP, mp);
15356 /* Use a control ping for synchronization */
15357 M (CONTROL_PING, mp_ping);
15360 /* Wait for a reply... */
15366 api_one_get_map_request_itr_rlocs (vat_main_t * vam)
15368 vl_api_one_get_map_request_itr_rlocs_t *mp;
15371 if (!vam->json_output)
15373 print (vam->ofp, "%=20s", "itr-rlocs:");
15376 M (ONE_GET_MAP_REQUEST_ITR_RLOCS, mp);
15379 /* Wait for a reply... */
15384 #define api_lisp_get_map_request_itr_rlocs api_one_get_map_request_itr_rlocs
15387 api_af_packet_create (vat_main_t * vam)
15389 unformat_input_t *i = vam->input;
15390 vl_api_af_packet_create_t *mp;
15391 u8 *host_if_name = 0;
15393 u8 random_hw_addr = 1;
15396 memset (hw_addr, 0, sizeof (hw_addr));
15398 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15400 if (unformat (i, "name %s", &host_if_name))
15401 vec_add1 (host_if_name, 0);
15402 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
15403 random_hw_addr = 0;
15408 if (!vec_len (host_if_name))
15410 errmsg ("host-interface name must be specified");
15414 if (vec_len (host_if_name) > 64)
15416 errmsg ("host-interface name too long");
15420 M (AF_PACKET_CREATE, mp);
15422 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
15423 clib_memcpy (mp->hw_addr, hw_addr, 6);
15424 mp->use_random_hw_addr = random_hw_addr;
15425 vec_free (host_if_name);
15428 W2 (ret, fprintf (vam->ofp, " new sw_if_index = %d ", vam->sw_if_index));
15433 api_af_packet_delete (vat_main_t * vam)
15435 unformat_input_t *i = vam->input;
15436 vl_api_af_packet_delete_t *mp;
15437 u8 *host_if_name = 0;
15440 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15442 if (unformat (i, "name %s", &host_if_name))
15443 vec_add1 (host_if_name, 0);
15448 if (!vec_len (host_if_name))
15450 errmsg ("host-interface name must be specified");
15454 if (vec_len (host_if_name) > 64)
15456 errmsg ("host-interface name too long");
15460 M (AF_PACKET_DELETE, mp);
15462 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
15463 vec_free (host_if_name);
15471 api_policer_add_del (vat_main_t * vam)
15473 unformat_input_t *i = vam->input;
15474 vl_api_policer_add_del_t *mp;
15484 u8 color_aware = 0;
15485 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
15488 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
15489 conform_action.dscp = 0;
15490 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
15491 exceed_action.dscp = 0;
15492 violate_action.action_type = SSE2_QOS_ACTION_DROP;
15493 violate_action.dscp = 0;
15495 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15497 if (unformat (i, "del"))
15499 else if (unformat (i, "name %s", &name))
15500 vec_add1 (name, 0);
15501 else if (unformat (i, "cir %u", &cir))
15503 else if (unformat (i, "eir %u", &eir))
15505 else if (unformat (i, "cb %u", &cb))
15507 else if (unformat (i, "eb %u", &eb))
15509 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
15512 else if (unformat (i, "round_type %U", unformat_policer_round_type,
15515 else if (unformat (i, "type %U", unformat_policer_type, &type))
15517 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
15520 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
15523 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
15526 else if (unformat (i, "color-aware"))
15532 if (!vec_len (name))
15534 errmsg ("policer name must be specified");
15538 if (vec_len (name) > 64)
15540 errmsg ("policer name too long");
15544 M (POLICER_ADD_DEL, mp);
15546 clib_memcpy (mp->name, name, vec_len (name));
15548 mp->is_add = is_add;
15553 mp->rate_type = rate_type;
15554 mp->round_type = round_type;
15556 mp->conform_action_type = conform_action.action_type;
15557 mp->conform_dscp = conform_action.dscp;
15558 mp->exceed_action_type = exceed_action.action_type;
15559 mp->exceed_dscp = exceed_action.dscp;
15560 mp->violate_action_type = violate_action.action_type;
15561 mp->violate_dscp = violate_action.dscp;
15562 mp->color_aware = color_aware;
15570 api_policer_dump (vat_main_t * vam)
15572 unformat_input_t *i = vam->input;
15573 vl_api_policer_dump_t *mp;
15574 vl_api_control_ping_t *mp_ping;
15575 u8 *match_name = 0;
15576 u8 match_name_valid = 0;
15579 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15581 if (unformat (i, "name %s", &match_name))
15583 vec_add1 (match_name, 0);
15584 match_name_valid = 1;
15590 M (POLICER_DUMP, mp);
15591 mp->match_name_valid = match_name_valid;
15592 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
15593 vec_free (match_name);
15597 /* Use a control ping for synchronization */
15598 M (CONTROL_PING, mp_ping);
15601 /* Wait for a reply... */
15607 api_policer_classify_set_interface (vat_main_t * vam)
15609 unformat_input_t *i = vam->input;
15610 vl_api_policer_classify_set_interface_t *mp;
15612 int sw_if_index_set;
15613 u32 ip4_table_index = ~0;
15614 u32 ip6_table_index = ~0;
15615 u32 l2_table_index = ~0;
15619 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15621 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15622 sw_if_index_set = 1;
15623 else if (unformat (i, "sw_if_index %d", &sw_if_index))
15624 sw_if_index_set = 1;
15625 else if (unformat (i, "del"))
15627 else if (unformat (i, "ip4-table %d", &ip4_table_index))
15629 else if (unformat (i, "ip6-table %d", &ip6_table_index))
15631 else if (unformat (i, "l2-table %d", &l2_table_index))
15635 clib_warning ("parse error '%U'", format_unformat_error, i);
15640 if (sw_if_index_set == 0)
15642 errmsg ("missing interface name or sw_if_index");
15646 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
15648 mp->sw_if_index = ntohl (sw_if_index);
15649 mp->ip4_table_index = ntohl (ip4_table_index);
15650 mp->ip6_table_index = ntohl (ip6_table_index);
15651 mp->l2_table_index = ntohl (l2_table_index);
15652 mp->is_add = is_add;
15660 api_policer_classify_dump (vat_main_t * vam)
15662 unformat_input_t *i = vam->input;
15663 vl_api_policer_classify_dump_t *mp;
15664 vl_api_control_ping_t *mp_ping;
15665 u8 type = POLICER_CLASSIFY_N_TABLES;
15668 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
15672 errmsg ("classify table type must be specified");
15676 if (!vam->json_output)
15678 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
15681 M (POLICER_CLASSIFY_DUMP, mp);
15686 /* Use a control ping for synchronization */
15687 M (CONTROL_PING, mp_ping);
15690 /* Wait for a reply... */
15696 api_netmap_create (vat_main_t * vam)
15698 unformat_input_t *i = vam->input;
15699 vl_api_netmap_create_t *mp;
15702 u8 random_hw_addr = 1;
15707 memset (hw_addr, 0, sizeof (hw_addr));
15709 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15711 if (unformat (i, "name %s", &if_name))
15712 vec_add1 (if_name, 0);
15713 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
15714 random_hw_addr = 0;
15715 else if (unformat (i, "pipe"))
15717 else if (unformat (i, "master"))
15719 else if (unformat (i, "slave"))
15725 if (!vec_len (if_name))
15727 errmsg ("interface name must be specified");
15731 if (vec_len (if_name) > 64)
15733 errmsg ("interface name too long");
15737 M (NETMAP_CREATE, mp);
15739 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
15740 clib_memcpy (mp->hw_addr, hw_addr, 6);
15741 mp->use_random_hw_addr = random_hw_addr;
15742 mp->is_pipe = is_pipe;
15743 mp->is_master = is_master;
15744 vec_free (if_name);
15752 api_netmap_delete (vat_main_t * vam)
15754 unformat_input_t *i = vam->input;
15755 vl_api_netmap_delete_t *mp;
15759 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15761 if (unformat (i, "name %s", &if_name))
15762 vec_add1 (if_name, 0);
15767 if (!vec_len (if_name))
15769 errmsg ("interface name must be specified");
15773 if (vec_len (if_name) > 64)
15775 errmsg ("interface name too long");
15779 M (NETMAP_DELETE, mp);
15781 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
15782 vec_free (if_name);
15789 static void vl_api_mpls_tunnel_details_t_handler
15790 (vl_api_mpls_tunnel_details_t * mp)
15792 vat_main_t *vam = &vat_main;
15793 i32 len = mp->mt_next_hop_n_labels;
15796 print (vam->ofp, "[%d]: via %U %d labels ",
15798 format_ip4_address, mp->mt_next_hop,
15799 ntohl (mp->mt_next_hop_sw_if_index));
15800 for (i = 0; i < len; i++)
15802 print (vam->ofp, "%u ", ntohl (mp->mt_next_hop_out_labels[i]));
15804 print (vam->ofp, "");
15807 static void vl_api_mpls_tunnel_details_t_handler_json
15808 (vl_api_mpls_tunnel_details_t * mp)
15810 vat_main_t *vam = &vat_main;
15811 vat_json_node_t *node = NULL;
15812 struct in_addr ip4;
15814 i32 len = mp->mt_next_hop_n_labels;
15816 if (VAT_JSON_ARRAY != vam->json_tree.type)
15818 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15819 vat_json_init_array (&vam->json_tree);
15821 node = vat_json_array_add (&vam->json_tree);
15823 vat_json_init_object (node);
15824 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
15825 clib_memcpy (&ip4, &(mp->mt_next_hop), sizeof (ip4));
15826 vat_json_object_add_ip4 (node, "next_hop", ip4);
15827 vat_json_object_add_uint (node, "next_hop_sw_if_index",
15828 ntohl (mp->mt_next_hop_sw_if_index));
15829 vat_json_object_add_uint (node, "l2_only", ntohl (mp->mt_l2_only));
15830 vat_json_object_add_uint (node, "label_count", len);
15831 for (i = 0; i < len; i++)
15833 vat_json_object_add_uint (node, "label",
15834 ntohl (mp->mt_next_hop_out_labels[i]));
15839 api_mpls_tunnel_dump (vat_main_t * vam)
15841 vl_api_mpls_tunnel_dump_t *mp;
15842 vl_api_control_ping_t *mp_ping;
15846 /* Parse args required to build the message */
15847 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
15849 if (!unformat (vam->input, "tunnel_index %d", &index))
15856 print (vam->ofp, " tunnel_index %d", index);
15858 M (MPLS_TUNNEL_DUMP, mp);
15859 mp->tunnel_index = htonl (index);
15862 /* Use a control ping for synchronization */
15863 M (CONTROL_PING, mp_ping);
15870 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
15871 #define vl_api_mpls_fib_details_t_print vl_noop_handler
15874 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
15876 vat_main_t *vam = &vat_main;
15877 int count = ntohl (mp->count);
15878 vl_api_fib_path2_t *fp;
15882 "table-id %d, label %u, ess_bit %u",
15883 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
15885 for (i = 0; i < count; i++)
15887 if (fp->afi == IP46_TYPE_IP6)
15889 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15890 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15891 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15892 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15893 format_ip6_address, fp->next_hop);
15894 else if (fp->afi == IP46_TYPE_IP4)
15896 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15897 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15898 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15899 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15900 format_ip4_address, fp->next_hop);
15905 static void vl_api_mpls_fib_details_t_handler_json
15906 (vl_api_mpls_fib_details_t * mp)
15908 vat_main_t *vam = &vat_main;
15909 int count = ntohl (mp->count);
15910 vat_json_node_t *node = NULL;
15911 struct in_addr ip4;
15912 struct in6_addr ip6;
15913 vl_api_fib_path2_t *fp;
15916 if (VAT_JSON_ARRAY != vam->json_tree.type)
15918 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15919 vat_json_init_array (&vam->json_tree);
15921 node = vat_json_array_add (&vam->json_tree);
15923 vat_json_init_object (node);
15924 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
15925 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
15926 vat_json_object_add_uint (node, "label", ntohl (mp->label));
15927 vat_json_object_add_uint (node, "path_count", count);
15929 for (i = 0; i < count; i++)
15931 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
15932 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
15933 vat_json_object_add_uint (node, "is_local", fp->is_local);
15934 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
15935 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
15936 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
15937 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
15938 if (fp->afi == IP46_TYPE_IP4)
15940 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
15941 vat_json_object_add_ip4 (node, "next_hop", ip4);
15943 else if (fp->afi == IP46_TYPE_IP6)
15945 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
15946 vat_json_object_add_ip6 (node, "next_hop", ip6);
15952 api_mpls_fib_dump (vat_main_t * vam)
15954 vl_api_mpls_fib_dump_t *mp;
15955 vl_api_control_ping_t *mp_ping;
15958 M (MPLS_FIB_DUMP, mp);
15961 /* Use a control ping for synchronization */
15962 M (CONTROL_PING, mp_ping);
15969 #define vl_api_ip_fib_details_t_endian vl_noop_handler
15970 #define vl_api_ip_fib_details_t_print vl_noop_handler
15973 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
15975 vat_main_t *vam = &vat_main;
15976 int count = ntohl (mp->count);
15977 vl_api_fib_path_t *fp;
15981 "table-id %d, prefix %U/%d",
15982 ntohl (mp->table_id), format_ip4_address, mp->address,
15983 mp->address_length);
15985 for (i = 0; i < count; i++)
15987 if (fp->afi == IP46_TYPE_IP6)
15989 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15990 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15991 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15992 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15993 format_ip6_address, fp->next_hop);
15994 else if (fp->afi == IP46_TYPE_IP4)
15996 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15997 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15998 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15999 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16000 format_ip4_address, fp->next_hop);
16005 static void vl_api_ip_fib_details_t_handler_json
16006 (vl_api_ip_fib_details_t * mp)
16008 vat_main_t *vam = &vat_main;
16009 int count = ntohl (mp->count);
16010 vat_json_node_t *node = NULL;
16011 struct in_addr ip4;
16012 struct in6_addr ip6;
16013 vl_api_fib_path_t *fp;
16016 if (VAT_JSON_ARRAY != vam->json_tree.type)
16018 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16019 vat_json_init_array (&vam->json_tree);
16021 node = vat_json_array_add (&vam->json_tree);
16023 vat_json_init_object (node);
16024 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
16025 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
16026 vat_json_object_add_ip4 (node, "prefix", ip4);
16027 vat_json_object_add_uint (node, "mask_length", mp->address_length);
16028 vat_json_object_add_uint (node, "path_count", count);
16030 for (i = 0; i < count; i++)
16032 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
16033 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
16034 vat_json_object_add_uint (node, "is_local", fp->is_local);
16035 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
16036 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
16037 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
16038 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
16039 if (fp->afi == IP46_TYPE_IP4)
16041 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
16042 vat_json_object_add_ip4 (node, "next_hop", ip4);
16044 else if (fp->afi == IP46_TYPE_IP6)
16046 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
16047 vat_json_object_add_ip6 (node, "next_hop", ip6);
16053 api_ip_fib_dump (vat_main_t * vam)
16055 vl_api_ip_fib_dump_t *mp;
16056 vl_api_control_ping_t *mp_ping;
16059 M (IP_FIB_DUMP, mp);
16062 /* Use a control ping for synchronization */
16063 M (CONTROL_PING, mp_ping);
16071 api_ip_mfib_dump (vat_main_t * vam)
16073 vl_api_ip_mfib_dump_t *mp;
16074 vl_api_control_ping_t *mp_ping;
16077 M (IP_MFIB_DUMP, mp);
16080 /* Use a control ping for synchronization */
16081 M (CONTROL_PING, mp_ping);
16088 static void vl_api_ip_neighbor_details_t_handler
16089 (vl_api_ip_neighbor_details_t * mp)
16091 vat_main_t *vam = &vat_main;
16093 print (vam->ofp, "%c %U %U",
16094 (mp->is_static) ? 'S' : 'D',
16095 format_ethernet_address, &mp->mac_address,
16096 (mp->is_ipv6) ? format_ip6_address : format_ip4_address,
16100 static void vl_api_ip_neighbor_details_t_handler_json
16101 (vl_api_ip_neighbor_details_t * mp)
16104 vat_main_t *vam = &vat_main;
16105 vat_json_node_t *node;
16106 struct in_addr ip4;
16107 struct in6_addr ip6;
16109 if (VAT_JSON_ARRAY != vam->json_tree.type)
16111 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16112 vat_json_init_array (&vam->json_tree);
16114 node = vat_json_array_add (&vam->json_tree);
16116 vat_json_init_object (node);
16117 vat_json_object_add_string_copy (node, "flag",
16118 (mp->is_static) ? (u8 *) "static" : (u8 *)
16121 vat_json_object_add_string_copy (node, "link_layer",
16122 format (0, "%U", format_ethernet_address,
16123 &mp->mac_address));
16127 clib_memcpy (&ip6, &mp->ip_address, sizeof (ip6));
16128 vat_json_object_add_ip6 (node, "ip_address", ip6);
16132 clib_memcpy (&ip4, &mp->ip_address, sizeof (ip4));
16133 vat_json_object_add_ip4 (node, "ip_address", ip4);
16138 api_ip_neighbor_dump (vat_main_t * vam)
16140 unformat_input_t *i = vam->input;
16141 vl_api_ip_neighbor_dump_t *mp;
16142 vl_api_control_ping_t *mp_ping;
16144 u32 sw_if_index = ~0;
16147 /* Parse args required to build the message */
16148 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16150 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16152 else if (unformat (i, "sw_if_index %d", &sw_if_index))
16154 else if (unformat (i, "ip6"))
16160 if (sw_if_index == ~0)
16162 errmsg ("missing interface name or sw_if_index");
16166 M (IP_NEIGHBOR_DUMP, mp);
16167 mp->is_ipv6 = (u8) is_ipv6;
16168 mp->sw_if_index = ntohl (sw_if_index);
16171 /* Use a control ping for synchronization */
16172 M (CONTROL_PING, mp_ping);
16179 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
16180 #define vl_api_ip6_fib_details_t_print vl_noop_handler
16183 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
16185 vat_main_t *vam = &vat_main;
16186 int count = ntohl (mp->count);
16187 vl_api_fib_path_t *fp;
16191 "table-id %d, prefix %U/%d",
16192 ntohl (mp->table_id), format_ip6_address, mp->address,
16193 mp->address_length);
16195 for (i = 0; i < count; i++)
16197 if (fp->afi == IP46_TYPE_IP6)
16199 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16200 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16201 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16202 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16203 format_ip6_address, fp->next_hop);
16204 else if (fp->afi == IP46_TYPE_IP4)
16206 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16207 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16208 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16209 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16210 format_ip4_address, fp->next_hop);
16215 static void vl_api_ip6_fib_details_t_handler_json
16216 (vl_api_ip6_fib_details_t * mp)
16218 vat_main_t *vam = &vat_main;
16219 int count = ntohl (mp->count);
16220 vat_json_node_t *node = NULL;
16221 struct in_addr ip4;
16222 struct in6_addr ip6;
16223 vl_api_fib_path_t *fp;
16226 if (VAT_JSON_ARRAY != vam->json_tree.type)
16228 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16229 vat_json_init_array (&vam->json_tree);
16231 node = vat_json_array_add (&vam->json_tree);
16233 vat_json_init_object (node);
16234 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
16235 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
16236 vat_json_object_add_ip6 (node, "prefix", ip6);
16237 vat_json_object_add_uint (node, "mask_length", mp->address_length);
16238 vat_json_object_add_uint (node, "path_count", count);
16240 for (i = 0; i < count; i++)
16242 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
16243 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
16244 vat_json_object_add_uint (node, "is_local", fp->is_local);
16245 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
16246 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
16247 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
16248 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
16249 if (fp->afi == IP46_TYPE_IP4)
16251 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
16252 vat_json_object_add_ip4 (node, "next_hop", ip4);
16254 else if (fp->afi == IP46_TYPE_IP6)
16256 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
16257 vat_json_object_add_ip6 (node, "next_hop", ip6);
16263 api_ip6_fib_dump (vat_main_t * vam)
16265 vl_api_ip6_fib_dump_t *mp;
16266 vl_api_control_ping_t *mp_ping;
16269 M (IP6_FIB_DUMP, mp);
16272 /* Use a control ping for synchronization */
16273 M (CONTROL_PING, mp_ping);
16281 api_ip6_mfib_dump (vat_main_t * vam)
16283 vl_api_ip6_mfib_dump_t *mp;
16284 vl_api_control_ping_t *mp_ping;
16287 M (IP6_MFIB_DUMP, mp);
16290 /* Use a control ping for synchronization */
16291 M (CONTROL_PING, mp_ping);
16299 api_classify_table_ids (vat_main_t * vam)
16301 vl_api_classify_table_ids_t *mp;
16304 /* Construct the API message */
16305 M (CLASSIFY_TABLE_IDS, mp);
16314 api_classify_table_by_interface (vat_main_t * vam)
16316 unformat_input_t *input = vam->input;
16317 vl_api_classify_table_by_interface_t *mp;
16319 u32 sw_if_index = ~0;
16321 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16323 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16325 else if (unformat (input, "sw_if_index %d", &sw_if_index))
16330 if (sw_if_index == ~0)
16332 errmsg ("missing interface name or sw_if_index");
16336 /* Construct the API message */
16337 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
16339 mp->sw_if_index = ntohl (sw_if_index);
16347 api_classify_table_info (vat_main_t * vam)
16349 unformat_input_t *input = vam->input;
16350 vl_api_classify_table_info_t *mp;
16354 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16356 if (unformat (input, "table_id %d", &table_id))
16361 if (table_id == ~0)
16363 errmsg ("missing table id");
16367 /* Construct the API message */
16368 M (CLASSIFY_TABLE_INFO, mp);
16370 mp->table_id = ntohl (table_id);
16378 api_classify_session_dump (vat_main_t * vam)
16380 unformat_input_t *input = vam->input;
16381 vl_api_classify_session_dump_t *mp;
16382 vl_api_control_ping_t *mp_ping;
16386 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16388 if (unformat (input, "table_id %d", &table_id))
16393 if (table_id == ~0)
16395 errmsg ("missing table id");
16399 /* Construct the API message */
16400 M (CLASSIFY_SESSION_DUMP, mp);
16402 mp->table_id = ntohl (table_id);
16405 /* Use a control ping for synchronization */
16406 M (CONTROL_PING, mp_ping);
16414 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
16416 vat_main_t *vam = &vat_main;
16418 print (vam->ofp, "collector_address %U, collector_port %d, "
16419 "src_address %U, vrf_id %d, path_mtu %u, "
16420 "template_interval %u, udp_checksum %d",
16421 format_ip4_address, mp->collector_address,
16422 ntohs (mp->collector_port),
16423 format_ip4_address, mp->src_address,
16424 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
16425 ntohl (mp->template_interval), mp->udp_checksum);
16428 vam->result_ready = 1;
16432 vl_api_ipfix_exporter_details_t_handler_json
16433 (vl_api_ipfix_exporter_details_t * mp)
16435 vat_main_t *vam = &vat_main;
16436 vat_json_node_t node;
16437 struct in_addr collector_address;
16438 struct in_addr src_address;
16440 vat_json_init_object (&node);
16441 clib_memcpy (&collector_address, &mp->collector_address,
16442 sizeof (collector_address));
16443 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
16444 vat_json_object_add_uint (&node, "collector_port",
16445 ntohs (mp->collector_port));
16446 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
16447 vat_json_object_add_ip4 (&node, "src_address", src_address);
16448 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
16449 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
16450 vat_json_object_add_uint (&node, "template_interval",
16451 ntohl (mp->template_interval));
16452 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
16454 vat_json_print (vam->ofp, &node);
16455 vat_json_free (&node);
16457 vam->result_ready = 1;
16461 api_ipfix_exporter_dump (vat_main_t * vam)
16463 vl_api_ipfix_exporter_dump_t *mp;
16466 /* Construct the API message */
16467 M (IPFIX_EXPORTER_DUMP, mp);
16476 api_ipfix_classify_stream_dump (vat_main_t * vam)
16478 vl_api_ipfix_classify_stream_dump_t *mp;
16481 /* Construct the API message */
16482 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
16493 vl_api_ipfix_classify_stream_details_t_handler
16494 (vl_api_ipfix_classify_stream_details_t * mp)
16496 vat_main_t *vam = &vat_main;
16497 print (vam->ofp, "domain_id %d, src_port %d",
16498 ntohl (mp->domain_id), ntohs (mp->src_port));
16500 vam->result_ready = 1;
16504 vl_api_ipfix_classify_stream_details_t_handler_json
16505 (vl_api_ipfix_classify_stream_details_t * mp)
16507 vat_main_t *vam = &vat_main;
16508 vat_json_node_t node;
16510 vat_json_init_object (&node);
16511 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
16512 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
16514 vat_json_print (vam->ofp, &node);
16515 vat_json_free (&node);
16517 vam->result_ready = 1;
16521 api_ipfix_classify_table_dump (vat_main_t * vam)
16523 vl_api_ipfix_classify_table_dump_t *mp;
16524 vl_api_control_ping_t *mp_ping;
16527 if (!vam->json_output)
16529 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
16530 "transport_protocol");
16533 /* Construct the API message */
16534 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
16539 /* Use a control ping for synchronization */
16540 M (CONTROL_PING, mp_ping);
16548 vl_api_ipfix_classify_table_details_t_handler
16549 (vl_api_ipfix_classify_table_details_t * mp)
16551 vat_main_t *vam = &vat_main;
16552 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
16553 mp->transport_protocol);
16557 vl_api_ipfix_classify_table_details_t_handler_json
16558 (vl_api_ipfix_classify_table_details_t * mp)
16560 vat_json_node_t *node = NULL;
16561 vat_main_t *vam = &vat_main;
16563 if (VAT_JSON_ARRAY != vam->json_tree.type)
16565 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16566 vat_json_init_array (&vam->json_tree);
16569 node = vat_json_array_add (&vam->json_tree);
16570 vat_json_init_object (node);
16572 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
16573 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
16574 vat_json_object_add_uint (node, "transport_protocol",
16575 mp->transport_protocol);
16579 api_sw_interface_span_enable_disable (vat_main_t * vam)
16581 unformat_input_t *i = vam->input;
16582 vl_api_sw_interface_span_enable_disable_t *mp;
16583 u32 src_sw_if_index = ~0;
16584 u32 dst_sw_if_index = ~0;
16588 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16591 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
16593 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
16597 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
16599 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
16601 else if (unformat (i, "disable"))
16603 else if (unformat (i, "rx"))
16605 else if (unformat (i, "tx"))
16607 else if (unformat (i, "both"))
16613 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
16615 mp->sw_if_index_from = htonl (src_sw_if_index);
16616 mp->sw_if_index_to = htonl (dst_sw_if_index);
16625 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
16628 vat_main_t *vam = &vat_main;
16629 u8 *sw_if_from_name = 0;
16630 u8 *sw_if_to_name = 0;
16631 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
16632 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
16633 char *states[] = { "none", "rx", "tx", "both" };
16637 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
16639 if ((u32) p->value[0] == sw_if_index_from)
16641 sw_if_from_name = (u8 *)(p->key);
16645 if ((u32) p->value[0] == sw_if_index_to)
16647 sw_if_to_name = (u8 *)(p->key);
16648 if (sw_if_from_name)
16653 print (vam->ofp, "%20s => %20s (%s)",
16654 sw_if_from_name, sw_if_to_name, states[mp->state]);
16658 vl_api_sw_interface_span_details_t_handler_json
16659 (vl_api_sw_interface_span_details_t * mp)
16661 vat_main_t *vam = &vat_main;
16662 vat_json_node_t *node = NULL;
16663 u8 *sw_if_from_name = 0;
16664 u8 *sw_if_to_name = 0;
16665 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
16666 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
16670 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
16672 if ((u32) p->value[0] == sw_if_index_from)
16674 sw_if_from_name = (u8 *)(p->key);
16678 if ((u32) p->value[0] == sw_if_index_to)
16680 sw_if_to_name = (u8 *)(p->key);
16681 if (sw_if_from_name)
16687 if (VAT_JSON_ARRAY != vam->json_tree.type)
16689 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16690 vat_json_init_array (&vam->json_tree);
16692 node = vat_json_array_add (&vam->json_tree);
16694 vat_json_init_object (node);
16695 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
16696 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
16697 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
16698 if (0 != sw_if_to_name)
16700 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
16702 vat_json_object_add_uint (node, "state", mp->state);
16706 api_sw_interface_span_dump (vat_main_t * vam)
16708 vl_api_sw_interface_span_dump_t *mp;
16709 vl_api_control_ping_t *mp_ping;
16712 M (SW_INTERFACE_SPAN_DUMP, mp);
16715 /* Use a control ping for synchronization */
16716 M (CONTROL_PING, mp_ping);
16724 api_pg_create_interface (vat_main_t * vam)
16726 unformat_input_t *input = vam->input;
16727 vl_api_pg_create_interface_t *mp;
16731 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16733 if (unformat (input, "if_id %d", &if_id))
16740 errmsg ("missing pg interface index");
16744 /* Construct the API message */
16745 M (PG_CREATE_INTERFACE, mp);
16747 mp->interface_id = ntohl (if_id);
16755 api_pg_capture (vat_main_t * vam)
16757 unformat_input_t *input = vam->input;
16758 vl_api_pg_capture_t *mp;
16763 u8 pcap_file_set = 0;
16766 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16768 if (unformat (input, "if_id %d", &if_id))
16770 else if (unformat (input, "pcap %s", &pcap_file))
16772 else if (unformat (input, "count %d", &count))
16774 else if (unformat (input, "disable"))
16781 errmsg ("missing pg interface index");
16784 if (pcap_file_set > 0)
16786 if (vec_len (pcap_file) > 255)
16788 errmsg ("pcap file name is too long");
16793 u32 name_len = vec_len (pcap_file);
16794 /* Construct the API message */
16795 M (PG_CAPTURE, mp);
16797 mp->interface_id = ntohl (if_id);
16798 mp->is_enabled = enable;
16799 mp->count = ntohl (count);
16800 mp->pcap_name_length = ntohl (name_len);
16801 if (pcap_file_set != 0)
16803 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
16805 vec_free (pcap_file);
16813 api_pg_enable_disable (vat_main_t * vam)
16815 unformat_input_t *input = vam->input;
16816 vl_api_pg_enable_disable_t *mp;
16819 u8 stream_name_set = 0;
16820 u8 *stream_name = 0;
16822 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16824 if (unformat (input, "stream %s", &stream_name))
16825 stream_name_set = 1;
16826 else if (unformat (input, "disable"))
16832 if (stream_name_set > 0)
16834 if (vec_len (stream_name) > 255)
16836 errmsg ("stream name too long");
16841 u32 name_len = vec_len (stream_name);
16842 /* Construct the API message */
16843 M (PG_ENABLE_DISABLE, mp);
16845 mp->is_enabled = enable;
16846 if (stream_name_set != 0)
16848 mp->stream_name_length = ntohl (name_len);
16849 clib_memcpy (mp->stream_name, stream_name, name_len);
16851 vec_free (stream_name);
16859 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
16861 unformat_input_t *input = vam->input;
16862 vl_api_ip_source_and_port_range_check_add_del_t *mp;
16864 u16 *low_ports = 0;
16865 u16 *high_ports = 0;
16868 ip4_address_t ip4_addr;
16869 ip6_address_t ip6_addr;
16878 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16880 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
16886 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
16891 else if (unformat (input, "vrf %d", &vrf_id))
16893 else if (unformat (input, "del"))
16895 else if (unformat (input, "port %d", &tmp))
16897 if (tmp == 0 || tmp > 65535)
16899 errmsg ("port %d out of range", tmp);
16903 this_hi = this_low + 1;
16904 vec_add1 (low_ports, this_low);
16905 vec_add1 (high_ports, this_hi);
16907 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
16909 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
16911 errmsg ("incorrect range parameters");
16915 /* Note: in debug CLI +1 is added to high before
16916 passing to real fn that does "the work"
16917 (ip_source_and_port_range_check_add_del).
16918 This fn is a wrapper around the binary API fn a
16919 control plane will call, which expects this increment
16920 to have occurred. Hence letting the binary API control
16921 plane fn do the increment for consistency between VAT
16922 and other control planes.
16925 vec_add1 (low_ports, this_low);
16926 vec_add1 (high_ports, this_hi);
16932 if (prefix_set == 0)
16934 errmsg ("<address>/<mask> not specified");
16940 errmsg ("VRF ID required, not specified");
16947 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
16951 if (vec_len (low_ports) == 0)
16953 errmsg ("At least one port or port range required");
16957 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
16959 mp->is_add = is_add;
16964 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
16969 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
16972 mp->mask_length = length;
16973 mp->number_of_ranges = vec_len (low_ports);
16975 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
16976 vec_free (low_ports);
16978 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
16979 vec_free (high_ports);
16981 mp->vrf_id = ntohl (vrf_id);
16989 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
16991 unformat_input_t *input = vam->input;
16992 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
16993 u32 sw_if_index = ~0;
16995 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
16996 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
17000 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17002 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17004 else if (unformat (input, "sw_if_index %d", &sw_if_index))
17006 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
17008 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
17010 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
17012 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
17014 else if (unformat (input, "del"))
17020 if (sw_if_index == ~0)
17022 errmsg ("Interface required but not specified");
17028 errmsg ("VRF ID required but not specified");
17032 if (tcp_out_vrf_id == 0
17033 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
17036 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
17040 /* Construct the API message */
17041 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
17043 mp->sw_if_index = ntohl (sw_if_index);
17044 mp->is_add = is_add;
17045 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
17046 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
17047 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
17048 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
17053 /* Wait for a reply... */
17059 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
17061 unformat_input_t *i = vam->input;
17062 vl_api_ipsec_gre_add_del_tunnel_t *mp;
17063 u32 local_sa_id = 0;
17064 u32 remote_sa_id = 0;
17065 ip4_address_t src_address;
17066 ip4_address_t dst_address;
17070 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17072 if (unformat (i, "local_sa %d", &local_sa_id))
17074 else if (unformat (i, "remote_sa %d", &remote_sa_id))
17076 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
17078 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
17080 else if (unformat (i, "del"))
17084 clib_warning ("parse error '%U'", format_unformat_error, i);
17089 M (IPSEC_GRE_ADD_DEL_TUNNEL, mp);
17091 mp->local_sa_id = ntohl (local_sa_id);
17092 mp->remote_sa_id = ntohl (remote_sa_id);
17093 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
17094 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
17095 mp->is_add = is_add;
17103 api_punt (vat_main_t * vam)
17105 unformat_input_t *i = vam->input;
17113 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17115 if (unformat (i, "ip %d", &ipv))
17117 else if (unformat (i, "protocol %d", &protocol))
17119 else if (unformat (i, "port %d", &port))
17121 else if (unformat (i, "del"))
17125 clib_warning ("parse error '%U'", format_unformat_error, i);
17132 mp->is_add = (u8) is_add;
17133 mp->ipv = (u8) ipv;
17134 mp->l4_protocol = (u8) protocol;
17135 mp->l4_port = htons ((u16) port);
17142 static void vl_api_ipsec_gre_tunnel_details_t_handler
17143 (vl_api_ipsec_gre_tunnel_details_t * mp)
17145 vat_main_t *vam = &vat_main;
17147 print (vam->ofp, "%11d%15U%15U%14d%14d",
17148 ntohl (mp->sw_if_index),
17149 format_ip4_address, &mp->src_address,
17150 format_ip4_address, &mp->dst_address,
17151 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
17154 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
17155 (vl_api_ipsec_gre_tunnel_details_t * mp)
17157 vat_main_t *vam = &vat_main;
17158 vat_json_node_t *node = NULL;
17159 struct in_addr ip4;
17161 if (VAT_JSON_ARRAY != vam->json_tree.type)
17163 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17164 vat_json_init_array (&vam->json_tree);
17166 node = vat_json_array_add (&vam->json_tree);
17168 vat_json_init_object (node);
17169 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
17170 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
17171 vat_json_object_add_ip4 (node, "src_address", ip4);
17172 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
17173 vat_json_object_add_ip4 (node, "dst_address", ip4);
17174 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
17175 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
17179 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
17181 unformat_input_t *i = vam->input;
17182 vl_api_ipsec_gre_tunnel_dump_t *mp;
17183 vl_api_control_ping_t *mp_ping;
17185 u8 sw_if_index_set = 0;
17188 /* Parse args required to build the message */
17189 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17191 if (unformat (i, "sw_if_index %d", &sw_if_index))
17192 sw_if_index_set = 1;
17197 if (sw_if_index_set == 0)
17202 if (!vam->json_output)
17204 print (vam->ofp, "%11s%15s%15s%14s%14s",
17205 "sw_if_index", "src_address", "dst_address",
17206 "local_sa_id", "remote_sa_id");
17209 /* Get list of gre-tunnel interfaces */
17210 M (IPSEC_GRE_TUNNEL_DUMP, mp);
17212 mp->sw_if_index = htonl (sw_if_index);
17216 /* Use a control ping for synchronization */
17217 M (CONTROL_PING, mp_ping);
17225 api_delete_subif (vat_main_t * vam)
17227 unformat_input_t *i = vam->input;
17228 vl_api_delete_subif_t *mp;
17229 u32 sw_if_index = ~0;
17232 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17234 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17236 if (unformat (i, "sw_if_index %d", &sw_if_index))
17242 if (sw_if_index == ~0)
17244 errmsg ("missing sw_if_index");
17248 /* Construct the API message */
17249 M (DELETE_SUBIF, mp);
17250 mp->sw_if_index = ntohl (sw_if_index);
17257 #define foreach_pbb_vtr_op \
17258 _("disable", L2_VTR_DISABLED) \
17259 _("pop", L2_VTR_POP_2) \
17260 _("push", L2_VTR_PUSH_2)
17263 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
17265 unformat_input_t *i = vam->input;
17266 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
17267 u32 sw_if_index = ~0, vtr_op = ~0;
17268 u16 outer_tag = ~0;
17269 u8 dmac[6], smac[6];
17270 u8 dmac_set = 0, smac_set = 0;
17276 /* Shut up coverity */
17277 memset (dmac, 0, sizeof (dmac));
17278 memset (smac, 0, sizeof (smac));
17280 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17282 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17284 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17286 else if (unformat (i, "vtr_op %d", &vtr_op))
17288 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
17291 else if (unformat (i, "translate_pbb_stag"))
17293 if (unformat (i, "%d", &tmp))
17295 vtr_op = L2_VTR_TRANSLATE_2_1;
17301 ("translate_pbb_stag operation requires outer tag definition");
17305 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
17307 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
17309 else if (unformat (i, "sid %d", &sid))
17311 else if (unformat (i, "vlanid %d", &tmp))
17315 clib_warning ("parse error '%U'", format_unformat_error, i);
17320 if ((sw_if_index == ~0) || (vtr_op == ~0))
17322 errmsg ("missing sw_if_index or vtr operation");
17325 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
17326 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
17329 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
17333 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
17334 mp->sw_if_index = ntohl (sw_if_index);
17335 mp->vtr_op = ntohl (vtr_op);
17336 mp->outer_tag = ntohs (outer_tag);
17337 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
17338 clib_memcpy (mp->b_smac, smac, sizeof (smac));
17339 mp->b_vlanid = ntohs (vlanid);
17340 mp->i_sid = ntohl (sid);
17348 api_flow_classify_set_interface (vat_main_t * vam)
17350 unformat_input_t *i = vam->input;
17351 vl_api_flow_classify_set_interface_t *mp;
17353 int sw_if_index_set;
17354 u32 ip4_table_index = ~0;
17355 u32 ip6_table_index = ~0;
17359 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17361 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17362 sw_if_index_set = 1;
17363 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17364 sw_if_index_set = 1;
17365 else if (unformat (i, "del"))
17367 else if (unformat (i, "ip4-table %d", &ip4_table_index))
17369 else if (unformat (i, "ip6-table %d", &ip6_table_index))
17373 clib_warning ("parse error '%U'", format_unformat_error, i);
17378 if (sw_if_index_set == 0)
17380 errmsg ("missing interface name or sw_if_index");
17384 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
17386 mp->sw_if_index = ntohl (sw_if_index);
17387 mp->ip4_table_index = ntohl (ip4_table_index);
17388 mp->ip6_table_index = ntohl (ip6_table_index);
17389 mp->is_add = is_add;
17397 api_flow_classify_dump (vat_main_t * vam)
17399 unformat_input_t *i = vam->input;
17400 vl_api_flow_classify_dump_t *mp;
17401 vl_api_control_ping_t *mp_ping;
17402 u8 type = FLOW_CLASSIFY_N_TABLES;
17405 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
17409 errmsg ("classify table type must be specified");
17413 if (!vam->json_output)
17415 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
17418 M (FLOW_CLASSIFY_DUMP, mp);
17423 /* Use a control ping for synchronization */
17424 M (CONTROL_PING, mp_ping);
17427 /* Wait for a reply... */
17433 api_feature_enable_disable (vat_main_t * vam)
17435 unformat_input_t *i = vam->input;
17436 vl_api_feature_enable_disable_t *mp;
17438 u8 *feature_name = 0;
17439 u32 sw_if_index = ~0;
17443 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17445 if (unformat (i, "arc_name %s", &arc_name))
17447 else if (unformat (i, "feature_name %s", &feature_name))
17450 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17452 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17454 else if (unformat (i, "disable"))
17462 errmsg ("missing arc name");
17465 if (vec_len (arc_name) > 63)
17467 errmsg ("arc name too long");
17470 if (feature_name == 0)
17472 errmsg ("missing feature name");
17475 if (vec_len (feature_name) > 63)
17477 errmsg ("feature name too long");
17480 if (sw_if_index == ~0)
17482 errmsg ("missing interface name or sw_if_index");
17486 /* Construct the API message */
17487 M (FEATURE_ENABLE_DISABLE, mp);
17488 mp->sw_if_index = ntohl (sw_if_index);
17489 mp->enable = enable;
17490 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
17491 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
17492 vec_free (arc_name);
17493 vec_free (feature_name);
17501 api_sw_interface_tag_add_del (vat_main_t * vam)
17503 unformat_input_t *i = vam->input;
17504 vl_api_sw_interface_tag_add_del_t *mp;
17505 u32 sw_if_index = ~0;
17510 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17512 if (unformat (i, "tag %s", &tag))
17514 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17516 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17518 else if (unformat (i, "del"))
17524 if (sw_if_index == ~0)
17526 errmsg ("missing interface name or sw_if_index");
17530 if (enable && (tag == 0))
17532 errmsg ("no tag specified");
17536 /* Construct the API message */
17537 M (SW_INTERFACE_TAG_ADD_DEL, mp);
17538 mp->sw_if_index = ntohl (sw_if_index);
17539 mp->is_add = enable;
17541 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
17549 static void vl_api_l2_xconnect_details_t_handler
17550 (vl_api_l2_xconnect_details_t * mp)
17552 vat_main_t *vam = &vat_main;
17554 print (vam->ofp, "%15d%15d",
17555 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
17558 static void vl_api_l2_xconnect_details_t_handler_json
17559 (vl_api_l2_xconnect_details_t * mp)
17561 vat_main_t *vam = &vat_main;
17562 vat_json_node_t *node = NULL;
17564 if (VAT_JSON_ARRAY != vam->json_tree.type)
17566 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17567 vat_json_init_array (&vam->json_tree);
17569 node = vat_json_array_add (&vam->json_tree);
17571 vat_json_init_object (node);
17572 vat_json_object_add_uint (node, "rx_sw_if_index",
17573 ntohl (mp->rx_sw_if_index));
17574 vat_json_object_add_uint (node, "tx_sw_if_index",
17575 ntohl (mp->tx_sw_if_index));
17579 api_l2_xconnect_dump (vat_main_t * vam)
17581 vl_api_l2_xconnect_dump_t *mp;
17582 vl_api_control_ping_t *mp_ping;
17585 if (!vam->json_output)
17587 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
17590 M (L2_XCONNECT_DUMP, mp);
17594 /* Use a control ping for synchronization */
17595 M (CONTROL_PING, mp_ping);
17603 api_sw_interface_set_mtu (vat_main_t * vam)
17605 unformat_input_t *i = vam->input;
17606 vl_api_sw_interface_set_mtu_t *mp;
17607 u32 sw_if_index = ~0;
17611 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17613 if (unformat (i, "mtu %d", &mtu))
17615 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17617 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17623 if (sw_if_index == ~0)
17625 errmsg ("missing interface name or sw_if_index");
17631 errmsg ("no mtu specified");
17635 /* Construct the API message */
17636 M (SW_INTERFACE_SET_MTU, mp);
17637 mp->sw_if_index = ntohl (sw_if_index);
17638 mp->mtu = ntohs ((u16) mtu);
17647 q_or_quit (vat_main_t * vam)
17649 #if VPP_API_TEST_BUILTIN == 0
17650 longjmp (vam->jump_buf, 1);
17652 return 0; /* not so much */
17656 q (vat_main_t * vam)
17658 return q_or_quit (vam);
17662 quit (vat_main_t * vam)
17664 return q_or_quit (vam);
17668 comment (vat_main_t * vam)
17674 cmd_cmp (void *a1, void *a2)
17679 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
17683 help (vat_main_t * vam)
17688 unformat_input_t *i = vam->input;
17691 if (unformat (i, "%s", &name))
17695 vec_add1 (name, 0);
17697 hs = hash_get_mem (vam->help_by_name, name);
17699 print (vam->ofp, "usage: %s %s", name, hs[0]);
17701 print (vam->ofp, "No such msg / command '%s'", name);
17706 print (vam->ofp, "Help is available for the following:");
17709 hash_foreach_pair (p, vam->function_by_name,
17711 vec_add1 (cmds, (u8 *)(p->key));
17715 vec_sort_with_function (cmds, cmd_cmp);
17717 for (j = 0; j < vec_len (cmds); j++)
17718 print (vam->ofp, "%s", cmds[j]);
17725 set (vat_main_t * vam)
17727 u8 *name = 0, *value = 0;
17728 unformat_input_t *i = vam->input;
17730 if (unformat (i, "%s", &name))
17732 /* The input buffer is a vector, not a string. */
17733 value = vec_dup (i->buffer);
17734 vec_delete (value, i->index, 0);
17735 /* Almost certainly has a trailing newline */
17736 if (value[vec_len (value) - 1] == '\n')
17737 value[vec_len (value) - 1] = 0;
17738 /* Make sure it's a proper string, one way or the other */
17739 vec_add1 (value, 0);
17740 (void) clib_macro_set_value (&vam->macro_main,
17741 (char *) name, (char *) value);
17744 errmsg ("usage: set <name> <value>");
17752 unset (vat_main_t * vam)
17756 if (unformat (vam->input, "%s", &name))
17757 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
17758 errmsg ("unset: %s wasn't set", name);
17771 macro_sort_cmp (void *a1, void *a2)
17773 macro_sort_t *s1 = a1;
17774 macro_sort_t *s2 = a2;
17776 return strcmp ((char *) (s1->name), (char *) (s2->name));
17780 dump_macro_table (vat_main_t * vam)
17782 macro_sort_t *sort_me = 0, *sm;
17787 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
17789 vec_add2 (sort_me, sm, 1);
17790 sm->name = (u8 *)(p->key);
17791 sm->value = (u8 *) (p->value[0]);
17795 vec_sort_with_function (sort_me, macro_sort_cmp);
17797 if (vec_len (sort_me))
17798 print (vam->ofp, "%-15s%s", "Name", "Value");
17800 print (vam->ofp, "The macro table is empty...");
17802 for (i = 0; i < vec_len (sort_me); i++)
17803 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
17808 dump_node_table (vat_main_t * vam)
17811 vlib_node_t *node, *next_node;
17813 if (vec_len (vam->graph_nodes) == 0)
17815 print (vam->ofp, "Node table empty, issue get_node_graph...");
17819 for (i = 0; i < vec_len (vam->graph_nodes); i++)
17821 node = vam->graph_nodes[i];
17822 print (vam->ofp, "[%d] %s", i, node->name);
17823 for (j = 0; j < vec_len (node->next_nodes); j++)
17825 if (node->next_nodes[j] != ~0)
17827 next_node = vam->graph_nodes[node->next_nodes[j]];
17828 print (vam->ofp, " [%d] %s", j, next_node->name);
17836 value_sort_cmp (void *a1, void *a2)
17838 name_sort_t *n1 = a1;
17839 name_sort_t *n2 = a2;
17841 if (n1->value < n2->value)
17843 if (n1->value > n2->value)
17850 dump_msg_api_table (vat_main_t * vam)
17852 api_main_t *am = &api_main;
17853 name_sort_t *nses = 0, *ns;
17858 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
17860 vec_add2 (nses, ns, 1);
17861 ns->name = (u8 *)(hp->key);
17862 ns->value = (u32) hp->value[0];
17866 vec_sort_with_function (nses, value_sort_cmp);
17868 for (i = 0; i < vec_len (nses); i++)
17869 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
17875 get_msg_id (vat_main_t * vam)
17880 if (unformat (vam->input, "%s", &name_and_crc))
17882 message_index = vl_api_get_msg_index (name_and_crc);
17883 if (message_index == ~0)
17885 print (vam->ofp, " '%s' not found", name_and_crc);
17888 print (vam->ofp, " '%s' has message index %d",
17889 name_and_crc, message_index);
17892 errmsg ("name_and_crc required...");
17897 search_node_table (vat_main_t * vam)
17899 unformat_input_t *line_input = vam->input;
17902 vlib_node_t *node, *next_node;
17905 if (vam->graph_node_index_by_name == 0)
17907 print (vam->ofp, "Node table empty, issue get_node_graph...");
17911 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
17913 if (unformat (line_input, "%s", &node_to_find))
17915 vec_add1 (node_to_find, 0);
17916 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
17919 print (vam->ofp, "%s not found...", node_to_find);
17922 node = vam->graph_nodes[p[0]];
17923 print (vam->ofp, "[%d] %s", p[0], node->name);
17924 for (j = 0; j < vec_len (node->next_nodes); j++)
17926 if (node->next_nodes[j] != ~0)
17928 next_node = vam->graph_nodes[node->next_nodes[j]];
17929 print (vam->ofp, " [%d] %s", j, next_node->name);
17936 clib_warning ("parse error '%U'", format_unformat_error,
17942 vec_free (node_to_find);
17951 script (vat_main_t * vam)
17953 #if (VPP_API_TEST_BUILTIN==0)
17955 char *save_current_file;
17956 unformat_input_t save_input;
17957 jmp_buf save_jump_buf;
17958 u32 save_line_number;
17960 FILE *new_fp, *save_ifp;
17962 if (unformat (vam->input, "%s", &s))
17964 new_fp = fopen ((char *) s, "r");
17967 errmsg ("Couldn't open script file %s", s);
17974 errmsg ("Missing script name");
17978 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
17979 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
17980 save_ifp = vam->ifp;
17981 save_line_number = vam->input_line_number;
17982 save_current_file = (char *) vam->current_file;
17984 vam->input_line_number = 0;
17986 vam->current_file = s;
17989 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
17990 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
17991 vam->ifp = save_ifp;
17992 vam->input_line_number = save_line_number;
17993 vam->current_file = (u8 *) save_current_file;
17998 clib_warning ("use the exec command...");
18004 echo (vat_main_t * vam)
18006 print (vam->ofp, "%v", vam->input->buffer);
18010 /* List of API message constructors, CLI names map to api_xxx */
18011 #define foreach_vpe_api_msg \
18012 _(create_loopback,"[mac <mac-addr>]") \
18013 _(sw_interface_dump,"") \
18014 _(sw_interface_set_flags, \
18015 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
18016 _(sw_interface_add_del_address, \
18017 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
18018 _(sw_interface_set_table, \
18019 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
18020 _(sw_interface_set_mpls_enable, \
18021 "<intfc> | sw_if_index [disable | dis]") \
18022 _(sw_interface_set_vpath, \
18023 "<intfc> | sw_if_index <id> enable | disable") \
18024 _(sw_interface_set_vxlan_bypass, \
18025 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
18026 _(sw_interface_set_l2_xconnect, \
18027 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
18028 "enable | disable") \
18029 _(sw_interface_set_l2_bridge, \
18030 "<intfc> | sw_if_index <id> bd_id <bridge-domain-id>\n" \
18031 "[shg <split-horizon-group>] [bvi]\n" \
18032 "enable | disable") \
18033 _(bridge_domain_add_del, \
18034 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n") \
18035 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
18037 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
18039 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
18041 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
18043 "tapname <name> mac <mac-addr> | random-mac [tag <string>]") \
18045 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
18047 "<vpp-if-name> | sw_if_index <id>") \
18048 _(sw_interface_tap_dump, "") \
18049 _(ip_add_del_route, \
18050 "<addr>/<mask> via <addr> [table-id <n>]\n" \
18051 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
18052 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
18053 "[multipath] [count <n>]") \
18054 _(ip_mroute_add_del, \
18055 "<src> <grp>/<mask> [table-id <n>]\n" \
18056 "[<intfc> | sw_if_index <id>] [local] [del]") \
18057 _(mpls_route_add_del, \
18058 "<label> <eos> via <addr> [table-id <n>]\n" \
18059 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
18060 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
18061 "[multipath] [count <n>]") \
18062 _(mpls_ip_bind_unbind, \
18063 "<label> <addr/len>") \
18064 _(mpls_tunnel_add_del, \
18065 " via <addr> [table-id <n>]\n" \
18066 "sw_if_index <id>] [l2] [del]") \
18067 _(proxy_arp_add_del, \
18068 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
18069 _(proxy_arp_intfc_enable_disable, \
18070 "<intfc> | sw_if_index <id> enable | disable") \
18071 _(sw_interface_set_unnumbered, \
18072 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
18073 _(ip_neighbor_add_del, \
18074 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
18075 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
18076 _(reset_vrf, "vrf <id> [ipv6]") \
18077 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
18078 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
18079 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
18080 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
18081 "[outer_vlan_id_any][inner_vlan_id_any]") \
18082 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
18083 _(reset_fib, "vrf <n> [ipv6]") \
18084 _(dhcp_proxy_config, \
18085 "svr <v46-address> src <v46-address>\n" \
18086 "rx_vrf_id <nn> server_vrf_id <nn> [del]") \
18087 _(dhcp_proxy_set_vss, \
18088 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
18089 _(dhcp_proxy_dump, "ip6") \
18090 _(dhcp_client_config, \
18091 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
18092 _(set_ip_flow_hash, \
18093 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
18094 _(sw_interface_ip6_enable_disable, \
18095 "<intfc> | sw_if_index <id> enable | disable") \
18096 _(sw_interface_ip6_set_link_local_address, \
18097 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
18098 _(sw_interface_ip6nd_ra_prefix, \
18099 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
18100 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
18101 "[nolink] [isno]") \
18102 _(sw_interface_ip6nd_ra_config, \
18103 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
18104 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
18105 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
18106 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
18107 _(l2_patch_add_del, \
18108 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
18109 "enable | disable") \
18110 _(sr_tunnel_add_del, \
18111 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
18112 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
18113 "[policy <policy_name>]") \
18114 _(sr_policy_add_del, \
18115 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
18116 _(sr_multicast_map_add_del, \
18117 "address [ip6 multicast address] sr-policy [policy name] [del]") \
18118 _(classify_add_del_table, \
18119 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
18120 " [del] [del-chain] mask <mask-value>\n" \
18121 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
18122 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
18123 _(classify_add_del_session, \
18124 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
18125 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
18126 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
18127 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
18128 _(classify_set_interface_ip_table, \
18129 "<intfc> | sw_if_index <nn> table <nn>") \
18130 _(classify_set_interface_l2_tables, \
18131 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
18132 " [other-table <nn>]") \
18133 _(get_node_index, "node <node-name") \
18134 _(add_node_next, "node <node-name> next <next-node-name>") \
18135 _(l2tpv3_create_tunnel, \
18136 "client_address <ip6-addr> our_address <ip6-addr>\n" \
18137 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
18138 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
18139 _(l2tpv3_set_tunnel_cookies, \
18140 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
18141 "[new_remote_cookie <nn>]\n") \
18142 _(l2tpv3_interface_enable_disable, \
18143 "<intfc> | sw_if_index <nn> enable | disable") \
18144 _(l2tpv3_set_lookup_key, \
18145 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
18146 _(sw_if_l2tpv3_tunnel_dump, "") \
18147 _(vxlan_add_del_tunnel, \
18148 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
18149 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
18150 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
18151 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
18152 _(gre_add_del_tunnel, \
18153 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [teb] [del]\n") \
18154 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
18155 _(l2_fib_clear_table, "") \
18156 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
18157 _(l2_interface_vlan_tag_rewrite, \
18158 "<intfc> | sw_if_index <nn> \n" \
18159 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
18160 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
18161 _(create_vhost_user_if, \
18162 "socket <filename> [server] [renumber <dev_instance>] " \
18163 "[mac <mac_address>]") \
18164 _(modify_vhost_user_if, \
18165 "<intfc> | sw_if_index <nn> socket <filename>\n" \
18166 "[server] [renumber <dev_instance>]") \
18167 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
18168 _(sw_interface_vhost_user_dump, "") \
18169 _(show_version, "") \
18170 _(vxlan_gpe_add_del_tunnel, \
18171 "local <addr> remote <addr> vni <nn>\n" \
18172 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
18173 "[next-ethernet] [next-nsh]\n") \
18174 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
18175 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
18176 _(interface_name_renumber, \
18177 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
18178 _(input_acl_set_interface, \
18179 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
18180 " [l2-table <nn>] [del]") \
18181 _(want_ip4_arp_events, "address <ip4-address> [del]") \
18182 _(want_ip6_nd_events, "address <ip6-address> [del]") \
18183 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
18184 _(ip_dump, "ipv4 | ipv6") \
18185 _(ipsec_spd_add_del, "spd_id <n> [del]") \
18186 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
18188 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
18189 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
18190 " integ_alg <alg> integ_key <hex>") \
18191 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
18192 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
18193 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
18194 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
18195 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
18196 _(ikev2_profile_add_del, "name <profile_name> [del]") \
18197 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
18198 "(auth_data 0x<data> | auth_data <data>)") \
18199 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
18200 "(id_data 0x<data> | id_data <data>) (local|remote)") \
18201 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
18202 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
18203 "(local|remote)") \
18204 _(ikev2_set_local_key, "file <absolute_file_path>") \
18205 _(ikev2_set_responder, "<profile_name> interface <interface> address <addr>") \
18206 _(ikev2_set_ike_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
18207 _(ikev2_set_esp_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
18208 _(ikev2_set_sa_lifetime, "<profile_name> <seconds> <jitter> <handover> <max bytes>") \
18209 _(ikev2_initiate_sa_init, "<profile_name>") \
18210 _(ikev2_initiate_del_ike_sa, "<ispi>") \
18211 _(ikev2_initiate_del_child_sa, "<ispi>") \
18212 _(ikev2_initiate_rekey_child_sa, "<ispi>") \
18213 _(delete_loopback,"sw_if_index <nn>") \
18214 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
18215 _(map_add_domain, \
18216 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
18217 "ip6-src <ip6addr> " \
18218 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
18219 _(map_del_domain, "index <n>") \
18220 _(map_add_del_rule, \
18221 "index <n> psid <n> dst <ip6addr> [del]") \
18222 _(map_domain_dump, "") \
18223 _(map_rule_dump, "index <map-domain>") \
18224 _(want_interface_events, "enable|disable") \
18225 _(want_stats,"enable|disable") \
18226 _(get_first_msg_id, "client <name>") \
18227 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
18228 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
18229 "fib-id <nn> [ip4][ip6][default]") \
18230 _(get_node_graph, " ") \
18231 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
18232 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
18233 _(ioam_disable, "") \
18234 _(one_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
18235 " sw_if_index <sw_if_index> p <priority> " \
18236 "w <weight>] [del]") \
18237 _(one_add_del_locator, "locator-set <locator_name> " \
18238 "iface <intf> | sw_if_index <sw_if_index> " \
18239 "p <priority> w <weight> [del]") \
18240 _(one_add_del_local_eid,"vni <vni> eid " \
18241 "<ipv4|ipv6>/<prefix> | <L2 address> " \
18242 "locator-set <locator_name> [del]" \
18243 "[key-id sha1|sha256 secret-key <secret-key>]")\
18244 _(one_add_del_map_resolver, "<ip4|6-addr> [del]") \
18245 _(one_add_del_map_server, "<ip4|6-addr> [del]") \
18246 _(one_enable_disable, "enable|disable") \
18247 _(one_map_register_enable_disable, "enable|disable") \
18248 _(one_rloc_probe_enable_disable, "enable|disable") \
18249 _(one_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
18251 "rloc <locator> p <prio> " \
18252 "w <weight> [rloc <loc> ... ] " \
18253 "action <action> [del-all]") \
18254 _(one_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
18256 _(one_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
18257 _(one_map_request_mode, "src-dst|dst-only") \
18258 _(one_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
18259 _(one_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
18260 _(one_locator_set_dump, "[local | remote]") \
18261 _(one_locator_dump, "ls_index <index> | ls_name <name>") \
18262 _(one_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
18263 "[local] | [remote]") \
18264 _(one_eid_table_vni_dump, "") \
18265 _(one_eid_table_map_dump, "l2|l3") \
18266 _(one_map_resolver_dump, "") \
18267 _(one_map_server_dump, "") \
18268 _(one_adjacencies_get, "vni <vni>") \
18269 _(show_one_rloc_probe_state, "") \
18270 _(show_one_map_register_state, "") \
18271 _(show_one_status, "") \
18272 _(one_get_map_request_itr_rlocs, "") \
18273 _(show_one_pitr, "") \
18274 _(show_one_map_request_mode, "") \
18275 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
18276 " sw_if_index <sw_if_index> p <priority> " \
18277 "w <weight>] [del]") \
18278 _(lisp_add_del_locator, "locator-set <locator_name> " \
18279 "iface <intf> | sw_if_index <sw_if_index> " \
18280 "p <priority> w <weight> [del]") \
18281 _(lisp_add_del_local_eid,"vni <vni> eid " \
18282 "<ipv4|ipv6>/<prefix> | <L2 address> " \
18283 "locator-set <locator_name> [del]" \
18284 "[key-id sha1|sha256 secret-key <secret-key>]") \
18285 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
18286 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
18287 _(lisp_enable_disable, "enable|disable") \
18288 _(lisp_map_register_enable_disable, "enable|disable") \
18289 _(lisp_rloc_probe_enable_disable, "enable|disable") \
18290 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
18292 "rloc <locator> p <prio> " \
18293 "w <weight> [rloc <loc> ... ] " \
18294 "action <action> [del-all]") \
18295 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
18297 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
18298 _(lisp_map_request_mode, "src-dst|dst-only") \
18299 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
18300 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
18301 _(lisp_locator_set_dump, "[local | remote]") \
18302 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
18303 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
18304 "[local] | [remote]") \
18305 _(lisp_eid_table_vni_dump, "") \
18306 _(lisp_eid_table_map_dump, "l2|l3") \
18307 _(lisp_map_resolver_dump, "") \
18308 _(lisp_map_server_dump, "") \
18309 _(lisp_adjacencies_get, "vni <vni>") \
18310 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
18311 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
18312 _(gpe_set_encap_mode, "lisp|vxlan") \
18313 _(gpe_get_encap_mode, "") \
18314 _(lisp_gpe_add_del_iface, "up|down") \
18315 _(lisp_gpe_enable_disable, "enable|disable") \
18316 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
18317 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
18318 _(show_lisp_rloc_probe_state, "") \
18319 _(show_lisp_map_register_state, "") \
18320 _(show_lisp_status, "") \
18321 _(lisp_get_map_request_itr_rlocs, "") \
18322 _(show_lisp_pitr, "") \
18323 _(show_lisp_map_request_mode, "") \
18324 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
18325 _(af_packet_delete, "name <host interface name>") \
18326 _(policer_add_del, "name <policer name> <params> [del]") \
18327 _(policer_dump, "[name <policer name>]") \
18328 _(policer_classify_set_interface, \
18329 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
18330 " [l2-table <nn>] [del]") \
18331 _(policer_classify_dump, "type [ip4|ip6|l2]") \
18332 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
18333 "[master|slave]") \
18334 _(netmap_delete, "name <interface name>") \
18335 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
18336 _(mpls_fib_dump, "") \
18337 _(classify_table_ids, "") \
18338 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
18339 _(classify_table_info, "table_id <nn>") \
18340 _(classify_session_dump, "table_id <nn>") \
18341 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
18342 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
18343 "[template_interval <nn>] [udp_checksum]") \
18344 _(ipfix_exporter_dump, "") \
18345 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
18346 _(ipfix_classify_stream_dump, "") \
18347 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
18348 _(ipfix_classify_table_dump, "") \
18349 _(sw_interface_span_enable_disable, "[src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
18350 _(sw_interface_span_dump, "") \
18351 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
18352 _(pg_create_interface, "if_id <nn>") \
18353 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
18354 _(pg_enable_disable, "[stream <id>] disable") \
18355 _(ip_source_and_port_range_check_add_del, \
18356 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
18357 _(ip_source_and_port_range_check_interface_add_del, \
18358 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
18359 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
18360 _(ipsec_gre_add_del_tunnel, \
18361 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
18362 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
18363 _(delete_subif,"<intfc> | sw_if_index <nn>") \
18364 _(l2_interface_pbb_tag_rewrite, \
18365 "<intfc> | sw_if_index <nn> \n" \
18366 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
18367 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
18368 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
18369 _(flow_classify_set_interface, \
18370 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
18371 _(flow_classify_dump, "type [ip4|ip6]") \
18372 _(ip_fib_dump, "") \
18373 _(ip_mfib_dump, "") \
18374 _(ip6_fib_dump, "") \
18375 _(ip6_mfib_dump, "") \
18376 _(feature_enable_disable, "arc_name <arc_name> " \
18377 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
18378 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
18380 _(l2_xconnect_dump, "") \
18381 _(sw_interface_set_mtu, "<intfc> | sw_if_index <nn> mtu <nn>") \
18382 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
18383 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]")
18385 /* List of command functions, CLI names map directly to functions */
18386 #define foreach_cli_function \
18387 _(comment, "usage: comment <ignore-rest-of-line>") \
18388 _(dump_interface_table, "usage: dump_interface_table") \
18389 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
18390 _(dump_ipv4_table, "usage: dump_ipv4_table") \
18391 _(dump_ipv6_table, "usage: dump_ipv6_table") \
18392 _(dump_stats_table, "usage: dump_stats_table") \
18393 _(dump_macro_table, "usage: dump_macro_table ") \
18394 _(dump_node_table, "usage: dump_node_table") \
18395 _(dump_msg_api_table, "usage: dump_msg_api_table") \
18396 _(get_msg_id, "usage: get_msg_id name_and_crc") \
18397 _(echo, "usage: echo <message>") \
18398 _(exec, "usage: exec <vpe-debug-CLI-command>") \
18399 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
18400 _(help, "usage: help") \
18401 _(q, "usage: quit") \
18402 _(quit, "usage: quit") \
18403 _(search_node_table, "usage: search_node_table <name>...") \
18404 _(set, "usage: set <variable-name> <value>") \
18405 _(script, "usage: script <file-name>") \
18406 _(unset, "usage: unset <variable-name>")
18409 static void vl_api_##n##_t_handler_uni \
18410 (vl_api_##n##_t * mp) \
18412 vat_main_t * vam = &vat_main; \
18413 if (vam->json_output) { \
18414 vl_api_##n##_t_handler_json(mp); \
18416 vl_api_##n##_t_handler(mp); \
18419 foreach_vpe_api_reply_msg;
18423 vat_api_hookup (vat_main_t * vam)
18426 vl_msg_api_set_handlers(VL_API_##N, #n, \
18427 vl_api_##n##_t_handler_uni, \
18429 vl_api_##n##_t_endian, \
18430 vl_api_##n##_t_print, \
18431 sizeof(vl_api_##n##_t), 1);
18432 foreach_vpe_api_reply_msg;
18435 #if (VPP_API_TEST_BUILTIN==0)
18436 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
18439 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
18441 vam->function_by_name = hash_create_string (0, sizeof (uword));
18443 vam->help_by_name = hash_create_string (0, sizeof (uword));
18445 /* API messages we can send */
18446 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
18447 foreach_vpe_api_msg;
18451 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
18452 foreach_vpe_api_msg;
18455 /* CLI functions */
18456 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
18457 foreach_cli_function;
18461 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
18462 foreach_cli_function;
18467 * fd.io coding-style-patch-verification: ON
18470 * eval: (c-set-style "gnu")