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);
116 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
118 vat_main_t *vam = va_arg (*args, vat_main_t *);
119 u32 *result = va_arg (*args, u32 *);
123 if (!unformat (input, "%s", &if_name))
126 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
133 #if VPP_API_TEST_BUILTIN == 0
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 #endif /* VPP_API_TEST_BUILTIN */
393 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
395 u8 *r = va_arg (*args, u8 *);
397 if (unformat (input, "kbps"))
398 *r = SSE2_QOS_RATE_KBPS;
399 else if (unformat (input, "pps"))
400 *r = SSE2_QOS_RATE_PPS;
407 unformat_policer_round_type (unformat_input_t * input, va_list * args)
409 u8 *r = va_arg (*args, u8 *);
411 if (unformat (input, "closest"))
412 *r = SSE2_QOS_ROUND_TO_CLOSEST;
413 else if (unformat (input, "up"))
414 *r = SSE2_QOS_ROUND_TO_UP;
415 else if (unformat (input, "down"))
416 *r = SSE2_QOS_ROUND_TO_DOWN;
423 unformat_policer_type (unformat_input_t * input, va_list * args)
425 u8 *r = va_arg (*args, u8 *);
427 if (unformat (input, "1r2c"))
428 *r = SSE2_QOS_POLICER_TYPE_1R2C;
429 else if (unformat (input, "1r3c"))
430 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
431 else if (unformat (input, "2r3c-2698"))
432 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
433 else if (unformat (input, "2r3c-4115"))
434 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
435 else if (unformat (input, "2r3c-mef5cf1"))
436 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
443 unformat_dscp (unformat_input_t * input, va_list * va)
445 u8 *r = va_arg (*va, u8 *);
448 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
457 unformat_policer_action_type (unformat_input_t * input, va_list * va)
459 sse2_qos_pol_action_params_st *a
460 = va_arg (*va, sse2_qos_pol_action_params_st *);
462 if (unformat (input, "drop"))
463 a->action_type = SSE2_QOS_ACTION_DROP;
464 else if (unformat (input, "transmit"))
465 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
466 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
467 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
474 unformat_policer_classify_table_type (unformat_input_t * input, va_list * va)
476 u32 *r = va_arg (*va, u32 *);
479 if (unformat (input, "ip4"))
480 tid = POLICER_CLASSIFY_TABLE_IP4;
481 else if (unformat (input, "ip6"))
482 tid = POLICER_CLASSIFY_TABLE_IP6;
483 else if (unformat (input, "l2"))
484 tid = POLICER_CLASSIFY_TABLE_L2;
493 unformat_flow_classify_table_type (unformat_input_t * input, va_list * va)
495 u32 *r = va_arg (*va, u32 *);
498 if (unformat (input, "ip4"))
499 tid = FLOW_CLASSIFY_TABLE_IP4;
500 else if (unformat (input, "ip6"))
501 tid = FLOW_CLASSIFY_TABLE_IP6;
509 static const char *mfib_flag_names[] = MFIB_ENTRY_NAMES_SHORT;
510 static const char *mfib_flag_long_names[] = MFIB_ENTRY_NAMES_LONG;
511 static const char *mfib_itf_flag_long_names[] = MFIB_ITF_NAMES_LONG;
512 static const char *mfib_itf_flag_names[] = MFIB_ITF_NAMES_SHORT;
515 unformat_mfib_itf_flags (unformat_input_t * input, va_list * args)
517 mfib_itf_flags_t old, *iflags = va_arg (*args, mfib_itf_flags_t *);
518 mfib_itf_attribute_t attr;
521 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
523 if (unformat (input, mfib_itf_flag_long_names[attr]))
524 *iflags |= (1 << attr);
526 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
528 if (unformat (input, mfib_itf_flag_names[attr]))
529 *iflags |= (1 << attr);
532 return (old == *iflags ? 0 : 1);
536 unformat_mfib_entry_flags (unformat_input_t * input, va_list * args)
538 mfib_entry_flags_t old, *eflags = va_arg (*args, mfib_entry_flags_t *);
539 mfib_entry_attribute_t attr;
542 FOR_EACH_MFIB_ATTRIBUTE (attr)
544 if (unformat (input, mfib_flag_long_names[attr]))
545 *eflags |= (1 << attr);
547 FOR_EACH_MFIB_ATTRIBUTE (attr)
549 if (unformat (input, mfib_flag_names[attr]))
550 *eflags |= (1 << attr);
553 return (old == *eflags ? 0 : 1);
556 #if (VPP_API_TEST_BUILTIN==0)
558 format_ip4_address (u8 * s, va_list * args)
560 u8 *a = va_arg (*args, u8 *);
561 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
565 format_ip6_address (u8 * s, va_list * args)
567 ip6_address_t *a = va_arg (*args, ip6_address_t *);
568 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
570 i_max_n_zero = ARRAY_LEN (a->as_u16);
572 i_first_zero = i_max_n_zero;
574 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
576 u32 is_zero = a->as_u16[i] == 0;
577 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
583 if ((!is_zero && n_zeros > max_n_zeros)
584 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
586 i_max_n_zero = i_first_zero;
587 max_n_zeros = n_zeros;
588 i_first_zero = ARRAY_LEN (a->as_u16);
593 last_double_colon = 0;
594 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
596 if (i == i_max_n_zero && max_n_zeros > 1)
598 s = format (s, "::");
599 i += max_n_zeros - 1;
600 last_double_colon = 1;
604 s = format (s, "%s%x",
605 (last_double_colon || i == 0) ? "" : ":",
606 clib_net_to_host_u16 (a->as_u16[i]));
607 last_double_colon = 0;
614 /* Format an IP46 address. */
616 format_ip46_address (u8 * s, va_list * args)
618 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
619 ip46_type_t type = va_arg (*args, ip46_type_t);
625 is_ip4 = ip46_address_is_ip4 (ip46);
636 format (s, "%U", format_ip4_address, &ip46->ip4) :
637 format (s, "%U", format_ip6_address, &ip46->ip6);
641 format_ethernet_address (u8 * s, va_list * args)
643 u8 *a = va_arg (*args, u8 *);
645 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
646 a[0], a[1], a[2], a[3], a[4], a[5]);
651 increment_v4_address (ip4_address_t * a)
655 v = ntohl (a->as_u32) + 1;
656 a->as_u32 = ntohl (v);
660 increment_v6_address (ip6_address_t * a)
664 v0 = clib_net_to_host_u64 (a->as_u64[0]);
665 v1 = clib_net_to_host_u64 (a->as_u64[1]);
670 a->as_u64[0] = clib_net_to_host_u64 (v0);
671 a->as_u64[1] = clib_net_to_host_u64 (v1);
675 increment_mac_address (u64 * mac)
679 tmp = clib_net_to_host_u64 (tmp);
680 tmp += 1 << 16; /* skip unused (least significant) octets */
681 tmp = clib_host_to_net_u64 (tmp);
685 static void vl_api_create_loopback_reply_t_handler
686 (vl_api_create_loopback_reply_t * mp)
688 vat_main_t *vam = &vat_main;
689 i32 retval = ntohl (mp->retval);
691 vam->retval = retval;
692 vam->regenerate_interface_table = 1;
693 vam->sw_if_index = ntohl (mp->sw_if_index);
694 vam->result_ready = 1;
697 static void vl_api_create_loopback_reply_t_handler_json
698 (vl_api_create_loopback_reply_t * mp)
700 vat_main_t *vam = &vat_main;
701 vat_json_node_t node;
703 vat_json_init_object (&node);
704 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
705 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
707 vat_json_print (vam->ofp, &node);
708 vat_json_free (&node);
709 vam->retval = ntohl (mp->retval);
710 vam->result_ready = 1;
713 static void vl_api_af_packet_create_reply_t_handler
714 (vl_api_af_packet_create_reply_t * mp)
716 vat_main_t *vam = &vat_main;
717 i32 retval = ntohl (mp->retval);
719 vam->retval = retval;
720 vam->regenerate_interface_table = 1;
721 vam->sw_if_index = ntohl (mp->sw_if_index);
722 vam->result_ready = 1;
725 static void vl_api_af_packet_create_reply_t_handler_json
726 (vl_api_af_packet_create_reply_t * mp)
728 vat_main_t *vam = &vat_main;
729 vat_json_node_t node;
731 vat_json_init_object (&node);
732 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
733 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
735 vat_json_print (vam->ofp, &node);
736 vat_json_free (&node);
738 vam->retval = ntohl (mp->retval);
739 vam->result_ready = 1;
742 static void vl_api_create_vlan_subif_reply_t_handler
743 (vl_api_create_vlan_subif_reply_t * mp)
745 vat_main_t *vam = &vat_main;
746 i32 retval = ntohl (mp->retval);
748 vam->retval = retval;
749 vam->regenerate_interface_table = 1;
750 vam->sw_if_index = ntohl (mp->sw_if_index);
751 vam->result_ready = 1;
754 static void vl_api_create_vlan_subif_reply_t_handler_json
755 (vl_api_create_vlan_subif_reply_t * mp)
757 vat_main_t *vam = &vat_main;
758 vat_json_node_t node;
760 vat_json_init_object (&node);
761 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
762 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
764 vat_json_print (vam->ofp, &node);
765 vat_json_free (&node);
767 vam->retval = ntohl (mp->retval);
768 vam->result_ready = 1;
771 static void vl_api_create_subif_reply_t_handler
772 (vl_api_create_subif_reply_t * mp)
774 vat_main_t *vam = &vat_main;
775 i32 retval = ntohl (mp->retval);
777 vam->retval = retval;
778 vam->regenerate_interface_table = 1;
779 vam->sw_if_index = ntohl (mp->sw_if_index);
780 vam->result_ready = 1;
783 static void vl_api_create_subif_reply_t_handler_json
784 (vl_api_create_subif_reply_t * mp)
786 vat_main_t *vam = &vat_main;
787 vat_json_node_t node;
789 vat_json_init_object (&node);
790 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
791 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
793 vat_json_print (vam->ofp, &node);
794 vat_json_free (&node);
796 vam->retval = ntohl (mp->retval);
797 vam->result_ready = 1;
800 static void vl_api_interface_name_renumber_reply_t_handler
801 (vl_api_interface_name_renumber_reply_t * mp)
803 vat_main_t *vam = &vat_main;
804 i32 retval = ntohl (mp->retval);
806 vam->retval = retval;
807 vam->regenerate_interface_table = 1;
808 vam->result_ready = 1;
811 static void vl_api_interface_name_renumber_reply_t_handler_json
812 (vl_api_interface_name_renumber_reply_t * mp)
814 vat_main_t *vam = &vat_main;
815 vat_json_node_t node;
817 vat_json_init_object (&node);
818 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
820 vat_json_print (vam->ofp, &node);
821 vat_json_free (&node);
823 vam->retval = ntohl (mp->retval);
824 vam->result_ready = 1;
828 * Special-case: build the interface table, maintain
829 * the next loopback sw_if_index vbl.
831 static void vl_api_sw_interface_details_t_handler
832 (vl_api_sw_interface_details_t * mp)
834 vat_main_t *vam = &vat_main;
835 u8 *s = format (0, "%s%c", mp->interface_name, 0);
837 hash_set_mem (vam->sw_if_index_by_interface_name, s,
838 ntohl (mp->sw_if_index));
840 /* In sub interface case, fill the sub interface table entry */
841 if (mp->sw_if_index != mp->sup_sw_if_index)
843 sw_interface_subif_t *sub = NULL;
845 vec_add2 (vam->sw_if_subif_table, sub, 1);
847 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
848 strncpy ((char *) sub->interface_name, (char *) s,
849 vec_len (sub->interface_name));
850 sub->sw_if_index = ntohl (mp->sw_if_index);
851 sub->sub_id = ntohl (mp->sub_id);
853 sub->sub_dot1ad = mp->sub_dot1ad;
854 sub->sub_number_of_tags = mp->sub_number_of_tags;
855 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
856 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
857 sub->sub_exact_match = mp->sub_exact_match;
858 sub->sub_default = mp->sub_default;
859 sub->sub_outer_vlan_id_any = mp->sub_outer_vlan_id_any;
860 sub->sub_inner_vlan_id_any = mp->sub_inner_vlan_id_any;
862 /* vlan tag rewrite */
863 sub->vtr_op = ntohl (mp->vtr_op);
864 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
865 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
866 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
870 static void vl_api_sw_interface_details_t_handler_json
871 (vl_api_sw_interface_details_t * mp)
873 vat_main_t *vam = &vat_main;
874 vat_json_node_t *node = NULL;
876 if (VAT_JSON_ARRAY != vam->json_tree.type)
878 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
879 vat_json_init_array (&vam->json_tree);
881 node = vat_json_array_add (&vam->json_tree);
883 vat_json_init_object (node);
884 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
885 vat_json_object_add_uint (node, "sup_sw_if_index",
886 ntohl (mp->sup_sw_if_index));
887 vat_json_object_add_uint (node, "l2_address_length",
888 ntohl (mp->l2_address_length));
889 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
890 sizeof (mp->l2_address));
891 vat_json_object_add_string_copy (node, "interface_name",
893 vat_json_object_add_uint (node, "admin_up_down", mp->admin_up_down);
894 vat_json_object_add_uint (node, "link_up_down", mp->link_up_down);
895 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
896 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
897 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
898 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
899 vat_json_object_add_uint (node, "sub_dot1ad", mp->sub_dot1ad);
900 vat_json_object_add_uint (node, "sub_number_of_tags",
901 mp->sub_number_of_tags);
902 vat_json_object_add_uint (node, "sub_outer_vlan_id",
903 ntohs (mp->sub_outer_vlan_id));
904 vat_json_object_add_uint (node, "sub_inner_vlan_id",
905 ntohs (mp->sub_inner_vlan_id));
906 vat_json_object_add_uint (node, "sub_exact_match", mp->sub_exact_match);
907 vat_json_object_add_uint (node, "sub_default", mp->sub_default);
908 vat_json_object_add_uint (node, "sub_outer_vlan_id_any",
909 mp->sub_outer_vlan_id_any);
910 vat_json_object_add_uint (node, "sub_inner_vlan_id_any",
911 mp->sub_inner_vlan_id_any);
912 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
913 vat_json_object_add_uint (node, "vtr_push_dot1q",
914 ntohl (mp->vtr_push_dot1q));
915 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
916 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
919 static void vl_api_sw_interface_set_flags_t_handler
920 (vl_api_sw_interface_set_flags_t * mp)
922 vat_main_t *vam = &vat_main;
923 if (vam->interface_event_display)
924 errmsg ("interface flags: sw_if_index %d %s %s",
925 ntohl (mp->sw_if_index),
926 mp->admin_up_down ? "admin-up" : "admin-down",
927 mp->link_up_down ? "link-up" : "link-down");
930 static void vl_api_sw_interface_set_flags_t_handler_json
931 (vl_api_sw_interface_set_flags_t * mp)
933 /* JSON output not supported */
937 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
939 vat_main_t *vam = &vat_main;
940 i32 retval = ntohl (mp->retval);
942 vam->retval = retval;
943 vam->shmem_result = (u8 *) mp->reply_in_shmem;
944 vam->result_ready = 1;
948 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
950 vat_main_t *vam = &vat_main;
951 vat_json_node_t node;
952 api_main_t *am = &api_main;
956 vat_json_init_object (&node);
957 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
958 vat_json_object_add_uint (&node, "reply_in_shmem",
959 ntohl (mp->reply_in_shmem));
960 /* Toss the shared-memory original... */
961 pthread_mutex_lock (&am->vlib_rp->mutex);
962 oldheap = svm_push_data_heap (am->vlib_rp);
964 reply = (u8 *) (mp->reply_in_shmem);
967 svm_pop_heap (oldheap);
968 pthread_mutex_unlock (&am->vlib_rp->mutex);
970 vat_json_print (vam->ofp, &node);
971 vat_json_free (&node);
973 vam->retval = ntohl (mp->retval);
974 vam->result_ready = 1;
978 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
980 vat_main_t *vam = &vat_main;
981 i32 retval = ntohl (mp->retval);
983 vam->retval = retval;
984 vam->cmd_reply = mp->reply;
985 vam->result_ready = 1;
989 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
991 vat_main_t *vam = &vat_main;
992 vat_json_node_t node;
994 vat_json_init_object (&node);
995 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
996 vat_json_object_add_string_copy (&node, "reply", mp->reply);
998 vat_json_print (vam->ofp, &node);
999 vat_json_free (&node);
1001 vam->retval = ntohl (mp->retval);
1002 vam->result_ready = 1;
1005 static void vl_api_classify_add_del_table_reply_t_handler
1006 (vl_api_classify_add_del_table_reply_t * mp)
1008 vat_main_t *vam = &vat_main;
1009 i32 retval = ntohl (mp->retval);
1010 if (vam->async_mode)
1012 vam->async_errors += (retval < 0);
1016 vam->retval = retval;
1018 ((mp->new_table_index != 0xFFFFFFFF) ||
1019 (mp->skip_n_vectors != 0xFFFFFFFF) ||
1020 (mp->match_n_vectors != 0xFFFFFFFF)))
1022 * Note: this is just barely thread-safe, depends on
1023 * the main thread spinning waiting for an answer...
1025 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d",
1026 ntohl (mp->new_table_index),
1027 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
1028 vam->result_ready = 1;
1032 static void vl_api_classify_add_del_table_reply_t_handler_json
1033 (vl_api_classify_add_del_table_reply_t * mp)
1035 vat_main_t *vam = &vat_main;
1036 vat_json_node_t node;
1038 vat_json_init_object (&node);
1039 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1040 vat_json_object_add_uint (&node, "new_table_index",
1041 ntohl (mp->new_table_index));
1042 vat_json_object_add_uint (&node, "skip_n_vectors",
1043 ntohl (mp->skip_n_vectors));
1044 vat_json_object_add_uint (&node, "match_n_vectors",
1045 ntohl (mp->match_n_vectors));
1047 vat_json_print (vam->ofp, &node);
1048 vat_json_free (&node);
1050 vam->retval = ntohl (mp->retval);
1051 vam->result_ready = 1;
1054 static void vl_api_get_node_index_reply_t_handler
1055 (vl_api_get_node_index_reply_t * mp)
1057 vat_main_t *vam = &vat_main;
1058 i32 retval = ntohl (mp->retval);
1059 if (vam->async_mode)
1061 vam->async_errors += (retval < 0);
1065 vam->retval = retval;
1067 errmsg ("node index %d", ntohl (mp->node_index));
1068 vam->result_ready = 1;
1072 static void vl_api_get_node_index_reply_t_handler_json
1073 (vl_api_get_node_index_reply_t * mp)
1075 vat_main_t *vam = &vat_main;
1076 vat_json_node_t node;
1078 vat_json_init_object (&node);
1079 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1080 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1082 vat_json_print (vam->ofp, &node);
1083 vat_json_free (&node);
1085 vam->retval = ntohl (mp->retval);
1086 vam->result_ready = 1;
1089 static void vl_api_get_next_index_reply_t_handler
1090 (vl_api_get_next_index_reply_t * mp)
1092 vat_main_t *vam = &vat_main;
1093 i32 retval = ntohl (mp->retval);
1094 if (vam->async_mode)
1096 vam->async_errors += (retval < 0);
1100 vam->retval = retval;
1102 errmsg ("next node index %d", ntohl (mp->next_index));
1103 vam->result_ready = 1;
1107 static void vl_api_get_next_index_reply_t_handler_json
1108 (vl_api_get_next_index_reply_t * mp)
1110 vat_main_t *vam = &vat_main;
1111 vat_json_node_t node;
1113 vat_json_init_object (&node);
1114 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1115 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1117 vat_json_print (vam->ofp, &node);
1118 vat_json_free (&node);
1120 vam->retval = ntohl (mp->retval);
1121 vam->result_ready = 1;
1124 static void vl_api_add_node_next_reply_t_handler
1125 (vl_api_add_node_next_reply_t * mp)
1127 vat_main_t *vam = &vat_main;
1128 i32 retval = ntohl (mp->retval);
1129 if (vam->async_mode)
1131 vam->async_errors += (retval < 0);
1135 vam->retval = retval;
1137 errmsg ("next index %d", ntohl (mp->next_index));
1138 vam->result_ready = 1;
1142 static void vl_api_add_node_next_reply_t_handler_json
1143 (vl_api_add_node_next_reply_t * mp)
1145 vat_main_t *vam = &vat_main;
1146 vat_json_node_t node;
1148 vat_json_init_object (&node);
1149 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1150 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1152 vat_json_print (vam->ofp, &node);
1153 vat_json_free (&node);
1155 vam->retval = ntohl (mp->retval);
1156 vam->result_ready = 1;
1159 static void vl_api_show_version_reply_t_handler
1160 (vl_api_show_version_reply_t * mp)
1162 vat_main_t *vam = &vat_main;
1163 i32 retval = ntohl (mp->retval);
1167 errmsg (" program: %s", mp->program);
1168 errmsg (" version: %s", mp->version);
1169 errmsg (" build date: %s", mp->build_date);
1170 errmsg ("build directory: %s", mp->build_directory);
1172 vam->retval = retval;
1173 vam->result_ready = 1;
1176 static void vl_api_show_version_reply_t_handler_json
1177 (vl_api_show_version_reply_t * mp)
1179 vat_main_t *vam = &vat_main;
1180 vat_json_node_t node;
1182 vat_json_init_object (&node);
1183 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1184 vat_json_object_add_string_copy (&node, "program", mp->program);
1185 vat_json_object_add_string_copy (&node, "version", mp->version);
1186 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1187 vat_json_object_add_string_copy (&node, "build_directory",
1188 mp->build_directory);
1190 vat_json_print (vam->ofp, &node);
1191 vat_json_free (&node);
1193 vam->retval = ntohl (mp->retval);
1194 vam->result_ready = 1;
1198 vl_api_ip4_arp_event_t_handler (vl_api_ip4_arp_event_t * mp)
1200 errmsg ("arp %s event: address %U new mac %U sw_if_index %d",
1201 mp->mac_ip ? "mac/ip binding" : "address resolution",
1202 format_ip4_address, &mp->address,
1203 format_ethernet_address, mp->new_mac, mp->sw_if_index);
1207 vl_api_ip4_arp_event_t_handler_json (vl_api_ip4_arp_event_t * mp)
1209 /* JSON output not supported */
1213 vl_api_ip6_nd_event_t_handler (vl_api_ip6_nd_event_t * mp)
1215 errmsg ("ip6 nd %s event: address %U new mac %U sw_if_index %d",
1216 mp->mac_ip ? "mac/ip binding" : "address resolution",
1217 format_ip6_address, mp->address,
1218 format_ethernet_address, mp->new_mac, mp->sw_if_index);
1222 vl_api_ip6_nd_event_t_handler_json (vl_api_ip6_nd_event_t * mp)
1224 /* JSON output not supported */
1228 * Special-case: build the bridge domain table, maintain
1229 * the next bd id vbl.
1231 static void vl_api_bridge_domain_details_t_handler
1232 (vl_api_bridge_domain_details_t * mp)
1234 vat_main_t *vam = &vat_main;
1235 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1237 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-3s",
1238 " ID", "LRN", "FWD", "FLD", "BVI", "#IF");
1240 print (vam->ofp, "%3d %3d %3d %3d %3d %3d",
1241 ntohl (mp->bd_id), mp->learn, mp->forward,
1242 mp->flood, ntohl (mp->bvi_sw_if_index), n_sw_ifs);
1245 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG", "Interface Name");
1248 static void vl_api_bridge_domain_details_t_handler_json
1249 (vl_api_bridge_domain_details_t * mp)
1251 vat_main_t *vam = &vat_main;
1252 vat_json_node_t *node, *array = NULL;
1254 if (VAT_JSON_ARRAY != vam->json_tree.type)
1256 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1257 vat_json_init_array (&vam->json_tree);
1259 node = vat_json_array_add (&vam->json_tree);
1261 vat_json_init_object (node);
1262 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1263 vat_json_object_add_uint (node, "flood", mp->flood);
1264 vat_json_object_add_uint (node, "forward", mp->forward);
1265 vat_json_object_add_uint (node, "learn", mp->learn);
1266 vat_json_object_add_uint (node, "bvi_sw_if_index",
1267 ntohl (mp->bvi_sw_if_index));
1268 vat_json_object_add_uint (node, "n_sw_ifs", ntohl (mp->n_sw_ifs));
1269 array = vat_json_object_add (node, "sw_if");
1270 vat_json_init_array (array);
1274 * Special-case: build the bridge domain sw if table.
1276 static void vl_api_bridge_domain_sw_if_details_t_handler
1277 (vl_api_bridge_domain_sw_if_details_t * mp)
1279 vat_main_t *vam = &vat_main;
1284 sw_if_index = ntohl (mp->sw_if_index);
1286 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1288 if ((u32) p->value[0] == sw_if_index)
1290 sw_if_name = (u8 *)(p->key);
1296 print (vam->ofp, "%7d %3d %s", sw_if_index,
1297 mp->shg, sw_if_name ? (char *) sw_if_name :
1298 "sw_if_index not found!");
1301 static void vl_api_bridge_domain_sw_if_details_t_handler_json
1302 (vl_api_bridge_domain_sw_if_details_t * mp)
1304 vat_main_t *vam = &vat_main;
1305 vat_json_node_t *node = NULL;
1306 uword last_index = 0;
1308 ASSERT (VAT_JSON_ARRAY == vam->json_tree.type);
1309 ASSERT (vec_len (vam->json_tree.array) >= 1);
1310 last_index = vec_len (vam->json_tree.array) - 1;
1311 node = &vam->json_tree.array[last_index];
1312 node = vat_json_object_get_element (node, "sw_if");
1313 ASSERT (NULL != node);
1314 node = vat_json_array_add (node);
1316 vat_json_init_object (node);
1317 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1318 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
1319 vat_json_object_add_uint (node, "shg", mp->shg);
1322 static void vl_api_control_ping_reply_t_handler
1323 (vl_api_control_ping_reply_t * mp)
1325 vat_main_t *vam = &vat_main;
1326 i32 retval = ntohl (mp->retval);
1327 if (vam->async_mode)
1329 vam->async_errors += (retval < 0);
1333 vam->retval = retval;
1334 vam->result_ready = 1;
1338 static void vl_api_control_ping_reply_t_handler_json
1339 (vl_api_control_ping_reply_t * mp)
1341 vat_main_t *vam = &vat_main;
1342 i32 retval = ntohl (mp->retval);
1344 if (VAT_JSON_NONE != vam->json_tree.type)
1346 vat_json_print (vam->ofp, &vam->json_tree);
1347 vat_json_free (&vam->json_tree);
1348 vam->json_tree.type = VAT_JSON_NONE;
1353 vat_json_init_array (&vam->json_tree);
1354 vat_json_print (vam->ofp, &vam->json_tree);
1355 vam->json_tree.type = VAT_JSON_NONE;
1358 vam->retval = retval;
1359 vam->result_ready = 1;
1363 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1365 vat_main_t *vam = &vat_main;
1366 i32 retval = ntohl (mp->retval);
1367 if (vam->async_mode)
1369 vam->async_errors += (retval < 0);
1373 vam->retval = retval;
1374 vam->result_ready = 1;
1378 static void vl_api_l2_flags_reply_t_handler_json
1379 (vl_api_l2_flags_reply_t * mp)
1381 vat_main_t *vam = &vat_main;
1382 vat_json_node_t node;
1384 vat_json_init_object (&node);
1385 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1386 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1387 ntohl (mp->resulting_feature_bitmap));
1389 vat_json_print (vam->ofp, &node);
1390 vat_json_free (&node);
1392 vam->retval = ntohl (mp->retval);
1393 vam->result_ready = 1;
1396 static void vl_api_bridge_flags_reply_t_handler
1397 (vl_api_bridge_flags_reply_t * mp)
1399 vat_main_t *vam = &vat_main;
1400 i32 retval = ntohl (mp->retval);
1401 if (vam->async_mode)
1403 vam->async_errors += (retval < 0);
1407 vam->retval = retval;
1408 vam->result_ready = 1;
1412 static void vl_api_bridge_flags_reply_t_handler_json
1413 (vl_api_bridge_flags_reply_t * mp)
1415 vat_main_t *vam = &vat_main;
1416 vat_json_node_t node;
1418 vat_json_init_object (&node);
1419 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1420 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1421 ntohl (mp->resulting_feature_bitmap));
1423 vat_json_print (vam->ofp, &node);
1424 vat_json_free (&node);
1426 vam->retval = ntohl (mp->retval);
1427 vam->result_ready = 1;
1430 static void vl_api_tap_connect_reply_t_handler
1431 (vl_api_tap_connect_reply_t * mp)
1433 vat_main_t *vam = &vat_main;
1434 i32 retval = ntohl (mp->retval);
1435 if (vam->async_mode)
1437 vam->async_errors += (retval < 0);
1441 vam->retval = retval;
1442 vam->sw_if_index = ntohl (mp->sw_if_index);
1443 vam->result_ready = 1;
1448 static void vl_api_tap_connect_reply_t_handler_json
1449 (vl_api_tap_connect_reply_t * mp)
1451 vat_main_t *vam = &vat_main;
1452 vat_json_node_t node;
1454 vat_json_init_object (&node);
1455 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1456 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1458 vat_json_print (vam->ofp, &node);
1459 vat_json_free (&node);
1461 vam->retval = ntohl (mp->retval);
1462 vam->result_ready = 1;
1467 vl_api_tap_modify_reply_t_handler (vl_api_tap_modify_reply_t * mp)
1469 vat_main_t *vam = &vat_main;
1470 i32 retval = ntohl (mp->retval);
1471 if (vam->async_mode)
1473 vam->async_errors += (retval < 0);
1477 vam->retval = retval;
1478 vam->sw_if_index = ntohl (mp->sw_if_index);
1479 vam->result_ready = 1;
1483 static void vl_api_tap_modify_reply_t_handler_json
1484 (vl_api_tap_modify_reply_t * mp)
1486 vat_main_t *vam = &vat_main;
1487 vat_json_node_t node;
1489 vat_json_init_object (&node);
1490 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1491 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1493 vat_json_print (vam->ofp, &node);
1494 vat_json_free (&node);
1496 vam->retval = ntohl (mp->retval);
1497 vam->result_ready = 1;
1501 vl_api_tap_delete_reply_t_handler (vl_api_tap_delete_reply_t * mp)
1503 vat_main_t *vam = &vat_main;
1504 i32 retval = ntohl (mp->retval);
1505 if (vam->async_mode)
1507 vam->async_errors += (retval < 0);
1511 vam->retval = retval;
1512 vam->result_ready = 1;
1516 static void vl_api_tap_delete_reply_t_handler_json
1517 (vl_api_tap_delete_reply_t * mp)
1519 vat_main_t *vam = &vat_main;
1520 vat_json_node_t node;
1522 vat_json_init_object (&node);
1523 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1525 vat_json_print (vam->ofp, &node);
1526 vat_json_free (&node);
1528 vam->retval = ntohl (mp->retval);
1529 vam->result_ready = 1;
1532 static void vl_api_mpls_tunnel_add_del_reply_t_handler
1533 (vl_api_mpls_tunnel_add_del_reply_t * mp)
1535 vat_main_t *vam = &vat_main;
1536 i32 retval = ntohl (mp->retval);
1537 if (vam->async_mode)
1539 vam->async_errors += (retval < 0);
1543 vam->retval = retval;
1544 vam->result_ready = 1;
1548 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
1549 (vl_api_mpls_tunnel_add_del_reply_t * mp)
1551 vat_main_t *vam = &vat_main;
1552 vat_json_node_t node;
1554 vat_json_init_object (&node);
1555 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1556 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
1557 ntohl (mp->sw_if_index));
1559 vat_json_print (vam->ofp, &node);
1560 vat_json_free (&node);
1562 vam->retval = ntohl (mp->retval);
1563 vam->result_ready = 1;
1566 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
1567 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1569 vat_main_t *vam = &vat_main;
1570 i32 retval = ntohl (mp->retval);
1571 if (vam->async_mode)
1573 vam->async_errors += (retval < 0);
1577 vam->retval = retval;
1578 vam->sw_if_index = ntohl (mp->sw_if_index);
1579 vam->result_ready = 1;
1583 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
1584 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1586 vat_main_t *vam = &vat_main;
1587 vat_json_node_t node;
1589 vat_json_init_object (&node);
1590 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1591 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1593 vat_json_print (vam->ofp, &node);
1594 vat_json_free (&node);
1596 vam->retval = ntohl (mp->retval);
1597 vam->result_ready = 1;
1601 static void vl_api_lisp_add_del_locator_set_reply_t_handler
1602 (vl_api_lisp_add_del_locator_set_reply_t * mp)
1604 vat_main_t *vam = &vat_main;
1605 i32 retval = ntohl (mp->retval);
1606 if (vam->async_mode)
1608 vam->async_errors += (retval < 0);
1612 vam->retval = retval;
1613 vam->result_ready = 1;
1617 static void vl_api_lisp_add_del_locator_set_reply_t_handler_json
1618 (vl_api_lisp_add_del_locator_set_reply_t * mp)
1620 vat_main_t *vam = &vat_main;
1621 vat_json_node_t node;
1623 vat_json_init_object (&node);
1624 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1625 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
1627 vat_json_print (vam->ofp, &node);
1628 vat_json_free (&node);
1630 vam->retval = ntohl (mp->retval);
1631 vam->result_ready = 1;
1634 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
1635 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1637 vat_main_t *vam = &vat_main;
1638 i32 retval = ntohl (mp->retval);
1639 if (vam->async_mode)
1641 vam->async_errors += (retval < 0);
1645 vam->retval = retval;
1646 vam->sw_if_index = ntohl (mp->sw_if_index);
1647 vam->result_ready = 1;
1651 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
1652 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1654 vat_main_t *vam = &vat_main;
1655 vat_json_node_t node;
1657 vat_json_init_object (&node);
1658 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1659 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1661 vat_json_print (vam->ofp, &node);
1662 vat_json_free (&node);
1664 vam->retval = ntohl (mp->retval);
1665 vam->result_ready = 1;
1668 static void vl_api_gre_add_del_tunnel_reply_t_handler
1669 (vl_api_gre_add_del_tunnel_reply_t * mp)
1671 vat_main_t *vam = &vat_main;
1672 i32 retval = ntohl (mp->retval);
1673 if (vam->async_mode)
1675 vam->async_errors += (retval < 0);
1679 vam->retval = retval;
1680 vam->sw_if_index = ntohl (mp->sw_if_index);
1681 vam->result_ready = 1;
1685 static void vl_api_gre_add_del_tunnel_reply_t_handler_json
1686 (vl_api_gre_add_del_tunnel_reply_t * mp)
1688 vat_main_t *vam = &vat_main;
1689 vat_json_node_t node;
1691 vat_json_init_object (&node);
1692 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1693 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1695 vat_json_print (vam->ofp, &node);
1696 vat_json_free (&node);
1698 vam->retval = ntohl (mp->retval);
1699 vam->result_ready = 1;
1702 static void vl_api_create_vhost_user_if_reply_t_handler
1703 (vl_api_create_vhost_user_if_reply_t * mp)
1705 vat_main_t *vam = &vat_main;
1706 i32 retval = ntohl (mp->retval);
1707 if (vam->async_mode)
1709 vam->async_errors += (retval < 0);
1713 vam->retval = retval;
1714 vam->sw_if_index = ntohl (mp->sw_if_index);
1715 vam->result_ready = 1;
1719 static void vl_api_create_vhost_user_if_reply_t_handler_json
1720 (vl_api_create_vhost_user_if_reply_t * mp)
1722 vat_main_t *vam = &vat_main;
1723 vat_json_node_t node;
1725 vat_json_init_object (&node);
1726 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1727 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1729 vat_json_print (vam->ofp, &node);
1730 vat_json_free (&node);
1732 vam->retval = ntohl (mp->retval);
1733 vam->result_ready = 1;
1736 static void vl_api_ip_address_details_t_handler
1737 (vl_api_ip_address_details_t * mp)
1739 vat_main_t *vam = &vat_main;
1740 static ip_address_details_t empty_ip_address_details = { {0} };
1741 ip_address_details_t *address = NULL;
1742 ip_details_t *current_ip_details = NULL;
1743 ip_details_t *details = NULL;
1745 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
1747 if (!details || vam->current_sw_if_index >= vec_len (details)
1748 || !details[vam->current_sw_if_index].present)
1750 errmsg ("ip address details arrived but not stored");
1751 errmsg ("ip_dump should be called first");
1755 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
1757 #define addresses (current_ip_details->addr)
1759 vec_validate_init_empty (addresses, vec_len (addresses),
1760 empty_ip_address_details);
1762 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
1764 clib_memcpy (&address->ip, &mp->ip, sizeof (address->ip));
1765 address->prefix_length = mp->prefix_length;
1769 static void vl_api_ip_address_details_t_handler_json
1770 (vl_api_ip_address_details_t * mp)
1772 vat_main_t *vam = &vat_main;
1773 vat_json_node_t *node = NULL;
1774 struct in6_addr ip6;
1777 if (VAT_JSON_ARRAY != vam->json_tree.type)
1779 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1780 vat_json_init_array (&vam->json_tree);
1782 node = vat_json_array_add (&vam->json_tree);
1784 vat_json_init_object (node);
1787 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
1788 vat_json_object_add_ip6 (node, "ip", ip6);
1792 clib_memcpy (&ip4, mp->ip, sizeof (ip4));
1793 vat_json_object_add_ip4 (node, "ip", ip4);
1795 vat_json_object_add_uint (node, "prefix_length", mp->prefix_length);
1799 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
1801 vat_main_t *vam = &vat_main;
1802 static ip_details_t empty_ip_details = { 0 };
1803 ip_details_t *ip = NULL;
1804 u32 sw_if_index = ~0;
1806 sw_if_index = ntohl (mp->sw_if_index);
1808 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1809 sw_if_index, empty_ip_details);
1811 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1818 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
1820 vat_main_t *vam = &vat_main;
1822 if (VAT_JSON_ARRAY != vam->json_tree.type)
1824 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1825 vat_json_init_array (&vam->json_tree);
1827 vat_json_array_add_uint (&vam->json_tree,
1828 clib_net_to_host_u32 (mp->sw_if_index));
1831 static void vl_api_map_domain_details_t_handler_json
1832 (vl_api_map_domain_details_t * mp)
1834 vat_json_node_t *node = NULL;
1835 vat_main_t *vam = &vat_main;
1836 struct in6_addr ip6;
1839 if (VAT_JSON_ARRAY != vam->json_tree.type)
1841 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1842 vat_json_init_array (&vam->json_tree);
1845 node = vat_json_array_add (&vam->json_tree);
1846 vat_json_init_object (node);
1848 vat_json_object_add_uint (node, "domain_index",
1849 clib_net_to_host_u32 (mp->domain_index));
1850 clib_memcpy (&ip6, mp->ip6_prefix, sizeof (ip6));
1851 vat_json_object_add_ip6 (node, "ip6_prefix", ip6);
1852 clib_memcpy (&ip4, mp->ip4_prefix, sizeof (ip4));
1853 vat_json_object_add_ip4 (node, "ip4_prefix", ip4);
1854 clib_memcpy (&ip6, mp->ip6_src, sizeof (ip6));
1855 vat_json_object_add_ip6 (node, "ip6_src", ip6);
1856 vat_json_object_add_int (node, "ip6_prefix_len", mp->ip6_prefix_len);
1857 vat_json_object_add_int (node, "ip4_prefix_len", mp->ip4_prefix_len);
1858 vat_json_object_add_int (node, "ip6_src_len", mp->ip6_src_len);
1859 vat_json_object_add_int (node, "ea_bits_len", mp->ea_bits_len);
1860 vat_json_object_add_int (node, "psid_offset", mp->psid_offset);
1861 vat_json_object_add_int (node, "psid_length", mp->psid_length);
1862 vat_json_object_add_uint (node, "flags", mp->flags);
1863 vat_json_object_add_uint (node, "mtu", clib_net_to_host_u16 (mp->mtu));
1864 vat_json_object_add_int (node, "is_translation", mp->is_translation);
1867 static void vl_api_map_domain_details_t_handler
1868 (vl_api_map_domain_details_t * mp)
1870 vat_main_t *vam = &vat_main;
1872 if (mp->is_translation)
1875 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U/%d (ip6-src) index: %u",
1876 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1877 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1878 format_ip6_address, mp->ip6_src, mp->ip6_src_len,
1879 clib_net_to_host_u32 (mp->domain_index));
1884 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U (ip6-src) index: %u",
1885 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1886 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1887 format_ip6_address, mp->ip6_src,
1888 clib_net_to_host_u32 (mp->domain_index));
1890 print (vam->ofp, " ea-len %d psid-offset %d psid-len %d mtu %d %s",
1891 mp->ea_bits_len, mp->psid_offset, mp->psid_length, mp->mtu,
1892 mp->is_translation ? "map-t" : "");
1895 static void vl_api_map_rule_details_t_handler_json
1896 (vl_api_map_rule_details_t * mp)
1898 struct in6_addr ip6;
1899 vat_json_node_t *node = NULL;
1900 vat_main_t *vam = &vat_main;
1902 if (VAT_JSON_ARRAY != vam->json_tree.type)
1904 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1905 vat_json_init_array (&vam->json_tree);
1908 node = vat_json_array_add (&vam->json_tree);
1909 vat_json_init_object (node);
1911 vat_json_object_add_uint (node, "psid", clib_net_to_host_u16 (mp->psid));
1912 clib_memcpy (&ip6, mp->ip6_dst, sizeof (ip6));
1913 vat_json_object_add_ip6 (node, "ip6_dst", ip6);
1917 vl_api_map_rule_details_t_handler (vl_api_map_rule_details_t * mp)
1919 vat_main_t *vam = &vat_main;
1920 print (vam->ofp, " %d (psid) %U (ip6-dst)",
1921 clib_net_to_host_u16 (mp->psid), format_ip6_address, mp->ip6_dst);
1925 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
1927 errmsg ("DHCP compl event: pid %d %s hostname %s host_addr %U "
1928 "router_addr %U host_mac %U",
1929 mp->pid, mp->is_ipv6 ? "ipv6" : "ipv4", mp->hostname,
1930 format_ip4_address, &mp->host_address,
1931 format_ip4_address, &mp->router_address,
1932 format_ethernet_address, mp->host_mac);
1935 static void vl_api_dhcp_compl_event_t_handler_json
1936 (vl_api_dhcp_compl_event_t * mp)
1938 /* JSON output not supported */
1942 set_simple_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1945 vat_main_t *vam = &vat_main;
1946 static u64 default_counter = 0;
1948 vec_validate_init_empty (vam->simple_interface_counters, vnet_counter_type,
1950 vec_validate_init_empty (vam->simple_interface_counters[vnet_counter_type],
1951 sw_if_index, default_counter);
1952 vam->simple_interface_counters[vnet_counter_type][sw_if_index] = counter;
1956 set_combined_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1957 interface_counter_t counter)
1959 vat_main_t *vam = &vat_main;
1960 static interface_counter_t default_counter = { 0, };
1962 vec_validate_init_empty (vam->combined_interface_counters,
1963 vnet_counter_type, NULL);
1964 vec_validate_init_empty (vam->combined_interface_counters
1965 [vnet_counter_type], sw_if_index, default_counter);
1966 vam->combined_interface_counters[vnet_counter_type][sw_if_index] = counter;
1969 static void vl_api_vnet_interface_counters_t_handler
1970 (vl_api_vnet_interface_counters_t * mp)
1975 static void vl_api_vnet_interface_counters_t_handler_json
1976 (vl_api_vnet_interface_counters_t * mp)
1978 interface_counter_t counter;
1983 u32 first_sw_if_index;
1986 count = ntohl (mp->count);
1987 first_sw_if_index = ntohl (mp->first_sw_if_index);
1989 if (!mp->is_combined)
1991 v_packets = (u64 *) & mp->data;
1992 for (i = 0; i < count; i++)
1995 clib_net_to_host_u64 (clib_mem_unaligned (v_packets, u64));
1996 set_simple_interface_counter (mp->vnet_counter_type,
1997 first_sw_if_index + i, packets);
2003 v = (vlib_counter_t *) & mp->data;
2004 for (i = 0; i < count; i++)
2007 clib_net_to_host_u64 (clib_mem_unaligned (&v->packets, u64));
2009 clib_net_to_host_u64 (clib_mem_unaligned (&v->bytes, u64));
2010 set_combined_interface_counter (mp->vnet_counter_type,
2011 first_sw_if_index + i, counter);
2018 ip4_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
2020 vat_main_t *vam = &vat_main;
2023 for (i = 0; i < vec_len (vam->ip4_fib_counters_vrf_id_by_index); i++)
2025 if (vam->ip4_fib_counters_vrf_id_by_index[i] == vrf_id)
2034 ip6_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
2036 vat_main_t *vam = &vat_main;
2039 for (i = 0; i < vec_len (vam->ip6_fib_counters_vrf_id_by_index); i++)
2041 if (vam->ip6_fib_counters_vrf_id_by_index[i] == vrf_id)
2049 static void vl_api_vnet_ip4_fib_counters_t_handler
2050 (vl_api_vnet_ip4_fib_counters_t * mp)
2055 static void vl_api_vnet_ip4_fib_counters_t_handler_json
2056 (vl_api_vnet_ip4_fib_counters_t * mp)
2058 vat_main_t *vam = &vat_main;
2059 vl_api_ip4_fib_counter_t *v;
2060 ip4_fib_counter_t *counter;
2067 vrf_id = ntohl (mp->vrf_id);
2068 vrf_index = ip4_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2069 if (~0 == vrf_index)
2071 vrf_index = vec_len (vam->ip4_fib_counters_vrf_id_by_index);
2072 vec_validate (vam->ip4_fib_counters_vrf_id_by_index, vrf_index);
2073 vam->ip4_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2074 vec_validate (vam->ip4_fib_counters, vrf_index);
2075 vam->ip4_fib_counters[vrf_index] = NULL;
2078 vec_free (vam->ip4_fib_counters[vrf_index]);
2079 v = (vl_api_ip4_fib_counter_t *) & mp->c;
2080 count = ntohl (mp->count);
2081 for (i = 0; i < count; i++)
2083 vec_validate (vam->ip4_fib_counters[vrf_index], i);
2084 counter = &vam->ip4_fib_counters[vrf_index][i];
2085 clib_memcpy (&ip4, &v->address, sizeof (ip4));
2086 counter->address = ip4;
2087 counter->address_length = v->address_length;
2088 counter->packets = clib_net_to_host_u64 (v->packets);
2089 counter->bytes = clib_net_to_host_u64 (v->bytes);
2094 static void vl_api_vnet_ip4_nbr_counters_t_handler
2095 (vl_api_vnet_ip4_nbr_counters_t * mp)
2100 static void vl_api_vnet_ip4_nbr_counters_t_handler_json
2101 (vl_api_vnet_ip4_nbr_counters_t * mp)
2103 vat_main_t *vam = &vat_main;
2104 vl_api_ip4_nbr_counter_t *v;
2105 ip4_nbr_counter_t *counter;
2110 sw_if_index = ntohl (mp->sw_if_index);
2111 count = ntohl (mp->count);
2112 vec_validate (vam->ip4_nbr_counters, sw_if_index);
2115 vec_free (vam->ip4_nbr_counters[sw_if_index]);
2117 v = (vl_api_ip4_nbr_counter_t *) & mp->c;
2118 for (i = 0; i < count; i++)
2120 vec_validate (vam->ip4_nbr_counters[sw_if_index], i);
2121 counter = &vam->ip4_nbr_counters[sw_if_index][i];
2122 counter->address.s_addr = v->address;
2123 counter->packets = clib_net_to_host_u64 (v->packets);
2124 counter->bytes = clib_net_to_host_u64 (v->bytes);
2125 counter->linkt = v->link_type;
2130 static void vl_api_vnet_ip6_fib_counters_t_handler
2131 (vl_api_vnet_ip6_fib_counters_t * mp)
2136 static void vl_api_vnet_ip6_fib_counters_t_handler_json
2137 (vl_api_vnet_ip6_fib_counters_t * mp)
2139 vat_main_t *vam = &vat_main;
2140 vl_api_ip6_fib_counter_t *v;
2141 ip6_fib_counter_t *counter;
2142 struct in6_addr ip6;
2148 vrf_id = ntohl (mp->vrf_id);
2149 vrf_index = ip6_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2150 if (~0 == vrf_index)
2152 vrf_index = vec_len (vam->ip6_fib_counters_vrf_id_by_index);
2153 vec_validate (vam->ip6_fib_counters_vrf_id_by_index, vrf_index);
2154 vam->ip6_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2155 vec_validate (vam->ip6_fib_counters, vrf_index);
2156 vam->ip6_fib_counters[vrf_index] = NULL;
2159 vec_free (vam->ip6_fib_counters[vrf_index]);
2160 v = (vl_api_ip6_fib_counter_t *) & mp->c;
2161 count = ntohl (mp->count);
2162 for (i = 0; i < count; i++)
2164 vec_validate (vam->ip6_fib_counters[vrf_index], i);
2165 counter = &vam->ip6_fib_counters[vrf_index][i];
2166 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2167 counter->address = ip6;
2168 counter->address_length = v->address_length;
2169 counter->packets = clib_net_to_host_u64 (v->packets);
2170 counter->bytes = clib_net_to_host_u64 (v->bytes);
2175 static void vl_api_vnet_ip6_nbr_counters_t_handler
2176 (vl_api_vnet_ip6_nbr_counters_t * mp)
2181 static void vl_api_vnet_ip6_nbr_counters_t_handler_json
2182 (vl_api_vnet_ip6_nbr_counters_t * mp)
2184 vat_main_t *vam = &vat_main;
2185 vl_api_ip6_nbr_counter_t *v;
2186 ip6_nbr_counter_t *counter;
2187 struct in6_addr ip6;
2192 sw_if_index = ntohl (mp->sw_if_index);
2193 count = ntohl (mp->count);
2194 vec_validate (vam->ip6_nbr_counters, sw_if_index);
2197 vec_free (vam->ip6_nbr_counters[sw_if_index]);
2199 v = (vl_api_ip6_nbr_counter_t *) & mp->c;
2200 for (i = 0; i < count; i++)
2202 vec_validate (vam->ip6_nbr_counters[sw_if_index], i);
2203 counter = &vam->ip6_nbr_counters[sw_if_index][i];
2204 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2205 counter->address = ip6;
2206 counter->packets = clib_net_to_host_u64 (v->packets);
2207 counter->bytes = clib_net_to_host_u64 (v->bytes);
2212 static void vl_api_get_first_msg_id_reply_t_handler
2213 (vl_api_get_first_msg_id_reply_t * mp)
2215 vat_main_t *vam = &vat_main;
2216 i32 retval = ntohl (mp->retval);
2218 if (vam->async_mode)
2220 vam->async_errors += (retval < 0);
2224 vam->retval = retval;
2225 vam->result_ready = 1;
2229 errmsg ("first message id %d", ntohs (mp->first_msg_id));
2233 static void vl_api_get_first_msg_id_reply_t_handler_json
2234 (vl_api_get_first_msg_id_reply_t * mp)
2236 vat_main_t *vam = &vat_main;
2237 vat_json_node_t node;
2239 vat_json_init_object (&node);
2240 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2241 vat_json_object_add_uint (&node, "first_msg_id",
2242 (uint) ntohs (mp->first_msg_id));
2244 vat_json_print (vam->ofp, &node);
2245 vat_json_free (&node);
2247 vam->retval = ntohl (mp->retval);
2248 vam->result_ready = 1;
2251 static void vl_api_get_node_graph_reply_t_handler
2252 (vl_api_get_node_graph_reply_t * mp)
2254 vat_main_t *vam = &vat_main;
2255 api_main_t *am = &api_main;
2256 i32 retval = ntohl (mp->retval);
2257 u8 *pvt_copy, *reply;
2262 if (vam->async_mode)
2264 vam->async_errors += (retval < 0);
2268 vam->retval = retval;
2269 vam->result_ready = 1;
2272 /* "Should never happen..." */
2276 reply = (u8 *) (mp->reply_in_shmem);
2277 pvt_copy = vec_dup (reply);
2279 /* Toss the shared-memory original... */
2280 pthread_mutex_lock (&am->vlib_rp->mutex);
2281 oldheap = svm_push_data_heap (am->vlib_rp);
2285 svm_pop_heap (oldheap);
2286 pthread_mutex_unlock (&am->vlib_rp->mutex);
2288 if (vam->graph_nodes)
2290 hash_free (vam->graph_node_index_by_name);
2292 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2294 node = vam->graph_nodes[i];
2295 vec_free (node->name);
2296 vec_free (node->next_nodes);
2299 vec_free (vam->graph_nodes);
2302 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2303 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2304 vec_free (pvt_copy);
2306 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2308 node = vam->graph_nodes[i];
2309 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2313 static void vl_api_get_node_graph_reply_t_handler_json
2314 (vl_api_get_node_graph_reply_t * mp)
2316 vat_main_t *vam = &vat_main;
2317 api_main_t *am = &api_main;
2319 vat_json_node_t node;
2322 /* $$$$ make this real? */
2323 vat_json_init_object (&node);
2324 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2325 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2327 reply = (u8 *) (mp->reply_in_shmem);
2329 /* Toss the shared-memory original... */
2330 pthread_mutex_lock (&am->vlib_rp->mutex);
2331 oldheap = svm_push_data_heap (am->vlib_rp);
2335 svm_pop_heap (oldheap);
2336 pthread_mutex_unlock (&am->vlib_rp->mutex);
2338 vat_json_print (vam->ofp, &node);
2339 vat_json_free (&node);
2341 vam->retval = ntohl (mp->retval);
2342 vam->result_ready = 1;
2346 vl_api_lisp_locator_details_t_handler (vl_api_lisp_locator_details_t * mp)
2348 vat_main_t *vam = &vat_main;
2353 s = format (s, "%=16d%=16d%=16d",
2354 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2358 s = format (s, "%=16U%=16d%=16d",
2359 mp->is_ipv6 ? format_ip6_address :
2361 mp->ip_address, mp->priority, mp->weight);
2364 print (vam->ofp, "%v", s);
2369 vl_api_lisp_locator_details_t_handler_json (vl_api_lisp_locator_details_t *
2372 vat_main_t *vam = &vat_main;
2373 vat_json_node_t *node = NULL;
2374 struct in6_addr ip6;
2377 if (VAT_JSON_ARRAY != vam->json_tree.type)
2379 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2380 vat_json_init_array (&vam->json_tree);
2382 node = vat_json_array_add (&vam->json_tree);
2383 vat_json_init_object (node);
2385 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2386 vat_json_object_add_uint (node, "priority", mp->priority);
2387 vat_json_object_add_uint (node, "weight", mp->weight);
2390 vat_json_object_add_uint (node, "sw_if_index",
2391 clib_net_to_host_u32 (mp->sw_if_index));
2396 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2397 vat_json_object_add_ip6 (node, "address", ip6);
2401 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2402 vat_json_object_add_ip4 (node, "address", ip4);
2408 vl_api_lisp_locator_set_details_t_handler (vl_api_lisp_locator_set_details_t *
2411 vat_main_t *vam = &vat_main;
2414 ls_name = format (0, "%s", mp->ls_name);
2416 print (vam->ofp, "%=10d%=15v", clib_net_to_host_u32 (mp->ls_index),
2422 vl_api_lisp_locator_set_details_t_handler_json
2423 (vl_api_lisp_locator_set_details_t * mp)
2425 vat_main_t *vam = &vat_main;
2426 vat_json_node_t *node = 0;
2429 ls_name = format (0, "%s", mp->ls_name);
2430 vec_add1 (ls_name, 0);
2432 if (VAT_JSON_ARRAY != vam->json_tree.type)
2434 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2435 vat_json_init_array (&vam->json_tree);
2437 node = vat_json_array_add (&vam->json_tree);
2439 vat_json_init_object (node);
2440 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2441 vat_json_object_add_uint (node, "ls_index",
2442 clib_net_to_host_u32 (mp->ls_index));
2447 format_lisp_flat_eid (u8 * s, va_list * args)
2449 u32 type = va_arg (*args, u32);
2450 u8 *eid = va_arg (*args, u8 *);
2451 u32 eid_len = va_arg (*args, u32);
2456 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
2458 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
2460 return format (s, "%U", format_ethernet_address, eid);
2466 format_lisp_eid_vat (u8 * s, va_list * args)
2468 u32 type = va_arg (*args, u32);
2469 u8 *eid = va_arg (*args, u8 *);
2470 u32 eid_len = va_arg (*args, u32);
2471 u8 *seid = va_arg (*args, u8 *);
2472 u32 seid_len = va_arg (*args, u32);
2473 u32 is_src_dst = va_arg (*args, u32);
2476 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
2478 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
2484 vl_api_lisp_eid_table_details_t_handler (vl_api_lisp_eid_table_details_t * mp)
2486 vat_main_t *vam = &vat_main;
2487 u8 *s = 0, *eid = 0;
2489 if (~0 == mp->locator_set_index)
2490 s = format (0, "action: %d", mp->action);
2492 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
2494 eid = format (0, "%U", format_lisp_eid_vat,
2498 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2501 print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
2502 clib_net_to_host_u32 (mp->vni),
2504 mp->is_local ? "local" : "remote",
2505 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
2506 clib_net_to_host_u16 (mp->key_id), mp->key);
2513 vl_api_lisp_eid_table_details_t_handler_json (vl_api_lisp_eid_table_details_t
2516 vat_main_t *vam = &vat_main;
2517 vat_json_node_t *node = 0;
2520 if (VAT_JSON_ARRAY != vam->json_tree.type)
2522 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2523 vat_json_init_array (&vam->json_tree);
2525 node = vat_json_array_add (&vam->json_tree);
2527 vat_json_init_object (node);
2528 if (~0 == mp->locator_set_index)
2529 vat_json_object_add_uint (node, "action", mp->action);
2531 vat_json_object_add_uint (node, "locator_set_index",
2532 clib_net_to_host_u32 (mp->locator_set_index));
2534 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
2535 eid = format (0, "%U", format_lisp_eid_vat,
2539 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2541 vat_json_object_add_string_copy (node, "eid", eid);
2542 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2543 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
2544 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
2548 vat_json_object_add_uint (node, "key_id",
2549 clib_net_to_host_u16 (mp->key_id));
2550 vat_json_object_add_string_copy (node, "key", mp->key);
2556 vl_api_lisp_eid_table_map_details_t_handler
2557 (vl_api_lisp_eid_table_map_details_t * mp)
2559 vat_main_t *vam = &vat_main;
2561 u8 *line = format (0, "%=10d%=10d",
2562 clib_net_to_host_u32 (mp->vni),
2563 clib_net_to_host_u32 (mp->dp_table));
2564 print (vam->ofp, "%v", line);
2569 vl_api_lisp_eid_table_map_details_t_handler_json
2570 (vl_api_lisp_eid_table_map_details_t * mp)
2572 vat_main_t *vam = &vat_main;
2573 vat_json_node_t *node = NULL;
2575 if (VAT_JSON_ARRAY != vam->json_tree.type)
2577 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2578 vat_json_init_array (&vam->json_tree);
2580 node = vat_json_array_add (&vam->json_tree);
2581 vat_json_init_object (node);
2582 vat_json_object_add_uint (node, "dp_table",
2583 clib_net_to_host_u32 (mp->dp_table));
2584 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2588 vl_api_lisp_eid_table_vni_details_t_handler
2589 (vl_api_lisp_eid_table_vni_details_t * mp)
2591 vat_main_t *vam = &vat_main;
2593 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
2594 print (vam->ofp, "%v", line);
2599 vl_api_lisp_eid_table_vni_details_t_handler_json
2600 (vl_api_lisp_eid_table_vni_details_t * mp)
2602 vat_main_t *vam = &vat_main;
2603 vat_json_node_t *node = NULL;
2605 if (VAT_JSON_ARRAY != vam->json_tree.type)
2607 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2608 vat_json_init_array (&vam->json_tree);
2610 node = vat_json_array_add (&vam->json_tree);
2611 vat_json_init_object (node);
2612 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2616 vl_api_show_lisp_map_register_state_reply_t_handler
2617 (vl_api_show_lisp_map_register_state_reply_t * mp)
2619 vat_main_t *vam = &vat_main;
2620 int retval = clib_net_to_host_u32 (mp->retval);
2622 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
2624 vam->retval = retval;
2625 vam->result_ready = 1;
2629 vl_api_show_lisp_map_register_state_reply_t_handler_json
2630 (vl_api_show_lisp_map_register_state_reply_t * mp)
2632 vat_main_t *vam = &vat_main;
2633 vat_json_node_t _node, *node = &_node;
2634 int retval = clib_net_to_host_u32 (mp->retval);
2636 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
2638 vat_json_init_object (node);
2639 vat_json_object_add_string_copy (node, "state", s);
2641 vat_json_print (vam->ofp, node);
2642 vat_json_free (node);
2644 vam->retval = retval;
2645 vam->result_ready = 1;
2650 vl_api_show_lisp_rloc_probe_state_reply_t_handler
2651 (vl_api_show_lisp_rloc_probe_state_reply_t * mp)
2653 vat_main_t *vam = &vat_main;
2654 int retval = clib_net_to_host_u32 (mp->retval);
2659 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
2661 vam->retval = retval;
2662 vam->result_ready = 1;
2666 vl_api_show_lisp_rloc_probe_state_reply_t_handler_json
2667 (vl_api_show_lisp_rloc_probe_state_reply_t * mp)
2669 vat_main_t *vam = &vat_main;
2670 vat_json_node_t _node, *node = &_node;
2671 int retval = clib_net_to_host_u32 (mp->retval);
2673 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
2674 vat_json_init_object (node);
2675 vat_json_object_add_string_copy (node, "state", s);
2677 vat_json_print (vam->ofp, node);
2678 vat_json_free (node);
2680 vam->retval = retval;
2681 vam->result_ready = 1;
2686 api_lisp_gpe_fwd_entry_net_to_host (vl_api_lisp_gpe_fwd_entry_t * e)
2688 e->dp_table = clib_net_to_host_u32 (e->dp_table);
2689 e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
2693 lisp_gpe_fwd_entries_get_reply_t_net_to_host
2694 (vl_api_lisp_gpe_fwd_entries_get_reply_t * mp)
2698 mp->count = clib_net_to_host_u32 (mp->count);
2699 for (i = 0; i < mp->count; i++)
2701 api_lisp_gpe_fwd_entry_net_to_host (&mp->entries[i]);
2706 vl_api_lisp_gpe_fwd_entry_path_details_t_handler
2707 (vl_api_lisp_gpe_fwd_entry_path_details_t * mp)
2709 vat_main_t *vam = &vat_main;
2710 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
2712 if (mp->lcl_loc.is_ip4)
2713 format_ip_address_fcn = format_ip4_address;
2715 format_ip_address_fcn = format_ip6_address;
2717 print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
2718 format_ip_address_fcn, &mp->lcl_loc,
2719 format_ip_address_fcn, &mp->rmt_loc);
2723 lisp_fill_locator_node (vat_json_node_t * n, vl_api_lisp_gpe_locator_t * loc)
2725 struct in6_addr ip6;
2730 clib_memcpy (&ip4, loc->addr, sizeof (ip4));
2731 vat_json_object_add_ip4 (n, "address", ip4);
2735 clib_memcpy (&ip6, loc->addr, sizeof (ip6));
2736 vat_json_object_add_ip6 (n, "address", ip6);
2738 vat_json_object_add_uint (n, "weight", loc->weight);
2742 vl_api_lisp_gpe_fwd_entry_path_details_t_handler_json
2743 (vl_api_lisp_gpe_fwd_entry_path_details_t * mp)
2745 vat_main_t *vam = &vat_main;
2746 vat_json_node_t *node = NULL;
2747 vat_json_node_t *loc_node;
2749 if (VAT_JSON_ARRAY != vam->json_tree.type)
2751 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2752 vat_json_init_array (&vam->json_tree);
2754 node = vat_json_array_add (&vam->json_tree);
2755 vat_json_init_object (node);
2757 loc_node = vat_json_object_add (node, "local_locator");
2758 vat_json_init_object (loc_node);
2759 lisp_fill_locator_node (loc_node, &mp->lcl_loc);
2761 loc_node = vat_json_object_add (node, "remote_locator");
2762 vat_json_init_object (loc_node);
2763 lisp_fill_locator_node (loc_node, &mp->rmt_loc);
2767 vl_api_lisp_gpe_fwd_entries_get_reply_t_handler
2768 (vl_api_lisp_gpe_fwd_entries_get_reply_t * mp)
2770 vat_main_t *vam = &vat_main;
2772 int retval = clib_net_to_host_u32 (mp->retval);
2773 vl_api_lisp_gpe_fwd_entry_t *e;
2778 lisp_gpe_fwd_entries_get_reply_t_net_to_host (mp);
2780 for (i = 0; i < mp->count; i++)
2782 e = &mp->entries[i];
2783 print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
2784 format_lisp_flat_eid, e->eid_type, e->leid, e->leid_prefix_len,
2785 format_lisp_flat_eid, e->eid_type, e->reid, e->reid_prefix_len);
2789 vam->retval = retval;
2790 vam->result_ready = 1;
2794 vl_api_lisp_gpe_fwd_entries_get_reply_t_handler_json
2795 (vl_api_lisp_gpe_fwd_entries_get_reply_t * mp)
2798 vat_main_t *vam = &vat_main;
2799 vat_json_node_t *e = 0, root;
2801 int retval = clib_net_to_host_u32 (mp->retval);
2802 vl_api_lisp_gpe_fwd_entry_t *fwd;
2807 lisp_gpe_fwd_entries_get_reply_t_net_to_host (mp);
2808 vat_json_init_array (&root);
2810 for (i = 0; i < mp->count; i++)
2812 e = vat_json_array_add (&root);
2813 fwd = &mp->entries[i];
2815 vat_json_init_object (e);
2816 vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
2817 vat_json_object_add_int (e, "dp_table", fwd->dp_table);
2819 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->leid,
2820 fwd->leid_prefix_len);
2822 vat_json_object_add_string_copy (e, "leid", s);
2825 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->reid,
2826 fwd->reid_prefix_len);
2828 vat_json_object_add_string_copy (e, "reid", s);
2832 vat_json_print (vam->ofp, &root);
2833 vat_json_free (&root);
2836 vam->retval = retval;
2837 vam->result_ready = 1;
2841 vl_api_lisp_adjacencies_get_reply_t_handler
2842 (vl_api_lisp_adjacencies_get_reply_t * mp)
2844 vat_main_t *vam = &vat_main;
2846 int retval = clib_net_to_host_u32 (mp->retval);
2847 vl_api_lisp_adjacency_t *a;
2852 n = clib_net_to_host_u32 (mp->count);
2854 for (i = 0; i < n; i++)
2856 a = &mp->adjacencies[i];
2857 print (vam->ofp, "%U %40U",
2858 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
2859 format_lisp_flat_eid, a->eid_type, a->reid, a->reid_prefix_len);
2863 vam->retval = retval;
2864 vam->result_ready = 1;
2868 vl_api_lisp_adjacencies_get_reply_t_handler_json
2869 (vl_api_lisp_adjacencies_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_lisp_adjacency_t *a;
2881 n = clib_net_to_host_u32 (mp->count);
2882 vat_json_init_array (&root);
2884 for (i = 0; i < n; i++)
2886 e = vat_json_array_add (&root);
2887 a = &mp->adjacencies[i];
2889 vat_json_init_object (e);
2890 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
2891 a->leid_prefix_len);
2893 vat_json_object_add_string_copy (e, "leid", s);
2896 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
2897 a->reid_prefix_len);
2899 vat_json_object_add_string_copy (e, "reid", s);
2903 vat_json_print (vam->ofp, &root);
2904 vat_json_free (&root);
2907 vam->retval = retval;
2908 vam->result_ready = 1;
2912 vl_api_lisp_map_server_details_t_handler (vl_api_lisp_map_server_details_t
2915 vat_main_t *vam = &vat_main;
2917 print (vam->ofp, "%=20U",
2918 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2923 vl_api_lisp_map_server_details_t_handler_json
2924 (vl_api_lisp_map_server_details_t * mp)
2926 vat_main_t *vam = &vat_main;
2927 vat_json_node_t *node = NULL;
2928 struct in6_addr ip6;
2931 if (VAT_JSON_ARRAY != vam->json_tree.type)
2933 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2934 vat_json_init_array (&vam->json_tree);
2936 node = vat_json_array_add (&vam->json_tree);
2938 vat_json_init_object (node);
2941 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2942 vat_json_object_add_ip6 (node, "map-server", ip6);
2946 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2947 vat_json_object_add_ip4 (node, "map-server", ip4);
2952 vl_api_lisp_map_resolver_details_t_handler (vl_api_lisp_map_resolver_details_t
2955 vat_main_t *vam = &vat_main;
2957 print (vam->ofp, "%=20U",
2958 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2963 vl_api_lisp_map_resolver_details_t_handler_json
2964 (vl_api_lisp_map_resolver_details_t * mp)
2966 vat_main_t *vam = &vat_main;
2967 vat_json_node_t *node = NULL;
2968 struct in6_addr ip6;
2971 if (VAT_JSON_ARRAY != vam->json_tree.type)
2973 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2974 vat_json_init_array (&vam->json_tree);
2976 node = vat_json_array_add (&vam->json_tree);
2978 vat_json_init_object (node);
2981 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2982 vat_json_object_add_ip6 (node, "map resolver", ip6);
2986 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2987 vat_json_object_add_ip4 (node, "map resolver", ip4);
2992 vl_api_show_lisp_status_reply_t_handler
2993 (vl_api_show_lisp_status_reply_t * mp)
2995 vat_main_t *vam = &vat_main;
2996 i32 retval = ntohl (mp->retval);
3000 print (vam->ofp, "feature: %s\ngpe: %s",
3001 mp->feature_status ? "enabled" : "disabled",
3002 mp->gpe_status ? "enabled" : "disabled");
3005 vam->retval = retval;
3006 vam->result_ready = 1;
3010 vl_api_show_lisp_status_reply_t_handler_json
3011 (vl_api_show_lisp_status_reply_t * mp)
3013 vat_main_t *vam = &vat_main;
3014 vat_json_node_t node;
3015 u8 *gpe_status = NULL;
3016 u8 *feature_status = NULL;
3018 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
3019 feature_status = format (0, "%s",
3020 mp->feature_status ? "enabled" : "disabled");
3021 vec_add1 (gpe_status, 0);
3022 vec_add1 (feature_status, 0);
3024 vat_json_init_object (&node);
3025 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
3026 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
3028 vec_free (gpe_status);
3029 vec_free (feature_status);
3031 vat_json_print (vam->ofp, &node);
3032 vat_json_free (&node);
3034 vam->retval = ntohl (mp->retval);
3035 vam->result_ready = 1;
3039 vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler
3040 (vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
3042 vat_main_t *vam = &vat_main;
3043 i32 retval = ntohl (mp->retval);
3047 print (vam->ofp, "%=20s", mp->locator_set_name);
3050 vam->retval = retval;
3051 vam->result_ready = 1;
3055 vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler_json
3056 (vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
3058 vat_main_t *vam = &vat_main;
3059 vat_json_node_t *node = NULL;
3061 if (VAT_JSON_ARRAY != vam->json_tree.type)
3063 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3064 vat_json_init_array (&vam->json_tree);
3066 node = vat_json_array_add (&vam->json_tree);
3068 vat_json_init_object (node);
3069 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
3071 vat_json_print (vam->ofp, node);
3072 vat_json_free (node);
3074 vam->retval = ntohl (mp->retval);
3075 vam->result_ready = 1;
3079 format_lisp_map_request_mode (u8 * s, va_list * args)
3081 u32 mode = va_arg (*args, u32);
3086 return format (0, "dst-only");
3088 return format (0, "src-dst");
3094 vl_api_show_lisp_map_request_mode_reply_t_handler
3095 (vl_api_show_lisp_map_request_mode_reply_t * mp)
3097 vat_main_t *vam = &vat_main;
3098 i32 retval = ntohl (mp->retval);
3102 u32 mode = mp->mode;
3103 print (vam->ofp, "map_request_mode: %U",
3104 format_lisp_map_request_mode, mode);
3107 vam->retval = retval;
3108 vam->result_ready = 1;
3112 vl_api_show_lisp_map_request_mode_reply_t_handler_json
3113 (vl_api_show_lisp_map_request_mode_reply_t * mp)
3115 vat_main_t *vam = &vat_main;
3116 vat_json_node_t node;
3121 s = format (0, "%U", format_lisp_map_request_mode, mode);
3124 vat_json_init_object (&node);
3125 vat_json_object_add_string_copy (&node, "map_request_mode", s);
3126 vat_json_print (vam->ofp, &node);
3127 vat_json_free (&node);
3130 vam->retval = ntohl (mp->retval);
3131 vam->result_ready = 1;
3135 vl_api_show_lisp_pitr_reply_t_handler (vl_api_show_lisp_pitr_reply_t * mp)
3137 vat_main_t *vam = &vat_main;
3138 i32 retval = ntohl (mp->retval);
3142 print (vam->ofp, "%-20s%-16s",
3143 mp->status ? "enabled" : "disabled",
3144 mp->status ? (char *) mp->locator_set_name : "");
3147 vam->retval = retval;
3148 vam->result_ready = 1;
3152 vl_api_show_lisp_pitr_reply_t_handler_json (vl_api_show_lisp_pitr_reply_t *
3155 vat_main_t *vam = &vat_main;
3156 vat_json_node_t node;
3159 status = format (0, "%s", mp->status ? "enabled" : "disabled");
3160 vec_add1 (status, 0);
3162 vat_json_init_object (&node);
3163 vat_json_object_add_string_copy (&node, "status", status);
3166 vat_json_object_add_string_copy (&node, "locator_set",
3167 mp->locator_set_name);
3172 vat_json_print (vam->ofp, &node);
3173 vat_json_free (&node);
3175 vam->retval = ntohl (mp->retval);
3176 vam->result_ready = 1;
3180 format_policer_type (u8 * s, va_list * va)
3182 u32 i = va_arg (*va, u32);
3184 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
3185 s = format (s, "1r2c");
3186 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
3187 s = format (s, "1r3c");
3188 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
3189 s = format (s, "2r3c-2698");
3190 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
3191 s = format (s, "2r3c-4115");
3192 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
3193 s = format (s, "2r3c-mef5cf1");
3195 s = format (s, "ILLEGAL");
3200 format_policer_rate_type (u8 * s, va_list * va)
3202 u32 i = va_arg (*va, u32);
3204 if (i == SSE2_QOS_RATE_KBPS)
3205 s = format (s, "kbps");
3206 else if (i == SSE2_QOS_RATE_PPS)
3207 s = format (s, "pps");
3209 s = format (s, "ILLEGAL");
3214 format_policer_round_type (u8 * s, va_list * va)
3216 u32 i = va_arg (*va, u32);
3218 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
3219 s = format (s, "closest");
3220 else if (i == SSE2_QOS_ROUND_TO_UP)
3221 s = format (s, "up");
3222 else if (i == SSE2_QOS_ROUND_TO_DOWN)
3223 s = format (s, "down");
3225 s = format (s, "ILLEGAL");
3230 format_policer_action_type (u8 * s, va_list * va)
3232 u32 i = va_arg (*va, u32);
3234 if (i == SSE2_QOS_ACTION_DROP)
3235 s = format (s, "drop");
3236 else if (i == SSE2_QOS_ACTION_TRANSMIT)
3237 s = format (s, "transmit");
3238 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3239 s = format (s, "mark-and-transmit");
3241 s = format (s, "ILLEGAL");
3246 format_dscp (u8 * s, va_list * va)
3248 u32 i = va_arg (*va, u32);
3253 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
3257 return format (s, "ILLEGAL");
3259 s = format (s, "%s", t);
3264 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
3266 vat_main_t *vam = &vat_main;
3267 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
3269 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3270 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
3272 conform_dscp_str = format (0, "");
3274 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3275 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
3277 exceed_dscp_str = format (0, "");
3279 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3280 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
3282 violate_dscp_str = format (0, "");
3284 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
3285 "rate type %U, round type %U, %s rate, %s color-aware, "
3286 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
3287 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
3288 "conform action %U%s, exceed action %U%s, violate action %U%s",
3290 format_policer_type, mp->type,
3293 clib_net_to_host_u64 (mp->cb),
3294 clib_net_to_host_u64 (mp->eb),
3295 format_policer_rate_type, mp->rate_type,
3296 format_policer_round_type, mp->round_type,
3297 mp->single_rate ? "single" : "dual",
3298 mp->color_aware ? "is" : "not",
3299 ntohl (mp->cir_tokens_per_period),
3300 ntohl (mp->pir_tokens_per_period),
3302 ntohl (mp->current_limit),
3303 ntohl (mp->current_bucket),
3304 ntohl (mp->extended_limit),
3305 ntohl (mp->extended_bucket),
3306 clib_net_to_host_u64 (mp->last_update_time),
3307 format_policer_action_type, mp->conform_action_type,
3309 format_policer_action_type, mp->exceed_action_type,
3311 format_policer_action_type, mp->violate_action_type,
3314 vec_free (conform_dscp_str);
3315 vec_free (exceed_dscp_str);
3316 vec_free (violate_dscp_str);
3319 static void vl_api_policer_details_t_handler_json
3320 (vl_api_policer_details_t * mp)
3322 vat_main_t *vam = &vat_main;
3323 vat_json_node_t *node;
3324 u8 *rate_type_str, *round_type_str, *type_str;
3325 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
3327 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
3329 format (0, "%U", format_policer_round_type, mp->round_type);
3330 type_str = format (0, "%U", format_policer_type, mp->type);
3331 conform_action_str = format (0, "%U", format_policer_action_type,
3332 mp->conform_action_type);
3333 exceed_action_str = format (0, "%U", format_policer_action_type,
3334 mp->exceed_action_type);
3335 violate_action_str = format (0, "%U", format_policer_action_type,
3336 mp->violate_action_type);
3338 if (VAT_JSON_ARRAY != vam->json_tree.type)
3340 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3341 vat_json_init_array (&vam->json_tree);
3343 node = vat_json_array_add (&vam->json_tree);
3345 vat_json_init_object (node);
3346 vat_json_object_add_string_copy (node, "name", mp->name);
3347 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
3348 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
3349 vat_json_object_add_uint (node, "cb", ntohl (mp->cb));
3350 vat_json_object_add_uint (node, "eb", ntohl (mp->eb));
3351 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
3352 vat_json_object_add_string_copy (node, "round_type", round_type_str);
3353 vat_json_object_add_string_copy (node, "type", type_str);
3354 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
3355 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
3356 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
3357 vat_json_object_add_uint (node, "cir_tokens_per_period",
3358 ntohl (mp->cir_tokens_per_period));
3359 vat_json_object_add_uint (node, "eir_tokens_per_period",
3360 ntohl (mp->pir_tokens_per_period));
3361 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
3362 vat_json_object_add_uint (node, "current_bucket",
3363 ntohl (mp->current_bucket));
3364 vat_json_object_add_uint (node, "extended_limit",
3365 ntohl (mp->extended_limit));
3366 vat_json_object_add_uint (node, "extended_bucket",
3367 ntohl (mp->extended_bucket));
3368 vat_json_object_add_uint (node, "last_update_time",
3369 ntohl (mp->last_update_time));
3370 vat_json_object_add_string_copy (node, "conform_action",
3371 conform_action_str);
3372 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3374 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
3375 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
3376 vec_free (dscp_str);
3378 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
3379 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3381 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
3382 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
3383 vec_free (dscp_str);
3385 vat_json_object_add_string_copy (node, "violate_action",
3386 violate_action_str);
3387 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3389 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
3390 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
3391 vec_free (dscp_str);
3394 vec_free (rate_type_str);
3395 vec_free (round_type_str);
3396 vec_free (type_str);
3397 vec_free (conform_action_str);
3398 vec_free (exceed_action_str);
3399 vec_free (violate_action_str);
3403 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
3406 vat_main_t *vam = &vat_main;
3407 int i, count = ntohl (mp->count);
3410 print (vam->ofp, "classify table ids (%d) : ", count);
3411 for (i = 0; i < count; i++)
3413 print (vam->ofp, "%d", ntohl (mp->ids[i]));
3414 print (vam->ofp, (i < count - 1) ? "," : "");
3416 vam->retval = ntohl (mp->retval);
3417 vam->result_ready = 1;
3421 vl_api_classify_table_ids_reply_t_handler_json
3422 (vl_api_classify_table_ids_reply_t * mp)
3424 vat_main_t *vam = &vat_main;
3425 int i, count = ntohl (mp->count);
3429 vat_json_node_t node;
3431 vat_json_init_object (&node);
3432 for (i = 0; i < count; i++)
3434 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
3436 vat_json_print (vam->ofp, &node);
3437 vat_json_free (&node);
3439 vam->retval = ntohl (mp->retval);
3440 vam->result_ready = 1;
3444 vl_api_classify_table_by_interface_reply_t_handler
3445 (vl_api_classify_table_by_interface_reply_t * mp)
3447 vat_main_t *vam = &vat_main;
3450 table_id = ntohl (mp->l2_table_id);
3452 print (vam->ofp, "l2 table id : %d", table_id);
3454 print (vam->ofp, "l2 table id : No input ACL tables configured");
3455 table_id = ntohl (mp->ip4_table_id);
3457 print (vam->ofp, "ip4 table id : %d", table_id);
3459 print (vam->ofp, "ip4 table id : No input ACL tables configured");
3460 table_id = ntohl (mp->ip6_table_id);
3462 print (vam->ofp, "ip6 table id : %d", table_id);
3464 print (vam->ofp, "ip6 table id : No input ACL tables configured");
3465 vam->retval = ntohl (mp->retval);
3466 vam->result_ready = 1;
3470 vl_api_classify_table_by_interface_reply_t_handler_json
3471 (vl_api_classify_table_by_interface_reply_t * mp)
3473 vat_main_t *vam = &vat_main;
3474 vat_json_node_t node;
3476 vat_json_init_object (&node);
3478 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
3479 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
3480 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
3482 vat_json_print (vam->ofp, &node);
3483 vat_json_free (&node);
3485 vam->retval = ntohl (mp->retval);
3486 vam->result_ready = 1;
3489 static void vl_api_policer_add_del_reply_t_handler
3490 (vl_api_policer_add_del_reply_t * mp)
3492 vat_main_t *vam = &vat_main;
3493 i32 retval = ntohl (mp->retval);
3494 if (vam->async_mode)
3496 vam->async_errors += (retval < 0);
3500 vam->retval = retval;
3501 vam->result_ready = 1;
3502 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
3504 * Note: this is just barely thread-safe, depends on
3505 * the main thread spinning waiting for an answer...
3507 errmsg ("policer index %d", ntohl (mp->policer_index));
3511 static void vl_api_policer_add_del_reply_t_handler_json
3512 (vl_api_policer_add_del_reply_t * mp)
3514 vat_main_t *vam = &vat_main;
3515 vat_json_node_t node;
3517 vat_json_init_object (&node);
3518 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3519 vat_json_object_add_uint (&node, "policer_index",
3520 ntohl (mp->policer_index));
3522 vat_json_print (vam->ofp, &node);
3523 vat_json_free (&node);
3525 vam->retval = ntohl (mp->retval);
3526 vam->result_ready = 1;
3529 /* Format hex dump. */
3531 format_hex_bytes (u8 * s, va_list * va)
3533 u8 *bytes = va_arg (*va, u8 *);
3534 int n_bytes = va_arg (*va, int);
3537 /* Print short or long form depending on byte count. */
3538 uword short_form = n_bytes <= 32;
3539 uword indent = format_get_indent (s);
3544 for (i = 0; i < n_bytes; i++)
3546 if (!short_form && (i % 32) == 0)
3547 s = format (s, "%08x: ", i);
3548 s = format (s, "%02x", bytes[i]);
3549 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
3550 s = format (s, "\n%U", format_white_space, indent);
3557 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
3560 vat_main_t *vam = &vat_main;
3561 i32 retval = ntohl (mp->retval);
3564 print (vam->ofp, "classify table info :");
3565 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
3566 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
3567 ntohl (mp->miss_next_index));
3568 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
3569 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
3570 ntohl (mp->match_n_vectors));
3571 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
3572 ntohl (mp->mask_length));
3574 vam->retval = retval;
3575 vam->result_ready = 1;
3579 vl_api_classify_table_info_reply_t_handler_json
3580 (vl_api_classify_table_info_reply_t * mp)
3582 vat_main_t *vam = &vat_main;
3583 vat_json_node_t node;
3585 i32 retval = ntohl (mp->retval);
3588 vat_json_init_object (&node);
3590 vat_json_object_add_int (&node, "sessions",
3591 ntohl (mp->active_sessions));
3592 vat_json_object_add_int (&node, "nexttbl",
3593 ntohl (mp->next_table_index));
3594 vat_json_object_add_int (&node, "nextnode",
3595 ntohl (mp->miss_next_index));
3596 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
3597 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
3598 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
3599 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
3600 ntohl (mp->mask_length), 0);
3601 vat_json_object_add_string_copy (&node, "mask", s);
3603 vat_json_print (vam->ofp, &node);
3604 vat_json_free (&node);
3606 vam->retval = ntohl (mp->retval);
3607 vam->result_ready = 1;
3611 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
3614 vat_main_t *vam = &vat_main;
3616 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
3617 ntohl (mp->hit_next_index), ntohl (mp->advance),
3618 ntohl (mp->opaque_index));
3619 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
3620 ntohl (mp->match_length));
3624 vl_api_classify_session_details_t_handler_json
3625 (vl_api_classify_session_details_t * mp)
3627 vat_main_t *vam = &vat_main;
3628 vat_json_node_t *node = NULL;
3630 if (VAT_JSON_ARRAY != vam->json_tree.type)
3632 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3633 vat_json_init_array (&vam->json_tree);
3635 node = vat_json_array_add (&vam->json_tree);
3637 vat_json_init_object (node);
3638 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
3639 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
3640 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
3642 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
3644 vat_json_object_add_string_copy (node, "match", s);
3647 static void vl_api_pg_create_interface_reply_t_handler
3648 (vl_api_pg_create_interface_reply_t * mp)
3650 vat_main_t *vam = &vat_main;
3652 vam->retval = ntohl (mp->retval);
3653 vam->result_ready = 1;
3656 static void vl_api_pg_create_interface_reply_t_handler_json
3657 (vl_api_pg_create_interface_reply_t * mp)
3659 vat_main_t *vam = &vat_main;
3660 vat_json_node_t node;
3662 i32 retval = ntohl (mp->retval);
3665 vat_json_init_object (&node);
3667 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
3669 vat_json_print (vam->ofp, &node);
3670 vat_json_free (&node);
3672 vam->retval = ntohl (mp->retval);
3673 vam->result_ready = 1;
3676 static void vl_api_policer_classify_details_t_handler
3677 (vl_api_policer_classify_details_t * mp)
3679 vat_main_t *vam = &vat_main;
3681 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
3682 ntohl (mp->table_index));
3685 static void vl_api_policer_classify_details_t_handler_json
3686 (vl_api_policer_classify_details_t * mp)
3688 vat_main_t *vam = &vat_main;
3689 vat_json_node_t *node;
3691 if (VAT_JSON_ARRAY != vam->json_tree.type)
3693 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3694 vat_json_init_array (&vam->json_tree);
3696 node = vat_json_array_add (&vam->json_tree);
3698 vat_json_init_object (node);
3699 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
3700 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
3703 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler
3704 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3706 vat_main_t *vam = &vat_main;
3707 i32 retval = ntohl (mp->retval);
3708 if (vam->async_mode)
3710 vam->async_errors += (retval < 0);
3714 vam->retval = retval;
3715 vam->sw_if_index = ntohl (mp->sw_if_index);
3716 vam->result_ready = 1;
3720 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler_json
3721 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3723 vat_main_t *vam = &vat_main;
3724 vat_json_node_t node;
3726 vat_json_init_object (&node);
3727 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3728 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
3730 vat_json_print (vam->ofp, &node);
3731 vat_json_free (&node);
3733 vam->retval = ntohl (mp->retval);
3734 vam->result_ready = 1;
3737 static void vl_api_flow_classify_details_t_handler
3738 (vl_api_flow_classify_details_t * mp)
3740 vat_main_t *vam = &vat_main;
3742 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
3743 ntohl (mp->table_index));
3746 static void vl_api_flow_classify_details_t_handler_json
3747 (vl_api_flow_classify_details_t * mp)
3749 vat_main_t *vam = &vat_main;
3750 vat_json_node_t *node;
3752 if (VAT_JSON_ARRAY != vam->json_tree.type)
3754 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3755 vat_json_init_array (&vam->json_tree);
3757 node = vat_json_array_add (&vam->json_tree);
3759 vat_json_init_object (node);
3760 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
3761 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
3766 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
3767 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
3768 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
3769 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
3770 #define vl_api_vnet_ip4_nbr_counters_t_endian vl_noop_handler
3771 #define vl_api_vnet_ip4_nbr_counters_t_print vl_noop_handler
3772 #define vl_api_vnet_ip6_nbr_counters_t_endian vl_noop_handler
3773 #define vl_api_vnet_ip6_nbr_counters_t_print vl_noop_handler
3774 #define vl_api_lisp_adjacencies_get_reply_t_endian vl_noop_handler
3775 #define vl_api_lisp_adjacencies_get_reply_t_print vl_noop_handler
3778 * Generate boilerplate reply handlers, which
3779 * dig the return value out of the xxx_reply_t API message,
3780 * stick it into vam->retval, and set vam->result_ready
3782 * Could also do this by pointing N message decode slots at
3783 * a single function, but that could break in subtle ways.
3786 #define foreach_standard_reply_retval_handler \
3787 _(sw_interface_set_flags_reply) \
3788 _(sw_interface_add_del_address_reply) \
3789 _(sw_interface_set_table_reply) \
3790 _(sw_interface_set_mpls_enable_reply) \
3791 _(sw_interface_set_vpath_reply) \
3792 _(sw_interface_set_vxlan_bypass_reply) \
3793 _(sw_interface_set_l2_bridge_reply) \
3794 _(bridge_domain_add_del_reply) \
3795 _(sw_interface_set_l2_xconnect_reply) \
3796 _(l2fib_add_del_reply) \
3797 _(ip_add_del_route_reply) \
3798 _(ip_mroute_add_del_reply) \
3799 _(mpls_route_add_del_reply) \
3800 _(mpls_ip_bind_unbind_reply) \
3801 _(proxy_arp_add_del_reply) \
3802 _(proxy_arp_intfc_enable_disable_reply) \
3803 _(sw_interface_set_unnumbered_reply) \
3804 _(ip_neighbor_add_del_reply) \
3805 _(reset_vrf_reply) \
3806 _(oam_add_del_reply) \
3807 _(reset_fib_reply) \
3808 _(dhcp_proxy_config_reply) \
3809 _(dhcp_proxy_config_2_reply) \
3810 _(dhcp_proxy_set_vss_reply) \
3811 _(dhcp_client_config_reply) \
3812 _(set_ip_flow_hash_reply) \
3813 _(sw_interface_ip6_enable_disable_reply) \
3814 _(sw_interface_ip6_set_link_local_address_reply) \
3815 _(sw_interface_ip6nd_ra_prefix_reply) \
3816 _(sw_interface_ip6nd_ra_config_reply) \
3817 _(set_arp_neighbor_limit_reply) \
3818 _(l2_patch_add_del_reply) \
3819 _(sr_tunnel_add_del_reply) \
3820 _(sr_policy_add_del_reply) \
3821 _(sr_multicast_map_add_del_reply) \
3822 _(classify_add_del_session_reply) \
3823 _(classify_set_interface_ip_table_reply) \
3824 _(classify_set_interface_l2_tables_reply) \
3825 _(l2tpv3_set_tunnel_cookies_reply) \
3826 _(l2tpv3_interface_enable_disable_reply) \
3827 _(l2tpv3_set_lookup_key_reply) \
3828 _(l2_fib_clear_table_reply) \
3829 _(l2_interface_efp_filter_reply) \
3830 _(l2_interface_vlan_tag_rewrite_reply) \
3831 _(modify_vhost_user_if_reply) \
3832 _(delete_vhost_user_if_reply) \
3833 _(want_ip4_arp_events_reply) \
3834 _(want_ip6_nd_events_reply) \
3835 _(input_acl_set_interface_reply) \
3836 _(ipsec_spd_add_del_reply) \
3837 _(ipsec_interface_add_del_spd_reply) \
3838 _(ipsec_spd_add_del_entry_reply) \
3839 _(ipsec_sad_add_del_entry_reply) \
3840 _(ipsec_sa_set_key_reply) \
3841 _(ikev2_profile_add_del_reply) \
3842 _(ikev2_profile_set_auth_reply) \
3843 _(ikev2_profile_set_id_reply) \
3844 _(ikev2_profile_set_ts_reply) \
3845 _(ikev2_set_local_key_reply) \
3846 _(delete_loopback_reply) \
3847 _(bd_ip_mac_add_del_reply) \
3848 _(map_del_domain_reply) \
3849 _(map_add_del_rule_reply) \
3850 _(want_interface_events_reply) \
3851 _(want_stats_reply) \
3852 _(cop_interface_enable_disable_reply) \
3853 _(cop_whitelist_enable_disable_reply) \
3854 _(sw_interface_clear_stats_reply) \
3855 _(ioam_enable_reply) \
3856 _(ioam_disable_reply) \
3857 _(lisp_add_del_locator_reply) \
3858 _(lisp_add_del_local_eid_reply) \
3859 _(lisp_add_del_remote_mapping_reply) \
3860 _(lisp_add_del_adjacency_reply) \
3861 _(lisp_gpe_add_del_fwd_entry_reply) \
3862 _(lisp_add_del_map_resolver_reply) \
3863 _(lisp_add_del_map_server_reply) \
3864 _(lisp_gpe_enable_disable_reply) \
3865 _(lisp_gpe_add_del_iface_reply) \
3866 _(lisp_enable_disable_reply) \
3867 _(lisp_rloc_probe_enable_disable_reply) \
3868 _(lisp_map_register_enable_disable_reply) \
3869 _(lisp_pitr_set_locator_set_reply) \
3870 _(lisp_map_request_mode_reply) \
3871 _(lisp_add_del_map_request_itr_rlocs_reply) \
3872 _(lisp_eid_table_add_del_map_reply) \
3873 _(vxlan_gpe_add_del_tunnel_reply) \
3874 _(af_packet_delete_reply) \
3875 _(policer_classify_set_interface_reply) \
3876 _(netmap_create_reply) \
3877 _(netmap_delete_reply) \
3878 _(set_ipfix_exporter_reply) \
3879 _(set_ipfix_classify_stream_reply) \
3880 _(ipfix_classify_table_add_del_reply) \
3881 _(flow_classify_set_interface_reply) \
3882 _(sw_interface_span_enable_disable_reply) \
3883 _(pg_capture_reply) \
3884 _(pg_enable_disable_reply) \
3885 _(ip_source_and_port_range_check_add_del_reply) \
3886 _(ip_source_and_port_range_check_interface_add_del_reply)\
3887 _(delete_subif_reply) \
3888 _(l2_interface_pbb_tag_rewrite_reply) \
3890 _(feature_enable_disable_reply) \
3891 _(sw_interface_tag_add_del_reply) \
3892 _(sw_interface_set_mtu_reply)
3895 #define foreach_standard_dpdk_reply_retval_handler \
3896 _(sw_interface_set_dpdk_hqos_pipe_reply) \
3897 _(sw_interface_set_dpdk_hqos_subport_reply) \
3898 _(sw_interface_set_dpdk_hqos_tctbl_reply)
3902 static void vl_api_##n##_t_handler \
3903 (vl_api_##n##_t * mp) \
3905 vat_main_t * vam = &vat_main; \
3906 i32 retval = ntohl(mp->retval); \
3907 if (vam->async_mode) { \
3908 vam->async_errors += (retval < 0); \
3910 vam->retval = retval; \
3911 vam->result_ready = 1; \
3914 foreach_standard_reply_retval_handler;
3918 static void vl_api_##n##_t_handler_json \
3919 (vl_api_##n##_t * mp) \
3921 vat_main_t * vam = &vat_main; \
3922 vat_json_node_t node; \
3923 vat_json_init_object(&node); \
3924 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
3925 vat_json_print(vam->ofp, &node); \
3926 vam->retval = ntohl(mp->retval); \
3927 vam->result_ready = 1; \
3929 foreach_standard_reply_retval_handler;
3934 static void vl_api_##n##_t_handler \
3935 (vl_api_##n##_t * mp) \
3937 vat_main_t * vam = &vat_main; \
3938 i32 retval = ntohl(mp->retval); \
3939 if (vam->async_mode) { \
3940 vam->async_errors += (retval < 0); \
3942 vam->retval = retval; \
3943 vam->result_ready = 1; \
3946 foreach_standard_dpdk_reply_retval_handler;
3950 static void vl_api_##n##_t_handler_json \
3951 (vl_api_##n##_t * mp) \
3953 vat_main_t * vam = &vat_main; \
3954 vat_json_node_t node; \
3955 vat_json_init_object(&node); \
3956 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
3957 vat_json_print(vam->ofp, &node); \
3958 vam->retval = ntohl(mp->retval); \
3959 vam->result_ready = 1; \
3961 foreach_standard_dpdk_reply_retval_handler;
3966 * Table of message reply handlers, must include boilerplate handlers
3970 #define foreach_vpe_api_reply_msg \
3971 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
3972 _(SW_INTERFACE_DETAILS, sw_interface_details) \
3973 _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
3974 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
3975 _(CONTROL_PING_REPLY, control_ping_reply) \
3976 _(CLI_REPLY, cli_reply) \
3977 _(CLI_INBAND_REPLY, cli_inband_reply) \
3978 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
3979 sw_interface_add_del_address_reply) \
3980 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
3981 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
3982 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
3983 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
3984 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
3985 sw_interface_set_l2_xconnect_reply) \
3986 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
3987 sw_interface_set_l2_bridge_reply) \
3988 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
3989 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
3990 _(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
3991 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
3992 _(L2_FLAGS_REPLY, l2_flags_reply) \
3993 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
3994 _(TAP_CONNECT_REPLY, tap_connect_reply) \
3995 _(TAP_MODIFY_REPLY, tap_modify_reply) \
3996 _(TAP_DELETE_REPLY, tap_delete_reply) \
3997 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
3998 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
3999 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
4000 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
4001 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
4002 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
4003 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
4004 proxy_arp_intfc_enable_disable_reply) \
4005 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
4006 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
4007 sw_interface_set_unnumbered_reply) \
4008 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
4009 _(RESET_VRF_REPLY, reset_vrf_reply) \
4010 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
4011 _(CREATE_SUBIF_REPLY, create_subif_reply) \
4012 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
4013 _(RESET_FIB_REPLY, reset_fib_reply) \
4014 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
4015 _(DHCP_PROXY_CONFIG_2_REPLY, dhcp_proxy_config_2_reply) \
4016 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
4017 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
4018 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
4019 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
4020 sw_interface_ip6_enable_disable_reply) \
4021 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
4022 sw_interface_ip6_set_link_local_address_reply) \
4023 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
4024 sw_interface_ip6nd_ra_prefix_reply) \
4025 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
4026 sw_interface_ip6nd_ra_config_reply) \
4027 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
4028 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
4029 _(SR_TUNNEL_ADD_DEL_REPLY, sr_tunnel_add_del_reply) \
4030 _(SR_POLICY_ADD_DEL_REPLY, sr_policy_add_del_reply) \
4031 _(SR_MULTICAST_MAP_ADD_DEL_REPLY, sr_multicast_map_add_del_reply) \
4032 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
4033 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
4034 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
4035 classify_set_interface_ip_table_reply) \
4036 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
4037 classify_set_interface_l2_tables_reply) \
4038 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
4039 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
4040 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
4041 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
4042 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
4043 l2tpv3_interface_enable_disable_reply) \
4044 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
4045 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
4046 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
4047 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
4048 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
4049 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
4050 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
4051 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
4052 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
4053 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
4054 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
4055 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
4056 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
4057 _(SHOW_VERSION_REPLY, show_version_reply) \
4058 _(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
4059 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
4060 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
4061 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
4062 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
4063 _(IP4_ARP_EVENT, ip4_arp_event) \
4064 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
4065 _(IP6_ND_EVENT, ip6_nd_event) \
4066 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
4067 _(IP_ADDRESS_DETAILS, ip_address_details) \
4068 _(IP_DETAILS, ip_details) \
4069 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
4070 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
4071 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
4072 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
4073 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
4074 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
4075 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
4076 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
4077 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
4078 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
4079 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
4080 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
4081 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
4082 _(VNET_INTERFACE_COUNTERS, vnet_interface_counters) \
4083 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
4084 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
4085 _(VNET_IP4_NBR_COUNTERS, vnet_ip4_nbr_counters) \
4086 _(VNET_IP6_NBR_COUNTERS, vnet_ip6_nbr_counters) \
4087 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
4088 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
4089 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
4090 _(MAP_DOMAIN_DETAILS, map_domain_details) \
4091 _(MAP_RULE_DETAILS, map_rule_details) \
4092 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
4093 _(WANT_STATS_REPLY, want_stats_reply) \
4094 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
4095 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
4096 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
4097 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
4098 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
4099 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
4100 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
4101 _(LISP_ADD_DEL_LOCATOR_SET_REPLY, lisp_add_del_locator_set_reply) \
4102 _(LISP_ADD_DEL_LOCATOR_REPLY, lisp_add_del_locator_reply) \
4103 _(LISP_ADD_DEL_LOCAL_EID_REPLY, lisp_add_del_local_eid_reply) \
4104 _(LISP_ADD_DEL_REMOTE_MAPPING_REPLY, lisp_add_del_remote_mapping_reply) \
4105 _(LISP_ADD_DEL_ADJACENCY_REPLY, lisp_add_del_adjacency_reply) \
4106 _(LISP_GPE_ADD_DEL_FWD_ENTRY_REPLY, lisp_gpe_add_del_fwd_entry_reply) \
4107 _(LISP_ADD_DEL_MAP_RESOLVER_REPLY, lisp_add_del_map_resolver_reply) \
4108 _(LISP_ADD_DEL_MAP_SERVER_REPLY, lisp_add_del_map_server_reply) \
4109 _(LISP_GPE_ENABLE_DISABLE_REPLY, lisp_gpe_enable_disable_reply) \
4110 _(LISP_ENABLE_DISABLE_REPLY, lisp_enable_disable_reply) \
4111 _(LISP_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
4112 lisp_map_register_enable_disable_reply) \
4113 _(LISP_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
4114 lisp_rloc_probe_enable_disable_reply) \
4115 _(LISP_PITR_SET_LOCATOR_SET_REPLY, lisp_pitr_set_locator_set_reply) \
4116 _(LISP_MAP_REQUEST_MODE_REPLY, lisp_map_request_mode_reply) \
4117 _(LISP_EID_TABLE_ADD_DEL_MAP_REPLY, lisp_eid_table_add_del_map_reply) \
4118 _(LISP_GPE_ADD_DEL_IFACE_REPLY, lisp_gpe_add_del_iface_reply) \
4119 _(LISP_LOCATOR_SET_DETAILS, lisp_locator_set_details) \
4120 _(LISP_LOCATOR_DETAILS, lisp_locator_details) \
4121 _(LISP_EID_TABLE_DETAILS, lisp_eid_table_details) \
4122 _(LISP_EID_TABLE_MAP_DETAILS, lisp_eid_table_map_details) \
4123 _(LISP_EID_TABLE_VNI_DETAILS, lisp_eid_table_vni_details) \
4124 _(LISP_MAP_RESOLVER_DETAILS, lisp_map_resolver_details) \
4125 _(LISP_MAP_SERVER_DETAILS, lisp_map_server_details) \
4126 _(LISP_ADJACENCIES_GET_REPLY, lisp_adjacencies_get_reply) \
4127 _(LISP_GPE_FWD_ENTRIES_GET_REPLY, lisp_gpe_fwd_entries_get_reply) \
4128 _(LISP_GPE_FWD_ENTRY_PATH_DETAILS, \
4129 lisp_gpe_fwd_entry_path_details) \
4130 _(SHOW_LISP_STATUS_REPLY, show_lisp_status_reply) \
4131 _(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
4132 lisp_add_del_map_request_itr_rlocs_reply) \
4133 _(LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
4134 lisp_get_map_request_itr_rlocs_reply) \
4135 _(SHOW_LISP_PITR_REPLY, show_lisp_pitr_reply) \
4136 _(SHOW_LISP_MAP_REQUEST_MODE_REPLY, show_lisp_map_request_mode_reply) \
4137 _(SHOW_LISP_RLOC_PROBE_STATE_REPLY, show_lisp_rloc_probe_state_reply) \
4138 _(SHOW_LISP_MAP_REGISTER_STATE_REPLY, \
4139 show_lisp_map_register_state_reply) \
4140 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
4141 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
4142 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
4143 _(POLICER_DETAILS, policer_details) \
4144 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
4145 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
4146 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
4147 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
4148 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
4149 _(MPLS_FIB_DETAILS, mpls_fib_details) \
4150 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
4151 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
4152 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
4153 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
4154 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
4155 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
4156 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
4157 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
4158 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
4159 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
4160 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
4161 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
4162 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
4163 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
4164 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
4165 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
4166 _(PG_CAPTURE_REPLY, pg_capture_reply) \
4167 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
4168 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
4169 ip_source_and_port_range_check_add_del_reply) \
4170 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
4171 ip_source_and_port_range_check_interface_add_del_reply) \
4172 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
4173 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
4174 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
4175 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
4176 _(PUNT_REPLY, punt_reply) \
4177 _(IP_FIB_DETAILS, ip_fib_details) \
4178 _(IP6_FIB_DETAILS, ip6_fib_details) \
4179 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
4180 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
4181 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
4182 _(SW_INTERFACE_SET_MTU_REPLY, sw_interface_set_mtu_reply) \
4183 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
4184 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply)
4187 #define foreach_vpe_dpdk_api_reply_msg \
4188 _(SW_INTERFACE_SET_DPDK_HQOS_PIPE_REPLY, \
4189 sw_interface_set_dpdk_hqos_pipe_reply) \
4190 _(SW_INTERFACE_SET_DPDK_HQOS_SUBPORT_REPLY, \
4191 sw_interface_set_dpdk_hqos_subport_reply) \
4192 _(SW_INTERFACE_SET_DPDK_HQOS_TCTBL_REPLY, \
4193 sw_interface_set_dpdk_hqos_tctbl_reply)
4203 #define STR_VTR_OP_CASE(op) \
4204 case L2_VTR_ ## op: \
4208 str_vtr_op (u32 vtr_op)
4212 STR_VTR_OP_CASE (DISABLED);
4213 STR_VTR_OP_CASE (PUSH_1);
4214 STR_VTR_OP_CASE (PUSH_2);
4215 STR_VTR_OP_CASE (POP_1);
4216 STR_VTR_OP_CASE (POP_2);
4217 STR_VTR_OP_CASE (TRANSLATE_1_1);
4218 STR_VTR_OP_CASE (TRANSLATE_1_2);
4219 STR_VTR_OP_CASE (TRANSLATE_2_1);
4220 STR_VTR_OP_CASE (TRANSLATE_2_2);
4227 dump_sub_interface_table (vat_main_t * vam)
4229 const sw_interface_subif_t *sub = NULL;
4231 if (vam->json_output)
4234 ("JSON output supported only for VPE API calls and dump_stats_table");
4239 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
4240 "Interface", "sw_if_index",
4241 "sub id", "dot1ad", "tags", "outer id",
4242 "inner id", "exact", "default", "outer any", "inner any");
4244 vec_foreach (sub, vam->sw_if_subif_table)
4247 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
4248 sub->interface_name,
4250 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
4251 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
4252 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
4253 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
4254 if (sub->vtr_op != L2_VTR_DISABLED)
4257 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
4258 "tag1: %d tag2: %d ]",
4259 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
4260 sub->vtr_tag1, sub->vtr_tag2);
4268 name_sort_cmp (void *a1, void *a2)
4270 name_sort_t *n1 = a1;
4271 name_sort_t *n2 = a2;
4273 return strcmp ((char *) n1->name, (char *) n2->name);
4277 dump_interface_table (vat_main_t * vam)
4280 name_sort_t *nses = 0, *ns;
4282 if (vam->json_output)
4285 ("JSON output supported only for VPE API calls and dump_stats_table");
4290 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4292 vec_add2 (nses, ns, 1);
4293 ns->name = (u8 *)(p->key);
4294 ns->value = (u32) p->value[0];
4298 vec_sort_with_function (nses, name_sort_cmp);
4300 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
4301 vec_foreach (ns, nses)
4303 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
4310 dump_ip_table (vat_main_t * vam, int is_ipv6)
4312 const ip_details_t *det = NULL;
4313 const ip_address_details_t *address = NULL;
4316 print (vam->ofp, "%-12s", "sw_if_index");
4318 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
4325 print (vam->ofp, "%-12d", i);
4326 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
4331 vec_foreach (address, det->addr)
4335 is_ipv6 ? format_ip6_address : format_ip4_address,
4336 address->ip, address->prefix_length);
4344 dump_ipv4_table (vat_main_t * vam)
4346 if (vam->json_output)
4349 ("JSON output supported only for VPE API calls and dump_stats_table");
4353 return dump_ip_table (vam, 0);
4357 dump_ipv6_table (vat_main_t * vam)
4359 if (vam->json_output)
4362 ("JSON output supported only for VPE API calls and dump_stats_table");
4366 return dump_ip_table (vam, 1);
4370 counter_type_to_str (u8 counter_type, u8 is_combined)
4374 switch (counter_type)
4376 case VNET_INTERFACE_COUNTER_DROP:
4378 case VNET_INTERFACE_COUNTER_PUNT:
4380 case VNET_INTERFACE_COUNTER_IP4:
4382 case VNET_INTERFACE_COUNTER_IP6:
4384 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
4386 case VNET_INTERFACE_COUNTER_RX_MISS:
4388 case VNET_INTERFACE_COUNTER_RX_ERROR:
4390 case VNET_INTERFACE_COUNTER_TX_ERROR:
4393 return "INVALID-COUNTER-TYPE";
4398 switch (counter_type)
4400 case VNET_INTERFACE_COUNTER_RX:
4402 case VNET_INTERFACE_COUNTER_TX:
4405 return "INVALID-COUNTER-TYPE";
4411 dump_stats_table (vat_main_t * vam)
4413 vat_json_node_t node;
4414 vat_json_node_t *msg_array;
4415 vat_json_node_t *msg;
4416 vat_json_node_t *counter_array;
4417 vat_json_node_t *counter;
4418 interface_counter_t c;
4420 ip4_fib_counter_t *c4;
4421 ip6_fib_counter_t *c6;
4422 ip4_nbr_counter_t *n4;
4423 ip6_nbr_counter_t *n6;
4426 if (!vam->json_output)
4428 clib_warning ("dump_stats_table supported only in JSON format");
4432 vat_json_init_object (&node);
4434 /* interface counters */
4435 msg_array = vat_json_object_add (&node, "interface_counters");
4436 vat_json_init_array (msg_array);
4437 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
4439 msg = vat_json_array_add (msg_array);
4440 vat_json_init_object (msg);
4441 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4442 (u8 *) counter_type_to_str (i, 0));
4443 vat_json_object_add_int (msg, "is_combined", 0);
4444 counter_array = vat_json_object_add (msg, "data");
4445 vat_json_init_array (counter_array);
4446 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
4448 packets = vam->simple_interface_counters[i][j];
4449 vat_json_array_add_uint (counter_array, packets);
4452 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
4454 msg = vat_json_array_add (msg_array);
4455 vat_json_init_object (msg);
4456 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4457 (u8 *) counter_type_to_str (i, 1));
4458 vat_json_object_add_int (msg, "is_combined", 1);
4459 counter_array = vat_json_object_add (msg, "data");
4460 vat_json_init_array (counter_array);
4461 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
4463 c = vam->combined_interface_counters[i][j];
4464 counter = vat_json_array_add (counter_array);
4465 vat_json_init_object (counter);
4466 vat_json_object_add_uint (counter, "packets", c.packets);
4467 vat_json_object_add_uint (counter, "bytes", c.bytes);
4471 /* ip4 fib counters */
4472 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
4473 vat_json_init_array (msg_array);
4474 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
4476 msg = vat_json_array_add (msg_array);
4477 vat_json_init_object (msg);
4478 vat_json_object_add_uint (msg, "vrf_id",
4479 vam->ip4_fib_counters_vrf_id_by_index[i]);
4480 counter_array = vat_json_object_add (msg, "c");
4481 vat_json_init_array (counter_array);
4482 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
4484 counter = vat_json_array_add (counter_array);
4485 vat_json_init_object (counter);
4486 c4 = &vam->ip4_fib_counters[i][j];
4487 vat_json_object_add_ip4 (counter, "address", c4->address);
4488 vat_json_object_add_uint (counter, "address_length",
4489 c4->address_length);
4490 vat_json_object_add_uint (counter, "packets", c4->packets);
4491 vat_json_object_add_uint (counter, "bytes", c4->bytes);
4495 /* ip6 fib counters */
4496 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
4497 vat_json_init_array (msg_array);
4498 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
4500 msg = vat_json_array_add (msg_array);
4501 vat_json_init_object (msg);
4502 vat_json_object_add_uint (msg, "vrf_id",
4503 vam->ip6_fib_counters_vrf_id_by_index[i]);
4504 counter_array = vat_json_object_add (msg, "c");
4505 vat_json_init_array (counter_array);
4506 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
4508 counter = vat_json_array_add (counter_array);
4509 vat_json_init_object (counter);
4510 c6 = &vam->ip6_fib_counters[i][j];
4511 vat_json_object_add_ip6 (counter, "address", c6->address);
4512 vat_json_object_add_uint (counter, "address_length",
4513 c6->address_length);
4514 vat_json_object_add_uint (counter, "packets", c6->packets);
4515 vat_json_object_add_uint (counter, "bytes", c6->bytes);
4519 /* ip4 nbr counters */
4520 msg_array = vat_json_object_add (&node, "ip4_nbr_counters");
4521 vat_json_init_array (msg_array);
4522 for (i = 0; i < vec_len (vam->ip4_nbr_counters); i++)
4524 msg = vat_json_array_add (msg_array);
4525 vat_json_init_object (msg);
4526 vat_json_object_add_uint (msg, "sw_if_index", i);
4527 counter_array = vat_json_object_add (msg, "c");
4528 vat_json_init_array (counter_array);
4529 for (j = 0; j < vec_len (vam->ip4_nbr_counters[i]); j++)
4531 counter = vat_json_array_add (counter_array);
4532 vat_json_init_object (counter);
4533 n4 = &vam->ip4_nbr_counters[i][j];
4534 vat_json_object_add_ip4 (counter, "address", n4->address);
4535 vat_json_object_add_uint (counter, "link-type", n4->linkt);
4536 vat_json_object_add_uint (counter, "packets", n4->packets);
4537 vat_json_object_add_uint (counter, "bytes", n4->bytes);
4541 /* ip6 nbr counters */
4542 msg_array = vat_json_object_add (&node, "ip6_nbr_counters");
4543 vat_json_init_array (msg_array);
4544 for (i = 0; i < vec_len (vam->ip6_nbr_counters); i++)
4546 msg = vat_json_array_add (msg_array);
4547 vat_json_init_object (msg);
4548 vat_json_object_add_uint (msg, "sw_if_index", i);
4549 counter_array = vat_json_object_add (msg, "c");
4550 vat_json_init_array (counter_array);
4551 for (j = 0; j < vec_len (vam->ip6_nbr_counters[i]); j++)
4553 counter = vat_json_array_add (counter_array);
4554 vat_json_init_object (counter);
4555 n6 = &vam->ip6_nbr_counters[i][j];
4556 vat_json_object_add_ip6 (counter, "address", n6->address);
4557 vat_json_object_add_uint (counter, "packets", n6->packets);
4558 vat_json_object_add_uint (counter, "bytes", n6->bytes);
4562 vat_json_print (vam->ofp, &node);
4563 vat_json_free (&node);
4569 exec (vat_main_t * vam)
4571 api_main_t *am = &api_main;
4572 vl_api_cli_request_t *mp;
4576 unformat_input_t *i = vam->input;
4578 if (vec_len (i->buffer) == 0)
4581 if (vam->exec_mode == 0 && unformat (i, "mode"))
4586 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4593 M (CLI_REQUEST, mp);
4596 * Copy cmd into shared memory.
4597 * In order for the CLI command to work, it
4598 * must be a vector ending in \n, not a C-string ending
4601 pthread_mutex_lock (&am->vlib_rp->mutex);
4602 oldheap = svm_push_data_heap (am->vlib_rp);
4604 vec_validate (cmd, vec_len (vam->input->buffer) - 1);
4605 clib_memcpy (cmd, vam->input->buffer, vec_len (vam->input->buffer));
4607 svm_pop_heap (oldheap);
4608 pthread_mutex_unlock (&am->vlib_rp->mutex);
4610 mp->cmd_in_shmem = (u64) cmd;
4612 timeout = vat_time_now (vam) + 10.0;
4614 while (vat_time_now (vam) < timeout)
4616 if (vam->result_ready == 1)
4619 if (vam->shmem_result != NULL)
4620 print (vam->ofp, "%s", vam->shmem_result);
4621 pthread_mutex_lock (&am->vlib_rp->mutex);
4622 oldheap = svm_push_data_heap (am->vlib_rp);
4624 free_me = (u8 *) vam->shmem_result;
4627 svm_pop_heap (oldheap);
4628 pthread_mutex_unlock (&am->vlib_rp->mutex);
4636 * Future replacement of exec() that passes CLI buffers directly in
4637 * the API messages instead of an additional shared memory area.
4640 exec_inband (vat_main_t * vam)
4642 vl_api_cli_inband_t *mp;
4643 unformat_input_t *i = vam->input;
4645 if (vec_len (i->buffer) == 0)
4648 if (vam->exec_mode == 0 && unformat (i, "mode"))
4653 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4660 * In order for the CLI command to work, it
4661 * must be a vector ending in \n, not a C-string ending
4664 u32 len = vec_len (vam->input->buffer);
4665 M2 (CLI_INBAND, mp, len);
4666 clib_memcpy (mp->cmd, vam->input->buffer, len);
4667 mp->length = htonl (len);
4670 W2 (print (vam->ofp, "%s", vam->cmd_reply));
4674 api_create_loopback (vat_main_t * vam)
4676 unformat_input_t *i = vam->input;
4677 vl_api_create_loopback_t *mp;
4681 memset (mac_address, 0, sizeof (mac_address));
4683 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4685 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
4691 /* Construct the API message */
4692 M (CREATE_LOOPBACK, mp);
4694 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
4701 api_delete_loopback (vat_main_t * vam)
4703 unformat_input_t *i = vam->input;
4704 vl_api_delete_loopback_t *mp;
4705 u32 sw_if_index = ~0;
4707 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4709 if (unformat (i, "sw_if_index %d", &sw_if_index))
4715 if (sw_if_index == ~0)
4717 errmsg ("missing sw_if_index");
4721 /* Construct the API message */
4722 M (DELETE_LOOPBACK, mp);
4723 mp->sw_if_index = ntohl (sw_if_index);
4730 api_want_stats (vat_main_t * vam)
4732 unformat_input_t *i = vam->input;
4733 vl_api_want_stats_t *mp;
4736 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4738 if (unformat (i, "enable"))
4740 else if (unformat (i, "disable"))
4748 errmsg ("missing enable|disable");
4753 mp->enable_disable = enable;
4760 api_want_interface_events (vat_main_t * vam)
4762 unformat_input_t *i = vam->input;
4763 vl_api_want_interface_events_t *mp;
4766 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4768 if (unformat (i, "enable"))
4770 else if (unformat (i, "disable"))
4778 errmsg ("missing enable|disable");
4782 M (WANT_INTERFACE_EVENTS, mp);
4783 mp->enable_disable = enable;
4785 vam->interface_event_display = enable;
4792 /* Note: non-static, called once to set up the initial intfc table */
4794 api_sw_interface_dump (vat_main_t * vam)
4796 vl_api_sw_interface_dump_t *mp;
4798 name_sort_t *nses = 0, *ns;
4799 sw_interface_subif_t *sub = NULL;
4801 /* Toss the old name table */
4803 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4805 vec_add2 (nses, ns, 1);
4806 ns->name = (u8 *)(p->key);
4807 ns->value = (u32) p->value[0];
4811 hash_free (vam->sw_if_index_by_interface_name);
4813 vec_foreach (ns, nses) vec_free (ns->name);
4817 vec_foreach (sub, vam->sw_if_subif_table)
4819 vec_free (sub->interface_name);
4821 vec_free (vam->sw_if_subif_table);
4823 /* recreate the interface name hash table */
4824 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
4826 /* Get list of ethernets */
4827 M (SW_INTERFACE_DUMP, mp);
4828 mp->name_filter_valid = 1;
4829 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
4832 /* and local / loopback interfaces */
4833 M (SW_INTERFACE_DUMP, mp);
4834 mp->name_filter_valid = 1;
4835 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
4838 /* and packet-generator interfaces */
4839 M (SW_INTERFACE_DUMP, mp);
4840 mp->name_filter_valid = 1;
4841 strncpy ((char *) mp->name_filter, "pg", sizeof (mp->name_filter) - 1);
4844 /* and vxlan-gpe tunnel interfaces */
4845 M (SW_INTERFACE_DUMP, mp);
4846 mp->name_filter_valid = 1;
4847 strncpy ((char *) mp->name_filter, "vxlan_gpe",
4848 sizeof (mp->name_filter) - 1);
4851 /* and vxlan tunnel interfaces */
4852 M (SW_INTERFACE_DUMP, mp);
4853 mp->name_filter_valid = 1;
4854 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
4857 /* and host (af_packet) interfaces */
4858 M (SW_INTERFACE_DUMP, mp);
4859 mp->name_filter_valid = 1;
4860 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
4863 /* and l2tpv3 tunnel interfaces */
4864 M (SW_INTERFACE_DUMP, mp);
4865 mp->name_filter_valid = 1;
4866 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
4867 sizeof (mp->name_filter) - 1);
4870 /* and GRE tunnel interfaces */
4871 M (SW_INTERFACE_DUMP, mp);
4872 mp->name_filter_valid = 1;
4873 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
4876 /* and LISP-GPE interfaces */
4877 M (SW_INTERFACE_DUMP, mp);
4878 mp->name_filter_valid = 1;
4879 strncpy ((char *) mp->name_filter, "lisp_gpe",
4880 sizeof (mp->name_filter) - 1);
4883 /* and IPSEC tunnel interfaces */
4884 M (SW_INTERFACE_DUMP, mp);
4885 mp->name_filter_valid = 1;
4886 strncpy ((char *) mp->name_filter, "ipsec", sizeof (mp->name_filter) - 1);
4889 /* Use a control ping for synchronization */
4891 vl_api_control_ping_t *mp;
4892 M (CONTROL_PING, mp);
4899 api_sw_interface_set_flags (vat_main_t * vam)
4901 unformat_input_t *i = vam->input;
4902 vl_api_sw_interface_set_flags_t *mp;
4904 u8 sw_if_index_set = 0;
4905 u8 admin_up = 0, link_up = 0;
4907 /* Parse args required to build the message */
4908 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4910 if (unformat (i, "admin-up"))
4912 else if (unformat (i, "admin-down"))
4914 else if (unformat (i, "link-up"))
4916 else if (unformat (i, "link-down"))
4919 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4920 sw_if_index_set = 1;
4921 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4922 sw_if_index_set = 1;
4927 if (sw_if_index_set == 0)
4929 errmsg ("missing interface name or sw_if_index");
4933 /* Construct the API message */
4934 M (SW_INTERFACE_SET_FLAGS, mp);
4935 mp->sw_if_index = ntohl (sw_if_index);
4936 mp->admin_up_down = admin_up;
4937 mp->link_up_down = link_up;
4942 /* Wait for a reply, return the good/bad news... */
4947 api_sw_interface_clear_stats (vat_main_t * vam)
4949 unformat_input_t *i = vam->input;
4950 vl_api_sw_interface_clear_stats_t *mp;
4952 u8 sw_if_index_set = 0;
4954 /* Parse args required to build the message */
4955 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4957 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4958 sw_if_index_set = 1;
4959 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4960 sw_if_index_set = 1;
4965 /* Construct the API message */
4966 M (SW_INTERFACE_CLEAR_STATS, mp);
4968 if (sw_if_index_set == 1)
4969 mp->sw_if_index = ntohl (sw_if_index);
4971 mp->sw_if_index = ~0;
4976 /* Wait for a reply, return the good/bad news... */
4982 api_sw_interface_set_dpdk_hqos_pipe (vat_main_t * vam)
4984 unformat_input_t *i = vam->input;
4985 vl_api_sw_interface_set_dpdk_hqos_pipe_t *mp;
4987 u8 sw_if_index_set = 0;
4995 /* Parse args required to build the message */
4996 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4998 if (unformat (i, "rx %U", api_unformat_sw_if_index, vam, &sw_if_index))
4999 sw_if_index_set = 1;
5000 else if (unformat (i, "sw_if_index %u", &sw_if_index))
5001 sw_if_index_set = 1;
5002 else if (unformat (i, "subport %u", &subport))
5005 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5006 sw_if_index_set = 1;
5007 else if (unformat (i, "pipe %u", &pipe))
5009 else if (unformat (i, "profile %u", &profile))
5015 if (sw_if_index_set == 0)
5017 errmsg ("missing interface name or sw_if_index");
5021 if (subport_set == 0)
5023 errmsg ("missing subport ");
5029 errmsg ("missing pipe");
5033 if (profile_set == 0)
5035 errmsg ("missing profile");
5039 M (SW_INTERFACE_SET_DPDK_HQOS_PIPE, mp);
5041 mp->sw_if_index = ntohl (sw_if_index);
5042 mp->subport = ntohl (subport);
5043 mp->pipe = ntohl (pipe);
5044 mp->profile = ntohl (profile);
5054 api_sw_interface_set_dpdk_hqos_subport (vat_main_t * vam)
5056 unformat_input_t *i = vam->input;
5057 vl_api_sw_interface_set_dpdk_hqos_subport_t *mp;
5059 u8 sw_if_index_set = 0;
5062 u32 tb_rate = 1250000000; /* 10GbE */
5063 u32 tb_size = 1000000;
5064 u32 tc_rate[] = { 1250000000, 1250000000, 1250000000, 1250000000 };
5067 /* Parse args required to build the message */
5068 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5070 if (unformat (i, "rx %U", api_unformat_sw_if_index, vam, &sw_if_index))
5071 sw_if_index_set = 1;
5072 else if (unformat (i, "sw_if_index %u", &sw_if_index))
5073 sw_if_index_set = 1;
5074 else if (unformat (i, "subport %u", &subport))
5077 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5078 sw_if_index_set = 1;
5079 else if (unformat (i, "rate %u", &tb_rate))
5083 for (tc_id = 0; tc_id < (sizeof (tc_rate) / sizeof (tc_rate[0]));
5085 tc_rate[tc_id] = tb_rate;
5087 else if (unformat (i, "bktsize %u", &tb_size))
5089 else if (unformat (i, "tc0 %u", &tc_rate[0]))
5091 else if (unformat (i, "tc1 %u", &tc_rate[1]))
5093 else if (unformat (i, "tc2 %u", &tc_rate[2]))
5095 else if (unformat (i, "tc3 %u", &tc_rate[3]))
5097 else if (unformat (i, "period %u", &tc_period))
5103 if (sw_if_index_set == 0)
5105 errmsg ("missing interface name or sw_if_index");
5109 if (subport_set == 0)
5111 errmsg ("missing subport ");
5115 M (SW_INTERFACE_SET_DPDK_HQOS_SUBPORT, mp);
5117 mp->sw_if_index = ntohl (sw_if_index);
5118 mp->subport = ntohl (subport);
5119 mp->tb_rate = ntohl (tb_rate);
5120 mp->tb_size = ntohl (tb_size);
5121 mp->tc_rate[0] = ntohl (tc_rate[0]);
5122 mp->tc_rate[1] = ntohl (tc_rate[1]);
5123 mp->tc_rate[2] = ntohl (tc_rate[2]);
5124 mp->tc_rate[3] = ntohl (tc_rate[3]);
5125 mp->tc_period = ntohl (tc_period);
5134 api_sw_interface_set_dpdk_hqos_tctbl (vat_main_t * vam)
5136 unformat_input_t *i = vam->input;
5137 vl_api_sw_interface_set_dpdk_hqos_tctbl_t *mp;
5139 u8 sw_if_index_set = 0;
5143 u32 entry, tc, queue;
5145 /* Parse args required to build the message */
5146 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5148 if (unformat (i, "rx %U", api_unformat_sw_if_index, vam, &sw_if_index))
5149 sw_if_index_set = 1;
5150 else if (unformat (i, "sw_if_index %u", &sw_if_index))
5151 sw_if_index_set = 1;
5152 else if (unformat (i, "entry %d", &entry))
5154 else if (unformat (i, "tc %d", &tc))
5156 else if (unformat (i, "queue %d", &queue))
5162 if (sw_if_index_set == 0)
5164 errmsg ("missing interface name or sw_if_index");
5170 errmsg ("missing entry ");
5176 errmsg ("missing traffic class ");
5182 errmsg ("missing queue ");
5186 M (SW_INTERFACE_SET_DPDK_HQOS_TCTBL, mp);
5188 mp->sw_if_index = ntohl (sw_if_index);
5189 mp->entry = ntohl (entry);
5190 mp->tc = ntohl (tc);
5191 mp->queue = ntohl (queue);
5201 api_sw_interface_add_del_address (vat_main_t * vam)
5203 unformat_input_t *i = vam->input;
5204 vl_api_sw_interface_add_del_address_t *mp;
5206 u8 sw_if_index_set = 0;
5207 u8 is_add = 1, del_all = 0;
5208 u32 address_length = 0;
5209 u8 v4_address_set = 0;
5210 u8 v6_address_set = 0;
5211 ip4_address_t v4address;
5212 ip6_address_t v6address;
5214 /* Parse args required to build the message */
5215 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5217 if (unformat (i, "del-all"))
5219 else if (unformat (i, "del"))
5222 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5223 sw_if_index_set = 1;
5224 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5225 sw_if_index_set = 1;
5226 else if (unformat (i, "%U/%d",
5227 unformat_ip4_address, &v4address, &address_length))
5229 else if (unformat (i, "%U/%d",
5230 unformat_ip6_address, &v6address, &address_length))
5236 if (sw_if_index_set == 0)
5238 errmsg ("missing interface name or sw_if_index");
5241 if (v4_address_set && v6_address_set)
5243 errmsg ("both v4 and v6 addresses set");
5246 if (!v4_address_set && !v6_address_set && !del_all)
5248 errmsg ("no addresses set");
5252 /* Construct the API message */
5253 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
5255 mp->sw_if_index = ntohl (sw_if_index);
5256 mp->is_add = is_add;
5257 mp->del_all = del_all;
5261 clib_memcpy (mp->address, &v6address, sizeof (v6address));
5265 clib_memcpy (mp->address, &v4address, sizeof (v4address));
5267 mp->address_length = address_length;
5272 /* Wait for a reply, return good/bad news */
5277 api_sw_interface_set_mpls_enable (vat_main_t * vam)
5279 unformat_input_t *i = vam->input;
5280 vl_api_sw_interface_set_mpls_enable_t *mp;
5282 u8 sw_if_index_set = 0;
5285 /* Parse args required to build the message */
5286 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5288 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5289 sw_if_index_set = 1;
5290 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5291 sw_if_index_set = 1;
5292 else if (unformat (i, "disable"))
5294 else if (unformat (i, "dis"))
5300 if (sw_if_index_set == 0)
5302 errmsg ("missing interface name or sw_if_index");
5306 /* Construct the API message */
5307 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
5309 mp->sw_if_index = ntohl (sw_if_index);
5310 mp->enable = enable;
5315 /* Wait for a reply... */
5320 api_sw_interface_set_table (vat_main_t * vam)
5322 unformat_input_t *i = vam->input;
5323 vl_api_sw_interface_set_table_t *mp;
5324 u32 sw_if_index, vrf_id = 0;
5325 u8 sw_if_index_set = 0;
5328 /* Parse args required to build the message */
5329 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5331 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5332 sw_if_index_set = 1;
5333 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5334 sw_if_index_set = 1;
5335 else if (unformat (i, "vrf %d", &vrf_id))
5337 else if (unformat (i, "ipv6"))
5343 if (sw_if_index_set == 0)
5345 errmsg ("missing interface name or sw_if_index");
5349 /* Construct the API message */
5350 M (SW_INTERFACE_SET_TABLE, mp);
5352 mp->sw_if_index = ntohl (sw_if_index);
5353 mp->is_ipv6 = is_ipv6;
5354 mp->vrf_id = ntohl (vrf_id);
5359 /* Wait for a reply... */
5363 static void vl_api_sw_interface_get_table_reply_t_handler
5364 (vl_api_sw_interface_get_table_reply_t * mp)
5366 vat_main_t *vam = &vat_main;
5368 print (vam->ofp, "%d", ntohl (mp->vrf_id));
5370 vam->retval = ntohl (mp->retval);
5371 vam->result_ready = 1;
5375 static void vl_api_sw_interface_get_table_reply_t_handler_json
5376 (vl_api_sw_interface_get_table_reply_t * mp)
5378 vat_main_t *vam = &vat_main;
5379 vat_json_node_t node;
5381 vat_json_init_object (&node);
5382 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
5383 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
5385 vat_json_print (vam->ofp, &node);
5386 vat_json_free (&node);
5388 vam->retval = ntohl (mp->retval);
5389 vam->result_ready = 1;
5393 api_sw_interface_get_table (vat_main_t * vam)
5395 unformat_input_t *i = vam->input;
5396 vl_api_sw_interface_get_table_t *mp;
5398 u8 sw_if_index_set = 0;
5401 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5403 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5404 sw_if_index_set = 1;
5405 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5406 sw_if_index_set = 1;
5407 else if (unformat (i, "ipv6"))
5413 if (sw_if_index_set == 0)
5415 errmsg ("missing interface name or sw_if_index");
5419 M (SW_INTERFACE_GET_TABLE, mp);
5420 mp->sw_if_index = htonl (sw_if_index);
5421 mp->is_ipv6 = is_ipv6;
5428 api_sw_interface_set_vpath (vat_main_t * vam)
5430 unformat_input_t *i = vam->input;
5431 vl_api_sw_interface_set_vpath_t *mp;
5432 u32 sw_if_index = 0;
5433 u8 sw_if_index_set = 0;
5436 /* Parse args required to build the message */
5437 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5439 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5440 sw_if_index_set = 1;
5441 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5442 sw_if_index_set = 1;
5443 else if (unformat (i, "enable"))
5445 else if (unformat (i, "disable"))
5451 if (sw_if_index_set == 0)
5453 errmsg ("missing interface name or sw_if_index");
5457 /* Construct the API message */
5458 M (SW_INTERFACE_SET_VPATH, mp);
5460 mp->sw_if_index = ntohl (sw_if_index);
5461 mp->enable = is_enable;
5466 /* Wait for a reply... */
5471 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
5473 unformat_input_t *i = vam->input;
5474 vl_api_sw_interface_set_vxlan_bypass_t *mp;
5475 u32 sw_if_index = 0;
5476 u8 sw_if_index_set = 0;
5480 /* Parse args required to build the message */
5481 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5483 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5484 sw_if_index_set = 1;
5485 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5486 sw_if_index_set = 1;
5487 else if (unformat (i, "enable"))
5489 else if (unformat (i, "disable"))
5491 else if (unformat (i, "ip4"))
5493 else if (unformat (i, "ip6"))
5499 if (sw_if_index_set == 0)
5501 errmsg ("missing interface name or sw_if_index");
5505 /* Construct the API message */
5506 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
5508 mp->sw_if_index = ntohl (sw_if_index);
5509 mp->enable = is_enable;
5510 mp->is_ipv6 = is_ipv6;
5515 /* Wait for a reply... */
5520 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
5522 unformat_input_t *i = vam->input;
5523 vl_api_sw_interface_set_l2_xconnect_t *mp;
5525 u8 rx_sw_if_index_set = 0;
5527 u8 tx_sw_if_index_set = 0;
5530 /* Parse args required to build the message */
5531 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5533 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
5534 rx_sw_if_index_set = 1;
5535 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5536 tx_sw_if_index_set = 1;
5537 else if (unformat (i, "rx"))
5539 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5541 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
5543 rx_sw_if_index_set = 1;
5548 else if (unformat (i, "tx"))
5550 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5552 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
5554 tx_sw_if_index_set = 1;
5559 else if (unformat (i, "enable"))
5561 else if (unformat (i, "disable"))
5567 if (rx_sw_if_index_set == 0)
5569 errmsg ("missing rx interface name or rx_sw_if_index");
5573 if (enable && (tx_sw_if_index_set == 0))
5575 errmsg ("missing tx interface name or tx_sw_if_index");
5579 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
5581 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5582 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
5583 mp->enable = enable;
5592 api_sw_interface_set_l2_bridge (vat_main_t * vam)
5594 unformat_input_t *i = vam->input;
5595 vl_api_sw_interface_set_l2_bridge_t *mp;
5597 u8 rx_sw_if_index_set = 0;
5604 /* Parse args required to build the message */
5605 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5607 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
5608 rx_sw_if_index_set = 1;
5609 else if (unformat (i, "bd_id %d", &bd_id))
5613 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
5614 rx_sw_if_index_set = 1;
5615 else if (unformat (i, "shg %d", &shg))
5617 else if (unformat (i, "bvi"))
5619 else if (unformat (i, "enable"))
5621 else if (unformat (i, "disable"))
5627 if (rx_sw_if_index_set == 0)
5629 errmsg ("missing rx interface name or sw_if_index");
5633 if (enable && (bd_id_set == 0))
5635 errmsg ("missing bridge domain");
5639 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
5641 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5642 mp->bd_id = ntohl (bd_id);
5645 mp->enable = enable;
5654 api_bridge_domain_dump (vat_main_t * vam)
5656 unformat_input_t *i = vam->input;
5657 vl_api_bridge_domain_dump_t *mp;
5660 /* Parse args required to build the message */
5661 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5663 if (unformat (i, "bd_id %d", &bd_id))
5669 M (BRIDGE_DOMAIN_DUMP, mp);
5670 mp->bd_id = ntohl (bd_id);
5673 /* Use a control ping for synchronization */
5675 vl_api_control_ping_t *mp;
5676 M (CONTROL_PING, mp);
5686 api_bridge_domain_add_del (vat_main_t * vam)
5688 unformat_input_t *i = vam->input;
5689 vl_api_bridge_domain_add_del_t *mp;
5692 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
5695 /* Parse args required to build the message */
5696 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5698 if (unformat (i, "bd_id %d", &bd_id))
5700 else if (unformat (i, "flood %d", &flood))
5702 else if (unformat (i, "uu-flood %d", &uu_flood))
5704 else if (unformat (i, "forward %d", &forward))
5706 else if (unformat (i, "learn %d", &learn))
5708 else if (unformat (i, "arp-term %d", &arp_term))
5710 else if (unformat (i, "mac-age %d", &mac_age))
5712 else if (unformat (i, "del"))
5715 flood = uu_flood = forward = learn = 0;
5723 errmsg ("missing bridge domain");
5729 errmsg ("mac age must be less than 256 ");
5733 M (BRIDGE_DOMAIN_ADD_DEL, mp);
5735 mp->bd_id = ntohl (bd_id);
5737 mp->uu_flood = uu_flood;
5738 mp->forward = forward;
5740 mp->arp_term = arp_term;
5741 mp->is_add = is_add;
5742 mp->mac_age = (u8) mac_age;
5751 api_l2fib_add_del (vat_main_t * vam)
5753 unformat_input_t *i = vam->input;
5754 vl_api_l2fib_add_del_t *mp;
5760 u32 sw_if_index = ~0;
5761 u8 sw_if_index_set = 0;
5770 /* Parse args required to build the message */
5771 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5773 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
5775 else if (unformat (i, "bd_id %d", &bd_id))
5777 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5778 sw_if_index_set = 1;
5779 else if (unformat (i, "sw_if"))
5781 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5784 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5785 sw_if_index_set = 1;
5790 else if (unformat (i, "static"))
5792 else if (unformat (i, "filter"))
5797 else if (unformat (i, "bvi"))
5802 else if (unformat (i, "del"))
5804 else if (unformat (i, "count %d", &count))
5812 errmsg ("missing mac address");
5818 errmsg ("missing bridge domain");
5822 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
5824 errmsg ("missing interface name or sw_if_index");
5830 /* Turn on async mode */
5831 vam->async_mode = 1;
5832 vam->async_errors = 0;
5833 before = vat_time_now (vam);
5836 for (j = 0; j < count; j++)
5838 M (L2FIB_ADD_DEL, mp);
5841 mp->bd_id = ntohl (bd_id);
5842 mp->is_add = is_add;
5846 mp->sw_if_index = ntohl (sw_if_index);
5847 mp->static_mac = static_mac;
5848 mp->filter_mac = filter_mac;
5849 mp->bvi_mac = bvi_mac;
5851 increment_mac_address (&mac);
5858 vl_api_control_ping_t *mp;
5861 /* Shut off async mode */
5862 vam->async_mode = 0;
5864 M (CONTROL_PING, mp);
5867 timeout = vat_time_now (vam) + 1.0;
5868 while (vat_time_now (vam) < timeout)
5869 if (vam->result_ready == 1)
5874 if (vam->retval == -99)
5877 if (vam->async_errors > 0)
5879 errmsg ("%d asynchronous errors", vam->async_errors);
5882 vam->async_errors = 0;
5883 after = vat_time_now (vam);
5885 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
5886 count, after - before, count / (after - before));
5890 /* Wait for a reply... */
5893 /* Return the good/bad news */
5894 return (vam->retval);
5898 api_l2_flags (vat_main_t * vam)
5900 unformat_input_t *i = vam->input;
5901 vl_api_l2_flags_t *mp;
5903 u32 feature_bitmap = 0;
5904 u8 sw_if_index_set = 0;
5906 /* Parse args required to build the message */
5907 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5909 if (unformat (i, "sw_if_index %d", &sw_if_index))
5910 sw_if_index_set = 1;
5911 else if (unformat (i, "sw_if"))
5913 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5916 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5917 sw_if_index_set = 1;
5922 else if (unformat (i, "learn"))
5923 feature_bitmap |= L2INPUT_FEAT_LEARN;
5924 else if (unformat (i, "forward"))
5925 feature_bitmap |= L2INPUT_FEAT_FWD;
5926 else if (unformat (i, "flood"))
5927 feature_bitmap |= L2INPUT_FEAT_FLOOD;
5928 else if (unformat (i, "uu-flood"))
5929 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
5934 if (sw_if_index_set == 0)
5936 errmsg ("missing interface name or sw_if_index");
5942 mp->sw_if_index = ntohl (sw_if_index);
5943 mp->feature_bitmap = ntohl (feature_bitmap);
5952 api_bridge_flags (vat_main_t * vam)
5954 unformat_input_t *i = vam->input;
5955 vl_api_bridge_flags_t *mp;
5961 /* Parse args required to build the message */
5962 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5964 if (unformat (i, "bd_id %d", &bd_id))
5966 else if (unformat (i, "learn"))
5968 else if (unformat (i, "forward"))
5970 else if (unformat (i, "flood"))
5972 else if (unformat (i, "uu-flood"))
5973 flags |= L2_UU_FLOOD;
5974 else if (unformat (i, "arp-term"))
5975 flags |= L2_ARP_TERM;
5976 else if (unformat (i, "off"))
5978 else if (unformat (i, "disable"))
5986 errmsg ("missing bridge domain");
5990 M (BRIDGE_FLAGS, mp);
5992 mp->bd_id = ntohl (bd_id);
5993 mp->feature_bitmap = ntohl (flags);
5994 mp->is_set = is_set;
6003 api_bd_ip_mac_add_del (vat_main_t * vam)
6005 unformat_input_t *i = vam->input;
6006 vl_api_bd_ip_mac_add_del_t *mp;
6013 ip4_address_t v4addr;
6014 ip6_address_t v6addr;
6018 /* Parse args required to build the message */
6019 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6021 if (unformat (i, "bd_id %d", &bd_id))
6025 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
6029 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
6034 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
6038 else if (unformat (i, "del"))
6046 errmsg ("missing bridge domain");
6049 else if (ip_set == 0)
6051 errmsg ("missing IP address");
6054 else if (mac_set == 0)
6056 errmsg ("missing MAC address");
6060 M (BD_IP_MAC_ADD_DEL, mp);
6062 mp->bd_id = ntohl (bd_id);
6063 mp->is_ipv6 = is_ipv6;
6064 mp->is_add = is_add;
6066 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
6068 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
6069 clib_memcpy (mp->mac_address, macaddr, 6);
6077 api_tap_connect (vat_main_t * vam)
6079 unformat_input_t *i = vam->input;
6080 vl_api_tap_connect_t *mp;
6086 ip4_address_t ip4_address;
6088 int ip4_address_set = 0;
6089 ip6_address_t ip6_address;
6091 int ip6_address_set = 0;
6093 memset (mac_address, 0, sizeof (mac_address));
6095 /* Parse args required to build the message */
6096 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6098 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6102 else if (unformat (i, "random-mac"))
6104 else if (unformat (i, "tapname %s", &tap_name))
6106 else if (unformat (i, "tag %s", &tag))
6108 else if (unformat (i, "address %U/%d",
6109 unformat_ip4_address, &ip4_address, &ip4_mask_width))
6110 ip4_address_set = 1;
6111 else if (unformat (i, "address %U/%d",
6112 unformat_ip6_address, &ip6_address, &ip6_mask_width))
6113 ip6_address_set = 1;
6120 errmsg ("missing tap name");
6123 if (vec_len (tap_name) > 63)
6125 errmsg ("tap name too long");
6128 vec_add1 (tap_name, 0);
6130 if (vec_len (tag) > 63)
6132 errmsg ("tag too long");
6136 /* Construct the API message */
6137 M (TAP_CONNECT, mp);
6139 mp->use_random_mac = random_mac;
6140 clib_memcpy (mp->mac_address, mac_address, 6);
6141 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
6143 clib_memcpy (mp->tag, tag, vec_len (tag));
6145 if (ip4_address_set)
6147 mp->ip4_address_set = 1;
6148 clib_memcpy (mp->ip4_address, &ip4_address, sizeof (mp->ip4_address));
6149 mp->ip4_mask_width = ip4_mask_width;
6151 if (ip6_address_set)
6153 mp->ip6_address_set = 1;
6154 clib_memcpy (mp->ip6_address, &ip6_address, sizeof (mp->ip6_address));
6155 mp->ip6_mask_width = ip6_mask_width;
6158 vec_free (tap_name);
6164 /* Wait for a reply... */
6169 api_tap_modify (vat_main_t * vam)
6171 unformat_input_t *i = vam->input;
6172 vl_api_tap_modify_t *mp;
6177 u32 sw_if_index = ~0;
6178 u8 sw_if_index_set = 0;
6180 memset (mac_address, 0, sizeof (mac_address));
6182 /* Parse args required to build the message */
6183 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6185 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6186 sw_if_index_set = 1;
6187 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6188 sw_if_index_set = 1;
6189 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6193 else if (unformat (i, "random-mac"))
6195 else if (unformat (i, "tapname %s", &tap_name))
6201 if (sw_if_index_set == 0)
6203 errmsg ("missing vpp interface name");
6208 errmsg ("missing tap name");
6211 if (vec_len (tap_name) > 63)
6213 errmsg ("tap name too long");
6215 vec_add1 (tap_name, 0);
6217 /* Construct the API message */
6220 mp->use_random_mac = random_mac;
6221 mp->sw_if_index = ntohl (sw_if_index);
6222 clib_memcpy (mp->mac_address, mac_address, 6);
6223 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
6224 vec_free (tap_name);
6229 /* Wait for a reply... */
6234 api_tap_delete (vat_main_t * vam)
6236 unformat_input_t *i = vam->input;
6237 vl_api_tap_delete_t *mp;
6238 u32 sw_if_index = ~0;
6239 u8 sw_if_index_set = 0;
6241 /* Parse args required to build the message */
6242 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6244 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6245 sw_if_index_set = 1;
6246 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6247 sw_if_index_set = 1;
6252 if (sw_if_index_set == 0)
6254 errmsg ("missing vpp interface name");
6258 /* Construct the API message */
6261 mp->sw_if_index = ntohl (sw_if_index);
6266 /* Wait for a reply... */
6271 api_ip_add_del_route (vat_main_t * vam)
6273 unformat_input_t *i = vam->input;
6274 vl_api_ip_add_del_route_t *mp;
6275 u32 sw_if_index = ~0, vrf_id = 0;
6277 u8 is_local = 0, is_drop = 0;
6278 u8 is_unreach = 0, is_prohibit = 0;
6279 u8 create_vrf_if_needed = 0;
6281 u32 next_hop_weight = 1;
6283 u8 is_multipath = 0;
6285 u8 address_length_set = 0;
6286 u32 next_hop_table_id = 0;
6287 u32 resolve_attempts = 0;
6288 u32 dst_address_length = 0;
6289 u8 next_hop_set = 0;
6290 ip4_address_t v4_dst_address, v4_next_hop_address;
6291 ip6_address_t v6_dst_address, v6_next_hop_address;
6295 u32 random_add_del = 0;
6296 u32 *random_vector = 0;
6298 u32 random_seed = 0xdeaddabe;
6299 u32 classify_table_index = ~0;
6301 u8 resolve_host = 0, resolve_attached = 0;
6302 mpls_label_t *next_hop_out_label_stack = NULL;
6303 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6304 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
6306 /* Parse args required to build the message */
6307 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6309 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6311 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6313 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
6318 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
6323 else if (unformat (i, "/%d", &dst_address_length))
6325 address_length_set = 1;
6328 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
6329 &v4_next_hop_address))
6333 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
6334 &v6_next_hop_address))
6338 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
6340 else if (unformat (i, "weight %d", &next_hop_weight))
6342 else if (unformat (i, "drop"))
6346 else if (unformat (i, "null-send-unreach"))
6350 else if (unformat (i, "null-send-prohibit"))
6354 else if (unformat (i, "local"))
6358 else if (unformat (i, "classify %d", &classify_table_index))
6362 else if (unformat (i, "del"))
6364 else if (unformat (i, "add"))
6366 else if (unformat (i, "not-last"))
6368 else if (unformat (i, "resolve-via-host"))
6370 else if (unformat (i, "resolve-via-attached"))
6371 resolve_attached = 1;
6372 else if (unformat (i, "multipath"))
6374 else if (unformat (i, "vrf %d", &vrf_id))
6376 else if (unformat (i, "create-vrf"))
6377 create_vrf_if_needed = 1;
6378 else if (unformat (i, "count %d", &count))
6380 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
6382 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6384 else if (unformat (i, "out-label %d", &next_hop_out_label))
6385 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
6386 else if (unformat (i, "via-label %d", &next_hop_via_label))
6388 else if (unformat (i, "random"))
6390 else if (unformat (i, "seed %d", &random_seed))
6394 clib_warning ("parse error '%U'", format_unformat_error, i);
6399 if (!next_hop_set && !is_drop && !is_local &&
6400 !is_classify && !is_unreach && !is_prohibit &&
6401 MPLS_LABEL_INVALID == next_hop_via_label)
6404 ("next hop / local / drop / unreach / prohibit / classify not set");
6408 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
6410 errmsg ("next hop and next-hop via label set");
6413 if (address_set == 0)
6415 errmsg ("missing addresses");
6419 if (address_length_set == 0)
6421 errmsg ("missing address length");
6425 /* Generate a pile of unique, random routes */
6428 u32 this_random_address;
6429 random_hash = hash_create (count, sizeof (uword));
6431 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
6432 for (j = 0; j <= count; j++)
6436 this_random_address = random_u32 (&random_seed);
6437 this_random_address =
6438 clib_host_to_net_u32 (this_random_address);
6440 while (hash_get (random_hash, this_random_address));
6441 vec_add1 (random_vector, this_random_address);
6442 hash_set (random_hash, this_random_address, 1);
6444 hash_free (random_hash);
6445 v4_dst_address.as_u32 = random_vector[0];
6450 /* Turn on async mode */
6451 vam->async_mode = 1;
6452 vam->async_errors = 0;
6453 before = vat_time_now (vam);
6456 for (j = 0; j < count; j++)
6458 /* Construct the API message */
6459 M2 (IP_ADD_DEL_ROUTE, mp,
6460 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
6462 mp->next_hop_sw_if_index = ntohl (sw_if_index);
6463 mp->table_id = ntohl (vrf_id);
6464 mp->create_vrf_if_needed = create_vrf_if_needed;
6466 mp->is_add = is_add;
6467 mp->is_drop = is_drop;
6468 mp->is_unreach = is_unreach;
6469 mp->is_prohibit = is_prohibit;
6470 mp->is_ipv6 = is_ipv6;
6471 mp->is_local = is_local;
6472 mp->is_classify = is_classify;
6473 mp->is_multipath = is_multipath;
6474 mp->is_resolve_host = resolve_host;
6475 mp->is_resolve_attached = resolve_attached;
6476 mp->not_last = not_last;
6477 mp->next_hop_weight = next_hop_weight;
6478 mp->dst_address_length = dst_address_length;
6479 mp->next_hop_table_id = ntohl (next_hop_table_id);
6480 mp->classify_table_index = ntohl (classify_table_index);
6481 mp->next_hop_via_label = ntohl (next_hop_via_label);
6482 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
6483 if (0 != mp->next_hop_n_out_labels)
6485 memcpy (mp->next_hop_out_label_stack,
6486 next_hop_out_label_stack,
6487 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
6488 vec_free (next_hop_out_label_stack);
6493 clib_memcpy (mp->dst_address, &v6_dst_address,
6494 sizeof (v6_dst_address));
6496 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
6497 sizeof (v6_next_hop_address));
6498 increment_v6_address (&v6_dst_address);
6502 clib_memcpy (mp->dst_address, &v4_dst_address,
6503 sizeof (v4_dst_address));
6505 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
6506 sizeof (v4_next_hop_address));
6508 v4_dst_address.as_u32 = random_vector[j + 1];
6510 increment_v4_address (&v4_dst_address);
6514 /* If we receive SIGTERM, stop now... */
6519 /* When testing multiple add/del ops, use a control-ping to sync */
6522 vl_api_control_ping_t *mp;
6526 /* Shut off async mode */
6527 vam->async_mode = 0;
6529 M (CONTROL_PING, mp);
6532 timeout = vat_time_now (vam) + 1.0;
6533 while (vat_time_now (vam) < timeout)
6534 if (vam->result_ready == 1)
6539 if (vam->retval == -99)
6542 if (vam->async_errors > 0)
6544 errmsg ("%d asynchronous errors", vam->async_errors);
6547 vam->async_errors = 0;
6548 after = vat_time_now (vam);
6550 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6554 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6555 count, after - before, count / (after - before));
6559 /* Wait for a reply... */
6563 /* Return the good/bad news */
6564 return (vam->retval);
6568 api_ip_mroute_add_del (vat_main_t * vam)
6570 unformat_input_t *i = vam->input;
6571 vl_api_ip_mroute_add_del_t *mp;
6572 u32 sw_if_index = ~0, vrf_id = 0;
6575 u8 create_vrf_if_needed = 0;
6578 u32 grp_address_length = 0;
6579 ip4_address_t v4_grp_address, v4_src_address;
6580 ip6_address_t v6_grp_address, v6_src_address;
6581 mfib_itf_flags_t iflags = 0;
6582 mfib_entry_flags_t eflags = 0;
6584 /* Parse args required to build the message */
6585 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6587 if (unformat (i, "sw_if_index %d", &sw_if_index))
6589 else if (unformat (i, "%U %U",
6590 unformat_ip4_address, &v4_src_address,
6591 unformat_ip4_address, &v4_grp_address))
6593 grp_address_length = 64;
6597 else if (unformat (i, "%U %U",
6598 unformat_ip6_address, &v6_src_address,
6599 unformat_ip6_address, &v6_grp_address))
6601 grp_address_length = 256;
6605 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
6607 memset (&v4_src_address, 0, sizeof (v4_src_address));
6608 grp_address_length = 32;
6612 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
6614 memset (&v6_src_address, 0, sizeof (v6_src_address));
6615 grp_address_length = 128;
6619 else if (unformat (i, "/%d", &grp_address_length))
6621 else if (unformat (i, "local"))
6625 else if (unformat (i, "del"))
6627 else if (unformat (i, "add"))
6629 else if (unformat (i, "vrf %d", &vrf_id))
6631 else if (unformat (i, "create-vrf"))
6632 create_vrf_if_needed = 1;
6633 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
6635 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
6639 clib_warning ("parse error '%U'", format_unformat_error, i);
6644 if (address_set == 0)
6646 errmsg ("missing addresses\n");
6650 /* Construct the API message */
6651 M (IP_MROUTE_ADD_DEL, mp);
6653 mp->next_hop_sw_if_index = ntohl (sw_if_index);
6654 mp->table_id = ntohl (vrf_id);
6655 mp->create_vrf_if_needed = create_vrf_if_needed;
6657 mp->is_add = is_add;
6658 mp->is_ipv6 = is_ipv6;
6659 mp->is_local = is_local;
6660 mp->itf_flags = ntohl (iflags);
6661 mp->entry_flags = ntohl (eflags);
6662 mp->grp_address_length = grp_address_length;
6663 mp->grp_address_length = ntohs (mp->grp_address_length);
6667 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
6668 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
6672 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
6673 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
6679 /* Wait for a reply... */
6684 api_mpls_route_add_del (vat_main_t * vam)
6686 unformat_input_t *i = vam->input;
6687 vl_api_mpls_route_add_del_t *mp;
6688 u32 sw_if_index = ~0, table_id = 0;
6689 u8 create_table_if_needed = 0;
6691 u32 next_hop_weight = 1;
6692 u8 is_multipath = 0;
6693 u32 next_hop_table_id = 0;
6694 u8 next_hop_set = 0;
6695 ip4_address_t v4_next_hop_address = {
6698 ip6_address_t v6_next_hop_address = { {0} };
6702 u32 classify_table_index = ~0;
6704 u8 resolve_host = 0, resolve_attached = 0;
6705 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
6706 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6707 mpls_label_t *next_hop_out_label_stack = NULL;
6708 mpls_label_t local_label = MPLS_LABEL_INVALID;
6710 u8 next_hop_proto_is_ip4 = 1;
6712 /* Parse args required to build the message */
6713 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6715 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6717 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6719 else if (unformat (i, "%d", &local_label))
6721 else if (unformat (i, "eos"))
6723 else if (unformat (i, "non-eos"))
6725 else if (unformat (i, "via %U", unformat_ip4_address,
6726 &v4_next_hop_address))
6729 next_hop_proto_is_ip4 = 1;
6731 else if (unformat (i, "via %U", unformat_ip6_address,
6732 &v6_next_hop_address))
6735 next_hop_proto_is_ip4 = 0;
6737 else if (unformat (i, "weight %d", &next_hop_weight))
6739 else if (unformat (i, "create-table"))
6740 create_table_if_needed = 1;
6741 else if (unformat (i, "classify %d", &classify_table_index))
6745 else if (unformat (i, "del"))
6747 else if (unformat (i, "add"))
6749 else if (unformat (i, "resolve-via-host"))
6751 else if (unformat (i, "resolve-via-attached"))
6752 resolve_attached = 1;
6753 else if (unformat (i, "multipath"))
6755 else if (unformat (i, "count %d", &count))
6757 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
6760 next_hop_proto_is_ip4 = 1;
6762 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
6765 next_hop_proto_is_ip4 = 0;
6767 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6769 else if (unformat (i, "via-label %d", &next_hop_via_label))
6771 else if (unformat (i, "out-label %d", &next_hop_out_label))
6772 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
6775 clib_warning ("parse error '%U'", format_unformat_error, i);
6780 if (!next_hop_set && !is_classify)
6782 errmsg ("next hop / classify not set");
6786 if (MPLS_LABEL_INVALID == local_label)
6788 errmsg ("missing label");
6794 /* Turn on async mode */
6795 vam->async_mode = 1;
6796 vam->async_errors = 0;
6797 before = vat_time_now (vam);
6800 for (j = 0; j < count; j++)
6802 /* Construct the API message */
6803 M2 (MPLS_ROUTE_ADD_DEL, mp,
6804 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
6806 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
6807 mp->mr_table_id = ntohl (table_id);
6808 mp->mr_create_table_if_needed = create_table_if_needed;
6810 mp->mr_is_add = is_add;
6811 mp->mr_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
6812 mp->mr_is_classify = is_classify;
6813 mp->mr_is_multipath = is_multipath;
6814 mp->mr_is_resolve_host = resolve_host;
6815 mp->mr_is_resolve_attached = resolve_attached;
6816 mp->mr_next_hop_weight = next_hop_weight;
6817 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
6818 mp->mr_classify_table_index = ntohl (classify_table_index);
6819 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
6820 mp->mr_label = ntohl (local_label);
6821 mp->mr_eos = is_eos;
6823 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
6824 if (0 != mp->mr_next_hop_n_out_labels)
6826 memcpy (mp->mr_next_hop_out_label_stack,
6827 next_hop_out_label_stack,
6828 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
6829 vec_free (next_hop_out_label_stack);
6834 if (next_hop_proto_is_ip4)
6836 clib_memcpy (mp->mr_next_hop,
6837 &v4_next_hop_address,
6838 sizeof (v4_next_hop_address));
6842 clib_memcpy (mp->mr_next_hop,
6843 &v6_next_hop_address,
6844 sizeof (v6_next_hop_address));
6851 /* If we receive SIGTERM, stop now... */
6856 /* When testing multiple add/del ops, use a control-ping to sync */
6859 vl_api_control_ping_t *mp;
6863 /* Shut off async mode */
6864 vam->async_mode = 0;
6866 M (CONTROL_PING, mp);
6869 timeout = vat_time_now (vam) + 1.0;
6870 while (vat_time_now (vam) < timeout)
6871 if (vam->result_ready == 1)
6876 if (vam->retval == -99)
6879 if (vam->async_errors > 0)
6881 errmsg ("%d asynchronous errors", vam->async_errors);
6884 vam->async_errors = 0;
6885 after = vat_time_now (vam);
6887 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6891 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6892 count, after - before, count / (after - before));
6896 /* Wait for a reply... */
6900 /* Return the good/bad news */
6901 return (vam->retval);
6905 api_mpls_ip_bind_unbind (vat_main_t * vam)
6907 unformat_input_t *i = vam->input;
6908 vl_api_mpls_ip_bind_unbind_t *mp;
6909 u32 ip_table_id = 0;
6910 u8 create_table_if_needed = 0;
6913 ip4_address_t v4_address;
6914 ip6_address_t v6_address;
6917 mpls_label_t local_label = MPLS_LABEL_INVALID;
6919 /* Parse args required to build the message */
6920 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6922 if (unformat (i, "%U/%d", unformat_ip4_address,
6923 &v4_address, &address_length))
6928 else if (unformat (i, "%U/%d", unformat_ip6_address,
6929 &v6_address, &address_length))
6934 else if (unformat (i, "%d", &local_label))
6936 else if (unformat (i, "create-table"))
6937 create_table_if_needed = 1;
6938 else if (unformat (i, "table-id %d", &ip_table_id))
6940 else if (unformat (i, "unbind"))
6942 else if (unformat (i, "bind"))
6946 clib_warning ("parse error '%U'", format_unformat_error, i);
6953 errmsg ("IP addres not set");
6957 if (MPLS_LABEL_INVALID == local_label)
6959 errmsg ("missing label");
6963 /* Construct the API message */
6964 M (MPLS_IP_BIND_UNBIND, mp);
6966 mp->mb_create_table_if_needed = create_table_if_needed;
6967 mp->mb_is_bind = is_bind;
6968 mp->mb_is_ip4 = is_ip4;
6969 mp->mb_ip_table_id = ntohl (ip_table_id);
6970 mp->mb_mpls_table_id = 0;
6971 mp->mb_label = ntohl (local_label);
6972 mp->mb_address_length = address_length;
6975 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
6977 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
6982 /* Wait for a reply... */
6987 api_proxy_arp_add_del (vat_main_t * vam)
6989 unformat_input_t *i = vam->input;
6990 vl_api_proxy_arp_add_del_t *mp;
6993 ip4_address_t lo, hi;
6996 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6998 if (unformat (i, "vrf %d", &vrf_id))
7000 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
7001 unformat_ip4_address, &hi))
7003 else if (unformat (i, "del"))
7007 clib_warning ("parse error '%U'", format_unformat_error, i);
7014 errmsg ("address range not set");
7018 M (PROXY_ARP_ADD_DEL, mp);
7020 mp->vrf_id = ntohl (vrf_id);
7021 mp->is_add = is_add;
7022 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
7023 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
7032 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
7034 unformat_input_t *i = vam->input;
7035 vl_api_proxy_arp_intfc_enable_disable_t *mp;
7038 u8 sw_if_index_set = 0;
7040 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7042 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7043 sw_if_index_set = 1;
7044 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7045 sw_if_index_set = 1;
7046 else if (unformat (i, "enable"))
7048 else if (unformat (i, "disable"))
7052 clib_warning ("parse error '%U'", format_unformat_error, i);
7057 if (sw_if_index_set == 0)
7059 errmsg ("missing interface name or sw_if_index");
7063 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
7065 mp->sw_if_index = ntohl (sw_if_index);
7066 mp->enable_disable = enable;
7075 api_mpls_tunnel_add_del (vat_main_t * vam)
7077 unformat_input_t *i = vam->input;
7078 vl_api_mpls_tunnel_add_del_t *mp;
7082 u32 sw_if_index = ~0;
7083 u32 next_hop_sw_if_index = ~0;
7084 u32 next_hop_proto_is_ip4 = 1;
7086 u32 next_hop_table_id = 0;
7087 ip4_address_t v4_next_hop_address = {
7090 ip6_address_t v6_next_hop_address = { {0} };
7091 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID, *labels = NULL;
7093 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7095 if (unformat (i, "add"))
7097 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
7099 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
7101 else if (unformat (i, "via %U",
7102 unformat_ip4_address, &v4_next_hop_address))
7104 next_hop_proto_is_ip4 = 1;
7106 else if (unformat (i, "via %U",
7107 unformat_ip6_address, &v6_next_hop_address))
7109 next_hop_proto_is_ip4 = 0;
7111 else if (unformat (i, "l2-only"))
7113 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
7115 else if (unformat (i, "out-label %d", &next_hop_out_label))
7116 vec_add1 (labels, ntohl (next_hop_out_label));
7119 clib_warning ("parse error '%U'", format_unformat_error, i);
7124 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (mpls_label_t) * vec_len (labels));
7126 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
7127 mp->mt_sw_if_index = ntohl (sw_if_index);
7128 mp->mt_is_add = is_add;
7129 mp->mt_l2_only = l2_only;
7130 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
7131 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
7133 mp->mt_next_hop_n_out_labels = vec_len (labels);
7135 if (0 != mp->mt_next_hop_n_out_labels)
7137 clib_memcpy (mp->mt_next_hop_out_label_stack, labels,
7138 sizeof (mpls_label_t) * mp->mt_next_hop_n_out_labels);
7142 if (next_hop_proto_is_ip4)
7144 clib_memcpy (mp->mt_next_hop,
7145 &v4_next_hop_address, sizeof (v4_next_hop_address));
7149 clib_memcpy (mp->mt_next_hop,
7150 &v6_next_hop_address, sizeof (v6_next_hop_address));
7160 api_sw_interface_set_unnumbered (vat_main_t * vam)
7162 unformat_input_t *i = vam->input;
7163 vl_api_sw_interface_set_unnumbered_t *mp;
7165 u32 unnum_sw_index = ~0;
7167 u8 sw_if_index_set = 0;
7169 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7171 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7172 sw_if_index_set = 1;
7173 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7174 sw_if_index_set = 1;
7175 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
7177 else if (unformat (i, "del"))
7181 clib_warning ("parse error '%U'", format_unformat_error, i);
7186 if (sw_if_index_set == 0)
7188 errmsg ("missing interface name or sw_if_index");
7192 M (SW_INTERFACE_SET_UNNUMBERED, mp);
7194 mp->sw_if_index = ntohl (sw_if_index);
7195 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
7196 mp->is_add = is_add;
7205 api_ip_neighbor_add_del (vat_main_t * vam)
7207 unformat_input_t *i = vam->input;
7208 vl_api_ip_neighbor_add_del_t *mp;
7210 u8 sw_if_index_set = 0;
7216 u8 v4_address_set = 0;
7217 u8 v6_address_set = 0;
7218 ip4_address_t v4address;
7219 ip6_address_t v6address;
7221 memset (mac_address, 0, sizeof (mac_address));
7223 /* Parse args required to build the message */
7224 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7226 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
7230 else if (unformat (i, "del"))
7233 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7234 sw_if_index_set = 1;
7235 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7236 sw_if_index_set = 1;
7237 else if (unformat (i, "is_static"))
7239 else if (unformat (i, "vrf %d", &vrf_id))
7241 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
7243 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
7247 clib_warning ("parse error '%U'", format_unformat_error, i);
7252 if (sw_if_index_set == 0)
7254 errmsg ("missing interface name or sw_if_index");
7257 if (v4_address_set && v6_address_set)
7259 errmsg ("both v4 and v6 addresses set");
7262 if (!v4_address_set && !v6_address_set)
7264 errmsg ("no address set");
7268 /* Construct the API message */
7269 M (IP_NEIGHBOR_ADD_DEL, mp);
7271 mp->sw_if_index = ntohl (sw_if_index);
7272 mp->is_add = is_add;
7273 mp->vrf_id = ntohl (vrf_id);
7274 mp->is_static = is_static;
7276 clib_memcpy (mp->mac_address, mac_address, 6);
7280 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
7284 /* mp->is_ipv6 = 0; via memset in M macro above */
7285 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
7291 /* Wait for a reply, return good/bad news */
7299 api_reset_vrf (vat_main_t * vam)
7301 unformat_input_t *i = vam->input;
7302 vl_api_reset_vrf_t *mp;
7307 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7309 if (unformat (i, "vrf %d", &vrf_id))
7311 else if (unformat (i, "ipv6"))
7315 clib_warning ("parse error '%U'", format_unformat_error, i);
7320 if (vrf_id_set == 0)
7322 errmsg ("missing vrf id");
7328 mp->vrf_id = ntohl (vrf_id);
7329 mp->is_ipv6 = is_ipv6;
7338 api_create_vlan_subif (vat_main_t * vam)
7340 unformat_input_t *i = vam->input;
7341 vl_api_create_vlan_subif_t *mp;
7343 u8 sw_if_index_set = 0;
7347 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7349 if (unformat (i, "sw_if_index %d", &sw_if_index))
7350 sw_if_index_set = 1;
7352 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7353 sw_if_index_set = 1;
7354 else if (unformat (i, "vlan %d", &vlan_id))
7358 clib_warning ("parse error '%U'", format_unformat_error, i);
7363 if (sw_if_index_set == 0)
7365 errmsg ("missing interface name or sw_if_index");
7369 if (vlan_id_set == 0)
7371 errmsg ("missing vlan_id");
7374 M (CREATE_VLAN_SUBIF, mp);
7376 mp->sw_if_index = ntohl (sw_if_index);
7377 mp->vlan_id = ntohl (vlan_id);
7385 #define foreach_create_subif_bit \
7392 _(outer_vlan_id_any) \
7393 _(inner_vlan_id_any)
7396 api_create_subif (vat_main_t * vam)
7398 unformat_input_t *i = vam->input;
7399 vl_api_create_subif_t *mp;
7401 u8 sw_if_index_set = 0;
7408 u32 exact_match = 0;
7409 u32 default_sub = 0;
7410 u32 outer_vlan_id_any = 0;
7411 u32 inner_vlan_id_any = 0;
7413 u16 outer_vlan_id = 0;
7414 u16 inner_vlan_id = 0;
7416 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7418 if (unformat (i, "sw_if_index %d", &sw_if_index))
7419 sw_if_index_set = 1;
7421 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7422 sw_if_index_set = 1;
7423 else if (unformat (i, "sub_id %d", &sub_id))
7425 else if (unformat (i, "outer_vlan_id %d", &tmp))
7426 outer_vlan_id = tmp;
7427 else if (unformat (i, "inner_vlan_id %d", &tmp))
7428 inner_vlan_id = tmp;
7430 #define _(a) else if (unformat (i, #a)) a = 1 ;
7431 foreach_create_subif_bit
7435 clib_warning ("parse error '%U'", format_unformat_error, i);
7440 if (sw_if_index_set == 0)
7442 errmsg ("missing interface name or sw_if_index");
7446 if (sub_id_set == 0)
7448 errmsg ("missing sub_id");
7451 M (CREATE_SUBIF, mp);
7453 mp->sw_if_index = ntohl (sw_if_index);
7454 mp->sub_id = ntohl (sub_id);
7456 #define _(a) mp->a = a;
7457 foreach_create_subif_bit;
7460 mp->outer_vlan_id = ntohs (outer_vlan_id);
7461 mp->inner_vlan_id = ntohs (inner_vlan_id);
7470 api_oam_add_del (vat_main_t * vam)
7472 unformat_input_t *i = vam->input;
7473 vl_api_oam_add_del_t *mp;
7476 ip4_address_t src, dst;
7480 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7482 if (unformat (i, "vrf %d", &vrf_id))
7484 else if (unformat (i, "src %U", unformat_ip4_address, &src))
7486 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
7488 else if (unformat (i, "del"))
7492 clib_warning ("parse error '%U'", format_unformat_error, i);
7499 errmsg ("missing src addr");
7505 errmsg ("missing dst addr");
7509 M (OAM_ADD_DEL, mp);
7511 mp->vrf_id = ntohl (vrf_id);
7512 mp->is_add = is_add;
7513 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
7514 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
7523 api_reset_fib (vat_main_t * vam)
7525 unformat_input_t *i = vam->input;
7526 vl_api_reset_fib_t *mp;
7531 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7533 if (unformat (i, "vrf %d", &vrf_id))
7535 else if (unformat (i, "ipv6"))
7539 clib_warning ("parse error '%U'", format_unformat_error, i);
7544 if (vrf_id_set == 0)
7546 errmsg ("missing vrf id");
7552 mp->vrf_id = ntohl (vrf_id);
7553 mp->is_ipv6 = is_ipv6;
7562 api_dhcp_proxy_config (vat_main_t * vam)
7564 unformat_input_t *i = vam->input;
7565 vl_api_dhcp_proxy_config_t *mp;
7569 u8 v4_address_set = 0;
7570 u8 v6_address_set = 0;
7571 ip4_address_t v4address;
7572 ip6_address_t v6address;
7573 u8 v4_src_address_set = 0;
7574 u8 v6_src_address_set = 0;
7575 ip4_address_t v4srcaddress;
7576 ip6_address_t v6srcaddress;
7578 /* Parse args required to build the message */
7579 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7581 if (unformat (i, "del"))
7583 else if (unformat (i, "vrf %d", &vrf_id))
7585 else if (unformat (i, "insert-cid %d", &insert_cid))
7587 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
7589 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
7591 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
7592 v4_src_address_set = 1;
7593 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
7594 v6_src_address_set = 1;
7599 if (v4_address_set && v6_address_set)
7601 errmsg ("both v4 and v6 server addresses set");
7604 if (!v4_address_set && !v6_address_set)
7606 errmsg ("no server addresses set");
7610 if (v4_src_address_set && v6_src_address_set)
7612 errmsg ("both v4 and v6 src addresses set");
7615 if (!v4_src_address_set && !v6_src_address_set)
7617 errmsg ("no src addresses set");
7621 if (!(v4_src_address_set && v4_address_set) &&
7622 !(v6_src_address_set && v6_address_set))
7624 errmsg ("no matching server and src addresses set");
7628 /* Construct the API message */
7629 M (DHCP_PROXY_CONFIG, mp);
7631 mp->insert_circuit_id = insert_cid;
7632 mp->is_add = is_add;
7633 mp->vrf_id = ntohl (vrf_id);
7637 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
7638 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
7642 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
7643 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
7649 /* Wait for a reply, return good/bad news */
7656 api_dhcp_proxy_config_2 (vat_main_t * vam)
7658 unformat_input_t *i = vam->input;
7659 vl_api_dhcp_proxy_config_2_t *mp;
7661 u32 server_vrf_id = 0;
7664 u8 v4_address_set = 0;
7665 u8 v6_address_set = 0;
7666 ip4_address_t v4address;
7667 ip6_address_t v6address;
7668 u8 v4_src_address_set = 0;
7669 u8 v6_src_address_set = 0;
7670 ip4_address_t v4srcaddress;
7671 ip6_address_t v6srcaddress;
7673 /* Parse args required to build the message */
7674 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7676 if (unformat (i, "del"))
7678 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
7680 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
7682 else if (unformat (i, "insert-cid %d", &insert_cid))
7684 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
7686 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
7688 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
7689 v4_src_address_set = 1;
7690 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
7691 v6_src_address_set = 1;
7696 if (v4_address_set && v6_address_set)
7698 errmsg ("both v4 and v6 server addresses set");
7701 if (!v4_address_set && !v6_address_set)
7703 errmsg ("no server addresses set");
7707 if (v4_src_address_set && v6_src_address_set)
7709 errmsg ("both v4 and v6 src addresses set");
7712 if (!v4_src_address_set && !v6_src_address_set)
7714 errmsg ("no src addresses set");
7718 if (!(v4_src_address_set && v4_address_set) &&
7719 !(v6_src_address_set && v6_address_set))
7721 errmsg ("no matching server and src addresses set");
7725 /* Construct the API message */
7726 M (DHCP_PROXY_CONFIG_2, mp);
7728 mp->insert_circuit_id = insert_cid;
7729 mp->is_add = is_add;
7730 mp->rx_vrf_id = ntohl (rx_vrf_id);
7731 mp->server_vrf_id = ntohl (server_vrf_id);
7735 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
7736 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
7740 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
7741 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
7747 /* Wait for a reply, return good/bad news */
7754 api_dhcp_proxy_set_vss (vat_main_t * vam)
7756 unformat_input_t *i = vam->input;
7757 vl_api_dhcp_proxy_set_vss_t *mp;
7767 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7769 if (unformat (i, "tbl_id %d", &tbl_id))
7771 if (unformat (i, "fib_id %d", &fib_id))
7773 if (unformat (i, "oui %d", &oui))
7775 else if (unformat (i, "ipv6"))
7777 else if (unformat (i, "del"))
7781 clib_warning ("parse error '%U'", format_unformat_error, i);
7786 if (tbl_id_set == 0)
7788 errmsg ("missing tbl id");
7792 if (fib_id_set == 0)
7794 errmsg ("missing fib id");
7799 errmsg ("missing oui");
7803 M (DHCP_PROXY_SET_VSS, mp);
7804 mp->tbl_id = ntohl (tbl_id);
7805 mp->fib_id = ntohl (fib_id);
7806 mp->oui = ntohl (oui);
7807 mp->is_ipv6 = is_ipv6;
7808 mp->is_add = is_add;
7817 api_dhcp_client_config (vat_main_t * vam)
7819 unformat_input_t *i = vam->input;
7820 vl_api_dhcp_client_config_t *mp;
7822 u8 sw_if_index_set = 0;
7825 u8 disable_event = 0;
7827 /* Parse args required to build the message */
7828 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7830 if (unformat (i, "del"))
7833 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7834 sw_if_index_set = 1;
7835 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7836 sw_if_index_set = 1;
7837 else if (unformat (i, "hostname %s", &hostname))
7839 else if (unformat (i, "disable_event"))
7845 if (sw_if_index_set == 0)
7847 errmsg ("missing interface name or sw_if_index");
7851 if (vec_len (hostname) > 63)
7853 errmsg ("hostname too long");
7855 vec_add1 (hostname, 0);
7857 /* Construct the API message */
7858 M (DHCP_CLIENT_CONFIG, mp);
7860 mp->sw_if_index = ntohl (sw_if_index);
7861 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
7862 vec_free (hostname);
7863 mp->is_add = is_add;
7864 mp->want_dhcp_event = disable_event ? 0 : 1;
7865 mp->pid = getpid ();
7870 /* Wait for a reply, return good/bad news */
7877 api_set_ip_flow_hash (vat_main_t * vam)
7879 unformat_input_t *i = vam->input;
7880 vl_api_set_ip_flow_hash_t *mp;
7891 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7893 if (unformat (i, "vrf %d", &vrf_id))
7895 else if (unformat (i, "ipv6"))
7897 else if (unformat (i, "src"))
7899 else if (unformat (i, "dst"))
7901 else if (unformat (i, "sport"))
7903 else if (unformat (i, "dport"))
7905 else if (unformat (i, "proto"))
7907 else if (unformat (i, "reverse"))
7912 clib_warning ("parse error '%U'", format_unformat_error, i);
7917 if (vrf_id_set == 0)
7919 errmsg ("missing vrf id");
7923 M (SET_IP_FLOW_HASH, mp);
7929 mp->reverse = reverse;
7930 mp->vrf_id = ntohl (vrf_id);
7931 mp->is_ipv6 = is_ipv6;
7940 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
7942 unformat_input_t *i = vam->input;
7943 vl_api_sw_interface_ip6_enable_disable_t *mp;
7945 u8 sw_if_index_set = 0;
7948 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7950 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7951 sw_if_index_set = 1;
7952 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7953 sw_if_index_set = 1;
7954 else if (unformat (i, "enable"))
7956 else if (unformat (i, "disable"))
7960 clib_warning ("parse error '%U'", format_unformat_error, i);
7965 if (sw_if_index_set == 0)
7967 errmsg ("missing interface name or sw_if_index");
7971 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
7973 mp->sw_if_index = ntohl (sw_if_index);
7974 mp->enable = enable;
7983 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
7985 unformat_input_t *i = vam->input;
7986 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
7988 u8 sw_if_index_set = 0;
7989 u8 v6_address_set = 0;
7990 ip6_address_t v6address;
7992 /* Parse args required to build the message */
7993 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7995 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7996 sw_if_index_set = 1;
7997 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7998 sw_if_index_set = 1;
7999 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
8005 if (sw_if_index_set == 0)
8007 errmsg ("missing interface name or sw_if_index");
8010 if (!v6_address_set)
8012 errmsg ("no address set");
8016 /* Construct the API message */
8017 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, mp);
8019 mp->sw_if_index = ntohl (sw_if_index);
8020 clib_memcpy (mp->address, &v6address, sizeof (v6address));
8025 /* Wait for a reply, return good/bad news */
8034 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
8036 unformat_input_t *i = vam->input;
8037 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
8039 u8 sw_if_index_set = 0;
8040 u32 address_length = 0;
8041 u8 v6_address_set = 0;
8042 ip6_address_t v6address;
8044 u8 no_advertise = 0;
8046 u8 no_autoconfig = 0;
8049 u32 val_lifetime = 0;
8050 u32 pref_lifetime = 0;
8052 /* Parse args required to build the message */
8053 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8055 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8056 sw_if_index_set = 1;
8057 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8058 sw_if_index_set = 1;
8059 else if (unformat (i, "%U/%d",
8060 unformat_ip6_address, &v6address, &address_length))
8062 else if (unformat (i, "val_life %d", &val_lifetime))
8064 else if (unformat (i, "pref_life %d", &pref_lifetime))
8066 else if (unformat (i, "def"))
8068 else if (unformat (i, "noadv"))
8070 else if (unformat (i, "offl"))
8072 else if (unformat (i, "noauto"))
8074 else if (unformat (i, "nolink"))
8076 else if (unformat (i, "isno"))
8080 clib_warning ("parse error '%U'", format_unformat_error, i);
8085 if (sw_if_index_set == 0)
8087 errmsg ("missing interface name or sw_if_index");
8090 if (!v6_address_set)
8092 errmsg ("no address set");
8096 /* Construct the API message */
8097 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
8099 mp->sw_if_index = ntohl (sw_if_index);
8100 clib_memcpy (mp->address, &v6address, sizeof (v6address));
8101 mp->address_length = address_length;
8102 mp->use_default = use_default;
8103 mp->no_advertise = no_advertise;
8104 mp->off_link = off_link;
8105 mp->no_autoconfig = no_autoconfig;
8106 mp->no_onlink = no_onlink;
8108 mp->val_lifetime = ntohl (val_lifetime);
8109 mp->pref_lifetime = ntohl (pref_lifetime);
8114 /* Wait for a reply, return good/bad news */
8122 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
8124 unformat_input_t *i = vam->input;
8125 vl_api_sw_interface_ip6nd_ra_config_t *mp;
8127 u8 sw_if_index_set = 0;
8132 u8 send_unicast = 0;
8135 u8 default_router = 0;
8136 u32 max_interval = 0;
8137 u32 min_interval = 0;
8139 u32 initial_count = 0;
8140 u32 initial_interval = 0;
8143 /* Parse args required to build the message */
8144 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8146 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8147 sw_if_index_set = 1;
8148 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8149 sw_if_index_set = 1;
8150 else if (unformat (i, "maxint %d", &max_interval))
8152 else if (unformat (i, "minint %d", &min_interval))
8154 else if (unformat (i, "life %d", &lifetime))
8156 else if (unformat (i, "count %d", &initial_count))
8158 else if (unformat (i, "interval %d", &initial_interval))
8160 else if (unformat (i, "suppress") || unformat (i, "surpress"))
8162 else if (unformat (i, "managed"))
8164 else if (unformat (i, "other"))
8166 else if (unformat (i, "ll"))
8168 else if (unformat (i, "send"))
8170 else if (unformat (i, "cease"))
8172 else if (unformat (i, "isno"))
8174 else if (unformat (i, "def"))
8178 clib_warning ("parse error '%U'", format_unformat_error, i);
8183 if (sw_if_index_set == 0)
8185 errmsg ("missing interface name or sw_if_index");
8189 /* Construct the API message */
8190 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
8192 mp->sw_if_index = ntohl (sw_if_index);
8193 mp->max_interval = ntohl (max_interval);
8194 mp->min_interval = ntohl (min_interval);
8195 mp->lifetime = ntohl (lifetime);
8196 mp->initial_count = ntohl (initial_count);
8197 mp->initial_interval = ntohl (initial_interval);
8198 mp->suppress = suppress;
8199 mp->managed = managed;
8201 mp->ll_option = ll_option;
8202 mp->send_unicast = send_unicast;
8205 mp->default_router = default_router;
8210 /* Wait for a reply, return good/bad news */
8218 api_set_arp_neighbor_limit (vat_main_t * vam)
8220 unformat_input_t *i = vam->input;
8221 vl_api_set_arp_neighbor_limit_t *mp;
8226 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8228 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
8230 else if (unformat (i, "ipv6"))
8234 clib_warning ("parse error '%U'", format_unformat_error, i);
8241 errmsg ("missing limit value");
8245 M (SET_ARP_NEIGHBOR_LIMIT, mp);
8247 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
8248 mp->is_ipv6 = is_ipv6;
8257 api_l2_patch_add_del (vat_main_t * vam)
8259 unformat_input_t *i = vam->input;
8260 vl_api_l2_patch_add_del_t *mp;
8262 u8 rx_sw_if_index_set = 0;
8264 u8 tx_sw_if_index_set = 0;
8267 /* Parse args required to build the message */
8268 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8270 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
8271 rx_sw_if_index_set = 1;
8272 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
8273 tx_sw_if_index_set = 1;
8274 else if (unformat (i, "rx"))
8276 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8278 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
8280 rx_sw_if_index_set = 1;
8285 else if (unformat (i, "tx"))
8287 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8289 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
8291 tx_sw_if_index_set = 1;
8296 else if (unformat (i, "del"))
8302 if (rx_sw_if_index_set == 0)
8304 errmsg ("missing rx interface name or rx_sw_if_index");
8308 if (tx_sw_if_index_set == 0)
8310 errmsg ("missing tx interface name or tx_sw_if_index");
8314 M (L2_PATCH_ADD_DEL, mp);
8316 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
8317 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
8318 mp->is_add = is_add;
8327 api_ioam_enable (vat_main_t * vam)
8329 unformat_input_t *input = vam->input;
8330 vl_api_ioam_enable_t *mp;
8332 int has_trace_option = 0;
8333 int has_pot_option = 0;
8334 int has_seqno_option = 0;
8335 int has_analyse_option = 0;
8337 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8339 if (unformat (input, "trace"))
8340 has_trace_option = 1;
8341 else if (unformat (input, "pot"))
8343 else if (unformat (input, "seqno"))
8344 has_seqno_option = 1;
8345 else if (unformat (input, "analyse"))
8346 has_analyse_option = 1;
8350 M (IOAM_ENABLE, mp);
8351 mp->id = htons (id);
8352 mp->seqno = has_seqno_option;
8353 mp->analyse = has_analyse_option;
8354 mp->pot_enable = has_pot_option;
8355 mp->trace_enable = has_trace_option;
8366 api_ioam_disable (vat_main_t * vam)
8368 vl_api_ioam_disable_t *mp;
8370 M (IOAM_DISABLE, mp);
8377 api_sr_tunnel_add_del (vat_main_t * vam)
8379 unformat_input_t *i = vam->input;
8380 vl_api_sr_tunnel_add_del_t *mp;
8383 ip6_address_t src_address;
8384 int src_address_set = 0;
8385 ip6_address_t dst_address;
8387 int dst_address_set = 0;
8389 u32 rx_table_id = 0;
8390 u32 tx_table_id = 0;
8391 ip6_address_t *segments = 0;
8392 ip6_address_t *this_seg;
8393 ip6_address_t *tags = 0;
8394 ip6_address_t *this_tag;
8395 ip6_address_t next_address, tag;
8397 u8 *policy_name = 0;
8399 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8401 if (unformat (i, "del"))
8403 else if (unformat (i, "name %s", &name))
8405 else if (unformat (i, "policy %s", &policy_name))
8407 else if (unformat (i, "rx_fib_id %d", &rx_table_id))
8409 else if (unformat (i, "tx_fib_id %d", &tx_table_id))
8411 else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
8412 src_address_set = 1;
8413 else if (unformat (i, "dst %U/%d",
8414 unformat_ip6_address, &dst_address, &dst_mask_width))
8415 dst_address_set = 1;
8416 else if (unformat (i, "next %U", unformat_ip6_address, &next_address))
8418 vec_add2 (segments, this_seg, 1);
8419 clib_memcpy (this_seg->as_u8, next_address.as_u8,
8420 sizeof (*this_seg));
8422 else if (unformat (i, "tag %U", unformat_ip6_address, &tag))
8424 vec_add2 (tags, this_tag, 1);
8425 clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
8427 else if (unformat (i, "clean"))
8428 flags |= IP6_SR_HEADER_FLAG_CLEANUP;
8429 else if (unformat (i, "protected"))
8430 flags |= IP6_SR_HEADER_FLAG_PROTECTED;
8431 else if (unformat (i, "InPE %d", &pl_index))
8433 if (pl_index <= 0 || pl_index > 4)
8435 pl_index_range_error:
8436 errmsg ("pl index %d out of range", pl_index);
8440 IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE << (3 * (pl_index - 1));
8442 else if (unformat (i, "EgPE %d", &pl_index))
8444 if (pl_index <= 0 || pl_index > 4)
8445 goto pl_index_range_error;
8447 IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE << (3 * (pl_index - 1));
8449 else if (unformat (i, "OrgSrc %d", &pl_index))
8451 if (pl_index <= 0 || pl_index > 4)
8452 goto pl_index_range_error;
8454 IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3 * (pl_index - 1));
8460 if (!src_address_set)
8462 errmsg ("src address required");
8466 if (!dst_address_set)
8468 errmsg ("dst address required");
8474 errmsg ("at least one sr segment required");
8478 M2 (SR_TUNNEL_ADD_DEL, mp,
8479 vec_len (segments) * sizeof (ip6_address_t)
8480 + vec_len (tags) * sizeof (ip6_address_t));
8482 clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
8483 clib_memcpy (mp->dst_address, &dst_address, sizeof (mp->dst_address));
8484 mp->dst_mask_width = dst_mask_width;
8485 mp->flags_net_byte_order = clib_host_to_net_u16 (flags);
8486 mp->n_segments = vec_len (segments);
8487 mp->n_tags = vec_len (tags);
8488 mp->is_add = is_del == 0;
8489 clib_memcpy (mp->segs_and_tags, segments,
8490 vec_len (segments) * sizeof (ip6_address_t));
8491 clib_memcpy (mp->segs_and_tags +
8492 vec_len (segments) * sizeof (ip6_address_t), tags,
8493 vec_len (tags) * sizeof (ip6_address_t));
8495 mp->outer_vrf_id = ntohl (rx_table_id);
8496 mp->inner_vrf_id = ntohl (tx_table_id);
8497 memcpy (mp->name, name, vec_len (name));
8498 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
8500 vec_free (segments);
8509 api_sr_policy_add_del (vat_main_t * vam)
8511 unformat_input_t *input = vam->input;
8512 vl_api_sr_policy_add_del_t *mp;
8515 u8 *tunnel_name = 0;
8516 u8 **tunnel_names = 0;
8521 int tunnel_names_length = 1; // Init to 1 to offset the #tunnel_names counter byte
8522 int tun_name_len = 0; // Different naming convention used as confusing these would be "bad" (TM)
8524 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8526 if (unformat (input, "del"))
8528 else if (unformat (input, "name %s", &name))
8530 else if (unformat (input, "tunnel %s", &tunnel_name))
8534 vec_add1 (tunnel_names, tunnel_name);
8536 - length = #bytes to store in serial vector
8537 - +1 = byte to store that length
8539 tunnel_names_length += (vec_len (tunnel_name) + 1);
8550 errmsg ("policy name required");
8554 if ((!tunnel_set) && (!is_del))
8556 errmsg ("tunnel name required");
8560 M2 (SR_POLICY_ADD_DEL, mp, tunnel_names_length);
8564 mp->is_add = !is_del;
8566 memcpy (mp->name, name, vec_len (name));
8567 // Since mp->tunnel_names is of type u8[0] and not a u8 *, u8 ** needs to be serialized
8568 u8 *serial_orig = 0;
8569 vec_validate (serial_orig, tunnel_names_length);
8570 *serial_orig = vec_len (tunnel_names); // Store the number of tunnels as length in first byte of serialized vector
8571 serial_orig += 1; // Move along one byte to store the length of first tunnel_name
8573 for (j = 0; j < vec_len (tunnel_names); j++)
8575 tun_name_len = vec_len (tunnel_names[j]);
8576 *serial_orig = tun_name_len; // Store length of tunnel name in first byte of Length/Value pair
8577 serial_orig += 1; // Move along one byte to store the actual tunnel name
8578 memcpy (serial_orig, tunnel_names[j], tun_name_len);
8579 serial_orig += tun_name_len; // Advance past the copy
8581 memcpy (mp->tunnel_names, serial_orig - tunnel_names_length, tunnel_names_length); // Regress serial_orig to head then copy fwd
8583 vec_free (tunnel_names);
8584 vec_free (tunnel_name);
8592 api_sr_multicast_map_add_del (vat_main_t * vam)
8594 unformat_input_t *input = vam->input;
8595 vl_api_sr_multicast_map_add_del_t *mp;
8597 ip6_address_t multicast_address;
8598 u8 *policy_name = 0;
8599 int multicast_address_set = 0;
8601 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8603 if (unformat (input, "del"))
8607 (input, "address %U", unformat_ip6_address, &multicast_address))
8608 multicast_address_set = 1;
8609 else if (unformat (input, "sr-policy %s", &policy_name))
8615 if (!is_del && !policy_name)
8617 errmsg ("sr-policy name required");
8622 if (!multicast_address_set)
8624 errmsg ("address required");
8628 M (SR_MULTICAST_MAP_ADD_DEL, mp);
8630 mp->is_add = !is_del;
8631 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
8632 clib_memcpy (mp->multicast_address, &multicast_address,
8633 sizeof (mp->multicast_address));
8636 vec_free (policy_name);
8644 #define foreach_tcp_proto_field \
8648 #define foreach_udp_proto_field \
8652 #define foreach_ip4_proto_field \
8663 unformat_tcp_mask (unformat_input_t * input, va_list * args)
8665 u8 **maskp = va_arg (*args, u8 **);
8667 u8 found_something = 0;
8670 #define _(a) u8 a=0;
8671 foreach_tcp_proto_field;
8674 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8677 #define _(a) else if (unformat (input, #a)) a=1;
8678 foreach_tcp_proto_field
8684 #define _(a) found_something += a;
8685 foreach_tcp_proto_field;
8688 if (found_something == 0)
8691 vec_validate (mask, sizeof (*tcp) - 1);
8693 tcp = (tcp_header_t *) mask;
8695 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
8696 foreach_tcp_proto_field;
8704 unformat_udp_mask (unformat_input_t * input, va_list * args)
8706 u8 **maskp = va_arg (*args, u8 **);
8708 u8 found_something = 0;
8711 #define _(a) u8 a=0;
8712 foreach_udp_proto_field;
8715 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8718 #define _(a) else if (unformat (input, #a)) a=1;
8719 foreach_udp_proto_field
8725 #define _(a) found_something += a;
8726 foreach_udp_proto_field;
8729 if (found_something == 0)
8732 vec_validate (mask, sizeof (*udp) - 1);
8734 udp = (udp_header_t *) mask;
8736 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
8737 foreach_udp_proto_field;
8746 u16 src_port, dst_port;
8750 unformat_l4_mask (unformat_input_t * input, va_list * args)
8752 u8 **maskp = va_arg (*args, u8 **);
8753 u16 src_port = 0, dst_port = 0;
8754 tcpudp_header_t *tcpudp;
8756 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8758 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
8760 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
8762 else if (unformat (input, "src_port"))
8764 else if (unformat (input, "dst_port"))
8770 if (!src_port && !dst_port)
8774 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
8776 tcpudp = (tcpudp_header_t *) mask;
8777 tcpudp->src_port = src_port;
8778 tcpudp->dst_port = dst_port;
8786 unformat_ip4_mask (unformat_input_t * input, va_list * args)
8788 u8 **maskp = va_arg (*args, u8 **);
8790 u8 found_something = 0;
8793 #define _(a) u8 a=0;
8794 foreach_ip4_proto_field;
8800 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8802 if (unformat (input, "version"))
8804 else if (unformat (input, "hdr_length"))
8806 else if (unformat (input, "src"))
8808 else if (unformat (input, "dst"))
8810 else if (unformat (input, "proto"))
8813 #define _(a) else if (unformat (input, #a)) a=1;
8814 foreach_ip4_proto_field
8820 #define _(a) found_something += a;
8821 foreach_ip4_proto_field;
8824 if (found_something == 0)
8827 vec_validate (mask, sizeof (*ip) - 1);
8829 ip = (ip4_header_t *) mask;
8831 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
8832 foreach_ip4_proto_field;
8835 ip->ip_version_and_header_length = 0;
8838 ip->ip_version_and_header_length |= 0xF0;
8841 ip->ip_version_and_header_length |= 0x0F;
8847 #define foreach_ip6_proto_field \
8855 unformat_ip6_mask (unformat_input_t * input, va_list * args)
8857 u8 **maskp = va_arg (*args, u8 **);
8859 u8 found_something = 0;
8861 u32 ip_version_traffic_class_and_flow_label;
8863 #define _(a) u8 a=0;
8864 foreach_ip6_proto_field;
8867 u8 traffic_class = 0;
8870 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8872 if (unformat (input, "version"))
8874 else if (unformat (input, "traffic-class"))
8876 else if (unformat (input, "flow-label"))
8878 else if (unformat (input, "src"))
8880 else if (unformat (input, "dst"))
8882 else if (unformat (input, "proto"))
8885 #define _(a) else if (unformat (input, #a)) a=1;
8886 foreach_ip6_proto_field
8892 #define _(a) found_something += a;
8893 foreach_ip6_proto_field;
8896 if (found_something == 0)
8899 vec_validate (mask, sizeof (*ip) - 1);
8901 ip = (ip6_header_t *) mask;
8903 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
8904 foreach_ip6_proto_field;
8907 ip_version_traffic_class_and_flow_label = 0;
8910 ip_version_traffic_class_and_flow_label |= 0xF0000000;
8913 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
8916 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
8918 ip->ip_version_traffic_class_and_flow_label =
8919 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
8926 unformat_l3_mask (unformat_input_t * input, va_list * args)
8928 u8 **maskp = va_arg (*args, u8 **);
8930 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8932 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
8934 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
8943 unformat_l2_mask (unformat_input_t * input, va_list * args)
8945 u8 **maskp = va_arg (*args, u8 **);
8960 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8962 if (unformat (input, "src"))
8964 else if (unformat (input, "dst"))
8966 else if (unformat (input, "proto"))
8968 else if (unformat (input, "tag1"))
8970 else if (unformat (input, "tag2"))
8972 else if (unformat (input, "ignore-tag1"))
8974 else if (unformat (input, "ignore-tag2"))
8976 else if (unformat (input, "cos1"))
8978 else if (unformat (input, "cos2"))
8980 else if (unformat (input, "dot1q"))
8982 else if (unformat (input, "dot1ad"))
8987 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
8988 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
8991 if (tag1 || ignore_tag1 || cos1 || dot1q)
8993 if (tag2 || ignore_tag2 || cos2 || dot1ad)
8996 vec_validate (mask, len - 1);
8999 memset (mask, 0xff, 6);
9002 memset (mask + 6, 0xff, 6);
9006 /* inner vlan tag */
9015 mask[21] = mask[20] = 0xff;
9036 mask[16] = mask[17] = 0xff;
9046 mask[12] = mask[13] = 0xff;
9053 unformat_classify_mask (unformat_input_t * input, va_list * args)
9055 u8 **maskp = va_arg (*args, u8 **);
9056 u32 *skipp = va_arg (*args, u32 *);
9057 u32 *matchp = va_arg (*args, u32 *);
9065 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9067 if (unformat (input, "hex %U", unformat_hex_string, &mask))
9069 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
9071 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
9073 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
9087 if (mask || l2 || l3 || l4)
9091 /* "With a free Ethernet header in every package" */
9093 vec_validate (l2, 13);
9097 vec_append (mask, l3);
9102 vec_append (mask, l4);
9107 /* Scan forward looking for the first significant mask octet */
9108 for (i = 0; i < vec_len (mask); i++)
9112 /* compute (skip, match) params */
9113 *skipp = i / sizeof (u32x4);
9114 vec_delete (mask, *skipp * sizeof (u32x4), 0);
9116 /* Pad mask to an even multiple of the vector size */
9117 while (vec_len (mask) % sizeof (u32x4))
9120 match = vec_len (mask) / sizeof (u32x4);
9122 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
9124 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
9125 if (*tmp || *(tmp + 1))
9130 clib_warning ("BUG: match 0");
9132 _vec_len (mask) = match * sizeof (u32x4);
9143 #define foreach_l2_next \
9145 _(ethernet, ETHERNET_INPUT) \
9150 unformat_l2_next_index (unformat_input_t * input, va_list * args)
9152 u32 *miss_next_indexp = va_arg (*args, u32 *);
9157 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
9161 if (unformat (input, "%d", &tmp))
9170 *miss_next_indexp = next_index;
9174 #define foreach_ip_next \
9180 unformat_ip_next_index (unformat_input_t * input, va_list * args)
9182 u32 *miss_next_indexp = va_arg (*args, u32 *);
9187 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
9191 if (unformat (input, "%d", &tmp))
9200 *miss_next_indexp = next_index;
9204 #define foreach_acl_next \
9208 unformat_acl_next_index (unformat_input_t * input, va_list * args)
9210 u32 *miss_next_indexp = va_arg (*args, u32 *);
9215 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
9219 if (unformat (input, "permit"))
9224 else if (unformat (input, "%d", &tmp))
9233 *miss_next_indexp = next_index;
9238 unformat_policer_precolor (unformat_input_t * input, va_list * args)
9240 u32 *r = va_arg (*args, u32 *);
9242 if (unformat (input, "conform-color"))
9243 *r = POLICE_CONFORM;
9244 else if (unformat (input, "exceed-color"))
9253 api_classify_add_del_table (vat_main_t * vam)
9255 unformat_input_t *i = vam->input;
9256 vl_api_classify_add_del_table_t *mp;
9263 u32 table_index = ~0;
9264 u32 next_table_index = ~0;
9265 u32 miss_next_index = ~0;
9266 u32 memory_size = 32 << 20;
9268 u32 current_data_flag = 0;
9269 int current_data_offset = 0;
9271 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9273 if (unformat (i, "del"))
9275 else if (unformat (i, "del-chain"))
9280 else if (unformat (i, "buckets %d", &nbuckets))
9282 else if (unformat (i, "memory_size %d", &memory_size))
9284 else if (unformat (i, "skip %d", &skip))
9286 else if (unformat (i, "match %d", &match))
9288 else if (unformat (i, "table %d", &table_index))
9290 else if (unformat (i, "mask %U", unformat_classify_mask,
9291 &mask, &skip, &match))
9293 else if (unformat (i, "next-table %d", &next_table_index))
9295 else if (unformat (i, "miss-next %U", unformat_ip_next_index,
9298 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
9301 else if (unformat (i, "acl-miss-next %U", unformat_acl_next_index,
9304 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
9306 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
9312 if (is_add && mask == 0)
9314 errmsg ("Mask required");
9318 if (is_add && skip == ~0)
9320 errmsg ("skip count required");
9324 if (is_add && match == ~0)
9326 errmsg ("match count required");
9330 if (!is_add && table_index == ~0)
9332 errmsg ("table index required for delete");
9336 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
9338 mp->is_add = is_add;
9339 mp->del_chain = del_chain;
9340 mp->table_index = ntohl (table_index);
9341 mp->nbuckets = ntohl (nbuckets);
9342 mp->memory_size = ntohl (memory_size);
9343 mp->skip_n_vectors = ntohl (skip);
9344 mp->match_n_vectors = ntohl (match);
9345 mp->next_table_index = ntohl (next_table_index);
9346 mp->miss_next_index = ntohl (miss_next_index);
9347 mp->current_data_flag = ntohl (current_data_flag);
9348 mp->current_data_offset = ntohl (current_data_offset);
9349 clib_memcpy (mp->mask, mask, vec_len (mask));
9359 unformat_l4_match (unformat_input_t * input, va_list * args)
9361 u8 **matchp = va_arg (*args, u8 **);
9363 u8 *proto_header = 0;
9369 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9371 if (unformat (input, "src_port %d", &src_port))
9373 else if (unformat (input, "dst_port %d", &dst_port))
9379 h.src_port = clib_host_to_net_u16 (src_port);
9380 h.dst_port = clib_host_to_net_u16 (dst_port);
9381 vec_validate (proto_header, sizeof (h) - 1);
9382 memcpy (proto_header, &h, sizeof (h));
9384 *matchp = proto_header;
9390 unformat_ip4_match (unformat_input_t * input, va_list * args)
9392 u8 **matchp = va_arg (*args, u8 **);
9399 int src = 0, dst = 0;
9400 ip4_address_t src_val, dst_val;
9407 int fragment_id = 0;
9408 u32 fragment_id_val;
9414 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9416 if (unformat (input, "version %d", &version_val))
9418 else if (unformat (input, "hdr_length %d", &hdr_length_val))
9420 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
9422 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
9424 else if (unformat (input, "proto %d", &proto_val))
9426 else if (unformat (input, "tos %d", &tos_val))
9428 else if (unformat (input, "length %d", &length_val))
9430 else if (unformat (input, "fragment_id %d", &fragment_id_val))
9432 else if (unformat (input, "ttl %d", &ttl_val))
9434 else if (unformat (input, "checksum %d", &checksum_val))
9440 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
9441 + ttl + checksum == 0)
9445 * Aligned because we use the real comparison functions
9447 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
9449 ip = (ip4_header_t *) match;
9451 /* These are realistically matched in practice */
9453 ip->src_address.as_u32 = src_val.as_u32;
9456 ip->dst_address.as_u32 = dst_val.as_u32;
9459 ip->protocol = proto_val;
9462 /* These are not, but they're included for completeness */
9464 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
9467 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
9473 ip->length = clib_host_to_net_u16 (length_val);
9479 ip->checksum = clib_host_to_net_u16 (checksum_val);
9486 unformat_ip6_match (unformat_input_t * input, va_list * args)
9488 u8 **matchp = va_arg (*args, u8 **);
9493 u8 traffic_class = 0;
9494 u32 traffic_class_val = 0;
9497 int src = 0, dst = 0;
9498 ip6_address_t src_val, dst_val;
9501 int payload_length = 0;
9502 u32 payload_length_val;
9505 u32 ip_version_traffic_class_and_flow_label;
9507 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9509 if (unformat (input, "version %d", &version_val))
9511 else if (unformat (input, "traffic_class %d", &traffic_class_val))
9513 else if (unformat (input, "flow_label %d", &flow_label_val))
9515 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
9517 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
9519 else if (unformat (input, "proto %d", &proto_val))
9521 else if (unformat (input, "payload_length %d", &payload_length_val))
9523 else if (unformat (input, "hop_limit %d", &hop_limit_val))
9529 if (version + traffic_class + flow_label + src + dst + proto +
9530 payload_length + hop_limit == 0)
9534 * Aligned because we use the real comparison functions
9536 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
9538 ip = (ip6_header_t *) match;
9541 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
9544 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
9547 ip->protocol = proto_val;
9549 ip_version_traffic_class_and_flow_label = 0;
9552 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
9555 ip_version_traffic_class_and_flow_label |=
9556 (traffic_class_val & 0xFF) << 20;
9559 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
9561 ip->ip_version_traffic_class_and_flow_label =
9562 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9565 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
9568 ip->hop_limit = hop_limit_val;
9575 unformat_l3_match (unformat_input_t * input, va_list * args)
9577 u8 **matchp = va_arg (*args, u8 **);
9579 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9581 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
9583 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
9592 unformat_vlan_tag (unformat_input_t * input, va_list * args)
9594 u8 *tagp = va_arg (*args, u8 *);
9597 if (unformat (input, "%d", &tag))
9599 tagp[0] = (tag >> 8) & 0x0F;
9600 tagp[1] = tag & 0xFF;
9608 unformat_l2_match (unformat_input_t * input, va_list * args)
9610 u8 **matchp = va_arg (*args, u8 **);
9630 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9632 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
9635 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
9637 else if (unformat (input, "proto %U",
9638 unformat_ethernet_type_host_byte_order, &proto_val))
9640 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
9642 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
9644 else if (unformat (input, "ignore-tag1"))
9646 else if (unformat (input, "ignore-tag2"))
9648 else if (unformat (input, "cos1 %d", &cos1_val))
9650 else if (unformat (input, "cos2 %d", &cos2_val))
9655 if ((src + dst + proto + tag1 + tag2 +
9656 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9659 if (tag1 || ignore_tag1 || cos1)
9661 if (tag2 || ignore_tag2 || cos2)
9664 vec_validate_aligned (match, len - 1, sizeof (u32x4));
9667 clib_memcpy (match, dst_val, 6);
9670 clib_memcpy (match + 6, src_val, 6);
9674 /* inner vlan tag */
9675 match[19] = tag2_val[1];
9676 match[18] = tag2_val[0];
9678 match[18] |= (cos2_val & 0x7) << 5;
9681 match[21] = proto_val & 0xff;
9682 match[20] = proto_val >> 8;
9686 match[15] = tag1_val[1];
9687 match[14] = tag1_val[0];
9690 match[14] |= (cos1_val & 0x7) << 5;
9696 match[15] = tag1_val[1];
9697 match[14] = tag1_val[0];
9700 match[17] = proto_val & 0xff;
9701 match[16] = proto_val >> 8;
9704 match[14] |= (cos1_val & 0x7) << 5;
9710 match[18] |= (cos2_val & 0x7) << 5;
9712 match[14] |= (cos1_val & 0x7) << 5;
9715 match[13] = proto_val & 0xff;
9716 match[12] = proto_val >> 8;
9725 unformat_classify_match (unformat_input_t * input, va_list * args)
9727 u8 **matchp = va_arg (*args, u8 **);
9728 u32 skip_n_vectors = va_arg (*args, u32);
9729 u32 match_n_vectors = va_arg (*args, u32);
9736 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9738 if (unformat (input, "hex %U", unformat_hex_string, &match))
9740 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
9742 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
9744 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
9758 if (match || l2 || l3 || l4)
9762 /* "Win a free Ethernet header in every packet" */
9764 vec_validate_aligned (l2, 13, sizeof (u32x4));
9768 vec_append_aligned (match, l3, sizeof (u32x4));
9773 vec_append_aligned (match, l4, sizeof (u32x4));
9778 /* Make sure the vector is big enough even if key is all 0's */
9779 vec_validate_aligned
9780 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
9783 /* Set size, include skipped vectors */
9784 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
9795 api_classify_add_del_session (vat_main_t * vam)
9797 unformat_input_t *i = vam->input;
9798 vl_api_classify_add_del_session_t *mp;
9800 u32 table_index = ~0;
9801 u32 hit_next_index = ~0;
9802 u32 opaque_index = ~0;
9805 u32 skip_n_vectors = 0;
9806 u32 match_n_vectors = 0;
9811 * Warning: you have to supply skip_n and match_n
9812 * because the API client cant simply look at the classify
9816 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9818 if (unformat (i, "del"))
9820 else if (unformat (i, "hit-next %U", unformat_ip_next_index,
9823 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
9826 else if (unformat (i, "acl-hit-next %U", unformat_acl_next_index,
9829 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
9831 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
9833 else if (unformat (i, "opaque-index %d", &opaque_index))
9835 else if (unformat (i, "skip_n %d", &skip_n_vectors))
9837 else if (unformat (i, "match_n %d", &match_n_vectors))
9839 else if (unformat (i, "match %U", unformat_classify_match,
9840 &match, skip_n_vectors, match_n_vectors))
9842 else if (unformat (i, "advance %d", &advance))
9844 else if (unformat (i, "table-index %d", &table_index))
9846 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
9848 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
9850 else if (unformat (i, "action %d", &action))
9852 else if (unformat (i, "metadata %d", &metadata))
9858 if (table_index == ~0)
9860 errmsg ("Table index required");
9864 if (is_add && match == 0)
9866 errmsg ("Match value required");
9870 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
9872 mp->is_add = is_add;
9873 mp->table_index = ntohl (table_index);
9874 mp->hit_next_index = ntohl (hit_next_index);
9875 mp->opaque_index = ntohl (opaque_index);
9876 mp->advance = ntohl (advance);
9877 mp->action = action;
9878 mp->metadata = ntohl (metadata);
9879 clib_memcpy (mp->match, match, vec_len (match));
9888 api_classify_set_interface_ip_table (vat_main_t * vam)
9890 unformat_input_t *i = vam->input;
9891 vl_api_classify_set_interface_ip_table_t *mp;
9893 int sw_if_index_set;
9894 u32 table_index = ~0;
9897 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9899 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9900 sw_if_index_set = 1;
9901 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9902 sw_if_index_set = 1;
9903 else if (unformat (i, "table %d", &table_index))
9907 clib_warning ("parse error '%U'", format_unformat_error, i);
9912 if (sw_if_index_set == 0)
9914 errmsg ("missing interface name or sw_if_index");
9919 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
9921 mp->sw_if_index = ntohl (sw_if_index);
9922 mp->table_index = ntohl (table_index);
9923 mp->is_ipv6 = is_ipv6;
9932 api_classify_set_interface_l2_tables (vat_main_t * vam)
9934 unformat_input_t *i = vam->input;
9935 vl_api_classify_set_interface_l2_tables_t *mp;
9937 int sw_if_index_set;
9938 u32 ip4_table_index = ~0;
9939 u32 ip6_table_index = ~0;
9940 u32 other_table_index = ~0;
9943 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9945 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9946 sw_if_index_set = 1;
9947 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9948 sw_if_index_set = 1;
9949 else if (unformat (i, "ip4-table %d", &ip4_table_index))
9951 else if (unformat (i, "ip6-table %d", &ip6_table_index))
9953 else if (unformat (i, "other-table %d", &other_table_index))
9955 else if (unformat (i, "is-input %d", &is_input))
9959 clib_warning ("parse error '%U'", format_unformat_error, i);
9964 if (sw_if_index_set == 0)
9966 errmsg ("missing interface name or sw_if_index");
9971 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
9973 mp->sw_if_index = ntohl (sw_if_index);
9974 mp->ip4_table_index = ntohl (ip4_table_index);
9975 mp->ip6_table_index = ntohl (ip6_table_index);
9976 mp->other_table_index = ntohl (other_table_index);
9977 mp->is_input = (u8) is_input;
9986 api_set_ipfix_exporter (vat_main_t * vam)
9988 unformat_input_t *i = vam->input;
9989 vl_api_set_ipfix_exporter_t *mp;
9990 ip4_address_t collector_address;
9991 u8 collector_address_set = 0;
9992 u32 collector_port = ~0;
9993 ip4_address_t src_address;
9994 u8 src_address_set = 0;
9997 u32 template_interval = ~0;
9998 u8 udp_checksum = 0;
10000 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10002 if (unformat (i, "collector_address %U", unformat_ip4_address,
10003 &collector_address))
10004 collector_address_set = 1;
10005 else if (unformat (i, "collector_port %d", &collector_port))
10007 else if (unformat (i, "src_address %U", unformat_ip4_address,
10009 src_address_set = 1;
10010 else if (unformat (i, "vrf_id %d", &vrf_id))
10012 else if (unformat (i, "path_mtu %d", &path_mtu))
10014 else if (unformat (i, "template_interval %d", &template_interval))
10016 else if (unformat (i, "udp_checksum"))
10022 if (collector_address_set == 0)
10024 errmsg ("collector_address required");
10028 if (src_address_set == 0)
10030 errmsg ("src_address required");
10034 M (SET_IPFIX_EXPORTER, mp);
10036 memcpy (mp->collector_address, collector_address.data,
10037 sizeof (collector_address.data));
10038 mp->collector_port = htons ((u16) collector_port);
10039 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
10040 mp->vrf_id = htonl (vrf_id);
10041 mp->path_mtu = htonl (path_mtu);
10042 mp->template_interval = htonl (template_interval);
10043 mp->udp_checksum = udp_checksum;
10051 api_set_ipfix_classify_stream (vat_main_t * vam)
10053 unformat_input_t *i = vam->input;
10054 vl_api_set_ipfix_classify_stream_t *mp;
10056 u32 src_port = UDP_DST_PORT_ipfix;
10058 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10060 if (unformat (i, "domain %d", &domain_id))
10062 else if (unformat (i, "src_port %d", &src_port))
10066 errmsg ("unknown input `%U'", format_unformat_error, i);
10071 M (SET_IPFIX_CLASSIFY_STREAM, mp);
10073 mp->domain_id = htonl (domain_id);
10074 mp->src_port = htons ((u16) src_port);
10082 api_ipfix_classify_table_add_del (vat_main_t * vam)
10084 unformat_input_t *i = vam->input;
10085 vl_api_ipfix_classify_table_add_del_t *mp;
10087 u32 classify_table_index = ~0;
10089 u8 transport_protocol = 255;
10091 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10093 if (unformat (i, "add"))
10095 else if (unformat (i, "del"))
10097 else if (unformat (i, "table %d", &classify_table_index))
10099 else if (unformat (i, "ip4"))
10101 else if (unformat (i, "ip6"))
10103 else if (unformat (i, "tcp"))
10104 transport_protocol = 6;
10105 else if (unformat (i, "udp"))
10106 transport_protocol = 17;
10109 errmsg ("unknown input `%U'", format_unformat_error, i);
10116 errmsg ("expecting: add|del");
10119 if (classify_table_index == ~0)
10121 errmsg ("classifier table not specified");
10124 if (ip_version == 0)
10126 errmsg ("IP version not specified");
10130 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
10132 mp->is_add = is_add;
10133 mp->table_id = htonl (classify_table_index);
10134 mp->ip_version = ip_version;
10135 mp->transport_protocol = transport_protocol;
10143 api_get_node_index (vat_main_t * vam)
10145 unformat_input_t *i = vam->input;
10146 vl_api_get_node_index_t *mp;
10149 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10151 if (unformat (i, "node %s", &name))
10158 errmsg ("node name required");
10161 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10163 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10167 M (GET_NODE_INDEX, mp);
10168 clib_memcpy (mp->node_name, name, vec_len (name));
10178 api_get_next_index (vat_main_t * vam)
10180 unformat_input_t *i = vam->input;
10181 vl_api_get_next_index_t *mp;
10182 u8 *node_name = 0, *next_node_name = 0;
10184 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10186 if (unformat (i, "node-name %s", &node_name))
10188 else if (unformat (i, "next-node-name %s", &next_node_name))
10192 if (node_name == 0)
10194 errmsg ("node name required");
10197 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
10199 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10203 if (next_node_name == 0)
10205 errmsg ("next node name required");
10208 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
10210 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
10214 M (GET_NEXT_INDEX, mp);
10215 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
10216 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
10217 vec_free (node_name);
10218 vec_free (next_node_name);
10227 api_add_node_next (vat_main_t * vam)
10229 unformat_input_t *i = vam->input;
10230 vl_api_add_node_next_t *mp;
10234 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10236 if (unformat (i, "node %s", &name))
10238 else if (unformat (i, "next %s", &next))
10245 errmsg ("node name required");
10248 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10250 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10255 errmsg ("next node required");
10258 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
10260 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
10264 M (ADD_NODE_NEXT, mp);
10265 clib_memcpy (mp->node_name, name, vec_len (name));
10266 clib_memcpy (mp->next_name, next, vec_len (next));
10277 api_l2tpv3_create_tunnel (vat_main_t * vam)
10279 unformat_input_t *i = vam->input;
10280 ip6_address_t client_address, our_address;
10281 int client_address_set = 0;
10282 int our_address_set = 0;
10283 u32 local_session_id = 0;
10284 u32 remote_session_id = 0;
10285 u64 local_cookie = 0;
10286 u64 remote_cookie = 0;
10287 u8 l2_sublayer_present = 0;
10288 vl_api_l2tpv3_create_tunnel_t *mp;
10290 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10292 if (unformat (i, "client_address %U", unformat_ip6_address,
10294 client_address_set = 1;
10295 else if (unformat (i, "our_address %U", unformat_ip6_address,
10297 our_address_set = 1;
10298 else if (unformat (i, "local_session_id %d", &local_session_id))
10300 else if (unformat (i, "remote_session_id %d", &remote_session_id))
10302 else if (unformat (i, "local_cookie %lld", &local_cookie))
10304 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
10306 else if (unformat (i, "l2-sublayer-present"))
10307 l2_sublayer_present = 1;
10312 if (client_address_set == 0)
10314 errmsg ("client_address required");
10318 if (our_address_set == 0)
10320 errmsg ("our_address required");
10324 M (L2TPV3_CREATE_TUNNEL, mp);
10326 clib_memcpy (mp->client_address, client_address.as_u8,
10327 sizeof (mp->client_address));
10329 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
10331 mp->local_session_id = ntohl (local_session_id);
10332 mp->remote_session_id = ntohl (remote_session_id);
10333 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
10334 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
10335 mp->l2_sublayer_present = l2_sublayer_present;
10345 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
10347 unformat_input_t *i = vam->input;
10349 u8 sw_if_index_set = 0;
10350 u64 new_local_cookie = 0;
10351 u64 new_remote_cookie = 0;
10352 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
10354 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10356 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10357 sw_if_index_set = 1;
10358 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10359 sw_if_index_set = 1;
10360 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
10362 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
10368 if (sw_if_index_set == 0)
10370 errmsg ("missing interface name or sw_if_index");
10374 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
10376 mp->sw_if_index = ntohl (sw_if_index);
10377 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
10378 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
10387 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
10389 unformat_input_t *i = vam->input;
10390 vl_api_l2tpv3_interface_enable_disable_t *mp;
10392 u8 sw_if_index_set = 0;
10393 u8 enable_disable = 1;
10395 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10397 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10398 sw_if_index_set = 1;
10399 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10400 sw_if_index_set = 1;
10401 else if (unformat (i, "enable"))
10402 enable_disable = 1;
10403 else if (unformat (i, "disable"))
10404 enable_disable = 0;
10409 if (sw_if_index_set == 0)
10411 errmsg ("missing interface name or sw_if_index");
10415 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
10417 mp->sw_if_index = ntohl (sw_if_index);
10418 mp->enable_disable = enable_disable;
10427 api_l2tpv3_set_lookup_key (vat_main_t * vam)
10429 unformat_input_t *i = vam->input;
10430 vl_api_l2tpv3_set_lookup_key_t *mp;
10433 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10435 if (unformat (i, "lookup_v6_src"))
10436 key = L2T_LOOKUP_SRC_ADDRESS;
10437 else if (unformat (i, "lookup_v6_dst"))
10438 key = L2T_LOOKUP_DST_ADDRESS;
10439 else if (unformat (i, "lookup_session_id"))
10440 key = L2T_LOOKUP_SESSION_ID;
10445 if (key == (u8) ~ 0)
10447 errmsg ("l2tp session lookup key unset");
10451 M (L2TPV3_SET_LOOKUP_KEY, mp);
10461 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
10462 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
10464 vat_main_t *vam = &vat_main;
10466 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
10467 format_ip6_address, mp->our_address,
10468 format_ip6_address, mp->client_address,
10469 clib_net_to_host_u32 (mp->sw_if_index));
10472 " local cookies %016llx %016llx remote cookie %016llx",
10473 clib_net_to_host_u64 (mp->local_cookie[0]),
10474 clib_net_to_host_u64 (mp->local_cookie[1]),
10475 clib_net_to_host_u64 (mp->remote_cookie));
10477 print (vam->ofp, " local session-id %d remote session-id %d",
10478 clib_net_to_host_u32 (mp->local_session_id),
10479 clib_net_to_host_u32 (mp->remote_session_id));
10481 print (vam->ofp, " l2 specific sublayer %s\n",
10482 mp->l2_sublayer_present ? "preset" : "absent");
10486 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
10487 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
10489 vat_main_t *vam = &vat_main;
10490 vat_json_node_t *node = NULL;
10491 struct in6_addr addr;
10493 if (VAT_JSON_ARRAY != vam->json_tree.type)
10495 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10496 vat_json_init_array (&vam->json_tree);
10498 node = vat_json_array_add (&vam->json_tree);
10500 vat_json_init_object (node);
10502 clib_memcpy (&addr, mp->our_address, sizeof (addr));
10503 vat_json_object_add_ip6 (node, "our_address", addr);
10504 clib_memcpy (&addr, mp->client_address, sizeof (addr));
10505 vat_json_object_add_ip6 (node, "client_address", addr);
10507 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
10508 vat_json_init_array (lc);
10509 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
10510 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
10511 vat_json_object_add_uint (node, "remote_cookie",
10512 clib_net_to_host_u64 (mp->remote_cookie));
10514 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
10515 vat_json_object_add_uint (node, "local_session_id",
10516 clib_net_to_host_u32 (mp->local_session_id));
10517 vat_json_object_add_uint (node, "remote_session_id",
10518 clib_net_to_host_u32 (mp->remote_session_id));
10519 vat_json_object_add_string_copy (node, "l2_sublayer",
10520 mp->l2_sublayer_present ? (u8 *) "present"
10521 : (u8 *) "absent");
10525 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
10527 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
10529 /* Get list of l2tpv3-tunnel interfaces */
10530 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
10533 /* Use a control ping for synchronization */
10535 vl_api_control_ping_t *mp;
10536 M (CONTROL_PING, mp);
10543 static void vl_api_sw_interface_tap_details_t_handler
10544 (vl_api_sw_interface_tap_details_t * mp)
10546 vat_main_t *vam = &vat_main;
10548 print (vam->ofp, "%-16s %d",
10549 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
10552 static void vl_api_sw_interface_tap_details_t_handler_json
10553 (vl_api_sw_interface_tap_details_t * mp)
10555 vat_main_t *vam = &vat_main;
10556 vat_json_node_t *node = NULL;
10558 if (VAT_JSON_ARRAY != vam->json_tree.type)
10560 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10561 vat_json_init_array (&vam->json_tree);
10563 node = vat_json_array_add (&vam->json_tree);
10565 vat_json_init_object (node);
10566 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10567 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
10571 api_sw_interface_tap_dump (vat_main_t * vam)
10573 vl_api_sw_interface_tap_dump_t *mp;
10575 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
10576 /* Get list of tap interfaces */
10577 M (SW_INTERFACE_TAP_DUMP, mp);
10580 /* Use a control ping for synchronization */
10582 vl_api_control_ping_t *mp;
10583 M (CONTROL_PING, mp);
10589 static uword unformat_vxlan_decap_next
10590 (unformat_input_t * input, va_list * args)
10592 u32 *result = va_arg (*args, u32 *);
10595 if (unformat (input, "l2"))
10596 *result = VXLAN_INPUT_NEXT_L2_INPUT;
10597 else if (unformat (input, "%d", &tmp))
10605 api_vxlan_add_del_tunnel (vat_main_t * vam)
10607 unformat_input_t *line_input = vam->input;
10608 vl_api_vxlan_add_del_tunnel_t *mp;
10609 ip46_address_t src, dst;
10611 u8 ipv4_set = 0, ipv6_set = 0;
10615 u32 mcast_sw_if_index = ~0;
10616 u32 encap_vrf_id = 0;
10617 u32 decap_next_index = ~0;
10620 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
10621 memset (&src, 0, sizeof src);
10622 memset (&dst, 0, sizeof dst);
10624 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10626 if (unformat (line_input, "del"))
10629 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
10635 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
10641 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
10647 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
10652 else if (unformat (line_input, "group %U %U",
10653 unformat_ip4_address, &dst.ip4,
10654 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
10656 grp_set = dst_set = 1;
10659 else if (unformat (line_input, "group %U",
10660 unformat_ip4_address, &dst.ip4))
10662 grp_set = dst_set = 1;
10665 else if (unformat (line_input, "group %U %U",
10666 unformat_ip6_address, &dst.ip6,
10667 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
10669 grp_set = dst_set = 1;
10672 else if (unformat (line_input, "group %U",
10673 unformat_ip6_address, &dst.ip6))
10675 grp_set = dst_set = 1;
10679 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
10681 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
10683 else if (unformat (line_input, "decap-next %U",
10684 unformat_vxlan_decap_next, &decap_next_index))
10686 else if (unformat (line_input, "vni %d", &vni))
10690 errmsg ("parse error '%U'", format_unformat_error, line_input);
10697 errmsg ("tunnel src address not specified");
10702 errmsg ("tunnel dst address not specified");
10706 if (grp_set && !ip46_address_is_multicast (&dst))
10708 errmsg ("tunnel group address not multicast");
10711 if (grp_set && mcast_sw_if_index == ~0)
10713 errmsg ("tunnel nonexistent multicast device");
10716 if (grp_set == 0 && ip46_address_is_multicast (&dst))
10718 errmsg ("tunnel dst address must be unicast");
10723 if (ipv4_set && ipv6_set)
10725 errmsg ("both IPv4 and IPv6 addresses specified");
10729 if ((vni == 0) || (vni >> 24))
10731 errmsg ("vni not specified or out of range");
10735 M (VXLAN_ADD_DEL_TUNNEL, mp);
10739 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
10740 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
10744 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
10745 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
10747 mp->encap_vrf_id = ntohl (encap_vrf_id);
10748 mp->decap_next_index = ntohl (decap_next_index);
10749 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
10750 mp->vni = ntohl (vni);
10751 mp->is_add = is_add;
10752 mp->is_ipv6 = ipv6_set;
10760 static void vl_api_vxlan_tunnel_details_t_handler
10761 (vl_api_vxlan_tunnel_details_t * mp)
10763 vat_main_t *vam = &vat_main;
10764 ip46_address_t src, dst;
10766 ip46_from_addr_buf (mp->is_ipv6, mp->src_address, &src);
10767 ip46_from_addr_buf (mp->is_ipv6, mp->dst_address, &dst);
10769 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
10770 ntohl (mp->sw_if_index),
10771 format_ip46_address, &src, IP46_TYPE_ANY,
10772 format_ip46_address, &dst, IP46_TYPE_ANY,
10773 ntohl (mp->encap_vrf_id),
10774 ntohl (mp->decap_next_index), ntohl (mp->vni),
10775 ntohl (mp->mcast_sw_if_index));
10778 static void vl_api_vxlan_tunnel_details_t_handler_json
10779 (vl_api_vxlan_tunnel_details_t * mp)
10781 vat_main_t *vam = &vat_main;
10782 vat_json_node_t *node = NULL;
10784 if (VAT_JSON_ARRAY != vam->json_tree.type)
10786 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10787 vat_json_init_array (&vam->json_tree);
10789 node = vat_json_array_add (&vam->json_tree);
10791 vat_json_init_object (node);
10792 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10795 struct in6_addr ip6;
10797 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
10798 vat_json_object_add_ip6 (node, "src_address", ip6);
10799 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
10800 vat_json_object_add_ip6 (node, "dst_address", ip6);
10804 struct in_addr ip4;
10806 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
10807 vat_json_object_add_ip4 (node, "src_address", ip4);
10808 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
10809 vat_json_object_add_ip4 (node, "dst_address", ip4);
10811 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
10812 vat_json_object_add_uint (node, "decap_next_index",
10813 ntohl (mp->decap_next_index));
10814 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
10815 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
10816 vat_json_object_add_uint (node, "mcast_sw_if_index",
10817 ntohl (mp->mcast_sw_if_index));
10821 api_vxlan_tunnel_dump (vat_main_t * vam)
10823 unformat_input_t *i = vam->input;
10824 vl_api_vxlan_tunnel_dump_t *mp;
10826 u8 sw_if_index_set = 0;
10828 /* Parse args required to build the message */
10829 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10831 if (unformat (i, "sw_if_index %d", &sw_if_index))
10832 sw_if_index_set = 1;
10837 if (sw_if_index_set == 0)
10842 if (!vam->json_output)
10844 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
10845 "sw_if_index", "src_address", "dst_address",
10846 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
10849 /* Get list of vxlan-tunnel interfaces */
10850 M (VXLAN_TUNNEL_DUMP, mp);
10852 mp->sw_if_index = htonl (sw_if_index);
10856 /* Use a control ping for synchronization */
10858 vl_api_control_ping_t *mp;
10859 M (CONTROL_PING, mp);
10866 api_gre_add_del_tunnel (vat_main_t * vam)
10868 unformat_input_t *line_input = vam->input;
10869 vl_api_gre_add_del_tunnel_t *mp;
10870 ip4_address_t src4, dst4;
10875 u32 outer_fib_id = 0;
10877 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10879 if (unformat (line_input, "del"))
10881 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
10883 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
10885 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
10887 else if (unformat (line_input, "teb"))
10891 errmsg ("parse error '%U'", format_unformat_error, line_input);
10898 errmsg ("tunnel src address not specified");
10903 errmsg ("tunnel dst address not specified");
10908 M (GRE_ADD_DEL_TUNNEL, mp);
10910 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
10911 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
10912 mp->outer_fib_id = ntohl (outer_fib_id);
10913 mp->is_add = is_add;
10922 static void vl_api_gre_tunnel_details_t_handler
10923 (vl_api_gre_tunnel_details_t * mp)
10925 vat_main_t *vam = &vat_main;
10927 print (vam->ofp, "%11d%15U%15U%6d%14d",
10928 ntohl (mp->sw_if_index),
10929 format_ip4_address, &mp->src_address,
10930 format_ip4_address, &mp->dst_address,
10931 mp->teb, ntohl (mp->outer_fib_id));
10934 static void vl_api_gre_tunnel_details_t_handler_json
10935 (vl_api_gre_tunnel_details_t * mp)
10937 vat_main_t *vam = &vat_main;
10938 vat_json_node_t *node = NULL;
10939 struct in_addr ip4;
10941 if (VAT_JSON_ARRAY != vam->json_tree.type)
10943 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10944 vat_json_init_array (&vam->json_tree);
10946 node = vat_json_array_add (&vam->json_tree);
10948 vat_json_init_object (node);
10949 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10950 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
10951 vat_json_object_add_ip4 (node, "src_address", ip4);
10952 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
10953 vat_json_object_add_ip4 (node, "dst_address", ip4);
10954 vat_json_object_add_uint (node, "teb", mp->teb);
10955 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
10959 api_gre_tunnel_dump (vat_main_t * vam)
10961 unformat_input_t *i = vam->input;
10962 vl_api_gre_tunnel_dump_t *mp;
10964 u8 sw_if_index_set = 0;
10966 /* Parse args required to build the message */
10967 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10969 if (unformat (i, "sw_if_index %d", &sw_if_index))
10970 sw_if_index_set = 1;
10975 if (sw_if_index_set == 0)
10980 if (!vam->json_output)
10982 print (vam->ofp, "%11s%15s%15s%6s%14s",
10983 "sw_if_index", "src_address", "dst_address", "teb",
10987 /* Get list of gre-tunnel interfaces */
10988 M (GRE_TUNNEL_DUMP, mp);
10990 mp->sw_if_index = htonl (sw_if_index);
10994 /* Use a control ping for synchronization */
10996 vl_api_control_ping_t *mp;
10997 M (CONTROL_PING, mp);
11004 api_l2_fib_clear_table (vat_main_t * vam)
11006 // unformat_input_t * i = vam->input;
11007 vl_api_l2_fib_clear_table_t *mp;
11009 M (L2_FIB_CLEAR_TABLE, mp);
11018 api_l2_interface_efp_filter (vat_main_t * vam)
11020 unformat_input_t *i = vam->input;
11021 vl_api_l2_interface_efp_filter_t *mp;
11024 u8 sw_if_index_set = 0;
11026 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11028 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11029 sw_if_index_set = 1;
11030 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11031 sw_if_index_set = 1;
11032 else if (unformat (i, "enable"))
11034 else if (unformat (i, "disable"))
11038 clib_warning ("parse error '%U'", format_unformat_error, i);
11043 if (sw_if_index_set == 0)
11045 errmsg ("missing sw_if_index");
11049 M (L2_INTERFACE_EFP_FILTER, mp);
11051 mp->sw_if_index = ntohl (sw_if_index);
11052 mp->enable_disable = enable;
11060 #define foreach_vtr_op \
11061 _("disable", L2_VTR_DISABLED) \
11062 _("push-1", L2_VTR_PUSH_1) \
11063 _("push-2", L2_VTR_PUSH_2) \
11064 _("pop-1", L2_VTR_POP_1) \
11065 _("pop-2", L2_VTR_POP_2) \
11066 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
11067 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
11068 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
11069 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
11072 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
11074 unformat_input_t *i = vam->input;
11075 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
11077 u8 sw_if_index_set = 0;
11080 u32 push_dot1q = 1;
11084 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11086 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11087 sw_if_index_set = 1;
11088 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11089 sw_if_index_set = 1;
11090 else if (unformat (i, "vtr_op %d", &vtr_op))
11092 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
11095 else if (unformat (i, "push_dot1q %d", &push_dot1q))
11097 else if (unformat (i, "tag1 %d", &tag1))
11099 else if (unformat (i, "tag2 %d", &tag2))
11103 clib_warning ("parse error '%U'", format_unformat_error, i);
11108 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
11110 errmsg ("missing vtr operation or sw_if_index");
11114 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
11115 mp->sw_if_index = ntohl (sw_if_index);
11116 mp->vtr_op = ntohl (vtr_op);
11117 mp->push_dot1q = ntohl (push_dot1q);
11118 mp->tag1 = ntohl (tag1);
11119 mp->tag2 = ntohl (tag2);
11128 api_create_vhost_user_if (vat_main_t * vam)
11130 unformat_input_t *i = vam->input;
11131 vl_api_create_vhost_user_if_t *mp;
11134 u8 file_name_set = 0;
11135 u32 custom_dev_instance = ~0;
11137 u8 use_custom_mac = 0;
11140 /* Shut up coverity */
11141 memset (hwaddr, 0, sizeof (hwaddr));
11143 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11145 if (unformat (i, "socket %s", &file_name))
11149 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
11151 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
11152 use_custom_mac = 1;
11153 else if (unformat (i, "server"))
11155 else if (unformat (i, "tag %s", &tag))
11161 if (file_name_set == 0)
11163 errmsg ("missing socket file name");
11167 if (vec_len (file_name) > 255)
11169 errmsg ("socket file name too long");
11172 vec_add1 (file_name, 0);
11174 M (CREATE_VHOST_USER_IF, mp);
11176 mp->is_server = is_server;
11177 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
11178 vec_free (file_name);
11179 if (custom_dev_instance != ~0)
11182 mp->custom_dev_instance = ntohl (custom_dev_instance);
11184 mp->use_custom_mac = use_custom_mac;
11185 clib_memcpy (mp->mac_address, hwaddr, 6);
11187 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
11197 api_modify_vhost_user_if (vat_main_t * vam)
11199 unformat_input_t *i = vam->input;
11200 vl_api_modify_vhost_user_if_t *mp;
11203 u8 file_name_set = 0;
11204 u32 custom_dev_instance = ~0;
11205 u8 sw_if_index_set = 0;
11206 u32 sw_if_index = (u32) ~ 0;
11208 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11210 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11211 sw_if_index_set = 1;
11212 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11213 sw_if_index_set = 1;
11214 else if (unformat (i, "socket %s", &file_name))
11218 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
11220 else if (unformat (i, "server"))
11226 if (sw_if_index_set == 0)
11228 errmsg ("missing sw_if_index or interface name");
11232 if (file_name_set == 0)
11234 errmsg ("missing socket file name");
11238 if (vec_len (file_name) > 255)
11240 errmsg ("socket file name too long");
11243 vec_add1 (file_name, 0);
11245 M (MODIFY_VHOST_USER_IF, mp);
11247 mp->sw_if_index = ntohl (sw_if_index);
11248 mp->is_server = is_server;
11249 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
11250 vec_free (file_name);
11251 if (custom_dev_instance != ~0)
11254 mp->custom_dev_instance = ntohl (custom_dev_instance);
11264 api_delete_vhost_user_if (vat_main_t * vam)
11266 unformat_input_t *i = vam->input;
11267 vl_api_delete_vhost_user_if_t *mp;
11268 u32 sw_if_index = ~0;
11269 u8 sw_if_index_set = 0;
11271 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11273 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11274 sw_if_index_set = 1;
11275 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11276 sw_if_index_set = 1;
11281 if (sw_if_index_set == 0)
11283 errmsg ("missing sw_if_index or interface name");
11288 M (DELETE_VHOST_USER_IF, mp);
11290 mp->sw_if_index = ntohl (sw_if_index);
11298 static void vl_api_sw_interface_vhost_user_details_t_handler
11299 (vl_api_sw_interface_vhost_user_details_t * mp)
11301 vat_main_t *vam = &vat_main;
11303 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
11304 (char *) mp->interface_name,
11305 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
11306 clib_net_to_host_u64 (mp->features), mp->is_server,
11307 ntohl (mp->num_regions), (char *) mp->sock_filename);
11308 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
11311 static void vl_api_sw_interface_vhost_user_details_t_handler_json
11312 (vl_api_sw_interface_vhost_user_details_t * mp)
11314 vat_main_t *vam = &vat_main;
11315 vat_json_node_t *node = NULL;
11317 if (VAT_JSON_ARRAY != vam->json_tree.type)
11319 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11320 vat_json_init_array (&vam->json_tree);
11322 node = vat_json_array_add (&vam->json_tree);
11324 vat_json_init_object (node);
11325 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11326 vat_json_object_add_string_copy (node, "interface_name",
11327 mp->interface_name);
11328 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
11329 ntohl (mp->virtio_net_hdr_sz));
11330 vat_json_object_add_uint (node, "features",
11331 clib_net_to_host_u64 (mp->features));
11332 vat_json_object_add_uint (node, "is_server", mp->is_server);
11333 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
11334 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
11335 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
11339 api_sw_interface_vhost_user_dump (vat_main_t * vam)
11341 vl_api_sw_interface_vhost_user_dump_t *mp;
11343 "Interface name idx hdr_sz features server regions filename");
11345 /* Get list of vhost-user interfaces */
11346 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
11349 /* Use a control ping for synchronization */
11351 vl_api_control_ping_t *mp;
11352 M (CONTROL_PING, mp);
11359 api_show_version (vat_main_t * vam)
11361 vl_api_show_version_t *mp;
11363 M (SHOW_VERSION, mp);
11373 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
11375 unformat_input_t *line_input = vam->input;
11376 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
11377 ip4_address_t local4, remote4;
11378 ip6_address_t local6, remote6;
11380 u8 ipv4_set = 0, ipv6_set = 0;
11383 u32 encap_vrf_id = 0;
11384 u32 decap_vrf_id = 0;
11389 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11391 if (unformat (line_input, "del"))
11393 else if (unformat (line_input, "local %U",
11394 unformat_ip4_address, &local4))
11399 else if (unformat (line_input, "remote %U",
11400 unformat_ip4_address, &remote4))
11405 else if (unformat (line_input, "local %U",
11406 unformat_ip6_address, &local6))
11411 else if (unformat (line_input, "remote %U",
11412 unformat_ip6_address, &remote6))
11417 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11419 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
11421 else if (unformat (line_input, "vni %d", &vni))
11423 else if (unformat (line_input, "next-ip4"))
11425 else if (unformat (line_input, "next-ip6"))
11427 else if (unformat (line_input, "next-ethernet"))
11429 else if (unformat (line_input, "next-nsh"))
11433 errmsg ("parse error '%U'", format_unformat_error, line_input);
11438 if (local_set == 0)
11440 errmsg ("tunnel local address not specified");
11443 if (remote_set == 0)
11445 errmsg ("tunnel remote address not specified");
11448 if (ipv4_set && ipv6_set)
11450 errmsg ("both IPv4 and IPv6 addresses specified");
11456 errmsg ("vni not specified");
11460 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
11465 clib_memcpy (&mp->local, &local6, sizeof (local6));
11466 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
11470 clib_memcpy (&mp->local, &local4, sizeof (local4));
11471 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
11474 mp->encap_vrf_id = ntohl (encap_vrf_id);
11475 mp->decap_vrf_id = ntohl (decap_vrf_id);
11476 mp->protocol = protocol;
11477 mp->vni = ntohl (vni);
11478 mp->is_add = is_add;
11479 mp->is_ipv6 = ipv6_set;
11487 static void vl_api_vxlan_gpe_tunnel_details_t_handler
11488 (vl_api_vxlan_gpe_tunnel_details_t * mp)
11490 vat_main_t *vam = &vat_main;
11492 print (vam->ofp, "%11d%24U%24U%13d%12d%14d%14d",
11493 ntohl (mp->sw_if_index),
11494 format_ip46_address, &(mp->local[0]),
11495 format_ip46_address, &(mp->remote[0]),
11497 ntohl (mp->protocol),
11498 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
11501 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
11502 (vl_api_vxlan_gpe_tunnel_details_t * mp)
11504 vat_main_t *vam = &vat_main;
11505 vat_json_node_t *node = NULL;
11506 struct in_addr ip4;
11507 struct in6_addr ip6;
11509 if (VAT_JSON_ARRAY != vam->json_tree.type)
11511 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11512 vat_json_init_array (&vam->json_tree);
11514 node = vat_json_array_add (&vam->json_tree);
11516 vat_json_init_object (node);
11517 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11520 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
11521 vat_json_object_add_ip6 (node, "local", ip6);
11522 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
11523 vat_json_object_add_ip6 (node, "remote", ip6);
11527 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
11528 vat_json_object_add_ip4 (node, "local", ip4);
11529 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
11530 vat_json_object_add_ip4 (node, "remote", ip4);
11532 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
11533 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
11534 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
11535 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
11536 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
11540 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
11542 unformat_input_t *i = vam->input;
11543 vl_api_vxlan_gpe_tunnel_dump_t *mp;
11545 u8 sw_if_index_set = 0;
11547 /* Parse args required to build the message */
11548 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11550 if (unformat (i, "sw_if_index %d", &sw_if_index))
11551 sw_if_index_set = 1;
11556 if (sw_if_index_set == 0)
11561 if (!vam->json_output)
11563 print (vam->ofp, "%11s%24s%24s%13s%15s%14s%14s",
11564 "sw_if_index", "local", "remote", "vni",
11565 "protocol", "encap_vrf_id", "decap_vrf_id");
11568 /* Get list of vxlan-tunnel interfaces */
11569 M (VXLAN_GPE_TUNNEL_DUMP, mp);
11571 mp->sw_if_index = htonl (sw_if_index);
11575 /* Use a control ping for synchronization */
11577 vl_api_control_ping_t *mp;
11578 M (CONTROL_PING, mp);
11585 format_l2_fib_mac_address (u8 * s, va_list * args)
11587 u8 *a = va_arg (*args, u8 *);
11589 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
11590 a[2], a[3], a[4], a[5], a[6], a[7]);
11593 static void vl_api_l2_fib_table_entry_t_handler
11594 (vl_api_l2_fib_table_entry_t * mp)
11596 vat_main_t *vam = &vat_main;
11598 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
11600 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
11601 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
11605 static void vl_api_l2_fib_table_entry_t_handler_json
11606 (vl_api_l2_fib_table_entry_t * mp)
11608 vat_main_t *vam = &vat_main;
11609 vat_json_node_t *node = NULL;
11611 if (VAT_JSON_ARRAY != vam->json_tree.type)
11613 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11614 vat_json_init_array (&vam->json_tree);
11616 node = vat_json_array_add (&vam->json_tree);
11618 vat_json_init_object (node);
11619 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
11620 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
11621 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11622 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
11623 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
11624 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
11628 api_l2_fib_table_dump (vat_main_t * vam)
11630 unformat_input_t *i = vam->input;
11631 vl_api_l2_fib_table_dump_t *mp;
11635 /* Parse args required to build the message */
11636 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11638 if (unformat (i, "bd_id %d", &bd_id))
11644 if (bd_id_set == 0)
11646 errmsg ("missing bridge domain");
11650 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
11652 /* Get list of l2 fib entries */
11653 M (L2_FIB_TABLE_DUMP, mp);
11655 mp->bd_id = ntohl (bd_id);
11658 /* Use a control ping for synchronization */
11660 vl_api_control_ping_t *mp;
11661 M (CONTROL_PING, mp);
11669 api_interface_name_renumber (vat_main_t * vam)
11671 unformat_input_t *line_input = vam->input;
11672 vl_api_interface_name_renumber_t *mp;
11673 u32 sw_if_index = ~0;
11674 u32 new_show_dev_instance = ~0;
11676 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11678 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
11681 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11683 else if (unformat (line_input, "new_show_dev_instance %d",
11684 &new_show_dev_instance))
11690 if (sw_if_index == ~0)
11692 errmsg ("missing interface name or sw_if_index");
11696 if (new_show_dev_instance == ~0)
11698 errmsg ("missing new_show_dev_instance");
11702 M (INTERFACE_NAME_RENUMBER, mp);
11704 mp->sw_if_index = ntohl (sw_if_index);
11705 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
11712 api_want_ip4_arp_events (vat_main_t * vam)
11714 unformat_input_t *line_input = vam->input;
11715 vl_api_want_ip4_arp_events_t *mp;
11716 ip4_address_t address;
11717 int address_set = 0;
11718 u32 enable_disable = 1;
11720 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11722 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
11724 else if (unformat (line_input, "del"))
11725 enable_disable = 0;
11730 if (address_set == 0)
11732 errmsg ("missing addresses");
11736 M (WANT_IP4_ARP_EVENTS, mp);
11737 mp->enable_disable = enable_disable;
11738 mp->pid = getpid ();
11739 mp->address = address.as_u32;
11746 api_want_ip6_nd_events (vat_main_t * vam)
11748 unformat_input_t *line_input = vam->input;
11749 vl_api_want_ip6_nd_events_t *mp;
11750 ip6_address_t address;
11751 int address_set = 0;
11752 u32 enable_disable = 1;
11754 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11756 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
11758 else if (unformat (line_input, "del"))
11759 enable_disable = 0;
11764 if (address_set == 0)
11766 errmsg ("missing addresses");
11770 M (WANT_IP6_ND_EVENTS, mp);
11771 mp->enable_disable = enable_disable;
11772 mp->pid = getpid ();
11773 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
11780 api_input_acl_set_interface (vat_main_t * vam)
11782 unformat_input_t *i = vam->input;
11783 vl_api_input_acl_set_interface_t *mp;
11785 int sw_if_index_set;
11786 u32 ip4_table_index = ~0;
11787 u32 ip6_table_index = ~0;
11788 u32 l2_table_index = ~0;
11791 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11793 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11794 sw_if_index_set = 1;
11795 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11796 sw_if_index_set = 1;
11797 else if (unformat (i, "del"))
11799 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11801 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11803 else if (unformat (i, "l2-table %d", &l2_table_index))
11807 clib_warning ("parse error '%U'", format_unformat_error, i);
11812 if (sw_if_index_set == 0)
11814 errmsg ("missing interface name or sw_if_index");
11818 M (INPUT_ACL_SET_INTERFACE, mp);
11820 mp->sw_if_index = ntohl (sw_if_index);
11821 mp->ip4_table_index = ntohl (ip4_table_index);
11822 mp->ip6_table_index = ntohl (ip6_table_index);
11823 mp->l2_table_index = ntohl (l2_table_index);
11824 mp->is_add = is_add;
11833 api_ip_address_dump (vat_main_t * vam)
11835 unformat_input_t *i = vam->input;
11836 vl_api_ip_address_dump_t *mp;
11837 u32 sw_if_index = ~0;
11838 u8 sw_if_index_set = 0;
11842 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11844 if (unformat (i, "sw_if_index %d", &sw_if_index))
11845 sw_if_index_set = 1;
11847 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11848 sw_if_index_set = 1;
11849 else if (unformat (i, "ipv4"))
11851 else if (unformat (i, "ipv6"))
11857 if (ipv4_set && ipv6_set)
11859 errmsg ("ipv4 and ipv6 flags cannot be both set");
11863 if ((!ipv4_set) && (!ipv6_set))
11865 errmsg ("no ipv4 nor ipv6 flag set");
11869 if (sw_if_index_set == 0)
11871 errmsg ("missing interface name or sw_if_index");
11875 vam->current_sw_if_index = sw_if_index;
11876 vam->is_ipv6 = ipv6_set;
11878 M (IP_ADDRESS_DUMP, mp);
11879 mp->sw_if_index = ntohl (sw_if_index);
11880 mp->is_ipv6 = ipv6_set;
11883 /* Use a control ping for synchronization */
11885 vl_api_control_ping_t *mp;
11886 M (CONTROL_PING, mp);
11893 api_ip_dump (vat_main_t * vam)
11895 vl_api_ip_dump_t *mp;
11896 unformat_input_t *in = vam->input;
11902 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
11904 if (unformat (in, "ipv4"))
11906 else if (unformat (in, "ipv6"))
11912 if (ipv4_set && ipv6_set)
11914 errmsg ("ipv4 and ipv6 flags cannot be both set");
11918 if ((!ipv4_set) && (!ipv6_set))
11920 errmsg ("no ipv4 nor ipv6 flag set");
11924 is_ipv6 = ipv6_set;
11925 vam->is_ipv6 = is_ipv6;
11927 /* free old data */
11928 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
11930 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
11932 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
11935 mp->is_ipv6 = ipv6_set;
11938 /* Use a control ping for synchronization */
11940 vl_api_control_ping_t *mp;
11941 M (CONTROL_PING, mp);
11948 api_ipsec_spd_add_del (vat_main_t * vam)
11950 unformat_input_t *i = vam->input;
11951 vl_api_ipsec_spd_add_del_t *mp;
11955 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11957 if (unformat (i, "spd_id %d", &spd_id))
11959 else if (unformat (i, "del"))
11963 clib_warning ("parse error '%U'", format_unformat_error, i);
11969 errmsg ("spd_id must be set");
11973 M (IPSEC_SPD_ADD_DEL, mp);
11975 mp->spd_id = ntohl (spd_id);
11976 mp->is_add = is_add;
11985 api_ipsec_interface_add_del_spd (vat_main_t * vam)
11987 unformat_input_t *i = vam->input;
11988 vl_api_ipsec_interface_add_del_spd_t *mp;
11990 u8 sw_if_index_set = 0;
11991 u32 spd_id = (u32) ~ 0;
11994 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11996 if (unformat (i, "del"))
11998 else if (unformat (i, "spd_id %d", &spd_id))
12001 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12002 sw_if_index_set = 1;
12003 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12004 sw_if_index_set = 1;
12007 clib_warning ("parse error '%U'", format_unformat_error, i);
12013 if (spd_id == (u32) ~ 0)
12015 errmsg ("spd_id must be set");
12019 if (sw_if_index_set == 0)
12021 errmsg ("missing interface name or sw_if_index");
12025 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
12027 mp->spd_id = ntohl (spd_id);
12028 mp->sw_if_index = ntohl (sw_if_index);
12029 mp->is_add = is_add;
12038 api_ipsec_spd_add_del_entry (vat_main_t * vam)
12040 unformat_input_t *i = vam->input;
12041 vl_api_ipsec_spd_add_del_entry_t *mp;
12042 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
12043 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
12045 u32 rport_start = 0, rport_stop = (u32) ~ 0;
12046 u32 lport_start = 0, lport_stop = (u32) ~ 0;
12047 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
12048 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
12050 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
12051 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
12052 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
12053 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
12054 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
12055 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
12057 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12059 if (unformat (i, "del"))
12061 if (unformat (i, "outbound"))
12063 if (unformat (i, "inbound"))
12065 else if (unformat (i, "spd_id %d", &spd_id))
12067 else if (unformat (i, "sa_id %d", &sa_id))
12069 else if (unformat (i, "priority %d", &priority))
12071 else if (unformat (i, "protocol %d", &protocol))
12073 else if (unformat (i, "lport_start %d", &lport_start))
12075 else if (unformat (i, "lport_stop %d", &lport_stop))
12077 else if (unformat (i, "rport_start %d", &rport_start))
12079 else if (unformat (i, "rport_stop %d", &rport_stop))
12083 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
12089 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
12096 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
12102 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
12109 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
12115 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
12122 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
12128 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
12134 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
12136 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
12138 clib_warning ("unsupported action: 'resolve'");
12144 clib_warning ("parse error '%U'", format_unformat_error, i);
12150 M (IPSEC_SPD_ADD_DEL_ENTRY, mp);
12152 mp->spd_id = ntohl (spd_id);
12153 mp->priority = ntohl (priority);
12154 mp->is_outbound = is_outbound;
12156 mp->is_ipv6 = is_ipv6;
12157 if (is_ipv6 || is_ip_any)
12159 clib_memcpy (mp->remote_address_start, &raddr6_start,
12160 sizeof (ip6_address_t));
12161 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
12162 sizeof (ip6_address_t));
12163 clib_memcpy (mp->local_address_start, &laddr6_start,
12164 sizeof (ip6_address_t));
12165 clib_memcpy (mp->local_address_stop, &laddr6_stop,
12166 sizeof (ip6_address_t));
12170 clib_memcpy (mp->remote_address_start, &raddr4_start,
12171 sizeof (ip4_address_t));
12172 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
12173 sizeof (ip4_address_t));
12174 clib_memcpy (mp->local_address_start, &laddr4_start,
12175 sizeof (ip4_address_t));
12176 clib_memcpy (mp->local_address_stop, &laddr4_stop,
12177 sizeof (ip4_address_t));
12179 mp->protocol = (u8) protocol;
12180 mp->local_port_start = ntohs ((u16) lport_start);
12181 mp->local_port_stop = ntohs ((u16) lport_stop);
12182 mp->remote_port_start = ntohs ((u16) rport_start);
12183 mp->remote_port_stop = ntohs ((u16) rport_stop);
12184 mp->policy = (u8) policy;
12185 mp->sa_id = ntohl (sa_id);
12186 mp->is_add = is_add;
12187 mp->is_ip_any = is_ip_any;
12195 api_ipsec_sad_add_del_entry (vat_main_t * vam)
12197 unformat_input_t *i = vam->input;
12198 vl_api_ipsec_sad_add_del_entry_t *mp;
12199 u32 sad_id = 0, spi = 0;
12200 u8 *ck = 0, *ik = 0;
12203 u8 protocol = IPSEC_PROTOCOL_AH;
12204 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
12205 u32 crypto_alg = 0, integ_alg = 0;
12206 ip4_address_t tun_src4;
12207 ip4_address_t tun_dst4;
12208 ip6_address_t tun_src6;
12209 ip6_address_t tun_dst6;
12211 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12213 if (unformat (i, "del"))
12215 else if (unformat (i, "sad_id %d", &sad_id))
12217 else if (unformat (i, "spi %d", &spi))
12219 else if (unformat (i, "esp"))
12220 protocol = IPSEC_PROTOCOL_ESP;
12221 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
12224 is_tunnel_ipv6 = 0;
12226 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
12229 is_tunnel_ipv6 = 0;
12231 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
12234 is_tunnel_ipv6 = 1;
12236 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
12239 is_tunnel_ipv6 = 1;
12243 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
12245 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
12246 crypto_alg >= IPSEC_CRYPTO_N_ALG)
12248 clib_warning ("unsupported crypto-alg: '%U'",
12249 format_ipsec_crypto_alg, crypto_alg);
12253 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
12257 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
12259 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
12260 integ_alg >= IPSEC_INTEG_N_ALG)
12262 clib_warning ("unsupported integ-alg: '%U'",
12263 format_ipsec_integ_alg, integ_alg);
12267 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
12271 clib_warning ("parse error '%U'", format_unformat_error, i);
12277 M (IPSEC_SAD_ADD_DEL_ENTRY, mp);
12279 mp->sad_id = ntohl (sad_id);
12280 mp->is_add = is_add;
12281 mp->protocol = protocol;
12282 mp->spi = ntohl (spi);
12283 mp->is_tunnel = is_tunnel;
12284 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
12285 mp->crypto_algorithm = crypto_alg;
12286 mp->integrity_algorithm = integ_alg;
12287 mp->crypto_key_length = vec_len (ck);
12288 mp->integrity_key_length = vec_len (ik);
12290 if (mp->crypto_key_length > sizeof (mp->crypto_key))
12291 mp->crypto_key_length = sizeof (mp->crypto_key);
12293 if (mp->integrity_key_length > sizeof (mp->integrity_key))
12294 mp->integrity_key_length = sizeof (mp->integrity_key);
12297 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
12299 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
12303 if (is_tunnel_ipv6)
12305 clib_memcpy (mp->tunnel_src_address, &tun_src6,
12306 sizeof (ip6_address_t));
12307 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
12308 sizeof (ip6_address_t));
12312 clib_memcpy (mp->tunnel_src_address, &tun_src4,
12313 sizeof (ip4_address_t));
12314 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
12315 sizeof (ip4_address_t));
12326 api_ipsec_sa_set_key (vat_main_t * vam)
12328 unformat_input_t *i = vam->input;
12329 vl_api_ipsec_sa_set_key_t *mp;
12331 u8 *ck = 0, *ik = 0;
12333 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12335 if (unformat (i, "sa_id %d", &sa_id))
12337 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
12339 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
12343 clib_warning ("parse error '%U'", format_unformat_error, i);
12348 M (IPSEC_SA_SET_KEY, mp);
12350 mp->sa_id = ntohl (sa_id);
12351 mp->crypto_key_length = vec_len (ck);
12352 mp->integrity_key_length = vec_len (ik);
12354 if (mp->crypto_key_length > sizeof (mp->crypto_key))
12355 mp->crypto_key_length = sizeof (mp->crypto_key);
12357 if (mp->integrity_key_length > sizeof (mp->integrity_key))
12358 mp->integrity_key_length = sizeof (mp->integrity_key);
12361 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
12363 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
12372 api_ikev2_profile_add_del (vat_main_t * vam)
12374 unformat_input_t *i = vam->input;
12375 vl_api_ikev2_profile_add_del_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, "del"))
12385 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12386 vec_add1 (name, 0);
12389 errmsg ("parse error '%U'", format_unformat_error, i);
12394 if (!vec_len (name))
12396 errmsg ("profile name must be specified");
12400 if (vec_len (name) > 64)
12402 errmsg ("profile name too long");
12406 M (IKEV2_PROFILE_ADD_DEL, mp);
12408 clib_memcpy (mp->name, name, vec_len (name));
12409 mp->is_add = is_add;
12419 api_ikev2_profile_set_auth (vat_main_t * vam)
12421 unformat_input_t *i = vam->input;
12422 vl_api_ikev2_profile_set_auth_t *mp;
12425 u32 auth_method = 0;
12428 const char *valid_chars = "a-zA-Z0-9_";
12430 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12432 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12433 vec_add1 (name, 0);
12434 else if (unformat (i, "auth_method %U",
12435 unformat_ikev2_auth_method, &auth_method))
12437 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
12439 else if (unformat (i, "auth_data %v", &data))
12443 errmsg ("parse error '%U'", format_unformat_error, i);
12448 if (!vec_len (name))
12450 errmsg ("profile name must be specified");
12454 if (vec_len (name) > 64)
12456 errmsg ("profile name too long");
12460 if (!vec_len (data))
12462 errmsg ("auth_data must be specified");
12468 errmsg ("auth_method must be specified");
12472 M (IKEV2_PROFILE_SET_AUTH, mp);
12474 mp->is_hex = is_hex;
12475 mp->auth_method = (u8) auth_method;
12476 mp->data_len = vec_len (data);
12477 clib_memcpy (mp->name, name, vec_len (name));
12478 clib_memcpy (mp->data, data, vec_len (data));
12489 api_ikev2_profile_set_id (vat_main_t * vam)
12491 unformat_input_t *i = vam->input;
12492 vl_api_ikev2_profile_set_id_t *mp;
12499 const char *valid_chars = "a-zA-Z0-9_";
12501 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12503 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12504 vec_add1 (name, 0);
12505 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
12507 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
12509 data = vec_new (u8, 4);
12510 clib_memcpy (data, ip4.as_u8, 4);
12512 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
12514 else if (unformat (i, "id_data %v", &data))
12516 else if (unformat (i, "local"))
12518 else if (unformat (i, "remote"))
12522 errmsg ("parse error '%U'", format_unformat_error, i);
12527 if (!vec_len (name))
12529 errmsg ("profile name must be specified");
12533 if (vec_len (name) > 64)
12535 errmsg ("profile name too long");
12539 if (!vec_len (data))
12541 errmsg ("id_data must be specified");
12547 errmsg ("id_type must be specified");
12551 M (IKEV2_PROFILE_SET_ID, mp);
12553 mp->is_local = is_local;
12554 mp->id_type = (u8) id_type;
12555 mp->data_len = vec_len (data);
12556 clib_memcpy (mp->name, name, vec_len (name));
12557 clib_memcpy (mp->data, data, vec_len (data));
12568 api_ikev2_profile_set_ts (vat_main_t * vam)
12570 unformat_input_t *i = vam->input;
12571 vl_api_ikev2_profile_set_ts_t *mp;
12574 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
12575 ip4_address_t start_addr, end_addr;
12577 const char *valid_chars = "a-zA-Z0-9_";
12579 start_addr.as_u32 = 0;
12580 end_addr.as_u32 = (u32) ~ 0;
12582 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12584 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12585 vec_add1 (name, 0);
12586 else if (unformat (i, "protocol %d", &proto))
12588 else if (unformat (i, "start_port %d", &start_port))
12590 else if (unformat (i, "end_port %d", &end_port))
12593 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
12595 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
12597 else if (unformat (i, "local"))
12599 else if (unformat (i, "remote"))
12603 errmsg ("parse error '%U'", format_unformat_error, i);
12608 if (!vec_len (name))
12610 errmsg ("profile name must be specified");
12614 if (vec_len (name) > 64)
12616 errmsg ("profile name too long");
12620 M (IKEV2_PROFILE_SET_TS, mp);
12622 mp->is_local = is_local;
12623 mp->proto = (u8) proto;
12624 mp->start_port = (u16) start_port;
12625 mp->end_port = (u16) end_port;
12626 mp->start_addr = start_addr.as_u32;
12627 mp->end_addr = end_addr.as_u32;
12628 clib_memcpy (mp->name, name, vec_len (name));
12638 api_ikev2_set_local_key (vat_main_t * vam)
12640 unformat_input_t *i = vam->input;
12641 vl_api_ikev2_set_local_key_t *mp;
12644 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12646 if (unformat (i, "file %v", &file))
12647 vec_add1 (file, 0);
12650 errmsg ("parse error '%U'", format_unformat_error, i);
12655 if (!vec_len (file))
12657 errmsg ("RSA key file must be specified");
12661 if (vec_len (file) > 256)
12663 errmsg ("file name too long");
12667 M (IKEV2_SET_LOCAL_KEY, mp);
12669 clib_memcpy (mp->key_file, file, vec_len (file));
12682 api_map_add_domain (vat_main_t * vam)
12684 unformat_input_t *i = vam->input;
12685 vl_api_map_add_domain_t *mp;
12687 ip4_address_t ip4_prefix;
12688 ip6_address_t ip6_prefix;
12689 ip6_address_t ip6_src;
12690 u32 num_m_args = 0;
12691 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
12692 0, psid_length = 0;
12693 u8 is_translation = 0;
12695 u32 ip6_src_len = 128;
12697 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12699 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
12700 &ip4_prefix, &ip4_prefix_len))
12702 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
12703 &ip6_prefix, &ip6_prefix_len))
12707 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
12710 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
12712 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
12714 else if (unformat (i, "psid-offset %d", &psid_offset))
12716 else if (unformat (i, "psid-len %d", &psid_length))
12718 else if (unformat (i, "mtu %d", &mtu))
12720 else if (unformat (i, "map-t"))
12721 is_translation = 1;
12724 clib_warning ("parse error '%U'", format_unformat_error, i);
12729 if (num_m_args < 3)
12731 errmsg ("mandatory argument(s) missing");
12735 /* Construct the API message */
12736 M (MAP_ADD_DOMAIN, mp);
12738 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
12739 mp->ip4_prefix_len = ip4_prefix_len;
12741 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
12742 mp->ip6_prefix_len = ip6_prefix_len;
12744 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
12745 mp->ip6_src_prefix_len = ip6_src_len;
12747 mp->ea_bits_len = ea_bits_len;
12748 mp->psid_offset = psid_offset;
12749 mp->psid_length = psid_length;
12750 mp->is_translation = is_translation;
12751 mp->mtu = htons (mtu);
12756 /* Wait for a reply, return good/bad news */
12761 api_map_del_domain (vat_main_t * vam)
12763 unformat_input_t *i = vam->input;
12764 vl_api_map_del_domain_t *mp;
12766 u32 num_m_args = 0;
12769 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12771 if (unformat (i, "index %d", &index))
12775 clib_warning ("parse error '%U'", format_unformat_error, i);
12780 if (num_m_args != 1)
12782 errmsg ("mandatory argument(s) missing");
12786 /* Construct the API message */
12787 M (MAP_DEL_DOMAIN, mp);
12789 mp->index = ntohl (index);
12794 /* Wait for a reply, return good/bad news */
12799 api_map_add_del_rule (vat_main_t * vam)
12801 unformat_input_t *i = vam->input;
12802 vl_api_map_add_del_rule_t *mp;
12804 ip6_address_t ip6_dst;
12805 u32 num_m_args = 0, index, psid = 0;
12807 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12809 if (unformat (i, "index %d", &index))
12811 else if (unformat (i, "psid %d", &psid))
12813 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
12815 else if (unformat (i, "del"))
12821 clib_warning ("parse error '%U'", format_unformat_error, i);
12826 /* Construct the API message */
12827 M (MAP_ADD_DEL_RULE, mp);
12829 mp->index = ntohl (index);
12830 mp->is_add = is_add;
12831 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
12832 mp->psid = ntohs (psid);
12837 /* Wait for a reply, return good/bad news */
12842 api_map_domain_dump (vat_main_t * vam)
12844 vl_api_map_domain_dump_t *mp;
12846 /* Construct the API message */
12847 M (MAP_DOMAIN_DUMP, mp);
12852 /* Use a control ping for synchronization */
12854 vl_api_control_ping_t *mp;
12855 M (CONTROL_PING, mp);
12862 api_map_rule_dump (vat_main_t * vam)
12864 unformat_input_t *i = vam->input;
12865 vl_api_map_rule_dump_t *mp;
12866 u32 domain_index = ~0;
12868 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12870 if (unformat (i, "index %u", &domain_index))
12876 if (domain_index == ~0)
12878 clib_warning ("parse error: domain index expected");
12882 /* Construct the API message */
12883 M (MAP_RULE_DUMP, mp);
12885 mp->domain_index = htonl (domain_index);
12890 /* Use a control ping for synchronization */
12892 vl_api_control_ping_t *mp;
12893 M (CONTROL_PING, mp);
12899 static void vl_api_map_add_domain_reply_t_handler
12900 (vl_api_map_add_domain_reply_t * mp)
12902 vat_main_t *vam = &vat_main;
12903 i32 retval = ntohl (mp->retval);
12905 if (vam->async_mode)
12907 vam->async_errors += (retval < 0);
12911 vam->retval = retval;
12912 vam->result_ready = 1;
12916 static void vl_api_map_add_domain_reply_t_handler_json
12917 (vl_api_map_add_domain_reply_t * mp)
12919 vat_main_t *vam = &vat_main;
12920 vat_json_node_t node;
12922 vat_json_init_object (&node);
12923 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
12924 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
12926 vat_json_print (vam->ofp, &node);
12927 vat_json_free (&node);
12929 vam->retval = ntohl (mp->retval);
12930 vam->result_ready = 1;
12934 api_get_first_msg_id (vat_main_t * vam)
12936 vl_api_get_first_msg_id_t *mp;
12937 unformat_input_t *i = vam->input;
12941 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12943 if (unformat (i, "client %s", &name))
12951 errmsg ("missing client name");
12954 vec_add1 (name, 0);
12956 if (vec_len (name) > 63)
12958 errmsg ("client name too long");
12962 M (GET_FIRST_MSG_ID, mp);
12963 clib_memcpy (mp->name, name, vec_len (name));
12971 api_cop_interface_enable_disable (vat_main_t * vam)
12973 unformat_input_t *line_input = vam->input;
12974 vl_api_cop_interface_enable_disable_t *mp;
12975 u32 sw_if_index = ~0;
12976 u8 enable_disable = 1;
12978 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12980 if (unformat (line_input, "disable"))
12981 enable_disable = 0;
12982 if (unformat (line_input, "enable"))
12983 enable_disable = 1;
12984 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
12985 vam, &sw_if_index))
12987 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
12993 if (sw_if_index == ~0)
12995 errmsg ("missing interface name or sw_if_index");
12999 /* Construct the API message */
13000 M (COP_INTERFACE_ENABLE_DISABLE, mp);
13001 mp->sw_if_index = ntohl (sw_if_index);
13002 mp->enable_disable = enable_disable;
13006 /* Wait for the reply */
13011 api_cop_whitelist_enable_disable (vat_main_t * vam)
13013 unformat_input_t *line_input = vam->input;
13014 vl_api_cop_whitelist_enable_disable_t *mp;
13015 u32 sw_if_index = ~0;
13016 u8 ip4 = 0, ip6 = 0, default_cop = 0;
13019 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13021 if (unformat (line_input, "ip4"))
13023 else if (unformat (line_input, "ip6"))
13025 else if (unformat (line_input, "default"))
13027 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
13028 vam, &sw_if_index))
13030 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13032 else if (unformat (line_input, "fib-id %d", &fib_id))
13038 if (sw_if_index == ~0)
13040 errmsg ("missing interface name or sw_if_index");
13044 /* Construct the API message */
13045 M (COP_WHITELIST_ENABLE_DISABLE, mp);
13046 mp->sw_if_index = ntohl (sw_if_index);
13047 mp->fib_id = ntohl (fib_id);
13050 mp->default_cop = default_cop;
13054 /* Wait for the reply */
13059 api_get_node_graph (vat_main_t * vam)
13061 vl_api_get_node_graph_t *mp;
13063 M (GET_NODE_GRAPH, mp);
13067 /* Wait for the reply */
13072 /** Used for parsing LISP eids */
13073 typedef CLIB_PACKED(struct{
13074 u8 addr[16]; /**< eid address */
13075 u32 len; /**< prefix length if IP */
13076 u8 type; /**< type of eid */
13081 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
13083 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
13085 memset (a, 0, sizeof (a[0]));
13087 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
13089 a->type = 0; /* ipv4 type */
13091 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
13093 a->type = 1; /* ipv6 type */
13095 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
13097 a->type = 2; /* mac type */
13104 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
13113 lisp_eid_size_vat (u8 type)
13128 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
13130 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
13134 api_lisp_add_del_locator_set (vat_main_t * vam)
13136 unformat_input_t *input = vam->input;
13137 vl_api_lisp_add_del_locator_set_t *mp;
13139 u8 *locator_set_name = NULL;
13140 u8 locator_set_name_set = 0;
13141 vl_api_local_locator_t locator, *locators = 0;
13142 u32 sw_if_index, priority, weight;
13145 /* Parse args required to build the message */
13146 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13148 if (unformat (input, "del"))
13152 else if (unformat (input, "locator-set %s", &locator_set_name))
13154 locator_set_name_set = 1;
13156 else if (unformat (input, "sw_if_index %u p %u w %u",
13157 &sw_if_index, &priority, &weight))
13159 locator.sw_if_index = htonl (sw_if_index);
13160 locator.priority = priority;
13161 locator.weight = weight;
13162 vec_add1 (locators, locator);
13166 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
13167 &sw_if_index, &priority, &weight))
13169 locator.sw_if_index = htonl (sw_if_index);
13170 locator.priority = priority;
13171 locator.weight = weight;
13172 vec_add1 (locators, locator);
13178 if (locator_set_name_set == 0)
13180 errmsg ("missing locator-set name");
13181 vec_free (locators);
13185 if (vec_len (locator_set_name) > 64)
13187 errmsg ("locator-set name too long");
13188 vec_free (locator_set_name);
13189 vec_free (locators);
13192 vec_add1 (locator_set_name, 0);
13194 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
13196 /* Construct the API message */
13197 M2 (LISP_ADD_DEL_LOCATOR_SET, mp, data_len);
13199 mp->is_add = is_add;
13200 clib_memcpy (mp->locator_set_name, locator_set_name,
13201 vec_len (locator_set_name));
13202 vec_free (locator_set_name);
13204 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
13206 clib_memcpy (mp->locators, locators, data_len);
13207 vec_free (locators);
13212 /* Wait for a reply... */
13220 api_lisp_add_del_locator (vat_main_t * vam)
13222 unformat_input_t *input = vam->input;
13223 vl_api_lisp_add_del_locator_t *mp;
13224 u32 tmp_if_index = ~0;
13225 u32 sw_if_index = ~0;
13226 u8 sw_if_index_set = 0;
13227 u8 sw_if_index_if_name_set = 0;
13229 u8 priority_set = 0;
13233 u8 *locator_set_name = NULL;
13234 u8 locator_set_name_set = 0;
13236 /* Parse args required to build the message */
13237 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13239 if (unformat (input, "del"))
13243 else if (unformat (input, "locator-set %s", &locator_set_name))
13245 locator_set_name_set = 1;
13247 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
13250 sw_if_index_if_name_set = 1;
13251 sw_if_index = tmp_if_index;
13253 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
13255 sw_if_index_set = 1;
13256 sw_if_index = tmp_if_index;
13258 else if (unformat (input, "p %d", &priority))
13262 else if (unformat (input, "w %d", &weight))
13270 if (locator_set_name_set == 0)
13272 errmsg ("missing locator-set name");
13276 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
13278 errmsg ("missing sw_if_index");
13279 vec_free (locator_set_name);
13283 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
13285 errmsg ("cannot use both params interface name and sw_if_index");
13286 vec_free (locator_set_name);
13290 if (priority_set == 0)
13292 errmsg ("missing locator-set priority");
13293 vec_free (locator_set_name);
13297 if (weight_set == 0)
13299 errmsg ("missing locator-set weight");
13300 vec_free (locator_set_name);
13304 if (vec_len (locator_set_name) > 64)
13306 errmsg ("locator-set name too long");
13307 vec_free (locator_set_name);
13310 vec_add1 (locator_set_name, 0);
13312 /* Construct the API message */
13313 M (LISP_ADD_DEL_LOCATOR, mp);
13315 mp->is_add = is_add;
13316 mp->sw_if_index = ntohl (sw_if_index);
13317 mp->priority = priority;
13318 mp->weight = weight;
13319 clib_memcpy (mp->locator_set_name, locator_set_name,
13320 vec_len (locator_set_name));
13321 vec_free (locator_set_name);
13326 /* Wait for a reply... */
13334 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
13336 u32 *key_id = va_arg (*args, u32 *);
13339 if (unformat (input, "%s", &s))
13341 if (!strcmp ((char *) s, "sha1"))
13342 key_id[0] = HMAC_SHA_1_96;
13343 else if (!strcmp ((char *) s, "sha256"))
13344 key_id[0] = HMAC_SHA_256_128;
13347 clib_warning ("invalid key_id: '%s'", s);
13348 key_id[0] = HMAC_NO_KEY;
13359 api_lisp_add_del_local_eid (vat_main_t * vam)
13361 unformat_input_t *input = vam->input;
13362 vl_api_lisp_add_del_local_eid_t *mp;
13365 lisp_eid_vat_t _eid, *eid = &_eid;
13366 u8 *locator_set_name = 0;
13367 u8 locator_set_name_set = 0;
13372 /* Parse args required to build the message */
13373 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13375 if (unformat (input, "del"))
13379 else if (unformat (input, "vni %d", &vni))
13383 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
13387 else if (unformat (input, "locator-set %s", &locator_set_name))
13389 locator_set_name_set = 1;
13391 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
13393 else if (unformat (input, "secret-key %_%v%_", &key))
13399 if (locator_set_name_set == 0)
13401 errmsg ("missing locator-set name");
13407 errmsg ("EID address not set!");
13408 vec_free (locator_set_name);
13412 if (key && (0 == key_id))
13414 errmsg ("invalid key_id!");
13418 if (vec_len (key) > 64)
13420 errmsg ("key too long");
13425 if (vec_len (locator_set_name) > 64)
13427 errmsg ("locator-set name too long");
13428 vec_free (locator_set_name);
13431 vec_add1 (locator_set_name, 0);
13433 /* Construct the API message */
13434 M (LISP_ADD_DEL_LOCAL_EID, mp);
13436 mp->is_add = is_add;
13437 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
13438 mp->eid_type = eid->type;
13439 mp->prefix_len = eid->len;
13440 mp->vni = clib_host_to_net_u32 (vni);
13441 mp->key_id = clib_host_to_net_u16 (key_id);
13442 clib_memcpy (mp->locator_set_name, locator_set_name,
13443 vec_len (locator_set_name));
13444 clib_memcpy (mp->key, key, vec_len (key));
13446 vec_free (locator_set_name);
13452 /* Wait for a reply... */
13460 /** Used for transferring locators via VPP API */
13461 typedef CLIB_PACKED(struct
13463 u8 is_ip4; /**< is locator an IPv4 address? */
13464 u8 priority; /**< locator priority */
13465 u8 weight; /**< locator weight */
13466 u8 addr[16]; /**< IPv4/IPv6 address */
13471 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
13473 u32 dp_table = 0, vni = 0;;
13474 unformat_input_t *input = vam->input;
13475 vl_api_lisp_gpe_add_del_fwd_entry_t *mp;
13477 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
13478 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
13479 u8 rmt_eid_set = 0, lcl_eid_set = 0;
13480 u32 action = ~0, w;
13481 ip4_address_t rmt_rloc4, lcl_rloc4;
13482 ip6_address_t rmt_rloc6, lcl_rloc6;
13483 vl_api_lisp_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc =
13486 memset (&rloc, 0, sizeof (rloc));
13488 /* Parse args required to build the message */
13489 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13491 if (unformat (input, "del"))
13493 else if (unformat (input, "add"))
13495 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
13499 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
13503 else if (unformat (input, "vrf %d", &dp_table))
13505 else if (unformat (input, "bd %d", &dp_table))
13507 else if (unformat (input, "vni %d", &vni))
13509 else if (unformat (input, "w %d", &w))
13513 errmsg ("No RLOC configured for setting priority/weight!");
13516 curr_rloc->weight = w;
13518 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
13519 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
13523 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
13525 vec_add1 (lcl_locs, rloc);
13527 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
13528 vec_add1 (rmt_locs, rloc);
13529 /* weight saved in rmt loc */
13530 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
13532 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
13533 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
13536 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
13538 vec_add1 (lcl_locs, rloc);
13540 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
13541 vec_add1 (rmt_locs, rloc);
13542 /* weight saved in rmt loc */
13543 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
13545 else if (unformat (input, "action %d", &action))
13551 clib_warning ("parse error '%U'", format_unformat_error, input);
13558 errmsg ("remote eid addresses not set");
13562 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
13564 errmsg ("eid types don't match");
13568 if (0 == rmt_locs && (u32) ~ 0 == action)
13570 errmsg ("action not set for negative mapping");
13574 /* Construct the API message */
13575 M2 (LISP_GPE_ADD_DEL_FWD_ENTRY, mp,
13576 sizeof (vl_api_lisp_gpe_locator_t) * vec_len (rmt_locs) * 2);
13578 mp->is_add = is_add;
13579 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
13580 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
13581 mp->eid_type = rmt_eid->type;
13582 mp->dp_table = clib_host_to_net_u32 (dp_table);
13583 mp->vni = clib_host_to_net_u32 (vni);
13584 mp->rmt_len = rmt_eid->len;
13585 mp->lcl_len = lcl_eid->len;
13586 mp->action = action;
13588 if (0 != rmt_locs && 0 != lcl_locs)
13590 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
13591 clib_memcpy (mp->locs, lcl_locs,
13592 (sizeof (vl_api_lisp_gpe_locator_t) * vec_len (lcl_locs)));
13594 u32 offset = sizeof (vl_api_lisp_gpe_locator_t) * vec_len (lcl_locs);
13595 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
13596 (sizeof (vl_api_lisp_gpe_locator_t) * vec_len (rmt_locs)));
13598 vec_free (lcl_locs);
13599 vec_free (rmt_locs);
13604 /* Wait for a reply... */
13612 api_lisp_add_del_map_server (vat_main_t * vam)
13614 unformat_input_t *input = vam->input;
13615 vl_api_lisp_add_del_map_server_t *mp;
13619 ip4_address_t ipv4;
13620 ip6_address_t ipv6;
13622 /* Parse args required to build the message */
13623 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13625 if (unformat (input, "del"))
13629 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
13633 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
13641 if (ipv4_set && ipv6_set)
13643 errmsg ("both eid v4 and v6 addresses set");
13647 if (!ipv4_set && !ipv6_set)
13649 errmsg ("eid addresses not set");
13653 /* Construct the API message */
13654 M (LISP_ADD_DEL_MAP_SERVER, mp);
13656 mp->is_add = is_add;
13660 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
13665 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
13671 /* Wait for a reply... */
13679 api_lisp_add_del_map_resolver (vat_main_t * vam)
13681 unformat_input_t *input = vam->input;
13682 vl_api_lisp_add_del_map_resolver_t *mp;
13686 ip4_address_t ipv4;
13687 ip6_address_t ipv6;
13689 /* Parse args required to build the message */
13690 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13692 if (unformat (input, "del"))
13696 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
13700 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
13708 if (ipv4_set && ipv6_set)
13710 errmsg ("both eid v4 and v6 addresses set");
13714 if (!ipv4_set && !ipv6_set)
13716 errmsg ("eid addresses not set");
13720 /* Construct the API message */
13721 M (LISP_ADD_DEL_MAP_RESOLVER, mp);
13723 mp->is_add = is_add;
13727 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
13732 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
13738 /* Wait for a reply... */
13746 api_lisp_gpe_enable_disable (vat_main_t * vam)
13748 unformat_input_t *input = vam->input;
13749 vl_api_lisp_gpe_enable_disable_t *mp;
13753 /* Parse args required to build the message */
13754 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13756 if (unformat (input, "enable"))
13761 else if (unformat (input, "disable"))
13772 errmsg ("Value not set");
13776 /* Construct the API message */
13777 M (LISP_GPE_ENABLE_DISABLE, mp);
13784 /* Wait for a reply... */
13792 api_lisp_rloc_probe_enable_disable (vat_main_t * vam)
13794 unformat_input_t *input = vam->input;
13795 vl_api_lisp_rloc_probe_enable_disable_t *mp;
13799 /* Parse args required to build the message */
13800 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13802 if (unformat (input, "enable"))
13807 else if (unformat (input, "disable"))
13815 errmsg ("Value not set");
13819 /* Construct the API message */
13820 M (LISP_RLOC_PROBE_ENABLE_DISABLE, mp);
13822 mp->is_enabled = is_en;
13827 /* Wait for a reply... */
13835 api_lisp_map_register_enable_disable (vat_main_t * vam)
13837 unformat_input_t *input = vam->input;
13838 vl_api_lisp_map_register_enable_disable_t *mp;
13842 /* Parse args required to build the message */
13843 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13845 if (unformat (input, "enable"))
13850 else if (unformat (input, "disable"))
13858 errmsg ("Value not set");
13862 /* Construct the API message */
13863 M (LISP_MAP_REGISTER_ENABLE_DISABLE, mp);
13865 mp->is_enabled = is_en;
13870 /* Wait for a reply... */
13878 api_lisp_enable_disable (vat_main_t * vam)
13880 unformat_input_t *input = vam->input;
13881 vl_api_lisp_enable_disable_t *mp;
13885 /* Parse args required to build the message */
13886 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13888 if (unformat (input, "enable"))
13893 else if (unformat (input, "disable"))
13903 errmsg ("Value not set");
13907 /* Construct the API message */
13908 M (LISP_ENABLE_DISABLE, mp);
13915 /* Wait for a reply... */
13923 api_show_lisp_map_register_state (vat_main_t * vam)
13925 vl_api_show_lisp_map_register_state_t *mp;
13927 M (SHOW_LISP_MAP_REGISTER_STATE, mp);
13932 /* wait for reply */
13939 api_show_lisp_rloc_probe_state (vat_main_t * vam)
13941 vl_api_show_lisp_rloc_probe_state_t *mp;
13943 M (SHOW_LISP_RLOC_PROBE_STATE, mp);
13948 /* wait for reply */
13955 api_show_lisp_map_request_mode (vat_main_t * vam)
13957 vl_api_show_lisp_map_request_mode_t *mp;
13959 M (SHOW_LISP_MAP_REQUEST_MODE, mp);
13964 /* wait for reply */
13971 api_lisp_map_request_mode (vat_main_t * vam)
13973 unformat_input_t *input = vam->input;
13974 vl_api_lisp_map_request_mode_t *mp;
13977 /* Parse args required to build the message */
13978 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13980 if (unformat (input, "dst-only"))
13982 else if (unformat (input, "src-dst"))
13986 errmsg ("parse error '%U'", format_unformat_error, input);
13991 M (LISP_MAP_REQUEST_MODE, mp);
13998 /* wait for reply */
14006 * Enable/disable LISP proxy ITR.
14008 * @param vam vpp API test context
14009 * @return return code
14012 api_lisp_pitr_set_locator_set (vat_main_t * vam)
14014 u8 ls_name_set = 0;
14015 unformat_input_t *input = vam->input;
14016 vl_api_lisp_pitr_set_locator_set_t *mp;
14020 /* Parse args required to build the message */
14021 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14023 if (unformat (input, "del"))
14025 else if (unformat (input, "locator-set %s", &ls_name))
14029 errmsg ("parse error '%U'", format_unformat_error, input);
14036 errmsg ("locator-set name not set!");
14040 M (LISP_PITR_SET_LOCATOR_SET, mp);
14042 mp->is_add = is_add;
14043 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
14044 vec_free (ls_name);
14049 /* wait for reply */
14057 api_show_lisp_pitr (vat_main_t * vam)
14059 vl_api_show_lisp_pitr_t *mp;
14061 if (!vam->json_output)
14063 print (vam->ofp, "%=20s", "lisp status:");
14066 M (SHOW_LISP_PITR, mp);
14070 /* Wait for a reply... */
14078 * Add/delete mapping between vni and vrf
14081 api_lisp_eid_table_add_del_map (vat_main_t * vam)
14083 unformat_input_t *input = vam->input;
14084 vl_api_lisp_eid_table_add_del_map_t *mp;
14085 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
14086 u32 vni, vrf, bd_index;
14088 /* Parse args required to build the message */
14089 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14091 if (unformat (input, "del"))
14093 else if (unformat (input, "vrf %d", &vrf))
14095 else if (unformat (input, "bd_index %d", &bd_index))
14097 else if (unformat (input, "vni %d", &vni))
14103 if (!vni_set || (!vrf_set && !bd_index_set))
14105 errmsg ("missing arguments!");
14109 if (vrf_set && bd_index_set)
14111 errmsg ("error: both vrf and bd entered!");
14115 M (LISP_EID_TABLE_ADD_DEL_MAP, mp);
14117 mp->is_add = is_add;
14118 mp->vni = htonl (vni);
14119 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
14120 mp->is_l2 = bd_index_set;
14125 /* wait for reply */
14133 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
14135 u32 *action = va_arg (*args, u32 *);
14138 if (unformat (input, "%s", &s))
14140 if (!strcmp ((char *) s, "no-action"))
14142 else if (!strcmp ((char *) s, "natively-forward"))
14144 else if (!strcmp ((char *) s, "send-map-request"))
14146 else if (!strcmp ((char *) s, "drop"))
14150 clib_warning ("invalid action: '%s'", s);
14162 * Add/del remote mapping to/from LISP control plane
14164 * @param vam vpp API test context
14165 * @return return code
14168 api_lisp_add_del_remote_mapping (vat_main_t * vam)
14170 unformat_input_t *input = vam->input;
14171 vl_api_lisp_add_del_remote_mapping_t *mp;
14173 lisp_eid_vat_t _eid, *eid = &_eid;
14174 lisp_eid_vat_t _seid, *seid = &_seid;
14175 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
14176 u32 action = ~0, p, w, data_len;
14177 ip4_address_t rloc4;
14178 ip6_address_t rloc6;
14179 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
14181 memset (&rloc, 0, sizeof (rloc));
14183 /* Parse args required to build the message */
14184 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14186 if (unformat (input, "del-all"))
14190 else if (unformat (input, "del"))
14194 else if (unformat (input, "add"))
14198 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
14202 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
14206 else if (unformat (input, "vni %d", &vni))
14210 else if (unformat (input, "p %d w %d", &p, &w))
14214 errmsg ("No RLOC configured for setting priority/weight!");
14217 curr_rloc->priority = p;
14218 curr_rloc->weight = w;
14220 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
14223 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
14224 vec_add1 (rlocs, rloc);
14225 curr_rloc = &rlocs[vec_len (rlocs) - 1];
14227 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
14230 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
14231 vec_add1 (rlocs, rloc);
14232 curr_rloc = &rlocs[vec_len (rlocs) - 1];
14234 else if (unformat (input, "action %U",
14235 unformat_negative_mapping_action, &action))
14241 clib_warning ("parse error '%U'", format_unformat_error, input);
14248 errmsg ("missing params!");
14252 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
14254 errmsg ("no action set for negative map-reply!");
14258 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
14260 M2 (LISP_ADD_DEL_REMOTE_MAPPING, mp, data_len);
14261 mp->is_add = is_add;
14262 mp->vni = htonl (vni);
14263 mp->action = (u8) action;
14264 mp->is_src_dst = seid_set;
14265 mp->eid_len = eid->len;
14266 mp->seid_len = seid->len;
14267 mp->del_all = del_all;
14268 mp->eid_type = eid->type;
14269 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
14270 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
14272 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
14273 clib_memcpy (mp->rlocs, rlocs, data_len);
14279 /* Wait for a reply... */
14287 * Add/del LISP adjacency. Saves mapping in LISP control plane and updates
14288 * forwarding entries in data-plane accordingly.
14290 * @param vam vpp API test context
14291 * @return return code
14294 api_lisp_add_del_adjacency (vat_main_t * vam)
14296 unformat_input_t *input = vam->input;
14297 vl_api_lisp_add_del_adjacency_t *mp;
14299 ip4_address_t leid4, reid4;
14300 ip6_address_t leid6, reid6;
14301 u8 reid_mac[6] = { 0 };
14302 u8 leid_mac[6] = { 0 };
14303 u8 reid_type, leid_type;
14304 u32 leid_len = 0, reid_len = 0, len;
14307 leid_type = reid_type = (u8) ~ 0;
14309 /* Parse args required to build the message */
14310 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14312 if (unformat (input, "del"))
14316 else if (unformat (input, "add"))
14320 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
14323 reid_type = 0; /* ipv4 */
14326 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
14329 reid_type = 1; /* ipv6 */
14332 else if (unformat (input, "reid %U", unformat_ethernet_address,
14335 reid_type = 2; /* mac */
14337 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
14340 leid_type = 0; /* ipv4 */
14343 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
14346 leid_type = 1; /* ipv6 */
14349 else if (unformat (input, "leid %U", unformat_ethernet_address,
14352 leid_type = 2; /* mac */
14354 else if (unformat (input, "vni %d", &vni))
14360 errmsg ("parse error '%U'", format_unformat_error, input);
14365 if ((u8) ~ 0 == reid_type)
14367 errmsg ("missing params!");
14371 if (leid_type != reid_type)
14373 errmsg ("remote and local EIDs are of different types!");
14377 M (LISP_ADD_DEL_ADJACENCY, mp);
14378 mp->is_add = is_add;
14379 mp->vni = htonl (vni);
14380 mp->leid_len = leid_len;
14381 mp->reid_len = reid_len;
14382 mp->eid_type = reid_type;
14384 switch (mp->eid_type)
14387 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
14388 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
14391 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
14392 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
14395 clib_memcpy (mp->leid, leid_mac, 6);
14396 clib_memcpy (mp->reid, reid_mac, 6);
14399 errmsg ("unknown EID type %d!", mp->eid_type);
14406 /* Wait for a reply... */
14414 api_lisp_gpe_add_del_iface (vat_main_t * vam)
14416 unformat_input_t *input = vam->input;
14417 vl_api_lisp_gpe_add_del_iface_t *mp;
14418 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
14419 u32 dp_table = 0, vni = 0;
14421 /* Parse args required to build the message */
14422 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14424 if (unformat (input, "up"))
14429 else if (unformat (input, "down"))
14434 else if (unformat (input, "table_id %d", &dp_table))
14438 else if (unformat (input, "bd_id %d", &dp_table))
14443 else if (unformat (input, "vni %d", &vni))
14451 if (action_set == 0)
14453 errmsg ("Action not set");
14456 if (dp_table_set == 0 || vni_set == 0)
14458 errmsg ("vni and dp_table must be set");
14462 /* Construct the API message */
14463 M (LISP_GPE_ADD_DEL_IFACE, mp);
14465 mp->is_add = is_add;
14466 mp->dp_table = dp_table;
14473 /* Wait for a reply... */
14481 * Add/del map request itr rlocs from LISP control plane and updates
14483 * @param vam vpp API test context
14484 * @return return code
14487 api_lisp_add_del_map_request_itr_rlocs (vat_main_t * vam)
14489 unformat_input_t *input = vam->input;
14490 vl_api_lisp_add_del_map_request_itr_rlocs_t *mp;
14491 u8 *locator_set_name = 0;
14492 u8 locator_set_name_set = 0;
14495 /* Parse args required to build the message */
14496 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14498 if (unformat (input, "del"))
14502 else if (unformat (input, "%_%v%_", &locator_set_name))
14504 locator_set_name_set = 1;
14508 clib_warning ("parse error '%U'", format_unformat_error, input);
14513 if (is_add && !locator_set_name_set)
14515 errmsg ("itr-rloc is not set!");
14519 if (is_add && vec_len (locator_set_name) > 64)
14521 errmsg ("itr-rloc locator-set name too long");
14522 vec_free (locator_set_name);
14526 M (LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
14527 mp->is_add = is_add;
14530 clib_memcpy (mp->locator_set_name, locator_set_name,
14531 vec_len (locator_set_name));
14535 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
14537 vec_free (locator_set_name);
14542 /* Wait for a reply... */
14550 api_lisp_locator_dump (vat_main_t * vam)
14552 unformat_input_t *input = vam->input;
14553 vl_api_lisp_locator_dump_t *mp;
14554 u8 is_index_set = 0, is_name_set = 0;
14558 /* Parse args required to build the message */
14559 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14561 if (unformat (input, "ls_name %_%v%_", &ls_name))
14565 else if (unformat (input, "ls_index %d", &ls_index))
14571 errmsg ("parse error '%U'", format_unformat_error, input);
14576 if (!is_index_set && !is_name_set)
14578 errmsg ("error: expected one of index or name!");
14582 if (is_index_set && is_name_set)
14584 errmsg ("error: only one param expected!");
14588 if (vec_len (ls_name) > 62)
14590 errmsg ("error: locator set name too long!");
14594 if (!vam->json_output)
14596 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
14599 M (LISP_LOCATOR_DUMP, mp);
14600 mp->is_index_set = is_index_set;
14603 mp->ls_index = clib_host_to_net_u32 (ls_index);
14606 vec_add1 (ls_name, 0);
14607 strncpy ((char *) mp->ls_name, (char *) ls_name,
14608 sizeof (mp->ls_name) - 1);
14614 /* Use a control ping for synchronization */
14616 vl_api_control_ping_t *mp;
14617 M (CONTROL_PING, mp);
14620 /* Wait for a reply... */
14628 api_lisp_locator_set_dump (vat_main_t * vam)
14630 vl_api_lisp_locator_set_dump_t *mp;
14631 unformat_input_t *input = vam->input;
14634 /* Parse args required to build the message */
14635 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14637 if (unformat (input, "local"))
14641 else if (unformat (input, "remote"))
14647 errmsg ("parse error '%U'", format_unformat_error, input);
14652 if (!vam->json_output)
14654 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
14657 M (LISP_LOCATOR_SET_DUMP, mp);
14659 mp->filter = filter;
14664 /* Use a control ping for synchronization */
14666 vl_api_control_ping_t *mp;
14667 M (CONTROL_PING, mp);
14670 /* Wait for a reply... */
14678 api_lisp_eid_table_map_dump (vat_main_t * vam)
14682 unformat_input_t *input = vam->input;
14683 vl_api_lisp_eid_table_map_dump_t *mp;
14685 /* Parse args required to build the message */
14686 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14688 if (unformat (input, "l2"))
14693 else if (unformat (input, "l3"))
14700 errmsg ("parse error '%U'", format_unformat_error, input);
14707 errmsg ("expected one of 'l2' or 'l3' parameter!");
14711 if (!vam->json_output)
14713 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
14716 M (LISP_EID_TABLE_MAP_DUMP, mp);
14722 /* Use a control ping for synchronization */
14724 vl_api_control_ping_t *mp;
14725 M (CONTROL_PING, mp);
14728 /* Wait for a reply... */
14736 api_lisp_eid_table_vni_dump (vat_main_t * vam)
14738 vl_api_lisp_eid_table_vni_dump_t *mp;
14740 if (!vam->json_output)
14742 print (vam->ofp, "VNI");
14745 M (LISP_EID_TABLE_VNI_DUMP, mp);
14750 /* Use a control ping for synchronization */
14752 vl_api_control_ping_t *mp;
14753 M (CONTROL_PING, mp);
14756 /* Wait for a reply... */
14764 api_lisp_eid_table_dump (vat_main_t * vam)
14766 unformat_input_t *i = vam->input;
14767 vl_api_lisp_eid_table_dump_t *mp;
14768 struct in_addr ip4;
14769 struct in6_addr ip6;
14771 u8 eid_type = ~0, eid_set = 0;
14772 u32 prefix_length = ~0, t, vni = 0;
14775 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14777 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
14783 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
14789 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
14794 else if (unformat (i, "vni %d", &t))
14798 else if (unformat (i, "local"))
14802 else if (unformat (i, "remote"))
14808 errmsg ("parse error '%U'", format_unformat_error, i);
14813 if (!vam->json_output)
14815 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
14816 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
14819 M (LISP_EID_TABLE_DUMP, mp);
14821 mp->filter = filter;
14825 mp->vni = htonl (vni);
14826 mp->eid_type = eid_type;
14830 mp->prefix_length = prefix_length;
14831 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
14834 mp->prefix_length = prefix_length;
14835 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
14838 clib_memcpy (mp->eid, mac, sizeof (mac));
14841 errmsg ("unknown EID type %d!", eid_type);
14849 /* Use a control ping for synchronization */
14851 vl_api_control_ping_t *mp;
14852 M (CONTROL_PING, mp);
14856 /* Wait for a reply... */
14864 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
14866 unformat_input_t *i = vam->input;
14867 vl_api_lisp_gpe_fwd_entries_get_t *mp;
14871 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14873 if (unformat (i, "vni %d", &vni))
14879 errmsg ("parse error '%U'", format_unformat_error, i);
14886 errmsg ("vni not set!");
14890 if (!vam->json_output)
14892 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
14896 M (LISP_GPE_FWD_ENTRIES_GET, mp);
14897 mp->vni = clib_host_to_net_u32 (vni);
14902 /* Wait for a reply... */
14909 #define vl_api_lisp_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
14910 #define vl_api_lisp_gpe_fwd_entries_get_reply_t_print vl_noop_handler
14911 #define vl_api_lisp_gpe_fwd_entry_path_details_t_endian vl_noop_handler
14912 #define vl_api_lisp_gpe_fwd_entry_path_details_t_print vl_noop_handler
14915 api_lisp_adjacencies_get (vat_main_t * vam)
14917 unformat_input_t *i = vam->input;
14918 vl_api_lisp_adjacencies_get_t *mp;
14922 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14924 if (unformat (i, "vni %d", &vni))
14930 errmsg ("parse error '%U'", format_unformat_error, i);
14937 errmsg ("vni not set!");
14941 if (!vam->json_output)
14943 print (vam->ofp, "%s %40s", "leid", "reid");
14946 M (LISP_ADJACENCIES_GET, mp);
14947 mp->vni = clib_host_to_net_u32 (vni);
14952 /* Wait for a reply... */
14960 api_lisp_map_server_dump (vat_main_t * vam)
14962 vl_api_lisp_map_server_dump_t *mp;
14964 if (!vam->json_output)
14966 print (vam->ofp, "%=20s", "Map server");
14969 M (LISP_MAP_SERVER_DUMP, mp);
14973 /* Use a control ping for synchronization */
14975 vl_api_control_ping_t *mp;
14976 M (CONTROL_PING, mp);
14979 /* Wait for a reply... */
14987 api_lisp_map_resolver_dump (vat_main_t * vam)
14989 vl_api_lisp_map_resolver_dump_t *mp;
14991 if (!vam->json_output)
14993 print (vam->ofp, "%=20s", "Map resolver");
14996 M (LISP_MAP_RESOLVER_DUMP, mp);
15000 /* Use a control ping for synchronization */
15002 vl_api_control_ping_t *mp;
15003 M (CONTROL_PING, mp);
15006 /* Wait for a reply... */
15014 api_show_lisp_status (vat_main_t * vam)
15016 vl_api_show_lisp_status_t *mp;
15018 if (!vam->json_output)
15020 print (vam->ofp, "%-20s%-16s", "lisp status", "locator-set");
15023 M (SHOW_LISP_STATUS, mp);
15026 /* Wait for a reply... */
15034 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
15036 vl_api_lisp_gpe_fwd_entry_path_dump_t *mp;
15037 unformat_input_t *i = vam->input;
15038 u32 fwd_entry_index = ~0;
15040 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15042 if (unformat (i, "index %d", &fwd_entry_index))
15048 if (~0 == fwd_entry_index)
15050 errmsg ("no index specified!");
15054 if (!vam->json_output)
15056 print (vam->ofp, "first line");
15059 M (LISP_GPE_FWD_ENTRY_PATH_DUMP, mp);
15063 /* Use a control ping for synchronization */
15065 vl_api_control_ping_t *mp;
15066 M (CONTROL_PING, mp);
15069 /* Wait for a reply... */
15077 api_lisp_get_map_request_itr_rlocs (vat_main_t * vam)
15079 vl_api_lisp_get_map_request_itr_rlocs_t *mp;
15081 if (!vam->json_output)
15083 print (vam->ofp, "%=20s", "itr-rlocs:");
15086 M (LISP_GET_MAP_REQUEST_ITR_RLOCS, mp);
15089 /* Wait for a reply... */
15097 api_af_packet_create (vat_main_t * vam)
15099 unformat_input_t *i = vam->input;
15100 vl_api_af_packet_create_t *mp;
15101 u8 *host_if_name = 0;
15103 u8 random_hw_addr = 1;
15105 memset (hw_addr, 0, sizeof (hw_addr));
15107 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15109 if (unformat (i, "name %s", &host_if_name))
15110 vec_add1 (host_if_name, 0);
15111 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
15112 random_hw_addr = 0;
15117 if (!vec_len (host_if_name))
15119 errmsg ("host-interface name must be specified");
15123 if (vec_len (host_if_name) > 64)
15125 errmsg ("host-interface name too long");
15129 M (AF_PACKET_CREATE, mp);
15131 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
15132 clib_memcpy (mp->hw_addr, hw_addr, 6);
15133 mp->use_random_hw_addr = random_hw_addr;
15134 vec_free (host_if_name);
15137 W2 (fprintf (vam->ofp, " new sw_if_index = %d ", vam->sw_if_index));
15143 api_af_packet_delete (vat_main_t * vam)
15145 unformat_input_t *i = vam->input;
15146 vl_api_af_packet_delete_t *mp;
15147 u8 *host_if_name = 0;
15149 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15151 if (unformat (i, "name %s", &host_if_name))
15152 vec_add1 (host_if_name, 0);
15157 if (!vec_len (host_if_name))
15159 errmsg ("host-interface name must be specified");
15163 if (vec_len (host_if_name) > 64)
15165 errmsg ("host-interface name too long");
15169 M (AF_PACKET_DELETE, mp);
15171 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
15172 vec_free (host_if_name);
15181 api_policer_add_del (vat_main_t * vam)
15183 unformat_input_t *i = vam->input;
15184 vl_api_policer_add_del_t *mp;
15194 u8 color_aware = 0;
15195 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
15197 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
15198 conform_action.dscp = 0;
15199 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
15200 exceed_action.dscp = 0;
15201 violate_action.action_type = SSE2_QOS_ACTION_DROP;
15202 violate_action.dscp = 0;
15204 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15206 if (unformat (i, "del"))
15208 else if (unformat (i, "name %s", &name))
15209 vec_add1 (name, 0);
15210 else if (unformat (i, "cir %u", &cir))
15212 else if (unformat (i, "eir %u", &eir))
15214 else if (unformat (i, "cb %u", &cb))
15216 else if (unformat (i, "eb %u", &eb))
15218 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
15221 else if (unformat (i, "round_type %U", unformat_policer_round_type,
15224 else if (unformat (i, "type %U", unformat_policer_type, &type))
15226 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
15229 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
15232 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
15235 else if (unformat (i, "color-aware"))
15241 if (!vec_len (name))
15243 errmsg ("policer name must be specified");
15247 if (vec_len (name) > 64)
15249 errmsg ("policer name too long");
15253 M (POLICER_ADD_DEL, mp);
15255 clib_memcpy (mp->name, name, vec_len (name));
15257 mp->is_add = is_add;
15262 mp->rate_type = rate_type;
15263 mp->round_type = round_type;
15265 mp->conform_action_type = conform_action.action_type;
15266 mp->conform_dscp = conform_action.dscp;
15267 mp->exceed_action_type = exceed_action.action_type;
15268 mp->exceed_dscp = exceed_action.dscp;
15269 mp->violate_action_type = violate_action.action_type;
15270 mp->violate_dscp = violate_action.dscp;
15271 mp->color_aware = color_aware;
15280 api_policer_dump (vat_main_t * vam)
15282 unformat_input_t *i = vam->input;
15283 vl_api_policer_dump_t *mp;
15284 u8 *match_name = 0;
15285 u8 match_name_valid = 0;
15287 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15289 if (unformat (i, "name %s", &match_name))
15291 vec_add1 (match_name, 0);
15292 match_name_valid = 1;
15298 M (POLICER_DUMP, mp);
15299 mp->match_name_valid = match_name_valid;
15300 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
15301 vec_free (match_name);
15305 /* Use a control ping for synchronization */
15307 vl_api_control_ping_t *mp;
15308 M (CONTROL_PING, mp);
15311 /* Wait for a reply... */
15319 api_policer_classify_set_interface (vat_main_t * vam)
15321 unformat_input_t *i = vam->input;
15322 vl_api_policer_classify_set_interface_t *mp;
15324 int sw_if_index_set;
15325 u32 ip4_table_index = ~0;
15326 u32 ip6_table_index = ~0;
15327 u32 l2_table_index = ~0;
15330 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15332 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15333 sw_if_index_set = 1;
15334 else if (unformat (i, "sw_if_index %d", &sw_if_index))
15335 sw_if_index_set = 1;
15336 else if (unformat (i, "del"))
15338 else if (unformat (i, "ip4-table %d", &ip4_table_index))
15340 else if (unformat (i, "ip6-table %d", &ip6_table_index))
15342 else if (unformat (i, "l2-table %d", &l2_table_index))
15346 clib_warning ("parse error '%U'", format_unformat_error, i);
15351 if (sw_if_index_set == 0)
15353 errmsg ("missing interface name or sw_if_index");
15357 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
15359 mp->sw_if_index = ntohl (sw_if_index);
15360 mp->ip4_table_index = ntohl (ip4_table_index);
15361 mp->ip6_table_index = ntohl (ip6_table_index);
15362 mp->l2_table_index = ntohl (l2_table_index);
15363 mp->is_add = is_add;
15372 api_policer_classify_dump (vat_main_t * vam)
15374 unformat_input_t *i = vam->input;
15375 vl_api_policer_classify_dump_t *mp;
15376 u8 type = POLICER_CLASSIFY_N_TABLES;
15378 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
15382 errmsg ("classify table type must be specified");
15386 if (!vam->json_output)
15388 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
15391 M (POLICER_CLASSIFY_DUMP, mp);
15396 /* Use a control ping for synchronization */
15398 vl_api_control_ping_t *mp;
15399 M (CONTROL_PING, mp);
15402 /* Wait for a reply... */
15410 api_netmap_create (vat_main_t * vam)
15412 unformat_input_t *i = vam->input;
15413 vl_api_netmap_create_t *mp;
15416 u8 random_hw_addr = 1;
15420 memset (hw_addr, 0, sizeof (hw_addr));
15422 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15424 if (unformat (i, "name %s", &if_name))
15425 vec_add1 (if_name, 0);
15426 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
15427 random_hw_addr = 0;
15428 else if (unformat (i, "pipe"))
15430 else if (unformat (i, "master"))
15432 else if (unformat (i, "slave"))
15438 if (!vec_len (if_name))
15440 errmsg ("interface name must be specified");
15444 if (vec_len (if_name) > 64)
15446 errmsg ("interface name too long");
15450 M (NETMAP_CREATE, mp);
15452 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
15453 clib_memcpy (mp->hw_addr, hw_addr, 6);
15454 mp->use_random_hw_addr = random_hw_addr;
15455 mp->is_pipe = is_pipe;
15456 mp->is_master = is_master;
15457 vec_free (if_name);
15466 api_netmap_delete (vat_main_t * vam)
15468 unformat_input_t *i = vam->input;
15469 vl_api_netmap_delete_t *mp;
15472 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15474 if (unformat (i, "name %s", &if_name))
15475 vec_add1 (if_name, 0);
15480 if (!vec_len (if_name))
15482 errmsg ("interface name must be specified");
15486 if (vec_len (if_name) > 64)
15488 errmsg ("interface name too long");
15492 M (NETMAP_DELETE, mp);
15494 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
15495 vec_free (if_name);
15503 static void vl_api_mpls_tunnel_details_t_handler
15504 (vl_api_mpls_tunnel_details_t * mp)
15506 vat_main_t *vam = &vat_main;
15507 i32 len = mp->mt_next_hop_n_labels;
15510 print (vam->ofp, "[%d]: via %U %d labels ",
15512 format_ip4_address, mp->mt_next_hop,
15513 ntohl (mp->mt_next_hop_sw_if_index));
15514 for (i = 0; i < len; i++)
15516 print (vam->ofp, "%u ", ntohl (mp->mt_next_hop_out_labels[i]));
15518 print (vam->ofp, "");
15521 static void vl_api_mpls_tunnel_details_t_handler_json
15522 (vl_api_mpls_tunnel_details_t * mp)
15524 vat_main_t *vam = &vat_main;
15525 vat_json_node_t *node = NULL;
15526 struct in_addr ip4;
15528 i32 len = mp->mt_next_hop_n_labels;
15530 if (VAT_JSON_ARRAY != vam->json_tree.type)
15532 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15533 vat_json_init_array (&vam->json_tree);
15535 node = vat_json_array_add (&vam->json_tree);
15537 vat_json_init_object (node);
15538 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
15539 clib_memcpy (&ip4, &(mp->mt_next_hop), sizeof (ip4));
15540 vat_json_object_add_ip4 (node, "next_hop", ip4);
15541 vat_json_object_add_uint (node, "next_hop_sw_if_index",
15542 ntohl (mp->mt_next_hop_sw_if_index));
15543 vat_json_object_add_uint (node, "l2_only", ntohl (mp->mt_l2_only));
15544 vat_json_object_add_uint (node, "label_count", len);
15545 for (i = 0; i < len; i++)
15547 vat_json_object_add_uint (node, "label",
15548 ntohl (mp->mt_next_hop_out_labels[i]));
15553 api_mpls_tunnel_dump (vat_main_t * vam)
15555 vl_api_mpls_tunnel_dump_t *mp;
15558 /* Parse args required to build the message */
15559 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
15561 if (!unformat (vam->input, "tunnel_index %d", &index))
15568 print (vam->ofp, " tunnel_index %d", index);
15570 M (MPLS_TUNNEL_DUMP, mp);
15571 mp->tunnel_index = htonl (index);
15574 /* Use a control ping for synchronization */
15576 vl_api_control_ping_t *mp;
15577 M (CONTROL_PING, mp);
15583 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
15584 #define vl_api_mpls_fib_details_t_print vl_noop_handler
15587 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
15589 vat_main_t *vam = &vat_main;
15590 int count = ntohl (mp->count);
15591 vl_api_fib_path2_t *fp;
15595 "table-id %d, label %u, ess_bit %u",
15596 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
15598 for (i = 0; i < count; i++)
15600 if (fp->afi == IP46_TYPE_IP6)
15602 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15603 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15604 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15605 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15606 format_ip6_address, fp->next_hop);
15607 else if (fp->afi == IP46_TYPE_IP4)
15609 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15610 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15611 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15612 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15613 format_ip4_address, fp->next_hop);
15618 static void vl_api_mpls_fib_details_t_handler_json
15619 (vl_api_mpls_fib_details_t * mp)
15621 vat_main_t *vam = &vat_main;
15622 int count = ntohl (mp->count);
15623 vat_json_node_t *node = NULL;
15624 struct in_addr ip4;
15625 struct in6_addr ip6;
15626 vl_api_fib_path2_t *fp;
15629 if (VAT_JSON_ARRAY != vam->json_tree.type)
15631 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15632 vat_json_init_array (&vam->json_tree);
15634 node = vat_json_array_add (&vam->json_tree);
15636 vat_json_init_object (node);
15637 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
15638 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
15639 vat_json_object_add_uint (node, "label", ntohl (mp->label));
15640 vat_json_object_add_uint (node, "path_count", count);
15642 for (i = 0; i < count; i++)
15644 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
15645 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
15646 vat_json_object_add_uint (node, "is_local", fp->is_local);
15647 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
15648 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
15649 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
15650 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
15651 if (fp->afi == IP46_TYPE_IP4)
15653 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
15654 vat_json_object_add_ip4 (node, "next_hop", ip4);
15656 else if (fp->afi == IP46_TYPE_IP6)
15658 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
15659 vat_json_object_add_ip6 (node, "next_hop", ip6);
15665 api_mpls_fib_dump (vat_main_t * vam)
15667 vl_api_mpls_fib_dump_t *mp;
15669 M (MPLS_FIB_DUMP, mp);
15672 /* Use a control ping for synchronization */
15674 vl_api_control_ping_t *mp;
15675 M (CONTROL_PING, mp);
15681 #define vl_api_ip_fib_details_t_endian vl_noop_handler
15682 #define vl_api_ip_fib_details_t_print vl_noop_handler
15685 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
15687 vat_main_t *vam = &vat_main;
15688 int count = ntohl (mp->count);
15689 vl_api_fib_path_t *fp;
15693 "table-id %d, prefix %U/%d",
15694 ntohl (mp->table_id), format_ip4_address, mp->address,
15695 mp->address_length);
15697 for (i = 0; i < count; i++)
15699 if (fp->afi == IP46_TYPE_IP6)
15701 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15702 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15703 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15704 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15705 format_ip6_address, fp->next_hop);
15706 else if (fp->afi == IP46_TYPE_IP4)
15708 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15709 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15710 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15711 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15712 format_ip4_address, fp->next_hop);
15717 static void vl_api_ip_fib_details_t_handler_json
15718 (vl_api_ip_fib_details_t * mp)
15720 vat_main_t *vam = &vat_main;
15721 int count = ntohl (mp->count);
15722 vat_json_node_t *node = NULL;
15723 struct in_addr ip4;
15724 struct in6_addr ip6;
15725 vl_api_fib_path_t *fp;
15728 if (VAT_JSON_ARRAY != vam->json_tree.type)
15730 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15731 vat_json_init_array (&vam->json_tree);
15733 node = vat_json_array_add (&vam->json_tree);
15735 vat_json_init_object (node);
15736 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
15737 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
15738 vat_json_object_add_ip4 (node, "prefix", ip4);
15739 vat_json_object_add_uint (node, "mask_length", mp->address_length);
15740 vat_json_object_add_uint (node, "path_count", count);
15742 for (i = 0; i < count; i++)
15744 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
15745 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
15746 vat_json_object_add_uint (node, "is_local", fp->is_local);
15747 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
15748 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
15749 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
15750 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
15751 if (fp->afi == IP46_TYPE_IP4)
15753 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
15754 vat_json_object_add_ip4 (node, "next_hop", ip4);
15756 else if (fp->afi == IP46_TYPE_IP6)
15758 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
15759 vat_json_object_add_ip6 (node, "next_hop", ip6);
15765 api_ip_fib_dump (vat_main_t * vam)
15767 vl_api_ip_fib_dump_t *mp;
15769 M (IP_FIB_DUMP, mp);
15772 /* Use a control ping for synchronization */
15774 vl_api_control_ping_t *mp;
15775 M (CONTROL_PING, mp);
15781 static void vl_api_ip_neighbor_details_t_handler
15782 (vl_api_ip_neighbor_details_t * mp)
15784 vat_main_t *vam = &vat_main;
15786 print (vam->ofp, "%c %U %U",
15787 (mp->is_static) ? 'S' : 'D',
15788 format_ethernet_address, &mp->mac_address,
15789 (mp->is_ipv6) ? format_ip6_address : format_ip4_address,
15793 static void vl_api_ip_neighbor_details_t_handler_json
15794 (vl_api_ip_neighbor_details_t * mp)
15797 vat_main_t *vam = &vat_main;
15798 vat_json_node_t *node;
15799 struct in_addr ip4;
15800 struct in6_addr ip6;
15802 if (VAT_JSON_ARRAY != vam->json_tree.type)
15804 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15805 vat_json_init_array (&vam->json_tree);
15807 node = vat_json_array_add (&vam->json_tree);
15809 vat_json_init_object (node);
15810 vat_json_object_add_string_copy (node, "flag",
15811 (mp->is_static) ? (u8 *) "static" : (u8 *)
15814 vat_json_object_add_string_copy (node, "link_layer",
15815 format (0, "%U", format_ethernet_address,
15816 &mp->mac_address));
15820 clib_memcpy (&ip6, &mp->ip_address, sizeof (ip6));
15821 vat_json_object_add_ip6 (node, "ip_address", ip6);
15825 clib_memcpy (&ip4, &mp->ip_address, sizeof (ip4));
15826 vat_json_object_add_ip4 (node, "ip_address", ip4);
15831 api_ip_neighbor_dump (vat_main_t * vam)
15833 unformat_input_t *i = vam->input;
15834 vl_api_ip_neighbor_dump_t *mp;
15836 u32 sw_if_index = ~0;
15838 /* Parse args required to build the message */
15839 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15841 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15843 else if (unformat (i, "sw_if_index %d", &sw_if_index))
15845 else if (unformat (i, "ip6"))
15851 if (sw_if_index == ~0)
15853 errmsg ("missing interface name or sw_if_index");
15857 M (IP_NEIGHBOR_DUMP, mp);
15858 mp->is_ipv6 = (u8) is_ipv6;
15859 mp->sw_if_index = ntohl (sw_if_index);
15862 /* Use a control ping for synchronization */
15864 vl_api_control_ping_t *mp;
15865 M (CONTROL_PING, mp);
15871 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
15872 #define vl_api_ip6_fib_details_t_print vl_noop_handler
15875 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
15877 vat_main_t *vam = &vat_main;
15878 int count = ntohl (mp->count);
15879 vl_api_fib_path_t *fp;
15883 "table-id %d, prefix %U/%d",
15884 ntohl (mp->table_id), format_ip6_address, mp->address,
15885 mp->address_length);
15887 for (i = 0; i < count; i++)
15889 if (fp->afi == IP46_TYPE_IP6)
15891 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15892 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15893 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15894 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15895 format_ip6_address, fp->next_hop);
15896 else if (fp->afi == IP46_TYPE_IP4)
15898 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15899 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15900 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15901 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15902 format_ip4_address, fp->next_hop);
15907 static void vl_api_ip6_fib_details_t_handler_json
15908 (vl_api_ip6_fib_details_t * mp)
15910 vat_main_t *vam = &vat_main;
15911 int count = ntohl (mp->count);
15912 vat_json_node_t *node = NULL;
15913 struct in_addr ip4;
15914 struct in6_addr ip6;
15915 vl_api_fib_path_t *fp;
15918 if (VAT_JSON_ARRAY != vam->json_tree.type)
15920 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15921 vat_json_init_array (&vam->json_tree);
15923 node = vat_json_array_add (&vam->json_tree);
15925 vat_json_init_object (node);
15926 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
15927 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
15928 vat_json_object_add_ip6 (node, "prefix", ip6);
15929 vat_json_object_add_uint (node, "mask_length", mp->address_length);
15930 vat_json_object_add_uint (node, "path_count", count);
15932 for (i = 0; i < count; i++)
15934 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
15935 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
15936 vat_json_object_add_uint (node, "is_local", fp->is_local);
15937 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
15938 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
15939 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
15940 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
15941 if (fp->afi == IP46_TYPE_IP4)
15943 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
15944 vat_json_object_add_ip4 (node, "next_hop", ip4);
15946 else if (fp->afi == IP46_TYPE_IP6)
15948 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
15949 vat_json_object_add_ip6 (node, "next_hop", ip6);
15955 api_ip6_fib_dump (vat_main_t * vam)
15957 vl_api_ip6_fib_dump_t *mp;
15959 M (IP6_FIB_DUMP, mp);
15962 /* Use a control ping for synchronization */
15964 vl_api_control_ping_t *mp;
15965 M (CONTROL_PING, mp);
15972 api_classify_table_ids (vat_main_t * vam)
15974 vl_api_classify_table_ids_t *mp;
15976 /* Construct the API message */
15977 M (CLASSIFY_TABLE_IDS, mp);
15987 api_classify_table_by_interface (vat_main_t * vam)
15989 unformat_input_t *input = vam->input;
15990 vl_api_classify_table_by_interface_t *mp;
15992 u32 sw_if_index = ~0;
15993 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15995 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15997 else if (unformat (input, "sw_if_index %d", &sw_if_index))
16002 if (sw_if_index == ~0)
16004 errmsg ("missing interface name or sw_if_index");
16008 /* Construct the API message */
16009 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
16011 mp->sw_if_index = ntohl (sw_if_index);
16020 api_classify_table_info (vat_main_t * vam)
16022 unformat_input_t *input = vam->input;
16023 vl_api_classify_table_info_t *mp;
16026 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16028 if (unformat (input, "table_id %d", &table_id))
16033 if (table_id == ~0)
16035 errmsg ("missing table id");
16039 /* Construct the API message */
16040 M (CLASSIFY_TABLE_INFO, mp);
16042 mp->table_id = ntohl (table_id);
16051 api_classify_session_dump (vat_main_t * vam)
16053 unformat_input_t *input = vam->input;
16054 vl_api_classify_session_dump_t *mp;
16057 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16059 if (unformat (input, "table_id %d", &table_id))
16064 if (table_id == ~0)
16066 errmsg ("missing table id");
16070 /* Construct the API message */
16071 M (CLASSIFY_SESSION_DUMP, mp);
16073 mp->table_id = ntohl (table_id);
16076 /* Use a control ping for synchronization */
16078 vl_api_control_ping_t *mp;
16079 M (CONTROL_PING, mp);
16088 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
16090 vat_main_t *vam = &vat_main;
16092 print (vam->ofp, "collector_address %U, collector_port %d, "
16093 "src_address %U, vrf_id %d, path_mtu %u, "
16094 "template_interval %u, udp_checksum %d",
16095 format_ip4_address, mp->collector_address,
16096 ntohs (mp->collector_port),
16097 format_ip4_address, mp->src_address,
16098 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
16099 ntohl (mp->template_interval), mp->udp_checksum);
16102 vam->result_ready = 1;
16106 vl_api_ipfix_exporter_details_t_handler_json
16107 (vl_api_ipfix_exporter_details_t * mp)
16109 vat_main_t *vam = &vat_main;
16110 vat_json_node_t node;
16111 struct in_addr collector_address;
16112 struct in_addr src_address;
16114 vat_json_init_object (&node);
16115 clib_memcpy (&collector_address, &mp->collector_address,
16116 sizeof (collector_address));
16117 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
16118 vat_json_object_add_uint (&node, "collector_port",
16119 ntohs (mp->collector_port));
16120 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
16121 vat_json_object_add_ip4 (&node, "src_address", src_address);
16122 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
16123 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
16124 vat_json_object_add_uint (&node, "template_interval",
16125 ntohl (mp->template_interval));
16126 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
16128 vat_json_print (vam->ofp, &node);
16129 vat_json_free (&node);
16131 vam->result_ready = 1;
16135 api_ipfix_exporter_dump (vat_main_t * vam)
16137 vl_api_ipfix_exporter_dump_t *mp;
16139 /* Construct the API message */
16140 M (IPFIX_EXPORTER_DUMP, mp);
16150 api_ipfix_classify_stream_dump (vat_main_t * vam)
16152 vl_api_ipfix_classify_stream_dump_t *mp;
16154 /* Construct the API message */
16155 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
16165 vl_api_ipfix_classify_stream_details_t_handler
16166 (vl_api_ipfix_classify_stream_details_t * mp)
16168 vat_main_t *vam = &vat_main;
16169 print (vam->ofp, "domain_id %d, src_port %d",
16170 ntohl (mp->domain_id), ntohs (mp->src_port));
16172 vam->result_ready = 1;
16176 vl_api_ipfix_classify_stream_details_t_handler_json
16177 (vl_api_ipfix_classify_stream_details_t * mp)
16179 vat_main_t *vam = &vat_main;
16180 vat_json_node_t node;
16182 vat_json_init_object (&node);
16183 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
16184 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
16186 vat_json_print (vam->ofp, &node);
16187 vat_json_free (&node);
16189 vam->result_ready = 1;
16193 api_ipfix_classify_table_dump (vat_main_t * vam)
16195 vl_api_ipfix_classify_table_dump_t *mp;
16197 if (!vam->json_output)
16199 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
16200 "transport_protocol");
16203 /* Construct the API message */
16204 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
16209 /* Use a control ping for synchronization */
16211 vl_api_control_ping_t *mp;
16212 M (CONTROL_PING, mp);
16219 vl_api_ipfix_classify_table_details_t_handler
16220 (vl_api_ipfix_classify_table_details_t * mp)
16222 vat_main_t *vam = &vat_main;
16223 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
16224 mp->transport_protocol);
16228 vl_api_ipfix_classify_table_details_t_handler_json
16229 (vl_api_ipfix_classify_table_details_t * mp)
16231 vat_json_node_t *node = NULL;
16232 vat_main_t *vam = &vat_main;
16234 if (VAT_JSON_ARRAY != vam->json_tree.type)
16236 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16237 vat_json_init_array (&vam->json_tree);
16240 node = vat_json_array_add (&vam->json_tree);
16241 vat_json_init_object (node);
16243 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
16244 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
16245 vat_json_object_add_uint (node, "transport_protocol",
16246 mp->transport_protocol);
16250 api_sw_interface_span_enable_disable (vat_main_t * vam)
16252 unformat_input_t *i = vam->input;
16253 vl_api_sw_interface_span_enable_disable_t *mp;
16254 u32 src_sw_if_index = ~0;
16255 u32 dst_sw_if_index = ~0;
16258 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16261 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
16263 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
16267 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
16269 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
16271 else if (unformat (i, "disable"))
16273 else if (unformat (i, "rx"))
16275 else if (unformat (i, "tx"))
16277 else if (unformat (i, "both"))
16283 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
16285 mp->sw_if_index_from = htonl (src_sw_if_index);
16286 mp->sw_if_index_to = htonl (dst_sw_if_index);
16296 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
16299 vat_main_t *vam = &vat_main;
16300 u8 *sw_if_from_name = 0;
16301 u8 *sw_if_to_name = 0;
16302 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
16303 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
16304 char *states[] = { "none", "rx", "tx", "both" };
16308 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
16310 if ((u32) p->value[0] == sw_if_index_from)
16312 sw_if_from_name = (u8 *)(p->key);
16316 if ((u32) p->value[0] == sw_if_index_to)
16318 sw_if_to_name = (u8 *)(p->key);
16319 if (sw_if_from_name)
16324 print (vam->ofp, "%20s => %20s (%s)",
16325 sw_if_from_name, sw_if_to_name, states[mp->state]);
16329 vl_api_sw_interface_span_details_t_handler_json
16330 (vl_api_sw_interface_span_details_t * mp)
16332 vat_main_t *vam = &vat_main;
16333 vat_json_node_t *node = NULL;
16334 u8 *sw_if_from_name = 0;
16335 u8 *sw_if_to_name = 0;
16336 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
16337 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
16341 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
16343 if ((u32) p->value[0] == sw_if_index_from)
16345 sw_if_from_name = (u8 *)(p->key);
16349 if ((u32) p->value[0] == sw_if_index_to)
16351 sw_if_to_name = (u8 *)(p->key);
16352 if (sw_if_from_name)
16358 if (VAT_JSON_ARRAY != vam->json_tree.type)
16360 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16361 vat_json_init_array (&vam->json_tree);
16363 node = vat_json_array_add (&vam->json_tree);
16365 vat_json_init_object (node);
16366 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
16367 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
16368 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
16369 if (0 != sw_if_to_name)
16371 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
16373 vat_json_object_add_uint (node, "state", mp->state);
16377 api_sw_interface_span_dump (vat_main_t * vam)
16379 vl_api_sw_interface_span_dump_t *mp;
16381 M (SW_INTERFACE_SPAN_DUMP, mp);
16384 /* Use a control ping for synchronization */
16386 vl_api_control_ping_t *mp;
16387 M (CONTROL_PING, mp);
16394 api_pg_create_interface (vat_main_t * vam)
16396 unformat_input_t *input = vam->input;
16397 vl_api_pg_create_interface_t *mp;
16400 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16402 if (unformat (input, "if_id %d", &if_id))
16409 errmsg ("missing pg interface index");
16413 /* Construct the API message */
16414 M (PG_CREATE_INTERFACE, mp);
16416 mp->interface_id = ntohl (if_id);
16425 api_pg_capture (vat_main_t * vam)
16427 unformat_input_t *input = vam->input;
16428 vl_api_pg_capture_t *mp;
16433 u8 pcap_file_set = 0;
16435 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16437 if (unformat (input, "if_id %d", &if_id))
16439 else if (unformat (input, "pcap %s", &pcap_file))
16441 else if (unformat (input, "count %d", &count))
16443 else if (unformat (input, "disable"))
16450 errmsg ("missing pg interface index");
16453 if (pcap_file_set > 0)
16455 if (vec_len (pcap_file) > 255)
16457 errmsg ("pcap file name is too long");
16462 u32 name_len = vec_len (pcap_file);
16463 /* Construct the API message */
16464 M (PG_CAPTURE, mp);
16466 mp->interface_id = ntohl (if_id);
16467 mp->is_enabled = enable;
16468 mp->count = ntohl (count);
16469 mp->pcap_name_length = ntohl (name_len);
16470 if (pcap_file_set != 0)
16472 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
16474 vec_free (pcap_file);
16483 api_pg_enable_disable (vat_main_t * vam)
16485 unformat_input_t *input = vam->input;
16486 vl_api_pg_enable_disable_t *mp;
16489 u8 stream_name_set = 0;
16490 u8 *stream_name = 0;
16491 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16493 if (unformat (input, "stream %s", &stream_name))
16494 stream_name_set = 1;
16495 else if (unformat (input, "disable"))
16501 if (stream_name_set > 0)
16503 if (vec_len (stream_name) > 255)
16505 errmsg ("stream name too long");
16510 u32 name_len = vec_len (stream_name);
16511 /* Construct the API message */
16512 M (PG_ENABLE_DISABLE, mp);
16514 mp->is_enabled = enable;
16515 if (stream_name_set != 0)
16517 mp->stream_name_length = ntohl (name_len);
16518 clib_memcpy (mp->stream_name, stream_name, name_len);
16520 vec_free (stream_name);
16529 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
16531 unformat_input_t *input = vam->input;
16532 vl_api_ip_source_and_port_range_check_add_del_t *mp;
16534 u16 *low_ports = 0;
16535 u16 *high_ports = 0;
16538 ip4_address_t ip4_addr;
16539 ip6_address_t ip6_addr;
16547 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16549 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
16555 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
16560 else if (unformat (input, "vrf %d", &vrf_id))
16562 else if (unformat (input, "del"))
16564 else if (unformat (input, "port %d", &tmp))
16566 if (tmp == 0 || tmp > 65535)
16568 errmsg ("port %d out of range", tmp);
16572 this_hi = this_low + 1;
16573 vec_add1 (low_ports, this_low);
16574 vec_add1 (high_ports, this_hi);
16576 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
16578 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
16580 errmsg ("incorrect range parameters");
16584 /* Note: in debug CLI +1 is added to high before
16585 passing to real fn that does "the work"
16586 (ip_source_and_port_range_check_add_del).
16587 This fn is a wrapper around the binary API fn a
16588 control plane will call, which expects this increment
16589 to have occurred. Hence letting the binary API control
16590 plane fn do the increment for consistency between VAT
16591 and other control planes.
16594 vec_add1 (low_ports, this_low);
16595 vec_add1 (high_ports, this_hi);
16601 if (prefix_set == 0)
16603 errmsg ("<address>/<mask> not specified");
16609 errmsg ("VRF ID required, not specified");
16616 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
16620 if (vec_len (low_ports) == 0)
16622 errmsg ("At least one port or port range required");
16626 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
16628 mp->is_add = is_add;
16633 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
16638 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
16641 mp->mask_length = length;
16642 mp->number_of_ranges = vec_len (low_ports);
16644 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
16645 vec_free (low_ports);
16647 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
16648 vec_free (high_ports);
16650 mp->vrf_id = ntohl (vrf_id);
16659 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
16661 unformat_input_t *input = vam->input;
16662 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
16663 u32 sw_if_index = ~0;
16665 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
16666 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
16669 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16671 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16673 else if (unformat (input, "sw_if_index %d", &sw_if_index))
16675 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
16677 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
16679 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
16681 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
16683 else if (unformat (input, "del"))
16689 if (sw_if_index == ~0)
16691 errmsg ("Interface required but not specified");
16697 errmsg ("VRF ID required but not specified");
16701 if (tcp_out_vrf_id == 0
16702 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
16705 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
16709 /* Construct the API message */
16710 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
16712 mp->sw_if_index = ntohl (sw_if_index);
16713 mp->is_add = is_add;
16714 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
16715 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
16716 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
16717 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
16722 /* Wait for a reply... */
16727 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
16729 unformat_input_t *i = vam->input;
16730 vl_api_ipsec_gre_add_del_tunnel_t *mp;
16731 u32 local_sa_id = 0;
16732 u32 remote_sa_id = 0;
16733 ip4_address_t src_address;
16734 ip4_address_t dst_address;
16737 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16739 if (unformat (i, "local_sa %d", &local_sa_id))
16741 else if (unformat (i, "remote_sa %d", &remote_sa_id))
16743 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
16745 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
16747 else if (unformat (i, "del"))
16751 clib_warning ("parse error '%U'", format_unformat_error, i);
16756 M (IPSEC_GRE_ADD_DEL_TUNNEL, mp);
16758 mp->local_sa_id = ntohl (local_sa_id);
16759 mp->remote_sa_id = ntohl (remote_sa_id);
16760 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
16761 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
16762 mp->is_add = is_add;
16771 api_punt (vat_main_t * vam)
16773 unformat_input_t *i = vam->input;
16780 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16782 if (unformat (i, "ip %d", &ipv))
16784 else if (unformat (i, "protocol %d", &protocol))
16786 else if (unformat (i, "port %d", &port))
16788 else if (unformat (i, "del"))
16792 clib_warning ("parse error '%U'", format_unformat_error, i);
16799 mp->is_add = (u8) is_add;
16800 mp->ipv = (u8) ipv;
16801 mp->l4_protocol = (u8) protocol;
16802 mp->l4_port = htons ((u16) port);
16810 static void vl_api_ipsec_gre_tunnel_details_t_handler
16811 (vl_api_ipsec_gre_tunnel_details_t * mp)
16813 vat_main_t *vam = &vat_main;
16815 print (vam->ofp, "%11d%15U%15U%14d%14d",
16816 ntohl (mp->sw_if_index),
16817 format_ip4_address, &mp->src_address,
16818 format_ip4_address, &mp->dst_address,
16819 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
16822 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
16823 (vl_api_ipsec_gre_tunnel_details_t * mp)
16825 vat_main_t *vam = &vat_main;
16826 vat_json_node_t *node = NULL;
16827 struct in_addr ip4;
16829 if (VAT_JSON_ARRAY != vam->json_tree.type)
16831 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16832 vat_json_init_array (&vam->json_tree);
16834 node = vat_json_array_add (&vam->json_tree);
16836 vat_json_init_object (node);
16837 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
16838 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
16839 vat_json_object_add_ip4 (node, "src_address", ip4);
16840 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
16841 vat_json_object_add_ip4 (node, "dst_address", ip4);
16842 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
16843 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
16847 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
16849 unformat_input_t *i = vam->input;
16850 vl_api_ipsec_gre_tunnel_dump_t *mp;
16852 u8 sw_if_index_set = 0;
16854 /* Parse args required to build the message */
16855 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16857 if (unformat (i, "sw_if_index %d", &sw_if_index))
16858 sw_if_index_set = 1;
16863 if (sw_if_index_set == 0)
16868 if (!vam->json_output)
16870 print (vam->ofp, "%11s%15s%15s%14s%14s",
16871 "sw_if_index", "src_address", "dst_address",
16872 "local_sa_id", "remote_sa_id");
16875 /* Get list of gre-tunnel interfaces */
16876 M (IPSEC_GRE_TUNNEL_DUMP, mp);
16878 mp->sw_if_index = htonl (sw_if_index);
16882 /* Use a control ping for synchronization */
16884 vl_api_control_ping_t *mp;
16885 M (CONTROL_PING, mp);
16892 api_delete_subif (vat_main_t * vam)
16894 unformat_input_t *i = vam->input;
16895 vl_api_delete_subif_t *mp;
16896 u32 sw_if_index = ~0;
16898 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16900 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16902 if (unformat (i, "sw_if_index %d", &sw_if_index))
16908 if (sw_if_index == ~0)
16910 errmsg ("missing sw_if_index");
16914 /* Construct the API message */
16915 M (DELETE_SUBIF, mp);
16916 mp->sw_if_index = ntohl (sw_if_index);
16922 #define foreach_pbb_vtr_op \
16923 _("disable", L2_VTR_DISABLED) \
16924 _("pop", L2_VTR_POP_2) \
16925 _("push", L2_VTR_PUSH_2)
16928 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
16930 unformat_input_t *i = vam->input;
16931 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
16932 u32 sw_if_index = ~0, vtr_op = ~0;
16933 u16 outer_tag = ~0;
16934 u8 dmac[6], smac[6];
16935 u8 dmac_set = 0, smac_set = 0;
16940 /* Shut up coverity */
16941 memset (dmac, 0, sizeof (dmac));
16942 memset (smac, 0, sizeof (smac));
16944 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16946 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16948 else if (unformat (i, "sw_if_index %d", &sw_if_index))
16950 else if (unformat (i, "vtr_op %d", &vtr_op))
16952 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
16955 else if (unformat (i, "translate_pbb_stag"))
16957 if (unformat (i, "%d", &tmp))
16959 vtr_op = L2_VTR_TRANSLATE_2_1;
16965 ("translate_pbb_stag operation requires outer tag definition");
16969 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
16971 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
16973 else if (unformat (i, "sid %d", &sid))
16975 else if (unformat (i, "vlanid %d", &tmp))
16979 clib_warning ("parse error '%U'", format_unformat_error, i);
16984 if ((sw_if_index == ~0) || (vtr_op == ~0))
16986 errmsg ("missing sw_if_index or vtr operation");
16989 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
16990 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
16993 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
16997 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
16998 mp->sw_if_index = ntohl (sw_if_index);
16999 mp->vtr_op = ntohl (vtr_op);
17000 mp->outer_tag = ntohs (outer_tag);
17001 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
17002 clib_memcpy (mp->b_smac, smac, sizeof (smac));
17003 mp->b_vlanid = ntohs (vlanid);
17004 mp->i_sid = ntohl (sid);
17013 api_flow_classify_set_interface (vat_main_t * vam)
17015 unformat_input_t *i = vam->input;
17016 vl_api_flow_classify_set_interface_t *mp;
17018 int sw_if_index_set;
17019 u32 ip4_table_index = ~0;
17020 u32 ip6_table_index = ~0;
17023 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17025 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17026 sw_if_index_set = 1;
17027 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17028 sw_if_index_set = 1;
17029 else if (unformat (i, "del"))
17031 else if (unformat (i, "ip4-table %d", &ip4_table_index))
17033 else if (unformat (i, "ip6-table %d", &ip6_table_index))
17037 clib_warning ("parse error '%U'", format_unformat_error, i);
17042 if (sw_if_index_set == 0)
17044 errmsg ("missing interface name or sw_if_index");
17048 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
17050 mp->sw_if_index = ntohl (sw_if_index);
17051 mp->ip4_table_index = ntohl (ip4_table_index);
17052 mp->ip6_table_index = ntohl (ip6_table_index);
17053 mp->is_add = is_add;
17062 api_flow_classify_dump (vat_main_t * vam)
17064 unformat_input_t *i = vam->input;
17065 vl_api_flow_classify_dump_t *mp;
17066 u8 type = FLOW_CLASSIFY_N_TABLES;
17068 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
17072 errmsg ("classify table type must be specified");
17076 if (!vam->json_output)
17078 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
17081 M (FLOW_CLASSIFY_DUMP, mp);
17086 /* Use a control ping for synchronization */
17088 vl_api_control_ping_t *mp;
17089 M (CONTROL_PING, mp);
17092 /* Wait for a reply... */
17100 api_feature_enable_disable (vat_main_t * vam)
17102 unformat_input_t *i = vam->input;
17103 vl_api_feature_enable_disable_t *mp;
17105 u8 *feature_name = 0;
17106 u32 sw_if_index = ~0;
17109 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17111 if (unformat (i, "arc_name %s", &arc_name))
17113 else if (unformat (i, "feature_name %s", &feature_name))
17116 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17118 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17120 else if (unformat (i, "disable"))
17128 errmsg ("missing arc name");
17131 if (vec_len (arc_name) > 63)
17133 errmsg ("arc name too long");
17136 if (feature_name == 0)
17138 errmsg ("missing feature name");
17141 if (vec_len (feature_name) > 63)
17143 errmsg ("feature name too long");
17146 if (sw_if_index == ~0)
17148 errmsg ("missing interface name or sw_if_index");
17152 /* Construct the API message */
17153 M (FEATURE_ENABLE_DISABLE, mp);
17154 mp->sw_if_index = ntohl (sw_if_index);
17155 mp->enable = enable;
17156 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
17157 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
17158 vec_free (arc_name);
17159 vec_free (feature_name);
17166 api_sw_interface_tag_add_del (vat_main_t * vam)
17168 unformat_input_t *i = vam->input;
17169 vl_api_sw_interface_tag_add_del_t *mp;
17170 u32 sw_if_index = ~0;
17174 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17176 if (unformat (i, "tag %s", &tag))
17178 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17180 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17182 else if (unformat (i, "del"))
17188 if (sw_if_index == ~0)
17190 errmsg ("missing interface name or sw_if_index");
17194 if (enable && (tag == 0))
17196 errmsg ("no tag specified");
17200 /* Construct the API message */
17201 M (SW_INTERFACE_TAG_ADD_DEL, mp);
17202 mp->sw_if_index = ntohl (sw_if_index);
17203 mp->is_add = enable;
17205 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
17212 static void vl_api_l2_xconnect_details_t_handler
17213 (vl_api_l2_xconnect_details_t * mp)
17215 vat_main_t *vam = &vat_main;
17217 print (vam->ofp, "%15d%15d",
17218 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
17221 static void vl_api_l2_xconnect_details_t_handler_json
17222 (vl_api_l2_xconnect_details_t * mp)
17224 vat_main_t *vam = &vat_main;
17225 vat_json_node_t *node = NULL;
17227 if (VAT_JSON_ARRAY != vam->json_tree.type)
17229 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17230 vat_json_init_array (&vam->json_tree);
17232 node = vat_json_array_add (&vam->json_tree);
17234 vat_json_init_object (node);
17235 vat_json_object_add_uint (node, "rx_sw_if_index",
17236 ntohl (mp->rx_sw_if_index));
17237 vat_json_object_add_uint (node, "tx_sw_if_index",
17238 ntohl (mp->tx_sw_if_index));
17242 api_l2_xconnect_dump (vat_main_t * vam)
17244 vl_api_l2_xconnect_dump_t *mp;
17246 if (!vam->json_output)
17248 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
17251 M (L2_XCONNECT_DUMP, mp);
17255 /* Use a control ping for synchronization */
17257 vl_api_control_ping_t *mp;
17258 M (CONTROL_PING, mp);
17265 api_sw_interface_set_mtu (vat_main_t * vam)
17267 unformat_input_t *i = vam->input;
17268 vl_api_sw_interface_set_mtu_t *mp;
17269 u32 sw_if_index = ~0;
17272 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17274 if (unformat (i, "mtu %d", &mtu))
17276 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17278 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17284 if (sw_if_index == ~0)
17286 errmsg ("missing interface name or sw_if_index");
17292 errmsg ("no mtu specified");
17296 /* Construct the API message */
17297 M (SW_INTERFACE_SET_MTU, mp);
17298 mp->sw_if_index = ntohl (sw_if_index);
17299 mp->mtu = ntohs ((u16) mtu);
17307 q_or_quit (vat_main_t * vam)
17309 longjmp (vam->jump_buf, 1);
17310 return 0; /* not so much */
17314 q (vat_main_t * vam)
17316 return q_or_quit (vam);
17320 quit (vat_main_t * vam)
17322 return q_or_quit (vam);
17326 comment (vat_main_t * vam)
17332 cmd_cmp (void *a1, void *a2)
17337 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
17341 help (vat_main_t * vam)
17346 unformat_input_t *i = vam->input;
17349 if (unformat (i, "%s", &name))
17353 vec_add1 (name, 0);
17355 hs = hash_get_mem (vam->help_by_name, name);
17357 print (vam->ofp, "usage: %s %s", name, hs[0]);
17359 print (vam->ofp, "No such msg / command '%s'", name);
17364 print (vam->ofp, "Help is available for the following:");
17367 hash_foreach_pair (p, vam->function_by_name,
17369 vec_add1 (cmds, (u8 *)(p->key));
17373 vec_sort_with_function (cmds, cmd_cmp);
17375 for (j = 0; j < vec_len (cmds); j++)
17376 print (vam->ofp, "%s", cmds[j]);
17383 set (vat_main_t * vam)
17385 u8 *name = 0, *value = 0;
17386 unformat_input_t *i = vam->input;
17388 if (unformat (i, "%s", &name))
17390 /* The input buffer is a vector, not a string. */
17391 value = vec_dup (i->buffer);
17392 vec_delete (value, i->index, 0);
17393 /* Almost certainly has a trailing newline */
17394 if (value[vec_len (value) - 1] == '\n')
17395 value[vec_len (value) - 1] = 0;
17396 /* Make sure it's a proper string, one way or the other */
17397 vec_add1 (value, 0);
17398 (void) clib_macro_set_value (&vam->macro_main,
17399 (char *) name, (char *) value);
17402 errmsg ("usage: set <name> <value>");
17410 unset (vat_main_t * vam)
17414 if (unformat (vam->input, "%s", &name))
17415 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
17416 errmsg ("unset: %s wasn't set", name);
17429 macro_sort_cmp (void *a1, void *a2)
17431 macro_sort_t *s1 = a1;
17432 macro_sort_t *s2 = a2;
17434 return strcmp ((char *) (s1->name), (char *) (s2->name));
17438 dump_macro_table (vat_main_t * vam)
17440 macro_sort_t *sort_me = 0, *sm;
17445 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
17447 vec_add2 (sort_me, sm, 1);
17448 sm->name = (u8 *)(p->key);
17449 sm->value = (u8 *) (p->value[0]);
17453 vec_sort_with_function (sort_me, macro_sort_cmp);
17455 if (vec_len (sort_me))
17456 print (vam->ofp, "%-15s%s", "Name", "Value");
17458 print (vam->ofp, "The macro table is empty...");
17460 for (i = 0; i < vec_len (sort_me); i++)
17461 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
17466 dump_node_table (vat_main_t * vam)
17469 vlib_node_t *node, *next_node;
17471 if (vec_len (vam->graph_nodes) == 0)
17473 print (vam->ofp, "Node table empty, issue get_node_graph...");
17477 for (i = 0; i < vec_len (vam->graph_nodes); i++)
17479 node = vam->graph_nodes[i];
17480 print (vam->ofp, "[%d] %s", i, node->name);
17481 for (j = 0; j < vec_len (node->next_nodes); j++)
17483 if (node->next_nodes[j] != ~0)
17485 next_node = vam->graph_nodes[node->next_nodes[j]];
17486 print (vam->ofp, " [%d] %s", j, next_node->name);
17494 value_sort_cmp (void *a1, void *a2)
17496 name_sort_t *n1 = a1;
17497 name_sort_t *n2 = a2;
17499 if (n1->value < n2->value)
17501 if (n1->value > n2->value)
17508 dump_msg_api_table (vat_main_t * vam)
17510 api_main_t *am = &api_main;
17511 name_sort_t *nses = 0, *ns;
17516 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
17518 vec_add2 (nses, ns, 1);
17519 ns->name = (u8 *)(hp->key);
17520 ns->value = (u32) hp->value[0];
17524 vec_sort_with_function (nses, value_sort_cmp);
17526 for (i = 0; i < vec_len (nses); i++)
17527 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
17533 get_msg_id (vat_main_t * vam)
17538 if (unformat (vam->input, "%s", &name_and_crc))
17540 message_index = vl_api_get_msg_index (name_and_crc);
17541 if (message_index == ~0)
17543 print (vam->ofp, " '%s' not found", name_and_crc);
17546 print (vam->ofp, " '%s' has message index %d",
17547 name_and_crc, message_index);
17550 errmsg ("name_and_crc required...");
17555 search_node_table (vat_main_t * vam)
17557 unformat_input_t *line_input = vam->input;
17560 vlib_node_t *node, *next_node;
17563 if (vam->graph_node_index_by_name == 0)
17565 print (vam->ofp, "Node table empty, issue get_node_graph...");
17569 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
17571 if (unformat (line_input, "%s", &node_to_find))
17573 vec_add1 (node_to_find, 0);
17574 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
17577 print (vam->ofp, "%s not found...", node_to_find);
17580 node = vam->graph_nodes[p[0]];
17581 print (vam->ofp, "[%d] %s", p[0], node->name);
17582 for (j = 0; j < vec_len (node->next_nodes); j++)
17584 if (node->next_nodes[j] != ~0)
17586 next_node = vam->graph_nodes[node->next_nodes[j]];
17587 print (vam->ofp, " [%d] %s", j, next_node->name);
17594 clib_warning ("parse error '%U'", format_unformat_error,
17600 vec_free (node_to_find);
17609 script (vat_main_t * vam)
17611 #if (VPP_API_TEST_BUILTIN==0)
17613 char *save_current_file;
17614 unformat_input_t save_input;
17615 jmp_buf save_jump_buf;
17616 u32 save_line_number;
17618 FILE *new_fp, *save_ifp;
17620 if (unformat (vam->input, "%s", &s))
17622 new_fp = fopen ((char *) s, "r");
17625 errmsg ("Couldn't open script file %s", s);
17632 errmsg ("Missing script name");
17636 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
17637 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
17638 save_ifp = vam->ifp;
17639 save_line_number = vam->input_line_number;
17640 save_current_file = (char *) vam->current_file;
17642 vam->input_line_number = 0;
17644 vam->current_file = s;
17647 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
17648 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
17649 vam->ifp = save_ifp;
17650 vam->input_line_number = save_line_number;
17651 vam->current_file = (u8 *) save_current_file;
17656 clib_warning ("use the exec command...");
17662 echo (vat_main_t * vam)
17664 print (vam->ofp, "%v", vam->input->buffer);
17668 /* List of API message constructors, CLI names map to api_xxx */
17669 #define foreach_vpe_api_msg \
17670 _(create_loopback,"[mac <mac-addr>]") \
17671 _(sw_interface_dump,"") \
17672 _(sw_interface_set_flags, \
17673 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
17674 _(sw_interface_add_del_address, \
17675 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
17676 _(sw_interface_set_table, \
17677 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
17678 _(sw_interface_set_mpls_enable, \
17679 "<intfc> | sw_if_index [disable | dis]") \
17680 _(sw_interface_set_vpath, \
17681 "<intfc> | sw_if_index <id> enable | disable") \
17682 _(sw_interface_set_vxlan_bypass, \
17683 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
17684 _(sw_interface_set_l2_xconnect, \
17685 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
17686 "enable | disable") \
17687 _(sw_interface_set_l2_bridge, \
17688 "<intfc> | sw_if_index <id> bd_id <bridge-domain-id>\n" \
17689 "[shg <split-horizon-group>] [bvi]\n" \
17690 "enable | disable") \
17691 _(bridge_domain_add_del, \
17692 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n") \
17693 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
17695 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
17697 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
17699 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
17701 "tapname <name> mac <mac-addr> | random-mac [tag <string>]") \
17703 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
17705 "<vpp-if-name> | sw_if_index <id>") \
17706 _(sw_interface_tap_dump, "") \
17707 _(ip_add_del_route, \
17708 "<addr>/<mask> via <addr> [table-id <n>]\n" \
17709 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
17710 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
17711 "[multipath] [count <n>]") \
17712 _(ip_mroute_add_del, \
17713 "<src> <grp>/<mask> [table-id <n>]\n" \
17714 "[<intfc> | sw_if_index <id>] [local] [del]") \
17715 _(mpls_route_add_del, \
17716 "<label> <eos> via <addr> [table-id <n>]\n" \
17717 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
17718 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
17719 "[multipath] [count <n>]") \
17720 _(mpls_ip_bind_unbind, \
17721 "<label> <addr/len>") \
17722 _(mpls_tunnel_add_del, \
17723 " via <addr> [table-id <n>]\n" \
17724 "sw_if_index <id>] [l2] [del]") \
17725 _(proxy_arp_add_del, \
17726 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
17727 _(proxy_arp_intfc_enable_disable, \
17728 "<intfc> | sw_if_index <id> enable | disable") \
17729 _(sw_interface_set_unnumbered, \
17730 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
17731 _(ip_neighbor_add_del, \
17732 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
17733 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
17734 _(reset_vrf, "vrf <id> [ipv6]") \
17735 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
17736 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
17737 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
17738 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
17739 "[outer_vlan_id_any][inner_vlan_id_any]") \
17740 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
17741 _(reset_fib, "vrf <n> [ipv6]") \
17742 _(dhcp_proxy_config, \
17743 "svr <v46-address> src <v46-address>\n" \
17744 "insert-cid <n> [del]") \
17745 _(dhcp_proxy_config_2, \
17746 "svr <v46-address> src <v46-address>\n" \
17747 "rx_vrf_id <nn> server_vrf_id <nn> insert-cid <n> [del]") \
17748 _(dhcp_proxy_set_vss, \
17749 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
17750 _(dhcp_client_config, \
17751 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
17752 _(set_ip_flow_hash, \
17753 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
17754 _(sw_interface_ip6_enable_disable, \
17755 "<intfc> | sw_if_index <id> enable | disable") \
17756 _(sw_interface_ip6_set_link_local_address, \
17757 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
17758 _(sw_interface_ip6nd_ra_prefix, \
17759 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
17760 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
17761 "[nolink] [isno]") \
17762 _(sw_interface_ip6nd_ra_config, \
17763 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
17764 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
17765 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
17766 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
17767 _(l2_patch_add_del, \
17768 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
17769 "enable | disable") \
17770 _(sr_tunnel_add_del, \
17771 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
17772 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
17773 "[policy <policy_name>]") \
17774 _(sr_policy_add_del, \
17775 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
17776 _(sr_multicast_map_add_del, \
17777 "address [ip6 multicast address] sr-policy [policy name] [del]") \
17778 _(classify_add_del_table, \
17779 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
17780 " [del] [del-chain] mask <mask-value>\n" \
17781 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
17782 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
17783 _(classify_add_del_session, \
17784 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
17785 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
17786 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
17787 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
17788 _(classify_set_interface_ip_table, \
17789 "<intfc> | sw_if_index <nn> table <nn>") \
17790 _(classify_set_interface_l2_tables, \
17791 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
17792 " [other-table <nn>]") \
17793 _(get_node_index, "node <node-name") \
17794 _(add_node_next, "node <node-name> next <next-node-name>") \
17795 _(l2tpv3_create_tunnel, \
17796 "client_address <ip6-addr> our_address <ip6-addr>\n" \
17797 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
17798 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
17799 _(l2tpv3_set_tunnel_cookies, \
17800 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
17801 "[new_remote_cookie <nn>]\n") \
17802 _(l2tpv3_interface_enable_disable, \
17803 "<intfc> | sw_if_index <nn> enable | disable") \
17804 _(l2tpv3_set_lookup_key, \
17805 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
17806 _(sw_if_l2tpv3_tunnel_dump, "") \
17807 _(vxlan_add_del_tunnel, \
17808 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
17809 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
17810 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
17811 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
17812 _(gre_add_del_tunnel, \
17813 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [teb] [del]\n") \
17814 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
17815 _(l2_fib_clear_table, "") \
17816 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
17817 _(l2_interface_vlan_tag_rewrite, \
17818 "<intfc> | sw_if_index <nn> \n" \
17819 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
17820 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
17821 _(create_vhost_user_if, \
17822 "socket <filename> [server] [renumber <dev_instance>] " \
17823 "[mac <mac_address>]") \
17824 _(modify_vhost_user_if, \
17825 "<intfc> | sw_if_index <nn> socket <filename>\n" \
17826 "[server] [renumber <dev_instance>]") \
17827 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
17828 _(sw_interface_vhost_user_dump, "") \
17829 _(show_version, "") \
17830 _(vxlan_gpe_add_del_tunnel, \
17831 "local <addr> remote <addr> vni <nn>\n" \
17832 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
17833 "[next-ethernet] [next-nsh]\n") \
17834 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
17835 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
17836 _(interface_name_renumber, \
17837 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
17838 _(input_acl_set_interface, \
17839 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
17840 " [l2-table <nn>] [del]") \
17841 _(want_ip4_arp_events, "address <ip4-address> [del]") \
17842 _(want_ip6_nd_events, "address <ip6-address> [del]") \
17843 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
17844 _(ip_dump, "ipv4 | ipv6") \
17845 _(ipsec_spd_add_del, "spd_id <n> [del]") \
17846 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
17848 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
17849 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
17850 " integ_alg <alg> integ_key <hex>") \
17851 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
17852 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
17853 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
17854 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
17855 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
17856 _(ikev2_profile_add_del, "name <profile_name> [del]") \
17857 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
17858 "(auth_data 0x<data> | auth_data <data>)") \
17859 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
17860 "(id_data 0x<data> | id_data <data>) (local|remote)") \
17861 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
17862 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
17863 "(local|remote)") \
17864 _(ikev2_set_local_key, "file <absolute_file_path>") \
17865 _(delete_loopback,"sw_if_index <nn>") \
17866 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
17867 _(map_add_domain, \
17868 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
17869 "ip6-src <ip6addr> " \
17870 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
17871 _(map_del_domain, "index <n>") \
17872 _(map_add_del_rule, \
17873 "index <n> psid <n> dst <ip6addr> [del]") \
17874 _(map_domain_dump, "") \
17875 _(map_rule_dump, "index <map-domain>") \
17876 _(want_interface_events, "enable|disable") \
17877 _(want_stats,"enable|disable") \
17878 _(get_first_msg_id, "client <name>") \
17879 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
17880 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
17881 "fib-id <nn> [ip4][ip6][default]") \
17882 _(get_node_graph, " ") \
17883 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
17884 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
17885 _(ioam_disable, "") \
17886 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
17887 " sw_if_index <sw_if_index> p <priority> " \
17888 "w <weight>] [del]") \
17889 _(lisp_add_del_locator, "locator-set <locator_name> " \
17890 "iface <intf> | sw_if_index <sw_if_index> " \
17891 "p <priority> w <weight> [del]") \
17892 _(lisp_add_del_local_eid,"vni <vni> eid " \
17893 "<ipv4|ipv6>/<prefix> | <L2 address> " \
17894 "locator-set <locator_name> [del]" \
17895 "[key-id sha1|sha256 secret-key <secret-key>]") \
17896 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
17897 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
17898 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
17899 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
17900 _(lisp_gpe_enable_disable, "enable|disable") \
17901 _(lisp_enable_disable, "enable|disable") \
17902 _(lisp_map_register_enable_disable, "enable|disable") \
17903 _(lisp_rloc_probe_enable_disable, "enable|disable") \
17904 _(lisp_gpe_add_del_iface, "up|down") \
17905 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
17907 "rloc <locator> p <prio> " \
17908 "w <weight> [rloc <loc> ... ] " \
17909 "action <action> [del-all]") \
17910 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
17912 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
17913 _(lisp_map_request_mode, "src-dst|dst-only") \
17914 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
17915 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
17916 _(lisp_locator_set_dump, "[local | remote]") \
17917 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
17918 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
17919 "[local] | [remote]") \
17920 _(lisp_eid_table_vni_dump, "") \
17921 _(lisp_eid_table_map_dump, "l2|l3") \
17922 _(lisp_map_resolver_dump, "") \
17923 _(lisp_map_server_dump, "") \
17924 _(lisp_adjacencies_get, "vni <vni>") \
17925 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
17926 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
17927 _(show_lisp_rloc_probe_state, "") \
17928 _(show_lisp_map_register_state, "") \
17929 _(show_lisp_status, "") \
17930 _(lisp_get_map_request_itr_rlocs, "") \
17931 _(show_lisp_pitr, "") \
17932 _(show_lisp_map_request_mode, "") \
17933 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
17934 _(af_packet_delete, "name <host interface name>") \
17935 _(policer_add_del, "name <policer name> <params> [del]") \
17936 _(policer_dump, "[name <policer name>]") \
17937 _(policer_classify_set_interface, \
17938 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
17939 " [l2-table <nn>] [del]") \
17940 _(policer_classify_dump, "type [ip4|ip6|l2]") \
17941 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
17942 "[master|slave]") \
17943 _(netmap_delete, "name <interface name>") \
17944 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
17945 _(mpls_fib_dump, "") \
17946 _(classify_table_ids, "") \
17947 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
17948 _(classify_table_info, "table_id <nn>") \
17949 _(classify_session_dump, "table_id <nn>") \
17950 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
17951 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
17952 "[template_interval <nn>] [udp_checksum]") \
17953 _(ipfix_exporter_dump, "") \
17954 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
17955 _(ipfix_classify_stream_dump, "") \
17956 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
17957 _(ipfix_classify_table_dump, "") \
17958 _(sw_interface_span_enable_disable, "[src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
17959 _(sw_interface_span_dump, "") \
17960 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
17961 _(pg_create_interface, "if_id <nn>") \
17962 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
17963 _(pg_enable_disable, "[stream <id>] disable") \
17964 _(ip_source_and_port_range_check_add_del, \
17965 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
17966 _(ip_source_and_port_range_check_interface_add_del, \
17967 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
17968 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
17969 _(ipsec_gre_add_del_tunnel, \
17970 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
17971 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
17972 _(delete_subif,"<intfc> | sw_if_index <nn>") \
17973 _(l2_interface_pbb_tag_rewrite, \
17974 "<intfc> | sw_if_index <nn> \n" \
17975 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
17976 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
17977 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
17978 _(flow_classify_set_interface, \
17979 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
17980 _(flow_classify_dump, "type [ip4|ip6]") \
17981 _(ip_fib_dump, "") \
17982 _(ip6_fib_dump, "") \
17983 _(feature_enable_disable, "arc_name <arc_name> " \
17984 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
17985 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
17987 _(l2_xconnect_dump, "") \
17988 _(sw_interface_set_mtu, "<intfc> | sw_if_index <nn> mtu <nn>") \
17989 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
17990 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]")
17993 #define foreach_vpe_dpdk_api_msg \
17994 _(sw_interface_set_dpdk_hqos_pipe, \
17995 "rx <intfc> | sw_if_index <id> subport <subport-id> pipe <pipe-id>\n" \
17996 "profile <profile-id>\n") \
17997 _(sw_interface_set_dpdk_hqos_subport, \
17998 "rx <intfc> | sw_if_index <id> subport <subport-id> [rate <n>]\n" \
17999 "[bktsize <n>] [tc0 <n>] [tc1 <n>] [tc2 <n>] [tc3 <n>] [period <n>]\n") \
18000 _(sw_interface_set_dpdk_hqos_tctbl, \
18001 "rx <intfc> | sw_if_index <id> entry <n> tc <n> queue <n>\n")
18004 /* List of command functions, CLI names map directly to functions */
18005 #define foreach_cli_function \
18006 _(comment, "usage: comment <ignore-rest-of-line>") \
18007 _(dump_interface_table, "usage: dump_interface_table") \
18008 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
18009 _(dump_ipv4_table, "usage: dump_ipv4_table") \
18010 _(dump_ipv6_table, "usage: dump_ipv6_table") \
18011 _(dump_stats_table, "usage: dump_stats_table") \
18012 _(dump_macro_table, "usage: dump_macro_table ") \
18013 _(dump_node_table, "usage: dump_node_table") \
18014 _(dump_msg_api_table, "usage: dump_msg_api_table") \
18015 _(get_msg_id, "usage: get_msg_id name_and_crc") \
18016 _(echo, "usage: echo <message>") \
18017 _(exec, "usage: exec <vpe-debug-CLI-command>") \
18018 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
18019 _(help, "usage: help") \
18020 _(q, "usage: quit") \
18021 _(quit, "usage: quit") \
18022 _(search_node_table, "usage: search_node_table <name>...") \
18023 _(set, "usage: set <variable-name> <value>") \
18024 _(script, "usage: script <file-name>") \
18025 _(unset, "usage: unset <variable-name>")
18028 static void vl_api_##n##_t_handler_uni \
18029 (vl_api_##n##_t * mp) \
18031 vat_main_t * vam = &vat_main; \
18032 if (vam->json_output) { \
18033 vl_api_##n##_t_handler_json(mp); \
18035 vl_api_##n##_t_handler(mp); \
18038 foreach_vpe_api_reply_msg;
18043 static void vl_api_##n##_t_handler_uni \
18044 (vl_api_##n##_t * mp) \
18046 vat_main_t * vam = &vat_main; \
18047 if (vam->json_output) { \
18048 vl_api_##n##_t_handler_json(mp); \
18050 vl_api_##n##_t_handler(mp); \
18053 foreach_vpe_dpdk_api_reply_msg;
18058 vat_api_hookup (vat_main_t * vam)
18061 vl_msg_api_set_handlers(VL_API_##N, #n, \
18062 vl_api_##n##_t_handler_uni, \
18064 vl_api_##n##_t_endian, \
18065 vl_api_##n##_t_print, \
18066 sizeof(vl_api_##n##_t), 1);
18067 foreach_vpe_api_reply_msg;
18072 vl_msg_api_set_handlers(VL_API_##N, #n, \
18073 vl_api_##n##_t_handler_uni, \
18075 vl_api_##n##_t_endian, \
18076 vl_api_##n##_t_print, \
18077 sizeof(vl_api_##n##_t), 1);
18078 foreach_vpe_dpdk_api_reply_msg;
18082 #if (VPP_API_TEST_BUILTIN==0)
18083 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
18086 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
18088 vam->function_by_name = hash_create_string (0, sizeof (uword));
18090 vam->help_by_name = hash_create_string (0, sizeof (uword));
18092 /* API messages we can send */
18093 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
18094 foreach_vpe_api_msg;
18097 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
18098 foreach_vpe_dpdk_api_msg;
18103 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
18104 foreach_vpe_api_msg;
18107 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
18108 foreach_vpe_dpdk_api_msg;
18112 /* CLI functions */
18113 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
18114 foreach_cli_function;
18118 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
18119 foreach_cli_function;
18124 * fd.io coding-style-patch-verification: ON
18127 * eval: (c-set-style "gnu")