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;
4646 if (vec_len (i->buffer) == 0)
4649 if (vam->exec_mode == 0 && unformat (i, "mode"))
4654 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4661 * In order for the CLI command to work, it
4662 * must be a vector ending in \n, not a C-string ending
4665 u32 len = vec_len (vam->input->buffer);
4666 M2 (CLI_INBAND, mp, len);
4667 clib_memcpy (mp->cmd, vam->input->buffer, len);
4668 mp->length = htonl (len);
4671 W2 (ret, print (vam->ofp, "%s", vam->cmd_reply));
4676 api_create_loopback (vat_main_t * vam)
4678 unformat_input_t *i = vam->input;
4679 vl_api_create_loopback_t *mp;
4684 memset (mac_address, 0, sizeof (mac_address));
4686 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4688 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
4694 /* Construct the API message */
4695 M (CREATE_LOOPBACK, mp);
4697 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
4705 api_delete_loopback (vat_main_t * vam)
4707 unformat_input_t *i = vam->input;
4708 vl_api_delete_loopback_t *mp;
4709 u32 sw_if_index = ~0;
4712 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4714 if (unformat (i, "sw_if_index %d", &sw_if_index))
4720 if (sw_if_index == ~0)
4722 errmsg ("missing sw_if_index");
4726 /* Construct the API message */
4727 M (DELETE_LOOPBACK, mp);
4728 mp->sw_if_index = ntohl (sw_if_index);
4736 api_want_stats (vat_main_t * vam)
4738 unformat_input_t *i = vam->input;
4739 vl_api_want_stats_t *mp;
4743 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4745 if (unformat (i, "enable"))
4747 else if (unformat (i, "disable"))
4755 errmsg ("missing enable|disable");
4760 mp->enable_disable = enable;
4768 api_want_interface_events (vat_main_t * vam)
4770 unformat_input_t *i = vam->input;
4771 vl_api_want_interface_events_t *mp;
4775 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4777 if (unformat (i, "enable"))
4779 else if (unformat (i, "disable"))
4787 errmsg ("missing enable|disable");
4791 M (WANT_INTERFACE_EVENTS, mp);
4792 mp->enable_disable = enable;
4794 vam->interface_event_display = enable;
4802 /* Note: non-static, called once to set up the initial intfc table */
4804 api_sw_interface_dump (vat_main_t * vam)
4806 vl_api_sw_interface_dump_t *mp;
4807 vl_api_control_ping_t *mp_ping;
4809 name_sort_t *nses = 0, *ns;
4810 sw_interface_subif_t *sub = NULL;
4813 /* Toss the old name table */
4815 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4817 vec_add2 (nses, ns, 1);
4818 ns->name = (u8 *)(p->key);
4819 ns->value = (u32) p->value[0];
4823 hash_free (vam->sw_if_index_by_interface_name);
4825 vec_foreach (ns, nses) vec_free (ns->name);
4829 vec_foreach (sub, vam->sw_if_subif_table)
4831 vec_free (sub->interface_name);
4833 vec_free (vam->sw_if_subif_table);
4835 /* recreate the interface name hash table */
4836 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
4838 /* Get list of ethernets */
4839 M (SW_INTERFACE_DUMP, mp);
4840 mp->name_filter_valid = 1;
4841 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
4844 /* and local / loopback interfaces */
4845 M (SW_INTERFACE_DUMP, mp);
4846 mp->name_filter_valid = 1;
4847 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
4850 /* and packet-generator interfaces */
4851 M (SW_INTERFACE_DUMP, mp);
4852 mp->name_filter_valid = 1;
4853 strncpy ((char *) mp->name_filter, "pg", sizeof (mp->name_filter) - 1);
4856 /* and vxlan-gpe tunnel interfaces */
4857 M (SW_INTERFACE_DUMP, mp);
4858 mp->name_filter_valid = 1;
4859 strncpy ((char *) mp->name_filter, "vxlan_gpe",
4860 sizeof (mp->name_filter) - 1);
4863 /* and vxlan tunnel interfaces */
4864 M (SW_INTERFACE_DUMP, mp);
4865 mp->name_filter_valid = 1;
4866 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
4869 /* and host (af_packet) interfaces */
4870 M (SW_INTERFACE_DUMP, mp);
4871 mp->name_filter_valid = 1;
4872 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
4875 /* and l2tpv3 tunnel interfaces */
4876 M (SW_INTERFACE_DUMP, mp);
4877 mp->name_filter_valid = 1;
4878 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
4879 sizeof (mp->name_filter) - 1);
4882 /* and GRE tunnel interfaces */
4883 M (SW_INTERFACE_DUMP, mp);
4884 mp->name_filter_valid = 1;
4885 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
4888 /* and LISP-GPE interfaces */
4889 M (SW_INTERFACE_DUMP, mp);
4890 mp->name_filter_valid = 1;
4891 strncpy ((char *) mp->name_filter, "lisp_gpe",
4892 sizeof (mp->name_filter) - 1);
4895 /* and IPSEC tunnel interfaces */
4896 M (SW_INTERFACE_DUMP, mp);
4897 mp->name_filter_valid = 1;
4898 strncpy ((char *) mp->name_filter, "ipsec", sizeof (mp->name_filter) - 1);
4901 /* Use a control ping for synchronization */
4902 M (CONTROL_PING, mp_ping);
4910 api_sw_interface_set_flags (vat_main_t * vam)
4912 unformat_input_t *i = vam->input;
4913 vl_api_sw_interface_set_flags_t *mp;
4915 u8 sw_if_index_set = 0;
4916 u8 admin_up = 0, link_up = 0;
4919 /* Parse args required to build the message */
4920 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4922 if (unformat (i, "admin-up"))
4924 else if (unformat (i, "admin-down"))
4926 else if (unformat (i, "link-up"))
4928 else if (unformat (i, "link-down"))
4931 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4932 sw_if_index_set = 1;
4933 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4934 sw_if_index_set = 1;
4939 if (sw_if_index_set == 0)
4941 errmsg ("missing interface name or sw_if_index");
4945 /* Construct the API message */
4946 M (SW_INTERFACE_SET_FLAGS, mp);
4947 mp->sw_if_index = ntohl (sw_if_index);
4948 mp->admin_up_down = admin_up;
4949 mp->link_up_down = link_up;
4954 /* Wait for a reply, return the good/bad news... */
4960 api_sw_interface_clear_stats (vat_main_t * vam)
4962 unformat_input_t *i = vam->input;
4963 vl_api_sw_interface_clear_stats_t *mp;
4965 u8 sw_if_index_set = 0;
4968 /* Parse args required to build the message */
4969 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4971 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4972 sw_if_index_set = 1;
4973 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4974 sw_if_index_set = 1;
4979 /* Construct the API message */
4980 M (SW_INTERFACE_CLEAR_STATS, mp);
4982 if (sw_if_index_set == 1)
4983 mp->sw_if_index = ntohl (sw_if_index);
4985 mp->sw_if_index = ~0;
4990 /* Wait for a reply, return the good/bad news... */
4997 api_sw_interface_set_dpdk_hqos_pipe (vat_main_t * vam)
4999 unformat_input_t *i = vam->input;
5000 vl_api_sw_interface_set_dpdk_hqos_pipe_t *mp;
5002 u8 sw_if_index_set = 0;
5011 /* Parse args required to build the message */
5012 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5014 if (unformat (i, "rx %U", api_unformat_sw_if_index, vam, &sw_if_index))
5015 sw_if_index_set = 1;
5016 else if (unformat (i, "sw_if_index %u", &sw_if_index))
5017 sw_if_index_set = 1;
5018 else if (unformat (i, "subport %u", &subport))
5021 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5022 sw_if_index_set = 1;
5023 else if (unformat (i, "pipe %u", &pipe))
5025 else if (unformat (i, "profile %u", &profile))
5031 if (sw_if_index_set == 0)
5033 errmsg ("missing interface name or sw_if_index");
5037 if (subport_set == 0)
5039 errmsg ("missing subport ");
5045 errmsg ("missing pipe");
5049 if (profile_set == 0)
5051 errmsg ("missing profile");
5055 M (SW_INTERFACE_SET_DPDK_HQOS_PIPE, mp);
5057 mp->sw_if_index = ntohl (sw_if_index);
5058 mp->subport = ntohl (subport);
5059 mp->pipe = ntohl (pipe);
5060 mp->profile = ntohl (profile);
5069 api_sw_interface_set_dpdk_hqos_subport (vat_main_t * vam)
5071 unformat_input_t *i = vam->input;
5072 vl_api_sw_interface_set_dpdk_hqos_subport_t *mp;
5074 u8 sw_if_index_set = 0;
5077 u32 tb_rate = 1250000000; /* 10GbE */
5078 u32 tb_size = 1000000;
5079 u32 tc_rate[] = { 1250000000, 1250000000, 1250000000, 1250000000 };
5083 /* Parse args required to build the message */
5084 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5086 if (unformat (i, "rx %U", api_unformat_sw_if_index, vam, &sw_if_index))
5087 sw_if_index_set = 1;
5088 else if (unformat (i, "sw_if_index %u", &sw_if_index))
5089 sw_if_index_set = 1;
5090 else if (unformat (i, "subport %u", &subport))
5093 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5094 sw_if_index_set = 1;
5095 else if (unformat (i, "rate %u", &tb_rate))
5099 for (tc_id = 0; tc_id < (sizeof (tc_rate) / sizeof (tc_rate[0]));
5101 tc_rate[tc_id] = tb_rate;
5103 else if (unformat (i, "bktsize %u", &tb_size))
5105 else if (unformat (i, "tc0 %u", &tc_rate[0]))
5107 else if (unformat (i, "tc1 %u", &tc_rate[1]))
5109 else if (unformat (i, "tc2 %u", &tc_rate[2]))
5111 else if (unformat (i, "tc3 %u", &tc_rate[3]))
5113 else if (unformat (i, "period %u", &tc_period))
5119 if (sw_if_index_set == 0)
5121 errmsg ("missing interface name or sw_if_index");
5125 if (subport_set == 0)
5127 errmsg ("missing subport ");
5131 M (SW_INTERFACE_SET_DPDK_HQOS_SUBPORT, mp);
5133 mp->sw_if_index = ntohl (sw_if_index);
5134 mp->subport = ntohl (subport);
5135 mp->tb_rate = ntohl (tb_rate);
5136 mp->tb_size = ntohl (tb_size);
5137 mp->tc_rate[0] = ntohl (tc_rate[0]);
5138 mp->tc_rate[1] = ntohl (tc_rate[1]);
5139 mp->tc_rate[2] = ntohl (tc_rate[2]);
5140 mp->tc_rate[3] = ntohl (tc_rate[3]);
5141 mp->tc_period = ntohl (tc_period);
5149 api_sw_interface_set_dpdk_hqos_tctbl (vat_main_t * vam)
5151 unformat_input_t *i = vam->input;
5152 vl_api_sw_interface_set_dpdk_hqos_tctbl_t *mp;
5154 u8 sw_if_index_set = 0;
5158 u32 entry, tc, queue;
5161 /* Parse args required to build the message */
5162 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5164 if (unformat (i, "rx %U", api_unformat_sw_if_index, vam, &sw_if_index))
5165 sw_if_index_set = 1;
5166 else if (unformat (i, "sw_if_index %u", &sw_if_index))
5167 sw_if_index_set = 1;
5168 else if (unformat (i, "entry %d", &entry))
5170 else if (unformat (i, "tc %d", &tc))
5172 else if (unformat (i, "queue %d", &queue))
5178 if (sw_if_index_set == 0)
5180 errmsg ("missing interface name or sw_if_index");
5186 errmsg ("missing entry ");
5192 errmsg ("missing traffic class ");
5198 errmsg ("missing queue ");
5202 M (SW_INTERFACE_SET_DPDK_HQOS_TCTBL, mp);
5204 mp->sw_if_index = ntohl (sw_if_index);
5205 mp->entry = ntohl (entry);
5206 mp->tc = ntohl (tc);
5207 mp->queue = ntohl (queue);
5216 api_sw_interface_add_del_address (vat_main_t * vam)
5218 unformat_input_t *i = vam->input;
5219 vl_api_sw_interface_add_del_address_t *mp;
5221 u8 sw_if_index_set = 0;
5222 u8 is_add = 1, del_all = 0;
5223 u32 address_length = 0;
5224 u8 v4_address_set = 0;
5225 u8 v6_address_set = 0;
5226 ip4_address_t v4address;
5227 ip6_address_t v6address;
5230 /* Parse args required to build the message */
5231 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5233 if (unformat (i, "del-all"))
5235 else if (unformat (i, "del"))
5238 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5239 sw_if_index_set = 1;
5240 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5241 sw_if_index_set = 1;
5242 else if (unformat (i, "%U/%d",
5243 unformat_ip4_address, &v4address, &address_length))
5245 else if (unformat (i, "%U/%d",
5246 unformat_ip6_address, &v6address, &address_length))
5252 if (sw_if_index_set == 0)
5254 errmsg ("missing interface name or sw_if_index");
5257 if (v4_address_set && v6_address_set)
5259 errmsg ("both v4 and v6 addresses set");
5262 if (!v4_address_set && !v6_address_set && !del_all)
5264 errmsg ("no addresses set");
5268 /* Construct the API message */
5269 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
5271 mp->sw_if_index = ntohl (sw_if_index);
5272 mp->is_add = is_add;
5273 mp->del_all = del_all;
5277 clib_memcpy (mp->address, &v6address, sizeof (v6address));
5281 clib_memcpy (mp->address, &v4address, sizeof (v4address));
5283 mp->address_length = address_length;
5288 /* Wait for a reply, return good/bad news */
5294 api_sw_interface_set_mpls_enable (vat_main_t * vam)
5296 unformat_input_t *i = vam->input;
5297 vl_api_sw_interface_set_mpls_enable_t *mp;
5299 u8 sw_if_index_set = 0;
5303 /* Parse args required to build the message */
5304 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5306 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5307 sw_if_index_set = 1;
5308 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5309 sw_if_index_set = 1;
5310 else if (unformat (i, "disable"))
5312 else if (unformat (i, "dis"))
5318 if (sw_if_index_set == 0)
5320 errmsg ("missing interface name or sw_if_index");
5324 /* Construct the API message */
5325 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
5327 mp->sw_if_index = ntohl (sw_if_index);
5328 mp->enable = enable;
5333 /* Wait for a reply... */
5339 api_sw_interface_set_table (vat_main_t * vam)
5341 unformat_input_t *i = vam->input;
5342 vl_api_sw_interface_set_table_t *mp;
5343 u32 sw_if_index, vrf_id = 0;
5344 u8 sw_if_index_set = 0;
5348 /* Parse args required to build the message */
5349 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5351 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5352 sw_if_index_set = 1;
5353 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5354 sw_if_index_set = 1;
5355 else if (unformat (i, "vrf %d", &vrf_id))
5357 else if (unformat (i, "ipv6"))
5363 if (sw_if_index_set == 0)
5365 errmsg ("missing interface name or sw_if_index");
5369 /* Construct the API message */
5370 M (SW_INTERFACE_SET_TABLE, mp);
5372 mp->sw_if_index = ntohl (sw_if_index);
5373 mp->is_ipv6 = is_ipv6;
5374 mp->vrf_id = ntohl (vrf_id);
5379 /* Wait for a reply... */
5384 static void vl_api_sw_interface_get_table_reply_t_handler
5385 (vl_api_sw_interface_get_table_reply_t * mp)
5387 vat_main_t *vam = &vat_main;
5389 print (vam->ofp, "%d", ntohl (mp->vrf_id));
5391 vam->retval = ntohl (mp->retval);
5392 vam->result_ready = 1;
5396 static void vl_api_sw_interface_get_table_reply_t_handler_json
5397 (vl_api_sw_interface_get_table_reply_t * mp)
5399 vat_main_t *vam = &vat_main;
5400 vat_json_node_t node;
5402 vat_json_init_object (&node);
5403 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
5404 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
5406 vat_json_print (vam->ofp, &node);
5407 vat_json_free (&node);
5409 vam->retval = ntohl (mp->retval);
5410 vam->result_ready = 1;
5414 api_sw_interface_get_table (vat_main_t * vam)
5416 unformat_input_t *i = vam->input;
5417 vl_api_sw_interface_get_table_t *mp;
5419 u8 sw_if_index_set = 0;
5423 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5425 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5426 sw_if_index_set = 1;
5427 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5428 sw_if_index_set = 1;
5429 else if (unformat (i, "ipv6"))
5435 if (sw_if_index_set == 0)
5437 errmsg ("missing interface name or sw_if_index");
5441 M (SW_INTERFACE_GET_TABLE, mp);
5442 mp->sw_if_index = htonl (sw_if_index);
5443 mp->is_ipv6 = is_ipv6;
5451 api_sw_interface_set_vpath (vat_main_t * vam)
5453 unformat_input_t *i = vam->input;
5454 vl_api_sw_interface_set_vpath_t *mp;
5455 u32 sw_if_index = 0;
5456 u8 sw_if_index_set = 0;
5460 /* Parse args required to build the message */
5461 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5463 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5464 sw_if_index_set = 1;
5465 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5466 sw_if_index_set = 1;
5467 else if (unformat (i, "enable"))
5469 else if (unformat (i, "disable"))
5475 if (sw_if_index_set == 0)
5477 errmsg ("missing interface name or sw_if_index");
5481 /* Construct the API message */
5482 M (SW_INTERFACE_SET_VPATH, mp);
5484 mp->sw_if_index = ntohl (sw_if_index);
5485 mp->enable = is_enable;
5490 /* Wait for a reply... */
5496 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
5498 unformat_input_t *i = vam->input;
5499 vl_api_sw_interface_set_vxlan_bypass_t *mp;
5500 u32 sw_if_index = 0;
5501 u8 sw_if_index_set = 0;
5506 /* Parse args required to build the message */
5507 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5509 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5510 sw_if_index_set = 1;
5511 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5512 sw_if_index_set = 1;
5513 else if (unformat (i, "enable"))
5515 else if (unformat (i, "disable"))
5517 else if (unformat (i, "ip4"))
5519 else if (unformat (i, "ip6"))
5525 if (sw_if_index_set == 0)
5527 errmsg ("missing interface name or sw_if_index");
5531 /* Construct the API message */
5532 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
5534 mp->sw_if_index = ntohl (sw_if_index);
5535 mp->enable = is_enable;
5536 mp->is_ipv6 = is_ipv6;
5541 /* Wait for a reply... */
5547 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
5549 unformat_input_t *i = vam->input;
5550 vl_api_sw_interface_set_l2_xconnect_t *mp;
5552 u8 rx_sw_if_index_set = 0;
5554 u8 tx_sw_if_index_set = 0;
5558 /* Parse args required to build the message */
5559 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5561 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
5562 rx_sw_if_index_set = 1;
5563 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5564 tx_sw_if_index_set = 1;
5565 else if (unformat (i, "rx"))
5567 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5569 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
5571 rx_sw_if_index_set = 1;
5576 else if (unformat (i, "tx"))
5578 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5580 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
5582 tx_sw_if_index_set = 1;
5587 else if (unformat (i, "enable"))
5589 else if (unformat (i, "disable"))
5595 if (rx_sw_if_index_set == 0)
5597 errmsg ("missing rx interface name or rx_sw_if_index");
5601 if (enable && (tx_sw_if_index_set == 0))
5603 errmsg ("missing tx interface name or tx_sw_if_index");
5607 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
5609 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5610 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
5611 mp->enable = enable;
5619 api_sw_interface_set_l2_bridge (vat_main_t * vam)
5621 unformat_input_t *i = vam->input;
5622 vl_api_sw_interface_set_l2_bridge_t *mp;
5624 u8 rx_sw_if_index_set = 0;
5632 /* Parse args required to build the message */
5633 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5635 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
5636 rx_sw_if_index_set = 1;
5637 else if (unformat (i, "bd_id %d", &bd_id))
5641 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
5642 rx_sw_if_index_set = 1;
5643 else if (unformat (i, "shg %d", &shg))
5645 else if (unformat (i, "bvi"))
5647 else if (unformat (i, "enable"))
5649 else if (unformat (i, "disable"))
5655 if (rx_sw_if_index_set == 0)
5657 errmsg ("missing rx interface name or sw_if_index");
5661 if (enable && (bd_id_set == 0))
5663 errmsg ("missing bridge domain");
5667 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
5669 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5670 mp->bd_id = ntohl (bd_id);
5673 mp->enable = enable;
5681 api_bridge_domain_dump (vat_main_t * vam)
5683 unformat_input_t *i = vam->input;
5684 vl_api_bridge_domain_dump_t *mp;
5685 vl_api_control_ping_t *mp_ping;
5689 /* Parse args required to build the message */
5690 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5692 if (unformat (i, "bd_id %d", &bd_id))
5698 M (BRIDGE_DOMAIN_DUMP, mp);
5699 mp->bd_id = ntohl (bd_id);
5702 /* Use a control ping for synchronization */
5703 M (CONTROL_PING, mp_ping);
5711 api_bridge_domain_add_del (vat_main_t * vam)
5713 unformat_input_t *i = vam->input;
5714 vl_api_bridge_domain_add_del_t *mp;
5717 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
5721 /* Parse args required to build the message */
5722 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5724 if (unformat (i, "bd_id %d", &bd_id))
5726 else if (unformat (i, "flood %d", &flood))
5728 else if (unformat (i, "uu-flood %d", &uu_flood))
5730 else if (unformat (i, "forward %d", &forward))
5732 else if (unformat (i, "learn %d", &learn))
5734 else if (unformat (i, "arp-term %d", &arp_term))
5736 else if (unformat (i, "mac-age %d", &mac_age))
5738 else if (unformat (i, "del"))
5741 flood = uu_flood = forward = learn = 0;
5749 errmsg ("missing bridge domain");
5755 errmsg ("mac age must be less than 256 ");
5759 M (BRIDGE_DOMAIN_ADD_DEL, mp);
5761 mp->bd_id = ntohl (bd_id);
5763 mp->uu_flood = uu_flood;
5764 mp->forward = forward;
5766 mp->arp_term = arp_term;
5767 mp->is_add = is_add;
5768 mp->mac_age = (u8) mac_age;
5776 api_l2fib_add_del (vat_main_t * vam)
5778 unformat_input_t *i = vam->input;
5779 vl_api_l2fib_add_del_t *mp;
5785 u32 sw_if_index = ~0;
5786 u8 sw_if_index_set = 0;
5795 /* Parse args required to build the message */
5796 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5798 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
5800 else if (unformat (i, "bd_id %d", &bd_id))
5802 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5803 sw_if_index_set = 1;
5804 else if (unformat (i, "sw_if"))
5806 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5809 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5810 sw_if_index_set = 1;
5815 else if (unformat (i, "static"))
5817 else if (unformat (i, "filter"))
5822 else if (unformat (i, "bvi"))
5827 else if (unformat (i, "del"))
5829 else if (unformat (i, "count %d", &count))
5837 errmsg ("missing mac address");
5843 errmsg ("missing bridge domain");
5847 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
5849 errmsg ("missing interface name or sw_if_index");
5855 /* Turn on async mode */
5856 vam->async_mode = 1;
5857 vam->async_errors = 0;
5858 before = vat_time_now (vam);
5861 for (j = 0; j < count; j++)
5863 M (L2FIB_ADD_DEL, mp);
5866 mp->bd_id = ntohl (bd_id);
5867 mp->is_add = is_add;
5871 mp->sw_if_index = ntohl (sw_if_index);
5872 mp->static_mac = static_mac;
5873 mp->filter_mac = filter_mac;
5874 mp->bvi_mac = bvi_mac;
5876 increment_mac_address (&mac);
5883 vl_api_control_ping_t *mp_ping;
5886 /* Shut off async mode */
5887 vam->async_mode = 0;
5889 M (CONTROL_PING, mp_ping);
5892 timeout = vat_time_now (vam) + 1.0;
5893 while (vat_time_now (vam) < timeout)
5894 if (vam->result_ready == 1)
5899 if (vam->retval == -99)
5902 if (vam->async_errors > 0)
5904 errmsg ("%d asynchronous errors", vam->async_errors);
5907 vam->async_errors = 0;
5908 after = vat_time_now (vam);
5910 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
5911 count, after - before, count / (after - before));
5917 /* Wait for a reply... */
5921 /* Return the good/bad news */
5922 return (vam->retval);
5926 api_l2_flags (vat_main_t * vam)
5928 unformat_input_t *i = vam->input;
5929 vl_api_l2_flags_t *mp;
5931 u32 feature_bitmap = 0;
5932 u8 sw_if_index_set = 0;
5935 /* Parse args required to build the message */
5936 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5938 if (unformat (i, "sw_if_index %d", &sw_if_index))
5939 sw_if_index_set = 1;
5940 else if (unformat (i, "sw_if"))
5942 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5945 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5946 sw_if_index_set = 1;
5951 else if (unformat (i, "learn"))
5952 feature_bitmap |= L2INPUT_FEAT_LEARN;
5953 else if (unformat (i, "forward"))
5954 feature_bitmap |= L2INPUT_FEAT_FWD;
5955 else if (unformat (i, "flood"))
5956 feature_bitmap |= L2INPUT_FEAT_FLOOD;
5957 else if (unformat (i, "uu-flood"))
5958 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
5963 if (sw_if_index_set == 0)
5965 errmsg ("missing interface name or sw_if_index");
5971 mp->sw_if_index = ntohl (sw_if_index);
5972 mp->feature_bitmap = ntohl (feature_bitmap);
5980 api_bridge_flags (vat_main_t * vam)
5982 unformat_input_t *i = vam->input;
5983 vl_api_bridge_flags_t *mp;
5990 /* Parse args required to build the message */
5991 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5993 if (unformat (i, "bd_id %d", &bd_id))
5995 else if (unformat (i, "learn"))
5997 else if (unformat (i, "forward"))
5999 else if (unformat (i, "flood"))
6001 else if (unformat (i, "uu-flood"))
6002 flags |= L2_UU_FLOOD;
6003 else if (unformat (i, "arp-term"))
6004 flags |= L2_ARP_TERM;
6005 else if (unformat (i, "off"))
6007 else if (unformat (i, "disable"))
6015 errmsg ("missing bridge domain");
6019 M (BRIDGE_FLAGS, mp);
6021 mp->bd_id = ntohl (bd_id);
6022 mp->feature_bitmap = ntohl (flags);
6023 mp->is_set = is_set;
6031 api_bd_ip_mac_add_del (vat_main_t * vam)
6033 unformat_input_t *i = vam->input;
6034 vl_api_bd_ip_mac_add_del_t *mp;
6041 ip4_address_t v4addr;
6042 ip6_address_t v6addr;
6047 /* Parse args required to build the message */
6048 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6050 if (unformat (i, "bd_id %d", &bd_id))
6054 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
6058 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
6063 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
6067 else if (unformat (i, "del"))
6075 errmsg ("missing bridge domain");
6078 else if (ip_set == 0)
6080 errmsg ("missing IP address");
6083 else if (mac_set == 0)
6085 errmsg ("missing MAC address");
6089 M (BD_IP_MAC_ADD_DEL, mp);
6091 mp->bd_id = ntohl (bd_id);
6092 mp->is_ipv6 = is_ipv6;
6093 mp->is_add = is_add;
6095 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
6097 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
6098 clib_memcpy (mp->mac_address, macaddr, 6);
6105 api_tap_connect (vat_main_t * vam)
6107 unformat_input_t *i = vam->input;
6108 vl_api_tap_connect_t *mp;
6114 ip4_address_t ip4_address;
6116 int ip4_address_set = 0;
6117 ip6_address_t ip6_address;
6119 int ip6_address_set = 0;
6122 memset (mac_address, 0, sizeof (mac_address));
6124 /* Parse args required to build the message */
6125 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6127 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6131 else if (unformat (i, "random-mac"))
6133 else if (unformat (i, "tapname %s", &tap_name))
6135 else if (unformat (i, "tag %s", &tag))
6137 else if (unformat (i, "address %U/%d",
6138 unformat_ip4_address, &ip4_address, &ip4_mask_width))
6139 ip4_address_set = 1;
6140 else if (unformat (i, "address %U/%d",
6141 unformat_ip6_address, &ip6_address, &ip6_mask_width))
6142 ip6_address_set = 1;
6149 errmsg ("missing tap name");
6152 if (vec_len (tap_name) > 63)
6154 errmsg ("tap name too long");
6157 vec_add1 (tap_name, 0);
6159 if (vec_len (tag) > 63)
6161 errmsg ("tag too long");
6165 /* Construct the API message */
6166 M (TAP_CONNECT, mp);
6168 mp->use_random_mac = random_mac;
6169 clib_memcpy (mp->mac_address, mac_address, 6);
6170 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
6172 clib_memcpy (mp->tag, tag, vec_len (tag));
6174 if (ip4_address_set)
6176 mp->ip4_address_set = 1;
6177 clib_memcpy (mp->ip4_address, &ip4_address, sizeof (mp->ip4_address));
6178 mp->ip4_mask_width = ip4_mask_width;
6180 if (ip6_address_set)
6182 mp->ip6_address_set = 1;
6183 clib_memcpy (mp->ip6_address, &ip6_address, sizeof (mp->ip6_address));
6184 mp->ip6_mask_width = ip6_mask_width;
6187 vec_free (tap_name);
6193 /* Wait for a reply... */
6199 api_tap_modify (vat_main_t * vam)
6201 unformat_input_t *i = vam->input;
6202 vl_api_tap_modify_t *mp;
6207 u32 sw_if_index = ~0;
6208 u8 sw_if_index_set = 0;
6211 memset (mac_address, 0, sizeof (mac_address));
6213 /* Parse args required to build the message */
6214 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6216 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6217 sw_if_index_set = 1;
6218 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6219 sw_if_index_set = 1;
6220 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6224 else if (unformat (i, "random-mac"))
6226 else if (unformat (i, "tapname %s", &tap_name))
6232 if (sw_if_index_set == 0)
6234 errmsg ("missing vpp interface name");
6239 errmsg ("missing tap name");
6242 if (vec_len (tap_name) > 63)
6244 errmsg ("tap name too long");
6246 vec_add1 (tap_name, 0);
6248 /* Construct the API message */
6251 mp->use_random_mac = random_mac;
6252 mp->sw_if_index = ntohl (sw_if_index);
6253 clib_memcpy (mp->mac_address, mac_address, 6);
6254 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
6255 vec_free (tap_name);
6260 /* Wait for a reply... */
6266 api_tap_delete (vat_main_t * vam)
6268 unformat_input_t *i = vam->input;
6269 vl_api_tap_delete_t *mp;
6270 u32 sw_if_index = ~0;
6271 u8 sw_if_index_set = 0;
6274 /* Parse args required to build the message */
6275 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6277 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6278 sw_if_index_set = 1;
6279 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6280 sw_if_index_set = 1;
6285 if (sw_if_index_set == 0)
6287 errmsg ("missing vpp interface name");
6291 /* Construct the API message */
6294 mp->sw_if_index = ntohl (sw_if_index);
6299 /* Wait for a reply... */
6305 api_ip_add_del_route (vat_main_t * vam)
6307 unformat_input_t *i = vam->input;
6308 vl_api_ip_add_del_route_t *mp;
6309 u32 sw_if_index = ~0, vrf_id = 0;
6311 u8 is_local = 0, is_drop = 0;
6312 u8 is_unreach = 0, is_prohibit = 0;
6313 u8 create_vrf_if_needed = 0;
6315 u32 next_hop_weight = 1;
6317 u8 is_multipath = 0;
6319 u8 address_length_set = 0;
6320 u32 next_hop_table_id = 0;
6321 u32 resolve_attempts = 0;
6322 u32 dst_address_length = 0;
6323 u8 next_hop_set = 0;
6324 ip4_address_t v4_dst_address, v4_next_hop_address;
6325 ip6_address_t v6_dst_address, v6_next_hop_address;
6329 u32 random_add_del = 0;
6330 u32 *random_vector = 0;
6332 u32 random_seed = 0xdeaddabe;
6333 u32 classify_table_index = ~0;
6335 u8 resolve_host = 0, resolve_attached = 0;
6336 mpls_label_t *next_hop_out_label_stack = NULL;
6337 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6338 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
6340 /* Parse args required to build the message */
6341 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6343 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6345 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6347 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
6352 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
6357 else if (unformat (i, "/%d", &dst_address_length))
6359 address_length_set = 1;
6362 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
6363 &v4_next_hop_address))
6367 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
6368 &v6_next_hop_address))
6372 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
6374 else if (unformat (i, "weight %d", &next_hop_weight))
6376 else if (unformat (i, "drop"))
6380 else if (unformat (i, "null-send-unreach"))
6384 else if (unformat (i, "null-send-prohibit"))
6388 else if (unformat (i, "local"))
6392 else if (unformat (i, "classify %d", &classify_table_index))
6396 else if (unformat (i, "del"))
6398 else if (unformat (i, "add"))
6400 else if (unformat (i, "not-last"))
6402 else if (unformat (i, "resolve-via-host"))
6404 else if (unformat (i, "resolve-via-attached"))
6405 resolve_attached = 1;
6406 else if (unformat (i, "multipath"))
6408 else if (unformat (i, "vrf %d", &vrf_id))
6410 else if (unformat (i, "create-vrf"))
6411 create_vrf_if_needed = 1;
6412 else if (unformat (i, "count %d", &count))
6414 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
6416 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6418 else if (unformat (i, "out-label %d", &next_hop_out_label))
6419 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
6420 else if (unformat (i, "via-label %d", &next_hop_via_label))
6422 else if (unformat (i, "random"))
6424 else if (unformat (i, "seed %d", &random_seed))
6428 clib_warning ("parse error '%U'", format_unformat_error, i);
6433 if (!next_hop_set && !is_drop && !is_local &&
6434 !is_classify && !is_unreach && !is_prohibit &&
6435 MPLS_LABEL_INVALID == next_hop_via_label)
6438 ("next hop / local / drop / unreach / prohibit / classify not set");
6442 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
6444 errmsg ("next hop and next-hop via label set");
6447 if (address_set == 0)
6449 errmsg ("missing addresses");
6453 if (address_length_set == 0)
6455 errmsg ("missing address length");
6459 /* Generate a pile of unique, random routes */
6462 u32 this_random_address;
6463 random_hash = hash_create (count, sizeof (uword));
6465 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
6466 for (j = 0; j <= count; j++)
6470 this_random_address = random_u32 (&random_seed);
6471 this_random_address =
6472 clib_host_to_net_u32 (this_random_address);
6474 while (hash_get (random_hash, this_random_address));
6475 vec_add1 (random_vector, this_random_address);
6476 hash_set (random_hash, this_random_address, 1);
6478 hash_free (random_hash);
6479 v4_dst_address.as_u32 = random_vector[0];
6484 /* Turn on async mode */
6485 vam->async_mode = 1;
6486 vam->async_errors = 0;
6487 before = vat_time_now (vam);
6490 for (j = 0; j < count; j++)
6492 /* Construct the API message */
6493 M2 (IP_ADD_DEL_ROUTE, mp,
6494 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
6496 mp->next_hop_sw_if_index = ntohl (sw_if_index);
6497 mp->table_id = ntohl (vrf_id);
6498 mp->create_vrf_if_needed = create_vrf_if_needed;
6500 mp->is_add = is_add;
6501 mp->is_drop = is_drop;
6502 mp->is_unreach = is_unreach;
6503 mp->is_prohibit = is_prohibit;
6504 mp->is_ipv6 = is_ipv6;
6505 mp->is_local = is_local;
6506 mp->is_classify = is_classify;
6507 mp->is_multipath = is_multipath;
6508 mp->is_resolve_host = resolve_host;
6509 mp->is_resolve_attached = resolve_attached;
6510 mp->not_last = not_last;
6511 mp->next_hop_weight = next_hop_weight;
6512 mp->dst_address_length = dst_address_length;
6513 mp->next_hop_table_id = ntohl (next_hop_table_id);
6514 mp->classify_table_index = ntohl (classify_table_index);
6515 mp->next_hop_via_label = ntohl (next_hop_via_label);
6516 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
6517 if (0 != mp->next_hop_n_out_labels)
6519 memcpy (mp->next_hop_out_label_stack,
6520 next_hop_out_label_stack,
6521 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
6522 vec_free (next_hop_out_label_stack);
6527 clib_memcpy (mp->dst_address, &v6_dst_address,
6528 sizeof (v6_dst_address));
6530 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
6531 sizeof (v6_next_hop_address));
6532 increment_v6_address (&v6_dst_address);
6536 clib_memcpy (mp->dst_address, &v4_dst_address,
6537 sizeof (v4_dst_address));
6539 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
6540 sizeof (v4_next_hop_address));
6542 v4_dst_address.as_u32 = random_vector[j + 1];
6544 increment_v4_address (&v4_dst_address);
6548 /* If we receive SIGTERM, stop now... */
6553 /* When testing multiple add/del ops, use a control-ping to sync */
6556 vl_api_control_ping_t *mp_ping;
6560 /* Shut off async mode */
6561 vam->async_mode = 0;
6563 M (CONTROL_PING, mp_ping);
6566 timeout = vat_time_now (vam) + 1.0;
6567 while (vat_time_now (vam) < timeout)
6568 if (vam->result_ready == 1)
6573 if (vam->retval == -99)
6576 if (vam->async_errors > 0)
6578 errmsg ("%d asynchronous errors", vam->async_errors);
6581 vam->async_errors = 0;
6582 after = vat_time_now (vam);
6584 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6588 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6589 count, after - before, count / (after - before));
6595 /* Wait for a reply... */
6600 /* Return the good/bad news */
6601 return (vam->retval);
6605 api_ip_mroute_add_del (vat_main_t * vam)
6607 unformat_input_t *i = vam->input;
6608 vl_api_ip_mroute_add_del_t *mp;
6609 u32 sw_if_index = ~0, vrf_id = 0;
6612 u8 create_vrf_if_needed = 0;
6615 u32 grp_address_length = 0;
6616 ip4_address_t v4_grp_address, v4_src_address;
6617 ip6_address_t v6_grp_address, v6_src_address;
6618 mfib_itf_flags_t iflags = 0;
6619 mfib_entry_flags_t eflags = 0;
6622 /* Parse args required to build the message */
6623 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6625 if (unformat (i, "sw_if_index %d", &sw_if_index))
6627 else if (unformat (i, "%U %U",
6628 unformat_ip4_address, &v4_src_address,
6629 unformat_ip4_address, &v4_grp_address))
6631 grp_address_length = 64;
6635 else if (unformat (i, "%U %U",
6636 unformat_ip6_address, &v6_src_address,
6637 unformat_ip6_address, &v6_grp_address))
6639 grp_address_length = 256;
6643 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
6645 memset (&v4_src_address, 0, sizeof (v4_src_address));
6646 grp_address_length = 32;
6650 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
6652 memset (&v6_src_address, 0, sizeof (v6_src_address));
6653 grp_address_length = 128;
6657 else if (unformat (i, "/%d", &grp_address_length))
6659 else if (unformat (i, "local"))
6663 else if (unformat (i, "del"))
6665 else if (unformat (i, "add"))
6667 else if (unformat (i, "vrf %d", &vrf_id))
6669 else if (unformat (i, "create-vrf"))
6670 create_vrf_if_needed = 1;
6671 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
6673 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
6677 clib_warning ("parse error '%U'", format_unformat_error, i);
6682 if (address_set == 0)
6684 errmsg ("missing addresses\n");
6688 /* Construct the API message */
6689 M (IP_MROUTE_ADD_DEL, mp);
6691 mp->next_hop_sw_if_index = ntohl (sw_if_index);
6692 mp->table_id = ntohl (vrf_id);
6693 mp->create_vrf_if_needed = create_vrf_if_needed;
6695 mp->is_add = is_add;
6696 mp->is_ipv6 = is_ipv6;
6697 mp->is_local = is_local;
6698 mp->itf_flags = ntohl (iflags);
6699 mp->entry_flags = ntohl (eflags);
6700 mp->grp_address_length = grp_address_length;
6701 mp->grp_address_length = ntohs (mp->grp_address_length);
6705 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
6706 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
6710 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
6711 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
6717 /* Wait for a reply... */
6723 api_mpls_route_add_del (vat_main_t * vam)
6725 unformat_input_t *i = vam->input;
6726 vl_api_mpls_route_add_del_t *mp;
6727 u32 sw_if_index = ~0, table_id = 0;
6728 u8 create_table_if_needed = 0;
6730 u32 next_hop_weight = 1;
6731 u8 is_multipath = 0;
6732 u32 next_hop_table_id = 0;
6733 u8 next_hop_set = 0;
6734 ip4_address_t v4_next_hop_address = {
6737 ip6_address_t v6_next_hop_address = { {0} };
6741 u32 classify_table_index = ~0;
6743 u8 resolve_host = 0, resolve_attached = 0;
6744 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
6745 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6746 mpls_label_t *next_hop_out_label_stack = NULL;
6747 mpls_label_t local_label = MPLS_LABEL_INVALID;
6749 u8 next_hop_proto_is_ip4 = 1;
6751 /* Parse args required to build the message */
6752 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6754 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6756 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6758 else if (unformat (i, "%d", &local_label))
6760 else if (unformat (i, "eos"))
6762 else if (unformat (i, "non-eos"))
6764 else if (unformat (i, "via %U", unformat_ip4_address,
6765 &v4_next_hop_address))
6768 next_hop_proto_is_ip4 = 1;
6770 else if (unformat (i, "via %U", unformat_ip6_address,
6771 &v6_next_hop_address))
6774 next_hop_proto_is_ip4 = 0;
6776 else if (unformat (i, "weight %d", &next_hop_weight))
6778 else if (unformat (i, "create-table"))
6779 create_table_if_needed = 1;
6780 else if (unformat (i, "classify %d", &classify_table_index))
6784 else if (unformat (i, "del"))
6786 else if (unformat (i, "add"))
6788 else if (unformat (i, "resolve-via-host"))
6790 else if (unformat (i, "resolve-via-attached"))
6791 resolve_attached = 1;
6792 else if (unformat (i, "multipath"))
6794 else if (unformat (i, "count %d", &count))
6796 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
6799 next_hop_proto_is_ip4 = 1;
6801 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
6804 next_hop_proto_is_ip4 = 0;
6806 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6808 else if (unformat (i, "via-label %d", &next_hop_via_label))
6810 else if (unformat (i, "out-label %d", &next_hop_out_label))
6811 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
6814 clib_warning ("parse error '%U'", format_unformat_error, i);
6819 if (!next_hop_set && !is_classify)
6821 errmsg ("next hop / classify not set");
6825 if (MPLS_LABEL_INVALID == local_label)
6827 errmsg ("missing label");
6833 /* Turn on async mode */
6834 vam->async_mode = 1;
6835 vam->async_errors = 0;
6836 before = vat_time_now (vam);
6839 for (j = 0; j < count; j++)
6841 /* Construct the API message */
6842 M2 (MPLS_ROUTE_ADD_DEL, mp,
6843 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
6845 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
6846 mp->mr_table_id = ntohl (table_id);
6847 mp->mr_create_table_if_needed = create_table_if_needed;
6849 mp->mr_is_add = is_add;
6850 mp->mr_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
6851 mp->mr_is_classify = is_classify;
6852 mp->mr_is_multipath = is_multipath;
6853 mp->mr_is_resolve_host = resolve_host;
6854 mp->mr_is_resolve_attached = resolve_attached;
6855 mp->mr_next_hop_weight = next_hop_weight;
6856 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
6857 mp->mr_classify_table_index = ntohl (classify_table_index);
6858 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
6859 mp->mr_label = ntohl (local_label);
6860 mp->mr_eos = is_eos;
6862 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
6863 if (0 != mp->mr_next_hop_n_out_labels)
6865 memcpy (mp->mr_next_hop_out_label_stack,
6866 next_hop_out_label_stack,
6867 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
6868 vec_free (next_hop_out_label_stack);
6873 if (next_hop_proto_is_ip4)
6875 clib_memcpy (mp->mr_next_hop,
6876 &v4_next_hop_address,
6877 sizeof (v4_next_hop_address));
6881 clib_memcpy (mp->mr_next_hop,
6882 &v6_next_hop_address,
6883 sizeof (v6_next_hop_address));
6890 /* If we receive SIGTERM, stop now... */
6895 /* When testing multiple add/del ops, use a control-ping to sync */
6898 vl_api_control_ping_t *mp_ping;
6902 /* Shut off async mode */
6903 vam->async_mode = 0;
6905 M (CONTROL_PING, mp_ping);
6908 timeout = vat_time_now (vam) + 1.0;
6909 while (vat_time_now (vam) < timeout)
6910 if (vam->result_ready == 1)
6915 if (vam->retval == -99)
6918 if (vam->async_errors > 0)
6920 errmsg ("%d asynchronous errors", vam->async_errors);
6923 vam->async_errors = 0;
6924 after = vat_time_now (vam);
6926 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6930 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6931 count, after - before, count / (after - before));
6937 /* Wait for a reply... */
6942 /* Return the good/bad news */
6943 return (vam->retval);
6947 api_mpls_ip_bind_unbind (vat_main_t * vam)
6949 unformat_input_t *i = vam->input;
6950 vl_api_mpls_ip_bind_unbind_t *mp;
6951 u32 ip_table_id = 0;
6952 u8 create_table_if_needed = 0;
6955 ip4_address_t v4_address;
6956 ip6_address_t v6_address;
6959 mpls_label_t local_label = MPLS_LABEL_INVALID;
6962 /* Parse args required to build the message */
6963 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6965 if (unformat (i, "%U/%d", unformat_ip4_address,
6966 &v4_address, &address_length))
6971 else if (unformat (i, "%U/%d", unformat_ip6_address,
6972 &v6_address, &address_length))
6977 else if (unformat (i, "%d", &local_label))
6979 else if (unformat (i, "create-table"))
6980 create_table_if_needed = 1;
6981 else if (unformat (i, "table-id %d", &ip_table_id))
6983 else if (unformat (i, "unbind"))
6985 else if (unformat (i, "bind"))
6989 clib_warning ("parse error '%U'", format_unformat_error, i);
6996 errmsg ("IP addres not set");
7000 if (MPLS_LABEL_INVALID == local_label)
7002 errmsg ("missing label");
7006 /* Construct the API message */
7007 M (MPLS_IP_BIND_UNBIND, mp);
7009 mp->mb_create_table_if_needed = create_table_if_needed;
7010 mp->mb_is_bind = is_bind;
7011 mp->mb_is_ip4 = is_ip4;
7012 mp->mb_ip_table_id = ntohl (ip_table_id);
7013 mp->mb_mpls_table_id = 0;
7014 mp->mb_label = ntohl (local_label);
7015 mp->mb_address_length = address_length;
7018 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
7020 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
7025 /* Wait for a reply... */
7031 api_proxy_arp_add_del (vat_main_t * vam)
7033 unformat_input_t *i = vam->input;
7034 vl_api_proxy_arp_add_del_t *mp;
7037 ip4_address_t lo, hi;
7041 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7043 if (unformat (i, "vrf %d", &vrf_id))
7045 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
7046 unformat_ip4_address, &hi))
7048 else if (unformat (i, "del"))
7052 clib_warning ("parse error '%U'", format_unformat_error, i);
7059 errmsg ("address range not set");
7063 M (PROXY_ARP_ADD_DEL, mp);
7065 mp->vrf_id = ntohl (vrf_id);
7066 mp->is_add = is_add;
7067 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
7068 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
7076 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
7078 unformat_input_t *i = vam->input;
7079 vl_api_proxy_arp_intfc_enable_disable_t *mp;
7082 u8 sw_if_index_set = 0;
7085 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7087 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7088 sw_if_index_set = 1;
7089 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7090 sw_if_index_set = 1;
7091 else if (unformat (i, "enable"))
7093 else if (unformat (i, "disable"))
7097 clib_warning ("parse error '%U'", format_unformat_error, i);
7102 if (sw_if_index_set == 0)
7104 errmsg ("missing interface name or sw_if_index");
7108 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
7110 mp->sw_if_index = ntohl (sw_if_index);
7111 mp->enable_disable = enable;
7119 api_mpls_tunnel_add_del (vat_main_t * vam)
7121 unformat_input_t *i = vam->input;
7122 vl_api_mpls_tunnel_add_del_t *mp;
7126 u32 sw_if_index = ~0;
7127 u32 next_hop_sw_if_index = ~0;
7128 u32 next_hop_proto_is_ip4 = 1;
7130 u32 next_hop_table_id = 0;
7131 ip4_address_t v4_next_hop_address = {
7134 ip6_address_t v6_next_hop_address = { {0} };
7135 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID, *labels = NULL;
7138 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7140 if (unformat (i, "add"))
7142 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
7144 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
7146 else if (unformat (i, "via %U",
7147 unformat_ip4_address, &v4_next_hop_address))
7149 next_hop_proto_is_ip4 = 1;
7151 else if (unformat (i, "via %U",
7152 unformat_ip6_address, &v6_next_hop_address))
7154 next_hop_proto_is_ip4 = 0;
7156 else if (unformat (i, "l2-only"))
7158 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
7160 else if (unformat (i, "out-label %d", &next_hop_out_label))
7161 vec_add1 (labels, ntohl (next_hop_out_label));
7164 clib_warning ("parse error '%U'", format_unformat_error, i);
7169 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (mpls_label_t) * vec_len (labels));
7171 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
7172 mp->mt_sw_if_index = ntohl (sw_if_index);
7173 mp->mt_is_add = is_add;
7174 mp->mt_l2_only = l2_only;
7175 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
7176 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
7178 mp->mt_next_hop_n_out_labels = vec_len (labels);
7180 if (0 != mp->mt_next_hop_n_out_labels)
7182 clib_memcpy (mp->mt_next_hop_out_label_stack, labels,
7183 sizeof (mpls_label_t) * mp->mt_next_hop_n_out_labels);
7187 if (next_hop_proto_is_ip4)
7189 clib_memcpy (mp->mt_next_hop,
7190 &v4_next_hop_address, sizeof (v4_next_hop_address));
7194 clib_memcpy (mp->mt_next_hop,
7195 &v6_next_hop_address, sizeof (v6_next_hop_address));
7204 api_sw_interface_set_unnumbered (vat_main_t * vam)
7206 unformat_input_t *i = vam->input;
7207 vl_api_sw_interface_set_unnumbered_t *mp;
7209 u32 unnum_sw_index = ~0;
7211 u8 sw_if_index_set = 0;
7214 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7216 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7217 sw_if_index_set = 1;
7218 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7219 sw_if_index_set = 1;
7220 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
7222 else if (unformat (i, "del"))
7226 clib_warning ("parse error '%U'", format_unformat_error, i);
7231 if (sw_if_index_set == 0)
7233 errmsg ("missing interface name or sw_if_index");
7237 M (SW_INTERFACE_SET_UNNUMBERED, mp);
7239 mp->sw_if_index = ntohl (sw_if_index);
7240 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
7241 mp->is_add = is_add;
7249 api_ip_neighbor_add_del (vat_main_t * vam)
7251 unformat_input_t *i = vam->input;
7252 vl_api_ip_neighbor_add_del_t *mp;
7254 u8 sw_if_index_set = 0;
7260 u8 v4_address_set = 0;
7261 u8 v6_address_set = 0;
7262 ip4_address_t v4address;
7263 ip6_address_t v6address;
7266 memset (mac_address, 0, sizeof (mac_address));
7268 /* Parse args required to build the message */
7269 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7271 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
7275 else if (unformat (i, "del"))
7278 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7279 sw_if_index_set = 1;
7280 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7281 sw_if_index_set = 1;
7282 else if (unformat (i, "is_static"))
7284 else if (unformat (i, "vrf %d", &vrf_id))
7286 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
7288 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
7292 clib_warning ("parse error '%U'", format_unformat_error, i);
7297 if (sw_if_index_set == 0)
7299 errmsg ("missing interface name or sw_if_index");
7302 if (v4_address_set && v6_address_set)
7304 errmsg ("both v4 and v6 addresses set");
7307 if (!v4_address_set && !v6_address_set)
7309 errmsg ("no address set");
7313 /* Construct the API message */
7314 M (IP_NEIGHBOR_ADD_DEL, mp);
7316 mp->sw_if_index = ntohl (sw_if_index);
7317 mp->is_add = is_add;
7318 mp->vrf_id = ntohl (vrf_id);
7319 mp->is_static = is_static;
7321 clib_memcpy (mp->mac_address, mac_address, 6);
7325 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
7329 /* mp->is_ipv6 = 0; via memset in M macro above */
7330 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
7336 /* Wait for a reply, return good/bad news */
7342 api_reset_vrf (vat_main_t * vam)
7344 unformat_input_t *i = vam->input;
7345 vl_api_reset_vrf_t *mp;
7351 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7353 if (unformat (i, "vrf %d", &vrf_id))
7355 else if (unformat (i, "ipv6"))
7359 clib_warning ("parse error '%U'", format_unformat_error, i);
7364 if (vrf_id_set == 0)
7366 errmsg ("missing vrf id");
7372 mp->vrf_id = ntohl (vrf_id);
7373 mp->is_ipv6 = is_ipv6;
7381 api_create_vlan_subif (vat_main_t * vam)
7383 unformat_input_t *i = vam->input;
7384 vl_api_create_vlan_subif_t *mp;
7386 u8 sw_if_index_set = 0;
7391 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7393 if (unformat (i, "sw_if_index %d", &sw_if_index))
7394 sw_if_index_set = 1;
7396 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7397 sw_if_index_set = 1;
7398 else if (unformat (i, "vlan %d", &vlan_id))
7402 clib_warning ("parse error '%U'", format_unformat_error, i);
7407 if (sw_if_index_set == 0)
7409 errmsg ("missing interface name or sw_if_index");
7413 if (vlan_id_set == 0)
7415 errmsg ("missing vlan_id");
7418 M (CREATE_VLAN_SUBIF, mp);
7420 mp->sw_if_index = ntohl (sw_if_index);
7421 mp->vlan_id = ntohl (vlan_id);
7428 #define foreach_create_subif_bit \
7435 _(outer_vlan_id_any) \
7436 _(inner_vlan_id_any)
7439 api_create_subif (vat_main_t * vam)
7441 unformat_input_t *i = vam->input;
7442 vl_api_create_subif_t *mp;
7444 u8 sw_if_index_set = 0;
7451 u32 exact_match = 0;
7452 u32 default_sub = 0;
7453 u32 outer_vlan_id_any = 0;
7454 u32 inner_vlan_id_any = 0;
7456 u16 outer_vlan_id = 0;
7457 u16 inner_vlan_id = 0;
7460 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7462 if (unformat (i, "sw_if_index %d", &sw_if_index))
7463 sw_if_index_set = 1;
7465 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7466 sw_if_index_set = 1;
7467 else if (unformat (i, "sub_id %d", &sub_id))
7469 else if (unformat (i, "outer_vlan_id %d", &tmp))
7470 outer_vlan_id = tmp;
7471 else if (unformat (i, "inner_vlan_id %d", &tmp))
7472 inner_vlan_id = tmp;
7474 #define _(a) else if (unformat (i, #a)) a = 1 ;
7475 foreach_create_subif_bit
7479 clib_warning ("parse error '%U'", format_unformat_error, i);
7484 if (sw_if_index_set == 0)
7486 errmsg ("missing interface name or sw_if_index");
7490 if (sub_id_set == 0)
7492 errmsg ("missing sub_id");
7495 M (CREATE_SUBIF, mp);
7497 mp->sw_if_index = ntohl (sw_if_index);
7498 mp->sub_id = ntohl (sub_id);
7500 #define _(a) mp->a = a;
7501 foreach_create_subif_bit;
7504 mp->outer_vlan_id = ntohs (outer_vlan_id);
7505 mp->inner_vlan_id = ntohs (inner_vlan_id);
7513 api_oam_add_del (vat_main_t * vam)
7515 unformat_input_t *i = vam->input;
7516 vl_api_oam_add_del_t *mp;
7519 ip4_address_t src, dst;
7524 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7526 if (unformat (i, "vrf %d", &vrf_id))
7528 else if (unformat (i, "src %U", unformat_ip4_address, &src))
7530 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
7532 else if (unformat (i, "del"))
7536 clib_warning ("parse error '%U'", format_unformat_error, i);
7543 errmsg ("missing src addr");
7549 errmsg ("missing dst addr");
7553 M (OAM_ADD_DEL, mp);
7555 mp->vrf_id = ntohl (vrf_id);
7556 mp->is_add = is_add;
7557 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
7558 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
7566 api_reset_fib (vat_main_t * vam)
7568 unformat_input_t *i = vam->input;
7569 vl_api_reset_fib_t *mp;
7575 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7577 if (unformat (i, "vrf %d", &vrf_id))
7579 else if (unformat (i, "ipv6"))
7583 clib_warning ("parse error '%U'", format_unformat_error, i);
7588 if (vrf_id_set == 0)
7590 errmsg ("missing vrf id");
7596 mp->vrf_id = ntohl (vrf_id);
7597 mp->is_ipv6 = is_ipv6;
7605 api_dhcp_proxy_config (vat_main_t * vam)
7607 unformat_input_t *i = vam->input;
7608 vl_api_dhcp_proxy_config_t *mp;
7612 u8 v4_address_set = 0;
7613 u8 v6_address_set = 0;
7614 ip4_address_t v4address;
7615 ip6_address_t v6address;
7616 u8 v4_src_address_set = 0;
7617 u8 v6_src_address_set = 0;
7618 ip4_address_t v4srcaddress;
7619 ip6_address_t v6srcaddress;
7622 /* Parse args required to build the message */
7623 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7625 if (unformat (i, "del"))
7627 else if (unformat (i, "vrf %d", &vrf_id))
7629 else if (unformat (i, "insert-cid %d", &insert_cid))
7631 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
7633 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
7635 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
7636 v4_src_address_set = 1;
7637 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
7638 v6_src_address_set = 1;
7643 if (v4_address_set && v6_address_set)
7645 errmsg ("both v4 and v6 server addresses set");
7648 if (!v4_address_set && !v6_address_set)
7650 errmsg ("no server addresses set");
7654 if (v4_src_address_set && v6_src_address_set)
7656 errmsg ("both v4 and v6 src addresses set");
7659 if (!v4_src_address_set && !v6_src_address_set)
7661 errmsg ("no src addresses set");
7665 if (!(v4_src_address_set && v4_address_set) &&
7666 !(v6_src_address_set && v6_address_set))
7668 errmsg ("no matching server and src addresses set");
7672 /* Construct the API message */
7673 M (DHCP_PROXY_CONFIG, mp);
7675 mp->insert_circuit_id = insert_cid;
7676 mp->is_add = is_add;
7677 mp->vrf_id = ntohl (vrf_id);
7681 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
7682 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
7686 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
7687 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
7693 /* Wait for a reply, return good/bad news */
7699 api_dhcp_proxy_config_2 (vat_main_t * vam)
7701 unformat_input_t *i = vam->input;
7702 vl_api_dhcp_proxy_config_2_t *mp;
7704 u32 server_vrf_id = 0;
7707 u8 v4_address_set = 0;
7708 u8 v6_address_set = 0;
7709 ip4_address_t v4address;
7710 ip6_address_t v6address;
7711 u8 v4_src_address_set = 0;
7712 u8 v6_src_address_set = 0;
7713 ip4_address_t v4srcaddress;
7714 ip6_address_t v6srcaddress;
7717 /* Parse args required to build the message */
7718 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7720 if (unformat (i, "del"))
7722 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
7724 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
7726 else if (unformat (i, "insert-cid %d", &insert_cid))
7728 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
7730 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
7732 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
7733 v4_src_address_set = 1;
7734 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
7735 v6_src_address_set = 1;
7740 if (v4_address_set && v6_address_set)
7742 errmsg ("both v4 and v6 server addresses set");
7745 if (!v4_address_set && !v6_address_set)
7747 errmsg ("no server addresses set");
7751 if (v4_src_address_set && v6_src_address_set)
7753 errmsg ("both v4 and v6 src addresses set");
7756 if (!v4_src_address_set && !v6_src_address_set)
7758 errmsg ("no src addresses set");
7762 if (!(v4_src_address_set && v4_address_set) &&
7763 !(v6_src_address_set && v6_address_set))
7765 errmsg ("no matching server and src addresses set");
7769 /* Construct the API message */
7770 M (DHCP_PROXY_CONFIG_2, mp);
7772 mp->insert_circuit_id = insert_cid;
7773 mp->is_add = is_add;
7774 mp->rx_vrf_id = ntohl (rx_vrf_id);
7775 mp->server_vrf_id = ntohl (server_vrf_id);
7779 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
7780 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
7784 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
7785 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
7791 /* Wait for a reply, return good/bad news */
7797 api_dhcp_proxy_set_vss (vat_main_t * vam)
7799 unformat_input_t *i = vam->input;
7800 vl_api_dhcp_proxy_set_vss_t *mp;
7811 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7813 if (unformat (i, "tbl_id %d", &tbl_id))
7815 if (unformat (i, "fib_id %d", &fib_id))
7817 if (unformat (i, "oui %d", &oui))
7819 else if (unformat (i, "ipv6"))
7821 else if (unformat (i, "del"))
7825 clib_warning ("parse error '%U'", format_unformat_error, i);
7830 if (tbl_id_set == 0)
7832 errmsg ("missing tbl id");
7836 if (fib_id_set == 0)
7838 errmsg ("missing fib id");
7843 errmsg ("missing oui");
7847 M (DHCP_PROXY_SET_VSS, mp);
7848 mp->tbl_id = ntohl (tbl_id);
7849 mp->fib_id = ntohl (fib_id);
7850 mp->oui = ntohl (oui);
7851 mp->is_ipv6 = is_ipv6;
7852 mp->is_add = is_add;
7860 api_dhcp_client_config (vat_main_t * vam)
7862 unformat_input_t *i = vam->input;
7863 vl_api_dhcp_client_config_t *mp;
7865 u8 sw_if_index_set = 0;
7868 u8 disable_event = 0;
7871 /* Parse args required to build the message */
7872 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7874 if (unformat (i, "del"))
7877 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7878 sw_if_index_set = 1;
7879 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7880 sw_if_index_set = 1;
7881 else if (unformat (i, "hostname %s", &hostname))
7883 else if (unformat (i, "disable_event"))
7889 if (sw_if_index_set == 0)
7891 errmsg ("missing interface name or sw_if_index");
7895 if (vec_len (hostname) > 63)
7897 errmsg ("hostname too long");
7899 vec_add1 (hostname, 0);
7901 /* Construct the API message */
7902 M (DHCP_CLIENT_CONFIG, mp);
7904 mp->sw_if_index = ntohl (sw_if_index);
7905 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
7906 vec_free (hostname);
7907 mp->is_add = is_add;
7908 mp->want_dhcp_event = disable_event ? 0 : 1;
7909 mp->pid = getpid ();
7914 /* Wait for a reply, return good/bad news */
7920 api_set_ip_flow_hash (vat_main_t * vam)
7922 unformat_input_t *i = vam->input;
7923 vl_api_set_ip_flow_hash_t *mp;
7935 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7937 if (unformat (i, "vrf %d", &vrf_id))
7939 else if (unformat (i, "ipv6"))
7941 else if (unformat (i, "src"))
7943 else if (unformat (i, "dst"))
7945 else if (unformat (i, "sport"))
7947 else if (unformat (i, "dport"))
7949 else if (unformat (i, "proto"))
7951 else if (unformat (i, "reverse"))
7956 clib_warning ("parse error '%U'", format_unformat_error, i);
7961 if (vrf_id_set == 0)
7963 errmsg ("missing vrf id");
7967 M (SET_IP_FLOW_HASH, mp);
7973 mp->reverse = reverse;
7974 mp->vrf_id = ntohl (vrf_id);
7975 mp->is_ipv6 = is_ipv6;
7983 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
7985 unformat_input_t *i = vam->input;
7986 vl_api_sw_interface_ip6_enable_disable_t *mp;
7988 u8 sw_if_index_set = 0;
7992 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7994 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7995 sw_if_index_set = 1;
7996 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7997 sw_if_index_set = 1;
7998 else if (unformat (i, "enable"))
8000 else if (unformat (i, "disable"))
8004 clib_warning ("parse error '%U'", format_unformat_error, i);
8009 if (sw_if_index_set == 0)
8011 errmsg ("missing interface name or sw_if_index");
8015 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
8017 mp->sw_if_index = ntohl (sw_if_index);
8018 mp->enable = enable;
8026 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
8028 unformat_input_t *i = vam->input;
8029 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
8031 u8 sw_if_index_set = 0;
8032 u8 v6_address_set = 0;
8033 ip6_address_t v6address;
8036 /* Parse args required to build the message */
8037 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8039 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8040 sw_if_index_set = 1;
8041 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8042 sw_if_index_set = 1;
8043 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
8049 if (sw_if_index_set == 0)
8051 errmsg ("missing interface name or sw_if_index");
8054 if (!v6_address_set)
8056 errmsg ("no address set");
8060 /* Construct the API message */
8061 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, mp);
8063 mp->sw_if_index = ntohl (sw_if_index);
8064 clib_memcpy (mp->address, &v6address, sizeof (v6address));
8069 /* Wait for a reply, return good/bad news */
8076 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
8078 unformat_input_t *i = vam->input;
8079 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
8081 u8 sw_if_index_set = 0;
8082 u32 address_length = 0;
8083 u8 v6_address_set = 0;
8084 ip6_address_t v6address;
8086 u8 no_advertise = 0;
8088 u8 no_autoconfig = 0;
8091 u32 val_lifetime = 0;
8092 u32 pref_lifetime = 0;
8095 /* Parse args required to build the message */
8096 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8098 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8099 sw_if_index_set = 1;
8100 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8101 sw_if_index_set = 1;
8102 else if (unformat (i, "%U/%d",
8103 unformat_ip6_address, &v6address, &address_length))
8105 else if (unformat (i, "val_life %d", &val_lifetime))
8107 else if (unformat (i, "pref_life %d", &pref_lifetime))
8109 else if (unformat (i, "def"))
8111 else if (unformat (i, "noadv"))
8113 else if (unformat (i, "offl"))
8115 else if (unformat (i, "noauto"))
8117 else if (unformat (i, "nolink"))
8119 else if (unformat (i, "isno"))
8123 clib_warning ("parse error '%U'", format_unformat_error, i);
8128 if (sw_if_index_set == 0)
8130 errmsg ("missing interface name or sw_if_index");
8133 if (!v6_address_set)
8135 errmsg ("no address set");
8139 /* Construct the API message */
8140 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
8142 mp->sw_if_index = ntohl (sw_if_index);
8143 clib_memcpy (mp->address, &v6address, sizeof (v6address));
8144 mp->address_length = address_length;
8145 mp->use_default = use_default;
8146 mp->no_advertise = no_advertise;
8147 mp->off_link = off_link;
8148 mp->no_autoconfig = no_autoconfig;
8149 mp->no_onlink = no_onlink;
8151 mp->val_lifetime = ntohl (val_lifetime);
8152 mp->pref_lifetime = ntohl (pref_lifetime);
8157 /* Wait for a reply, return good/bad news */
8163 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
8165 unformat_input_t *i = vam->input;
8166 vl_api_sw_interface_ip6nd_ra_config_t *mp;
8168 u8 sw_if_index_set = 0;
8173 u8 send_unicast = 0;
8176 u8 default_router = 0;
8177 u32 max_interval = 0;
8178 u32 min_interval = 0;
8180 u32 initial_count = 0;
8181 u32 initial_interval = 0;
8185 /* Parse args required to build the message */
8186 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8188 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8189 sw_if_index_set = 1;
8190 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8191 sw_if_index_set = 1;
8192 else if (unformat (i, "maxint %d", &max_interval))
8194 else if (unformat (i, "minint %d", &min_interval))
8196 else if (unformat (i, "life %d", &lifetime))
8198 else if (unformat (i, "count %d", &initial_count))
8200 else if (unformat (i, "interval %d", &initial_interval))
8202 else if (unformat (i, "suppress") || unformat (i, "surpress"))
8204 else if (unformat (i, "managed"))
8206 else if (unformat (i, "other"))
8208 else if (unformat (i, "ll"))
8210 else if (unformat (i, "send"))
8212 else if (unformat (i, "cease"))
8214 else if (unformat (i, "isno"))
8216 else if (unformat (i, "def"))
8220 clib_warning ("parse error '%U'", format_unformat_error, i);
8225 if (sw_if_index_set == 0)
8227 errmsg ("missing interface name or sw_if_index");
8231 /* Construct the API message */
8232 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
8234 mp->sw_if_index = ntohl (sw_if_index);
8235 mp->max_interval = ntohl (max_interval);
8236 mp->min_interval = ntohl (min_interval);
8237 mp->lifetime = ntohl (lifetime);
8238 mp->initial_count = ntohl (initial_count);
8239 mp->initial_interval = ntohl (initial_interval);
8240 mp->suppress = suppress;
8241 mp->managed = managed;
8243 mp->ll_option = ll_option;
8244 mp->send_unicast = send_unicast;
8247 mp->default_router = default_router;
8252 /* Wait for a reply, return good/bad news */
8258 api_set_arp_neighbor_limit (vat_main_t * vam)
8260 unformat_input_t *i = vam->input;
8261 vl_api_set_arp_neighbor_limit_t *mp;
8267 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8269 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
8271 else if (unformat (i, "ipv6"))
8275 clib_warning ("parse error '%U'", format_unformat_error, i);
8282 errmsg ("missing limit value");
8286 M (SET_ARP_NEIGHBOR_LIMIT, mp);
8288 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
8289 mp->is_ipv6 = is_ipv6;
8297 api_l2_patch_add_del (vat_main_t * vam)
8299 unformat_input_t *i = vam->input;
8300 vl_api_l2_patch_add_del_t *mp;
8302 u8 rx_sw_if_index_set = 0;
8304 u8 tx_sw_if_index_set = 0;
8308 /* Parse args required to build the message */
8309 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8311 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
8312 rx_sw_if_index_set = 1;
8313 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
8314 tx_sw_if_index_set = 1;
8315 else if (unformat (i, "rx"))
8317 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8319 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
8321 rx_sw_if_index_set = 1;
8326 else if (unformat (i, "tx"))
8328 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8330 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
8332 tx_sw_if_index_set = 1;
8337 else if (unformat (i, "del"))
8343 if (rx_sw_if_index_set == 0)
8345 errmsg ("missing rx interface name or rx_sw_if_index");
8349 if (tx_sw_if_index_set == 0)
8351 errmsg ("missing tx interface name or tx_sw_if_index");
8355 M (L2_PATCH_ADD_DEL, mp);
8357 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
8358 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
8359 mp->is_add = is_add;
8367 api_ioam_enable (vat_main_t * vam)
8369 unformat_input_t *input = vam->input;
8370 vl_api_ioam_enable_t *mp;
8372 int has_trace_option = 0;
8373 int has_pot_option = 0;
8374 int has_seqno_option = 0;
8375 int has_analyse_option = 0;
8378 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8380 if (unformat (input, "trace"))
8381 has_trace_option = 1;
8382 else if (unformat (input, "pot"))
8384 else if (unformat (input, "seqno"))
8385 has_seqno_option = 1;
8386 else if (unformat (input, "analyse"))
8387 has_analyse_option = 1;
8391 M (IOAM_ENABLE, mp);
8392 mp->id = htons (id);
8393 mp->seqno = has_seqno_option;
8394 mp->analyse = has_analyse_option;
8395 mp->pot_enable = has_pot_option;
8396 mp->trace_enable = has_trace_option;
8405 api_ioam_disable (vat_main_t * vam)
8407 vl_api_ioam_disable_t *mp;
8410 M (IOAM_DISABLE, mp);
8417 api_sr_tunnel_add_del (vat_main_t * vam)
8419 unformat_input_t *i = vam->input;
8420 vl_api_sr_tunnel_add_del_t *mp;
8423 ip6_address_t src_address;
8424 int src_address_set = 0;
8425 ip6_address_t dst_address;
8427 int dst_address_set = 0;
8429 u32 rx_table_id = 0;
8430 u32 tx_table_id = 0;
8431 ip6_address_t *segments = 0;
8432 ip6_address_t *this_seg;
8433 ip6_address_t *tags = 0;
8434 ip6_address_t *this_tag;
8435 ip6_address_t next_address, tag;
8437 u8 *policy_name = 0;
8440 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8442 if (unformat (i, "del"))
8444 else if (unformat (i, "name %s", &name))
8446 else if (unformat (i, "policy %s", &policy_name))
8448 else if (unformat (i, "rx_fib_id %d", &rx_table_id))
8450 else if (unformat (i, "tx_fib_id %d", &tx_table_id))
8452 else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
8453 src_address_set = 1;
8454 else if (unformat (i, "dst %U/%d",
8455 unformat_ip6_address, &dst_address, &dst_mask_width))
8456 dst_address_set = 1;
8457 else if (unformat (i, "next %U", unformat_ip6_address, &next_address))
8459 vec_add2 (segments, this_seg, 1);
8460 clib_memcpy (this_seg->as_u8, next_address.as_u8,
8461 sizeof (*this_seg));
8463 else if (unformat (i, "tag %U", unformat_ip6_address, &tag))
8465 vec_add2 (tags, this_tag, 1);
8466 clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
8468 else if (unformat (i, "clean"))
8469 flags |= IP6_SR_HEADER_FLAG_CLEANUP;
8470 else if (unformat (i, "protected"))
8471 flags |= IP6_SR_HEADER_FLAG_PROTECTED;
8472 else if (unformat (i, "InPE %d", &pl_index))
8474 if (pl_index <= 0 || pl_index > 4)
8476 pl_index_range_error:
8477 errmsg ("pl index %d out of range", pl_index);
8481 IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE << (3 * (pl_index - 1));
8483 else if (unformat (i, "EgPE %d", &pl_index))
8485 if (pl_index <= 0 || pl_index > 4)
8486 goto pl_index_range_error;
8488 IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE << (3 * (pl_index - 1));
8490 else if (unformat (i, "OrgSrc %d", &pl_index))
8492 if (pl_index <= 0 || pl_index > 4)
8493 goto pl_index_range_error;
8495 IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3 * (pl_index - 1));
8501 if (!src_address_set)
8503 errmsg ("src address required");
8507 if (!dst_address_set)
8509 errmsg ("dst address required");
8515 errmsg ("at least one sr segment required");
8519 M2 (SR_TUNNEL_ADD_DEL, mp,
8520 vec_len (segments) * sizeof (ip6_address_t)
8521 + vec_len (tags) * sizeof (ip6_address_t));
8523 clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
8524 clib_memcpy (mp->dst_address, &dst_address, sizeof (mp->dst_address));
8525 mp->dst_mask_width = dst_mask_width;
8526 mp->flags_net_byte_order = clib_host_to_net_u16 (flags);
8527 mp->n_segments = vec_len (segments);
8528 mp->n_tags = vec_len (tags);
8529 mp->is_add = is_del == 0;
8530 clib_memcpy (mp->segs_and_tags, segments,
8531 vec_len (segments) * sizeof (ip6_address_t));
8532 clib_memcpy (mp->segs_and_tags +
8533 vec_len (segments) * sizeof (ip6_address_t), tags,
8534 vec_len (tags) * sizeof (ip6_address_t));
8536 mp->outer_vrf_id = ntohl (rx_table_id);
8537 mp->inner_vrf_id = ntohl (tx_table_id);
8538 memcpy (mp->name, name, vec_len (name));
8539 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
8541 vec_free (segments);
8550 api_sr_policy_add_del (vat_main_t * vam)
8552 unformat_input_t *input = vam->input;
8553 vl_api_sr_policy_add_del_t *mp;
8556 u8 *tunnel_name = 0;
8557 u8 **tunnel_names = 0;
8562 int tunnel_names_length = 1; // Init to 1 to offset the #tunnel_names counter byte
8563 int tun_name_len = 0; // Different naming convention used as confusing these would be "bad" (TM)
8566 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8568 if (unformat (input, "del"))
8570 else if (unformat (input, "name %s", &name))
8572 else if (unformat (input, "tunnel %s", &tunnel_name))
8576 vec_add1 (tunnel_names, tunnel_name);
8578 - length = #bytes to store in serial vector
8579 - +1 = byte to store that length
8581 tunnel_names_length += (vec_len (tunnel_name) + 1);
8592 errmsg ("policy name required");
8596 if ((!tunnel_set) && (!is_del))
8598 errmsg ("tunnel name required");
8602 M2 (SR_POLICY_ADD_DEL, mp, tunnel_names_length);
8606 mp->is_add = !is_del;
8608 memcpy (mp->name, name, vec_len (name));
8609 // Since mp->tunnel_names is of type u8[0] and not a u8 *, u8 ** needs to be serialized
8610 u8 *serial_orig = 0;
8611 vec_validate (serial_orig, tunnel_names_length);
8612 *serial_orig = vec_len (tunnel_names); // Store the number of tunnels as length in first byte of serialized vector
8613 serial_orig += 1; // Move along one byte to store the length of first tunnel_name
8615 for (j = 0; j < vec_len (tunnel_names); j++)
8617 tun_name_len = vec_len (tunnel_names[j]);
8618 *serial_orig = tun_name_len; // Store length of tunnel name in first byte of Length/Value pair
8619 serial_orig += 1; // Move along one byte to store the actual tunnel name
8620 memcpy (serial_orig, tunnel_names[j], tun_name_len);
8621 serial_orig += tun_name_len; // Advance past the copy
8623 memcpy (mp->tunnel_names, serial_orig - tunnel_names_length, tunnel_names_length); // Regress serial_orig to head then copy fwd
8625 vec_free (tunnel_names);
8626 vec_free (tunnel_name);
8634 api_sr_multicast_map_add_del (vat_main_t * vam)
8636 unformat_input_t *input = vam->input;
8637 vl_api_sr_multicast_map_add_del_t *mp;
8639 ip6_address_t multicast_address;
8640 u8 *policy_name = 0;
8641 int multicast_address_set = 0;
8644 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8646 if (unformat (input, "del"))
8650 (input, "address %U", unformat_ip6_address, &multicast_address))
8651 multicast_address_set = 1;
8652 else if (unformat (input, "sr-policy %s", &policy_name))
8658 if (!is_del && !policy_name)
8660 errmsg ("sr-policy name required");
8665 if (!multicast_address_set)
8667 errmsg ("address required");
8671 M (SR_MULTICAST_MAP_ADD_DEL, mp);
8673 mp->is_add = !is_del;
8674 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
8675 clib_memcpy (mp->multicast_address, &multicast_address,
8676 sizeof (mp->multicast_address));
8679 vec_free (policy_name);
8687 #define foreach_tcp_proto_field \
8691 #define foreach_udp_proto_field \
8695 #define foreach_ip4_proto_field \
8706 unformat_tcp_mask (unformat_input_t * input, va_list * args)
8708 u8 **maskp = va_arg (*args, u8 **);
8710 u8 found_something = 0;
8713 #define _(a) u8 a=0;
8714 foreach_tcp_proto_field;
8717 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8720 #define _(a) else if (unformat (input, #a)) a=1;
8721 foreach_tcp_proto_field
8727 #define _(a) found_something += a;
8728 foreach_tcp_proto_field;
8731 if (found_something == 0)
8734 vec_validate (mask, sizeof (*tcp) - 1);
8736 tcp = (tcp_header_t *) mask;
8738 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
8739 foreach_tcp_proto_field;
8747 unformat_udp_mask (unformat_input_t * input, va_list * args)
8749 u8 **maskp = va_arg (*args, u8 **);
8751 u8 found_something = 0;
8754 #define _(a) u8 a=0;
8755 foreach_udp_proto_field;
8758 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8761 #define _(a) else if (unformat (input, #a)) a=1;
8762 foreach_udp_proto_field
8768 #define _(a) found_something += a;
8769 foreach_udp_proto_field;
8772 if (found_something == 0)
8775 vec_validate (mask, sizeof (*udp) - 1);
8777 udp = (udp_header_t *) mask;
8779 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
8780 foreach_udp_proto_field;
8789 u16 src_port, dst_port;
8793 unformat_l4_mask (unformat_input_t * input, va_list * args)
8795 u8 **maskp = va_arg (*args, u8 **);
8796 u16 src_port = 0, dst_port = 0;
8797 tcpudp_header_t *tcpudp;
8799 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8801 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
8803 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
8805 else if (unformat (input, "src_port"))
8807 else if (unformat (input, "dst_port"))
8813 if (!src_port && !dst_port)
8817 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
8819 tcpudp = (tcpudp_header_t *) mask;
8820 tcpudp->src_port = src_port;
8821 tcpudp->dst_port = dst_port;
8829 unformat_ip4_mask (unformat_input_t * input, va_list * args)
8831 u8 **maskp = va_arg (*args, u8 **);
8833 u8 found_something = 0;
8836 #define _(a) u8 a=0;
8837 foreach_ip4_proto_field;
8843 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8845 if (unformat (input, "version"))
8847 else if (unformat (input, "hdr_length"))
8849 else if (unformat (input, "src"))
8851 else if (unformat (input, "dst"))
8853 else if (unformat (input, "proto"))
8856 #define _(a) else if (unformat (input, #a)) a=1;
8857 foreach_ip4_proto_field
8863 #define _(a) found_something += a;
8864 foreach_ip4_proto_field;
8867 if (found_something == 0)
8870 vec_validate (mask, sizeof (*ip) - 1);
8872 ip = (ip4_header_t *) mask;
8874 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
8875 foreach_ip4_proto_field;
8878 ip->ip_version_and_header_length = 0;
8881 ip->ip_version_and_header_length |= 0xF0;
8884 ip->ip_version_and_header_length |= 0x0F;
8890 #define foreach_ip6_proto_field \
8898 unformat_ip6_mask (unformat_input_t * input, va_list * args)
8900 u8 **maskp = va_arg (*args, u8 **);
8902 u8 found_something = 0;
8904 u32 ip_version_traffic_class_and_flow_label;
8906 #define _(a) u8 a=0;
8907 foreach_ip6_proto_field;
8910 u8 traffic_class = 0;
8913 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8915 if (unformat (input, "version"))
8917 else if (unformat (input, "traffic-class"))
8919 else if (unformat (input, "flow-label"))
8921 else if (unformat (input, "src"))
8923 else if (unformat (input, "dst"))
8925 else if (unformat (input, "proto"))
8928 #define _(a) else if (unformat (input, #a)) a=1;
8929 foreach_ip6_proto_field
8935 #define _(a) found_something += a;
8936 foreach_ip6_proto_field;
8939 if (found_something == 0)
8942 vec_validate (mask, sizeof (*ip) - 1);
8944 ip = (ip6_header_t *) mask;
8946 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
8947 foreach_ip6_proto_field;
8950 ip_version_traffic_class_and_flow_label = 0;
8953 ip_version_traffic_class_and_flow_label |= 0xF0000000;
8956 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
8959 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
8961 ip->ip_version_traffic_class_and_flow_label =
8962 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
8969 unformat_l3_mask (unformat_input_t * input, va_list * args)
8971 u8 **maskp = va_arg (*args, u8 **);
8973 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8975 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
8977 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
8986 unformat_l2_mask (unformat_input_t * input, va_list * args)
8988 u8 **maskp = va_arg (*args, u8 **);
9003 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9005 if (unformat (input, "src"))
9007 else if (unformat (input, "dst"))
9009 else if (unformat (input, "proto"))
9011 else if (unformat (input, "tag1"))
9013 else if (unformat (input, "tag2"))
9015 else if (unformat (input, "ignore-tag1"))
9017 else if (unformat (input, "ignore-tag2"))
9019 else if (unformat (input, "cos1"))
9021 else if (unformat (input, "cos2"))
9023 else if (unformat (input, "dot1q"))
9025 else if (unformat (input, "dot1ad"))
9030 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
9031 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9034 if (tag1 || ignore_tag1 || cos1 || dot1q)
9036 if (tag2 || ignore_tag2 || cos2 || dot1ad)
9039 vec_validate (mask, len - 1);
9042 memset (mask, 0xff, 6);
9045 memset (mask + 6, 0xff, 6);
9049 /* inner vlan tag */
9058 mask[21] = mask[20] = 0xff;
9079 mask[16] = mask[17] = 0xff;
9089 mask[12] = mask[13] = 0xff;
9096 unformat_classify_mask (unformat_input_t * input, va_list * args)
9098 u8 **maskp = va_arg (*args, u8 **);
9099 u32 *skipp = va_arg (*args, u32 *);
9100 u32 *matchp = va_arg (*args, u32 *);
9108 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9110 if (unformat (input, "hex %U", unformat_hex_string, &mask))
9112 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
9114 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
9116 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
9130 if (mask || l2 || l3 || l4)
9134 /* "With a free Ethernet header in every package" */
9136 vec_validate (l2, 13);
9140 vec_append (mask, l3);
9145 vec_append (mask, l4);
9150 /* Scan forward looking for the first significant mask octet */
9151 for (i = 0; i < vec_len (mask); i++)
9155 /* compute (skip, match) params */
9156 *skipp = i / sizeof (u32x4);
9157 vec_delete (mask, *skipp * sizeof (u32x4), 0);
9159 /* Pad mask to an even multiple of the vector size */
9160 while (vec_len (mask) % sizeof (u32x4))
9163 match = vec_len (mask) / sizeof (u32x4);
9165 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
9167 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
9168 if (*tmp || *(tmp + 1))
9173 clib_warning ("BUG: match 0");
9175 _vec_len (mask) = match * sizeof (u32x4);
9186 #define foreach_l2_next \
9188 _(ethernet, ETHERNET_INPUT) \
9193 unformat_l2_next_index (unformat_input_t * input, va_list * args)
9195 u32 *miss_next_indexp = va_arg (*args, u32 *);
9200 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
9204 if (unformat (input, "%d", &tmp))
9213 *miss_next_indexp = next_index;
9217 #define foreach_ip_next \
9223 unformat_ip_next_index (unformat_input_t * input, va_list * args)
9225 u32 *miss_next_indexp = va_arg (*args, u32 *);
9230 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
9234 if (unformat (input, "%d", &tmp))
9243 *miss_next_indexp = next_index;
9247 #define foreach_acl_next \
9251 unformat_acl_next_index (unformat_input_t * input, va_list * args)
9253 u32 *miss_next_indexp = va_arg (*args, u32 *);
9258 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
9262 if (unformat (input, "permit"))
9267 else if (unformat (input, "%d", &tmp))
9276 *miss_next_indexp = next_index;
9281 unformat_policer_precolor (unformat_input_t * input, va_list * args)
9283 u32 *r = va_arg (*args, u32 *);
9285 if (unformat (input, "conform-color"))
9286 *r = POLICE_CONFORM;
9287 else if (unformat (input, "exceed-color"))
9296 api_classify_add_del_table (vat_main_t * vam)
9298 unformat_input_t *i = vam->input;
9299 vl_api_classify_add_del_table_t *mp;
9306 u32 table_index = ~0;
9307 u32 next_table_index = ~0;
9308 u32 miss_next_index = ~0;
9309 u32 memory_size = 32 << 20;
9311 u32 current_data_flag = 0;
9312 int current_data_offset = 0;
9315 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9317 if (unformat (i, "del"))
9319 else if (unformat (i, "del-chain"))
9324 else if (unformat (i, "buckets %d", &nbuckets))
9326 else if (unformat (i, "memory_size %d", &memory_size))
9328 else if (unformat (i, "skip %d", &skip))
9330 else if (unformat (i, "match %d", &match))
9332 else if (unformat (i, "table %d", &table_index))
9334 else if (unformat (i, "mask %U", unformat_classify_mask,
9335 &mask, &skip, &match))
9337 else if (unformat (i, "next-table %d", &next_table_index))
9339 else if (unformat (i, "miss-next %U", unformat_ip_next_index,
9342 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
9345 else if (unformat (i, "acl-miss-next %U", unformat_acl_next_index,
9348 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
9350 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
9356 if (is_add && mask == 0)
9358 errmsg ("Mask required");
9362 if (is_add && skip == ~0)
9364 errmsg ("skip count required");
9368 if (is_add && match == ~0)
9370 errmsg ("match count required");
9374 if (!is_add && table_index == ~0)
9376 errmsg ("table index required for delete");
9380 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
9382 mp->is_add = is_add;
9383 mp->del_chain = del_chain;
9384 mp->table_index = ntohl (table_index);
9385 mp->nbuckets = ntohl (nbuckets);
9386 mp->memory_size = ntohl (memory_size);
9387 mp->skip_n_vectors = ntohl (skip);
9388 mp->match_n_vectors = ntohl (match);
9389 mp->next_table_index = ntohl (next_table_index);
9390 mp->miss_next_index = ntohl (miss_next_index);
9391 mp->current_data_flag = ntohl (current_data_flag);
9392 mp->current_data_offset = ntohl (current_data_offset);
9393 clib_memcpy (mp->mask, mask, vec_len (mask));
9403 unformat_l4_match (unformat_input_t * input, va_list * args)
9405 u8 **matchp = va_arg (*args, u8 **);
9407 u8 *proto_header = 0;
9413 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9415 if (unformat (input, "src_port %d", &src_port))
9417 else if (unformat (input, "dst_port %d", &dst_port))
9423 h.src_port = clib_host_to_net_u16 (src_port);
9424 h.dst_port = clib_host_to_net_u16 (dst_port);
9425 vec_validate (proto_header, sizeof (h) - 1);
9426 memcpy (proto_header, &h, sizeof (h));
9428 *matchp = proto_header;
9434 unformat_ip4_match (unformat_input_t * input, va_list * args)
9436 u8 **matchp = va_arg (*args, u8 **);
9443 int src = 0, dst = 0;
9444 ip4_address_t src_val, dst_val;
9451 int fragment_id = 0;
9452 u32 fragment_id_val;
9458 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9460 if (unformat (input, "version %d", &version_val))
9462 else if (unformat (input, "hdr_length %d", &hdr_length_val))
9464 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
9466 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
9468 else if (unformat (input, "proto %d", &proto_val))
9470 else if (unformat (input, "tos %d", &tos_val))
9472 else if (unformat (input, "length %d", &length_val))
9474 else if (unformat (input, "fragment_id %d", &fragment_id_val))
9476 else if (unformat (input, "ttl %d", &ttl_val))
9478 else if (unformat (input, "checksum %d", &checksum_val))
9484 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
9485 + ttl + checksum == 0)
9489 * Aligned because we use the real comparison functions
9491 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
9493 ip = (ip4_header_t *) match;
9495 /* These are realistically matched in practice */
9497 ip->src_address.as_u32 = src_val.as_u32;
9500 ip->dst_address.as_u32 = dst_val.as_u32;
9503 ip->protocol = proto_val;
9506 /* These are not, but they're included for completeness */
9508 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
9511 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
9517 ip->length = clib_host_to_net_u16 (length_val);
9523 ip->checksum = clib_host_to_net_u16 (checksum_val);
9530 unformat_ip6_match (unformat_input_t * input, va_list * args)
9532 u8 **matchp = va_arg (*args, u8 **);
9537 u8 traffic_class = 0;
9538 u32 traffic_class_val = 0;
9541 int src = 0, dst = 0;
9542 ip6_address_t src_val, dst_val;
9545 int payload_length = 0;
9546 u32 payload_length_val;
9549 u32 ip_version_traffic_class_and_flow_label;
9551 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9553 if (unformat (input, "version %d", &version_val))
9555 else if (unformat (input, "traffic_class %d", &traffic_class_val))
9557 else if (unformat (input, "flow_label %d", &flow_label_val))
9559 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
9561 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
9563 else if (unformat (input, "proto %d", &proto_val))
9565 else if (unformat (input, "payload_length %d", &payload_length_val))
9567 else if (unformat (input, "hop_limit %d", &hop_limit_val))
9573 if (version + traffic_class + flow_label + src + dst + proto +
9574 payload_length + hop_limit == 0)
9578 * Aligned because we use the real comparison functions
9580 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
9582 ip = (ip6_header_t *) match;
9585 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
9588 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
9591 ip->protocol = proto_val;
9593 ip_version_traffic_class_and_flow_label = 0;
9596 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
9599 ip_version_traffic_class_and_flow_label |=
9600 (traffic_class_val & 0xFF) << 20;
9603 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
9605 ip->ip_version_traffic_class_and_flow_label =
9606 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9609 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
9612 ip->hop_limit = hop_limit_val;
9619 unformat_l3_match (unformat_input_t * input, va_list * args)
9621 u8 **matchp = va_arg (*args, u8 **);
9623 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9625 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
9627 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
9636 unformat_vlan_tag (unformat_input_t * input, va_list * args)
9638 u8 *tagp = va_arg (*args, u8 *);
9641 if (unformat (input, "%d", &tag))
9643 tagp[0] = (tag >> 8) & 0x0F;
9644 tagp[1] = tag & 0xFF;
9652 unformat_l2_match (unformat_input_t * input, va_list * args)
9654 u8 **matchp = va_arg (*args, u8 **);
9674 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9676 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
9679 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
9681 else if (unformat (input, "proto %U",
9682 unformat_ethernet_type_host_byte_order, &proto_val))
9684 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
9686 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
9688 else if (unformat (input, "ignore-tag1"))
9690 else if (unformat (input, "ignore-tag2"))
9692 else if (unformat (input, "cos1 %d", &cos1_val))
9694 else if (unformat (input, "cos2 %d", &cos2_val))
9699 if ((src + dst + proto + tag1 + tag2 +
9700 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9703 if (tag1 || ignore_tag1 || cos1)
9705 if (tag2 || ignore_tag2 || cos2)
9708 vec_validate_aligned (match, len - 1, sizeof (u32x4));
9711 clib_memcpy (match, dst_val, 6);
9714 clib_memcpy (match + 6, src_val, 6);
9718 /* inner vlan tag */
9719 match[19] = tag2_val[1];
9720 match[18] = tag2_val[0];
9722 match[18] |= (cos2_val & 0x7) << 5;
9725 match[21] = proto_val & 0xff;
9726 match[20] = proto_val >> 8;
9730 match[15] = tag1_val[1];
9731 match[14] = tag1_val[0];
9734 match[14] |= (cos1_val & 0x7) << 5;
9740 match[15] = tag1_val[1];
9741 match[14] = tag1_val[0];
9744 match[17] = proto_val & 0xff;
9745 match[16] = proto_val >> 8;
9748 match[14] |= (cos1_val & 0x7) << 5;
9754 match[18] |= (cos2_val & 0x7) << 5;
9756 match[14] |= (cos1_val & 0x7) << 5;
9759 match[13] = proto_val & 0xff;
9760 match[12] = proto_val >> 8;
9769 unformat_classify_match (unformat_input_t * input, va_list * args)
9771 u8 **matchp = va_arg (*args, u8 **);
9772 u32 skip_n_vectors = va_arg (*args, u32);
9773 u32 match_n_vectors = va_arg (*args, u32);
9780 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9782 if (unformat (input, "hex %U", unformat_hex_string, &match))
9784 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
9786 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
9788 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
9802 if (match || l2 || l3 || l4)
9806 /* "Win a free Ethernet header in every packet" */
9808 vec_validate_aligned (l2, 13, sizeof (u32x4));
9812 vec_append_aligned (match, l3, sizeof (u32x4));
9817 vec_append_aligned (match, l4, sizeof (u32x4));
9822 /* Make sure the vector is big enough even if key is all 0's */
9823 vec_validate_aligned
9824 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
9827 /* Set size, include skipped vectors */
9828 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
9839 api_classify_add_del_session (vat_main_t * vam)
9841 unformat_input_t *i = vam->input;
9842 vl_api_classify_add_del_session_t *mp;
9844 u32 table_index = ~0;
9845 u32 hit_next_index = ~0;
9846 u32 opaque_index = ~0;
9849 u32 skip_n_vectors = 0;
9850 u32 match_n_vectors = 0;
9856 * Warning: you have to supply skip_n and match_n
9857 * because the API client cant simply look at the classify
9861 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9863 if (unformat (i, "del"))
9865 else if (unformat (i, "hit-next %U", unformat_ip_next_index,
9868 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
9871 else if (unformat (i, "acl-hit-next %U", unformat_acl_next_index,
9874 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
9876 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
9878 else if (unformat (i, "opaque-index %d", &opaque_index))
9880 else if (unformat (i, "skip_n %d", &skip_n_vectors))
9882 else if (unformat (i, "match_n %d", &match_n_vectors))
9884 else if (unformat (i, "match %U", unformat_classify_match,
9885 &match, skip_n_vectors, match_n_vectors))
9887 else if (unformat (i, "advance %d", &advance))
9889 else if (unformat (i, "table-index %d", &table_index))
9891 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
9893 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
9895 else if (unformat (i, "action %d", &action))
9897 else if (unformat (i, "metadata %d", &metadata))
9903 if (table_index == ~0)
9905 errmsg ("Table index required");
9909 if (is_add && match == 0)
9911 errmsg ("Match value required");
9915 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
9917 mp->is_add = is_add;
9918 mp->table_index = ntohl (table_index);
9919 mp->hit_next_index = ntohl (hit_next_index);
9920 mp->opaque_index = ntohl (opaque_index);
9921 mp->advance = ntohl (advance);
9922 mp->action = action;
9923 mp->metadata = ntohl (metadata);
9924 clib_memcpy (mp->match, match, vec_len (match));
9933 api_classify_set_interface_ip_table (vat_main_t * vam)
9935 unformat_input_t *i = vam->input;
9936 vl_api_classify_set_interface_ip_table_t *mp;
9938 int sw_if_index_set;
9939 u32 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, "table %d", &table_index))
9953 clib_warning ("parse error '%U'", format_unformat_error, i);
9958 if (sw_if_index_set == 0)
9960 errmsg ("missing interface name or sw_if_index");
9965 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
9967 mp->sw_if_index = ntohl (sw_if_index);
9968 mp->table_index = ntohl (table_index);
9969 mp->is_ipv6 = is_ipv6;
9977 api_classify_set_interface_l2_tables (vat_main_t * vam)
9979 unformat_input_t *i = vam->input;
9980 vl_api_classify_set_interface_l2_tables_t *mp;
9982 int sw_if_index_set;
9983 u32 ip4_table_index = ~0;
9984 u32 ip6_table_index = ~0;
9985 u32 other_table_index = ~0;
9989 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9991 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9992 sw_if_index_set = 1;
9993 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9994 sw_if_index_set = 1;
9995 else if (unformat (i, "ip4-table %d", &ip4_table_index))
9997 else if (unformat (i, "ip6-table %d", &ip6_table_index))
9999 else if (unformat (i, "other-table %d", &other_table_index))
10001 else if (unformat (i, "is-input %d", &is_input))
10005 clib_warning ("parse error '%U'", format_unformat_error, i);
10010 if (sw_if_index_set == 0)
10012 errmsg ("missing interface name or sw_if_index");
10017 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
10019 mp->sw_if_index = ntohl (sw_if_index);
10020 mp->ip4_table_index = ntohl (ip4_table_index);
10021 mp->ip6_table_index = ntohl (ip6_table_index);
10022 mp->other_table_index = ntohl (other_table_index);
10023 mp->is_input = (u8) is_input;
10031 api_set_ipfix_exporter (vat_main_t * vam)
10033 unformat_input_t *i = vam->input;
10034 vl_api_set_ipfix_exporter_t *mp;
10035 ip4_address_t collector_address;
10036 u8 collector_address_set = 0;
10037 u32 collector_port = ~0;
10038 ip4_address_t src_address;
10039 u8 src_address_set = 0;
10042 u32 template_interval = ~0;
10043 u8 udp_checksum = 0;
10046 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10048 if (unformat (i, "collector_address %U", unformat_ip4_address,
10049 &collector_address))
10050 collector_address_set = 1;
10051 else if (unformat (i, "collector_port %d", &collector_port))
10053 else if (unformat (i, "src_address %U", unformat_ip4_address,
10055 src_address_set = 1;
10056 else if (unformat (i, "vrf_id %d", &vrf_id))
10058 else if (unformat (i, "path_mtu %d", &path_mtu))
10060 else if (unformat (i, "template_interval %d", &template_interval))
10062 else if (unformat (i, "udp_checksum"))
10068 if (collector_address_set == 0)
10070 errmsg ("collector_address required");
10074 if (src_address_set == 0)
10076 errmsg ("src_address required");
10080 M (SET_IPFIX_EXPORTER, mp);
10082 memcpy (mp->collector_address, collector_address.data,
10083 sizeof (collector_address.data));
10084 mp->collector_port = htons ((u16) collector_port);
10085 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
10086 mp->vrf_id = htonl (vrf_id);
10087 mp->path_mtu = htonl (path_mtu);
10088 mp->template_interval = htonl (template_interval);
10089 mp->udp_checksum = udp_checksum;
10097 api_set_ipfix_classify_stream (vat_main_t * vam)
10099 unformat_input_t *i = vam->input;
10100 vl_api_set_ipfix_classify_stream_t *mp;
10102 u32 src_port = UDP_DST_PORT_ipfix;
10105 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10107 if (unformat (i, "domain %d", &domain_id))
10109 else if (unformat (i, "src_port %d", &src_port))
10113 errmsg ("unknown input `%U'", format_unformat_error, i);
10118 M (SET_IPFIX_CLASSIFY_STREAM, mp);
10120 mp->domain_id = htonl (domain_id);
10121 mp->src_port = htons ((u16) src_port);
10129 api_ipfix_classify_table_add_del (vat_main_t * vam)
10131 unformat_input_t *i = vam->input;
10132 vl_api_ipfix_classify_table_add_del_t *mp;
10134 u32 classify_table_index = ~0;
10136 u8 transport_protocol = 255;
10139 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10141 if (unformat (i, "add"))
10143 else if (unformat (i, "del"))
10145 else if (unformat (i, "table %d", &classify_table_index))
10147 else if (unformat (i, "ip4"))
10149 else if (unformat (i, "ip6"))
10151 else if (unformat (i, "tcp"))
10152 transport_protocol = 6;
10153 else if (unformat (i, "udp"))
10154 transport_protocol = 17;
10157 errmsg ("unknown input `%U'", format_unformat_error, i);
10164 errmsg ("expecting: add|del");
10167 if (classify_table_index == ~0)
10169 errmsg ("classifier table not specified");
10172 if (ip_version == 0)
10174 errmsg ("IP version not specified");
10178 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
10180 mp->is_add = is_add;
10181 mp->table_id = htonl (classify_table_index);
10182 mp->ip_version = ip_version;
10183 mp->transport_protocol = transport_protocol;
10191 api_get_node_index (vat_main_t * vam)
10193 unformat_input_t *i = vam->input;
10194 vl_api_get_node_index_t *mp;
10198 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10200 if (unformat (i, "node %s", &name))
10207 errmsg ("node name required");
10210 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10212 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10216 M (GET_NODE_INDEX, mp);
10217 clib_memcpy (mp->node_name, name, vec_len (name));
10226 api_get_next_index (vat_main_t * vam)
10228 unformat_input_t *i = vam->input;
10229 vl_api_get_next_index_t *mp;
10230 u8 *node_name = 0, *next_node_name = 0;
10233 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10235 if (unformat (i, "node-name %s", &node_name))
10237 else if (unformat (i, "next-node-name %s", &next_node_name))
10241 if (node_name == 0)
10243 errmsg ("node name required");
10246 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
10248 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10252 if (next_node_name == 0)
10254 errmsg ("next node name required");
10257 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
10259 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
10263 M (GET_NEXT_INDEX, mp);
10264 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
10265 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
10266 vec_free (node_name);
10267 vec_free (next_node_name);
10275 api_add_node_next (vat_main_t * vam)
10277 unformat_input_t *i = vam->input;
10278 vl_api_add_node_next_t *mp;
10283 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10285 if (unformat (i, "node %s", &name))
10287 else if (unformat (i, "next %s", &next))
10294 errmsg ("node name required");
10297 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10299 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10304 errmsg ("next node required");
10307 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
10309 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
10313 M (ADD_NODE_NEXT, mp);
10314 clib_memcpy (mp->node_name, name, vec_len (name));
10315 clib_memcpy (mp->next_name, next, vec_len (next));
10325 api_l2tpv3_create_tunnel (vat_main_t * vam)
10327 unformat_input_t *i = vam->input;
10328 ip6_address_t client_address, our_address;
10329 int client_address_set = 0;
10330 int our_address_set = 0;
10331 u32 local_session_id = 0;
10332 u32 remote_session_id = 0;
10333 u64 local_cookie = 0;
10334 u64 remote_cookie = 0;
10335 u8 l2_sublayer_present = 0;
10336 vl_api_l2tpv3_create_tunnel_t *mp;
10339 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10341 if (unformat (i, "client_address %U", unformat_ip6_address,
10343 client_address_set = 1;
10344 else if (unformat (i, "our_address %U", unformat_ip6_address,
10346 our_address_set = 1;
10347 else if (unformat (i, "local_session_id %d", &local_session_id))
10349 else if (unformat (i, "remote_session_id %d", &remote_session_id))
10351 else if (unformat (i, "local_cookie %lld", &local_cookie))
10353 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
10355 else if (unformat (i, "l2-sublayer-present"))
10356 l2_sublayer_present = 1;
10361 if (client_address_set == 0)
10363 errmsg ("client_address required");
10367 if (our_address_set == 0)
10369 errmsg ("our_address required");
10373 M (L2TPV3_CREATE_TUNNEL, mp);
10375 clib_memcpy (mp->client_address, client_address.as_u8,
10376 sizeof (mp->client_address));
10378 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
10380 mp->local_session_id = ntohl (local_session_id);
10381 mp->remote_session_id = ntohl (remote_session_id);
10382 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
10383 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
10384 mp->l2_sublayer_present = l2_sublayer_present;
10393 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
10395 unformat_input_t *i = vam->input;
10397 u8 sw_if_index_set = 0;
10398 u64 new_local_cookie = 0;
10399 u64 new_remote_cookie = 0;
10400 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
10403 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10405 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10406 sw_if_index_set = 1;
10407 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10408 sw_if_index_set = 1;
10409 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
10411 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
10417 if (sw_if_index_set == 0)
10419 errmsg ("missing interface name or sw_if_index");
10423 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
10425 mp->sw_if_index = ntohl (sw_if_index);
10426 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
10427 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
10435 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
10437 unformat_input_t *i = vam->input;
10438 vl_api_l2tpv3_interface_enable_disable_t *mp;
10440 u8 sw_if_index_set = 0;
10441 u8 enable_disable = 1;
10444 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10446 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10447 sw_if_index_set = 1;
10448 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10449 sw_if_index_set = 1;
10450 else if (unformat (i, "enable"))
10451 enable_disable = 1;
10452 else if (unformat (i, "disable"))
10453 enable_disable = 0;
10458 if (sw_if_index_set == 0)
10460 errmsg ("missing interface name or sw_if_index");
10464 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
10466 mp->sw_if_index = ntohl (sw_if_index);
10467 mp->enable_disable = enable_disable;
10475 api_l2tpv3_set_lookup_key (vat_main_t * vam)
10477 unformat_input_t *i = vam->input;
10478 vl_api_l2tpv3_set_lookup_key_t *mp;
10482 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10484 if (unformat (i, "lookup_v6_src"))
10485 key = L2T_LOOKUP_SRC_ADDRESS;
10486 else if (unformat (i, "lookup_v6_dst"))
10487 key = L2T_LOOKUP_DST_ADDRESS;
10488 else if (unformat (i, "lookup_session_id"))
10489 key = L2T_LOOKUP_SESSION_ID;
10494 if (key == (u8) ~ 0)
10496 errmsg ("l2tp session lookup key unset");
10500 M (L2TPV3_SET_LOOKUP_KEY, mp);
10509 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
10510 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
10512 vat_main_t *vam = &vat_main;
10514 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
10515 format_ip6_address, mp->our_address,
10516 format_ip6_address, mp->client_address,
10517 clib_net_to_host_u32 (mp->sw_if_index));
10520 " local cookies %016llx %016llx remote cookie %016llx",
10521 clib_net_to_host_u64 (mp->local_cookie[0]),
10522 clib_net_to_host_u64 (mp->local_cookie[1]),
10523 clib_net_to_host_u64 (mp->remote_cookie));
10525 print (vam->ofp, " local session-id %d remote session-id %d",
10526 clib_net_to_host_u32 (mp->local_session_id),
10527 clib_net_to_host_u32 (mp->remote_session_id));
10529 print (vam->ofp, " l2 specific sublayer %s\n",
10530 mp->l2_sublayer_present ? "preset" : "absent");
10534 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
10535 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
10537 vat_main_t *vam = &vat_main;
10538 vat_json_node_t *node = NULL;
10539 struct in6_addr addr;
10541 if (VAT_JSON_ARRAY != vam->json_tree.type)
10543 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10544 vat_json_init_array (&vam->json_tree);
10546 node = vat_json_array_add (&vam->json_tree);
10548 vat_json_init_object (node);
10550 clib_memcpy (&addr, mp->our_address, sizeof (addr));
10551 vat_json_object_add_ip6 (node, "our_address", addr);
10552 clib_memcpy (&addr, mp->client_address, sizeof (addr));
10553 vat_json_object_add_ip6 (node, "client_address", addr);
10555 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
10556 vat_json_init_array (lc);
10557 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
10558 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
10559 vat_json_object_add_uint (node, "remote_cookie",
10560 clib_net_to_host_u64 (mp->remote_cookie));
10562 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
10563 vat_json_object_add_uint (node, "local_session_id",
10564 clib_net_to_host_u32 (mp->local_session_id));
10565 vat_json_object_add_uint (node, "remote_session_id",
10566 clib_net_to_host_u32 (mp->remote_session_id));
10567 vat_json_object_add_string_copy (node, "l2_sublayer",
10568 mp->l2_sublayer_present ? (u8 *) "present"
10569 : (u8 *) "absent");
10573 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
10575 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
10576 vl_api_control_ping_t *mp_ping;
10579 /* Get list of l2tpv3-tunnel interfaces */
10580 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
10583 /* Use a control ping for synchronization */
10584 M (CONTROL_PING, mp_ping);
10592 static void vl_api_sw_interface_tap_details_t_handler
10593 (vl_api_sw_interface_tap_details_t * mp)
10595 vat_main_t *vam = &vat_main;
10597 print (vam->ofp, "%-16s %d",
10598 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
10601 static void vl_api_sw_interface_tap_details_t_handler_json
10602 (vl_api_sw_interface_tap_details_t * mp)
10604 vat_main_t *vam = &vat_main;
10605 vat_json_node_t *node = NULL;
10607 if (VAT_JSON_ARRAY != vam->json_tree.type)
10609 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10610 vat_json_init_array (&vam->json_tree);
10612 node = vat_json_array_add (&vam->json_tree);
10614 vat_json_init_object (node);
10615 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10616 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
10620 api_sw_interface_tap_dump (vat_main_t * vam)
10622 vl_api_sw_interface_tap_dump_t *mp;
10623 vl_api_control_ping_t *mp_ping;
10626 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
10627 /* Get list of tap interfaces */
10628 M (SW_INTERFACE_TAP_DUMP, mp);
10631 /* Use a control ping for synchronization */
10632 M (CONTROL_PING, mp_ping);
10639 static uword unformat_vxlan_decap_next
10640 (unformat_input_t * input, va_list * args)
10642 u32 *result = va_arg (*args, u32 *);
10645 if (unformat (input, "l2"))
10646 *result = VXLAN_INPUT_NEXT_L2_INPUT;
10647 else if (unformat (input, "%d", &tmp))
10655 api_vxlan_add_del_tunnel (vat_main_t * vam)
10657 unformat_input_t *line_input = vam->input;
10658 vl_api_vxlan_add_del_tunnel_t *mp;
10659 ip46_address_t src, dst;
10661 u8 ipv4_set = 0, ipv6_set = 0;
10665 u32 mcast_sw_if_index = ~0;
10666 u32 encap_vrf_id = 0;
10667 u32 decap_next_index = ~0;
10671 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
10672 memset (&src, 0, sizeof src);
10673 memset (&dst, 0, sizeof dst);
10675 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10677 if (unformat (line_input, "del"))
10680 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
10686 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
10692 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
10698 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
10703 else if (unformat (line_input, "group %U %U",
10704 unformat_ip4_address, &dst.ip4,
10705 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
10707 grp_set = dst_set = 1;
10710 else if (unformat (line_input, "group %U",
10711 unformat_ip4_address, &dst.ip4))
10713 grp_set = dst_set = 1;
10716 else if (unformat (line_input, "group %U %U",
10717 unformat_ip6_address, &dst.ip6,
10718 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
10720 grp_set = dst_set = 1;
10723 else if (unformat (line_input, "group %U",
10724 unformat_ip6_address, &dst.ip6))
10726 grp_set = dst_set = 1;
10730 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
10732 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
10734 else if (unformat (line_input, "decap-next %U",
10735 unformat_vxlan_decap_next, &decap_next_index))
10737 else if (unformat (line_input, "vni %d", &vni))
10741 errmsg ("parse error '%U'", format_unformat_error, line_input);
10748 errmsg ("tunnel src address not specified");
10753 errmsg ("tunnel dst address not specified");
10757 if (grp_set && !ip46_address_is_multicast (&dst))
10759 errmsg ("tunnel group address not multicast");
10762 if (grp_set && mcast_sw_if_index == ~0)
10764 errmsg ("tunnel nonexistent multicast device");
10767 if (grp_set == 0 && ip46_address_is_multicast (&dst))
10769 errmsg ("tunnel dst address must be unicast");
10774 if (ipv4_set && ipv6_set)
10776 errmsg ("both IPv4 and IPv6 addresses specified");
10780 if ((vni == 0) || (vni >> 24))
10782 errmsg ("vni not specified or out of range");
10786 M (VXLAN_ADD_DEL_TUNNEL, mp);
10790 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
10791 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
10795 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
10796 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
10798 mp->encap_vrf_id = ntohl (encap_vrf_id);
10799 mp->decap_next_index = ntohl (decap_next_index);
10800 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
10801 mp->vni = ntohl (vni);
10802 mp->is_add = is_add;
10803 mp->is_ipv6 = ipv6_set;
10810 static void vl_api_vxlan_tunnel_details_t_handler
10811 (vl_api_vxlan_tunnel_details_t * mp)
10813 vat_main_t *vam = &vat_main;
10814 ip46_address_t src, dst;
10816 ip46_from_addr_buf (mp->is_ipv6, mp->src_address, &src);
10817 ip46_from_addr_buf (mp->is_ipv6, mp->dst_address, &dst);
10819 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
10820 ntohl (mp->sw_if_index),
10821 format_ip46_address, &src, IP46_TYPE_ANY,
10822 format_ip46_address, &dst, IP46_TYPE_ANY,
10823 ntohl (mp->encap_vrf_id),
10824 ntohl (mp->decap_next_index), ntohl (mp->vni),
10825 ntohl (mp->mcast_sw_if_index));
10828 static void vl_api_vxlan_tunnel_details_t_handler_json
10829 (vl_api_vxlan_tunnel_details_t * mp)
10831 vat_main_t *vam = &vat_main;
10832 vat_json_node_t *node = NULL;
10834 if (VAT_JSON_ARRAY != vam->json_tree.type)
10836 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10837 vat_json_init_array (&vam->json_tree);
10839 node = vat_json_array_add (&vam->json_tree);
10841 vat_json_init_object (node);
10842 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10845 struct in6_addr ip6;
10847 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
10848 vat_json_object_add_ip6 (node, "src_address", ip6);
10849 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
10850 vat_json_object_add_ip6 (node, "dst_address", ip6);
10854 struct in_addr ip4;
10856 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
10857 vat_json_object_add_ip4 (node, "src_address", ip4);
10858 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
10859 vat_json_object_add_ip4 (node, "dst_address", ip4);
10861 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
10862 vat_json_object_add_uint (node, "decap_next_index",
10863 ntohl (mp->decap_next_index));
10864 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
10865 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
10866 vat_json_object_add_uint (node, "mcast_sw_if_index",
10867 ntohl (mp->mcast_sw_if_index));
10871 api_vxlan_tunnel_dump (vat_main_t * vam)
10873 unformat_input_t *i = vam->input;
10874 vl_api_vxlan_tunnel_dump_t *mp;
10875 vl_api_control_ping_t *mp_ping;
10877 u8 sw_if_index_set = 0;
10880 /* Parse args required to build the message */
10881 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10883 if (unformat (i, "sw_if_index %d", &sw_if_index))
10884 sw_if_index_set = 1;
10889 if (sw_if_index_set == 0)
10894 if (!vam->json_output)
10896 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
10897 "sw_if_index", "src_address", "dst_address",
10898 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
10901 /* Get list of vxlan-tunnel interfaces */
10902 M (VXLAN_TUNNEL_DUMP, mp);
10904 mp->sw_if_index = htonl (sw_if_index);
10908 /* Use a control ping for synchronization */
10909 M (CONTROL_PING, mp_ping);
10917 api_gre_add_del_tunnel (vat_main_t * vam)
10919 unformat_input_t *line_input = vam->input;
10920 vl_api_gre_add_del_tunnel_t *mp;
10921 ip4_address_t src4, dst4;
10926 u32 outer_fib_id = 0;
10929 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10931 if (unformat (line_input, "del"))
10933 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
10935 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
10937 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
10939 else if (unformat (line_input, "teb"))
10943 errmsg ("parse error '%U'", format_unformat_error, line_input);
10950 errmsg ("tunnel src address not specified");
10955 errmsg ("tunnel dst address not specified");
10960 M (GRE_ADD_DEL_TUNNEL, mp);
10962 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
10963 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
10964 mp->outer_fib_id = ntohl (outer_fib_id);
10965 mp->is_add = is_add;
10973 static void vl_api_gre_tunnel_details_t_handler
10974 (vl_api_gre_tunnel_details_t * mp)
10976 vat_main_t *vam = &vat_main;
10978 print (vam->ofp, "%11d%15U%15U%6d%14d",
10979 ntohl (mp->sw_if_index),
10980 format_ip4_address, &mp->src_address,
10981 format_ip4_address, &mp->dst_address,
10982 mp->teb, ntohl (mp->outer_fib_id));
10985 static void vl_api_gre_tunnel_details_t_handler_json
10986 (vl_api_gre_tunnel_details_t * mp)
10988 vat_main_t *vam = &vat_main;
10989 vat_json_node_t *node = NULL;
10990 struct in_addr ip4;
10992 if (VAT_JSON_ARRAY != vam->json_tree.type)
10994 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10995 vat_json_init_array (&vam->json_tree);
10997 node = vat_json_array_add (&vam->json_tree);
10999 vat_json_init_object (node);
11000 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11001 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
11002 vat_json_object_add_ip4 (node, "src_address", ip4);
11003 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
11004 vat_json_object_add_ip4 (node, "dst_address", ip4);
11005 vat_json_object_add_uint (node, "teb", mp->teb);
11006 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
11010 api_gre_tunnel_dump (vat_main_t * vam)
11012 unformat_input_t *i = vam->input;
11013 vl_api_gre_tunnel_dump_t *mp;
11014 vl_api_control_ping_t *mp_ping;
11016 u8 sw_if_index_set = 0;
11019 /* Parse args required to build the message */
11020 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11022 if (unformat (i, "sw_if_index %d", &sw_if_index))
11023 sw_if_index_set = 1;
11028 if (sw_if_index_set == 0)
11033 if (!vam->json_output)
11035 print (vam->ofp, "%11s%15s%15s%6s%14s",
11036 "sw_if_index", "src_address", "dst_address", "teb",
11040 /* Get list of gre-tunnel interfaces */
11041 M (GRE_TUNNEL_DUMP, mp);
11043 mp->sw_if_index = htonl (sw_if_index);
11047 /* Use a control ping for synchronization */
11048 M (CONTROL_PING, mp_ping);
11056 api_l2_fib_clear_table (vat_main_t * vam)
11058 // unformat_input_t * i = vam->input;
11059 vl_api_l2_fib_clear_table_t *mp;
11062 M (L2_FIB_CLEAR_TABLE, mp);
11070 api_l2_interface_efp_filter (vat_main_t * vam)
11072 unformat_input_t *i = vam->input;
11073 vl_api_l2_interface_efp_filter_t *mp;
11076 u8 sw_if_index_set = 0;
11079 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11081 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11082 sw_if_index_set = 1;
11083 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11084 sw_if_index_set = 1;
11085 else if (unformat (i, "enable"))
11087 else if (unformat (i, "disable"))
11091 clib_warning ("parse error '%U'", format_unformat_error, i);
11096 if (sw_if_index_set == 0)
11098 errmsg ("missing sw_if_index");
11102 M (L2_INTERFACE_EFP_FILTER, mp);
11104 mp->sw_if_index = ntohl (sw_if_index);
11105 mp->enable_disable = enable;
11112 #define foreach_vtr_op \
11113 _("disable", L2_VTR_DISABLED) \
11114 _("push-1", L2_VTR_PUSH_1) \
11115 _("push-2", L2_VTR_PUSH_2) \
11116 _("pop-1", L2_VTR_POP_1) \
11117 _("pop-2", L2_VTR_POP_2) \
11118 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
11119 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
11120 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
11121 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
11124 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
11126 unformat_input_t *i = vam->input;
11127 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
11129 u8 sw_if_index_set = 0;
11132 u32 push_dot1q = 1;
11137 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11139 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11140 sw_if_index_set = 1;
11141 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11142 sw_if_index_set = 1;
11143 else if (unformat (i, "vtr_op %d", &vtr_op))
11145 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
11148 else if (unformat (i, "push_dot1q %d", &push_dot1q))
11150 else if (unformat (i, "tag1 %d", &tag1))
11152 else if (unformat (i, "tag2 %d", &tag2))
11156 clib_warning ("parse error '%U'", format_unformat_error, i);
11161 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
11163 errmsg ("missing vtr operation or sw_if_index");
11167 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
11168 mp->sw_if_index = ntohl (sw_if_index);
11169 mp->vtr_op = ntohl (vtr_op);
11170 mp->push_dot1q = ntohl (push_dot1q);
11171 mp->tag1 = ntohl (tag1);
11172 mp->tag2 = ntohl (tag2);
11180 api_create_vhost_user_if (vat_main_t * vam)
11182 unformat_input_t *i = vam->input;
11183 vl_api_create_vhost_user_if_t *mp;
11186 u8 file_name_set = 0;
11187 u32 custom_dev_instance = ~0;
11189 u8 use_custom_mac = 0;
11193 /* Shut up coverity */
11194 memset (hwaddr, 0, sizeof (hwaddr));
11196 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11198 if (unformat (i, "socket %s", &file_name))
11202 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
11204 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
11205 use_custom_mac = 1;
11206 else if (unformat (i, "server"))
11208 else if (unformat (i, "tag %s", &tag))
11214 if (file_name_set == 0)
11216 errmsg ("missing socket file name");
11220 if (vec_len (file_name) > 255)
11222 errmsg ("socket file name too long");
11225 vec_add1 (file_name, 0);
11227 M (CREATE_VHOST_USER_IF, mp);
11229 mp->is_server = is_server;
11230 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
11231 vec_free (file_name);
11232 if (custom_dev_instance != ~0)
11235 mp->custom_dev_instance = ntohl (custom_dev_instance);
11237 mp->use_custom_mac = use_custom_mac;
11238 clib_memcpy (mp->mac_address, hwaddr, 6);
11240 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
11249 api_modify_vhost_user_if (vat_main_t * vam)
11251 unformat_input_t *i = vam->input;
11252 vl_api_modify_vhost_user_if_t *mp;
11255 u8 file_name_set = 0;
11256 u32 custom_dev_instance = ~0;
11257 u8 sw_if_index_set = 0;
11258 u32 sw_if_index = (u32) ~ 0;
11261 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11263 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11264 sw_if_index_set = 1;
11265 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11266 sw_if_index_set = 1;
11267 else if (unformat (i, "socket %s", &file_name))
11271 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
11273 else if (unformat (i, "server"))
11279 if (sw_if_index_set == 0)
11281 errmsg ("missing sw_if_index or interface name");
11285 if (file_name_set == 0)
11287 errmsg ("missing socket file name");
11291 if (vec_len (file_name) > 255)
11293 errmsg ("socket file name too long");
11296 vec_add1 (file_name, 0);
11298 M (MODIFY_VHOST_USER_IF, mp);
11300 mp->sw_if_index = ntohl (sw_if_index);
11301 mp->is_server = is_server;
11302 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
11303 vec_free (file_name);
11304 if (custom_dev_instance != ~0)
11307 mp->custom_dev_instance = ntohl (custom_dev_instance);
11316 api_delete_vhost_user_if (vat_main_t * vam)
11318 unformat_input_t *i = vam->input;
11319 vl_api_delete_vhost_user_if_t *mp;
11320 u32 sw_if_index = ~0;
11321 u8 sw_if_index_set = 0;
11324 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11326 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11327 sw_if_index_set = 1;
11328 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11329 sw_if_index_set = 1;
11334 if (sw_if_index_set == 0)
11336 errmsg ("missing sw_if_index or interface name");
11341 M (DELETE_VHOST_USER_IF, mp);
11343 mp->sw_if_index = ntohl (sw_if_index);
11350 static void vl_api_sw_interface_vhost_user_details_t_handler
11351 (vl_api_sw_interface_vhost_user_details_t * mp)
11353 vat_main_t *vam = &vat_main;
11355 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
11356 (char *) mp->interface_name,
11357 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
11358 clib_net_to_host_u64 (mp->features), mp->is_server,
11359 ntohl (mp->num_regions), (char *) mp->sock_filename);
11360 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
11363 static void vl_api_sw_interface_vhost_user_details_t_handler_json
11364 (vl_api_sw_interface_vhost_user_details_t * mp)
11366 vat_main_t *vam = &vat_main;
11367 vat_json_node_t *node = NULL;
11369 if (VAT_JSON_ARRAY != vam->json_tree.type)
11371 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11372 vat_json_init_array (&vam->json_tree);
11374 node = vat_json_array_add (&vam->json_tree);
11376 vat_json_init_object (node);
11377 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11378 vat_json_object_add_string_copy (node, "interface_name",
11379 mp->interface_name);
11380 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
11381 ntohl (mp->virtio_net_hdr_sz));
11382 vat_json_object_add_uint (node, "features",
11383 clib_net_to_host_u64 (mp->features));
11384 vat_json_object_add_uint (node, "is_server", mp->is_server);
11385 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
11386 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
11387 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
11391 api_sw_interface_vhost_user_dump (vat_main_t * vam)
11393 vl_api_sw_interface_vhost_user_dump_t *mp;
11394 vl_api_control_ping_t *mp_ping;
11397 "Interface name idx hdr_sz features server regions filename");
11399 /* Get list of vhost-user interfaces */
11400 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
11403 /* Use a control ping for synchronization */
11404 M (CONTROL_PING, mp_ping);
11412 api_show_version (vat_main_t * vam)
11414 vl_api_show_version_t *mp;
11417 M (SHOW_VERSION, mp);
11426 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
11428 unformat_input_t *line_input = vam->input;
11429 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
11430 ip4_address_t local4, remote4;
11431 ip6_address_t local6, remote6;
11433 u8 ipv4_set = 0, ipv6_set = 0;
11436 u32 encap_vrf_id = 0;
11437 u32 decap_vrf_id = 0;
11443 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11445 if (unformat (line_input, "del"))
11447 else if (unformat (line_input, "local %U",
11448 unformat_ip4_address, &local4))
11453 else if (unformat (line_input, "remote %U",
11454 unformat_ip4_address, &remote4))
11459 else if (unformat (line_input, "local %U",
11460 unformat_ip6_address, &local6))
11465 else if (unformat (line_input, "remote %U",
11466 unformat_ip6_address, &remote6))
11471 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11473 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
11475 else if (unformat (line_input, "vni %d", &vni))
11477 else if (unformat (line_input, "next-ip4"))
11479 else if (unformat (line_input, "next-ip6"))
11481 else if (unformat (line_input, "next-ethernet"))
11483 else if (unformat (line_input, "next-nsh"))
11487 errmsg ("parse error '%U'", format_unformat_error, line_input);
11492 if (local_set == 0)
11494 errmsg ("tunnel local address not specified");
11497 if (remote_set == 0)
11499 errmsg ("tunnel remote address not specified");
11502 if (ipv4_set && ipv6_set)
11504 errmsg ("both IPv4 and IPv6 addresses specified");
11510 errmsg ("vni not specified");
11514 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
11519 clib_memcpy (&mp->local, &local6, sizeof (local6));
11520 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
11524 clib_memcpy (&mp->local, &local4, sizeof (local4));
11525 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
11528 mp->encap_vrf_id = ntohl (encap_vrf_id);
11529 mp->decap_vrf_id = ntohl (decap_vrf_id);
11530 mp->protocol = protocol;
11531 mp->vni = ntohl (vni);
11532 mp->is_add = is_add;
11533 mp->is_ipv6 = ipv6_set;
11540 static void vl_api_vxlan_gpe_tunnel_details_t_handler
11541 (vl_api_vxlan_gpe_tunnel_details_t * mp)
11543 vat_main_t *vam = &vat_main;
11545 print (vam->ofp, "%11d%24U%24U%13d%12d%14d%14d",
11546 ntohl (mp->sw_if_index),
11547 format_ip46_address, &(mp->local[0]),
11548 format_ip46_address, &(mp->remote[0]),
11550 ntohl (mp->protocol),
11551 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
11554 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
11555 (vl_api_vxlan_gpe_tunnel_details_t * mp)
11557 vat_main_t *vam = &vat_main;
11558 vat_json_node_t *node = NULL;
11559 struct in_addr ip4;
11560 struct in6_addr ip6;
11562 if (VAT_JSON_ARRAY != vam->json_tree.type)
11564 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11565 vat_json_init_array (&vam->json_tree);
11567 node = vat_json_array_add (&vam->json_tree);
11569 vat_json_init_object (node);
11570 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11573 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
11574 vat_json_object_add_ip6 (node, "local", ip6);
11575 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
11576 vat_json_object_add_ip6 (node, "remote", ip6);
11580 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
11581 vat_json_object_add_ip4 (node, "local", ip4);
11582 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
11583 vat_json_object_add_ip4 (node, "remote", ip4);
11585 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
11586 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
11587 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
11588 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
11589 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
11593 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
11595 unformat_input_t *i = vam->input;
11596 vl_api_vxlan_gpe_tunnel_dump_t *mp;
11597 vl_api_control_ping_t *mp_ping;
11599 u8 sw_if_index_set = 0;
11602 /* Parse args required to build the message */
11603 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11605 if (unformat (i, "sw_if_index %d", &sw_if_index))
11606 sw_if_index_set = 1;
11611 if (sw_if_index_set == 0)
11616 if (!vam->json_output)
11618 print (vam->ofp, "%11s%24s%24s%13s%15s%14s%14s",
11619 "sw_if_index", "local", "remote", "vni",
11620 "protocol", "encap_vrf_id", "decap_vrf_id");
11623 /* Get list of vxlan-tunnel interfaces */
11624 M (VXLAN_GPE_TUNNEL_DUMP, mp);
11626 mp->sw_if_index = htonl (sw_if_index);
11630 /* Use a control ping for synchronization */
11631 M (CONTROL_PING, mp_ping);
11639 format_l2_fib_mac_address (u8 * s, va_list * args)
11641 u8 *a = va_arg (*args, u8 *);
11643 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
11644 a[2], a[3], a[4], a[5], a[6], a[7]);
11647 static void vl_api_l2_fib_table_entry_t_handler
11648 (vl_api_l2_fib_table_entry_t * mp)
11650 vat_main_t *vam = &vat_main;
11652 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
11654 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
11655 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
11659 static void vl_api_l2_fib_table_entry_t_handler_json
11660 (vl_api_l2_fib_table_entry_t * mp)
11662 vat_main_t *vam = &vat_main;
11663 vat_json_node_t *node = NULL;
11665 if (VAT_JSON_ARRAY != vam->json_tree.type)
11667 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11668 vat_json_init_array (&vam->json_tree);
11670 node = vat_json_array_add (&vam->json_tree);
11672 vat_json_init_object (node);
11673 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
11674 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
11675 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11676 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
11677 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
11678 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
11682 api_l2_fib_table_dump (vat_main_t * vam)
11684 unformat_input_t *i = vam->input;
11685 vl_api_l2_fib_table_dump_t *mp;
11686 vl_api_control_ping_t *mp_ping;
11691 /* Parse args required to build the message */
11692 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11694 if (unformat (i, "bd_id %d", &bd_id))
11700 if (bd_id_set == 0)
11702 errmsg ("missing bridge domain");
11706 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
11708 /* Get list of l2 fib entries */
11709 M (L2_FIB_TABLE_DUMP, mp);
11711 mp->bd_id = ntohl (bd_id);
11714 /* Use a control ping for synchronization */
11715 M (CONTROL_PING, mp_ping);
11724 api_interface_name_renumber (vat_main_t * vam)
11726 unformat_input_t *line_input = vam->input;
11727 vl_api_interface_name_renumber_t *mp;
11728 u32 sw_if_index = ~0;
11729 u32 new_show_dev_instance = ~0;
11732 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11734 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
11737 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11739 else if (unformat (line_input, "new_show_dev_instance %d",
11740 &new_show_dev_instance))
11746 if (sw_if_index == ~0)
11748 errmsg ("missing interface name or sw_if_index");
11752 if (new_show_dev_instance == ~0)
11754 errmsg ("missing new_show_dev_instance");
11758 M (INTERFACE_NAME_RENUMBER, mp);
11760 mp->sw_if_index = ntohl (sw_if_index);
11761 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
11769 api_want_ip4_arp_events (vat_main_t * vam)
11771 unformat_input_t *line_input = vam->input;
11772 vl_api_want_ip4_arp_events_t *mp;
11773 ip4_address_t address;
11774 int address_set = 0;
11775 u32 enable_disable = 1;
11778 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11780 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
11782 else if (unformat (line_input, "del"))
11783 enable_disable = 0;
11788 if (address_set == 0)
11790 errmsg ("missing addresses");
11794 M (WANT_IP4_ARP_EVENTS, mp);
11795 mp->enable_disable = enable_disable;
11796 mp->pid = getpid ();
11797 mp->address = address.as_u32;
11805 api_want_ip6_nd_events (vat_main_t * vam)
11807 unformat_input_t *line_input = vam->input;
11808 vl_api_want_ip6_nd_events_t *mp;
11809 ip6_address_t address;
11810 int address_set = 0;
11811 u32 enable_disable = 1;
11814 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11816 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
11818 else if (unformat (line_input, "del"))
11819 enable_disable = 0;
11824 if (address_set == 0)
11826 errmsg ("missing addresses");
11830 M (WANT_IP6_ND_EVENTS, mp);
11831 mp->enable_disable = enable_disable;
11832 mp->pid = getpid ();
11833 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
11841 api_input_acl_set_interface (vat_main_t * vam)
11843 unformat_input_t *i = vam->input;
11844 vl_api_input_acl_set_interface_t *mp;
11846 int sw_if_index_set;
11847 u32 ip4_table_index = ~0;
11848 u32 ip6_table_index = ~0;
11849 u32 l2_table_index = ~0;
11853 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11855 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11856 sw_if_index_set = 1;
11857 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11858 sw_if_index_set = 1;
11859 else if (unformat (i, "del"))
11861 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11863 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11865 else if (unformat (i, "l2-table %d", &l2_table_index))
11869 clib_warning ("parse error '%U'", format_unformat_error, i);
11874 if (sw_if_index_set == 0)
11876 errmsg ("missing interface name or sw_if_index");
11880 M (INPUT_ACL_SET_INTERFACE, mp);
11882 mp->sw_if_index = ntohl (sw_if_index);
11883 mp->ip4_table_index = ntohl (ip4_table_index);
11884 mp->ip6_table_index = ntohl (ip6_table_index);
11885 mp->l2_table_index = ntohl (l2_table_index);
11886 mp->is_add = is_add;
11894 api_ip_address_dump (vat_main_t * vam)
11896 unformat_input_t *i = vam->input;
11897 vl_api_ip_address_dump_t *mp;
11898 vl_api_control_ping_t *mp_ping;
11899 u32 sw_if_index = ~0;
11900 u8 sw_if_index_set = 0;
11905 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11907 if (unformat (i, "sw_if_index %d", &sw_if_index))
11908 sw_if_index_set = 1;
11910 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11911 sw_if_index_set = 1;
11912 else if (unformat (i, "ipv4"))
11914 else if (unformat (i, "ipv6"))
11920 if (ipv4_set && ipv6_set)
11922 errmsg ("ipv4 and ipv6 flags cannot be both set");
11926 if ((!ipv4_set) && (!ipv6_set))
11928 errmsg ("no ipv4 nor ipv6 flag set");
11932 if (sw_if_index_set == 0)
11934 errmsg ("missing interface name or sw_if_index");
11938 vam->current_sw_if_index = sw_if_index;
11939 vam->is_ipv6 = ipv6_set;
11941 M (IP_ADDRESS_DUMP, mp);
11942 mp->sw_if_index = ntohl (sw_if_index);
11943 mp->is_ipv6 = ipv6_set;
11946 /* Use a control ping for synchronization */
11947 M (CONTROL_PING, mp_ping);
11955 api_ip_dump (vat_main_t * vam)
11957 vl_api_ip_dump_t *mp;
11958 vl_api_control_ping_t *mp_ping;
11959 unformat_input_t *in = vam->input;
11966 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
11968 if (unformat (in, "ipv4"))
11970 else if (unformat (in, "ipv6"))
11976 if (ipv4_set && ipv6_set)
11978 errmsg ("ipv4 and ipv6 flags cannot be both set");
11982 if ((!ipv4_set) && (!ipv6_set))
11984 errmsg ("no ipv4 nor ipv6 flag set");
11988 is_ipv6 = ipv6_set;
11989 vam->is_ipv6 = is_ipv6;
11991 /* free old data */
11992 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
11994 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
11996 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
11999 mp->is_ipv6 = ipv6_set;
12002 /* Use a control ping for synchronization */
12003 M (CONTROL_PING, mp_ping);
12011 api_ipsec_spd_add_del (vat_main_t * vam)
12013 unformat_input_t *i = vam->input;
12014 vl_api_ipsec_spd_add_del_t *mp;
12019 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12021 if (unformat (i, "spd_id %d", &spd_id))
12023 else if (unformat (i, "del"))
12027 clib_warning ("parse error '%U'", format_unformat_error, i);
12033 errmsg ("spd_id must be set");
12037 M (IPSEC_SPD_ADD_DEL, mp);
12039 mp->spd_id = ntohl (spd_id);
12040 mp->is_add = is_add;
12048 api_ipsec_interface_add_del_spd (vat_main_t * vam)
12050 unformat_input_t *i = vam->input;
12051 vl_api_ipsec_interface_add_del_spd_t *mp;
12053 u8 sw_if_index_set = 0;
12054 u32 spd_id = (u32) ~ 0;
12058 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12060 if (unformat (i, "del"))
12062 else if (unformat (i, "spd_id %d", &spd_id))
12065 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12066 sw_if_index_set = 1;
12067 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12068 sw_if_index_set = 1;
12071 clib_warning ("parse error '%U'", format_unformat_error, i);
12077 if (spd_id == (u32) ~ 0)
12079 errmsg ("spd_id must be set");
12083 if (sw_if_index_set == 0)
12085 errmsg ("missing interface name or sw_if_index");
12089 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
12091 mp->spd_id = ntohl (spd_id);
12092 mp->sw_if_index = ntohl (sw_if_index);
12093 mp->is_add = is_add;
12101 api_ipsec_spd_add_del_entry (vat_main_t * vam)
12103 unformat_input_t *i = vam->input;
12104 vl_api_ipsec_spd_add_del_entry_t *mp;
12105 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
12106 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
12108 u32 rport_start = 0, rport_stop = (u32) ~ 0;
12109 u32 lport_start = 0, lport_stop = (u32) ~ 0;
12110 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
12111 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
12114 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
12115 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
12116 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
12117 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
12118 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
12119 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
12121 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12123 if (unformat (i, "del"))
12125 if (unformat (i, "outbound"))
12127 if (unformat (i, "inbound"))
12129 else if (unformat (i, "spd_id %d", &spd_id))
12131 else if (unformat (i, "sa_id %d", &sa_id))
12133 else if (unformat (i, "priority %d", &priority))
12135 else if (unformat (i, "protocol %d", &protocol))
12137 else if (unformat (i, "lport_start %d", &lport_start))
12139 else if (unformat (i, "lport_stop %d", &lport_stop))
12141 else if (unformat (i, "rport_start %d", &rport_start))
12143 else if (unformat (i, "rport_stop %d", &rport_stop))
12147 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
12153 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
12160 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
12166 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
12173 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
12179 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
12186 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
12192 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
12198 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
12200 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
12202 clib_warning ("unsupported action: 'resolve'");
12208 clib_warning ("parse error '%U'", format_unformat_error, i);
12214 M (IPSEC_SPD_ADD_DEL_ENTRY, mp);
12216 mp->spd_id = ntohl (spd_id);
12217 mp->priority = ntohl (priority);
12218 mp->is_outbound = is_outbound;
12220 mp->is_ipv6 = is_ipv6;
12221 if (is_ipv6 || is_ip_any)
12223 clib_memcpy (mp->remote_address_start, &raddr6_start,
12224 sizeof (ip6_address_t));
12225 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
12226 sizeof (ip6_address_t));
12227 clib_memcpy (mp->local_address_start, &laddr6_start,
12228 sizeof (ip6_address_t));
12229 clib_memcpy (mp->local_address_stop, &laddr6_stop,
12230 sizeof (ip6_address_t));
12234 clib_memcpy (mp->remote_address_start, &raddr4_start,
12235 sizeof (ip4_address_t));
12236 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
12237 sizeof (ip4_address_t));
12238 clib_memcpy (mp->local_address_start, &laddr4_start,
12239 sizeof (ip4_address_t));
12240 clib_memcpy (mp->local_address_stop, &laddr4_stop,
12241 sizeof (ip4_address_t));
12243 mp->protocol = (u8) protocol;
12244 mp->local_port_start = ntohs ((u16) lport_start);
12245 mp->local_port_stop = ntohs ((u16) lport_stop);
12246 mp->remote_port_start = ntohs ((u16) rport_start);
12247 mp->remote_port_stop = ntohs ((u16) rport_stop);
12248 mp->policy = (u8) policy;
12249 mp->sa_id = ntohl (sa_id);
12250 mp->is_add = is_add;
12251 mp->is_ip_any = is_ip_any;
12258 api_ipsec_sad_add_del_entry (vat_main_t * vam)
12260 unformat_input_t *i = vam->input;
12261 vl_api_ipsec_sad_add_del_entry_t *mp;
12262 u32 sad_id = 0, spi = 0;
12263 u8 *ck = 0, *ik = 0;
12266 u8 protocol = IPSEC_PROTOCOL_AH;
12267 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
12268 u32 crypto_alg = 0, integ_alg = 0;
12269 ip4_address_t tun_src4;
12270 ip4_address_t tun_dst4;
12271 ip6_address_t tun_src6;
12272 ip6_address_t tun_dst6;
12275 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12277 if (unformat (i, "del"))
12279 else if (unformat (i, "sad_id %d", &sad_id))
12281 else if (unformat (i, "spi %d", &spi))
12283 else if (unformat (i, "esp"))
12284 protocol = IPSEC_PROTOCOL_ESP;
12285 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
12288 is_tunnel_ipv6 = 0;
12290 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
12293 is_tunnel_ipv6 = 0;
12295 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
12298 is_tunnel_ipv6 = 1;
12300 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
12303 is_tunnel_ipv6 = 1;
12307 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
12309 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
12310 crypto_alg >= IPSEC_CRYPTO_N_ALG)
12312 clib_warning ("unsupported crypto-alg: '%U'",
12313 format_ipsec_crypto_alg, crypto_alg);
12317 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
12321 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
12323 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
12324 integ_alg >= IPSEC_INTEG_N_ALG)
12326 clib_warning ("unsupported integ-alg: '%U'",
12327 format_ipsec_integ_alg, integ_alg);
12331 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
12335 clib_warning ("parse error '%U'", format_unformat_error, i);
12341 M (IPSEC_SAD_ADD_DEL_ENTRY, mp);
12343 mp->sad_id = ntohl (sad_id);
12344 mp->is_add = is_add;
12345 mp->protocol = protocol;
12346 mp->spi = ntohl (spi);
12347 mp->is_tunnel = is_tunnel;
12348 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
12349 mp->crypto_algorithm = crypto_alg;
12350 mp->integrity_algorithm = integ_alg;
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);
12367 if (is_tunnel_ipv6)
12369 clib_memcpy (mp->tunnel_src_address, &tun_src6,
12370 sizeof (ip6_address_t));
12371 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
12372 sizeof (ip6_address_t));
12376 clib_memcpy (mp->tunnel_src_address, &tun_src4,
12377 sizeof (ip4_address_t));
12378 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
12379 sizeof (ip4_address_t));
12389 api_ipsec_sa_set_key (vat_main_t * vam)
12391 unformat_input_t *i = vam->input;
12392 vl_api_ipsec_sa_set_key_t *mp;
12394 u8 *ck = 0, *ik = 0;
12397 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12399 if (unformat (i, "sa_id %d", &sa_id))
12401 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
12403 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
12407 clib_warning ("parse error '%U'", format_unformat_error, i);
12412 M (IPSEC_SA_SET_KEY, mp);
12414 mp->sa_id = ntohl (sa_id);
12415 mp->crypto_key_length = vec_len (ck);
12416 mp->integrity_key_length = vec_len (ik);
12418 if (mp->crypto_key_length > sizeof (mp->crypto_key))
12419 mp->crypto_key_length = sizeof (mp->crypto_key);
12421 if (mp->integrity_key_length > sizeof (mp->integrity_key))
12422 mp->integrity_key_length = sizeof (mp->integrity_key);
12425 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
12427 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
12435 api_ikev2_profile_add_del (vat_main_t * vam)
12437 unformat_input_t *i = vam->input;
12438 vl_api_ikev2_profile_add_del_t *mp;
12443 const char *valid_chars = "a-zA-Z0-9_";
12445 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12447 if (unformat (i, "del"))
12449 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12450 vec_add1 (name, 0);
12453 errmsg ("parse error '%U'", format_unformat_error, i);
12458 if (!vec_len (name))
12460 errmsg ("profile name must be specified");
12464 if (vec_len (name) > 64)
12466 errmsg ("profile name too long");
12470 M (IKEV2_PROFILE_ADD_DEL, mp);
12472 clib_memcpy (mp->name, name, vec_len (name));
12473 mp->is_add = is_add;
12482 api_ikev2_profile_set_auth (vat_main_t * vam)
12484 unformat_input_t *i = vam->input;
12485 vl_api_ikev2_profile_set_auth_t *mp;
12488 u32 auth_method = 0;
12492 const char *valid_chars = "a-zA-Z0-9_";
12494 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12496 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12497 vec_add1 (name, 0);
12498 else if (unformat (i, "auth_method %U",
12499 unformat_ikev2_auth_method, &auth_method))
12501 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
12503 else if (unformat (i, "auth_data %v", &data))
12507 errmsg ("parse error '%U'", format_unformat_error, i);
12512 if (!vec_len (name))
12514 errmsg ("profile name must be specified");
12518 if (vec_len (name) > 64)
12520 errmsg ("profile name too long");
12524 if (!vec_len (data))
12526 errmsg ("auth_data must be specified");
12532 errmsg ("auth_method must be specified");
12536 M (IKEV2_PROFILE_SET_AUTH, mp);
12538 mp->is_hex = is_hex;
12539 mp->auth_method = (u8) auth_method;
12540 mp->data_len = vec_len (data);
12541 clib_memcpy (mp->name, name, vec_len (name));
12542 clib_memcpy (mp->data, data, vec_len (data));
12552 api_ikev2_profile_set_id (vat_main_t * vam)
12554 unformat_input_t *i = vam->input;
12555 vl_api_ikev2_profile_set_id_t *mp;
12563 const char *valid_chars = "a-zA-Z0-9_";
12565 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12567 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12568 vec_add1 (name, 0);
12569 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
12571 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
12573 data = vec_new (u8, 4);
12574 clib_memcpy (data, ip4.as_u8, 4);
12576 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
12578 else if (unformat (i, "id_data %v", &data))
12580 else if (unformat (i, "local"))
12582 else if (unformat (i, "remote"))
12586 errmsg ("parse error '%U'", format_unformat_error, i);
12591 if (!vec_len (name))
12593 errmsg ("profile name must be specified");
12597 if (vec_len (name) > 64)
12599 errmsg ("profile name too long");
12603 if (!vec_len (data))
12605 errmsg ("id_data must be specified");
12611 errmsg ("id_type must be specified");
12615 M (IKEV2_PROFILE_SET_ID, mp);
12617 mp->is_local = is_local;
12618 mp->id_type = (u8) id_type;
12619 mp->data_len = vec_len (data);
12620 clib_memcpy (mp->name, name, vec_len (name));
12621 clib_memcpy (mp->data, data, vec_len (data));
12631 api_ikev2_profile_set_ts (vat_main_t * vam)
12633 unformat_input_t *i = vam->input;
12634 vl_api_ikev2_profile_set_ts_t *mp;
12637 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
12638 ip4_address_t start_addr, end_addr;
12640 const char *valid_chars = "a-zA-Z0-9_";
12643 start_addr.as_u32 = 0;
12644 end_addr.as_u32 = (u32) ~ 0;
12646 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12648 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12649 vec_add1 (name, 0);
12650 else if (unformat (i, "protocol %d", &proto))
12652 else if (unformat (i, "start_port %d", &start_port))
12654 else if (unformat (i, "end_port %d", &end_port))
12657 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
12659 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
12661 else if (unformat (i, "local"))
12663 else if (unformat (i, "remote"))
12667 errmsg ("parse error '%U'", format_unformat_error, i);
12672 if (!vec_len (name))
12674 errmsg ("profile name must be specified");
12678 if (vec_len (name) > 64)
12680 errmsg ("profile name too long");
12684 M (IKEV2_PROFILE_SET_TS, mp);
12686 mp->is_local = is_local;
12687 mp->proto = (u8) proto;
12688 mp->start_port = (u16) start_port;
12689 mp->end_port = (u16) end_port;
12690 mp->start_addr = start_addr.as_u32;
12691 mp->end_addr = end_addr.as_u32;
12692 clib_memcpy (mp->name, name, vec_len (name));
12701 api_ikev2_set_local_key (vat_main_t * vam)
12703 unformat_input_t *i = vam->input;
12704 vl_api_ikev2_set_local_key_t *mp;
12708 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12710 if (unformat (i, "file %v", &file))
12711 vec_add1 (file, 0);
12714 errmsg ("parse error '%U'", format_unformat_error, i);
12719 if (!vec_len (file))
12721 errmsg ("RSA key file must be specified");
12725 if (vec_len (file) > 256)
12727 errmsg ("file name too long");
12731 M (IKEV2_SET_LOCAL_KEY, mp);
12733 clib_memcpy (mp->key_file, file, vec_len (file));
12745 api_map_add_domain (vat_main_t * vam)
12747 unformat_input_t *i = vam->input;
12748 vl_api_map_add_domain_t *mp;
12750 ip4_address_t ip4_prefix;
12751 ip6_address_t ip6_prefix;
12752 ip6_address_t ip6_src;
12753 u32 num_m_args = 0;
12754 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
12755 0, psid_length = 0;
12756 u8 is_translation = 0;
12758 u32 ip6_src_len = 128;
12761 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12763 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
12764 &ip4_prefix, &ip4_prefix_len))
12766 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
12767 &ip6_prefix, &ip6_prefix_len))
12771 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
12774 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
12776 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
12778 else if (unformat (i, "psid-offset %d", &psid_offset))
12780 else if (unformat (i, "psid-len %d", &psid_length))
12782 else if (unformat (i, "mtu %d", &mtu))
12784 else if (unformat (i, "map-t"))
12785 is_translation = 1;
12788 clib_warning ("parse error '%U'", format_unformat_error, i);
12793 if (num_m_args < 3)
12795 errmsg ("mandatory argument(s) missing");
12799 /* Construct the API message */
12800 M (MAP_ADD_DOMAIN, mp);
12802 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
12803 mp->ip4_prefix_len = ip4_prefix_len;
12805 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
12806 mp->ip6_prefix_len = ip6_prefix_len;
12808 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
12809 mp->ip6_src_prefix_len = ip6_src_len;
12811 mp->ea_bits_len = ea_bits_len;
12812 mp->psid_offset = psid_offset;
12813 mp->psid_length = psid_length;
12814 mp->is_translation = is_translation;
12815 mp->mtu = htons (mtu);
12820 /* Wait for a reply, return good/bad news */
12826 api_map_del_domain (vat_main_t * vam)
12828 unformat_input_t *i = vam->input;
12829 vl_api_map_del_domain_t *mp;
12831 u32 num_m_args = 0;
12835 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12837 if (unformat (i, "index %d", &index))
12841 clib_warning ("parse error '%U'", format_unformat_error, i);
12846 if (num_m_args != 1)
12848 errmsg ("mandatory argument(s) missing");
12852 /* Construct the API message */
12853 M (MAP_DEL_DOMAIN, mp);
12855 mp->index = ntohl (index);
12860 /* Wait for a reply, return good/bad news */
12866 api_map_add_del_rule (vat_main_t * vam)
12868 unformat_input_t *i = vam->input;
12869 vl_api_map_add_del_rule_t *mp;
12871 ip6_address_t ip6_dst;
12872 u32 num_m_args = 0, index, psid = 0;
12875 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12877 if (unformat (i, "index %d", &index))
12879 else if (unformat (i, "psid %d", &psid))
12881 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
12883 else if (unformat (i, "del"))
12889 clib_warning ("parse error '%U'", format_unformat_error, i);
12894 /* Construct the API message */
12895 M (MAP_ADD_DEL_RULE, mp);
12897 mp->index = ntohl (index);
12898 mp->is_add = is_add;
12899 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
12900 mp->psid = ntohs (psid);
12905 /* Wait for a reply, return good/bad news */
12911 api_map_domain_dump (vat_main_t * vam)
12913 vl_api_map_domain_dump_t *mp;
12914 vl_api_control_ping_t *mp_ping;
12917 /* Construct the API message */
12918 M (MAP_DOMAIN_DUMP, mp);
12923 /* Use a control ping for synchronization */
12924 M (CONTROL_PING, mp_ping);
12932 api_map_rule_dump (vat_main_t * vam)
12934 unformat_input_t *i = vam->input;
12935 vl_api_map_rule_dump_t *mp;
12936 vl_api_control_ping_t *mp_ping;
12937 u32 domain_index = ~0;
12940 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12942 if (unformat (i, "index %u", &domain_index))
12948 if (domain_index == ~0)
12950 clib_warning ("parse error: domain index expected");
12954 /* Construct the API message */
12955 M (MAP_RULE_DUMP, mp);
12957 mp->domain_index = htonl (domain_index);
12962 /* Use a control ping for synchronization */
12963 M (CONTROL_PING, mp_ping);
12970 static void vl_api_map_add_domain_reply_t_handler
12971 (vl_api_map_add_domain_reply_t * mp)
12973 vat_main_t *vam = &vat_main;
12974 i32 retval = ntohl (mp->retval);
12976 if (vam->async_mode)
12978 vam->async_errors += (retval < 0);
12982 vam->retval = retval;
12983 vam->result_ready = 1;
12987 static void vl_api_map_add_domain_reply_t_handler_json
12988 (vl_api_map_add_domain_reply_t * mp)
12990 vat_main_t *vam = &vat_main;
12991 vat_json_node_t node;
12993 vat_json_init_object (&node);
12994 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
12995 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
12997 vat_json_print (vam->ofp, &node);
12998 vat_json_free (&node);
13000 vam->retval = ntohl (mp->retval);
13001 vam->result_ready = 1;
13005 api_get_first_msg_id (vat_main_t * vam)
13007 vl_api_get_first_msg_id_t *mp;
13008 unformat_input_t *i = vam->input;
13013 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13015 if (unformat (i, "client %s", &name))
13023 errmsg ("missing client name");
13026 vec_add1 (name, 0);
13028 if (vec_len (name) > 63)
13030 errmsg ("client name too long");
13034 M (GET_FIRST_MSG_ID, mp);
13035 clib_memcpy (mp->name, name, vec_len (name));
13042 api_cop_interface_enable_disable (vat_main_t * vam)
13044 unformat_input_t *line_input = vam->input;
13045 vl_api_cop_interface_enable_disable_t *mp;
13046 u32 sw_if_index = ~0;
13047 u8 enable_disable = 1;
13050 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13052 if (unformat (line_input, "disable"))
13053 enable_disable = 0;
13054 if (unformat (line_input, "enable"))
13055 enable_disable = 1;
13056 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
13057 vam, &sw_if_index))
13059 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13065 if (sw_if_index == ~0)
13067 errmsg ("missing interface name or sw_if_index");
13071 /* Construct the API message */
13072 M (COP_INTERFACE_ENABLE_DISABLE, mp);
13073 mp->sw_if_index = ntohl (sw_if_index);
13074 mp->enable_disable = enable_disable;
13078 /* Wait for the reply */
13084 api_cop_whitelist_enable_disable (vat_main_t * vam)
13086 unformat_input_t *line_input = vam->input;
13087 vl_api_cop_whitelist_enable_disable_t *mp;
13088 u32 sw_if_index = ~0;
13089 u8 ip4 = 0, ip6 = 0, default_cop = 0;
13093 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13095 if (unformat (line_input, "ip4"))
13097 else if (unformat (line_input, "ip6"))
13099 else if (unformat (line_input, "default"))
13101 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
13102 vam, &sw_if_index))
13104 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13106 else if (unformat (line_input, "fib-id %d", &fib_id))
13112 if (sw_if_index == ~0)
13114 errmsg ("missing interface name or sw_if_index");
13118 /* Construct the API message */
13119 M (COP_WHITELIST_ENABLE_DISABLE, mp);
13120 mp->sw_if_index = ntohl (sw_if_index);
13121 mp->fib_id = ntohl (fib_id);
13124 mp->default_cop = default_cop;
13128 /* Wait for the reply */
13134 api_get_node_graph (vat_main_t * vam)
13136 vl_api_get_node_graph_t *mp;
13139 M (GET_NODE_GRAPH, mp);
13143 /* Wait for the reply */
13149 /** Used for parsing LISP eids */
13150 typedef CLIB_PACKED(struct{
13151 u8 addr[16]; /**< eid address */
13152 u32 len; /**< prefix length if IP */
13153 u8 type; /**< type of eid */
13158 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
13160 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
13162 memset (a, 0, sizeof (a[0]));
13164 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
13166 a->type = 0; /* ipv4 type */
13168 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
13170 a->type = 1; /* ipv6 type */
13172 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
13174 a->type = 2; /* mac type */
13181 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
13190 lisp_eid_size_vat (u8 type)
13205 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
13207 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
13211 api_lisp_add_del_locator_set (vat_main_t * vam)
13213 unformat_input_t *input = vam->input;
13214 vl_api_lisp_add_del_locator_set_t *mp;
13216 u8 *locator_set_name = NULL;
13217 u8 locator_set_name_set = 0;
13218 vl_api_local_locator_t locator, *locators = 0;
13219 u32 sw_if_index, priority, weight;
13223 /* Parse args required to build the message */
13224 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13226 if (unformat (input, "del"))
13230 else if (unformat (input, "locator-set %s", &locator_set_name))
13232 locator_set_name_set = 1;
13234 else if (unformat (input, "sw_if_index %u p %u w %u",
13235 &sw_if_index, &priority, &weight))
13237 locator.sw_if_index = htonl (sw_if_index);
13238 locator.priority = priority;
13239 locator.weight = weight;
13240 vec_add1 (locators, locator);
13244 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
13245 &sw_if_index, &priority, &weight))
13247 locator.sw_if_index = htonl (sw_if_index);
13248 locator.priority = priority;
13249 locator.weight = weight;
13250 vec_add1 (locators, locator);
13256 if (locator_set_name_set == 0)
13258 errmsg ("missing locator-set name");
13259 vec_free (locators);
13263 if (vec_len (locator_set_name) > 64)
13265 errmsg ("locator-set name too long");
13266 vec_free (locator_set_name);
13267 vec_free (locators);
13270 vec_add1 (locator_set_name, 0);
13272 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
13274 /* Construct the API message */
13275 M2 (LISP_ADD_DEL_LOCATOR_SET, mp, data_len);
13277 mp->is_add = is_add;
13278 clib_memcpy (mp->locator_set_name, locator_set_name,
13279 vec_len (locator_set_name));
13280 vec_free (locator_set_name);
13282 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
13284 clib_memcpy (mp->locators, locators, data_len);
13285 vec_free (locators);
13290 /* Wait for a reply... */
13296 api_lisp_add_del_locator (vat_main_t * vam)
13298 unformat_input_t *input = vam->input;
13299 vl_api_lisp_add_del_locator_t *mp;
13300 u32 tmp_if_index = ~0;
13301 u32 sw_if_index = ~0;
13302 u8 sw_if_index_set = 0;
13303 u8 sw_if_index_if_name_set = 0;
13305 u8 priority_set = 0;
13309 u8 *locator_set_name = NULL;
13310 u8 locator_set_name_set = 0;
13313 /* Parse args required to build the message */
13314 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13316 if (unformat (input, "del"))
13320 else if (unformat (input, "locator-set %s", &locator_set_name))
13322 locator_set_name_set = 1;
13324 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
13327 sw_if_index_if_name_set = 1;
13328 sw_if_index = tmp_if_index;
13330 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
13332 sw_if_index_set = 1;
13333 sw_if_index = tmp_if_index;
13335 else if (unformat (input, "p %d", &priority))
13339 else if (unformat (input, "w %d", &weight))
13347 if (locator_set_name_set == 0)
13349 errmsg ("missing locator-set name");
13353 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
13355 errmsg ("missing sw_if_index");
13356 vec_free (locator_set_name);
13360 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
13362 errmsg ("cannot use both params interface name and sw_if_index");
13363 vec_free (locator_set_name);
13367 if (priority_set == 0)
13369 errmsg ("missing locator-set priority");
13370 vec_free (locator_set_name);
13374 if (weight_set == 0)
13376 errmsg ("missing locator-set weight");
13377 vec_free (locator_set_name);
13381 if (vec_len (locator_set_name) > 64)
13383 errmsg ("locator-set name too long");
13384 vec_free (locator_set_name);
13387 vec_add1 (locator_set_name, 0);
13389 /* Construct the API message */
13390 M (LISP_ADD_DEL_LOCATOR, mp);
13392 mp->is_add = is_add;
13393 mp->sw_if_index = ntohl (sw_if_index);
13394 mp->priority = priority;
13395 mp->weight = weight;
13396 clib_memcpy (mp->locator_set_name, locator_set_name,
13397 vec_len (locator_set_name));
13398 vec_free (locator_set_name);
13403 /* Wait for a reply... */
13409 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
13411 u32 *key_id = va_arg (*args, u32 *);
13414 if (unformat (input, "%s", &s))
13416 if (!strcmp ((char *) s, "sha1"))
13417 key_id[0] = HMAC_SHA_1_96;
13418 else if (!strcmp ((char *) s, "sha256"))
13419 key_id[0] = HMAC_SHA_256_128;
13422 clib_warning ("invalid key_id: '%s'", s);
13423 key_id[0] = HMAC_NO_KEY;
13434 api_lisp_add_del_local_eid (vat_main_t * vam)
13436 unformat_input_t *input = vam->input;
13437 vl_api_lisp_add_del_local_eid_t *mp;
13440 lisp_eid_vat_t _eid, *eid = &_eid;
13441 u8 *locator_set_name = 0;
13442 u8 locator_set_name_set = 0;
13448 /* Parse args required to build the message */
13449 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13451 if (unformat (input, "del"))
13455 else if (unformat (input, "vni %d", &vni))
13459 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
13463 else if (unformat (input, "locator-set %s", &locator_set_name))
13465 locator_set_name_set = 1;
13467 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
13469 else if (unformat (input, "secret-key %_%v%_", &key))
13475 if (locator_set_name_set == 0)
13477 errmsg ("missing locator-set name");
13483 errmsg ("EID address not set!");
13484 vec_free (locator_set_name);
13488 if (key && (0 == key_id))
13490 errmsg ("invalid key_id!");
13494 if (vec_len (key) > 64)
13496 errmsg ("key too long");
13501 if (vec_len (locator_set_name) > 64)
13503 errmsg ("locator-set name too long");
13504 vec_free (locator_set_name);
13507 vec_add1 (locator_set_name, 0);
13509 /* Construct the API message */
13510 M (LISP_ADD_DEL_LOCAL_EID, mp);
13512 mp->is_add = is_add;
13513 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
13514 mp->eid_type = eid->type;
13515 mp->prefix_len = eid->len;
13516 mp->vni = clib_host_to_net_u32 (vni);
13517 mp->key_id = clib_host_to_net_u16 (key_id);
13518 clib_memcpy (mp->locator_set_name, locator_set_name,
13519 vec_len (locator_set_name));
13520 clib_memcpy (mp->key, key, vec_len (key));
13522 vec_free (locator_set_name);
13528 /* Wait for a reply... */
13534 /** Used for transferring locators via VPP API */
13535 typedef CLIB_PACKED(struct
13537 u8 is_ip4; /**< is locator an IPv4 address? */
13538 u8 priority; /**< locator priority */
13539 u8 weight; /**< locator weight */
13540 u8 addr[16]; /**< IPv4/IPv6 address */
13545 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
13547 u32 dp_table = 0, vni = 0;;
13548 unformat_input_t *input = vam->input;
13549 vl_api_lisp_gpe_add_del_fwd_entry_t *mp;
13551 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
13552 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
13553 u8 rmt_eid_set = 0, lcl_eid_set = 0;
13554 u32 action = ~0, w;
13555 ip4_address_t rmt_rloc4, lcl_rloc4;
13556 ip6_address_t rmt_rloc6, lcl_rloc6;
13557 vl_api_lisp_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc =
13561 memset (&rloc, 0, sizeof (rloc));
13563 /* Parse args required to build the message */
13564 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13566 if (unformat (input, "del"))
13568 else if (unformat (input, "add"))
13570 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
13574 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
13578 else if (unformat (input, "vrf %d", &dp_table))
13580 else if (unformat (input, "bd %d", &dp_table))
13582 else if (unformat (input, "vni %d", &vni))
13584 else if (unformat (input, "w %d", &w))
13588 errmsg ("No RLOC configured for setting priority/weight!");
13591 curr_rloc->weight = w;
13593 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
13594 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
13598 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
13600 vec_add1 (lcl_locs, rloc);
13602 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
13603 vec_add1 (rmt_locs, rloc);
13604 /* weight saved in rmt loc */
13605 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
13607 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
13608 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
13611 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
13613 vec_add1 (lcl_locs, rloc);
13615 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
13616 vec_add1 (rmt_locs, rloc);
13617 /* weight saved in rmt loc */
13618 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
13620 else if (unformat (input, "action %d", &action))
13626 clib_warning ("parse error '%U'", format_unformat_error, input);
13633 errmsg ("remote eid addresses not set");
13637 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
13639 errmsg ("eid types don't match");
13643 if (0 == rmt_locs && (u32) ~ 0 == action)
13645 errmsg ("action not set for negative mapping");
13649 /* Construct the API message */
13650 M2 (LISP_GPE_ADD_DEL_FWD_ENTRY, mp,
13651 sizeof (vl_api_lisp_gpe_locator_t) * vec_len (rmt_locs) * 2);
13653 mp->is_add = is_add;
13654 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
13655 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
13656 mp->eid_type = rmt_eid->type;
13657 mp->dp_table = clib_host_to_net_u32 (dp_table);
13658 mp->vni = clib_host_to_net_u32 (vni);
13659 mp->rmt_len = rmt_eid->len;
13660 mp->lcl_len = lcl_eid->len;
13661 mp->action = action;
13663 if (0 != rmt_locs && 0 != lcl_locs)
13665 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
13666 clib_memcpy (mp->locs, lcl_locs,
13667 (sizeof (vl_api_lisp_gpe_locator_t) * vec_len (lcl_locs)));
13669 u32 offset = sizeof (vl_api_lisp_gpe_locator_t) * vec_len (lcl_locs);
13670 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
13671 (sizeof (vl_api_lisp_gpe_locator_t) * vec_len (rmt_locs)));
13673 vec_free (lcl_locs);
13674 vec_free (rmt_locs);
13679 /* Wait for a reply... */
13685 api_lisp_add_del_map_server (vat_main_t * vam)
13687 unformat_input_t *input = vam->input;
13688 vl_api_lisp_add_del_map_server_t *mp;
13692 ip4_address_t ipv4;
13693 ip6_address_t ipv6;
13696 /* Parse args required to build the message */
13697 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13699 if (unformat (input, "del"))
13703 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
13707 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
13715 if (ipv4_set && ipv6_set)
13717 errmsg ("both eid v4 and v6 addresses set");
13721 if (!ipv4_set && !ipv6_set)
13723 errmsg ("eid addresses not set");
13727 /* Construct the API message */
13728 M (LISP_ADD_DEL_MAP_SERVER, mp);
13730 mp->is_add = is_add;
13734 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
13739 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
13745 /* Wait for a reply... */
13751 api_lisp_add_del_map_resolver (vat_main_t * vam)
13753 unformat_input_t *input = vam->input;
13754 vl_api_lisp_add_del_map_resolver_t *mp;
13758 ip4_address_t ipv4;
13759 ip6_address_t ipv6;
13762 /* Parse args required to build the message */
13763 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13765 if (unformat (input, "del"))
13769 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
13773 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
13781 if (ipv4_set && ipv6_set)
13783 errmsg ("both eid v4 and v6 addresses set");
13787 if (!ipv4_set && !ipv6_set)
13789 errmsg ("eid addresses not set");
13793 /* Construct the API message */
13794 M (LISP_ADD_DEL_MAP_RESOLVER, mp);
13796 mp->is_add = is_add;
13800 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
13805 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
13811 /* Wait for a reply... */
13817 api_lisp_gpe_enable_disable (vat_main_t * vam)
13819 unformat_input_t *input = vam->input;
13820 vl_api_lisp_gpe_enable_disable_t *mp;
13825 /* Parse args required to build the message */
13826 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13828 if (unformat (input, "enable"))
13833 else if (unformat (input, "disable"))
13844 errmsg ("Value not set");
13848 /* Construct the API message */
13849 M (LISP_GPE_ENABLE_DISABLE, mp);
13856 /* Wait for a reply... */
13862 api_lisp_rloc_probe_enable_disable (vat_main_t * vam)
13864 unformat_input_t *input = vam->input;
13865 vl_api_lisp_rloc_probe_enable_disable_t *mp;
13870 /* Parse args required to build the message */
13871 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13873 if (unformat (input, "enable"))
13878 else if (unformat (input, "disable"))
13886 errmsg ("Value not set");
13890 /* Construct the API message */
13891 M (LISP_RLOC_PROBE_ENABLE_DISABLE, mp);
13893 mp->is_enabled = is_en;
13898 /* Wait for a reply... */
13904 api_lisp_map_register_enable_disable (vat_main_t * vam)
13906 unformat_input_t *input = vam->input;
13907 vl_api_lisp_map_register_enable_disable_t *mp;
13912 /* Parse args required to build the message */
13913 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13915 if (unformat (input, "enable"))
13920 else if (unformat (input, "disable"))
13928 errmsg ("Value not set");
13932 /* Construct the API message */
13933 M (LISP_MAP_REGISTER_ENABLE_DISABLE, mp);
13935 mp->is_enabled = is_en;
13940 /* Wait for a reply... */
13946 api_lisp_enable_disable (vat_main_t * vam)
13948 unformat_input_t *input = vam->input;
13949 vl_api_lisp_enable_disable_t *mp;
13954 /* Parse args required to build the message */
13955 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13957 if (unformat (input, "enable"))
13962 else if (unformat (input, "disable"))
13972 errmsg ("Value not set");
13976 /* Construct the API message */
13977 M (LISP_ENABLE_DISABLE, mp);
13984 /* Wait for a reply... */
13990 api_show_lisp_map_register_state (vat_main_t * vam)
13992 vl_api_show_lisp_map_register_state_t *mp;
13995 M (SHOW_LISP_MAP_REGISTER_STATE, mp);
14000 /* wait for reply */
14006 api_show_lisp_rloc_probe_state (vat_main_t * vam)
14008 vl_api_show_lisp_rloc_probe_state_t *mp;
14011 M (SHOW_LISP_RLOC_PROBE_STATE, mp);
14016 /* wait for reply */
14022 api_show_lisp_map_request_mode (vat_main_t * vam)
14024 vl_api_show_lisp_map_request_mode_t *mp;
14027 M (SHOW_LISP_MAP_REQUEST_MODE, mp);
14032 /* wait for reply */
14038 api_lisp_map_request_mode (vat_main_t * vam)
14040 unformat_input_t *input = vam->input;
14041 vl_api_lisp_map_request_mode_t *mp;
14045 /* Parse args required to build the message */
14046 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14048 if (unformat (input, "dst-only"))
14050 else if (unformat (input, "src-dst"))
14054 errmsg ("parse error '%U'", format_unformat_error, input);
14059 M (LISP_MAP_REQUEST_MODE, mp);
14066 /* wait for reply */
14072 * Enable/disable LISP proxy ITR.
14074 * @param vam vpp API test context
14075 * @return return code
14078 api_lisp_pitr_set_locator_set (vat_main_t * vam)
14080 u8 ls_name_set = 0;
14081 unformat_input_t *input = vam->input;
14082 vl_api_lisp_pitr_set_locator_set_t *mp;
14087 /* Parse args required to build the message */
14088 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14090 if (unformat (input, "del"))
14092 else if (unformat (input, "locator-set %s", &ls_name))
14096 errmsg ("parse error '%U'", format_unformat_error, input);
14103 errmsg ("locator-set name not set!");
14107 M (LISP_PITR_SET_LOCATOR_SET, mp);
14109 mp->is_add = is_add;
14110 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
14111 vec_free (ls_name);
14116 /* wait for reply */
14122 api_show_lisp_pitr (vat_main_t * vam)
14124 vl_api_show_lisp_pitr_t *mp;
14127 if (!vam->json_output)
14129 print (vam->ofp, "%=20s", "lisp status:");
14132 M (SHOW_LISP_PITR, mp);
14136 /* Wait for a reply... */
14142 * Add/delete mapping between vni and vrf
14145 api_lisp_eid_table_add_del_map (vat_main_t * vam)
14147 unformat_input_t *input = vam->input;
14148 vl_api_lisp_eid_table_add_del_map_t *mp;
14149 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
14150 u32 vni, vrf, bd_index;
14153 /* Parse args required to build the message */
14154 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14156 if (unformat (input, "del"))
14158 else if (unformat (input, "vrf %d", &vrf))
14160 else if (unformat (input, "bd_index %d", &bd_index))
14162 else if (unformat (input, "vni %d", &vni))
14168 if (!vni_set || (!vrf_set && !bd_index_set))
14170 errmsg ("missing arguments!");
14174 if (vrf_set && bd_index_set)
14176 errmsg ("error: both vrf and bd entered!");
14180 M (LISP_EID_TABLE_ADD_DEL_MAP, mp);
14182 mp->is_add = is_add;
14183 mp->vni = htonl (vni);
14184 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
14185 mp->is_l2 = bd_index_set;
14190 /* wait for reply */
14196 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
14198 u32 *action = va_arg (*args, u32 *);
14201 if (unformat (input, "%s", &s))
14203 if (!strcmp ((char *) s, "no-action"))
14205 else if (!strcmp ((char *) s, "natively-forward"))
14207 else if (!strcmp ((char *) s, "send-map-request"))
14209 else if (!strcmp ((char *) s, "drop"))
14213 clib_warning ("invalid action: '%s'", s);
14225 * Add/del remote mapping to/from LISP control plane
14227 * @param vam vpp API test context
14228 * @return return code
14231 api_lisp_add_del_remote_mapping (vat_main_t * vam)
14233 unformat_input_t *input = vam->input;
14234 vl_api_lisp_add_del_remote_mapping_t *mp;
14236 lisp_eid_vat_t _eid, *eid = &_eid;
14237 lisp_eid_vat_t _seid, *seid = &_seid;
14238 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
14239 u32 action = ~0, p, w, data_len;
14240 ip4_address_t rloc4;
14241 ip6_address_t rloc6;
14242 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
14245 memset (&rloc, 0, sizeof (rloc));
14247 /* Parse args required to build the message */
14248 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14250 if (unformat (input, "del-all"))
14254 else if (unformat (input, "del"))
14258 else if (unformat (input, "add"))
14262 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
14266 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
14270 else if (unformat (input, "vni %d", &vni))
14274 else if (unformat (input, "p %d w %d", &p, &w))
14278 errmsg ("No RLOC configured for setting priority/weight!");
14281 curr_rloc->priority = p;
14282 curr_rloc->weight = w;
14284 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
14287 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
14288 vec_add1 (rlocs, rloc);
14289 curr_rloc = &rlocs[vec_len (rlocs) - 1];
14291 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
14294 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
14295 vec_add1 (rlocs, rloc);
14296 curr_rloc = &rlocs[vec_len (rlocs) - 1];
14298 else if (unformat (input, "action %U",
14299 unformat_negative_mapping_action, &action))
14305 clib_warning ("parse error '%U'", format_unformat_error, input);
14312 errmsg ("missing params!");
14316 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
14318 errmsg ("no action set for negative map-reply!");
14322 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
14324 M2 (LISP_ADD_DEL_REMOTE_MAPPING, mp, data_len);
14325 mp->is_add = is_add;
14326 mp->vni = htonl (vni);
14327 mp->action = (u8) action;
14328 mp->is_src_dst = seid_set;
14329 mp->eid_len = eid->len;
14330 mp->seid_len = seid->len;
14331 mp->del_all = del_all;
14332 mp->eid_type = eid->type;
14333 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
14334 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
14336 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
14337 clib_memcpy (mp->rlocs, rlocs, data_len);
14343 /* Wait for a reply... */
14349 * Add/del LISP adjacency. Saves mapping in LISP control plane and updates
14350 * forwarding entries in data-plane accordingly.
14352 * @param vam vpp API test context
14353 * @return return code
14356 api_lisp_add_del_adjacency (vat_main_t * vam)
14358 unformat_input_t *input = vam->input;
14359 vl_api_lisp_add_del_adjacency_t *mp;
14361 ip4_address_t leid4, reid4;
14362 ip6_address_t leid6, reid6;
14363 u8 reid_mac[6] = { 0 };
14364 u8 leid_mac[6] = { 0 };
14365 u8 reid_type, leid_type;
14366 u32 leid_len = 0, reid_len = 0, len;
14370 leid_type = reid_type = (u8) ~ 0;
14372 /* Parse args required to build the message */
14373 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14375 if (unformat (input, "del"))
14379 else if (unformat (input, "add"))
14383 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
14386 reid_type = 0; /* ipv4 */
14389 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
14392 reid_type = 1; /* ipv6 */
14395 else if (unformat (input, "reid %U", unformat_ethernet_address,
14398 reid_type = 2; /* mac */
14400 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
14403 leid_type = 0; /* ipv4 */
14406 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
14409 leid_type = 1; /* ipv6 */
14412 else if (unformat (input, "leid %U", unformat_ethernet_address,
14415 leid_type = 2; /* mac */
14417 else if (unformat (input, "vni %d", &vni))
14423 errmsg ("parse error '%U'", format_unformat_error, input);
14428 if ((u8) ~ 0 == reid_type)
14430 errmsg ("missing params!");
14434 if (leid_type != reid_type)
14436 errmsg ("remote and local EIDs are of different types!");
14440 M (LISP_ADD_DEL_ADJACENCY, mp);
14441 mp->is_add = is_add;
14442 mp->vni = htonl (vni);
14443 mp->leid_len = leid_len;
14444 mp->reid_len = reid_len;
14445 mp->eid_type = reid_type;
14447 switch (mp->eid_type)
14450 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
14451 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
14454 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
14455 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
14458 clib_memcpy (mp->leid, leid_mac, 6);
14459 clib_memcpy (mp->reid, reid_mac, 6);
14462 errmsg ("unknown EID type %d!", mp->eid_type);
14469 /* Wait for a reply... */
14475 api_lisp_gpe_add_del_iface (vat_main_t * vam)
14477 unformat_input_t *input = vam->input;
14478 vl_api_lisp_gpe_add_del_iface_t *mp;
14479 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
14480 u32 dp_table = 0, vni = 0;
14483 /* Parse args required to build the message */
14484 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14486 if (unformat (input, "up"))
14491 else if (unformat (input, "down"))
14496 else if (unformat (input, "table_id %d", &dp_table))
14500 else if (unformat (input, "bd_id %d", &dp_table))
14505 else if (unformat (input, "vni %d", &vni))
14513 if (action_set == 0)
14515 errmsg ("Action not set");
14518 if (dp_table_set == 0 || vni_set == 0)
14520 errmsg ("vni and dp_table must be set");
14524 /* Construct the API message */
14525 M (LISP_GPE_ADD_DEL_IFACE, mp);
14527 mp->is_add = is_add;
14528 mp->dp_table = dp_table;
14535 /* Wait for a reply... */
14541 * Add/del map request itr rlocs from LISP control plane and updates
14543 * @param vam vpp API test context
14544 * @return return code
14547 api_lisp_add_del_map_request_itr_rlocs (vat_main_t * vam)
14549 unformat_input_t *input = vam->input;
14550 vl_api_lisp_add_del_map_request_itr_rlocs_t *mp;
14551 u8 *locator_set_name = 0;
14552 u8 locator_set_name_set = 0;
14556 /* Parse args required to build the message */
14557 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14559 if (unformat (input, "del"))
14563 else if (unformat (input, "%_%v%_", &locator_set_name))
14565 locator_set_name_set = 1;
14569 clib_warning ("parse error '%U'", format_unformat_error, input);
14574 if (is_add && !locator_set_name_set)
14576 errmsg ("itr-rloc is not set!");
14580 if (is_add && vec_len (locator_set_name) > 64)
14582 errmsg ("itr-rloc locator-set name too long");
14583 vec_free (locator_set_name);
14587 M (LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
14588 mp->is_add = is_add;
14591 clib_memcpy (mp->locator_set_name, locator_set_name,
14592 vec_len (locator_set_name));
14596 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
14598 vec_free (locator_set_name);
14603 /* Wait for a reply... */
14609 api_lisp_locator_dump (vat_main_t * vam)
14611 unformat_input_t *input = vam->input;
14612 vl_api_lisp_locator_dump_t *mp;
14613 vl_api_control_ping_t *mp_ping;
14614 u8 is_index_set = 0, is_name_set = 0;
14619 /* Parse args required to build the message */
14620 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14622 if (unformat (input, "ls_name %_%v%_", &ls_name))
14626 else if (unformat (input, "ls_index %d", &ls_index))
14632 errmsg ("parse error '%U'", format_unformat_error, input);
14637 if (!is_index_set && !is_name_set)
14639 errmsg ("error: expected one of index or name!");
14643 if (is_index_set && is_name_set)
14645 errmsg ("error: only one param expected!");
14649 if (vec_len (ls_name) > 62)
14651 errmsg ("error: locator set name too long!");
14655 if (!vam->json_output)
14657 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
14660 M (LISP_LOCATOR_DUMP, mp);
14661 mp->is_index_set = is_index_set;
14664 mp->ls_index = clib_host_to_net_u32 (ls_index);
14667 vec_add1 (ls_name, 0);
14668 strncpy ((char *) mp->ls_name, (char *) ls_name,
14669 sizeof (mp->ls_name) - 1);
14675 /* Use a control ping for synchronization */
14676 M (CONTROL_PING, mp_ping);
14679 /* Wait for a reply... */
14685 api_lisp_locator_set_dump (vat_main_t * vam)
14687 vl_api_lisp_locator_set_dump_t *mp;
14688 vl_api_control_ping_t *mp_ping;
14689 unformat_input_t *input = vam->input;
14693 /* Parse args required to build the message */
14694 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14696 if (unformat (input, "local"))
14700 else if (unformat (input, "remote"))
14706 errmsg ("parse error '%U'", format_unformat_error, input);
14711 if (!vam->json_output)
14713 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
14716 M (LISP_LOCATOR_SET_DUMP, mp);
14718 mp->filter = filter;
14723 /* Use a control ping for synchronization */
14724 M (CONTROL_PING, mp_ping);
14727 /* Wait for a reply... */
14733 api_lisp_eid_table_map_dump (vat_main_t * vam)
14737 unformat_input_t *input = vam->input;
14738 vl_api_lisp_eid_table_map_dump_t *mp;
14739 vl_api_control_ping_t *mp_ping;
14742 /* Parse args required to build the message */
14743 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14745 if (unformat (input, "l2"))
14750 else if (unformat (input, "l3"))
14757 errmsg ("parse error '%U'", format_unformat_error, input);
14764 errmsg ("expected one of 'l2' or 'l3' parameter!");
14768 if (!vam->json_output)
14770 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
14773 M (LISP_EID_TABLE_MAP_DUMP, mp);
14779 /* Use a control ping for synchronization */
14780 M (CONTROL_PING, mp_ping);
14783 /* Wait for a reply... */
14789 api_lisp_eid_table_vni_dump (vat_main_t * vam)
14791 vl_api_lisp_eid_table_vni_dump_t *mp;
14792 vl_api_control_ping_t *mp_ping;
14795 if (!vam->json_output)
14797 print (vam->ofp, "VNI");
14800 M (LISP_EID_TABLE_VNI_DUMP, mp);
14805 /* Use a control ping for synchronization */
14806 M (CONTROL_PING, mp_ping);
14809 /* Wait for a reply... */
14815 api_lisp_eid_table_dump (vat_main_t * vam)
14817 unformat_input_t *i = vam->input;
14818 vl_api_lisp_eid_table_dump_t *mp;
14819 vl_api_control_ping_t *mp_ping;
14820 struct in_addr ip4;
14821 struct in6_addr ip6;
14823 u8 eid_type = ~0, eid_set = 0;
14824 u32 prefix_length = ~0, t, vni = 0;
14828 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14830 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
14836 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
14842 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
14847 else if (unformat (i, "vni %d", &t))
14851 else if (unformat (i, "local"))
14855 else if (unformat (i, "remote"))
14861 errmsg ("parse error '%U'", format_unformat_error, i);
14866 if (!vam->json_output)
14868 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
14869 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
14872 M (LISP_EID_TABLE_DUMP, mp);
14874 mp->filter = filter;
14878 mp->vni = htonl (vni);
14879 mp->eid_type = eid_type;
14883 mp->prefix_length = prefix_length;
14884 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
14887 mp->prefix_length = prefix_length;
14888 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
14891 clib_memcpy (mp->eid, mac, sizeof (mac));
14894 errmsg ("unknown EID type %d!", eid_type);
14902 /* Use a control ping for synchronization */
14903 M (CONTROL_PING, mp_ping);
14906 /* Wait for a reply... */
14912 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
14914 unformat_input_t *i = vam->input;
14915 vl_api_lisp_gpe_fwd_entries_get_t *mp;
14920 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14922 if (unformat (i, "vni %d", &vni))
14928 errmsg ("parse error '%U'", format_unformat_error, i);
14935 errmsg ("vni not set!");
14939 if (!vam->json_output)
14941 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
14945 M (LISP_GPE_FWD_ENTRIES_GET, mp);
14946 mp->vni = clib_host_to_net_u32 (vni);
14951 /* Wait for a reply... */
14956 #define vl_api_lisp_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
14957 #define vl_api_lisp_gpe_fwd_entries_get_reply_t_print vl_noop_handler
14958 #define vl_api_lisp_gpe_fwd_entry_path_details_t_endian vl_noop_handler
14959 #define vl_api_lisp_gpe_fwd_entry_path_details_t_print vl_noop_handler
14962 api_lisp_adjacencies_get (vat_main_t * vam)
14964 unformat_input_t *i = vam->input;
14965 vl_api_lisp_adjacencies_get_t *mp;
14970 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14972 if (unformat (i, "vni %d", &vni))
14978 errmsg ("parse error '%U'", format_unformat_error, i);
14985 errmsg ("vni not set!");
14989 if (!vam->json_output)
14991 print (vam->ofp, "%s %40s", "leid", "reid");
14994 M (LISP_ADJACENCIES_GET, mp);
14995 mp->vni = clib_host_to_net_u32 (vni);
15000 /* Wait for a reply... */
15006 api_lisp_map_server_dump (vat_main_t * vam)
15008 vl_api_lisp_map_server_dump_t *mp;
15009 vl_api_control_ping_t *mp_ping;
15012 if (!vam->json_output)
15014 print (vam->ofp, "%=20s", "Map server");
15017 M (LISP_MAP_SERVER_DUMP, mp);
15021 /* Use a control ping for synchronization */
15022 M (CONTROL_PING, mp_ping);
15025 /* Wait for a reply... */
15031 api_lisp_map_resolver_dump (vat_main_t * vam)
15033 vl_api_lisp_map_resolver_dump_t *mp;
15034 vl_api_control_ping_t *mp_ping;
15037 if (!vam->json_output)
15039 print (vam->ofp, "%=20s", "Map resolver");
15042 M (LISP_MAP_RESOLVER_DUMP, mp);
15046 /* Use a control ping for synchronization */
15047 M (CONTROL_PING, mp_ping);
15050 /* Wait for a reply... */
15056 api_show_lisp_status (vat_main_t * vam)
15058 vl_api_show_lisp_status_t *mp;
15061 if (!vam->json_output)
15063 print (vam->ofp, "%-20s%-16s", "lisp status", "locator-set");
15066 M (SHOW_LISP_STATUS, mp);
15069 /* Wait for a reply... */
15075 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
15077 vl_api_lisp_gpe_fwd_entry_path_dump_t *mp;
15078 vl_api_control_ping_t *mp_ping;
15079 unformat_input_t *i = vam->input;
15080 u32 fwd_entry_index = ~0;
15083 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15085 if (unformat (i, "index %d", &fwd_entry_index))
15091 if (~0 == fwd_entry_index)
15093 errmsg ("no index specified!");
15097 if (!vam->json_output)
15099 print (vam->ofp, "first line");
15102 M (LISP_GPE_FWD_ENTRY_PATH_DUMP, mp);
15106 /* Use a control ping for synchronization */
15107 M (CONTROL_PING, mp_ping);
15110 /* Wait for a reply... */
15116 api_lisp_get_map_request_itr_rlocs (vat_main_t * vam)
15118 vl_api_lisp_get_map_request_itr_rlocs_t *mp;
15121 if (!vam->json_output)
15123 print (vam->ofp, "%=20s", "itr-rlocs:");
15126 M (LISP_GET_MAP_REQUEST_ITR_RLOCS, mp);
15129 /* Wait for a reply... */
15135 api_af_packet_create (vat_main_t * vam)
15137 unformat_input_t *i = vam->input;
15138 vl_api_af_packet_create_t *mp;
15139 u8 *host_if_name = 0;
15141 u8 random_hw_addr = 1;
15144 memset (hw_addr, 0, sizeof (hw_addr));
15146 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15148 if (unformat (i, "name %s", &host_if_name))
15149 vec_add1 (host_if_name, 0);
15150 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
15151 random_hw_addr = 0;
15156 if (!vec_len (host_if_name))
15158 errmsg ("host-interface name must be specified");
15162 if (vec_len (host_if_name) > 64)
15164 errmsg ("host-interface name too long");
15168 M (AF_PACKET_CREATE, mp);
15170 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
15171 clib_memcpy (mp->hw_addr, hw_addr, 6);
15172 mp->use_random_hw_addr = random_hw_addr;
15173 vec_free (host_if_name);
15176 W2 (ret, fprintf (vam->ofp, " new sw_if_index = %d ", vam->sw_if_index));
15181 api_af_packet_delete (vat_main_t * vam)
15183 unformat_input_t *i = vam->input;
15184 vl_api_af_packet_delete_t *mp;
15185 u8 *host_if_name = 0;
15188 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15190 if (unformat (i, "name %s", &host_if_name))
15191 vec_add1 (host_if_name, 0);
15196 if (!vec_len (host_if_name))
15198 errmsg ("host-interface name must be specified");
15202 if (vec_len (host_if_name) > 64)
15204 errmsg ("host-interface name too long");
15208 M (AF_PACKET_DELETE, mp);
15210 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
15211 vec_free (host_if_name);
15219 api_policer_add_del (vat_main_t * vam)
15221 unformat_input_t *i = vam->input;
15222 vl_api_policer_add_del_t *mp;
15232 u8 color_aware = 0;
15233 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
15236 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
15237 conform_action.dscp = 0;
15238 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
15239 exceed_action.dscp = 0;
15240 violate_action.action_type = SSE2_QOS_ACTION_DROP;
15241 violate_action.dscp = 0;
15243 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15245 if (unformat (i, "del"))
15247 else if (unformat (i, "name %s", &name))
15248 vec_add1 (name, 0);
15249 else if (unformat (i, "cir %u", &cir))
15251 else if (unformat (i, "eir %u", &eir))
15253 else if (unformat (i, "cb %u", &cb))
15255 else if (unformat (i, "eb %u", &eb))
15257 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
15260 else if (unformat (i, "round_type %U", unformat_policer_round_type,
15263 else if (unformat (i, "type %U", unformat_policer_type, &type))
15265 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
15268 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
15271 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
15274 else if (unformat (i, "color-aware"))
15280 if (!vec_len (name))
15282 errmsg ("policer name must be specified");
15286 if (vec_len (name) > 64)
15288 errmsg ("policer name too long");
15292 M (POLICER_ADD_DEL, mp);
15294 clib_memcpy (mp->name, name, vec_len (name));
15296 mp->is_add = is_add;
15301 mp->rate_type = rate_type;
15302 mp->round_type = round_type;
15304 mp->conform_action_type = conform_action.action_type;
15305 mp->conform_dscp = conform_action.dscp;
15306 mp->exceed_action_type = exceed_action.action_type;
15307 mp->exceed_dscp = exceed_action.dscp;
15308 mp->violate_action_type = violate_action.action_type;
15309 mp->violate_dscp = violate_action.dscp;
15310 mp->color_aware = color_aware;
15318 api_policer_dump (vat_main_t * vam)
15320 unformat_input_t *i = vam->input;
15321 vl_api_policer_dump_t *mp;
15322 vl_api_control_ping_t *mp_ping;
15323 u8 *match_name = 0;
15324 u8 match_name_valid = 0;
15327 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15329 if (unformat (i, "name %s", &match_name))
15331 vec_add1 (match_name, 0);
15332 match_name_valid = 1;
15338 M (POLICER_DUMP, mp);
15339 mp->match_name_valid = match_name_valid;
15340 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
15341 vec_free (match_name);
15345 /* Use a control ping for synchronization */
15346 M (CONTROL_PING, mp_ping);
15349 /* Wait for a reply... */
15355 api_policer_classify_set_interface (vat_main_t * vam)
15357 unformat_input_t *i = vam->input;
15358 vl_api_policer_classify_set_interface_t *mp;
15360 int sw_if_index_set;
15361 u32 ip4_table_index = ~0;
15362 u32 ip6_table_index = ~0;
15363 u32 l2_table_index = ~0;
15367 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15369 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15370 sw_if_index_set = 1;
15371 else if (unformat (i, "sw_if_index %d", &sw_if_index))
15372 sw_if_index_set = 1;
15373 else if (unformat (i, "del"))
15375 else if (unformat (i, "ip4-table %d", &ip4_table_index))
15377 else if (unformat (i, "ip6-table %d", &ip6_table_index))
15379 else if (unformat (i, "l2-table %d", &l2_table_index))
15383 clib_warning ("parse error '%U'", format_unformat_error, i);
15388 if (sw_if_index_set == 0)
15390 errmsg ("missing interface name or sw_if_index");
15394 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
15396 mp->sw_if_index = ntohl (sw_if_index);
15397 mp->ip4_table_index = ntohl (ip4_table_index);
15398 mp->ip6_table_index = ntohl (ip6_table_index);
15399 mp->l2_table_index = ntohl (l2_table_index);
15400 mp->is_add = is_add;
15408 api_policer_classify_dump (vat_main_t * vam)
15410 unformat_input_t *i = vam->input;
15411 vl_api_policer_classify_dump_t *mp;
15412 vl_api_control_ping_t *mp_ping;
15413 u8 type = POLICER_CLASSIFY_N_TABLES;
15416 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
15420 errmsg ("classify table type must be specified");
15424 if (!vam->json_output)
15426 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
15429 M (POLICER_CLASSIFY_DUMP, mp);
15434 /* Use a control ping for synchronization */
15435 M (CONTROL_PING, mp_ping);
15438 /* Wait for a reply... */
15444 api_netmap_create (vat_main_t * vam)
15446 unformat_input_t *i = vam->input;
15447 vl_api_netmap_create_t *mp;
15450 u8 random_hw_addr = 1;
15455 memset (hw_addr, 0, sizeof (hw_addr));
15457 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15459 if (unformat (i, "name %s", &if_name))
15460 vec_add1 (if_name, 0);
15461 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
15462 random_hw_addr = 0;
15463 else if (unformat (i, "pipe"))
15465 else if (unformat (i, "master"))
15467 else if (unformat (i, "slave"))
15473 if (!vec_len (if_name))
15475 errmsg ("interface name must be specified");
15479 if (vec_len (if_name) > 64)
15481 errmsg ("interface name too long");
15485 M (NETMAP_CREATE, mp);
15487 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
15488 clib_memcpy (mp->hw_addr, hw_addr, 6);
15489 mp->use_random_hw_addr = random_hw_addr;
15490 mp->is_pipe = is_pipe;
15491 mp->is_master = is_master;
15492 vec_free (if_name);
15500 api_netmap_delete (vat_main_t * vam)
15502 unformat_input_t *i = vam->input;
15503 vl_api_netmap_delete_t *mp;
15507 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15509 if (unformat (i, "name %s", &if_name))
15510 vec_add1 (if_name, 0);
15515 if (!vec_len (if_name))
15517 errmsg ("interface name must be specified");
15521 if (vec_len (if_name) > 64)
15523 errmsg ("interface name too long");
15527 M (NETMAP_DELETE, mp);
15529 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
15530 vec_free (if_name);
15537 static void vl_api_mpls_tunnel_details_t_handler
15538 (vl_api_mpls_tunnel_details_t * mp)
15540 vat_main_t *vam = &vat_main;
15541 i32 len = mp->mt_next_hop_n_labels;
15544 print (vam->ofp, "[%d]: via %U %d labels ",
15546 format_ip4_address, mp->mt_next_hop,
15547 ntohl (mp->mt_next_hop_sw_if_index));
15548 for (i = 0; i < len; i++)
15550 print (vam->ofp, "%u ", ntohl (mp->mt_next_hop_out_labels[i]));
15552 print (vam->ofp, "");
15555 static void vl_api_mpls_tunnel_details_t_handler_json
15556 (vl_api_mpls_tunnel_details_t * mp)
15558 vat_main_t *vam = &vat_main;
15559 vat_json_node_t *node = NULL;
15560 struct in_addr ip4;
15562 i32 len = mp->mt_next_hop_n_labels;
15564 if (VAT_JSON_ARRAY != vam->json_tree.type)
15566 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15567 vat_json_init_array (&vam->json_tree);
15569 node = vat_json_array_add (&vam->json_tree);
15571 vat_json_init_object (node);
15572 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
15573 clib_memcpy (&ip4, &(mp->mt_next_hop), sizeof (ip4));
15574 vat_json_object_add_ip4 (node, "next_hop", ip4);
15575 vat_json_object_add_uint (node, "next_hop_sw_if_index",
15576 ntohl (mp->mt_next_hop_sw_if_index));
15577 vat_json_object_add_uint (node, "l2_only", ntohl (mp->mt_l2_only));
15578 vat_json_object_add_uint (node, "label_count", len);
15579 for (i = 0; i < len; i++)
15581 vat_json_object_add_uint (node, "label",
15582 ntohl (mp->mt_next_hop_out_labels[i]));
15587 api_mpls_tunnel_dump (vat_main_t * vam)
15589 vl_api_mpls_tunnel_dump_t *mp;
15590 vl_api_control_ping_t *mp_ping;
15594 /* Parse args required to build the message */
15595 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
15597 if (!unformat (vam->input, "tunnel_index %d", &index))
15604 print (vam->ofp, " tunnel_index %d", index);
15606 M (MPLS_TUNNEL_DUMP, mp);
15607 mp->tunnel_index = htonl (index);
15610 /* Use a control ping for synchronization */
15611 M (CONTROL_PING, mp_ping);
15618 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
15619 #define vl_api_mpls_fib_details_t_print vl_noop_handler
15622 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
15624 vat_main_t *vam = &vat_main;
15625 int count = ntohl (mp->count);
15626 vl_api_fib_path2_t *fp;
15630 "table-id %d, label %u, ess_bit %u",
15631 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
15633 for (i = 0; i < count; i++)
15635 if (fp->afi == IP46_TYPE_IP6)
15637 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15638 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15639 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15640 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15641 format_ip6_address, fp->next_hop);
15642 else if (fp->afi == IP46_TYPE_IP4)
15644 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15645 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15646 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15647 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15648 format_ip4_address, fp->next_hop);
15653 static void vl_api_mpls_fib_details_t_handler_json
15654 (vl_api_mpls_fib_details_t * mp)
15656 vat_main_t *vam = &vat_main;
15657 int count = ntohl (mp->count);
15658 vat_json_node_t *node = NULL;
15659 struct in_addr ip4;
15660 struct in6_addr ip6;
15661 vl_api_fib_path2_t *fp;
15664 if (VAT_JSON_ARRAY != vam->json_tree.type)
15666 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15667 vat_json_init_array (&vam->json_tree);
15669 node = vat_json_array_add (&vam->json_tree);
15671 vat_json_init_object (node);
15672 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
15673 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
15674 vat_json_object_add_uint (node, "label", ntohl (mp->label));
15675 vat_json_object_add_uint (node, "path_count", count);
15677 for (i = 0; i < count; i++)
15679 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
15680 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
15681 vat_json_object_add_uint (node, "is_local", fp->is_local);
15682 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
15683 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
15684 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
15685 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
15686 if (fp->afi == IP46_TYPE_IP4)
15688 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
15689 vat_json_object_add_ip4 (node, "next_hop", ip4);
15691 else if (fp->afi == IP46_TYPE_IP6)
15693 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
15694 vat_json_object_add_ip6 (node, "next_hop", ip6);
15700 api_mpls_fib_dump (vat_main_t * vam)
15702 vl_api_mpls_fib_dump_t *mp;
15703 vl_api_control_ping_t *mp_ping;
15706 M (MPLS_FIB_DUMP, mp);
15709 /* Use a control ping for synchronization */
15710 M (CONTROL_PING, mp_ping);
15717 #define vl_api_ip_fib_details_t_endian vl_noop_handler
15718 #define vl_api_ip_fib_details_t_print vl_noop_handler
15721 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
15723 vat_main_t *vam = &vat_main;
15724 int count = ntohl (mp->count);
15725 vl_api_fib_path_t *fp;
15729 "table-id %d, prefix %U/%d",
15730 ntohl (mp->table_id), format_ip4_address, mp->address,
15731 mp->address_length);
15733 for (i = 0; i < count; i++)
15735 if (fp->afi == IP46_TYPE_IP6)
15737 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15738 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15739 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15740 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15741 format_ip6_address, fp->next_hop);
15742 else if (fp->afi == IP46_TYPE_IP4)
15744 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15745 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15746 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15747 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15748 format_ip4_address, fp->next_hop);
15753 static void vl_api_ip_fib_details_t_handler_json
15754 (vl_api_ip_fib_details_t * mp)
15756 vat_main_t *vam = &vat_main;
15757 int count = ntohl (mp->count);
15758 vat_json_node_t *node = NULL;
15759 struct in_addr ip4;
15760 struct in6_addr ip6;
15761 vl_api_fib_path_t *fp;
15764 if (VAT_JSON_ARRAY != vam->json_tree.type)
15766 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15767 vat_json_init_array (&vam->json_tree);
15769 node = vat_json_array_add (&vam->json_tree);
15771 vat_json_init_object (node);
15772 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
15773 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
15774 vat_json_object_add_ip4 (node, "prefix", ip4);
15775 vat_json_object_add_uint (node, "mask_length", mp->address_length);
15776 vat_json_object_add_uint (node, "path_count", count);
15778 for (i = 0; i < count; i++)
15780 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
15781 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
15782 vat_json_object_add_uint (node, "is_local", fp->is_local);
15783 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
15784 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
15785 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
15786 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
15787 if (fp->afi == IP46_TYPE_IP4)
15789 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
15790 vat_json_object_add_ip4 (node, "next_hop", ip4);
15792 else if (fp->afi == IP46_TYPE_IP6)
15794 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
15795 vat_json_object_add_ip6 (node, "next_hop", ip6);
15801 api_ip_fib_dump (vat_main_t * vam)
15803 vl_api_ip_fib_dump_t *mp;
15804 vl_api_control_ping_t *mp_ping;
15807 M (IP_FIB_DUMP, mp);
15810 /* Use a control ping for synchronization */
15811 M (CONTROL_PING, mp_ping);
15818 static void vl_api_ip_neighbor_details_t_handler
15819 (vl_api_ip_neighbor_details_t * mp)
15821 vat_main_t *vam = &vat_main;
15823 print (vam->ofp, "%c %U %U",
15824 (mp->is_static) ? 'S' : 'D',
15825 format_ethernet_address, &mp->mac_address,
15826 (mp->is_ipv6) ? format_ip6_address : format_ip4_address,
15830 static void vl_api_ip_neighbor_details_t_handler_json
15831 (vl_api_ip_neighbor_details_t * mp)
15834 vat_main_t *vam = &vat_main;
15835 vat_json_node_t *node;
15836 struct in_addr ip4;
15837 struct in6_addr ip6;
15839 if (VAT_JSON_ARRAY != vam->json_tree.type)
15841 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15842 vat_json_init_array (&vam->json_tree);
15844 node = vat_json_array_add (&vam->json_tree);
15846 vat_json_init_object (node);
15847 vat_json_object_add_string_copy (node, "flag",
15848 (mp->is_static) ? (u8 *) "static" : (u8 *)
15851 vat_json_object_add_string_copy (node, "link_layer",
15852 format (0, "%U", format_ethernet_address,
15853 &mp->mac_address));
15857 clib_memcpy (&ip6, &mp->ip_address, sizeof (ip6));
15858 vat_json_object_add_ip6 (node, "ip_address", ip6);
15862 clib_memcpy (&ip4, &mp->ip_address, sizeof (ip4));
15863 vat_json_object_add_ip4 (node, "ip_address", ip4);
15868 api_ip_neighbor_dump (vat_main_t * vam)
15870 unformat_input_t *i = vam->input;
15871 vl_api_ip_neighbor_dump_t *mp;
15872 vl_api_control_ping_t *mp_ping;
15874 u32 sw_if_index = ~0;
15877 /* Parse args required to build the message */
15878 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15880 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15882 else if (unformat (i, "sw_if_index %d", &sw_if_index))
15884 else if (unformat (i, "ip6"))
15890 if (sw_if_index == ~0)
15892 errmsg ("missing interface name or sw_if_index");
15896 M (IP_NEIGHBOR_DUMP, mp);
15897 mp->is_ipv6 = (u8) is_ipv6;
15898 mp->sw_if_index = ntohl (sw_if_index);
15901 /* Use a control ping for synchronization */
15902 M (CONTROL_PING, mp_ping);
15909 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
15910 #define vl_api_ip6_fib_details_t_print vl_noop_handler
15913 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
15915 vat_main_t *vam = &vat_main;
15916 int count = ntohl (mp->count);
15917 vl_api_fib_path_t *fp;
15921 "table-id %d, prefix %U/%d",
15922 ntohl (mp->table_id), format_ip6_address, mp->address,
15923 mp->address_length);
15925 for (i = 0; i < count; i++)
15927 if (fp->afi == IP46_TYPE_IP6)
15929 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15930 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15931 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15932 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15933 format_ip6_address, fp->next_hop);
15934 else if (fp->afi == IP46_TYPE_IP4)
15936 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15937 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15938 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15939 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15940 format_ip4_address, fp->next_hop);
15945 static void vl_api_ip6_fib_details_t_handler_json
15946 (vl_api_ip6_fib_details_t * mp)
15948 vat_main_t *vam = &vat_main;
15949 int count = ntohl (mp->count);
15950 vat_json_node_t *node = NULL;
15951 struct in_addr ip4;
15952 struct in6_addr ip6;
15953 vl_api_fib_path_t *fp;
15956 if (VAT_JSON_ARRAY != vam->json_tree.type)
15958 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15959 vat_json_init_array (&vam->json_tree);
15961 node = vat_json_array_add (&vam->json_tree);
15963 vat_json_init_object (node);
15964 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
15965 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
15966 vat_json_object_add_ip6 (node, "prefix", ip6);
15967 vat_json_object_add_uint (node, "mask_length", mp->address_length);
15968 vat_json_object_add_uint (node, "path_count", count);
15970 for (i = 0; i < count; i++)
15972 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
15973 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
15974 vat_json_object_add_uint (node, "is_local", fp->is_local);
15975 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
15976 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
15977 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
15978 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
15979 if (fp->afi == IP46_TYPE_IP4)
15981 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
15982 vat_json_object_add_ip4 (node, "next_hop", ip4);
15984 else if (fp->afi == IP46_TYPE_IP6)
15986 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
15987 vat_json_object_add_ip6 (node, "next_hop", ip6);
15993 api_ip6_fib_dump (vat_main_t * vam)
15995 vl_api_ip6_fib_dump_t *mp;
15996 vl_api_control_ping_t *mp_ping;
15999 M (IP6_FIB_DUMP, mp);
16002 /* Use a control ping for synchronization */
16003 M (CONTROL_PING, mp_ping);
16011 api_classify_table_ids (vat_main_t * vam)
16013 vl_api_classify_table_ids_t *mp;
16016 /* Construct the API message */
16017 M (CLASSIFY_TABLE_IDS, mp);
16026 api_classify_table_by_interface (vat_main_t * vam)
16028 unformat_input_t *input = vam->input;
16029 vl_api_classify_table_by_interface_t *mp;
16031 u32 sw_if_index = ~0;
16033 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16035 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16037 else if (unformat (input, "sw_if_index %d", &sw_if_index))
16042 if (sw_if_index == ~0)
16044 errmsg ("missing interface name or sw_if_index");
16048 /* Construct the API message */
16049 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
16051 mp->sw_if_index = ntohl (sw_if_index);
16059 api_classify_table_info (vat_main_t * vam)
16061 unformat_input_t *input = vam->input;
16062 vl_api_classify_table_info_t *mp;
16066 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16068 if (unformat (input, "table_id %d", &table_id))
16073 if (table_id == ~0)
16075 errmsg ("missing table id");
16079 /* Construct the API message */
16080 M (CLASSIFY_TABLE_INFO, mp);
16082 mp->table_id = ntohl (table_id);
16090 api_classify_session_dump (vat_main_t * vam)
16092 unformat_input_t *input = vam->input;
16093 vl_api_classify_session_dump_t *mp;
16094 vl_api_control_ping_t *mp_ping;
16098 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16100 if (unformat (input, "table_id %d", &table_id))
16105 if (table_id == ~0)
16107 errmsg ("missing table id");
16111 /* Construct the API message */
16112 M (CLASSIFY_SESSION_DUMP, mp);
16114 mp->table_id = ntohl (table_id);
16117 /* Use a control ping for synchronization */
16118 M (CONTROL_PING, mp_ping);
16126 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
16128 vat_main_t *vam = &vat_main;
16130 print (vam->ofp, "collector_address %U, collector_port %d, "
16131 "src_address %U, vrf_id %d, path_mtu %u, "
16132 "template_interval %u, udp_checksum %d",
16133 format_ip4_address, mp->collector_address,
16134 ntohs (mp->collector_port),
16135 format_ip4_address, mp->src_address,
16136 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
16137 ntohl (mp->template_interval), mp->udp_checksum);
16140 vam->result_ready = 1;
16144 vl_api_ipfix_exporter_details_t_handler_json
16145 (vl_api_ipfix_exporter_details_t * mp)
16147 vat_main_t *vam = &vat_main;
16148 vat_json_node_t node;
16149 struct in_addr collector_address;
16150 struct in_addr src_address;
16152 vat_json_init_object (&node);
16153 clib_memcpy (&collector_address, &mp->collector_address,
16154 sizeof (collector_address));
16155 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
16156 vat_json_object_add_uint (&node, "collector_port",
16157 ntohs (mp->collector_port));
16158 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
16159 vat_json_object_add_ip4 (&node, "src_address", src_address);
16160 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
16161 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
16162 vat_json_object_add_uint (&node, "template_interval",
16163 ntohl (mp->template_interval));
16164 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
16166 vat_json_print (vam->ofp, &node);
16167 vat_json_free (&node);
16169 vam->result_ready = 1;
16173 api_ipfix_exporter_dump (vat_main_t * vam)
16175 vl_api_ipfix_exporter_dump_t *mp;
16178 /* Construct the API message */
16179 M (IPFIX_EXPORTER_DUMP, mp);
16188 api_ipfix_classify_stream_dump (vat_main_t * vam)
16190 vl_api_ipfix_classify_stream_dump_t *mp;
16193 /* Construct the API message */
16194 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
16205 vl_api_ipfix_classify_stream_details_t_handler
16206 (vl_api_ipfix_classify_stream_details_t * mp)
16208 vat_main_t *vam = &vat_main;
16209 print (vam->ofp, "domain_id %d, src_port %d",
16210 ntohl (mp->domain_id), ntohs (mp->src_port));
16212 vam->result_ready = 1;
16216 vl_api_ipfix_classify_stream_details_t_handler_json
16217 (vl_api_ipfix_classify_stream_details_t * mp)
16219 vat_main_t *vam = &vat_main;
16220 vat_json_node_t node;
16222 vat_json_init_object (&node);
16223 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
16224 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
16226 vat_json_print (vam->ofp, &node);
16227 vat_json_free (&node);
16229 vam->result_ready = 1;
16233 api_ipfix_classify_table_dump (vat_main_t * vam)
16235 vl_api_ipfix_classify_table_dump_t *mp;
16236 vl_api_control_ping_t *mp_ping;
16239 if (!vam->json_output)
16241 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
16242 "transport_protocol");
16245 /* Construct the API message */
16246 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
16251 /* Use a control ping for synchronization */
16252 M (CONTROL_PING, mp_ping);
16260 vl_api_ipfix_classify_table_details_t_handler
16261 (vl_api_ipfix_classify_table_details_t * mp)
16263 vat_main_t *vam = &vat_main;
16264 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
16265 mp->transport_protocol);
16269 vl_api_ipfix_classify_table_details_t_handler_json
16270 (vl_api_ipfix_classify_table_details_t * mp)
16272 vat_json_node_t *node = NULL;
16273 vat_main_t *vam = &vat_main;
16275 if (VAT_JSON_ARRAY != vam->json_tree.type)
16277 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16278 vat_json_init_array (&vam->json_tree);
16281 node = vat_json_array_add (&vam->json_tree);
16282 vat_json_init_object (node);
16284 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
16285 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
16286 vat_json_object_add_uint (node, "transport_protocol",
16287 mp->transport_protocol);
16291 api_sw_interface_span_enable_disable (vat_main_t * vam)
16293 unformat_input_t *i = vam->input;
16294 vl_api_sw_interface_span_enable_disable_t *mp;
16295 u32 src_sw_if_index = ~0;
16296 u32 dst_sw_if_index = ~0;
16300 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16303 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
16305 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
16309 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
16311 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
16313 else if (unformat (i, "disable"))
16315 else if (unformat (i, "rx"))
16317 else if (unformat (i, "tx"))
16319 else if (unformat (i, "both"))
16325 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
16327 mp->sw_if_index_from = htonl (src_sw_if_index);
16328 mp->sw_if_index_to = htonl (dst_sw_if_index);
16337 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
16340 vat_main_t *vam = &vat_main;
16341 u8 *sw_if_from_name = 0;
16342 u8 *sw_if_to_name = 0;
16343 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
16344 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
16345 char *states[] = { "none", "rx", "tx", "both" };
16349 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
16351 if ((u32) p->value[0] == sw_if_index_from)
16353 sw_if_from_name = (u8 *)(p->key);
16357 if ((u32) p->value[0] == sw_if_index_to)
16359 sw_if_to_name = (u8 *)(p->key);
16360 if (sw_if_from_name)
16365 print (vam->ofp, "%20s => %20s (%s)",
16366 sw_if_from_name, sw_if_to_name, states[mp->state]);
16370 vl_api_sw_interface_span_details_t_handler_json
16371 (vl_api_sw_interface_span_details_t * mp)
16373 vat_main_t *vam = &vat_main;
16374 vat_json_node_t *node = NULL;
16375 u8 *sw_if_from_name = 0;
16376 u8 *sw_if_to_name = 0;
16377 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
16378 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
16382 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
16384 if ((u32) p->value[0] == sw_if_index_from)
16386 sw_if_from_name = (u8 *)(p->key);
16390 if ((u32) p->value[0] == sw_if_index_to)
16392 sw_if_to_name = (u8 *)(p->key);
16393 if (sw_if_from_name)
16399 if (VAT_JSON_ARRAY != vam->json_tree.type)
16401 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16402 vat_json_init_array (&vam->json_tree);
16404 node = vat_json_array_add (&vam->json_tree);
16406 vat_json_init_object (node);
16407 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
16408 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
16409 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
16410 if (0 != sw_if_to_name)
16412 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
16414 vat_json_object_add_uint (node, "state", mp->state);
16418 api_sw_interface_span_dump (vat_main_t * vam)
16420 vl_api_sw_interface_span_dump_t *mp;
16421 vl_api_control_ping_t *mp_ping;
16424 M (SW_INTERFACE_SPAN_DUMP, mp);
16427 /* Use a control ping for synchronization */
16428 M (CONTROL_PING, mp_ping);
16436 api_pg_create_interface (vat_main_t * vam)
16438 unformat_input_t *input = vam->input;
16439 vl_api_pg_create_interface_t *mp;
16443 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16445 if (unformat (input, "if_id %d", &if_id))
16452 errmsg ("missing pg interface index");
16456 /* Construct the API message */
16457 M (PG_CREATE_INTERFACE, mp);
16459 mp->interface_id = ntohl (if_id);
16467 api_pg_capture (vat_main_t * vam)
16469 unformat_input_t *input = vam->input;
16470 vl_api_pg_capture_t *mp;
16475 u8 pcap_file_set = 0;
16478 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16480 if (unformat (input, "if_id %d", &if_id))
16482 else if (unformat (input, "pcap %s", &pcap_file))
16484 else if (unformat (input, "count %d", &count))
16486 else if (unformat (input, "disable"))
16493 errmsg ("missing pg interface index");
16496 if (pcap_file_set > 0)
16498 if (vec_len (pcap_file) > 255)
16500 errmsg ("pcap file name is too long");
16505 u32 name_len = vec_len (pcap_file);
16506 /* Construct the API message */
16507 M (PG_CAPTURE, mp);
16509 mp->interface_id = ntohl (if_id);
16510 mp->is_enabled = enable;
16511 mp->count = ntohl (count);
16512 mp->pcap_name_length = ntohl (name_len);
16513 if (pcap_file_set != 0)
16515 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
16517 vec_free (pcap_file);
16525 api_pg_enable_disable (vat_main_t * vam)
16527 unformat_input_t *input = vam->input;
16528 vl_api_pg_enable_disable_t *mp;
16531 u8 stream_name_set = 0;
16532 u8 *stream_name = 0;
16534 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16536 if (unformat (input, "stream %s", &stream_name))
16537 stream_name_set = 1;
16538 else if (unformat (input, "disable"))
16544 if (stream_name_set > 0)
16546 if (vec_len (stream_name) > 255)
16548 errmsg ("stream name too long");
16553 u32 name_len = vec_len (stream_name);
16554 /* Construct the API message */
16555 M (PG_ENABLE_DISABLE, mp);
16557 mp->is_enabled = enable;
16558 if (stream_name_set != 0)
16560 mp->stream_name_length = ntohl (name_len);
16561 clib_memcpy (mp->stream_name, stream_name, name_len);
16563 vec_free (stream_name);
16571 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
16573 unformat_input_t *input = vam->input;
16574 vl_api_ip_source_and_port_range_check_add_del_t *mp;
16576 u16 *low_ports = 0;
16577 u16 *high_ports = 0;
16580 ip4_address_t ip4_addr;
16581 ip6_address_t ip6_addr;
16590 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16592 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
16598 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
16603 else if (unformat (input, "vrf %d", &vrf_id))
16605 else if (unformat (input, "del"))
16607 else if (unformat (input, "port %d", &tmp))
16609 if (tmp == 0 || tmp > 65535)
16611 errmsg ("port %d out of range", tmp);
16615 this_hi = this_low + 1;
16616 vec_add1 (low_ports, this_low);
16617 vec_add1 (high_ports, this_hi);
16619 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
16621 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
16623 errmsg ("incorrect range parameters");
16627 /* Note: in debug CLI +1 is added to high before
16628 passing to real fn that does "the work"
16629 (ip_source_and_port_range_check_add_del).
16630 This fn is a wrapper around the binary API fn a
16631 control plane will call, which expects this increment
16632 to have occurred. Hence letting the binary API control
16633 plane fn do the increment for consistency between VAT
16634 and other control planes.
16637 vec_add1 (low_ports, this_low);
16638 vec_add1 (high_ports, this_hi);
16644 if (prefix_set == 0)
16646 errmsg ("<address>/<mask> not specified");
16652 errmsg ("VRF ID required, not specified");
16659 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
16663 if (vec_len (low_ports) == 0)
16665 errmsg ("At least one port or port range required");
16669 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
16671 mp->is_add = is_add;
16676 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
16681 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
16684 mp->mask_length = length;
16685 mp->number_of_ranges = vec_len (low_ports);
16687 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
16688 vec_free (low_ports);
16690 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
16691 vec_free (high_ports);
16693 mp->vrf_id = ntohl (vrf_id);
16701 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
16703 unformat_input_t *input = vam->input;
16704 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
16705 u32 sw_if_index = ~0;
16707 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
16708 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
16712 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16714 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16716 else if (unformat (input, "sw_if_index %d", &sw_if_index))
16718 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
16720 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
16722 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
16724 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
16726 else if (unformat (input, "del"))
16732 if (sw_if_index == ~0)
16734 errmsg ("Interface required but not specified");
16740 errmsg ("VRF ID required but not specified");
16744 if (tcp_out_vrf_id == 0
16745 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
16748 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
16752 /* Construct the API message */
16753 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
16755 mp->sw_if_index = ntohl (sw_if_index);
16756 mp->is_add = is_add;
16757 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
16758 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
16759 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
16760 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
16765 /* Wait for a reply... */
16771 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
16773 unformat_input_t *i = vam->input;
16774 vl_api_ipsec_gre_add_del_tunnel_t *mp;
16775 u32 local_sa_id = 0;
16776 u32 remote_sa_id = 0;
16777 ip4_address_t src_address;
16778 ip4_address_t dst_address;
16782 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16784 if (unformat (i, "local_sa %d", &local_sa_id))
16786 else if (unformat (i, "remote_sa %d", &remote_sa_id))
16788 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
16790 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
16792 else if (unformat (i, "del"))
16796 clib_warning ("parse error '%U'", format_unformat_error, i);
16801 M (IPSEC_GRE_ADD_DEL_TUNNEL, mp);
16803 mp->local_sa_id = ntohl (local_sa_id);
16804 mp->remote_sa_id = ntohl (remote_sa_id);
16805 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
16806 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
16807 mp->is_add = is_add;
16815 api_punt (vat_main_t * vam)
16817 unformat_input_t *i = vam->input;
16825 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16827 if (unformat (i, "ip %d", &ipv))
16829 else if (unformat (i, "protocol %d", &protocol))
16831 else if (unformat (i, "port %d", &port))
16833 else if (unformat (i, "del"))
16837 clib_warning ("parse error '%U'", format_unformat_error, i);
16844 mp->is_add = (u8) is_add;
16845 mp->ipv = (u8) ipv;
16846 mp->l4_protocol = (u8) protocol;
16847 mp->l4_port = htons ((u16) port);
16854 static void vl_api_ipsec_gre_tunnel_details_t_handler
16855 (vl_api_ipsec_gre_tunnel_details_t * mp)
16857 vat_main_t *vam = &vat_main;
16859 print (vam->ofp, "%11d%15U%15U%14d%14d",
16860 ntohl (mp->sw_if_index),
16861 format_ip4_address, &mp->src_address,
16862 format_ip4_address, &mp->dst_address,
16863 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
16866 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
16867 (vl_api_ipsec_gre_tunnel_details_t * mp)
16869 vat_main_t *vam = &vat_main;
16870 vat_json_node_t *node = NULL;
16871 struct in_addr ip4;
16873 if (VAT_JSON_ARRAY != vam->json_tree.type)
16875 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16876 vat_json_init_array (&vam->json_tree);
16878 node = vat_json_array_add (&vam->json_tree);
16880 vat_json_init_object (node);
16881 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
16882 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
16883 vat_json_object_add_ip4 (node, "src_address", ip4);
16884 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
16885 vat_json_object_add_ip4 (node, "dst_address", ip4);
16886 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
16887 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
16891 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
16893 unformat_input_t *i = vam->input;
16894 vl_api_ipsec_gre_tunnel_dump_t *mp;
16895 vl_api_control_ping_t *mp_ping;
16897 u8 sw_if_index_set = 0;
16900 /* Parse args required to build the message */
16901 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16903 if (unformat (i, "sw_if_index %d", &sw_if_index))
16904 sw_if_index_set = 1;
16909 if (sw_if_index_set == 0)
16914 if (!vam->json_output)
16916 print (vam->ofp, "%11s%15s%15s%14s%14s",
16917 "sw_if_index", "src_address", "dst_address",
16918 "local_sa_id", "remote_sa_id");
16921 /* Get list of gre-tunnel interfaces */
16922 M (IPSEC_GRE_TUNNEL_DUMP, mp);
16924 mp->sw_if_index = htonl (sw_if_index);
16928 /* Use a control ping for synchronization */
16929 M (CONTROL_PING, mp_ping);
16937 api_delete_subif (vat_main_t * vam)
16939 unformat_input_t *i = vam->input;
16940 vl_api_delete_subif_t *mp;
16941 u32 sw_if_index = ~0;
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 if (unformat (i, "sw_if_index %d", &sw_if_index))
16954 if (sw_if_index == ~0)
16956 errmsg ("missing sw_if_index");
16960 /* Construct the API message */
16961 M (DELETE_SUBIF, mp);
16962 mp->sw_if_index = ntohl (sw_if_index);
16969 #define foreach_pbb_vtr_op \
16970 _("disable", L2_VTR_DISABLED) \
16971 _("pop", L2_VTR_POP_2) \
16972 _("push", L2_VTR_PUSH_2)
16975 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
16977 unformat_input_t *i = vam->input;
16978 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
16979 u32 sw_if_index = ~0, vtr_op = ~0;
16980 u16 outer_tag = ~0;
16981 u8 dmac[6], smac[6];
16982 u8 dmac_set = 0, smac_set = 0;
16988 /* Shut up coverity */
16989 memset (dmac, 0, sizeof (dmac));
16990 memset (smac, 0, sizeof (smac));
16992 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16994 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16996 else if (unformat (i, "sw_if_index %d", &sw_if_index))
16998 else if (unformat (i, "vtr_op %d", &vtr_op))
17000 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
17003 else if (unformat (i, "translate_pbb_stag"))
17005 if (unformat (i, "%d", &tmp))
17007 vtr_op = L2_VTR_TRANSLATE_2_1;
17013 ("translate_pbb_stag operation requires outer tag definition");
17017 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
17019 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
17021 else if (unformat (i, "sid %d", &sid))
17023 else if (unformat (i, "vlanid %d", &tmp))
17027 clib_warning ("parse error '%U'", format_unformat_error, i);
17032 if ((sw_if_index == ~0) || (vtr_op == ~0))
17034 errmsg ("missing sw_if_index or vtr operation");
17037 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
17038 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
17041 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
17045 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
17046 mp->sw_if_index = ntohl (sw_if_index);
17047 mp->vtr_op = ntohl (vtr_op);
17048 mp->outer_tag = ntohs (outer_tag);
17049 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
17050 clib_memcpy (mp->b_smac, smac, sizeof (smac));
17051 mp->b_vlanid = ntohs (vlanid);
17052 mp->i_sid = ntohl (sid);
17060 api_flow_classify_set_interface (vat_main_t * vam)
17062 unformat_input_t *i = vam->input;
17063 vl_api_flow_classify_set_interface_t *mp;
17065 int sw_if_index_set;
17066 u32 ip4_table_index = ~0;
17067 u32 ip6_table_index = ~0;
17071 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17073 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17074 sw_if_index_set = 1;
17075 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17076 sw_if_index_set = 1;
17077 else if (unformat (i, "del"))
17079 else if (unformat (i, "ip4-table %d", &ip4_table_index))
17081 else if (unformat (i, "ip6-table %d", &ip6_table_index))
17085 clib_warning ("parse error '%U'", format_unformat_error, i);
17090 if (sw_if_index_set == 0)
17092 errmsg ("missing interface name or sw_if_index");
17096 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
17098 mp->sw_if_index = ntohl (sw_if_index);
17099 mp->ip4_table_index = ntohl (ip4_table_index);
17100 mp->ip6_table_index = ntohl (ip6_table_index);
17101 mp->is_add = is_add;
17109 api_flow_classify_dump (vat_main_t * vam)
17111 unformat_input_t *i = vam->input;
17112 vl_api_flow_classify_dump_t *mp;
17113 vl_api_control_ping_t *mp_ping;
17114 u8 type = FLOW_CLASSIFY_N_TABLES;
17117 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
17121 errmsg ("classify table type must be specified");
17125 if (!vam->json_output)
17127 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
17130 M (FLOW_CLASSIFY_DUMP, mp);
17135 /* Use a control ping for synchronization */
17136 M (CONTROL_PING, mp_ping);
17139 /* Wait for a reply... */
17145 api_feature_enable_disable (vat_main_t * vam)
17147 unformat_input_t *i = vam->input;
17148 vl_api_feature_enable_disable_t *mp;
17150 u8 *feature_name = 0;
17151 u32 sw_if_index = ~0;
17155 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17157 if (unformat (i, "arc_name %s", &arc_name))
17159 else if (unformat (i, "feature_name %s", &feature_name))
17162 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17164 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17166 else if (unformat (i, "disable"))
17174 errmsg ("missing arc name");
17177 if (vec_len (arc_name) > 63)
17179 errmsg ("arc name too long");
17182 if (feature_name == 0)
17184 errmsg ("missing feature name");
17187 if (vec_len (feature_name) > 63)
17189 errmsg ("feature name too long");
17192 if (sw_if_index == ~0)
17194 errmsg ("missing interface name or sw_if_index");
17198 /* Construct the API message */
17199 M (FEATURE_ENABLE_DISABLE, mp);
17200 mp->sw_if_index = ntohl (sw_if_index);
17201 mp->enable = enable;
17202 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
17203 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
17204 vec_free (arc_name);
17205 vec_free (feature_name);
17213 api_sw_interface_tag_add_del (vat_main_t * vam)
17215 unformat_input_t *i = vam->input;
17216 vl_api_sw_interface_tag_add_del_t *mp;
17217 u32 sw_if_index = ~0;
17222 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17224 if (unformat (i, "tag %s", &tag))
17226 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17228 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17230 else if (unformat (i, "del"))
17236 if (sw_if_index == ~0)
17238 errmsg ("missing interface name or sw_if_index");
17242 if (enable && (tag == 0))
17244 errmsg ("no tag specified");
17248 /* Construct the API message */
17249 M (SW_INTERFACE_TAG_ADD_DEL, mp);
17250 mp->sw_if_index = ntohl (sw_if_index);
17251 mp->is_add = enable;
17253 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
17261 static void vl_api_l2_xconnect_details_t_handler
17262 (vl_api_l2_xconnect_details_t * mp)
17264 vat_main_t *vam = &vat_main;
17266 print (vam->ofp, "%15d%15d",
17267 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
17270 static void vl_api_l2_xconnect_details_t_handler_json
17271 (vl_api_l2_xconnect_details_t * mp)
17273 vat_main_t *vam = &vat_main;
17274 vat_json_node_t *node = NULL;
17276 if (VAT_JSON_ARRAY != vam->json_tree.type)
17278 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17279 vat_json_init_array (&vam->json_tree);
17281 node = vat_json_array_add (&vam->json_tree);
17283 vat_json_init_object (node);
17284 vat_json_object_add_uint (node, "rx_sw_if_index",
17285 ntohl (mp->rx_sw_if_index));
17286 vat_json_object_add_uint (node, "tx_sw_if_index",
17287 ntohl (mp->tx_sw_if_index));
17291 api_l2_xconnect_dump (vat_main_t * vam)
17293 vl_api_l2_xconnect_dump_t *mp;
17294 vl_api_control_ping_t *mp_ping;
17297 if (!vam->json_output)
17299 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
17302 M (L2_XCONNECT_DUMP, mp);
17306 /* Use a control ping for synchronization */
17307 M (CONTROL_PING, mp_ping);
17315 api_sw_interface_set_mtu (vat_main_t * vam)
17317 unformat_input_t *i = vam->input;
17318 vl_api_sw_interface_set_mtu_t *mp;
17319 u32 sw_if_index = ~0;
17323 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17325 if (unformat (i, "mtu %d", &mtu))
17327 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17329 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17335 if (sw_if_index == ~0)
17337 errmsg ("missing interface name or sw_if_index");
17343 errmsg ("no mtu specified");
17347 /* Construct the API message */
17348 M (SW_INTERFACE_SET_MTU, mp);
17349 mp->sw_if_index = ntohl (sw_if_index);
17350 mp->mtu = ntohs ((u16) mtu);
17359 q_or_quit (vat_main_t * vam)
17361 longjmp (vam->jump_buf, 1);
17362 return 0; /* not so much */
17366 q (vat_main_t * vam)
17368 return q_or_quit (vam);
17372 quit (vat_main_t * vam)
17374 return q_or_quit (vam);
17378 comment (vat_main_t * vam)
17384 cmd_cmp (void *a1, void *a2)
17389 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
17393 help (vat_main_t * vam)
17398 unformat_input_t *i = vam->input;
17401 if (unformat (i, "%s", &name))
17405 vec_add1 (name, 0);
17407 hs = hash_get_mem (vam->help_by_name, name);
17409 print (vam->ofp, "usage: %s %s", name, hs[0]);
17411 print (vam->ofp, "No such msg / command '%s'", name);
17416 print (vam->ofp, "Help is available for the following:");
17419 hash_foreach_pair (p, vam->function_by_name,
17421 vec_add1 (cmds, (u8 *)(p->key));
17425 vec_sort_with_function (cmds, cmd_cmp);
17427 for (j = 0; j < vec_len (cmds); j++)
17428 print (vam->ofp, "%s", cmds[j]);
17435 set (vat_main_t * vam)
17437 u8 *name = 0, *value = 0;
17438 unformat_input_t *i = vam->input;
17440 if (unformat (i, "%s", &name))
17442 /* The input buffer is a vector, not a string. */
17443 value = vec_dup (i->buffer);
17444 vec_delete (value, i->index, 0);
17445 /* Almost certainly has a trailing newline */
17446 if (value[vec_len (value) - 1] == '\n')
17447 value[vec_len (value) - 1] = 0;
17448 /* Make sure it's a proper string, one way or the other */
17449 vec_add1 (value, 0);
17450 (void) clib_macro_set_value (&vam->macro_main,
17451 (char *) name, (char *) value);
17454 errmsg ("usage: set <name> <value>");
17462 unset (vat_main_t * vam)
17466 if (unformat (vam->input, "%s", &name))
17467 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
17468 errmsg ("unset: %s wasn't set", name);
17481 macro_sort_cmp (void *a1, void *a2)
17483 macro_sort_t *s1 = a1;
17484 macro_sort_t *s2 = a2;
17486 return strcmp ((char *) (s1->name), (char *) (s2->name));
17490 dump_macro_table (vat_main_t * vam)
17492 macro_sort_t *sort_me = 0, *sm;
17497 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
17499 vec_add2 (sort_me, sm, 1);
17500 sm->name = (u8 *)(p->key);
17501 sm->value = (u8 *) (p->value[0]);
17505 vec_sort_with_function (sort_me, macro_sort_cmp);
17507 if (vec_len (sort_me))
17508 print (vam->ofp, "%-15s%s", "Name", "Value");
17510 print (vam->ofp, "The macro table is empty...");
17512 for (i = 0; i < vec_len (sort_me); i++)
17513 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
17518 dump_node_table (vat_main_t * vam)
17521 vlib_node_t *node, *next_node;
17523 if (vec_len (vam->graph_nodes) == 0)
17525 print (vam->ofp, "Node table empty, issue get_node_graph...");
17529 for (i = 0; i < vec_len (vam->graph_nodes); i++)
17531 node = vam->graph_nodes[i];
17532 print (vam->ofp, "[%d] %s", i, node->name);
17533 for (j = 0; j < vec_len (node->next_nodes); j++)
17535 if (node->next_nodes[j] != ~0)
17537 next_node = vam->graph_nodes[node->next_nodes[j]];
17538 print (vam->ofp, " [%d] %s", j, next_node->name);
17546 value_sort_cmp (void *a1, void *a2)
17548 name_sort_t *n1 = a1;
17549 name_sort_t *n2 = a2;
17551 if (n1->value < n2->value)
17553 if (n1->value > n2->value)
17560 dump_msg_api_table (vat_main_t * vam)
17562 api_main_t *am = &api_main;
17563 name_sort_t *nses = 0, *ns;
17568 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
17570 vec_add2 (nses, ns, 1);
17571 ns->name = (u8 *)(hp->key);
17572 ns->value = (u32) hp->value[0];
17576 vec_sort_with_function (nses, value_sort_cmp);
17578 for (i = 0; i < vec_len (nses); i++)
17579 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
17585 get_msg_id (vat_main_t * vam)
17590 if (unformat (vam->input, "%s", &name_and_crc))
17592 message_index = vl_api_get_msg_index (name_and_crc);
17593 if (message_index == ~0)
17595 print (vam->ofp, " '%s' not found", name_and_crc);
17598 print (vam->ofp, " '%s' has message index %d",
17599 name_and_crc, message_index);
17602 errmsg ("name_and_crc required...");
17607 search_node_table (vat_main_t * vam)
17609 unformat_input_t *line_input = vam->input;
17612 vlib_node_t *node, *next_node;
17615 if (vam->graph_node_index_by_name == 0)
17617 print (vam->ofp, "Node table empty, issue get_node_graph...");
17621 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
17623 if (unformat (line_input, "%s", &node_to_find))
17625 vec_add1 (node_to_find, 0);
17626 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
17629 print (vam->ofp, "%s not found...", node_to_find);
17632 node = vam->graph_nodes[p[0]];
17633 print (vam->ofp, "[%d] %s", p[0], node->name);
17634 for (j = 0; j < vec_len (node->next_nodes); j++)
17636 if (node->next_nodes[j] != ~0)
17638 next_node = vam->graph_nodes[node->next_nodes[j]];
17639 print (vam->ofp, " [%d] %s", j, next_node->name);
17646 clib_warning ("parse error '%U'", format_unformat_error,
17652 vec_free (node_to_find);
17661 script (vat_main_t * vam)
17663 #if (VPP_API_TEST_BUILTIN==0)
17665 char *save_current_file;
17666 unformat_input_t save_input;
17667 jmp_buf save_jump_buf;
17668 u32 save_line_number;
17670 FILE *new_fp, *save_ifp;
17672 if (unformat (vam->input, "%s", &s))
17674 new_fp = fopen ((char *) s, "r");
17677 errmsg ("Couldn't open script file %s", s);
17684 errmsg ("Missing script name");
17688 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
17689 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
17690 save_ifp = vam->ifp;
17691 save_line_number = vam->input_line_number;
17692 save_current_file = (char *) vam->current_file;
17694 vam->input_line_number = 0;
17696 vam->current_file = s;
17699 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
17700 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
17701 vam->ifp = save_ifp;
17702 vam->input_line_number = save_line_number;
17703 vam->current_file = (u8 *) save_current_file;
17708 clib_warning ("use the exec command...");
17714 echo (vat_main_t * vam)
17716 print (vam->ofp, "%v", vam->input->buffer);
17720 /* List of API message constructors, CLI names map to api_xxx */
17721 #define foreach_vpe_api_msg \
17722 _(create_loopback,"[mac <mac-addr>]") \
17723 _(sw_interface_dump,"") \
17724 _(sw_interface_set_flags, \
17725 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
17726 _(sw_interface_add_del_address, \
17727 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
17728 _(sw_interface_set_table, \
17729 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
17730 _(sw_interface_set_mpls_enable, \
17731 "<intfc> | sw_if_index [disable | dis]") \
17732 _(sw_interface_set_vpath, \
17733 "<intfc> | sw_if_index <id> enable | disable") \
17734 _(sw_interface_set_vxlan_bypass, \
17735 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
17736 _(sw_interface_set_l2_xconnect, \
17737 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
17738 "enable | disable") \
17739 _(sw_interface_set_l2_bridge, \
17740 "<intfc> | sw_if_index <id> bd_id <bridge-domain-id>\n" \
17741 "[shg <split-horizon-group>] [bvi]\n" \
17742 "enable | disable") \
17743 _(bridge_domain_add_del, \
17744 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n") \
17745 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
17747 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
17749 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
17751 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
17753 "tapname <name> mac <mac-addr> | random-mac [tag <string>]") \
17755 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
17757 "<vpp-if-name> | sw_if_index <id>") \
17758 _(sw_interface_tap_dump, "") \
17759 _(ip_add_del_route, \
17760 "<addr>/<mask> via <addr> [table-id <n>]\n" \
17761 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
17762 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
17763 "[multipath] [count <n>]") \
17764 _(ip_mroute_add_del, \
17765 "<src> <grp>/<mask> [table-id <n>]\n" \
17766 "[<intfc> | sw_if_index <id>] [local] [del]") \
17767 _(mpls_route_add_del, \
17768 "<label> <eos> via <addr> [table-id <n>]\n" \
17769 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
17770 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
17771 "[multipath] [count <n>]") \
17772 _(mpls_ip_bind_unbind, \
17773 "<label> <addr/len>") \
17774 _(mpls_tunnel_add_del, \
17775 " via <addr> [table-id <n>]\n" \
17776 "sw_if_index <id>] [l2] [del]") \
17777 _(proxy_arp_add_del, \
17778 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
17779 _(proxy_arp_intfc_enable_disable, \
17780 "<intfc> | sw_if_index <id> enable | disable") \
17781 _(sw_interface_set_unnumbered, \
17782 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
17783 _(ip_neighbor_add_del, \
17784 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
17785 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
17786 _(reset_vrf, "vrf <id> [ipv6]") \
17787 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
17788 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
17789 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
17790 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
17791 "[outer_vlan_id_any][inner_vlan_id_any]") \
17792 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
17793 _(reset_fib, "vrf <n> [ipv6]") \
17794 _(dhcp_proxy_config, \
17795 "svr <v46-address> src <v46-address>\n" \
17796 "insert-cid <n> [del]") \
17797 _(dhcp_proxy_config_2, \
17798 "svr <v46-address> src <v46-address>\n" \
17799 "rx_vrf_id <nn> server_vrf_id <nn> insert-cid <n> [del]") \
17800 _(dhcp_proxy_set_vss, \
17801 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
17802 _(dhcp_client_config, \
17803 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
17804 _(set_ip_flow_hash, \
17805 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
17806 _(sw_interface_ip6_enable_disable, \
17807 "<intfc> | sw_if_index <id> enable | disable") \
17808 _(sw_interface_ip6_set_link_local_address, \
17809 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
17810 _(sw_interface_ip6nd_ra_prefix, \
17811 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
17812 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
17813 "[nolink] [isno]") \
17814 _(sw_interface_ip6nd_ra_config, \
17815 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
17816 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
17817 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
17818 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
17819 _(l2_patch_add_del, \
17820 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
17821 "enable | disable") \
17822 _(sr_tunnel_add_del, \
17823 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
17824 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
17825 "[policy <policy_name>]") \
17826 _(sr_policy_add_del, \
17827 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
17828 _(sr_multicast_map_add_del, \
17829 "address [ip6 multicast address] sr-policy [policy name] [del]") \
17830 _(classify_add_del_table, \
17831 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
17832 " [del] [del-chain] mask <mask-value>\n" \
17833 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
17834 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
17835 _(classify_add_del_session, \
17836 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
17837 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
17838 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
17839 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
17840 _(classify_set_interface_ip_table, \
17841 "<intfc> | sw_if_index <nn> table <nn>") \
17842 _(classify_set_interface_l2_tables, \
17843 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
17844 " [other-table <nn>]") \
17845 _(get_node_index, "node <node-name") \
17846 _(add_node_next, "node <node-name> next <next-node-name>") \
17847 _(l2tpv3_create_tunnel, \
17848 "client_address <ip6-addr> our_address <ip6-addr>\n" \
17849 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
17850 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
17851 _(l2tpv3_set_tunnel_cookies, \
17852 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
17853 "[new_remote_cookie <nn>]\n") \
17854 _(l2tpv3_interface_enable_disable, \
17855 "<intfc> | sw_if_index <nn> enable | disable") \
17856 _(l2tpv3_set_lookup_key, \
17857 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
17858 _(sw_if_l2tpv3_tunnel_dump, "") \
17859 _(vxlan_add_del_tunnel, \
17860 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
17861 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
17862 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
17863 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
17864 _(gre_add_del_tunnel, \
17865 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [teb] [del]\n") \
17866 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
17867 _(l2_fib_clear_table, "") \
17868 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
17869 _(l2_interface_vlan_tag_rewrite, \
17870 "<intfc> | sw_if_index <nn> \n" \
17871 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
17872 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
17873 _(create_vhost_user_if, \
17874 "socket <filename> [server] [renumber <dev_instance>] " \
17875 "[mac <mac_address>]") \
17876 _(modify_vhost_user_if, \
17877 "<intfc> | sw_if_index <nn> socket <filename>\n" \
17878 "[server] [renumber <dev_instance>]") \
17879 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
17880 _(sw_interface_vhost_user_dump, "") \
17881 _(show_version, "") \
17882 _(vxlan_gpe_add_del_tunnel, \
17883 "local <addr> remote <addr> vni <nn>\n" \
17884 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
17885 "[next-ethernet] [next-nsh]\n") \
17886 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
17887 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
17888 _(interface_name_renumber, \
17889 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
17890 _(input_acl_set_interface, \
17891 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
17892 " [l2-table <nn>] [del]") \
17893 _(want_ip4_arp_events, "address <ip4-address> [del]") \
17894 _(want_ip6_nd_events, "address <ip6-address> [del]") \
17895 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
17896 _(ip_dump, "ipv4 | ipv6") \
17897 _(ipsec_spd_add_del, "spd_id <n> [del]") \
17898 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
17900 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
17901 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
17902 " integ_alg <alg> integ_key <hex>") \
17903 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
17904 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
17905 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
17906 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
17907 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
17908 _(ikev2_profile_add_del, "name <profile_name> [del]") \
17909 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
17910 "(auth_data 0x<data> | auth_data <data>)") \
17911 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
17912 "(id_data 0x<data> | id_data <data>) (local|remote)") \
17913 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
17914 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
17915 "(local|remote)") \
17916 _(ikev2_set_local_key, "file <absolute_file_path>") \
17917 _(delete_loopback,"sw_if_index <nn>") \
17918 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
17919 _(map_add_domain, \
17920 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
17921 "ip6-src <ip6addr> " \
17922 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
17923 _(map_del_domain, "index <n>") \
17924 _(map_add_del_rule, \
17925 "index <n> psid <n> dst <ip6addr> [del]") \
17926 _(map_domain_dump, "") \
17927 _(map_rule_dump, "index <map-domain>") \
17928 _(want_interface_events, "enable|disable") \
17929 _(want_stats,"enable|disable") \
17930 _(get_first_msg_id, "client <name>") \
17931 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
17932 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
17933 "fib-id <nn> [ip4][ip6][default]") \
17934 _(get_node_graph, " ") \
17935 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
17936 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
17937 _(ioam_disable, "") \
17938 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
17939 " sw_if_index <sw_if_index> p <priority> " \
17940 "w <weight>] [del]") \
17941 _(lisp_add_del_locator, "locator-set <locator_name> " \
17942 "iface <intf> | sw_if_index <sw_if_index> " \
17943 "p <priority> w <weight> [del]") \
17944 _(lisp_add_del_local_eid,"vni <vni> eid " \
17945 "<ipv4|ipv6>/<prefix> | <L2 address> " \
17946 "locator-set <locator_name> [del]" \
17947 "[key-id sha1|sha256 secret-key <secret-key>]") \
17948 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
17949 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
17950 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
17951 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
17952 _(lisp_gpe_enable_disable, "enable|disable") \
17953 _(lisp_enable_disable, "enable|disable") \
17954 _(lisp_map_register_enable_disable, "enable|disable") \
17955 _(lisp_rloc_probe_enable_disable, "enable|disable") \
17956 _(lisp_gpe_add_del_iface, "up|down") \
17957 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
17959 "rloc <locator> p <prio> " \
17960 "w <weight> [rloc <loc> ... ] " \
17961 "action <action> [del-all]") \
17962 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
17964 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
17965 _(lisp_map_request_mode, "src-dst|dst-only") \
17966 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
17967 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
17968 _(lisp_locator_set_dump, "[local | remote]") \
17969 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
17970 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
17971 "[local] | [remote]") \
17972 _(lisp_eid_table_vni_dump, "") \
17973 _(lisp_eid_table_map_dump, "l2|l3") \
17974 _(lisp_map_resolver_dump, "") \
17975 _(lisp_map_server_dump, "") \
17976 _(lisp_adjacencies_get, "vni <vni>") \
17977 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
17978 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
17979 _(show_lisp_rloc_probe_state, "") \
17980 _(show_lisp_map_register_state, "") \
17981 _(show_lisp_status, "") \
17982 _(lisp_get_map_request_itr_rlocs, "") \
17983 _(show_lisp_pitr, "") \
17984 _(show_lisp_map_request_mode, "") \
17985 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
17986 _(af_packet_delete, "name <host interface name>") \
17987 _(policer_add_del, "name <policer name> <params> [del]") \
17988 _(policer_dump, "[name <policer name>]") \
17989 _(policer_classify_set_interface, \
17990 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
17991 " [l2-table <nn>] [del]") \
17992 _(policer_classify_dump, "type [ip4|ip6|l2]") \
17993 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
17994 "[master|slave]") \
17995 _(netmap_delete, "name <interface name>") \
17996 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
17997 _(mpls_fib_dump, "") \
17998 _(classify_table_ids, "") \
17999 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
18000 _(classify_table_info, "table_id <nn>") \
18001 _(classify_session_dump, "table_id <nn>") \
18002 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
18003 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
18004 "[template_interval <nn>] [udp_checksum]") \
18005 _(ipfix_exporter_dump, "") \
18006 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
18007 _(ipfix_classify_stream_dump, "") \
18008 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
18009 _(ipfix_classify_table_dump, "") \
18010 _(sw_interface_span_enable_disable, "[src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
18011 _(sw_interface_span_dump, "") \
18012 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
18013 _(pg_create_interface, "if_id <nn>") \
18014 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
18015 _(pg_enable_disable, "[stream <id>] disable") \
18016 _(ip_source_and_port_range_check_add_del, \
18017 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
18018 _(ip_source_and_port_range_check_interface_add_del, \
18019 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
18020 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
18021 _(ipsec_gre_add_del_tunnel, \
18022 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
18023 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
18024 _(delete_subif,"<intfc> | sw_if_index <nn>") \
18025 _(l2_interface_pbb_tag_rewrite, \
18026 "<intfc> | sw_if_index <nn> \n" \
18027 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
18028 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
18029 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
18030 _(flow_classify_set_interface, \
18031 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
18032 _(flow_classify_dump, "type [ip4|ip6]") \
18033 _(ip_fib_dump, "") \
18034 _(ip6_fib_dump, "") \
18035 _(feature_enable_disable, "arc_name <arc_name> " \
18036 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
18037 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
18039 _(l2_xconnect_dump, "") \
18040 _(sw_interface_set_mtu, "<intfc> | sw_if_index <nn> mtu <nn>") \
18041 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
18042 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]")
18045 #define foreach_vpe_dpdk_api_msg \
18046 _(sw_interface_set_dpdk_hqos_pipe, \
18047 "rx <intfc> | sw_if_index <id> subport <subport-id> pipe <pipe-id>\n" \
18048 "profile <profile-id>\n") \
18049 _(sw_interface_set_dpdk_hqos_subport, \
18050 "rx <intfc> | sw_if_index <id> subport <subport-id> [rate <n>]\n" \
18051 "[bktsize <n>] [tc0 <n>] [tc1 <n>] [tc2 <n>] [tc3 <n>] [period <n>]\n") \
18052 _(sw_interface_set_dpdk_hqos_tctbl, \
18053 "rx <intfc> | sw_if_index <id> entry <n> tc <n> queue <n>\n")
18056 /* List of command functions, CLI names map directly to functions */
18057 #define foreach_cli_function \
18058 _(comment, "usage: comment <ignore-rest-of-line>") \
18059 _(dump_interface_table, "usage: dump_interface_table") \
18060 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
18061 _(dump_ipv4_table, "usage: dump_ipv4_table") \
18062 _(dump_ipv6_table, "usage: dump_ipv6_table") \
18063 _(dump_stats_table, "usage: dump_stats_table") \
18064 _(dump_macro_table, "usage: dump_macro_table ") \
18065 _(dump_node_table, "usage: dump_node_table") \
18066 _(dump_msg_api_table, "usage: dump_msg_api_table") \
18067 _(get_msg_id, "usage: get_msg_id name_and_crc") \
18068 _(echo, "usage: echo <message>") \
18069 _(exec, "usage: exec <vpe-debug-CLI-command>") \
18070 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
18071 _(help, "usage: help") \
18072 _(q, "usage: quit") \
18073 _(quit, "usage: quit") \
18074 _(search_node_table, "usage: search_node_table <name>...") \
18075 _(set, "usage: set <variable-name> <value>") \
18076 _(script, "usage: script <file-name>") \
18077 _(unset, "usage: unset <variable-name>")
18080 static void vl_api_##n##_t_handler_uni \
18081 (vl_api_##n##_t * mp) \
18083 vat_main_t * vam = &vat_main; \
18084 if (vam->json_output) { \
18085 vl_api_##n##_t_handler_json(mp); \
18087 vl_api_##n##_t_handler(mp); \
18090 foreach_vpe_api_reply_msg;
18095 static void vl_api_##n##_t_handler_uni \
18096 (vl_api_##n##_t * mp) \
18098 vat_main_t * vam = &vat_main; \
18099 if (vam->json_output) { \
18100 vl_api_##n##_t_handler_json(mp); \
18102 vl_api_##n##_t_handler(mp); \
18105 foreach_vpe_dpdk_api_reply_msg;
18110 vat_api_hookup (vat_main_t * vam)
18113 vl_msg_api_set_handlers(VL_API_##N, #n, \
18114 vl_api_##n##_t_handler_uni, \
18116 vl_api_##n##_t_endian, \
18117 vl_api_##n##_t_print, \
18118 sizeof(vl_api_##n##_t), 1);
18119 foreach_vpe_api_reply_msg;
18124 vl_msg_api_set_handlers(VL_API_##N, #n, \
18125 vl_api_##n##_t_handler_uni, \
18127 vl_api_##n##_t_endian, \
18128 vl_api_##n##_t_print, \
18129 sizeof(vl_api_##n##_t), 1);
18130 foreach_vpe_dpdk_api_reply_msg;
18134 #if (VPP_API_TEST_BUILTIN==0)
18135 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
18138 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
18140 vam->function_by_name = hash_create_string (0, sizeof (uword));
18142 vam->help_by_name = hash_create_string (0, sizeof (uword));
18144 /* API messages we can send */
18145 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
18146 foreach_vpe_api_msg;
18149 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
18150 foreach_vpe_dpdk_api_msg;
18155 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
18156 foreach_vpe_api_msg;
18159 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
18160 foreach_vpe_dpdk_api_msg;
18164 /* CLI functions */
18165 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
18166 foreach_cli_function;
18170 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
18171 foreach_cli_function;
18176 * fd.io coding-style-patch-verification: ON
18179 * eval: (c-set-style "gnu")