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;
4808 name_sort_t *nses = 0, *ns;
4809 sw_interface_subif_t *sub = NULL;
4812 /* Toss the old name table */
4814 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4816 vec_add2 (nses, ns, 1);
4817 ns->name = (u8 *)(p->key);
4818 ns->value = (u32) p->value[0];
4822 hash_free (vam->sw_if_index_by_interface_name);
4824 vec_foreach (ns, nses) vec_free (ns->name);
4828 vec_foreach (sub, vam->sw_if_subif_table)
4830 vec_free (sub->interface_name);
4832 vec_free (vam->sw_if_subif_table);
4834 /* recreate the interface name hash table */
4835 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
4837 /* Get list of ethernets */
4838 M (SW_INTERFACE_DUMP, mp);
4839 mp->name_filter_valid = 1;
4840 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
4843 /* and local / loopback interfaces */
4844 M (SW_INTERFACE_DUMP, mp);
4845 mp->name_filter_valid = 1;
4846 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
4849 /* and packet-generator interfaces */
4850 M (SW_INTERFACE_DUMP, mp);
4851 mp->name_filter_valid = 1;
4852 strncpy ((char *) mp->name_filter, "pg", sizeof (mp->name_filter) - 1);
4855 /* and vxlan-gpe tunnel interfaces */
4856 M (SW_INTERFACE_DUMP, mp);
4857 mp->name_filter_valid = 1;
4858 strncpy ((char *) mp->name_filter, "vxlan_gpe",
4859 sizeof (mp->name_filter) - 1);
4862 /* and vxlan tunnel interfaces */
4863 M (SW_INTERFACE_DUMP, mp);
4864 mp->name_filter_valid = 1;
4865 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
4868 /* and host (af_packet) interfaces */
4869 M (SW_INTERFACE_DUMP, mp);
4870 mp->name_filter_valid = 1;
4871 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
4874 /* and l2tpv3 tunnel interfaces */
4875 M (SW_INTERFACE_DUMP, mp);
4876 mp->name_filter_valid = 1;
4877 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
4878 sizeof (mp->name_filter) - 1);
4881 /* and GRE tunnel interfaces */
4882 M (SW_INTERFACE_DUMP, mp);
4883 mp->name_filter_valid = 1;
4884 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
4887 /* and LISP-GPE interfaces */
4888 M (SW_INTERFACE_DUMP, mp);
4889 mp->name_filter_valid = 1;
4890 strncpy ((char *) mp->name_filter, "lisp_gpe",
4891 sizeof (mp->name_filter) - 1);
4894 /* and IPSEC tunnel interfaces */
4895 M (SW_INTERFACE_DUMP, mp);
4896 mp->name_filter_valid = 1;
4897 strncpy ((char *) mp->name_filter, "ipsec", sizeof (mp->name_filter) - 1);
4900 /* Use a control ping for synchronization */
4902 vl_api_control_ping_t *mp;
4903 M (CONTROL_PING, mp);
4911 api_sw_interface_set_flags (vat_main_t * vam)
4913 unformat_input_t *i = vam->input;
4914 vl_api_sw_interface_set_flags_t *mp;
4916 u8 sw_if_index_set = 0;
4917 u8 admin_up = 0, link_up = 0;
4920 /* Parse args required to build the message */
4921 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4923 if (unformat (i, "admin-up"))
4925 else if (unformat (i, "admin-down"))
4927 else if (unformat (i, "link-up"))
4929 else if (unformat (i, "link-down"))
4932 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4933 sw_if_index_set = 1;
4934 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4935 sw_if_index_set = 1;
4940 if (sw_if_index_set == 0)
4942 errmsg ("missing interface name or sw_if_index");
4946 /* Construct the API message */
4947 M (SW_INTERFACE_SET_FLAGS, mp);
4948 mp->sw_if_index = ntohl (sw_if_index);
4949 mp->admin_up_down = admin_up;
4950 mp->link_up_down = link_up;
4955 /* Wait for a reply, return the good/bad news... */
4961 api_sw_interface_clear_stats (vat_main_t * vam)
4963 unformat_input_t *i = vam->input;
4964 vl_api_sw_interface_clear_stats_t *mp;
4966 u8 sw_if_index_set = 0;
4969 /* Parse args required to build the message */
4970 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4972 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4973 sw_if_index_set = 1;
4974 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4975 sw_if_index_set = 1;
4980 /* Construct the API message */
4981 M (SW_INTERFACE_CLEAR_STATS, mp);
4983 if (sw_if_index_set == 1)
4984 mp->sw_if_index = ntohl (sw_if_index);
4986 mp->sw_if_index = ~0;
4991 /* Wait for a reply, return the good/bad news... */
4998 api_sw_interface_set_dpdk_hqos_pipe (vat_main_t * vam)
5000 unformat_input_t *i = vam->input;
5001 vl_api_sw_interface_set_dpdk_hqos_pipe_t *mp;
5003 u8 sw_if_index_set = 0;
5012 /* Parse args required to build the message */
5013 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5015 if (unformat (i, "rx %U", api_unformat_sw_if_index, vam, &sw_if_index))
5016 sw_if_index_set = 1;
5017 else if (unformat (i, "sw_if_index %u", &sw_if_index))
5018 sw_if_index_set = 1;
5019 else if (unformat (i, "subport %u", &subport))
5022 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5023 sw_if_index_set = 1;
5024 else if (unformat (i, "pipe %u", &pipe))
5026 else if (unformat (i, "profile %u", &profile))
5032 if (sw_if_index_set == 0)
5034 errmsg ("missing interface name or sw_if_index");
5038 if (subport_set == 0)
5040 errmsg ("missing subport ");
5046 errmsg ("missing pipe");
5050 if (profile_set == 0)
5052 errmsg ("missing profile");
5056 M (SW_INTERFACE_SET_DPDK_HQOS_PIPE, mp);
5058 mp->sw_if_index = ntohl (sw_if_index);
5059 mp->subport = ntohl (subport);
5060 mp->pipe = ntohl (pipe);
5061 mp->profile = ntohl (profile);
5070 api_sw_interface_set_dpdk_hqos_subport (vat_main_t * vam)
5072 unformat_input_t *i = vam->input;
5073 vl_api_sw_interface_set_dpdk_hqos_subport_t *mp;
5075 u8 sw_if_index_set = 0;
5078 u32 tb_rate = 1250000000; /* 10GbE */
5079 u32 tb_size = 1000000;
5080 u32 tc_rate[] = { 1250000000, 1250000000, 1250000000, 1250000000 };
5084 /* Parse args required to build the message */
5085 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5087 if (unformat (i, "rx %U", api_unformat_sw_if_index, vam, &sw_if_index))
5088 sw_if_index_set = 1;
5089 else if (unformat (i, "sw_if_index %u", &sw_if_index))
5090 sw_if_index_set = 1;
5091 else if (unformat (i, "subport %u", &subport))
5094 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5095 sw_if_index_set = 1;
5096 else if (unformat (i, "rate %u", &tb_rate))
5100 for (tc_id = 0; tc_id < (sizeof (tc_rate) / sizeof (tc_rate[0]));
5102 tc_rate[tc_id] = tb_rate;
5104 else if (unformat (i, "bktsize %u", &tb_size))
5106 else if (unformat (i, "tc0 %u", &tc_rate[0]))
5108 else if (unformat (i, "tc1 %u", &tc_rate[1]))
5110 else if (unformat (i, "tc2 %u", &tc_rate[2]))
5112 else if (unformat (i, "tc3 %u", &tc_rate[3]))
5114 else if (unformat (i, "period %u", &tc_period))
5120 if (sw_if_index_set == 0)
5122 errmsg ("missing interface name or sw_if_index");
5126 if (subport_set == 0)
5128 errmsg ("missing subport ");
5132 M (SW_INTERFACE_SET_DPDK_HQOS_SUBPORT, mp);
5134 mp->sw_if_index = ntohl (sw_if_index);
5135 mp->subport = ntohl (subport);
5136 mp->tb_rate = ntohl (tb_rate);
5137 mp->tb_size = ntohl (tb_size);
5138 mp->tc_rate[0] = ntohl (tc_rate[0]);
5139 mp->tc_rate[1] = ntohl (tc_rate[1]);
5140 mp->tc_rate[2] = ntohl (tc_rate[2]);
5141 mp->tc_rate[3] = ntohl (tc_rate[3]);
5142 mp->tc_period = ntohl (tc_period);
5150 api_sw_interface_set_dpdk_hqos_tctbl (vat_main_t * vam)
5152 unformat_input_t *i = vam->input;
5153 vl_api_sw_interface_set_dpdk_hqos_tctbl_t *mp;
5155 u8 sw_if_index_set = 0;
5159 u32 entry, tc, queue;
5162 /* Parse args required to build the message */
5163 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5165 if (unformat (i, "rx %U", api_unformat_sw_if_index, vam, &sw_if_index))
5166 sw_if_index_set = 1;
5167 else if (unformat (i, "sw_if_index %u", &sw_if_index))
5168 sw_if_index_set = 1;
5169 else if (unformat (i, "entry %d", &entry))
5171 else if (unformat (i, "tc %d", &tc))
5173 else if (unformat (i, "queue %d", &queue))
5179 if (sw_if_index_set == 0)
5181 errmsg ("missing interface name or sw_if_index");
5187 errmsg ("missing entry ");
5193 errmsg ("missing traffic class ");
5199 errmsg ("missing queue ");
5203 M (SW_INTERFACE_SET_DPDK_HQOS_TCTBL, mp);
5205 mp->sw_if_index = ntohl (sw_if_index);
5206 mp->entry = ntohl (entry);
5207 mp->tc = ntohl (tc);
5208 mp->queue = ntohl (queue);
5217 api_sw_interface_add_del_address (vat_main_t * vam)
5219 unformat_input_t *i = vam->input;
5220 vl_api_sw_interface_add_del_address_t *mp;
5222 u8 sw_if_index_set = 0;
5223 u8 is_add = 1, del_all = 0;
5224 u32 address_length = 0;
5225 u8 v4_address_set = 0;
5226 u8 v6_address_set = 0;
5227 ip4_address_t v4address;
5228 ip6_address_t v6address;
5231 /* Parse args required to build the message */
5232 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5234 if (unformat (i, "del-all"))
5236 else if (unformat (i, "del"))
5239 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5240 sw_if_index_set = 1;
5241 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5242 sw_if_index_set = 1;
5243 else if (unformat (i, "%U/%d",
5244 unformat_ip4_address, &v4address, &address_length))
5246 else if (unformat (i, "%U/%d",
5247 unformat_ip6_address, &v6address, &address_length))
5253 if (sw_if_index_set == 0)
5255 errmsg ("missing interface name or sw_if_index");
5258 if (v4_address_set && v6_address_set)
5260 errmsg ("both v4 and v6 addresses set");
5263 if (!v4_address_set && !v6_address_set && !del_all)
5265 errmsg ("no addresses set");
5269 /* Construct the API message */
5270 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
5272 mp->sw_if_index = ntohl (sw_if_index);
5273 mp->is_add = is_add;
5274 mp->del_all = del_all;
5278 clib_memcpy (mp->address, &v6address, sizeof (v6address));
5282 clib_memcpy (mp->address, &v4address, sizeof (v4address));
5284 mp->address_length = address_length;
5289 /* Wait for a reply, return good/bad news */
5295 api_sw_interface_set_mpls_enable (vat_main_t * vam)
5297 unformat_input_t *i = vam->input;
5298 vl_api_sw_interface_set_mpls_enable_t *mp;
5300 u8 sw_if_index_set = 0;
5304 /* Parse args required to build the message */
5305 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5307 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5308 sw_if_index_set = 1;
5309 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5310 sw_if_index_set = 1;
5311 else if (unformat (i, "disable"))
5313 else if (unformat (i, "dis"))
5319 if (sw_if_index_set == 0)
5321 errmsg ("missing interface name or sw_if_index");
5325 /* Construct the API message */
5326 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
5328 mp->sw_if_index = ntohl (sw_if_index);
5329 mp->enable = enable;
5334 /* Wait for a reply... */
5340 api_sw_interface_set_table (vat_main_t * vam)
5342 unformat_input_t *i = vam->input;
5343 vl_api_sw_interface_set_table_t *mp;
5344 u32 sw_if_index, vrf_id = 0;
5345 u8 sw_if_index_set = 0;
5349 /* Parse args required to build the message */
5350 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5352 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5353 sw_if_index_set = 1;
5354 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5355 sw_if_index_set = 1;
5356 else if (unformat (i, "vrf %d", &vrf_id))
5358 else if (unformat (i, "ipv6"))
5364 if (sw_if_index_set == 0)
5366 errmsg ("missing interface name or sw_if_index");
5370 /* Construct the API message */
5371 M (SW_INTERFACE_SET_TABLE, mp);
5373 mp->sw_if_index = ntohl (sw_if_index);
5374 mp->is_ipv6 = is_ipv6;
5375 mp->vrf_id = ntohl (vrf_id);
5380 /* Wait for a reply... */
5385 static void vl_api_sw_interface_get_table_reply_t_handler
5386 (vl_api_sw_interface_get_table_reply_t * mp)
5388 vat_main_t *vam = &vat_main;
5390 print (vam->ofp, "%d", ntohl (mp->vrf_id));
5392 vam->retval = ntohl (mp->retval);
5393 vam->result_ready = 1;
5397 static void vl_api_sw_interface_get_table_reply_t_handler_json
5398 (vl_api_sw_interface_get_table_reply_t * mp)
5400 vat_main_t *vam = &vat_main;
5401 vat_json_node_t node;
5403 vat_json_init_object (&node);
5404 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
5405 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
5407 vat_json_print (vam->ofp, &node);
5408 vat_json_free (&node);
5410 vam->retval = ntohl (mp->retval);
5411 vam->result_ready = 1;
5415 api_sw_interface_get_table (vat_main_t * vam)
5417 unformat_input_t *i = vam->input;
5418 vl_api_sw_interface_get_table_t *mp;
5420 u8 sw_if_index_set = 0;
5424 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5426 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5427 sw_if_index_set = 1;
5428 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5429 sw_if_index_set = 1;
5430 else if (unformat (i, "ipv6"))
5436 if (sw_if_index_set == 0)
5438 errmsg ("missing interface name or sw_if_index");
5442 M (SW_INTERFACE_GET_TABLE, mp);
5443 mp->sw_if_index = htonl (sw_if_index);
5444 mp->is_ipv6 = is_ipv6;
5452 api_sw_interface_set_vpath (vat_main_t * vam)
5454 unformat_input_t *i = vam->input;
5455 vl_api_sw_interface_set_vpath_t *mp;
5456 u32 sw_if_index = 0;
5457 u8 sw_if_index_set = 0;
5461 /* Parse args required to build the message */
5462 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5464 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5465 sw_if_index_set = 1;
5466 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5467 sw_if_index_set = 1;
5468 else if (unformat (i, "enable"))
5470 else if (unformat (i, "disable"))
5476 if (sw_if_index_set == 0)
5478 errmsg ("missing interface name or sw_if_index");
5482 /* Construct the API message */
5483 M (SW_INTERFACE_SET_VPATH, mp);
5485 mp->sw_if_index = ntohl (sw_if_index);
5486 mp->enable = is_enable;
5491 /* Wait for a reply... */
5497 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
5499 unformat_input_t *i = vam->input;
5500 vl_api_sw_interface_set_vxlan_bypass_t *mp;
5501 u32 sw_if_index = 0;
5502 u8 sw_if_index_set = 0;
5507 /* Parse args required to build the message */
5508 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5510 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5511 sw_if_index_set = 1;
5512 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5513 sw_if_index_set = 1;
5514 else if (unformat (i, "enable"))
5516 else if (unformat (i, "disable"))
5518 else if (unformat (i, "ip4"))
5520 else if (unformat (i, "ip6"))
5526 if (sw_if_index_set == 0)
5528 errmsg ("missing interface name or sw_if_index");
5532 /* Construct the API message */
5533 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
5535 mp->sw_if_index = ntohl (sw_if_index);
5536 mp->enable = is_enable;
5537 mp->is_ipv6 = is_ipv6;
5542 /* Wait for a reply... */
5548 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
5550 unformat_input_t *i = vam->input;
5551 vl_api_sw_interface_set_l2_xconnect_t *mp;
5553 u8 rx_sw_if_index_set = 0;
5555 u8 tx_sw_if_index_set = 0;
5559 /* Parse args required to build the message */
5560 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5562 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
5563 rx_sw_if_index_set = 1;
5564 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5565 tx_sw_if_index_set = 1;
5566 else if (unformat (i, "rx"))
5568 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5570 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
5572 rx_sw_if_index_set = 1;
5577 else if (unformat (i, "tx"))
5579 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5581 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
5583 tx_sw_if_index_set = 1;
5588 else if (unformat (i, "enable"))
5590 else if (unformat (i, "disable"))
5596 if (rx_sw_if_index_set == 0)
5598 errmsg ("missing rx interface name or rx_sw_if_index");
5602 if (enable && (tx_sw_if_index_set == 0))
5604 errmsg ("missing tx interface name or tx_sw_if_index");
5608 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
5610 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5611 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
5612 mp->enable = enable;
5620 api_sw_interface_set_l2_bridge (vat_main_t * vam)
5622 unformat_input_t *i = vam->input;
5623 vl_api_sw_interface_set_l2_bridge_t *mp;
5625 u8 rx_sw_if_index_set = 0;
5633 /* Parse args required to build the message */
5634 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5636 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
5637 rx_sw_if_index_set = 1;
5638 else if (unformat (i, "bd_id %d", &bd_id))
5642 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
5643 rx_sw_if_index_set = 1;
5644 else if (unformat (i, "shg %d", &shg))
5646 else if (unformat (i, "bvi"))
5648 else if (unformat (i, "enable"))
5650 else if (unformat (i, "disable"))
5656 if (rx_sw_if_index_set == 0)
5658 errmsg ("missing rx interface name or sw_if_index");
5662 if (enable && (bd_id_set == 0))
5664 errmsg ("missing bridge domain");
5668 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
5670 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5671 mp->bd_id = ntohl (bd_id);
5674 mp->enable = enable;
5682 api_bridge_domain_dump (vat_main_t * vam)
5684 unformat_input_t *i = vam->input;
5685 vl_api_bridge_domain_dump_t *mp;
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 */
5704 vl_api_control_ping_t *mp;
5705 M (CONTROL_PING, mp);
5714 api_bridge_domain_add_del (vat_main_t * vam)
5716 unformat_input_t *i = vam->input;
5717 vl_api_bridge_domain_add_del_t *mp;
5720 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
5724 /* Parse args required to build the message */
5725 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5727 if (unformat (i, "bd_id %d", &bd_id))
5729 else if (unformat (i, "flood %d", &flood))
5731 else if (unformat (i, "uu-flood %d", &uu_flood))
5733 else if (unformat (i, "forward %d", &forward))
5735 else if (unformat (i, "learn %d", &learn))
5737 else if (unformat (i, "arp-term %d", &arp_term))
5739 else if (unformat (i, "mac-age %d", &mac_age))
5741 else if (unformat (i, "del"))
5744 flood = uu_flood = forward = learn = 0;
5752 errmsg ("missing bridge domain");
5758 errmsg ("mac age must be less than 256 ");
5762 M (BRIDGE_DOMAIN_ADD_DEL, mp);
5764 mp->bd_id = ntohl (bd_id);
5766 mp->uu_flood = uu_flood;
5767 mp->forward = forward;
5769 mp->arp_term = arp_term;
5770 mp->is_add = is_add;
5771 mp->mac_age = (u8) mac_age;
5779 api_l2fib_add_del (vat_main_t * vam)
5781 unformat_input_t *i = vam->input;
5782 vl_api_l2fib_add_del_t *mp;
5788 u32 sw_if_index = ~0;
5789 u8 sw_if_index_set = 0;
5798 /* Parse args required to build the message */
5799 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5801 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
5803 else if (unformat (i, "bd_id %d", &bd_id))
5805 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5806 sw_if_index_set = 1;
5807 else if (unformat (i, "sw_if"))
5809 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5812 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5813 sw_if_index_set = 1;
5818 else if (unformat (i, "static"))
5820 else if (unformat (i, "filter"))
5825 else if (unformat (i, "bvi"))
5830 else if (unformat (i, "del"))
5832 else if (unformat (i, "count %d", &count))
5840 errmsg ("missing mac address");
5846 errmsg ("missing bridge domain");
5850 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
5852 errmsg ("missing interface name or sw_if_index");
5858 /* Turn on async mode */
5859 vam->async_mode = 1;
5860 vam->async_errors = 0;
5861 before = vat_time_now (vam);
5864 for (j = 0; j < count; j++)
5866 M (L2FIB_ADD_DEL, mp);
5869 mp->bd_id = ntohl (bd_id);
5870 mp->is_add = is_add;
5874 mp->sw_if_index = ntohl (sw_if_index);
5875 mp->static_mac = static_mac;
5876 mp->filter_mac = filter_mac;
5877 mp->bvi_mac = bvi_mac;
5879 increment_mac_address (&mac);
5886 vl_api_control_ping_t *mp;
5889 /* Shut off async mode */
5890 vam->async_mode = 0;
5892 M (CONTROL_PING, mp);
5895 timeout = vat_time_now (vam) + 1.0;
5896 while (vat_time_now (vam) < timeout)
5897 if (vam->result_ready == 1)
5902 if (vam->retval == -99)
5905 if (vam->async_errors > 0)
5907 errmsg ("%d asynchronous errors", vam->async_errors);
5910 vam->async_errors = 0;
5911 after = vat_time_now (vam);
5913 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
5914 count, after - before, count / (after - before));
5920 /* Wait for a reply... */
5924 /* Return the good/bad news */
5925 return (vam->retval);
5929 api_l2_flags (vat_main_t * vam)
5931 unformat_input_t *i = vam->input;
5932 vl_api_l2_flags_t *mp;
5934 u32 feature_bitmap = 0;
5935 u8 sw_if_index_set = 0;
5938 /* Parse args required to build the message */
5939 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5941 if (unformat (i, "sw_if_index %d", &sw_if_index))
5942 sw_if_index_set = 1;
5943 else if (unformat (i, "sw_if"))
5945 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5948 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5949 sw_if_index_set = 1;
5954 else if (unformat (i, "learn"))
5955 feature_bitmap |= L2INPUT_FEAT_LEARN;
5956 else if (unformat (i, "forward"))
5957 feature_bitmap |= L2INPUT_FEAT_FWD;
5958 else if (unformat (i, "flood"))
5959 feature_bitmap |= L2INPUT_FEAT_FLOOD;
5960 else if (unformat (i, "uu-flood"))
5961 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
5966 if (sw_if_index_set == 0)
5968 errmsg ("missing interface name or sw_if_index");
5974 mp->sw_if_index = ntohl (sw_if_index);
5975 mp->feature_bitmap = ntohl (feature_bitmap);
5983 api_bridge_flags (vat_main_t * vam)
5985 unformat_input_t *i = vam->input;
5986 vl_api_bridge_flags_t *mp;
5993 /* Parse args required to build the message */
5994 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5996 if (unformat (i, "bd_id %d", &bd_id))
5998 else if (unformat (i, "learn"))
6000 else if (unformat (i, "forward"))
6002 else if (unformat (i, "flood"))
6004 else if (unformat (i, "uu-flood"))
6005 flags |= L2_UU_FLOOD;
6006 else if (unformat (i, "arp-term"))
6007 flags |= L2_ARP_TERM;
6008 else if (unformat (i, "off"))
6010 else if (unformat (i, "disable"))
6018 errmsg ("missing bridge domain");
6022 M (BRIDGE_FLAGS, mp);
6024 mp->bd_id = ntohl (bd_id);
6025 mp->feature_bitmap = ntohl (flags);
6026 mp->is_set = is_set;
6034 api_bd_ip_mac_add_del (vat_main_t * vam)
6036 unformat_input_t *i = vam->input;
6037 vl_api_bd_ip_mac_add_del_t *mp;
6044 ip4_address_t v4addr;
6045 ip6_address_t v6addr;
6050 /* Parse args required to build the message */
6051 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6053 if (unformat (i, "bd_id %d", &bd_id))
6057 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
6061 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
6066 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
6070 else if (unformat (i, "del"))
6078 errmsg ("missing bridge domain");
6081 else if (ip_set == 0)
6083 errmsg ("missing IP address");
6086 else if (mac_set == 0)
6088 errmsg ("missing MAC address");
6092 M (BD_IP_MAC_ADD_DEL, mp);
6094 mp->bd_id = ntohl (bd_id);
6095 mp->is_ipv6 = is_ipv6;
6096 mp->is_add = is_add;
6098 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
6100 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
6101 clib_memcpy (mp->mac_address, macaddr, 6);
6108 api_tap_connect (vat_main_t * vam)
6110 unformat_input_t *i = vam->input;
6111 vl_api_tap_connect_t *mp;
6117 ip4_address_t ip4_address;
6119 int ip4_address_set = 0;
6120 ip6_address_t ip6_address;
6122 int ip6_address_set = 0;
6125 memset (mac_address, 0, sizeof (mac_address));
6127 /* Parse args required to build the message */
6128 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6130 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6134 else if (unformat (i, "random-mac"))
6136 else if (unformat (i, "tapname %s", &tap_name))
6138 else if (unformat (i, "tag %s", &tag))
6140 else if (unformat (i, "address %U/%d",
6141 unformat_ip4_address, &ip4_address, &ip4_mask_width))
6142 ip4_address_set = 1;
6143 else if (unformat (i, "address %U/%d",
6144 unformat_ip6_address, &ip6_address, &ip6_mask_width))
6145 ip6_address_set = 1;
6152 errmsg ("missing tap name");
6155 if (vec_len (tap_name) > 63)
6157 errmsg ("tap name too long");
6160 vec_add1 (tap_name, 0);
6162 if (vec_len (tag) > 63)
6164 errmsg ("tag too long");
6168 /* Construct the API message */
6169 M (TAP_CONNECT, mp);
6171 mp->use_random_mac = random_mac;
6172 clib_memcpy (mp->mac_address, mac_address, 6);
6173 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
6175 clib_memcpy (mp->tag, tag, vec_len (tag));
6177 if (ip4_address_set)
6179 mp->ip4_address_set = 1;
6180 clib_memcpy (mp->ip4_address, &ip4_address, sizeof (mp->ip4_address));
6181 mp->ip4_mask_width = ip4_mask_width;
6183 if (ip6_address_set)
6185 mp->ip6_address_set = 1;
6186 clib_memcpy (mp->ip6_address, &ip6_address, sizeof (mp->ip6_address));
6187 mp->ip6_mask_width = ip6_mask_width;
6190 vec_free (tap_name);
6196 /* Wait for a reply... */
6202 api_tap_modify (vat_main_t * vam)
6204 unformat_input_t *i = vam->input;
6205 vl_api_tap_modify_t *mp;
6210 u32 sw_if_index = ~0;
6211 u8 sw_if_index_set = 0;
6214 memset (mac_address, 0, sizeof (mac_address));
6216 /* Parse args required to build the message */
6217 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6219 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6220 sw_if_index_set = 1;
6221 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6222 sw_if_index_set = 1;
6223 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6227 else if (unformat (i, "random-mac"))
6229 else if (unformat (i, "tapname %s", &tap_name))
6235 if (sw_if_index_set == 0)
6237 errmsg ("missing vpp interface name");
6242 errmsg ("missing tap name");
6245 if (vec_len (tap_name) > 63)
6247 errmsg ("tap name too long");
6249 vec_add1 (tap_name, 0);
6251 /* Construct the API message */
6254 mp->use_random_mac = random_mac;
6255 mp->sw_if_index = ntohl (sw_if_index);
6256 clib_memcpy (mp->mac_address, mac_address, 6);
6257 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
6258 vec_free (tap_name);
6263 /* Wait for a reply... */
6269 api_tap_delete (vat_main_t * vam)
6271 unformat_input_t *i = vam->input;
6272 vl_api_tap_delete_t *mp;
6273 u32 sw_if_index = ~0;
6274 u8 sw_if_index_set = 0;
6277 /* Parse args required to build the message */
6278 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6280 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6281 sw_if_index_set = 1;
6282 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6283 sw_if_index_set = 1;
6288 if (sw_if_index_set == 0)
6290 errmsg ("missing vpp interface name");
6294 /* Construct the API message */
6297 mp->sw_if_index = ntohl (sw_if_index);
6302 /* Wait for a reply... */
6308 api_ip_add_del_route (vat_main_t * vam)
6310 unformat_input_t *i = vam->input;
6311 vl_api_ip_add_del_route_t *mp;
6312 u32 sw_if_index = ~0, vrf_id = 0;
6314 u8 is_local = 0, is_drop = 0;
6315 u8 is_unreach = 0, is_prohibit = 0;
6316 u8 create_vrf_if_needed = 0;
6318 u32 next_hop_weight = 1;
6320 u8 is_multipath = 0;
6322 u8 address_length_set = 0;
6323 u32 next_hop_table_id = 0;
6324 u32 resolve_attempts = 0;
6325 u32 dst_address_length = 0;
6326 u8 next_hop_set = 0;
6327 ip4_address_t v4_dst_address, v4_next_hop_address;
6328 ip6_address_t v6_dst_address, v6_next_hop_address;
6332 u32 random_add_del = 0;
6333 u32 *random_vector = 0;
6335 u32 random_seed = 0xdeaddabe;
6336 u32 classify_table_index = ~0;
6338 u8 resolve_host = 0, resolve_attached = 0;
6339 mpls_label_t *next_hop_out_label_stack = NULL;
6340 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6341 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
6343 /* Parse args required to build the message */
6344 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6346 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6348 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6350 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
6355 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
6360 else if (unformat (i, "/%d", &dst_address_length))
6362 address_length_set = 1;
6365 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
6366 &v4_next_hop_address))
6370 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
6371 &v6_next_hop_address))
6375 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
6377 else if (unformat (i, "weight %d", &next_hop_weight))
6379 else if (unformat (i, "drop"))
6383 else if (unformat (i, "null-send-unreach"))
6387 else if (unformat (i, "null-send-prohibit"))
6391 else if (unformat (i, "local"))
6395 else if (unformat (i, "classify %d", &classify_table_index))
6399 else if (unformat (i, "del"))
6401 else if (unformat (i, "add"))
6403 else if (unformat (i, "not-last"))
6405 else if (unformat (i, "resolve-via-host"))
6407 else if (unformat (i, "resolve-via-attached"))
6408 resolve_attached = 1;
6409 else if (unformat (i, "multipath"))
6411 else if (unformat (i, "vrf %d", &vrf_id))
6413 else if (unformat (i, "create-vrf"))
6414 create_vrf_if_needed = 1;
6415 else if (unformat (i, "count %d", &count))
6417 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
6419 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6421 else if (unformat (i, "out-label %d", &next_hop_out_label))
6422 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
6423 else if (unformat (i, "via-label %d", &next_hop_via_label))
6425 else if (unformat (i, "random"))
6427 else if (unformat (i, "seed %d", &random_seed))
6431 clib_warning ("parse error '%U'", format_unformat_error, i);
6436 if (!next_hop_set && !is_drop && !is_local &&
6437 !is_classify && !is_unreach && !is_prohibit &&
6438 MPLS_LABEL_INVALID == next_hop_via_label)
6441 ("next hop / local / drop / unreach / prohibit / classify not set");
6445 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
6447 errmsg ("next hop and next-hop via label set");
6450 if (address_set == 0)
6452 errmsg ("missing addresses");
6456 if (address_length_set == 0)
6458 errmsg ("missing address length");
6462 /* Generate a pile of unique, random routes */
6465 u32 this_random_address;
6466 random_hash = hash_create (count, sizeof (uword));
6468 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
6469 for (j = 0; j <= count; j++)
6473 this_random_address = random_u32 (&random_seed);
6474 this_random_address =
6475 clib_host_to_net_u32 (this_random_address);
6477 while (hash_get (random_hash, this_random_address));
6478 vec_add1 (random_vector, this_random_address);
6479 hash_set (random_hash, this_random_address, 1);
6481 hash_free (random_hash);
6482 v4_dst_address.as_u32 = random_vector[0];
6487 /* Turn on async mode */
6488 vam->async_mode = 1;
6489 vam->async_errors = 0;
6490 before = vat_time_now (vam);
6493 for (j = 0; j < count; j++)
6495 /* Construct the API message */
6496 M2 (IP_ADD_DEL_ROUTE, mp,
6497 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
6499 mp->next_hop_sw_if_index = ntohl (sw_if_index);
6500 mp->table_id = ntohl (vrf_id);
6501 mp->create_vrf_if_needed = create_vrf_if_needed;
6503 mp->is_add = is_add;
6504 mp->is_drop = is_drop;
6505 mp->is_unreach = is_unreach;
6506 mp->is_prohibit = is_prohibit;
6507 mp->is_ipv6 = is_ipv6;
6508 mp->is_local = is_local;
6509 mp->is_classify = is_classify;
6510 mp->is_multipath = is_multipath;
6511 mp->is_resolve_host = resolve_host;
6512 mp->is_resolve_attached = resolve_attached;
6513 mp->not_last = not_last;
6514 mp->next_hop_weight = next_hop_weight;
6515 mp->dst_address_length = dst_address_length;
6516 mp->next_hop_table_id = ntohl (next_hop_table_id);
6517 mp->classify_table_index = ntohl (classify_table_index);
6518 mp->next_hop_via_label = ntohl (next_hop_via_label);
6519 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
6520 if (0 != mp->next_hop_n_out_labels)
6522 memcpy (mp->next_hop_out_label_stack,
6523 next_hop_out_label_stack,
6524 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
6525 vec_free (next_hop_out_label_stack);
6530 clib_memcpy (mp->dst_address, &v6_dst_address,
6531 sizeof (v6_dst_address));
6533 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
6534 sizeof (v6_next_hop_address));
6535 increment_v6_address (&v6_dst_address);
6539 clib_memcpy (mp->dst_address, &v4_dst_address,
6540 sizeof (v4_dst_address));
6542 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
6543 sizeof (v4_next_hop_address));
6545 v4_dst_address.as_u32 = random_vector[j + 1];
6547 increment_v4_address (&v4_dst_address);
6551 /* If we receive SIGTERM, stop now... */
6556 /* When testing multiple add/del ops, use a control-ping to sync */
6559 vl_api_control_ping_t *mp;
6563 /* Shut off async mode */
6564 vam->async_mode = 0;
6566 M (CONTROL_PING, mp);
6569 timeout = vat_time_now (vam) + 1.0;
6570 while (vat_time_now (vam) < timeout)
6571 if (vam->result_ready == 1)
6576 if (vam->retval == -99)
6579 if (vam->async_errors > 0)
6581 errmsg ("%d asynchronous errors", vam->async_errors);
6584 vam->async_errors = 0;
6585 after = vat_time_now (vam);
6587 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6591 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6592 count, after - before, count / (after - before));
6598 /* Wait for a reply... */
6603 /* Return the good/bad news */
6604 return (vam->retval);
6608 api_ip_mroute_add_del (vat_main_t * vam)
6610 unformat_input_t *i = vam->input;
6611 vl_api_ip_mroute_add_del_t *mp;
6612 u32 sw_if_index = ~0, vrf_id = 0;
6615 u8 create_vrf_if_needed = 0;
6618 u32 grp_address_length = 0;
6619 ip4_address_t v4_grp_address, v4_src_address;
6620 ip6_address_t v6_grp_address, v6_src_address;
6621 mfib_itf_flags_t iflags = 0;
6622 mfib_entry_flags_t eflags = 0;
6625 /* Parse args required to build the message */
6626 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6628 if (unformat (i, "sw_if_index %d", &sw_if_index))
6630 else if (unformat (i, "%U %U",
6631 unformat_ip4_address, &v4_src_address,
6632 unformat_ip4_address, &v4_grp_address))
6634 grp_address_length = 64;
6638 else if (unformat (i, "%U %U",
6639 unformat_ip6_address, &v6_src_address,
6640 unformat_ip6_address, &v6_grp_address))
6642 grp_address_length = 256;
6646 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
6648 memset (&v4_src_address, 0, sizeof (v4_src_address));
6649 grp_address_length = 32;
6653 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
6655 memset (&v6_src_address, 0, sizeof (v6_src_address));
6656 grp_address_length = 128;
6660 else if (unformat (i, "/%d", &grp_address_length))
6662 else if (unformat (i, "local"))
6666 else if (unformat (i, "del"))
6668 else if (unformat (i, "add"))
6670 else if (unformat (i, "vrf %d", &vrf_id))
6672 else if (unformat (i, "create-vrf"))
6673 create_vrf_if_needed = 1;
6674 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
6676 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
6680 clib_warning ("parse error '%U'", format_unformat_error, i);
6685 if (address_set == 0)
6687 errmsg ("missing addresses\n");
6691 /* Construct the API message */
6692 M (IP_MROUTE_ADD_DEL, mp);
6694 mp->next_hop_sw_if_index = ntohl (sw_if_index);
6695 mp->table_id = ntohl (vrf_id);
6696 mp->create_vrf_if_needed = create_vrf_if_needed;
6698 mp->is_add = is_add;
6699 mp->is_ipv6 = is_ipv6;
6700 mp->is_local = is_local;
6701 mp->itf_flags = ntohl (iflags);
6702 mp->entry_flags = ntohl (eflags);
6703 mp->grp_address_length = grp_address_length;
6704 mp->grp_address_length = ntohs (mp->grp_address_length);
6708 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
6709 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
6713 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
6714 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
6720 /* Wait for a reply... */
6726 api_mpls_route_add_del (vat_main_t * vam)
6728 unformat_input_t *i = vam->input;
6729 vl_api_mpls_route_add_del_t *mp;
6730 u32 sw_if_index = ~0, table_id = 0;
6731 u8 create_table_if_needed = 0;
6733 u32 next_hop_weight = 1;
6734 u8 is_multipath = 0;
6735 u32 next_hop_table_id = 0;
6736 u8 next_hop_set = 0;
6737 ip4_address_t v4_next_hop_address = {
6740 ip6_address_t v6_next_hop_address = { {0} };
6744 u32 classify_table_index = ~0;
6746 u8 resolve_host = 0, resolve_attached = 0;
6747 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
6748 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6749 mpls_label_t *next_hop_out_label_stack = NULL;
6750 mpls_label_t local_label = MPLS_LABEL_INVALID;
6752 u8 next_hop_proto_is_ip4 = 1;
6754 /* Parse args required to build the message */
6755 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6757 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6759 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6761 else if (unformat (i, "%d", &local_label))
6763 else if (unformat (i, "eos"))
6765 else if (unformat (i, "non-eos"))
6767 else if (unformat (i, "via %U", unformat_ip4_address,
6768 &v4_next_hop_address))
6771 next_hop_proto_is_ip4 = 1;
6773 else if (unformat (i, "via %U", unformat_ip6_address,
6774 &v6_next_hop_address))
6777 next_hop_proto_is_ip4 = 0;
6779 else if (unformat (i, "weight %d", &next_hop_weight))
6781 else if (unformat (i, "create-table"))
6782 create_table_if_needed = 1;
6783 else if (unformat (i, "classify %d", &classify_table_index))
6787 else if (unformat (i, "del"))
6789 else if (unformat (i, "add"))
6791 else if (unformat (i, "resolve-via-host"))
6793 else if (unformat (i, "resolve-via-attached"))
6794 resolve_attached = 1;
6795 else if (unformat (i, "multipath"))
6797 else if (unformat (i, "count %d", &count))
6799 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
6802 next_hop_proto_is_ip4 = 1;
6804 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
6807 next_hop_proto_is_ip4 = 0;
6809 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6811 else if (unformat (i, "via-label %d", &next_hop_via_label))
6813 else if (unformat (i, "out-label %d", &next_hop_out_label))
6814 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
6817 clib_warning ("parse error '%U'", format_unformat_error, i);
6822 if (!next_hop_set && !is_classify)
6824 errmsg ("next hop / classify not set");
6828 if (MPLS_LABEL_INVALID == local_label)
6830 errmsg ("missing label");
6836 /* Turn on async mode */
6837 vam->async_mode = 1;
6838 vam->async_errors = 0;
6839 before = vat_time_now (vam);
6842 for (j = 0; j < count; j++)
6844 /* Construct the API message */
6845 M2 (MPLS_ROUTE_ADD_DEL, mp,
6846 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
6848 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
6849 mp->mr_table_id = ntohl (table_id);
6850 mp->mr_create_table_if_needed = create_table_if_needed;
6852 mp->mr_is_add = is_add;
6853 mp->mr_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
6854 mp->mr_is_classify = is_classify;
6855 mp->mr_is_multipath = is_multipath;
6856 mp->mr_is_resolve_host = resolve_host;
6857 mp->mr_is_resolve_attached = resolve_attached;
6858 mp->mr_next_hop_weight = next_hop_weight;
6859 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
6860 mp->mr_classify_table_index = ntohl (classify_table_index);
6861 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
6862 mp->mr_label = ntohl (local_label);
6863 mp->mr_eos = is_eos;
6865 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
6866 if (0 != mp->mr_next_hop_n_out_labels)
6868 memcpy (mp->mr_next_hop_out_label_stack,
6869 next_hop_out_label_stack,
6870 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
6871 vec_free (next_hop_out_label_stack);
6876 if (next_hop_proto_is_ip4)
6878 clib_memcpy (mp->mr_next_hop,
6879 &v4_next_hop_address,
6880 sizeof (v4_next_hop_address));
6884 clib_memcpy (mp->mr_next_hop,
6885 &v6_next_hop_address,
6886 sizeof (v6_next_hop_address));
6893 /* If we receive SIGTERM, stop now... */
6898 /* When testing multiple add/del ops, use a control-ping to sync */
6901 vl_api_control_ping_t *mp;
6905 /* Shut off async mode */
6906 vam->async_mode = 0;
6908 M (CONTROL_PING, mp);
6911 timeout = vat_time_now (vam) + 1.0;
6912 while (vat_time_now (vam) < timeout)
6913 if (vam->result_ready == 1)
6918 if (vam->retval == -99)
6921 if (vam->async_errors > 0)
6923 errmsg ("%d asynchronous errors", vam->async_errors);
6926 vam->async_errors = 0;
6927 after = vat_time_now (vam);
6929 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6933 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6934 count, after - before, count / (after - before));
6940 /* Wait for a reply... */
6945 /* Return the good/bad news */
6946 return (vam->retval);
6950 api_mpls_ip_bind_unbind (vat_main_t * vam)
6952 unformat_input_t *i = vam->input;
6953 vl_api_mpls_ip_bind_unbind_t *mp;
6954 u32 ip_table_id = 0;
6955 u8 create_table_if_needed = 0;
6958 ip4_address_t v4_address;
6959 ip6_address_t v6_address;
6962 mpls_label_t local_label = MPLS_LABEL_INVALID;
6965 /* Parse args required to build the message */
6966 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6968 if (unformat (i, "%U/%d", unformat_ip4_address,
6969 &v4_address, &address_length))
6974 else if (unformat (i, "%U/%d", unformat_ip6_address,
6975 &v6_address, &address_length))
6980 else if (unformat (i, "%d", &local_label))
6982 else if (unformat (i, "create-table"))
6983 create_table_if_needed = 1;
6984 else if (unformat (i, "table-id %d", &ip_table_id))
6986 else if (unformat (i, "unbind"))
6988 else if (unformat (i, "bind"))
6992 clib_warning ("parse error '%U'", format_unformat_error, i);
6999 errmsg ("IP addres not set");
7003 if (MPLS_LABEL_INVALID == local_label)
7005 errmsg ("missing label");
7009 /* Construct the API message */
7010 M (MPLS_IP_BIND_UNBIND, mp);
7012 mp->mb_create_table_if_needed = create_table_if_needed;
7013 mp->mb_is_bind = is_bind;
7014 mp->mb_is_ip4 = is_ip4;
7015 mp->mb_ip_table_id = ntohl (ip_table_id);
7016 mp->mb_mpls_table_id = 0;
7017 mp->mb_label = ntohl (local_label);
7018 mp->mb_address_length = address_length;
7021 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
7023 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
7028 /* Wait for a reply... */
7034 api_proxy_arp_add_del (vat_main_t * vam)
7036 unformat_input_t *i = vam->input;
7037 vl_api_proxy_arp_add_del_t *mp;
7040 ip4_address_t lo, hi;
7044 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7046 if (unformat (i, "vrf %d", &vrf_id))
7048 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
7049 unformat_ip4_address, &hi))
7051 else if (unformat (i, "del"))
7055 clib_warning ("parse error '%U'", format_unformat_error, i);
7062 errmsg ("address range not set");
7066 M (PROXY_ARP_ADD_DEL, mp);
7068 mp->vrf_id = ntohl (vrf_id);
7069 mp->is_add = is_add;
7070 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
7071 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
7079 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
7081 unformat_input_t *i = vam->input;
7082 vl_api_proxy_arp_intfc_enable_disable_t *mp;
7085 u8 sw_if_index_set = 0;
7088 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7090 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7091 sw_if_index_set = 1;
7092 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7093 sw_if_index_set = 1;
7094 else if (unformat (i, "enable"))
7096 else if (unformat (i, "disable"))
7100 clib_warning ("parse error '%U'", format_unformat_error, i);
7105 if (sw_if_index_set == 0)
7107 errmsg ("missing interface name or sw_if_index");
7111 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
7113 mp->sw_if_index = ntohl (sw_if_index);
7114 mp->enable_disable = enable;
7122 api_mpls_tunnel_add_del (vat_main_t * vam)
7124 unformat_input_t *i = vam->input;
7125 vl_api_mpls_tunnel_add_del_t *mp;
7129 u32 sw_if_index = ~0;
7130 u32 next_hop_sw_if_index = ~0;
7131 u32 next_hop_proto_is_ip4 = 1;
7133 u32 next_hop_table_id = 0;
7134 ip4_address_t v4_next_hop_address = {
7137 ip6_address_t v6_next_hop_address = { {0} };
7138 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID, *labels = NULL;
7141 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7143 if (unformat (i, "add"))
7145 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
7147 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
7149 else if (unformat (i, "via %U",
7150 unformat_ip4_address, &v4_next_hop_address))
7152 next_hop_proto_is_ip4 = 1;
7154 else if (unformat (i, "via %U",
7155 unformat_ip6_address, &v6_next_hop_address))
7157 next_hop_proto_is_ip4 = 0;
7159 else if (unformat (i, "l2-only"))
7161 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
7163 else if (unformat (i, "out-label %d", &next_hop_out_label))
7164 vec_add1 (labels, ntohl (next_hop_out_label));
7167 clib_warning ("parse error '%U'", format_unformat_error, i);
7172 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (mpls_label_t) * vec_len (labels));
7174 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
7175 mp->mt_sw_if_index = ntohl (sw_if_index);
7176 mp->mt_is_add = is_add;
7177 mp->mt_l2_only = l2_only;
7178 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
7179 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
7181 mp->mt_next_hop_n_out_labels = vec_len (labels);
7183 if (0 != mp->mt_next_hop_n_out_labels)
7185 clib_memcpy (mp->mt_next_hop_out_label_stack, labels,
7186 sizeof (mpls_label_t) * mp->mt_next_hop_n_out_labels);
7190 if (next_hop_proto_is_ip4)
7192 clib_memcpy (mp->mt_next_hop,
7193 &v4_next_hop_address, sizeof (v4_next_hop_address));
7197 clib_memcpy (mp->mt_next_hop,
7198 &v6_next_hop_address, sizeof (v6_next_hop_address));
7207 api_sw_interface_set_unnumbered (vat_main_t * vam)
7209 unformat_input_t *i = vam->input;
7210 vl_api_sw_interface_set_unnumbered_t *mp;
7212 u32 unnum_sw_index = ~0;
7214 u8 sw_if_index_set = 0;
7217 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7219 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7220 sw_if_index_set = 1;
7221 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7222 sw_if_index_set = 1;
7223 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
7225 else if (unformat (i, "del"))
7229 clib_warning ("parse error '%U'", format_unformat_error, i);
7234 if (sw_if_index_set == 0)
7236 errmsg ("missing interface name or sw_if_index");
7240 M (SW_INTERFACE_SET_UNNUMBERED, mp);
7242 mp->sw_if_index = ntohl (sw_if_index);
7243 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
7244 mp->is_add = is_add;
7252 api_ip_neighbor_add_del (vat_main_t * vam)
7254 unformat_input_t *i = vam->input;
7255 vl_api_ip_neighbor_add_del_t *mp;
7257 u8 sw_if_index_set = 0;
7263 u8 v4_address_set = 0;
7264 u8 v6_address_set = 0;
7265 ip4_address_t v4address;
7266 ip6_address_t v6address;
7269 memset (mac_address, 0, sizeof (mac_address));
7271 /* Parse args required to build the message */
7272 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7274 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
7278 else if (unformat (i, "del"))
7281 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7282 sw_if_index_set = 1;
7283 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7284 sw_if_index_set = 1;
7285 else if (unformat (i, "is_static"))
7287 else if (unformat (i, "vrf %d", &vrf_id))
7289 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
7291 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
7295 clib_warning ("parse error '%U'", format_unformat_error, i);
7300 if (sw_if_index_set == 0)
7302 errmsg ("missing interface name or sw_if_index");
7305 if (v4_address_set && v6_address_set)
7307 errmsg ("both v4 and v6 addresses set");
7310 if (!v4_address_set && !v6_address_set)
7312 errmsg ("no address set");
7316 /* Construct the API message */
7317 M (IP_NEIGHBOR_ADD_DEL, mp);
7319 mp->sw_if_index = ntohl (sw_if_index);
7320 mp->is_add = is_add;
7321 mp->vrf_id = ntohl (vrf_id);
7322 mp->is_static = is_static;
7324 clib_memcpy (mp->mac_address, mac_address, 6);
7328 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
7332 /* mp->is_ipv6 = 0; via memset in M macro above */
7333 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
7339 /* Wait for a reply, return good/bad news */
7345 api_reset_vrf (vat_main_t * vam)
7347 unformat_input_t *i = vam->input;
7348 vl_api_reset_vrf_t *mp;
7354 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7356 if (unformat (i, "vrf %d", &vrf_id))
7358 else if (unformat (i, "ipv6"))
7362 clib_warning ("parse error '%U'", format_unformat_error, i);
7367 if (vrf_id_set == 0)
7369 errmsg ("missing vrf id");
7375 mp->vrf_id = ntohl (vrf_id);
7376 mp->is_ipv6 = is_ipv6;
7384 api_create_vlan_subif (vat_main_t * vam)
7386 unformat_input_t *i = vam->input;
7387 vl_api_create_vlan_subif_t *mp;
7389 u8 sw_if_index_set = 0;
7394 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7396 if (unformat (i, "sw_if_index %d", &sw_if_index))
7397 sw_if_index_set = 1;
7399 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7400 sw_if_index_set = 1;
7401 else if (unformat (i, "vlan %d", &vlan_id))
7405 clib_warning ("parse error '%U'", format_unformat_error, i);
7410 if (sw_if_index_set == 0)
7412 errmsg ("missing interface name or sw_if_index");
7416 if (vlan_id_set == 0)
7418 errmsg ("missing vlan_id");
7421 M (CREATE_VLAN_SUBIF, mp);
7423 mp->sw_if_index = ntohl (sw_if_index);
7424 mp->vlan_id = ntohl (vlan_id);
7431 #define foreach_create_subif_bit \
7438 _(outer_vlan_id_any) \
7439 _(inner_vlan_id_any)
7442 api_create_subif (vat_main_t * vam)
7444 unformat_input_t *i = vam->input;
7445 vl_api_create_subif_t *mp;
7447 u8 sw_if_index_set = 0;
7454 u32 exact_match = 0;
7455 u32 default_sub = 0;
7456 u32 outer_vlan_id_any = 0;
7457 u32 inner_vlan_id_any = 0;
7459 u16 outer_vlan_id = 0;
7460 u16 inner_vlan_id = 0;
7463 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7465 if (unformat (i, "sw_if_index %d", &sw_if_index))
7466 sw_if_index_set = 1;
7468 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7469 sw_if_index_set = 1;
7470 else if (unformat (i, "sub_id %d", &sub_id))
7472 else if (unformat (i, "outer_vlan_id %d", &tmp))
7473 outer_vlan_id = tmp;
7474 else if (unformat (i, "inner_vlan_id %d", &tmp))
7475 inner_vlan_id = tmp;
7477 #define _(a) else if (unformat (i, #a)) a = 1 ;
7478 foreach_create_subif_bit
7482 clib_warning ("parse error '%U'", format_unformat_error, i);
7487 if (sw_if_index_set == 0)
7489 errmsg ("missing interface name or sw_if_index");
7493 if (sub_id_set == 0)
7495 errmsg ("missing sub_id");
7498 M (CREATE_SUBIF, mp);
7500 mp->sw_if_index = ntohl (sw_if_index);
7501 mp->sub_id = ntohl (sub_id);
7503 #define _(a) mp->a = a;
7504 foreach_create_subif_bit;
7507 mp->outer_vlan_id = ntohs (outer_vlan_id);
7508 mp->inner_vlan_id = ntohs (inner_vlan_id);
7516 api_oam_add_del (vat_main_t * vam)
7518 unformat_input_t *i = vam->input;
7519 vl_api_oam_add_del_t *mp;
7522 ip4_address_t src, dst;
7527 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7529 if (unformat (i, "vrf %d", &vrf_id))
7531 else if (unformat (i, "src %U", unformat_ip4_address, &src))
7533 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
7535 else if (unformat (i, "del"))
7539 clib_warning ("parse error '%U'", format_unformat_error, i);
7546 errmsg ("missing src addr");
7552 errmsg ("missing dst addr");
7556 M (OAM_ADD_DEL, mp);
7558 mp->vrf_id = ntohl (vrf_id);
7559 mp->is_add = is_add;
7560 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
7561 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
7569 api_reset_fib (vat_main_t * vam)
7571 unformat_input_t *i = vam->input;
7572 vl_api_reset_fib_t *mp;
7578 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7580 if (unformat (i, "vrf %d", &vrf_id))
7582 else if (unformat (i, "ipv6"))
7586 clib_warning ("parse error '%U'", format_unformat_error, i);
7591 if (vrf_id_set == 0)
7593 errmsg ("missing vrf id");
7599 mp->vrf_id = ntohl (vrf_id);
7600 mp->is_ipv6 = is_ipv6;
7608 api_dhcp_proxy_config (vat_main_t * vam)
7610 unformat_input_t *i = vam->input;
7611 vl_api_dhcp_proxy_config_t *mp;
7615 u8 v4_address_set = 0;
7616 u8 v6_address_set = 0;
7617 ip4_address_t v4address;
7618 ip6_address_t v6address;
7619 u8 v4_src_address_set = 0;
7620 u8 v6_src_address_set = 0;
7621 ip4_address_t v4srcaddress;
7622 ip6_address_t v6srcaddress;
7625 /* Parse args required to build the message */
7626 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7628 if (unformat (i, "del"))
7630 else if (unformat (i, "vrf %d", &vrf_id))
7632 else if (unformat (i, "insert-cid %d", &insert_cid))
7634 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
7636 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
7638 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
7639 v4_src_address_set = 1;
7640 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
7641 v6_src_address_set = 1;
7646 if (v4_address_set && v6_address_set)
7648 errmsg ("both v4 and v6 server addresses set");
7651 if (!v4_address_set && !v6_address_set)
7653 errmsg ("no server addresses set");
7657 if (v4_src_address_set && v6_src_address_set)
7659 errmsg ("both v4 and v6 src addresses set");
7662 if (!v4_src_address_set && !v6_src_address_set)
7664 errmsg ("no src addresses set");
7668 if (!(v4_src_address_set && v4_address_set) &&
7669 !(v6_src_address_set && v6_address_set))
7671 errmsg ("no matching server and src addresses set");
7675 /* Construct the API message */
7676 M (DHCP_PROXY_CONFIG, mp);
7678 mp->insert_circuit_id = insert_cid;
7679 mp->is_add = is_add;
7680 mp->vrf_id = ntohl (vrf_id);
7684 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
7685 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
7689 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
7690 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
7696 /* Wait for a reply, return good/bad news */
7702 api_dhcp_proxy_config_2 (vat_main_t * vam)
7704 unformat_input_t *i = vam->input;
7705 vl_api_dhcp_proxy_config_2_t *mp;
7707 u32 server_vrf_id = 0;
7710 u8 v4_address_set = 0;
7711 u8 v6_address_set = 0;
7712 ip4_address_t v4address;
7713 ip6_address_t v6address;
7714 u8 v4_src_address_set = 0;
7715 u8 v6_src_address_set = 0;
7716 ip4_address_t v4srcaddress;
7717 ip6_address_t v6srcaddress;
7720 /* Parse args required to build the message */
7721 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7723 if (unformat (i, "del"))
7725 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
7727 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
7729 else if (unformat (i, "insert-cid %d", &insert_cid))
7731 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
7733 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
7735 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
7736 v4_src_address_set = 1;
7737 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
7738 v6_src_address_set = 1;
7743 if (v4_address_set && v6_address_set)
7745 errmsg ("both v4 and v6 server addresses set");
7748 if (!v4_address_set && !v6_address_set)
7750 errmsg ("no server addresses set");
7754 if (v4_src_address_set && v6_src_address_set)
7756 errmsg ("both v4 and v6 src addresses set");
7759 if (!v4_src_address_set && !v6_src_address_set)
7761 errmsg ("no src addresses set");
7765 if (!(v4_src_address_set && v4_address_set) &&
7766 !(v6_src_address_set && v6_address_set))
7768 errmsg ("no matching server and src addresses set");
7772 /* Construct the API message */
7773 M (DHCP_PROXY_CONFIG_2, mp);
7775 mp->insert_circuit_id = insert_cid;
7776 mp->is_add = is_add;
7777 mp->rx_vrf_id = ntohl (rx_vrf_id);
7778 mp->server_vrf_id = ntohl (server_vrf_id);
7782 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
7783 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
7787 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
7788 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
7794 /* Wait for a reply, return good/bad news */
7800 api_dhcp_proxy_set_vss (vat_main_t * vam)
7802 unformat_input_t *i = vam->input;
7803 vl_api_dhcp_proxy_set_vss_t *mp;
7814 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7816 if (unformat (i, "tbl_id %d", &tbl_id))
7818 if (unformat (i, "fib_id %d", &fib_id))
7820 if (unformat (i, "oui %d", &oui))
7822 else if (unformat (i, "ipv6"))
7824 else if (unformat (i, "del"))
7828 clib_warning ("parse error '%U'", format_unformat_error, i);
7833 if (tbl_id_set == 0)
7835 errmsg ("missing tbl id");
7839 if (fib_id_set == 0)
7841 errmsg ("missing fib id");
7846 errmsg ("missing oui");
7850 M (DHCP_PROXY_SET_VSS, mp);
7851 mp->tbl_id = ntohl (tbl_id);
7852 mp->fib_id = ntohl (fib_id);
7853 mp->oui = ntohl (oui);
7854 mp->is_ipv6 = is_ipv6;
7855 mp->is_add = is_add;
7863 api_dhcp_client_config (vat_main_t * vam)
7865 unformat_input_t *i = vam->input;
7866 vl_api_dhcp_client_config_t *mp;
7868 u8 sw_if_index_set = 0;
7871 u8 disable_event = 0;
7874 /* Parse args required to build the message */
7875 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7877 if (unformat (i, "del"))
7880 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7881 sw_if_index_set = 1;
7882 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7883 sw_if_index_set = 1;
7884 else if (unformat (i, "hostname %s", &hostname))
7886 else if (unformat (i, "disable_event"))
7892 if (sw_if_index_set == 0)
7894 errmsg ("missing interface name or sw_if_index");
7898 if (vec_len (hostname) > 63)
7900 errmsg ("hostname too long");
7902 vec_add1 (hostname, 0);
7904 /* Construct the API message */
7905 M (DHCP_CLIENT_CONFIG, mp);
7907 mp->sw_if_index = ntohl (sw_if_index);
7908 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
7909 vec_free (hostname);
7910 mp->is_add = is_add;
7911 mp->want_dhcp_event = disable_event ? 0 : 1;
7912 mp->pid = getpid ();
7917 /* Wait for a reply, return good/bad news */
7923 api_set_ip_flow_hash (vat_main_t * vam)
7925 unformat_input_t *i = vam->input;
7926 vl_api_set_ip_flow_hash_t *mp;
7938 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7940 if (unformat (i, "vrf %d", &vrf_id))
7942 else if (unformat (i, "ipv6"))
7944 else if (unformat (i, "src"))
7946 else if (unformat (i, "dst"))
7948 else if (unformat (i, "sport"))
7950 else if (unformat (i, "dport"))
7952 else if (unformat (i, "proto"))
7954 else if (unformat (i, "reverse"))
7959 clib_warning ("parse error '%U'", format_unformat_error, i);
7964 if (vrf_id_set == 0)
7966 errmsg ("missing vrf id");
7970 M (SET_IP_FLOW_HASH, mp);
7976 mp->reverse = reverse;
7977 mp->vrf_id = ntohl (vrf_id);
7978 mp->is_ipv6 = is_ipv6;
7986 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
7988 unformat_input_t *i = vam->input;
7989 vl_api_sw_interface_ip6_enable_disable_t *mp;
7991 u8 sw_if_index_set = 0;
7995 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7997 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7998 sw_if_index_set = 1;
7999 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8000 sw_if_index_set = 1;
8001 else if (unformat (i, "enable"))
8003 else if (unformat (i, "disable"))
8007 clib_warning ("parse error '%U'", format_unformat_error, i);
8012 if (sw_if_index_set == 0)
8014 errmsg ("missing interface name or sw_if_index");
8018 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
8020 mp->sw_if_index = ntohl (sw_if_index);
8021 mp->enable = enable;
8029 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
8031 unformat_input_t *i = vam->input;
8032 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
8034 u8 sw_if_index_set = 0;
8035 u8 v6_address_set = 0;
8036 ip6_address_t v6address;
8039 /* Parse args required to build the message */
8040 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8042 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8043 sw_if_index_set = 1;
8044 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8045 sw_if_index_set = 1;
8046 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
8052 if (sw_if_index_set == 0)
8054 errmsg ("missing interface name or sw_if_index");
8057 if (!v6_address_set)
8059 errmsg ("no address set");
8063 /* Construct the API message */
8064 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, mp);
8066 mp->sw_if_index = ntohl (sw_if_index);
8067 clib_memcpy (mp->address, &v6address, sizeof (v6address));
8072 /* Wait for a reply, return good/bad news */
8079 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
8081 unformat_input_t *i = vam->input;
8082 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
8084 u8 sw_if_index_set = 0;
8085 u32 address_length = 0;
8086 u8 v6_address_set = 0;
8087 ip6_address_t v6address;
8089 u8 no_advertise = 0;
8091 u8 no_autoconfig = 0;
8094 u32 val_lifetime = 0;
8095 u32 pref_lifetime = 0;
8098 /* Parse args required to build the message */
8099 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8101 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8102 sw_if_index_set = 1;
8103 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8104 sw_if_index_set = 1;
8105 else if (unformat (i, "%U/%d",
8106 unformat_ip6_address, &v6address, &address_length))
8108 else if (unformat (i, "val_life %d", &val_lifetime))
8110 else if (unformat (i, "pref_life %d", &pref_lifetime))
8112 else if (unformat (i, "def"))
8114 else if (unformat (i, "noadv"))
8116 else if (unformat (i, "offl"))
8118 else if (unformat (i, "noauto"))
8120 else if (unformat (i, "nolink"))
8122 else if (unformat (i, "isno"))
8126 clib_warning ("parse error '%U'", format_unformat_error, i);
8131 if (sw_if_index_set == 0)
8133 errmsg ("missing interface name or sw_if_index");
8136 if (!v6_address_set)
8138 errmsg ("no address set");
8142 /* Construct the API message */
8143 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
8145 mp->sw_if_index = ntohl (sw_if_index);
8146 clib_memcpy (mp->address, &v6address, sizeof (v6address));
8147 mp->address_length = address_length;
8148 mp->use_default = use_default;
8149 mp->no_advertise = no_advertise;
8150 mp->off_link = off_link;
8151 mp->no_autoconfig = no_autoconfig;
8152 mp->no_onlink = no_onlink;
8154 mp->val_lifetime = ntohl (val_lifetime);
8155 mp->pref_lifetime = ntohl (pref_lifetime);
8160 /* Wait for a reply, return good/bad news */
8166 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
8168 unformat_input_t *i = vam->input;
8169 vl_api_sw_interface_ip6nd_ra_config_t *mp;
8171 u8 sw_if_index_set = 0;
8176 u8 send_unicast = 0;
8179 u8 default_router = 0;
8180 u32 max_interval = 0;
8181 u32 min_interval = 0;
8183 u32 initial_count = 0;
8184 u32 initial_interval = 0;
8188 /* Parse args required to build the message */
8189 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8191 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8192 sw_if_index_set = 1;
8193 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8194 sw_if_index_set = 1;
8195 else if (unformat (i, "maxint %d", &max_interval))
8197 else if (unformat (i, "minint %d", &min_interval))
8199 else if (unformat (i, "life %d", &lifetime))
8201 else if (unformat (i, "count %d", &initial_count))
8203 else if (unformat (i, "interval %d", &initial_interval))
8205 else if (unformat (i, "suppress") || unformat (i, "surpress"))
8207 else if (unformat (i, "managed"))
8209 else if (unformat (i, "other"))
8211 else if (unformat (i, "ll"))
8213 else if (unformat (i, "send"))
8215 else if (unformat (i, "cease"))
8217 else if (unformat (i, "isno"))
8219 else if (unformat (i, "def"))
8223 clib_warning ("parse error '%U'", format_unformat_error, i);
8228 if (sw_if_index_set == 0)
8230 errmsg ("missing interface name or sw_if_index");
8234 /* Construct the API message */
8235 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
8237 mp->sw_if_index = ntohl (sw_if_index);
8238 mp->max_interval = ntohl (max_interval);
8239 mp->min_interval = ntohl (min_interval);
8240 mp->lifetime = ntohl (lifetime);
8241 mp->initial_count = ntohl (initial_count);
8242 mp->initial_interval = ntohl (initial_interval);
8243 mp->suppress = suppress;
8244 mp->managed = managed;
8246 mp->ll_option = ll_option;
8247 mp->send_unicast = send_unicast;
8250 mp->default_router = default_router;
8255 /* Wait for a reply, return good/bad news */
8261 api_set_arp_neighbor_limit (vat_main_t * vam)
8263 unformat_input_t *i = vam->input;
8264 vl_api_set_arp_neighbor_limit_t *mp;
8270 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8272 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
8274 else if (unformat (i, "ipv6"))
8278 clib_warning ("parse error '%U'", format_unformat_error, i);
8285 errmsg ("missing limit value");
8289 M (SET_ARP_NEIGHBOR_LIMIT, mp);
8291 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
8292 mp->is_ipv6 = is_ipv6;
8300 api_l2_patch_add_del (vat_main_t * vam)
8302 unformat_input_t *i = vam->input;
8303 vl_api_l2_patch_add_del_t *mp;
8305 u8 rx_sw_if_index_set = 0;
8307 u8 tx_sw_if_index_set = 0;
8311 /* Parse args required to build the message */
8312 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8314 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
8315 rx_sw_if_index_set = 1;
8316 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
8317 tx_sw_if_index_set = 1;
8318 else if (unformat (i, "rx"))
8320 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8322 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
8324 rx_sw_if_index_set = 1;
8329 else if (unformat (i, "tx"))
8331 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8333 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
8335 tx_sw_if_index_set = 1;
8340 else if (unformat (i, "del"))
8346 if (rx_sw_if_index_set == 0)
8348 errmsg ("missing rx interface name or rx_sw_if_index");
8352 if (tx_sw_if_index_set == 0)
8354 errmsg ("missing tx interface name or tx_sw_if_index");
8358 M (L2_PATCH_ADD_DEL, mp);
8360 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
8361 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
8362 mp->is_add = is_add;
8370 api_ioam_enable (vat_main_t * vam)
8372 unformat_input_t *input = vam->input;
8373 vl_api_ioam_enable_t *mp;
8375 int has_trace_option = 0;
8376 int has_pot_option = 0;
8377 int has_seqno_option = 0;
8378 int has_analyse_option = 0;
8381 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8383 if (unformat (input, "trace"))
8384 has_trace_option = 1;
8385 else if (unformat (input, "pot"))
8387 else if (unformat (input, "seqno"))
8388 has_seqno_option = 1;
8389 else if (unformat (input, "analyse"))
8390 has_analyse_option = 1;
8394 M (IOAM_ENABLE, mp);
8395 mp->id = htons (id);
8396 mp->seqno = has_seqno_option;
8397 mp->analyse = has_analyse_option;
8398 mp->pot_enable = has_pot_option;
8399 mp->trace_enable = has_trace_option;
8408 api_ioam_disable (vat_main_t * vam)
8410 vl_api_ioam_disable_t *mp;
8413 M (IOAM_DISABLE, mp);
8420 api_sr_tunnel_add_del (vat_main_t * vam)
8422 unformat_input_t *i = vam->input;
8423 vl_api_sr_tunnel_add_del_t *mp;
8426 ip6_address_t src_address;
8427 int src_address_set = 0;
8428 ip6_address_t dst_address;
8430 int dst_address_set = 0;
8432 u32 rx_table_id = 0;
8433 u32 tx_table_id = 0;
8434 ip6_address_t *segments = 0;
8435 ip6_address_t *this_seg;
8436 ip6_address_t *tags = 0;
8437 ip6_address_t *this_tag;
8438 ip6_address_t next_address, tag;
8440 u8 *policy_name = 0;
8443 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8445 if (unformat (i, "del"))
8447 else if (unformat (i, "name %s", &name))
8449 else if (unformat (i, "policy %s", &policy_name))
8451 else if (unformat (i, "rx_fib_id %d", &rx_table_id))
8453 else if (unformat (i, "tx_fib_id %d", &tx_table_id))
8455 else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
8456 src_address_set = 1;
8457 else if (unformat (i, "dst %U/%d",
8458 unformat_ip6_address, &dst_address, &dst_mask_width))
8459 dst_address_set = 1;
8460 else if (unformat (i, "next %U", unformat_ip6_address, &next_address))
8462 vec_add2 (segments, this_seg, 1);
8463 clib_memcpy (this_seg->as_u8, next_address.as_u8,
8464 sizeof (*this_seg));
8466 else if (unformat (i, "tag %U", unformat_ip6_address, &tag))
8468 vec_add2 (tags, this_tag, 1);
8469 clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
8471 else if (unformat (i, "clean"))
8472 flags |= IP6_SR_HEADER_FLAG_CLEANUP;
8473 else if (unformat (i, "protected"))
8474 flags |= IP6_SR_HEADER_FLAG_PROTECTED;
8475 else if (unformat (i, "InPE %d", &pl_index))
8477 if (pl_index <= 0 || pl_index > 4)
8479 pl_index_range_error:
8480 errmsg ("pl index %d out of range", pl_index);
8484 IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE << (3 * (pl_index - 1));
8486 else if (unformat (i, "EgPE %d", &pl_index))
8488 if (pl_index <= 0 || pl_index > 4)
8489 goto pl_index_range_error;
8491 IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE << (3 * (pl_index - 1));
8493 else if (unformat (i, "OrgSrc %d", &pl_index))
8495 if (pl_index <= 0 || pl_index > 4)
8496 goto pl_index_range_error;
8498 IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3 * (pl_index - 1));
8504 if (!src_address_set)
8506 errmsg ("src address required");
8510 if (!dst_address_set)
8512 errmsg ("dst address required");
8518 errmsg ("at least one sr segment required");
8522 M2 (SR_TUNNEL_ADD_DEL, mp,
8523 vec_len (segments) * sizeof (ip6_address_t)
8524 + vec_len (tags) * sizeof (ip6_address_t));
8526 clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
8527 clib_memcpy (mp->dst_address, &dst_address, sizeof (mp->dst_address));
8528 mp->dst_mask_width = dst_mask_width;
8529 mp->flags_net_byte_order = clib_host_to_net_u16 (flags);
8530 mp->n_segments = vec_len (segments);
8531 mp->n_tags = vec_len (tags);
8532 mp->is_add = is_del == 0;
8533 clib_memcpy (mp->segs_and_tags, segments,
8534 vec_len (segments) * sizeof (ip6_address_t));
8535 clib_memcpy (mp->segs_and_tags +
8536 vec_len (segments) * sizeof (ip6_address_t), tags,
8537 vec_len (tags) * sizeof (ip6_address_t));
8539 mp->outer_vrf_id = ntohl (rx_table_id);
8540 mp->inner_vrf_id = ntohl (tx_table_id);
8541 memcpy (mp->name, name, vec_len (name));
8542 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
8544 vec_free (segments);
8553 api_sr_policy_add_del (vat_main_t * vam)
8555 unformat_input_t *input = vam->input;
8556 vl_api_sr_policy_add_del_t *mp;
8559 u8 *tunnel_name = 0;
8560 u8 **tunnel_names = 0;
8565 int tunnel_names_length = 1; // Init to 1 to offset the #tunnel_names counter byte
8566 int tun_name_len = 0; // Different naming convention used as confusing these would be "bad" (TM)
8569 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8571 if (unformat (input, "del"))
8573 else if (unformat (input, "name %s", &name))
8575 else if (unformat (input, "tunnel %s", &tunnel_name))
8579 vec_add1 (tunnel_names, tunnel_name);
8581 - length = #bytes to store in serial vector
8582 - +1 = byte to store that length
8584 tunnel_names_length += (vec_len (tunnel_name) + 1);
8595 errmsg ("policy name required");
8599 if ((!tunnel_set) && (!is_del))
8601 errmsg ("tunnel name required");
8605 M2 (SR_POLICY_ADD_DEL, mp, tunnel_names_length);
8609 mp->is_add = !is_del;
8611 memcpy (mp->name, name, vec_len (name));
8612 // Since mp->tunnel_names is of type u8[0] and not a u8 *, u8 ** needs to be serialized
8613 u8 *serial_orig = 0;
8614 vec_validate (serial_orig, tunnel_names_length);
8615 *serial_orig = vec_len (tunnel_names); // Store the number of tunnels as length in first byte of serialized vector
8616 serial_orig += 1; // Move along one byte to store the length of first tunnel_name
8618 for (j = 0; j < vec_len (tunnel_names); j++)
8620 tun_name_len = vec_len (tunnel_names[j]);
8621 *serial_orig = tun_name_len; // Store length of tunnel name in first byte of Length/Value pair
8622 serial_orig += 1; // Move along one byte to store the actual tunnel name
8623 memcpy (serial_orig, tunnel_names[j], tun_name_len);
8624 serial_orig += tun_name_len; // Advance past the copy
8626 memcpy (mp->tunnel_names, serial_orig - tunnel_names_length, tunnel_names_length); // Regress serial_orig to head then copy fwd
8628 vec_free (tunnel_names);
8629 vec_free (tunnel_name);
8637 api_sr_multicast_map_add_del (vat_main_t * vam)
8639 unformat_input_t *input = vam->input;
8640 vl_api_sr_multicast_map_add_del_t *mp;
8642 ip6_address_t multicast_address;
8643 u8 *policy_name = 0;
8644 int multicast_address_set = 0;
8647 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8649 if (unformat (input, "del"))
8653 (input, "address %U", unformat_ip6_address, &multicast_address))
8654 multicast_address_set = 1;
8655 else if (unformat (input, "sr-policy %s", &policy_name))
8661 if (!is_del && !policy_name)
8663 errmsg ("sr-policy name required");
8668 if (!multicast_address_set)
8670 errmsg ("address required");
8674 M (SR_MULTICAST_MAP_ADD_DEL, mp);
8676 mp->is_add = !is_del;
8677 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
8678 clib_memcpy (mp->multicast_address, &multicast_address,
8679 sizeof (mp->multicast_address));
8682 vec_free (policy_name);
8690 #define foreach_tcp_proto_field \
8694 #define foreach_udp_proto_field \
8698 #define foreach_ip4_proto_field \
8709 unformat_tcp_mask (unformat_input_t * input, va_list * args)
8711 u8 **maskp = va_arg (*args, u8 **);
8713 u8 found_something = 0;
8716 #define _(a) u8 a=0;
8717 foreach_tcp_proto_field;
8720 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8723 #define _(a) else if (unformat (input, #a)) a=1;
8724 foreach_tcp_proto_field
8730 #define _(a) found_something += a;
8731 foreach_tcp_proto_field;
8734 if (found_something == 0)
8737 vec_validate (mask, sizeof (*tcp) - 1);
8739 tcp = (tcp_header_t *) mask;
8741 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
8742 foreach_tcp_proto_field;
8750 unformat_udp_mask (unformat_input_t * input, va_list * args)
8752 u8 **maskp = va_arg (*args, u8 **);
8754 u8 found_something = 0;
8757 #define _(a) u8 a=0;
8758 foreach_udp_proto_field;
8761 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8764 #define _(a) else if (unformat (input, #a)) a=1;
8765 foreach_udp_proto_field
8771 #define _(a) found_something += a;
8772 foreach_udp_proto_field;
8775 if (found_something == 0)
8778 vec_validate (mask, sizeof (*udp) - 1);
8780 udp = (udp_header_t *) mask;
8782 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
8783 foreach_udp_proto_field;
8792 u16 src_port, dst_port;
8796 unformat_l4_mask (unformat_input_t * input, va_list * args)
8798 u8 **maskp = va_arg (*args, u8 **);
8799 u16 src_port = 0, dst_port = 0;
8800 tcpudp_header_t *tcpudp;
8802 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8804 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
8806 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
8808 else if (unformat (input, "src_port"))
8810 else if (unformat (input, "dst_port"))
8816 if (!src_port && !dst_port)
8820 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
8822 tcpudp = (tcpudp_header_t *) mask;
8823 tcpudp->src_port = src_port;
8824 tcpudp->dst_port = dst_port;
8832 unformat_ip4_mask (unformat_input_t * input, va_list * args)
8834 u8 **maskp = va_arg (*args, u8 **);
8836 u8 found_something = 0;
8839 #define _(a) u8 a=0;
8840 foreach_ip4_proto_field;
8846 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8848 if (unformat (input, "version"))
8850 else if (unformat (input, "hdr_length"))
8852 else if (unformat (input, "src"))
8854 else if (unformat (input, "dst"))
8856 else if (unformat (input, "proto"))
8859 #define _(a) else if (unformat (input, #a)) a=1;
8860 foreach_ip4_proto_field
8866 #define _(a) found_something += a;
8867 foreach_ip4_proto_field;
8870 if (found_something == 0)
8873 vec_validate (mask, sizeof (*ip) - 1);
8875 ip = (ip4_header_t *) mask;
8877 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
8878 foreach_ip4_proto_field;
8881 ip->ip_version_and_header_length = 0;
8884 ip->ip_version_and_header_length |= 0xF0;
8887 ip->ip_version_and_header_length |= 0x0F;
8893 #define foreach_ip6_proto_field \
8901 unformat_ip6_mask (unformat_input_t * input, va_list * args)
8903 u8 **maskp = va_arg (*args, u8 **);
8905 u8 found_something = 0;
8907 u32 ip_version_traffic_class_and_flow_label;
8909 #define _(a) u8 a=0;
8910 foreach_ip6_proto_field;
8913 u8 traffic_class = 0;
8916 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8918 if (unformat (input, "version"))
8920 else if (unformat (input, "traffic-class"))
8922 else if (unformat (input, "flow-label"))
8924 else if (unformat (input, "src"))
8926 else if (unformat (input, "dst"))
8928 else if (unformat (input, "proto"))
8931 #define _(a) else if (unformat (input, #a)) a=1;
8932 foreach_ip6_proto_field
8938 #define _(a) found_something += a;
8939 foreach_ip6_proto_field;
8942 if (found_something == 0)
8945 vec_validate (mask, sizeof (*ip) - 1);
8947 ip = (ip6_header_t *) mask;
8949 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
8950 foreach_ip6_proto_field;
8953 ip_version_traffic_class_and_flow_label = 0;
8956 ip_version_traffic_class_and_flow_label |= 0xF0000000;
8959 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
8962 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
8964 ip->ip_version_traffic_class_and_flow_label =
8965 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
8972 unformat_l3_mask (unformat_input_t * input, va_list * args)
8974 u8 **maskp = va_arg (*args, u8 **);
8976 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8978 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
8980 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
8989 unformat_l2_mask (unformat_input_t * input, va_list * args)
8991 u8 **maskp = va_arg (*args, u8 **);
9006 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9008 if (unformat (input, "src"))
9010 else if (unformat (input, "dst"))
9012 else if (unformat (input, "proto"))
9014 else if (unformat (input, "tag1"))
9016 else if (unformat (input, "tag2"))
9018 else if (unformat (input, "ignore-tag1"))
9020 else if (unformat (input, "ignore-tag2"))
9022 else if (unformat (input, "cos1"))
9024 else if (unformat (input, "cos2"))
9026 else if (unformat (input, "dot1q"))
9028 else if (unformat (input, "dot1ad"))
9033 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
9034 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9037 if (tag1 || ignore_tag1 || cos1 || dot1q)
9039 if (tag2 || ignore_tag2 || cos2 || dot1ad)
9042 vec_validate (mask, len - 1);
9045 memset (mask, 0xff, 6);
9048 memset (mask + 6, 0xff, 6);
9052 /* inner vlan tag */
9061 mask[21] = mask[20] = 0xff;
9082 mask[16] = mask[17] = 0xff;
9092 mask[12] = mask[13] = 0xff;
9099 unformat_classify_mask (unformat_input_t * input, va_list * args)
9101 u8 **maskp = va_arg (*args, u8 **);
9102 u32 *skipp = va_arg (*args, u32 *);
9103 u32 *matchp = va_arg (*args, u32 *);
9111 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9113 if (unformat (input, "hex %U", unformat_hex_string, &mask))
9115 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
9117 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
9119 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
9133 if (mask || l2 || l3 || l4)
9137 /* "With a free Ethernet header in every package" */
9139 vec_validate (l2, 13);
9143 vec_append (mask, l3);
9148 vec_append (mask, l4);
9153 /* Scan forward looking for the first significant mask octet */
9154 for (i = 0; i < vec_len (mask); i++)
9158 /* compute (skip, match) params */
9159 *skipp = i / sizeof (u32x4);
9160 vec_delete (mask, *skipp * sizeof (u32x4), 0);
9162 /* Pad mask to an even multiple of the vector size */
9163 while (vec_len (mask) % sizeof (u32x4))
9166 match = vec_len (mask) / sizeof (u32x4);
9168 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
9170 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
9171 if (*tmp || *(tmp + 1))
9176 clib_warning ("BUG: match 0");
9178 _vec_len (mask) = match * sizeof (u32x4);
9189 #define foreach_l2_next \
9191 _(ethernet, ETHERNET_INPUT) \
9196 unformat_l2_next_index (unformat_input_t * input, va_list * args)
9198 u32 *miss_next_indexp = va_arg (*args, u32 *);
9203 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
9207 if (unformat (input, "%d", &tmp))
9216 *miss_next_indexp = next_index;
9220 #define foreach_ip_next \
9226 unformat_ip_next_index (unformat_input_t * input, va_list * args)
9228 u32 *miss_next_indexp = va_arg (*args, u32 *);
9233 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
9237 if (unformat (input, "%d", &tmp))
9246 *miss_next_indexp = next_index;
9250 #define foreach_acl_next \
9254 unformat_acl_next_index (unformat_input_t * input, va_list * args)
9256 u32 *miss_next_indexp = va_arg (*args, u32 *);
9261 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
9265 if (unformat (input, "permit"))
9270 else if (unformat (input, "%d", &tmp))
9279 *miss_next_indexp = next_index;
9284 unformat_policer_precolor (unformat_input_t * input, va_list * args)
9286 u32 *r = va_arg (*args, u32 *);
9288 if (unformat (input, "conform-color"))
9289 *r = POLICE_CONFORM;
9290 else if (unformat (input, "exceed-color"))
9299 api_classify_add_del_table (vat_main_t * vam)
9301 unformat_input_t *i = vam->input;
9302 vl_api_classify_add_del_table_t *mp;
9309 u32 table_index = ~0;
9310 u32 next_table_index = ~0;
9311 u32 miss_next_index = ~0;
9312 u32 memory_size = 32 << 20;
9314 u32 current_data_flag = 0;
9315 int current_data_offset = 0;
9318 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9320 if (unformat (i, "del"))
9322 else if (unformat (i, "del-chain"))
9327 else if (unformat (i, "buckets %d", &nbuckets))
9329 else if (unformat (i, "memory_size %d", &memory_size))
9331 else if (unformat (i, "skip %d", &skip))
9333 else if (unformat (i, "match %d", &match))
9335 else if (unformat (i, "table %d", &table_index))
9337 else if (unformat (i, "mask %U", unformat_classify_mask,
9338 &mask, &skip, &match))
9340 else if (unformat (i, "next-table %d", &next_table_index))
9342 else if (unformat (i, "miss-next %U", unformat_ip_next_index,
9345 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
9348 else if (unformat (i, "acl-miss-next %U", unformat_acl_next_index,
9351 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
9353 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
9359 if (is_add && mask == 0)
9361 errmsg ("Mask required");
9365 if (is_add && skip == ~0)
9367 errmsg ("skip count required");
9371 if (is_add && match == ~0)
9373 errmsg ("match count required");
9377 if (!is_add && table_index == ~0)
9379 errmsg ("table index required for delete");
9383 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
9385 mp->is_add = is_add;
9386 mp->del_chain = del_chain;
9387 mp->table_index = ntohl (table_index);
9388 mp->nbuckets = ntohl (nbuckets);
9389 mp->memory_size = ntohl (memory_size);
9390 mp->skip_n_vectors = ntohl (skip);
9391 mp->match_n_vectors = ntohl (match);
9392 mp->next_table_index = ntohl (next_table_index);
9393 mp->miss_next_index = ntohl (miss_next_index);
9394 mp->current_data_flag = ntohl (current_data_flag);
9395 mp->current_data_offset = ntohl (current_data_offset);
9396 clib_memcpy (mp->mask, mask, vec_len (mask));
9406 unformat_l4_match (unformat_input_t * input, va_list * args)
9408 u8 **matchp = va_arg (*args, u8 **);
9410 u8 *proto_header = 0;
9416 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9418 if (unformat (input, "src_port %d", &src_port))
9420 else if (unformat (input, "dst_port %d", &dst_port))
9426 h.src_port = clib_host_to_net_u16 (src_port);
9427 h.dst_port = clib_host_to_net_u16 (dst_port);
9428 vec_validate (proto_header, sizeof (h) - 1);
9429 memcpy (proto_header, &h, sizeof (h));
9431 *matchp = proto_header;
9437 unformat_ip4_match (unformat_input_t * input, va_list * args)
9439 u8 **matchp = va_arg (*args, u8 **);
9446 int src = 0, dst = 0;
9447 ip4_address_t src_val, dst_val;
9454 int fragment_id = 0;
9455 u32 fragment_id_val;
9461 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9463 if (unformat (input, "version %d", &version_val))
9465 else if (unformat (input, "hdr_length %d", &hdr_length_val))
9467 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
9469 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
9471 else if (unformat (input, "proto %d", &proto_val))
9473 else if (unformat (input, "tos %d", &tos_val))
9475 else if (unformat (input, "length %d", &length_val))
9477 else if (unformat (input, "fragment_id %d", &fragment_id_val))
9479 else if (unformat (input, "ttl %d", &ttl_val))
9481 else if (unformat (input, "checksum %d", &checksum_val))
9487 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
9488 + ttl + checksum == 0)
9492 * Aligned because we use the real comparison functions
9494 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
9496 ip = (ip4_header_t *) match;
9498 /* These are realistically matched in practice */
9500 ip->src_address.as_u32 = src_val.as_u32;
9503 ip->dst_address.as_u32 = dst_val.as_u32;
9506 ip->protocol = proto_val;
9509 /* These are not, but they're included for completeness */
9511 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
9514 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
9520 ip->length = clib_host_to_net_u16 (length_val);
9526 ip->checksum = clib_host_to_net_u16 (checksum_val);
9533 unformat_ip6_match (unformat_input_t * input, va_list * args)
9535 u8 **matchp = va_arg (*args, u8 **);
9540 u8 traffic_class = 0;
9541 u32 traffic_class_val = 0;
9544 int src = 0, dst = 0;
9545 ip6_address_t src_val, dst_val;
9548 int payload_length = 0;
9549 u32 payload_length_val;
9552 u32 ip_version_traffic_class_and_flow_label;
9554 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9556 if (unformat (input, "version %d", &version_val))
9558 else if (unformat (input, "traffic_class %d", &traffic_class_val))
9560 else if (unformat (input, "flow_label %d", &flow_label_val))
9562 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
9564 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
9566 else if (unformat (input, "proto %d", &proto_val))
9568 else if (unformat (input, "payload_length %d", &payload_length_val))
9570 else if (unformat (input, "hop_limit %d", &hop_limit_val))
9576 if (version + traffic_class + flow_label + src + dst + proto +
9577 payload_length + hop_limit == 0)
9581 * Aligned because we use the real comparison functions
9583 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
9585 ip = (ip6_header_t *) match;
9588 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
9591 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
9594 ip->protocol = proto_val;
9596 ip_version_traffic_class_and_flow_label = 0;
9599 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
9602 ip_version_traffic_class_and_flow_label |=
9603 (traffic_class_val & 0xFF) << 20;
9606 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
9608 ip->ip_version_traffic_class_and_flow_label =
9609 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9612 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
9615 ip->hop_limit = hop_limit_val;
9622 unformat_l3_match (unformat_input_t * input, va_list * args)
9624 u8 **matchp = va_arg (*args, u8 **);
9626 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9628 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
9630 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
9639 unformat_vlan_tag (unformat_input_t * input, va_list * args)
9641 u8 *tagp = va_arg (*args, u8 *);
9644 if (unformat (input, "%d", &tag))
9646 tagp[0] = (tag >> 8) & 0x0F;
9647 tagp[1] = tag & 0xFF;
9655 unformat_l2_match (unformat_input_t * input, va_list * args)
9657 u8 **matchp = va_arg (*args, u8 **);
9677 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9679 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
9682 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
9684 else if (unformat (input, "proto %U",
9685 unformat_ethernet_type_host_byte_order, &proto_val))
9687 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
9689 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
9691 else if (unformat (input, "ignore-tag1"))
9693 else if (unformat (input, "ignore-tag2"))
9695 else if (unformat (input, "cos1 %d", &cos1_val))
9697 else if (unformat (input, "cos2 %d", &cos2_val))
9702 if ((src + dst + proto + tag1 + tag2 +
9703 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9706 if (tag1 || ignore_tag1 || cos1)
9708 if (tag2 || ignore_tag2 || cos2)
9711 vec_validate_aligned (match, len - 1, sizeof (u32x4));
9714 clib_memcpy (match, dst_val, 6);
9717 clib_memcpy (match + 6, src_val, 6);
9721 /* inner vlan tag */
9722 match[19] = tag2_val[1];
9723 match[18] = tag2_val[0];
9725 match[18] |= (cos2_val & 0x7) << 5;
9728 match[21] = proto_val & 0xff;
9729 match[20] = proto_val >> 8;
9733 match[15] = tag1_val[1];
9734 match[14] = tag1_val[0];
9737 match[14] |= (cos1_val & 0x7) << 5;
9743 match[15] = tag1_val[1];
9744 match[14] = tag1_val[0];
9747 match[17] = proto_val & 0xff;
9748 match[16] = proto_val >> 8;
9751 match[14] |= (cos1_val & 0x7) << 5;
9757 match[18] |= (cos2_val & 0x7) << 5;
9759 match[14] |= (cos1_val & 0x7) << 5;
9762 match[13] = proto_val & 0xff;
9763 match[12] = proto_val >> 8;
9772 unformat_classify_match (unformat_input_t * input, va_list * args)
9774 u8 **matchp = va_arg (*args, u8 **);
9775 u32 skip_n_vectors = va_arg (*args, u32);
9776 u32 match_n_vectors = va_arg (*args, u32);
9783 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9785 if (unformat (input, "hex %U", unformat_hex_string, &match))
9787 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
9789 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
9791 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
9805 if (match || l2 || l3 || l4)
9809 /* "Win a free Ethernet header in every packet" */
9811 vec_validate_aligned (l2, 13, sizeof (u32x4));
9815 vec_append_aligned (match, l3, sizeof (u32x4));
9820 vec_append_aligned (match, l4, sizeof (u32x4));
9825 /* Make sure the vector is big enough even if key is all 0's */
9826 vec_validate_aligned
9827 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
9830 /* Set size, include skipped vectors */
9831 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
9842 api_classify_add_del_session (vat_main_t * vam)
9844 unformat_input_t *i = vam->input;
9845 vl_api_classify_add_del_session_t *mp;
9847 u32 table_index = ~0;
9848 u32 hit_next_index = ~0;
9849 u32 opaque_index = ~0;
9852 u32 skip_n_vectors = 0;
9853 u32 match_n_vectors = 0;
9859 * Warning: you have to supply skip_n and match_n
9860 * because the API client cant simply look at the classify
9864 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9866 if (unformat (i, "del"))
9868 else if (unformat (i, "hit-next %U", unformat_ip_next_index,
9871 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
9874 else if (unformat (i, "acl-hit-next %U", unformat_acl_next_index,
9877 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
9879 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
9881 else if (unformat (i, "opaque-index %d", &opaque_index))
9883 else if (unformat (i, "skip_n %d", &skip_n_vectors))
9885 else if (unformat (i, "match_n %d", &match_n_vectors))
9887 else if (unformat (i, "match %U", unformat_classify_match,
9888 &match, skip_n_vectors, match_n_vectors))
9890 else if (unformat (i, "advance %d", &advance))
9892 else if (unformat (i, "table-index %d", &table_index))
9894 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
9896 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
9898 else if (unformat (i, "action %d", &action))
9900 else if (unformat (i, "metadata %d", &metadata))
9906 if (table_index == ~0)
9908 errmsg ("Table index required");
9912 if (is_add && match == 0)
9914 errmsg ("Match value required");
9918 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
9920 mp->is_add = is_add;
9921 mp->table_index = ntohl (table_index);
9922 mp->hit_next_index = ntohl (hit_next_index);
9923 mp->opaque_index = ntohl (opaque_index);
9924 mp->advance = ntohl (advance);
9925 mp->action = action;
9926 mp->metadata = ntohl (metadata);
9927 clib_memcpy (mp->match, match, vec_len (match));
9936 api_classify_set_interface_ip_table (vat_main_t * vam)
9938 unformat_input_t *i = vam->input;
9939 vl_api_classify_set_interface_ip_table_t *mp;
9941 int sw_if_index_set;
9942 u32 table_index = ~0;
9946 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9948 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9949 sw_if_index_set = 1;
9950 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9951 sw_if_index_set = 1;
9952 else if (unformat (i, "table %d", &table_index))
9956 clib_warning ("parse error '%U'", format_unformat_error, i);
9961 if (sw_if_index_set == 0)
9963 errmsg ("missing interface name or sw_if_index");
9968 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
9970 mp->sw_if_index = ntohl (sw_if_index);
9971 mp->table_index = ntohl (table_index);
9972 mp->is_ipv6 = is_ipv6;
9980 api_classify_set_interface_l2_tables (vat_main_t * vam)
9982 unformat_input_t *i = vam->input;
9983 vl_api_classify_set_interface_l2_tables_t *mp;
9985 int sw_if_index_set;
9986 u32 ip4_table_index = ~0;
9987 u32 ip6_table_index = ~0;
9988 u32 other_table_index = ~0;
9992 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9994 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9995 sw_if_index_set = 1;
9996 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9997 sw_if_index_set = 1;
9998 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10000 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10002 else if (unformat (i, "other-table %d", &other_table_index))
10004 else if (unformat (i, "is-input %d", &is_input))
10008 clib_warning ("parse error '%U'", format_unformat_error, i);
10013 if (sw_if_index_set == 0)
10015 errmsg ("missing interface name or sw_if_index");
10020 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
10022 mp->sw_if_index = ntohl (sw_if_index);
10023 mp->ip4_table_index = ntohl (ip4_table_index);
10024 mp->ip6_table_index = ntohl (ip6_table_index);
10025 mp->other_table_index = ntohl (other_table_index);
10026 mp->is_input = (u8) is_input;
10034 api_set_ipfix_exporter (vat_main_t * vam)
10036 unformat_input_t *i = vam->input;
10037 vl_api_set_ipfix_exporter_t *mp;
10038 ip4_address_t collector_address;
10039 u8 collector_address_set = 0;
10040 u32 collector_port = ~0;
10041 ip4_address_t src_address;
10042 u8 src_address_set = 0;
10045 u32 template_interval = ~0;
10046 u8 udp_checksum = 0;
10049 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10051 if (unformat (i, "collector_address %U", unformat_ip4_address,
10052 &collector_address))
10053 collector_address_set = 1;
10054 else if (unformat (i, "collector_port %d", &collector_port))
10056 else if (unformat (i, "src_address %U", unformat_ip4_address,
10058 src_address_set = 1;
10059 else if (unformat (i, "vrf_id %d", &vrf_id))
10061 else if (unformat (i, "path_mtu %d", &path_mtu))
10063 else if (unformat (i, "template_interval %d", &template_interval))
10065 else if (unformat (i, "udp_checksum"))
10071 if (collector_address_set == 0)
10073 errmsg ("collector_address required");
10077 if (src_address_set == 0)
10079 errmsg ("src_address required");
10083 M (SET_IPFIX_EXPORTER, mp);
10085 memcpy (mp->collector_address, collector_address.data,
10086 sizeof (collector_address.data));
10087 mp->collector_port = htons ((u16) collector_port);
10088 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
10089 mp->vrf_id = htonl (vrf_id);
10090 mp->path_mtu = htonl (path_mtu);
10091 mp->template_interval = htonl (template_interval);
10092 mp->udp_checksum = udp_checksum;
10100 api_set_ipfix_classify_stream (vat_main_t * vam)
10102 unformat_input_t *i = vam->input;
10103 vl_api_set_ipfix_classify_stream_t *mp;
10105 u32 src_port = UDP_DST_PORT_ipfix;
10108 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10110 if (unformat (i, "domain %d", &domain_id))
10112 else if (unformat (i, "src_port %d", &src_port))
10116 errmsg ("unknown input `%U'", format_unformat_error, i);
10121 M (SET_IPFIX_CLASSIFY_STREAM, mp);
10123 mp->domain_id = htonl (domain_id);
10124 mp->src_port = htons ((u16) src_port);
10132 api_ipfix_classify_table_add_del (vat_main_t * vam)
10134 unformat_input_t *i = vam->input;
10135 vl_api_ipfix_classify_table_add_del_t *mp;
10137 u32 classify_table_index = ~0;
10139 u8 transport_protocol = 255;
10142 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10144 if (unformat (i, "add"))
10146 else if (unformat (i, "del"))
10148 else if (unformat (i, "table %d", &classify_table_index))
10150 else if (unformat (i, "ip4"))
10152 else if (unformat (i, "ip6"))
10154 else if (unformat (i, "tcp"))
10155 transport_protocol = 6;
10156 else if (unformat (i, "udp"))
10157 transport_protocol = 17;
10160 errmsg ("unknown input `%U'", format_unformat_error, i);
10167 errmsg ("expecting: add|del");
10170 if (classify_table_index == ~0)
10172 errmsg ("classifier table not specified");
10175 if (ip_version == 0)
10177 errmsg ("IP version not specified");
10181 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
10183 mp->is_add = is_add;
10184 mp->table_id = htonl (classify_table_index);
10185 mp->ip_version = ip_version;
10186 mp->transport_protocol = transport_protocol;
10194 api_get_node_index (vat_main_t * vam)
10196 unformat_input_t *i = vam->input;
10197 vl_api_get_node_index_t *mp;
10201 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10203 if (unformat (i, "node %s", &name))
10210 errmsg ("node name required");
10213 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10215 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10219 M (GET_NODE_INDEX, mp);
10220 clib_memcpy (mp->node_name, name, vec_len (name));
10229 api_get_next_index (vat_main_t * vam)
10231 unformat_input_t *i = vam->input;
10232 vl_api_get_next_index_t *mp;
10233 u8 *node_name = 0, *next_node_name = 0;
10236 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10238 if (unformat (i, "node-name %s", &node_name))
10240 else if (unformat (i, "next-node-name %s", &next_node_name))
10244 if (node_name == 0)
10246 errmsg ("node name required");
10249 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
10251 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10255 if (next_node_name == 0)
10257 errmsg ("next node name required");
10260 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
10262 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
10266 M (GET_NEXT_INDEX, mp);
10267 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
10268 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
10269 vec_free (node_name);
10270 vec_free (next_node_name);
10278 api_add_node_next (vat_main_t * vam)
10280 unformat_input_t *i = vam->input;
10281 vl_api_add_node_next_t *mp;
10286 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10288 if (unformat (i, "node %s", &name))
10290 else if (unformat (i, "next %s", &next))
10297 errmsg ("node name required");
10300 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10302 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10307 errmsg ("next node required");
10310 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
10312 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
10316 M (ADD_NODE_NEXT, mp);
10317 clib_memcpy (mp->node_name, name, vec_len (name));
10318 clib_memcpy (mp->next_name, next, vec_len (next));
10328 api_l2tpv3_create_tunnel (vat_main_t * vam)
10330 unformat_input_t *i = vam->input;
10331 ip6_address_t client_address, our_address;
10332 int client_address_set = 0;
10333 int our_address_set = 0;
10334 u32 local_session_id = 0;
10335 u32 remote_session_id = 0;
10336 u64 local_cookie = 0;
10337 u64 remote_cookie = 0;
10338 u8 l2_sublayer_present = 0;
10339 vl_api_l2tpv3_create_tunnel_t *mp;
10342 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10344 if (unformat (i, "client_address %U", unformat_ip6_address,
10346 client_address_set = 1;
10347 else if (unformat (i, "our_address %U", unformat_ip6_address,
10349 our_address_set = 1;
10350 else if (unformat (i, "local_session_id %d", &local_session_id))
10352 else if (unformat (i, "remote_session_id %d", &remote_session_id))
10354 else if (unformat (i, "local_cookie %lld", &local_cookie))
10356 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
10358 else if (unformat (i, "l2-sublayer-present"))
10359 l2_sublayer_present = 1;
10364 if (client_address_set == 0)
10366 errmsg ("client_address required");
10370 if (our_address_set == 0)
10372 errmsg ("our_address required");
10376 M (L2TPV3_CREATE_TUNNEL, mp);
10378 clib_memcpy (mp->client_address, client_address.as_u8,
10379 sizeof (mp->client_address));
10381 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
10383 mp->local_session_id = ntohl (local_session_id);
10384 mp->remote_session_id = ntohl (remote_session_id);
10385 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
10386 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
10387 mp->l2_sublayer_present = l2_sublayer_present;
10396 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
10398 unformat_input_t *i = vam->input;
10400 u8 sw_if_index_set = 0;
10401 u64 new_local_cookie = 0;
10402 u64 new_remote_cookie = 0;
10403 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
10406 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10408 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10409 sw_if_index_set = 1;
10410 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10411 sw_if_index_set = 1;
10412 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
10414 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
10420 if (sw_if_index_set == 0)
10422 errmsg ("missing interface name or sw_if_index");
10426 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
10428 mp->sw_if_index = ntohl (sw_if_index);
10429 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
10430 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
10438 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
10440 unformat_input_t *i = vam->input;
10441 vl_api_l2tpv3_interface_enable_disable_t *mp;
10443 u8 sw_if_index_set = 0;
10444 u8 enable_disable = 1;
10447 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10449 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10450 sw_if_index_set = 1;
10451 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10452 sw_if_index_set = 1;
10453 else if (unformat (i, "enable"))
10454 enable_disable = 1;
10455 else if (unformat (i, "disable"))
10456 enable_disable = 0;
10461 if (sw_if_index_set == 0)
10463 errmsg ("missing interface name or sw_if_index");
10467 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
10469 mp->sw_if_index = ntohl (sw_if_index);
10470 mp->enable_disable = enable_disable;
10478 api_l2tpv3_set_lookup_key (vat_main_t * vam)
10480 unformat_input_t *i = vam->input;
10481 vl_api_l2tpv3_set_lookup_key_t *mp;
10485 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10487 if (unformat (i, "lookup_v6_src"))
10488 key = L2T_LOOKUP_SRC_ADDRESS;
10489 else if (unformat (i, "lookup_v6_dst"))
10490 key = L2T_LOOKUP_DST_ADDRESS;
10491 else if (unformat (i, "lookup_session_id"))
10492 key = L2T_LOOKUP_SESSION_ID;
10497 if (key == (u8) ~ 0)
10499 errmsg ("l2tp session lookup key unset");
10503 M (L2TPV3_SET_LOOKUP_KEY, mp);
10512 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
10513 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
10515 vat_main_t *vam = &vat_main;
10517 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
10518 format_ip6_address, mp->our_address,
10519 format_ip6_address, mp->client_address,
10520 clib_net_to_host_u32 (mp->sw_if_index));
10523 " local cookies %016llx %016llx remote cookie %016llx",
10524 clib_net_to_host_u64 (mp->local_cookie[0]),
10525 clib_net_to_host_u64 (mp->local_cookie[1]),
10526 clib_net_to_host_u64 (mp->remote_cookie));
10528 print (vam->ofp, " local session-id %d remote session-id %d",
10529 clib_net_to_host_u32 (mp->local_session_id),
10530 clib_net_to_host_u32 (mp->remote_session_id));
10532 print (vam->ofp, " l2 specific sublayer %s\n",
10533 mp->l2_sublayer_present ? "preset" : "absent");
10537 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
10538 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
10540 vat_main_t *vam = &vat_main;
10541 vat_json_node_t *node = NULL;
10542 struct in6_addr addr;
10544 if (VAT_JSON_ARRAY != vam->json_tree.type)
10546 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10547 vat_json_init_array (&vam->json_tree);
10549 node = vat_json_array_add (&vam->json_tree);
10551 vat_json_init_object (node);
10553 clib_memcpy (&addr, mp->our_address, sizeof (addr));
10554 vat_json_object_add_ip6 (node, "our_address", addr);
10555 clib_memcpy (&addr, mp->client_address, sizeof (addr));
10556 vat_json_object_add_ip6 (node, "client_address", addr);
10558 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
10559 vat_json_init_array (lc);
10560 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
10561 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
10562 vat_json_object_add_uint (node, "remote_cookie",
10563 clib_net_to_host_u64 (mp->remote_cookie));
10565 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
10566 vat_json_object_add_uint (node, "local_session_id",
10567 clib_net_to_host_u32 (mp->local_session_id));
10568 vat_json_object_add_uint (node, "remote_session_id",
10569 clib_net_to_host_u32 (mp->remote_session_id));
10570 vat_json_object_add_string_copy (node, "l2_sublayer",
10571 mp->l2_sublayer_present ? (u8 *) "present"
10572 : (u8 *) "absent");
10576 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
10578 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
10581 /* Get list of l2tpv3-tunnel interfaces */
10582 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
10585 /* Use a control ping for synchronization */
10587 vl_api_control_ping_t *mp;
10588 M (CONTROL_PING, mp);
10596 static void vl_api_sw_interface_tap_details_t_handler
10597 (vl_api_sw_interface_tap_details_t * mp)
10599 vat_main_t *vam = &vat_main;
10601 print (vam->ofp, "%-16s %d",
10602 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
10605 static void vl_api_sw_interface_tap_details_t_handler_json
10606 (vl_api_sw_interface_tap_details_t * mp)
10608 vat_main_t *vam = &vat_main;
10609 vat_json_node_t *node = NULL;
10611 if (VAT_JSON_ARRAY != vam->json_tree.type)
10613 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10614 vat_json_init_array (&vam->json_tree);
10616 node = vat_json_array_add (&vam->json_tree);
10618 vat_json_init_object (node);
10619 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10620 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
10624 api_sw_interface_tap_dump (vat_main_t * vam)
10626 vl_api_sw_interface_tap_dump_t *mp;
10629 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
10630 /* Get list of tap interfaces */
10631 M (SW_INTERFACE_TAP_DUMP, mp);
10634 /* Use a control ping for synchronization */
10636 vl_api_control_ping_t *mp;
10637 M (CONTROL_PING, mp);
10644 static uword unformat_vxlan_decap_next
10645 (unformat_input_t * input, va_list * args)
10647 u32 *result = va_arg (*args, u32 *);
10650 if (unformat (input, "l2"))
10651 *result = VXLAN_INPUT_NEXT_L2_INPUT;
10652 else if (unformat (input, "%d", &tmp))
10660 api_vxlan_add_del_tunnel (vat_main_t * vam)
10662 unformat_input_t *line_input = vam->input;
10663 vl_api_vxlan_add_del_tunnel_t *mp;
10664 ip46_address_t src, dst;
10666 u8 ipv4_set = 0, ipv6_set = 0;
10670 u32 mcast_sw_if_index = ~0;
10671 u32 encap_vrf_id = 0;
10672 u32 decap_next_index = ~0;
10676 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
10677 memset (&src, 0, sizeof src);
10678 memset (&dst, 0, sizeof dst);
10680 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10682 if (unformat (line_input, "del"))
10685 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
10691 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
10697 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
10703 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
10708 else if (unformat (line_input, "group %U %U",
10709 unformat_ip4_address, &dst.ip4,
10710 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
10712 grp_set = dst_set = 1;
10715 else if (unformat (line_input, "group %U",
10716 unformat_ip4_address, &dst.ip4))
10718 grp_set = dst_set = 1;
10721 else if (unformat (line_input, "group %U %U",
10722 unformat_ip6_address, &dst.ip6,
10723 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
10725 grp_set = dst_set = 1;
10728 else if (unformat (line_input, "group %U",
10729 unformat_ip6_address, &dst.ip6))
10731 grp_set = dst_set = 1;
10735 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
10737 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
10739 else if (unformat (line_input, "decap-next %U",
10740 unformat_vxlan_decap_next, &decap_next_index))
10742 else if (unformat (line_input, "vni %d", &vni))
10746 errmsg ("parse error '%U'", format_unformat_error, line_input);
10753 errmsg ("tunnel src address not specified");
10758 errmsg ("tunnel dst address not specified");
10762 if (grp_set && !ip46_address_is_multicast (&dst))
10764 errmsg ("tunnel group address not multicast");
10767 if (grp_set && mcast_sw_if_index == ~0)
10769 errmsg ("tunnel nonexistent multicast device");
10772 if (grp_set == 0 && ip46_address_is_multicast (&dst))
10774 errmsg ("tunnel dst address must be unicast");
10779 if (ipv4_set && ipv6_set)
10781 errmsg ("both IPv4 and IPv6 addresses specified");
10785 if ((vni == 0) || (vni >> 24))
10787 errmsg ("vni not specified or out of range");
10791 M (VXLAN_ADD_DEL_TUNNEL, mp);
10795 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
10796 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
10800 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
10801 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
10803 mp->encap_vrf_id = ntohl (encap_vrf_id);
10804 mp->decap_next_index = ntohl (decap_next_index);
10805 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
10806 mp->vni = ntohl (vni);
10807 mp->is_add = is_add;
10808 mp->is_ipv6 = ipv6_set;
10815 static void vl_api_vxlan_tunnel_details_t_handler
10816 (vl_api_vxlan_tunnel_details_t * mp)
10818 vat_main_t *vam = &vat_main;
10819 ip46_address_t src, dst;
10821 ip46_from_addr_buf (mp->is_ipv6, mp->src_address, &src);
10822 ip46_from_addr_buf (mp->is_ipv6, mp->dst_address, &dst);
10824 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
10825 ntohl (mp->sw_if_index),
10826 format_ip46_address, &src, IP46_TYPE_ANY,
10827 format_ip46_address, &dst, IP46_TYPE_ANY,
10828 ntohl (mp->encap_vrf_id),
10829 ntohl (mp->decap_next_index), ntohl (mp->vni),
10830 ntohl (mp->mcast_sw_if_index));
10833 static void vl_api_vxlan_tunnel_details_t_handler_json
10834 (vl_api_vxlan_tunnel_details_t * mp)
10836 vat_main_t *vam = &vat_main;
10837 vat_json_node_t *node = NULL;
10839 if (VAT_JSON_ARRAY != vam->json_tree.type)
10841 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10842 vat_json_init_array (&vam->json_tree);
10844 node = vat_json_array_add (&vam->json_tree);
10846 vat_json_init_object (node);
10847 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10850 struct in6_addr ip6;
10852 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
10853 vat_json_object_add_ip6 (node, "src_address", ip6);
10854 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
10855 vat_json_object_add_ip6 (node, "dst_address", ip6);
10859 struct in_addr ip4;
10861 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
10862 vat_json_object_add_ip4 (node, "src_address", ip4);
10863 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
10864 vat_json_object_add_ip4 (node, "dst_address", ip4);
10866 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
10867 vat_json_object_add_uint (node, "decap_next_index",
10868 ntohl (mp->decap_next_index));
10869 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
10870 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
10871 vat_json_object_add_uint (node, "mcast_sw_if_index",
10872 ntohl (mp->mcast_sw_if_index));
10876 api_vxlan_tunnel_dump (vat_main_t * vam)
10878 unformat_input_t *i = vam->input;
10879 vl_api_vxlan_tunnel_dump_t *mp;
10881 u8 sw_if_index_set = 0;
10884 /* Parse args required to build the message */
10885 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10887 if (unformat (i, "sw_if_index %d", &sw_if_index))
10888 sw_if_index_set = 1;
10893 if (sw_if_index_set == 0)
10898 if (!vam->json_output)
10900 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
10901 "sw_if_index", "src_address", "dst_address",
10902 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
10905 /* Get list of vxlan-tunnel interfaces */
10906 M (VXLAN_TUNNEL_DUMP, mp);
10908 mp->sw_if_index = htonl (sw_if_index);
10912 /* Use a control ping for synchronization */
10914 vl_api_control_ping_t *mp;
10915 M (CONTROL_PING, mp);
10923 api_gre_add_del_tunnel (vat_main_t * vam)
10925 unformat_input_t *line_input = vam->input;
10926 vl_api_gre_add_del_tunnel_t *mp;
10927 ip4_address_t src4, dst4;
10932 u32 outer_fib_id = 0;
10935 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10937 if (unformat (line_input, "del"))
10939 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
10941 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
10943 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
10945 else if (unformat (line_input, "teb"))
10949 errmsg ("parse error '%U'", format_unformat_error, line_input);
10956 errmsg ("tunnel src address not specified");
10961 errmsg ("tunnel dst address not specified");
10966 M (GRE_ADD_DEL_TUNNEL, mp);
10968 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
10969 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
10970 mp->outer_fib_id = ntohl (outer_fib_id);
10971 mp->is_add = is_add;
10979 static void vl_api_gre_tunnel_details_t_handler
10980 (vl_api_gre_tunnel_details_t * mp)
10982 vat_main_t *vam = &vat_main;
10984 print (vam->ofp, "%11d%15U%15U%6d%14d",
10985 ntohl (mp->sw_if_index),
10986 format_ip4_address, &mp->src_address,
10987 format_ip4_address, &mp->dst_address,
10988 mp->teb, ntohl (mp->outer_fib_id));
10991 static void vl_api_gre_tunnel_details_t_handler_json
10992 (vl_api_gre_tunnel_details_t * mp)
10994 vat_main_t *vam = &vat_main;
10995 vat_json_node_t *node = NULL;
10996 struct in_addr ip4;
10998 if (VAT_JSON_ARRAY != vam->json_tree.type)
11000 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11001 vat_json_init_array (&vam->json_tree);
11003 node = vat_json_array_add (&vam->json_tree);
11005 vat_json_init_object (node);
11006 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11007 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
11008 vat_json_object_add_ip4 (node, "src_address", ip4);
11009 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
11010 vat_json_object_add_ip4 (node, "dst_address", ip4);
11011 vat_json_object_add_uint (node, "teb", mp->teb);
11012 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
11016 api_gre_tunnel_dump (vat_main_t * vam)
11018 unformat_input_t *i = vam->input;
11019 vl_api_gre_tunnel_dump_t *mp;
11021 u8 sw_if_index_set = 0;
11024 /* Parse args required to build the message */
11025 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11027 if (unformat (i, "sw_if_index %d", &sw_if_index))
11028 sw_if_index_set = 1;
11033 if (sw_if_index_set == 0)
11038 if (!vam->json_output)
11040 print (vam->ofp, "%11s%15s%15s%6s%14s",
11041 "sw_if_index", "src_address", "dst_address", "teb",
11045 /* Get list of gre-tunnel interfaces */
11046 M (GRE_TUNNEL_DUMP, mp);
11048 mp->sw_if_index = htonl (sw_if_index);
11052 /* Use a control ping for synchronization */
11054 vl_api_control_ping_t *mp;
11055 M (CONTROL_PING, mp);
11063 api_l2_fib_clear_table (vat_main_t * vam)
11065 // unformat_input_t * i = vam->input;
11066 vl_api_l2_fib_clear_table_t *mp;
11069 M (L2_FIB_CLEAR_TABLE, mp);
11077 api_l2_interface_efp_filter (vat_main_t * vam)
11079 unformat_input_t *i = vam->input;
11080 vl_api_l2_interface_efp_filter_t *mp;
11083 u8 sw_if_index_set = 0;
11086 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11088 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11089 sw_if_index_set = 1;
11090 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11091 sw_if_index_set = 1;
11092 else if (unformat (i, "enable"))
11094 else if (unformat (i, "disable"))
11098 clib_warning ("parse error '%U'", format_unformat_error, i);
11103 if (sw_if_index_set == 0)
11105 errmsg ("missing sw_if_index");
11109 M (L2_INTERFACE_EFP_FILTER, mp);
11111 mp->sw_if_index = ntohl (sw_if_index);
11112 mp->enable_disable = enable;
11119 #define foreach_vtr_op \
11120 _("disable", L2_VTR_DISABLED) \
11121 _("push-1", L2_VTR_PUSH_1) \
11122 _("push-2", L2_VTR_PUSH_2) \
11123 _("pop-1", L2_VTR_POP_1) \
11124 _("pop-2", L2_VTR_POP_2) \
11125 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
11126 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
11127 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
11128 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
11131 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
11133 unformat_input_t *i = vam->input;
11134 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
11136 u8 sw_if_index_set = 0;
11139 u32 push_dot1q = 1;
11144 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11146 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11147 sw_if_index_set = 1;
11148 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11149 sw_if_index_set = 1;
11150 else if (unformat (i, "vtr_op %d", &vtr_op))
11152 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
11155 else if (unformat (i, "push_dot1q %d", &push_dot1q))
11157 else if (unformat (i, "tag1 %d", &tag1))
11159 else if (unformat (i, "tag2 %d", &tag2))
11163 clib_warning ("parse error '%U'", format_unformat_error, i);
11168 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
11170 errmsg ("missing vtr operation or sw_if_index");
11174 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
11175 mp->sw_if_index = ntohl (sw_if_index);
11176 mp->vtr_op = ntohl (vtr_op);
11177 mp->push_dot1q = ntohl (push_dot1q);
11178 mp->tag1 = ntohl (tag1);
11179 mp->tag2 = ntohl (tag2);
11187 api_create_vhost_user_if (vat_main_t * vam)
11189 unformat_input_t *i = vam->input;
11190 vl_api_create_vhost_user_if_t *mp;
11193 u8 file_name_set = 0;
11194 u32 custom_dev_instance = ~0;
11196 u8 use_custom_mac = 0;
11200 /* Shut up coverity */
11201 memset (hwaddr, 0, sizeof (hwaddr));
11203 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11205 if (unformat (i, "socket %s", &file_name))
11209 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
11211 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
11212 use_custom_mac = 1;
11213 else if (unformat (i, "server"))
11215 else if (unformat (i, "tag %s", &tag))
11221 if (file_name_set == 0)
11223 errmsg ("missing socket file name");
11227 if (vec_len (file_name) > 255)
11229 errmsg ("socket file name too long");
11232 vec_add1 (file_name, 0);
11234 M (CREATE_VHOST_USER_IF, mp);
11236 mp->is_server = is_server;
11237 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
11238 vec_free (file_name);
11239 if (custom_dev_instance != ~0)
11242 mp->custom_dev_instance = ntohl (custom_dev_instance);
11244 mp->use_custom_mac = use_custom_mac;
11245 clib_memcpy (mp->mac_address, hwaddr, 6);
11247 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
11256 api_modify_vhost_user_if (vat_main_t * vam)
11258 unformat_input_t *i = vam->input;
11259 vl_api_modify_vhost_user_if_t *mp;
11262 u8 file_name_set = 0;
11263 u32 custom_dev_instance = ~0;
11264 u8 sw_if_index_set = 0;
11265 u32 sw_if_index = (u32) ~ 0;
11268 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11270 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11271 sw_if_index_set = 1;
11272 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11273 sw_if_index_set = 1;
11274 else if (unformat (i, "socket %s", &file_name))
11278 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
11280 else if (unformat (i, "server"))
11286 if (sw_if_index_set == 0)
11288 errmsg ("missing sw_if_index or interface name");
11292 if (file_name_set == 0)
11294 errmsg ("missing socket file name");
11298 if (vec_len (file_name) > 255)
11300 errmsg ("socket file name too long");
11303 vec_add1 (file_name, 0);
11305 M (MODIFY_VHOST_USER_IF, mp);
11307 mp->sw_if_index = ntohl (sw_if_index);
11308 mp->is_server = is_server;
11309 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
11310 vec_free (file_name);
11311 if (custom_dev_instance != ~0)
11314 mp->custom_dev_instance = ntohl (custom_dev_instance);
11323 api_delete_vhost_user_if (vat_main_t * vam)
11325 unformat_input_t *i = vam->input;
11326 vl_api_delete_vhost_user_if_t *mp;
11327 u32 sw_if_index = ~0;
11328 u8 sw_if_index_set = 0;
11331 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11333 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11334 sw_if_index_set = 1;
11335 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11336 sw_if_index_set = 1;
11341 if (sw_if_index_set == 0)
11343 errmsg ("missing sw_if_index or interface name");
11348 M (DELETE_VHOST_USER_IF, mp);
11350 mp->sw_if_index = ntohl (sw_if_index);
11357 static void vl_api_sw_interface_vhost_user_details_t_handler
11358 (vl_api_sw_interface_vhost_user_details_t * mp)
11360 vat_main_t *vam = &vat_main;
11362 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
11363 (char *) mp->interface_name,
11364 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
11365 clib_net_to_host_u64 (mp->features), mp->is_server,
11366 ntohl (mp->num_regions), (char *) mp->sock_filename);
11367 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
11370 static void vl_api_sw_interface_vhost_user_details_t_handler_json
11371 (vl_api_sw_interface_vhost_user_details_t * mp)
11373 vat_main_t *vam = &vat_main;
11374 vat_json_node_t *node = NULL;
11376 if (VAT_JSON_ARRAY != vam->json_tree.type)
11378 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11379 vat_json_init_array (&vam->json_tree);
11381 node = vat_json_array_add (&vam->json_tree);
11383 vat_json_init_object (node);
11384 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11385 vat_json_object_add_string_copy (node, "interface_name",
11386 mp->interface_name);
11387 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
11388 ntohl (mp->virtio_net_hdr_sz));
11389 vat_json_object_add_uint (node, "features",
11390 clib_net_to_host_u64 (mp->features));
11391 vat_json_object_add_uint (node, "is_server", mp->is_server);
11392 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
11393 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
11394 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
11398 api_sw_interface_vhost_user_dump (vat_main_t * vam)
11400 vl_api_sw_interface_vhost_user_dump_t *mp;
11403 "Interface name idx hdr_sz features server regions filename");
11405 /* Get list of vhost-user interfaces */
11406 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
11409 /* Use a control ping for synchronization */
11411 vl_api_control_ping_t *mp;
11412 M (CONTROL_PING, mp);
11420 api_show_version (vat_main_t * vam)
11422 vl_api_show_version_t *mp;
11425 M (SHOW_VERSION, mp);
11434 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
11436 unformat_input_t *line_input = vam->input;
11437 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
11438 ip4_address_t local4, remote4;
11439 ip6_address_t local6, remote6;
11441 u8 ipv4_set = 0, ipv6_set = 0;
11444 u32 encap_vrf_id = 0;
11445 u32 decap_vrf_id = 0;
11451 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11453 if (unformat (line_input, "del"))
11455 else if (unformat (line_input, "local %U",
11456 unformat_ip4_address, &local4))
11461 else if (unformat (line_input, "remote %U",
11462 unformat_ip4_address, &remote4))
11467 else if (unformat (line_input, "local %U",
11468 unformat_ip6_address, &local6))
11473 else if (unformat (line_input, "remote %U",
11474 unformat_ip6_address, &remote6))
11479 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11481 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
11483 else if (unformat (line_input, "vni %d", &vni))
11485 else if (unformat (line_input, "next-ip4"))
11487 else if (unformat (line_input, "next-ip6"))
11489 else if (unformat (line_input, "next-ethernet"))
11491 else if (unformat (line_input, "next-nsh"))
11495 errmsg ("parse error '%U'", format_unformat_error, line_input);
11500 if (local_set == 0)
11502 errmsg ("tunnel local address not specified");
11505 if (remote_set == 0)
11507 errmsg ("tunnel remote address not specified");
11510 if (ipv4_set && ipv6_set)
11512 errmsg ("both IPv4 and IPv6 addresses specified");
11518 errmsg ("vni not specified");
11522 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
11527 clib_memcpy (&mp->local, &local6, sizeof (local6));
11528 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
11532 clib_memcpy (&mp->local, &local4, sizeof (local4));
11533 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
11536 mp->encap_vrf_id = ntohl (encap_vrf_id);
11537 mp->decap_vrf_id = ntohl (decap_vrf_id);
11538 mp->protocol = protocol;
11539 mp->vni = ntohl (vni);
11540 mp->is_add = is_add;
11541 mp->is_ipv6 = ipv6_set;
11548 static void vl_api_vxlan_gpe_tunnel_details_t_handler
11549 (vl_api_vxlan_gpe_tunnel_details_t * mp)
11551 vat_main_t *vam = &vat_main;
11553 print (vam->ofp, "%11d%24U%24U%13d%12d%14d%14d",
11554 ntohl (mp->sw_if_index),
11555 format_ip46_address, &(mp->local[0]),
11556 format_ip46_address, &(mp->remote[0]),
11558 ntohl (mp->protocol),
11559 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
11562 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
11563 (vl_api_vxlan_gpe_tunnel_details_t * mp)
11565 vat_main_t *vam = &vat_main;
11566 vat_json_node_t *node = NULL;
11567 struct in_addr ip4;
11568 struct in6_addr ip6;
11570 if (VAT_JSON_ARRAY != vam->json_tree.type)
11572 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11573 vat_json_init_array (&vam->json_tree);
11575 node = vat_json_array_add (&vam->json_tree);
11577 vat_json_init_object (node);
11578 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11581 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
11582 vat_json_object_add_ip6 (node, "local", ip6);
11583 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
11584 vat_json_object_add_ip6 (node, "remote", ip6);
11588 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
11589 vat_json_object_add_ip4 (node, "local", ip4);
11590 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
11591 vat_json_object_add_ip4 (node, "remote", ip4);
11593 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
11594 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
11595 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
11596 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
11597 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
11601 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
11603 unformat_input_t *i = vam->input;
11604 vl_api_vxlan_gpe_tunnel_dump_t *mp;
11606 u8 sw_if_index_set = 0;
11609 /* Parse args required to build the message */
11610 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11612 if (unformat (i, "sw_if_index %d", &sw_if_index))
11613 sw_if_index_set = 1;
11618 if (sw_if_index_set == 0)
11623 if (!vam->json_output)
11625 print (vam->ofp, "%11s%24s%24s%13s%15s%14s%14s",
11626 "sw_if_index", "local", "remote", "vni",
11627 "protocol", "encap_vrf_id", "decap_vrf_id");
11630 /* Get list of vxlan-tunnel interfaces */
11631 M (VXLAN_GPE_TUNNEL_DUMP, mp);
11633 mp->sw_if_index = htonl (sw_if_index);
11637 /* Use a control ping for synchronization */
11639 vl_api_control_ping_t *mp;
11640 M (CONTROL_PING, mp);
11648 format_l2_fib_mac_address (u8 * s, va_list * args)
11650 u8 *a = va_arg (*args, u8 *);
11652 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
11653 a[2], a[3], a[4], a[5], a[6], a[7]);
11656 static void vl_api_l2_fib_table_entry_t_handler
11657 (vl_api_l2_fib_table_entry_t * mp)
11659 vat_main_t *vam = &vat_main;
11661 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
11663 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
11664 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
11668 static void vl_api_l2_fib_table_entry_t_handler_json
11669 (vl_api_l2_fib_table_entry_t * mp)
11671 vat_main_t *vam = &vat_main;
11672 vat_json_node_t *node = NULL;
11674 if (VAT_JSON_ARRAY != vam->json_tree.type)
11676 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11677 vat_json_init_array (&vam->json_tree);
11679 node = vat_json_array_add (&vam->json_tree);
11681 vat_json_init_object (node);
11682 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
11683 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
11684 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11685 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
11686 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
11687 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
11691 api_l2_fib_table_dump (vat_main_t * vam)
11693 unformat_input_t *i = vam->input;
11694 vl_api_l2_fib_table_dump_t *mp;
11699 /* Parse args required to build the message */
11700 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11702 if (unformat (i, "bd_id %d", &bd_id))
11708 if (bd_id_set == 0)
11710 errmsg ("missing bridge domain");
11714 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
11716 /* Get list of l2 fib entries */
11717 M (L2_FIB_TABLE_DUMP, mp);
11719 mp->bd_id = ntohl (bd_id);
11722 /* Use a control ping for synchronization */
11724 vl_api_control_ping_t *mp;
11725 M (CONTROL_PING, mp);
11734 api_interface_name_renumber (vat_main_t * vam)
11736 unformat_input_t *line_input = vam->input;
11737 vl_api_interface_name_renumber_t *mp;
11738 u32 sw_if_index = ~0;
11739 u32 new_show_dev_instance = ~0;
11742 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11744 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
11747 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11749 else if (unformat (line_input, "new_show_dev_instance %d",
11750 &new_show_dev_instance))
11756 if (sw_if_index == ~0)
11758 errmsg ("missing interface name or sw_if_index");
11762 if (new_show_dev_instance == ~0)
11764 errmsg ("missing new_show_dev_instance");
11768 M (INTERFACE_NAME_RENUMBER, mp);
11770 mp->sw_if_index = ntohl (sw_if_index);
11771 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
11779 api_want_ip4_arp_events (vat_main_t * vam)
11781 unformat_input_t *line_input = vam->input;
11782 vl_api_want_ip4_arp_events_t *mp;
11783 ip4_address_t address;
11784 int address_set = 0;
11785 u32 enable_disable = 1;
11788 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11790 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
11792 else if (unformat (line_input, "del"))
11793 enable_disable = 0;
11798 if (address_set == 0)
11800 errmsg ("missing addresses");
11804 M (WANT_IP4_ARP_EVENTS, mp);
11805 mp->enable_disable = enable_disable;
11806 mp->pid = getpid ();
11807 mp->address = address.as_u32;
11815 api_want_ip6_nd_events (vat_main_t * vam)
11817 unformat_input_t *line_input = vam->input;
11818 vl_api_want_ip6_nd_events_t *mp;
11819 ip6_address_t address;
11820 int address_set = 0;
11821 u32 enable_disable = 1;
11824 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11826 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
11828 else if (unformat (line_input, "del"))
11829 enable_disable = 0;
11834 if (address_set == 0)
11836 errmsg ("missing addresses");
11840 M (WANT_IP6_ND_EVENTS, mp);
11841 mp->enable_disable = enable_disable;
11842 mp->pid = getpid ();
11843 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
11851 api_input_acl_set_interface (vat_main_t * vam)
11853 unformat_input_t *i = vam->input;
11854 vl_api_input_acl_set_interface_t *mp;
11856 int sw_if_index_set;
11857 u32 ip4_table_index = ~0;
11858 u32 ip6_table_index = ~0;
11859 u32 l2_table_index = ~0;
11863 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11865 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11866 sw_if_index_set = 1;
11867 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11868 sw_if_index_set = 1;
11869 else if (unformat (i, "del"))
11871 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11873 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11875 else if (unformat (i, "l2-table %d", &l2_table_index))
11879 clib_warning ("parse error '%U'", format_unformat_error, i);
11884 if (sw_if_index_set == 0)
11886 errmsg ("missing interface name or sw_if_index");
11890 M (INPUT_ACL_SET_INTERFACE, mp);
11892 mp->sw_if_index = ntohl (sw_if_index);
11893 mp->ip4_table_index = ntohl (ip4_table_index);
11894 mp->ip6_table_index = ntohl (ip6_table_index);
11895 mp->l2_table_index = ntohl (l2_table_index);
11896 mp->is_add = is_add;
11904 api_ip_address_dump (vat_main_t * vam)
11906 unformat_input_t *i = vam->input;
11907 vl_api_ip_address_dump_t *mp;
11908 u32 sw_if_index = ~0;
11909 u8 sw_if_index_set = 0;
11914 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11916 if (unformat (i, "sw_if_index %d", &sw_if_index))
11917 sw_if_index_set = 1;
11919 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11920 sw_if_index_set = 1;
11921 else if (unformat (i, "ipv4"))
11923 else if (unformat (i, "ipv6"))
11929 if (ipv4_set && ipv6_set)
11931 errmsg ("ipv4 and ipv6 flags cannot be both set");
11935 if ((!ipv4_set) && (!ipv6_set))
11937 errmsg ("no ipv4 nor ipv6 flag set");
11941 if (sw_if_index_set == 0)
11943 errmsg ("missing interface name or sw_if_index");
11947 vam->current_sw_if_index = sw_if_index;
11948 vam->is_ipv6 = ipv6_set;
11950 M (IP_ADDRESS_DUMP, mp);
11951 mp->sw_if_index = ntohl (sw_if_index);
11952 mp->is_ipv6 = ipv6_set;
11955 /* Use a control ping for synchronization */
11957 vl_api_control_ping_t *mp;
11958 M (CONTROL_PING, mp);
11966 api_ip_dump (vat_main_t * vam)
11968 vl_api_ip_dump_t *mp;
11969 unformat_input_t *in = vam->input;
11976 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
11978 if (unformat (in, "ipv4"))
11980 else if (unformat (in, "ipv6"))
11986 if (ipv4_set && ipv6_set)
11988 errmsg ("ipv4 and ipv6 flags cannot be both set");
11992 if ((!ipv4_set) && (!ipv6_set))
11994 errmsg ("no ipv4 nor ipv6 flag set");
11998 is_ipv6 = ipv6_set;
11999 vam->is_ipv6 = is_ipv6;
12001 /* free old data */
12002 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
12004 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
12006 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
12009 mp->is_ipv6 = ipv6_set;
12012 /* Use a control ping for synchronization */
12014 vl_api_control_ping_t *mp;
12015 M (CONTROL_PING, mp);
12023 api_ipsec_spd_add_del (vat_main_t * vam)
12025 unformat_input_t *i = vam->input;
12026 vl_api_ipsec_spd_add_del_t *mp;
12031 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12033 if (unformat (i, "spd_id %d", &spd_id))
12035 else if (unformat (i, "del"))
12039 clib_warning ("parse error '%U'", format_unformat_error, i);
12045 errmsg ("spd_id must be set");
12049 M (IPSEC_SPD_ADD_DEL, mp);
12051 mp->spd_id = ntohl (spd_id);
12052 mp->is_add = is_add;
12060 api_ipsec_interface_add_del_spd (vat_main_t * vam)
12062 unformat_input_t *i = vam->input;
12063 vl_api_ipsec_interface_add_del_spd_t *mp;
12065 u8 sw_if_index_set = 0;
12066 u32 spd_id = (u32) ~ 0;
12070 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12072 if (unformat (i, "del"))
12074 else if (unformat (i, "spd_id %d", &spd_id))
12077 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12078 sw_if_index_set = 1;
12079 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12080 sw_if_index_set = 1;
12083 clib_warning ("parse error '%U'", format_unformat_error, i);
12089 if (spd_id == (u32) ~ 0)
12091 errmsg ("spd_id must be set");
12095 if (sw_if_index_set == 0)
12097 errmsg ("missing interface name or sw_if_index");
12101 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
12103 mp->spd_id = ntohl (spd_id);
12104 mp->sw_if_index = ntohl (sw_if_index);
12105 mp->is_add = is_add;
12113 api_ipsec_spd_add_del_entry (vat_main_t * vam)
12115 unformat_input_t *i = vam->input;
12116 vl_api_ipsec_spd_add_del_entry_t *mp;
12117 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
12118 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
12120 u32 rport_start = 0, rport_stop = (u32) ~ 0;
12121 u32 lport_start = 0, lport_stop = (u32) ~ 0;
12122 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
12123 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
12126 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
12127 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
12128 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
12129 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
12130 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
12131 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
12133 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12135 if (unformat (i, "del"))
12137 if (unformat (i, "outbound"))
12139 if (unformat (i, "inbound"))
12141 else if (unformat (i, "spd_id %d", &spd_id))
12143 else if (unformat (i, "sa_id %d", &sa_id))
12145 else if (unformat (i, "priority %d", &priority))
12147 else if (unformat (i, "protocol %d", &protocol))
12149 else if (unformat (i, "lport_start %d", &lport_start))
12151 else if (unformat (i, "lport_stop %d", &lport_stop))
12153 else if (unformat (i, "rport_start %d", &rport_start))
12155 else if (unformat (i, "rport_stop %d", &rport_stop))
12159 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
12165 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
12172 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
12178 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
12185 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
12191 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
12198 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
12204 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
12210 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
12212 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
12214 clib_warning ("unsupported action: 'resolve'");
12220 clib_warning ("parse error '%U'", format_unformat_error, i);
12226 M (IPSEC_SPD_ADD_DEL_ENTRY, mp);
12228 mp->spd_id = ntohl (spd_id);
12229 mp->priority = ntohl (priority);
12230 mp->is_outbound = is_outbound;
12232 mp->is_ipv6 = is_ipv6;
12233 if (is_ipv6 || is_ip_any)
12235 clib_memcpy (mp->remote_address_start, &raddr6_start,
12236 sizeof (ip6_address_t));
12237 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
12238 sizeof (ip6_address_t));
12239 clib_memcpy (mp->local_address_start, &laddr6_start,
12240 sizeof (ip6_address_t));
12241 clib_memcpy (mp->local_address_stop, &laddr6_stop,
12242 sizeof (ip6_address_t));
12246 clib_memcpy (mp->remote_address_start, &raddr4_start,
12247 sizeof (ip4_address_t));
12248 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
12249 sizeof (ip4_address_t));
12250 clib_memcpy (mp->local_address_start, &laddr4_start,
12251 sizeof (ip4_address_t));
12252 clib_memcpy (mp->local_address_stop, &laddr4_stop,
12253 sizeof (ip4_address_t));
12255 mp->protocol = (u8) protocol;
12256 mp->local_port_start = ntohs ((u16) lport_start);
12257 mp->local_port_stop = ntohs ((u16) lport_stop);
12258 mp->remote_port_start = ntohs ((u16) rport_start);
12259 mp->remote_port_stop = ntohs ((u16) rport_stop);
12260 mp->policy = (u8) policy;
12261 mp->sa_id = ntohl (sa_id);
12262 mp->is_add = is_add;
12263 mp->is_ip_any = is_ip_any;
12270 api_ipsec_sad_add_del_entry (vat_main_t * vam)
12272 unformat_input_t *i = vam->input;
12273 vl_api_ipsec_sad_add_del_entry_t *mp;
12274 u32 sad_id = 0, spi = 0;
12275 u8 *ck = 0, *ik = 0;
12278 u8 protocol = IPSEC_PROTOCOL_AH;
12279 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
12280 u32 crypto_alg = 0, integ_alg = 0;
12281 ip4_address_t tun_src4;
12282 ip4_address_t tun_dst4;
12283 ip6_address_t tun_src6;
12284 ip6_address_t tun_dst6;
12287 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12289 if (unformat (i, "del"))
12291 else if (unformat (i, "sad_id %d", &sad_id))
12293 else if (unformat (i, "spi %d", &spi))
12295 else if (unformat (i, "esp"))
12296 protocol = IPSEC_PROTOCOL_ESP;
12297 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
12300 is_tunnel_ipv6 = 0;
12302 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
12305 is_tunnel_ipv6 = 0;
12307 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
12310 is_tunnel_ipv6 = 1;
12312 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
12315 is_tunnel_ipv6 = 1;
12319 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
12321 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
12322 crypto_alg >= IPSEC_CRYPTO_N_ALG)
12324 clib_warning ("unsupported crypto-alg: '%U'",
12325 format_ipsec_crypto_alg, crypto_alg);
12329 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
12333 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
12335 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
12336 integ_alg >= IPSEC_INTEG_N_ALG)
12338 clib_warning ("unsupported integ-alg: '%U'",
12339 format_ipsec_integ_alg, integ_alg);
12343 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
12347 clib_warning ("parse error '%U'", format_unformat_error, i);
12353 M (IPSEC_SAD_ADD_DEL_ENTRY, mp);
12355 mp->sad_id = ntohl (sad_id);
12356 mp->is_add = is_add;
12357 mp->protocol = protocol;
12358 mp->spi = ntohl (spi);
12359 mp->is_tunnel = is_tunnel;
12360 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
12361 mp->crypto_algorithm = crypto_alg;
12362 mp->integrity_algorithm = integ_alg;
12363 mp->crypto_key_length = vec_len (ck);
12364 mp->integrity_key_length = vec_len (ik);
12366 if (mp->crypto_key_length > sizeof (mp->crypto_key))
12367 mp->crypto_key_length = sizeof (mp->crypto_key);
12369 if (mp->integrity_key_length > sizeof (mp->integrity_key))
12370 mp->integrity_key_length = sizeof (mp->integrity_key);
12373 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
12375 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
12379 if (is_tunnel_ipv6)
12381 clib_memcpy (mp->tunnel_src_address, &tun_src6,
12382 sizeof (ip6_address_t));
12383 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
12384 sizeof (ip6_address_t));
12388 clib_memcpy (mp->tunnel_src_address, &tun_src4,
12389 sizeof (ip4_address_t));
12390 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
12391 sizeof (ip4_address_t));
12401 api_ipsec_sa_set_key (vat_main_t * vam)
12403 unformat_input_t *i = vam->input;
12404 vl_api_ipsec_sa_set_key_t *mp;
12406 u8 *ck = 0, *ik = 0;
12409 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12411 if (unformat (i, "sa_id %d", &sa_id))
12413 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
12415 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
12419 clib_warning ("parse error '%U'", format_unformat_error, i);
12424 M (IPSEC_SA_SET_KEY, mp);
12426 mp->sa_id = ntohl (sa_id);
12427 mp->crypto_key_length = vec_len (ck);
12428 mp->integrity_key_length = vec_len (ik);
12430 if (mp->crypto_key_length > sizeof (mp->crypto_key))
12431 mp->crypto_key_length = sizeof (mp->crypto_key);
12433 if (mp->integrity_key_length > sizeof (mp->integrity_key))
12434 mp->integrity_key_length = sizeof (mp->integrity_key);
12437 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
12439 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
12447 api_ikev2_profile_add_del (vat_main_t * vam)
12449 unformat_input_t *i = vam->input;
12450 vl_api_ikev2_profile_add_del_t *mp;
12455 const char *valid_chars = "a-zA-Z0-9_";
12457 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12459 if (unformat (i, "del"))
12461 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12462 vec_add1 (name, 0);
12465 errmsg ("parse error '%U'", format_unformat_error, i);
12470 if (!vec_len (name))
12472 errmsg ("profile name must be specified");
12476 if (vec_len (name) > 64)
12478 errmsg ("profile name too long");
12482 M (IKEV2_PROFILE_ADD_DEL, mp);
12484 clib_memcpy (mp->name, name, vec_len (name));
12485 mp->is_add = is_add;
12494 api_ikev2_profile_set_auth (vat_main_t * vam)
12496 unformat_input_t *i = vam->input;
12497 vl_api_ikev2_profile_set_auth_t *mp;
12500 u32 auth_method = 0;
12504 const char *valid_chars = "a-zA-Z0-9_";
12506 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12508 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12509 vec_add1 (name, 0);
12510 else if (unformat (i, "auth_method %U",
12511 unformat_ikev2_auth_method, &auth_method))
12513 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
12515 else if (unformat (i, "auth_data %v", &data))
12519 errmsg ("parse error '%U'", format_unformat_error, i);
12524 if (!vec_len (name))
12526 errmsg ("profile name must be specified");
12530 if (vec_len (name) > 64)
12532 errmsg ("profile name too long");
12536 if (!vec_len (data))
12538 errmsg ("auth_data must be specified");
12544 errmsg ("auth_method must be specified");
12548 M (IKEV2_PROFILE_SET_AUTH, mp);
12550 mp->is_hex = is_hex;
12551 mp->auth_method = (u8) auth_method;
12552 mp->data_len = vec_len (data);
12553 clib_memcpy (mp->name, name, vec_len (name));
12554 clib_memcpy (mp->data, data, vec_len (data));
12564 api_ikev2_profile_set_id (vat_main_t * vam)
12566 unformat_input_t *i = vam->input;
12567 vl_api_ikev2_profile_set_id_t *mp;
12575 const char *valid_chars = "a-zA-Z0-9_";
12577 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12579 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12580 vec_add1 (name, 0);
12581 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
12583 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
12585 data = vec_new (u8, 4);
12586 clib_memcpy (data, ip4.as_u8, 4);
12588 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
12590 else if (unformat (i, "id_data %v", &data))
12592 else if (unformat (i, "local"))
12594 else if (unformat (i, "remote"))
12598 errmsg ("parse error '%U'", format_unformat_error, i);
12603 if (!vec_len (name))
12605 errmsg ("profile name must be specified");
12609 if (vec_len (name) > 64)
12611 errmsg ("profile name too long");
12615 if (!vec_len (data))
12617 errmsg ("id_data must be specified");
12623 errmsg ("id_type must be specified");
12627 M (IKEV2_PROFILE_SET_ID, mp);
12629 mp->is_local = is_local;
12630 mp->id_type = (u8) id_type;
12631 mp->data_len = vec_len (data);
12632 clib_memcpy (mp->name, name, vec_len (name));
12633 clib_memcpy (mp->data, data, vec_len (data));
12643 api_ikev2_profile_set_ts (vat_main_t * vam)
12645 unformat_input_t *i = vam->input;
12646 vl_api_ikev2_profile_set_ts_t *mp;
12649 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
12650 ip4_address_t start_addr, end_addr;
12652 const char *valid_chars = "a-zA-Z0-9_";
12655 start_addr.as_u32 = 0;
12656 end_addr.as_u32 = (u32) ~ 0;
12658 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12660 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12661 vec_add1 (name, 0);
12662 else if (unformat (i, "protocol %d", &proto))
12664 else if (unformat (i, "start_port %d", &start_port))
12666 else if (unformat (i, "end_port %d", &end_port))
12669 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
12671 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
12673 else if (unformat (i, "local"))
12675 else if (unformat (i, "remote"))
12679 errmsg ("parse error '%U'", format_unformat_error, i);
12684 if (!vec_len (name))
12686 errmsg ("profile name must be specified");
12690 if (vec_len (name) > 64)
12692 errmsg ("profile name too long");
12696 M (IKEV2_PROFILE_SET_TS, mp);
12698 mp->is_local = is_local;
12699 mp->proto = (u8) proto;
12700 mp->start_port = (u16) start_port;
12701 mp->end_port = (u16) end_port;
12702 mp->start_addr = start_addr.as_u32;
12703 mp->end_addr = end_addr.as_u32;
12704 clib_memcpy (mp->name, name, vec_len (name));
12713 api_ikev2_set_local_key (vat_main_t * vam)
12715 unformat_input_t *i = vam->input;
12716 vl_api_ikev2_set_local_key_t *mp;
12720 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12722 if (unformat (i, "file %v", &file))
12723 vec_add1 (file, 0);
12726 errmsg ("parse error '%U'", format_unformat_error, i);
12731 if (!vec_len (file))
12733 errmsg ("RSA key file must be specified");
12737 if (vec_len (file) > 256)
12739 errmsg ("file name too long");
12743 M (IKEV2_SET_LOCAL_KEY, mp);
12745 clib_memcpy (mp->key_file, file, vec_len (file));
12757 api_map_add_domain (vat_main_t * vam)
12759 unformat_input_t *i = vam->input;
12760 vl_api_map_add_domain_t *mp;
12762 ip4_address_t ip4_prefix;
12763 ip6_address_t ip6_prefix;
12764 ip6_address_t ip6_src;
12765 u32 num_m_args = 0;
12766 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
12767 0, psid_length = 0;
12768 u8 is_translation = 0;
12770 u32 ip6_src_len = 128;
12773 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12775 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
12776 &ip4_prefix, &ip4_prefix_len))
12778 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
12779 &ip6_prefix, &ip6_prefix_len))
12783 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
12786 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
12788 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
12790 else if (unformat (i, "psid-offset %d", &psid_offset))
12792 else if (unformat (i, "psid-len %d", &psid_length))
12794 else if (unformat (i, "mtu %d", &mtu))
12796 else if (unformat (i, "map-t"))
12797 is_translation = 1;
12800 clib_warning ("parse error '%U'", format_unformat_error, i);
12805 if (num_m_args < 3)
12807 errmsg ("mandatory argument(s) missing");
12811 /* Construct the API message */
12812 M (MAP_ADD_DOMAIN, mp);
12814 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
12815 mp->ip4_prefix_len = ip4_prefix_len;
12817 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
12818 mp->ip6_prefix_len = ip6_prefix_len;
12820 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
12821 mp->ip6_src_prefix_len = ip6_src_len;
12823 mp->ea_bits_len = ea_bits_len;
12824 mp->psid_offset = psid_offset;
12825 mp->psid_length = psid_length;
12826 mp->is_translation = is_translation;
12827 mp->mtu = htons (mtu);
12832 /* Wait for a reply, return good/bad news */
12838 api_map_del_domain (vat_main_t * vam)
12840 unformat_input_t *i = vam->input;
12841 vl_api_map_del_domain_t *mp;
12843 u32 num_m_args = 0;
12847 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12849 if (unformat (i, "index %d", &index))
12853 clib_warning ("parse error '%U'", format_unformat_error, i);
12858 if (num_m_args != 1)
12860 errmsg ("mandatory argument(s) missing");
12864 /* Construct the API message */
12865 M (MAP_DEL_DOMAIN, mp);
12867 mp->index = ntohl (index);
12872 /* Wait for a reply, return good/bad news */
12878 api_map_add_del_rule (vat_main_t * vam)
12880 unformat_input_t *i = vam->input;
12881 vl_api_map_add_del_rule_t *mp;
12883 ip6_address_t ip6_dst;
12884 u32 num_m_args = 0, index, psid = 0;
12887 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12889 if (unformat (i, "index %d", &index))
12891 else if (unformat (i, "psid %d", &psid))
12893 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
12895 else if (unformat (i, "del"))
12901 clib_warning ("parse error '%U'", format_unformat_error, i);
12906 /* Construct the API message */
12907 M (MAP_ADD_DEL_RULE, mp);
12909 mp->index = ntohl (index);
12910 mp->is_add = is_add;
12911 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
12912 mp->psid = ntohs (psid);
12917 /* Wait for a reply, return good/bad news */
12923 api_map_domain_dump (vat_main_t * vam)
12925 vl_api_map_domain_dump_t *mp;
12928 /* Construct the API message */
12929 M (MAP_DOMAIN_DUMP, mp);
12934 /* Use a control ping for synchronization */
12936 vl_api_control_ping_t *mp;
12937 M (CONTROL_PING, mp);
12945 api_map_rule_dump (vat_main_t * vam)
12947 unformat_input_t *i = vam->input;
12948 vl_api_map_rule_dump_t *mp;
12949 u32 domain_index = ~0;
12952 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12954 if (unformat (i, "index %u", &domain_index))
12960 if (domain_index == ~0)
12962 clib_warning ("parse error: domain index expected");
12966 /* Construct the API message */
12967 M (MAP_RULE_DUMP, mp);
12969 mp->domain_index = htonl (domain_index);
12974 /* Use a control ping for synchronization */
12976 vl_api_control_ping_t *mp;
12977 M (CONTROL_PING, mp);
12984 static void vl_api_map_add_domain_reply_t_handler
12985 (vl_api_map_add_domain_reply_t * mp)
12987 vat_main_t *vam = &vat_main;
12988 i32 retval = ntohl (mp->retval);
12990 if (vam->async_mode)
12992 vam->async_errors += (retval < 0);
12996 vam->retval = retval;
12997 vam->result_ready = 1;
13001 static void vl_api_map_add_domain_reply_t_handler_json
13002 (vl_api_map_add_domain_reply_t * mp)
13004 vat_main_t *vam = &vat_main;
13005 vat_json_node_t node;
13007 vat_json_init_object (&node);
13008 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
13009 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
13011 vat_json_print (vam->ofp, &node);
13012 vat_json_free (&node);
13014 vam->retval = ntohl (mp->retval);
13015 vam->result_ready = 1;
13019 api_get_first_msg_id (vat_main_t * vam)
13021 vl_api_get_first_msg_id_t *mp;
13022 unformat_input_t *i = vam->input;
13027 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13029 if (unformat (i, "client %s", &name))
13037 errmsg ("missing client name");
13040 vec_add1 (name, 0);
13042 if (vec_len (name) > 63)
13044 errmsg ("client name too long");
13048 M (GET_FIRST_MSG_ID, mp);
13049 clib_memcpy (mp->name, name, vec_len (name));
13056 api_cop_interface_enable_disable (vat_main_t * vam)
13058 unformat_input_t *line_input = vam->input;
13059 vl_api_cop_interface_enable_disable_t *mp;
13060 u32 sw_if_index = ~0;
13061 u8 enable_disable = 1;
13064 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13066 if (unformat (line_input, "disable"))
13067 enable_disable = 0;
13068 if (unformat (line_input, "enable"))
13069 enable_disable = 1;
13070 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
13071 vam, &sw_if_index))
13073 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13079 if (sw_if_index == ~0)
13081 errmsg ("missing interface name or sw_if_index");
13085 /* Construct the API message */
13086 M (COP_INTERFACE_ENABLE_DISABLE, mp);
13087 mp->sw_if_index = ntohl (sw_if_index);
13088 mp->enable_disable = enable_disable;
13092 /* Wait for the reply */
13098 api_cop_whitelist_enable_disable (vat_main_t * vam)
13100 unformat_input_t *line_input = vam->input;
13101 vl_api_cop_whitelist_enable_disable_t *mp;
13102 u32 sw_if_index = ~0;
13103 u8 ip4 = 0, ip6 = 0, default_cop = 0;
13107 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13109 if (unformat (line_input, "ip4"))
13111 else if (unformat (line_input, "ip6"))
13113 else if (unformat (line_input, "default"))
13115 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
13116 vam, &sw_if_index))
13118 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13120 else if (unformat (line_input, "fib-id %d", &fib_id))
13126 if (sw_if_index == ~0)
13128 errmsg ("missing interface name or sw_if_index");
13132 /* Construct the API message */
13133 M (COP_WHITELIST_ENABLE_DISABLE, mp);
13134 mp->sw_if_index = ntohl (sw_if_index);
13135 mp->fib_id = ntohl (fib_id);
13138 mp->default_cop = default_cop;
13142 /* Wait for the reply */
13148 api_get_node_graph (vat_main_t * vam)
13150 vl_api_get_node_graph_t *mp;
13153 M (GET_NODE_GRAPH, mp);
13157 /* Wait for the reply */
13163 /** Used for parsing LISP eids */
13164 typedef CLIB_PACKED(struct{
13165 u8 addr[16]; /**< eid address */
13166 u32 len; /**< prefix length if IP */
13167 u8 type; /**< type of eid */
13172 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
13174 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
13176 memset (a, 0, sizeof (a[0]));
13178 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
13180 a->type = 0; /* ipv4 type */
13182 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
13184 a->type = 1; /* ipv6 type */
13186 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
13188 a->type = 2; /* mac type */
13195 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
13204 lisp_eid_size_vat (u8 type)
13219 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
13221 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
13225 api_lisp_add_del_locator_set (vat_main_t * vam)
13227 unformat_input_t *input = vam->input;
13228 vl_api_lisp_add_del_locator_set_t *mp;
13230 u8 *locator_set_name = NULL;
13231 u8 locator_set_name_set = 0;
13232 vl_api_local_locator_t locator, *locators = 0;
13233 u32 sw_if_index, priority, weight;
13237 /* Parse args required to build the message */
13238 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13240 if (unformat (input, "del"))
13244 else if (unformat (input, "locator-set %s", &locator_set_name))
13246 locator_set_name_set = 1;
13248 else if (unformat (input, "sw_if_index %u p %u w %u",
13249 &sw_if_index, &priority, &weight))
13251 locator.sw_if_index = htonl (sw_if_index);
13252 locator.priority = priority;
13253 locator.weight = weight;
13254 vec_add1 (locators, locator);
13258 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
13259 &sw_if_index, &priority, &weight))
13261 locator.sw_if_index = htonl (sw_if_index);
13262 locator.priority = priority;
13263 locator.weight = weight;
13264 vec_add1 (locators, locator);
13270 if (locator_set_name_set == 0)
13272 errmsg ("missing locator-set name");
13273 vec_free (locators);
13277 if (vec_len (locator_set_name) > 64)
13279 errmsg ("locator-set name too long");
13280 vec_free (locator_set_name);
13281 vec_free (locators);
13284 vec_add1 (locator_set_name, 0);
13286 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
13288 /* Construct the API message */
13289 M2 (LISP_ADD_DEL_LOCATOR_SET, mp, data_len);
13291 mp->is_add = is_add;
13292 clib_memcpy (mp->locator_set_name, locator_set_name,
13293 vec_len (locator_set_name));
13294 vec_free (locator_set_name);
13296 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
13298 clib_memcpy (mp->locators, locators, data_len);
13299 vec_free (locators);
13304 /* Wait for a reply... */
13310 api_lisp_add_del_locator (vat_main_t * vam)
13312 unformat_input_t *input = vam->input;
13313 vl_api_lisp_add_del_locator_t *mp;
13314 u32 tmp_if_index = ~0;
13315 u32 sw_if_index = ~0;
13316 u8 sw_if_index_set = 0;
13317 u8 sw_if_index_if_name_set = 0;
13319 u8 priority_set = 0;
13323 u8 *locator_set_name = NULL;
13324 u8 locator_set_name_set = 0;
13327 /* Parse args required to build the message */
13328 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13330 if (unformat (input, "del"))
13334 else if (unformat (input, "locator-set %s", &locator_set_name))
13336 locator_set_name_set = 1;
13338 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
13341 sw_if_index_if_name_set = 1;
13342 sw_if_index = tmp_if_index;
13344 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
13346 sw_if_index_set = 1;
13347 sw_if_index = tmp_if_index;
13349 else if (unformat (input, "p %d", &priority))
13353 else if (unformat (input, "w %d", &weight))
13361 if (locator_set_name_set == 0)
13363 errmsg ("missing locator-set name");
13367 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
13369 errmsg ("missing sw_if_index");
13370 vec_free (locator_set_name);
13374 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
13376 errmsg ("cannot use both params interface name and sw_if_index");
13377 vec_free (locator_set_name);
13381 if (priority_set == 0)
13383 errmsg ("missing locator-set priority");
13384 vec_free (locator_set_name);
13388 if (weight_set == 0)
13390 errmsg ("missing locator-set weight");
13391 vec_free (locator_set_name);
13395 if (vec_len (locator_set_name) > 64)
13397 errmsg ("locator-set name too long");
13398 vec_free (locator_set_name);
13401 vec_add1 (locator_set_name, 0);
13403 /* Construct the API message */
13404 M (LISP_ADD_DEL_LOCATOR, mp);
13406 mp->is_add = is_add;
13407 mp->sw_if_index = ntohl (sw_if_index);
13408 mp->priority = priority;
13409 mp->weight = weight;
13410 clib_memcpy (mp->locator_set_name, locator_set_name,
13411 vec_len (locator_set_name));
13412 vec_free (locator_set_name);
13417 /* Wait for a reply... */
13423 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
13425 u32 *key_id = va_arg (*args, u32 *);
13428 if (unformat (input, "%s", &s))
13430 if (!strcmp ((char *) s, "sha1"))
13431 key_id[0] = HMAC_SHA_1_96;
13432 else if (!strcmp ((char *) s, "sha256"))
13433 key_id[0] = HMAC_SHA_256_128;
13436 clib_warning ("invalid key_id: '%s'", s);
13437 key_id[0] = HMAC_NO_KEY;
13448 api_lisp_add_del_local_eid (vat_main_t * vam)
13450 unformat_input_t *input = vam->input;
13451 vl_api_lisp_add_del_local_eid_t *mp;
13454 lisp_eid_vat_t _eid, *eid = &_eid;
13455 u8 *locator_set_name = 0;
13456 u8 locator_set_name_set = 0;
13462 /* Parse args required to build the message */
13463 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13465 if (unformat (input, "del"))
13469 else if (unformat (input, "vni %d", &vni))
13473 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
13477 else if (unformat (input, "locator-set %s", &locator_set_name))
13479 locator_set_name_set = 1;
13481 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
13483 else if (unformat (input, "secret-key %_%v%_", &key))
13489 if (locator_set_name_set == 0)
13491 errmsg ("missing locator-set name");
13497 errmsg ("EID address not set!");
13498 vec_free (locator_set_name);
13502 if (key && (0 == key_id))
13504 errmsg ("invalid key_id!");
13508 if (vec_len (key) > 64)
13510 errmsg ("key too long");
13515 if (vec_len (locator_set_name) > 64)
13517 errmsg ("locator-set name too long");
13518 vec_free (locator_set_name);
13521 vec_add1 (locator_set_name, 0);
13523 /* Construct the API message */
13524 M (LISP_ADD_DEL_LOCAL_EID, mp);
13526 mp->is_add = is_add;
13527 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
13528 mp->eid_type = eid->type;
13529 mp->prefix_len = eid->len;
13530 mp->vni = clib_host_to_net_u32 (vni);
13531 mp->key_id = clib_host_to_net_u16 (key_id);
13532 clib_memcpy (mp->locator_set_name, locator_set_name,
13533 vec_len (locator_set_name));
13534 clib_memcpy (mp->key, key, vec_len (key));
13536 vec_free (locator_set_name);
13542 /* Wait for a reply... */
13548 /** Used for transferring locators via VPP API */
13549 typedef CLIB_PACKED(struct
13551 u8 is_ip4; /**< is locator an IPv4 address? */
13552 u8 priority; /**< locator priority */
13553 u8 weight; /**< locator weight */
13554 u8 addr[16]; /**< IPv4/IPv6 address */
13559 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
13561 u32 dp_table = 0, vni = 0;;
13562 unformat_input_t *input = vam->input;
13563 vl_api_lisp_gpe_add_del_fwd_entry_t *mp;
13565 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
13566 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
13567 u8 rmt_eid_set = 0, lcl_eid_set = 0;
13568 u32 action = ~0, w;
13569 ip4_address_t rmt_rloc4, lcl_rloc4;
13570 ip6_address_t rmt_rloc6, lcl_rloc6;
13571 vl_api_lisp_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc =
13575 memset (&rloc, 0, sizeof (rloc));
13577 /* Parse args required to build the message */
13578 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13580 if (unformat (input, "del"))
13582 else if (unformat (input, "add"))
13584 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
13588 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
13592 else if (unformat (input, "vrf %d", &dp_table))
13594 else if (unformat (input, "bd %d", &dp_table))
13596 else if (unformat (input, "vni %d", &vni))
13598 else if (unformat (input, "w %d", &w))
13602 errmsg ("No RLOC configured for setting priority/weight!");
13605 curr_rloc->weight = w;
13607 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
13608 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
13612 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
13614 vec_add1 (lcl_locs, rloc);
13616 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
13617 vec_add1 (rmt_locs, rloc);
13618 /* weight saved in rmt loc */
13619 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
13621 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
13622 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
13625 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
13627 vec_add1 (lcl_locs, rloc);
13629 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
13630 vec_add1 (rmt_locs, rloc);
13631 /* weight saved in rmt loc */
13632 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
13634 else if (unformat (input, "action %d", &action))
13640 clib_warning ("parse error '%U'", format_unformat_error, input);
13647 errmsg ("remote eid addresses not set");
13651 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
13653 errmsg ("eid types don't match");
13657 if (0 == rmt_locs && (u32) ~ 0 == action)
13659 errmsg ("action not set for negative mapping");
13663 /* Construct the API message */
13664 M2 (LISP_GPE_ADD_DEL_FWD_ENTRY, mp,
13665 sizeof (vl_api_lisp_gpe_locator_t) * vec_len (rmt_locs) * 2);
13667 mp->is_add = is_add;
13668 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
13669 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
13670 mp->eid_type = rmt_eid->type;
13671 mp->dp_table = clib_host_to_net_u32 (dp_table);
13672 mp->vni = clib_host_to_net_u32 (vni);
13673 mp->rmt_len = rmt_eid->len;
13674 mp->lcl_len = lcl_eid->len;
13675 mp->action = action;
13677 if (0 != rmt_locs && 0 != lcl_locs)
13679 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
13680 clib_memcpy (mp->locs, lcl_locs,
13681 (sizeof (vl_api_lisp_gpe_locator_t) * vec_len (lcl_locs)));
13683 u32 offset = sizeof (vl_api_lisp_gpe_locator_t) * vec_len (lcl_locs);
13684 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
13685 (sizeof (vl_api_lisp_gpe_locator_t) * vec_len (rmt_locs)));
13687 vec_free (lcl_locs);
13688 vec_free (rmt_locs);
13693 /* Wait for a reply... */
13699 api_lisp_add_del_map_server (vat_main_t * vam)
13701 unformat_input_t *input = vam->input;
13702 vl_api_lisp_add_del_map_server_t *mp;
13706 ip4_address_t ipv4;
13707 ip6_address_t ipv6;
13710 /* Parse args required to build the message */
13711 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13713 if (unformat (input, "del"))
13717 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
13721 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
13729 if (ipv4_set && ipv6_set)
13731 errmsg ("both eid v4 and v6 addresses set");
13735 if (!ipv4_set && !ipv6_set)
13737 errmsg ("eid addresses not set");
13741 /* Construct the API message */
13742 M (LISP_ADD_DEL_MAP_SERVER, mp);
13744 mp->is_add = is_add;
13748 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
13753 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
13759 /* Wait for a reply... */
13765 api_lisp_add_del_map_resolver (vat_main_t * vam)
13767 unformat_input_t *input = vam->input;
13768 vl_api_lisp_add_del_map_resolver_t *mp;
13772 ip4_address_t ipv4;
13773 ip6_address_t ipv6;
13776 /* Parse args required to build the message */
13777 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13779 if (unformat (input, "del"))
13783 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
13787 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
13795 if (ipv4_set && ipv6_set)
13797 errmsg ("both eid v4 and v6 addresses set");
13801 if (!ipv4_set && !ipv6_set)
13803 errmsg ("eid addresses not set");
13807 /* Construct the API message */
13808 M (LISP_ADD_DEL_MAP_RESOLVER, mp);
13810 mp->is_add = is_add;
13814 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
13819 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
13825 /* Wait for a reply... */
13831 api_lisp_gpe_enable_disable (vat_main_t * vam)
13833 unformat_input_t *input = vam->input;
13834 vl_api_lisp_gpe_enable_disable_t *mp;
13839 /* Parse args required to build the message */
13840 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13842 if (unformat (input, "enable"))
13847 else if (unformat (input, "disable"))
13858 errmsg ("Value not set");
13862 /* Construct the API message */
13863 M (LISP_GPE_ENABLE_DISABLE, mp);
13870 /* Wait for a reply... */
13876 api_lisp_rloc_probe_enable_disable (vat_main_t * vam)
13878 unformat_input_t *input = vam->input;
13879 vl_api_lisp_rloc_probe_enable_disable_t *mp;
13884 /* Parse args required to build the message */
13885 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13887 if (unformat (input, "enable"))
13892 else if (unformat (input, "disable"))
13900 errmsg ("Value not set");
13904 /* Construct the API message */
13905 M (LISP_RLOC_PROBE_ENABLE_DISABLE, mp);
13907 mp->is_enabled = is_en;
13912 /* Wait for a reply... */
13918 api_lisp_map_register_enable_disable (vat_main_t * vam)
13920 unformat_input_t *input = vam->input;
13921 vl_api_lisp_map_register_enable_disable_t *mp;
13926 /* Parse args required to build the message */
13927 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13929 if (unformat (input, "enable"))
13934 else if (unformat (input, "disable"))
13942 errmsg ("Value not set");
13946 /* Construct the API message */
13947 M (LISP_MAP_REGISTER_ENABLE_DISABLE, mp);
13949 mp->is_enabled = is_en;
13954 /* Wait for a reply... */
13960 api_lisp_enable_disable (vat_main_t * vam)
13962 unformat_input_t *input = vam->input;
13963 vl_api_lisp_enable_disable_t *mp;
13968 /* Parse args required to build the message */
13969 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13971 if (unformat (input, "enable"))
13976 else if (unformat (input, "disable"))
13986 errmsg ("Value not set");
13990 /* Construct the API message */
13991 M (LISP_ENABLE_DISABLE, mp);
13998 /* Wait for a reply... */
14004 api_show_lisp_map_register_state (vat_main_t * vam)
14006 vl_api_show_lisp_map_register_state_t *mp;
14009 M (SHOW_LISP_MAP_REGISTER_STATE, mp);
14014 /* wait for reply */
14020 api_show_lisp_rloc_probe_state (vat_main_t * vam)
14022 vl_api_show_lisp_rloc_probe_state_t *mp;
14025 M (SHOW_LISP_RLOC_PROBE_STATE, mp);
14030 /* wait for reply */
14036 api_show_lisp_map_request_mode (vat_main_t * vam)
14038 vl_api_show_lisp_map_request_mode_t *mp;
14041 M (SHOW_LISP_MAP_REQUEST_MODE, mp);
14046 /* wait for reply */
14052 api_lisp_map_request_mode (vat_main_t * vam)
14054 unformat_input_t *input = vam->input;
14055 vl_api_lisp_map_request_mode_t *mp;
14059 /* Parse args required to build the message */
14060 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14062 if (unformat (input, "dst-only"))
14064 else if (unformat (input, "src-dst"))
14068 errmsg ("parse error '%U'", format_unformat_error, input);
14073 M (LISP_MAP_REQUEST_MODE, mp);
14080 /* wait for reply */
14086 * Enable/disable LISP proxy ITR.
14088 * @param vam vpp API test context
14089 * @return return code
14092 api_lisp_pitr_set_locator_set (vat_main_t * vam)
14094 u8 ls_name_set = 0;
14095 unformat_input_t *input = vam->input;
14096 vl_api_lisp_pitr_set_locator_set_t *mp;
14101 /* Parse args required to build the message */
14102 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14104 if (unformat (input, "del"))
14106 else if (unformat (input, "locator-set %s", &ls_name))
14110 errmsg ("parse error '%U'", format_unformat_error, input);
14117 errmsg ("locator-set name not set!");
14121 M (LISP_PITR_SET_LOCATOR_SET, mp);
14123 mp->is_add = is_add;
14124 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
14125 vec_free (ls_name);
14130 /* wait for reply */
14136 api_show_lisp_pitr (vat_main_t * vam)
14138 vl_api_show_lisp_pitr_t *mp;
14141 if (!vam->json_output)
14143 print (vam->ofp, "%=20s", "lisp status:");
14146 M (SHOW_LISP_PITR, mp);
14150 /* Wait for a reply... */
14156 * Add/delete mapping between vni and vrf
14159 api_lisp_eid_table_add_del_map (vat_main_t * vam)
14161 unformat_input_t *input = vam->input;
14162 vl_api_lisp_eid_table_add_del_map_t *mp;
14163 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
14164 u32 vni, vrf, bd_index;
14167 /* Parse args required to build the message */
14168 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14170 if (unformat (input, "del"))
14172 else if (unformat (input, "vrf %d", &vrf))
14174 else if (unformat (input, "bd_index %d", &bd_index))
14176 else if (unformat (input, "vni %d", &vni))
14182 if (!vni_set || (!vrf_set && !bd_index_set))
14184 errmsg ("missing arguments!");
14188 if (vrf_set && bd_index_set)
14190 errmsg ("error: both vrf and bd entered!");
14194 M (LISP_EID_TABLE_ADD_DEL_MAP, mp);
14196 mp->is_add = is_add;
14197 mp->vni = htonl (vni);
14198 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
14199 mp->is_l2 = bd_index_set;
14204 /* wait for reply */
14210 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
14212 u32 *action = va_arg (*args, u32 *);
14215 if (unformat (input, "%s", &s))
14217 if (!strcmp ((char *) s, "no-action"))
14219 else if (!strcmp ((char *) s, "natively-forward"))
14221 else if (!strcmp ((char *) s, "send-map-request"))
14223 else if (!strcmp ((char *) s, "drop"))
14227 clib_warning ("invalid action: '%s'", s);
14239 * Add/del remote mapping to/from LISP control plane
14241 * @param vam vpp API test context
14242 * @return return code
14245 api_lisp_add_del_remote_mapping (vat_main_t * vam)
14247 unformat_input_t *input = vam->input;
14248 vl_api_lisp_add_del_remote_mapping_t *mp;
14250 lisp_eid_vat_t _eid, *eid = &_eid;
14251 lisp_eid_vat_t _seid, *seid = &_seid;
14252 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
14253 u32 action = ~0, p, w, data_len;
14254 ip4_address_t rloc4;
14255 ip6_address_t rloc6;
14256 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
14259 memset (&rloc, 0, sizeof (rloc));
14261 /* Parse args required to build the message */
14262 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14264 if (unformat (input, "del-all"))
14268 else if (unformat (input, "del"))
14272 else if (unformat (input, "add"))
14276 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
14280 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
14284 else if (unformat (input, "vni %d", &vni))
14288 else if (unformat (input, "p %d w %d", &p, &w))
14292 errmsg ("No RLOC configured for setting priority/weight!");
14295 curr_rloc->priority = p;
14296 curr_rloc->weight = w;
14298 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
14301 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
14302 vec_add1 (rlocs, rloc);
14303 curr_rloc = &rlocs[vec_len (rlocs) - 1];
14305 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
14308 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
14309 vec_add1 (rlocs, rloc);
14310 curr_rloc = &rlocs[vec_len (rlocs) - 1];
14312 else if (unformat (input, "action %U",
14313 unformat_negative_mapping_action, &action))
14319 clib_warning ("parse error '%U'", format_unformat_error, input);
14326 errmsg ("missing params!");
14330 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
14332 errmsg ("no action set for negative map-reply!");
14336 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
14338 M2 (LISP_ADD_DEL_REMOTE_MAPPING, mp, data_len);
14339 mp->is_add = is_add;
14340 mp->vni = htonl (vni);
14341 mp->action = (u8) action;
14342 mp->is_src_dst = seid_set;
14343 mp->eid_len = eid->len;
14344 mp->seid_len = seid->len;
14345 mp->del_all = del_all;
14346 mp->eid_type = eid->type;
14347 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
14348 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
14350 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
14351 clib_memcpy (mp->rlocs, rlocs, data_len);
14357 /* Wait for a reply... */
14363 * Add/del LISP adjacency. Saves mapping in LISP control plane and updates
14364 * forwarding entries in data-plane accordingly.
14366 * @param vam vpp API test context
14367 * @return return code
14370 api_lisp_add_del_adjacency (vat_main_t * vam)
14372 unformat_input_t *input = vam->input;
14373 vl_api_lisp_add_del_adjacency_t *mp;
14375 ip4_address_t leid4, reid4;
14376 ip6_address_t leid6, reid6;
14377 u8 reid_mac[6] = { 0 };
14378 u8 leid_mac[6] = { 0 };
14379 u8 reid_type, leid_type;
14380 u32 leid_len = 0, reid_len = 0, len;
14384 leid_type = reid_type = (u8) ~ 0;
14386 /* Parse args required to build the message */
14387 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14389 if (unformat (input, "del"))
14393 else if (unformat (input, "add"))
14397 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
14400 reid_type = 0; /* ipv4 */
14403 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
14406 reid_type = 1; /* ipv6 */
14409 else if (unformat (input, "reid %U", unformat_ethernet_address,
14412 reid_type = 2; /* mac */
14414 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
14417 leid_type = 0; /* ipv4 */
14420 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
14423 leid_type = 1; /* ipv6 */
14426 else if (unformat (input, "leid %U", unformat_ethernet_address,
14429 leid_type = 2; /* mac */
14431 else if (unformat (input, "vni %d", &vni))
14437 errmsg ("parse error '%U'", format_unformat_error, input);
14442 if ((u8) ~ 0 == reid_type)
14444 errmsg ("missing params!");
14448 if (leid_type != reid_type)
14450 errmsg ("remote and local EIDs are of different types!");
14454 M (LISP_ADD_DEL_ADJACENCY, mp);
14455 mp->is_add = is_add;
14456 mp->vni = htonl (vni);
14457 mp->leid_len = leid_len;
14458 mp->reid_len = reid_len;
14459 mp->eid_type = reid_type;
14461 switch (mp->eid_type)
14464 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
14465 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
14468 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
14469 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
14472 clib_memcpy (mp->leid, leid_mac, 6);
14473 clib_memcpy (mp->reid, reid_mac, 6);
14476 errmsg ("unknown EID type %d!", mp->eid_type);
14483 /* Wait for a reply... */
14489 api_lisp_gpe_add_del_iface (vat_main_t * vam)
14491 unformat_input_t *input = vam->input;
14492 vl_api_lisp_gpe_add_del_iface_t *mp;
14493 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
14494 u32 dp_table = 0, vni = 0;
14497 /* Parse args required to build the message */
14498 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14500 if (unformat (input, "up"))
14505 else if (unformat (input, "down"))
14510 else if (unformat (input, "table_id %d", &dp_table))
14514 else if (unformat (input, "bd_id %d", &dp_table))
14519 else if (unformat (input, "vni %d", &vni))
14527 if (action_set == 0)
14529 errmsg ("Action not set");
14532 if (dp_table_set == 0 || vni_set == 0)
14534 errmsg ("vni and dp_table must be set");
14538 /* Construct the API message */
14539 M (LISP_GPE_ADD_DEL_IFACE, mp);
14541 mp->is_add = is_add;
14542 mp->dp_table = dp_table;
14549 /* Wait for a reply... */
14555 * Add/del map request itr rlocs from LISP control plane and updates
14557 * @param vam vpp API test context
14558 * @return return code
14561 api_lisp_add_del_map_request_itr_rlocs (vat_main_t * vam)
14563 unformat_input_t *input = vam->input;
14564 vl_api_lisp_add_del_map_request_itr_rlocs_t *mp;
14565 u8 *locator_set_name = 0;
14566 u8 locator_set_name_set = 0;
14570 /* Parse args required to build the message */
14571 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14573 if (unformat (input, "del"))
14577 else if (unformat (input, "%_%v%_", &locator_set_name))
14579 locator_set_name_set = 1;
14583 clib_warning ("parse error '%U'", format_unformat_error, input);
14588 if (is_add && !locator_set_name_set)
14590 errmsg ("itr-rloc is not set!");
14594 if (is_add && vec_len (locator_set_name) > 64)
14596 errmsg ("itr-rloc locator-set name too long");
14597 vec_free (locator_set_name);
14601 M (LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
14602 mp->is_add = is_add;
14605 clib_memcpy (mp->locator_set_name, locator_set_name,
14606 vec_len (locator_set_name));
14610 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
14612 vec_free (locator_set_name);
14617 /* Wait for a reply... */
14623 api_lisp_locator_dump (vat_main_t * vam)
14625 unformat_input_t *input = vam->input;
14626 vl_api_lisp_locator_dump_t *mp;
14627 u8 is_index_set = 0, is_name_set = 0;
14632 /* Parse args required to build the message */
14633 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14635 if (unformat (input, "ls_name %_%v%_", &ls_name))
14639 else if (unformat (input, "ls_index %d", &ls_index))
14645 errmsg ("parse error '%U'", format_unformat_error, input);
14650 if (!is_index_set && !is_name_set)
14652 errmsg ("error: expected one of index or name!");
14656 if (is_index_set && is_name_set)
14658 errmsg ("error: only one param expected!");
14662 if (vec_len (ls_name) > 62)
14664 errmsg ("error: locator set name too long!");
14668 if (!vam->json_output)
14670 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
14673 M (LISP_LOCATOR_DUMP, mp);
14674 mp->is_index_set = is_index_set;
14677 mp->ls_index = clib_host_to_net_u32 (ls_index);
14680 vec_add1 (ls_name, 0);
14681 strncpy ((char *) mp->ls_name, (char *) ls_name,
14682 sizeof (mp->ls_name) - 1);
14688 /* Use a control ping for synchronization */
14690 vl_api_control_ping_t *mp;
14691 M (CONTROL_PING, mp);
14694 /* Wait for a reply... */
14700 api_lisp_locator_set_dump (vat_main_t * vam)
14702 vl_api_lisp_locator_set_dump_t *mp;
14703 unformat_input_t *input = vam->input;
14707 /* Parse args required to build the message */
14708 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14710 if (unformat (input, "local"))
14714 else if (unformat (input, "remote"))
14720 errmsg ("parse error '%U'", format_unformat_error, input);
14725 if (!vam->json_output)
14727 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
14730 M (LISP_LOCATOR_SET_DUMP, mp);
14732 mp->filter = filter;
14737 /* Use a control ping for synchronization */
14739 vl_api_control_ping_t *mp;
14740 M (CONTROL_PING, mp);
14743 /* Wait for a reply... */
14749 api_lisp_eid_table_map_dump (vat_main_t * vam)
14753 unformat_input_t *input = vam->input;
14754 vl_api_lisp_eid_table_map_dump_t *mp;
14757 /* Parse args required to build the message */
14758 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14760 if (unformat (input, "l2"))
14765 else if (unformat (input, "l3"))
14772 errmsg ("parse error '%U'", format_unformat_error, input);
14779 errmsg ("expected one of 'l2' or 'l3' parameter!");
14783 if (!vam->json_output)
14785 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
14788 M (LISP_EID_TABLE_MAP_DUMP, mp);
14794 /* Use a control ping for synchronization */
14796 vl_api_control_ping_t *mp;
14797 M (CONTROL_PING, mp);
14800 /* Wait for a reply... */
14806 api_lisp_eid_table_vni_dump (vat_main_t * vam)
14808 vl_api_lisp_eid_table_vni_dump_t *mp;
14811 if (!vam->json_output)
14813 print (vam->ofp, "VNI");
14816 M (LISP_EID_TABLE_VNI_DUMP, mp);
14821 /* Use a control ping for synchronization */
14823 vl_api_control_ping_t *mp;
14824 M (CONTROL_PING, mp);
14827 /* Wait for a reply... */
14833 api_lisp_eid_table_dump (vat_main_t * vam)
14835 unformat_input_t *i = vam->input;
14836 vl_api_lisp_eid_table_dump_t *mp;
14837 struct in_addr ip4;
14838 struct in6_addr ip6;
14840 u8 eid_type = ~0, eid_set = 0;
14841 u32 prefix_length = ~0, t, vni = 0;
14845 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14847 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
14853 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
14859 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
14864 else if (unformat (i, "vni %d", &t))
14868 else if (unformat (i, "local"))
14872 else if (unformat (i, "remote"))
14878 errmsg ("parse error '%U'", format_unformat_error, i);
14883 if (!vam->json_output)
14885 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
14886 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
14889 M (LISP_EID_TABLE_DUMP, mp);
14891 mp->filter = filter;
14895 mp->vni = htonl (vni);
14896 mp->eid_type = eid_type;
14900 mp->prefix_length = prefix_length;
14901 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
14904 mp->prefix_length = prefix_length;
14905 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
14908 clib_memcpy (mp->eid, mac, sizeof (mac));
14911 errmsg ("unknown EID type %d!", eid_type);
14919 /* Use a control ping for synchronization */
14921 vl_api_control_ping_t *mp;
14922 M (CONTROL_PING, mp);
14926 /* Wait for a reply... */
14932 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
14934 unformat_input_t *i = vam->input;
14935 vl_api_lisp_gpe_fwd_entries_get_t *mp;
14940 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14942 if (unformat (i, "vni %d", &vni))
14948 errmsg ("parse error '%U'", format_unformat_error, i);
14955 errmsg ("vni not set!");
14959 if (!vam->json_output)
14961 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
14965 M (LISP_GPE_FWD_ENTRIES_GET, mp);
14966 mp->vni = clib_host_to_net_u32 (vni);
14971 /* Wait for a reply... */
14976 #define vl_api_lisp_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
14977 #define vl_api_lisp_gpe_fwd_entries_get_reply_t_print vl_noop_handler
14978 #define vl_api_lisp_gpe_fwd_entry_path_details_t_endian vl_noop_handler
14979 #define vl_api_lisp_gpe_fwd_entry_path_details_t_print vl_noop_handler
14982 api_lisp_adjacencies_get (vat_main_t * vam)
14984 unformat_input_t *i = vam->input;
14985 vl_api_lisp_adjacencies_get_t *mp;
14990 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14992 if (unformat (i, "vni %d", &vni))
14998 errmsg ("parse error '%U'", format_unformat_error, i);
15005 errmsg ("vni not set!");
15009 if (!vam->json_output)
15011 print (vam->ofp, "%s %40s", "leid", "reid");
15014 M (LISP_ADJACENCIES_GET, mp);
15015 mp->vni = clib_host_to_net_u32 (vni);
15020 /* Wait for a reply... */
15026 api_lisp_map_server_dump (vat_main_t * vam)
15028 vl_api_lisp_map_server_dump_t *mp;
15031 if (!vam->json_output)
15033 print (vam->ofp, "%=20s", "Map server");
15036 M (LISP_MAP_SERVER_DUMP, mp);
15040 /* Use a control ping for synchronization */
15042 vl_api_control_ping_t *mp;
15043 M (CONTROL_PING, mp);
15046 /* Wait for a reply... */
15052 api_lisp_map_resolver_dump (vat_main_t * vam)
15054 vl_api_lisp_map_resolver_dump_t *mp;
15057 if (!vam->json_output)
15059 print (vam->ofp, "%=20s", "Map resolver");
15062 M (LISP_MAP_RESOLVER_DUMP, mp);
15066 /* Use a control ping for synchronization */
15068 vl_api_control_ping_t *mp;
15069 M (CONTROL_PING, mp);
15072 /* Wait for a reply... */
15078 api_show_lisp_status (vat_main_t * vam)
15080 vl_api_show_lisp_status_t *mp;
15083 if (!vam->json_output)
15085 print (vam->ofp, "%-20s%-16s", "lisp status", "locator-set");
15088 M (SHOW_LISP_STATUS, mp);
15091 /* Wait for a reply... */
15097 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
15099 vl_api_lisp_gpe_fwd_entry_path_dump_t *mp;
15100 unformat_input_t *i = vam->input;
15101 u32 fwd_entry_index = ~0;
15104 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15106 if (unformat (i, "index %d", &fwd_entry_index))
15112 if (~0 == fwd_entry_index)
15114 errmsg ("no index specified!");
15118 if (!vam->json_output)
15120 print (vam->ofp, "first line");
15123 M (LISP_GPE_FWD_ENTRY_PATH_DUMP, mp);
15127 /* Use a control ping for synchronization */
15129 vl_api_control_ping_t *mp;
15130 M (CONTROL_PING, mp);
15133 /* Wait for a reply... */
15139 api_lisp_get_map_request_itr_rlocs (vat_main_t * vam)
15141 vl_api_lisp_get_map_request_itr_rlocs_t *mp;
15144 if (!vam->json_output)
15146 print (vam->ofp, "%=20s", "itr-rlocs:");
15149 M (LISP_GET_MAP_REQUEST_ITR_RLOCS, mp);
15152 /* Wait for a reply... */
15158 api_af_packet_create (vat_main_t * vam)
15160 unformat_input_t *i = vam->input;
15161 vl_api_af_packet_create_t *mp;
15162 u8 *host_if_name = 0;
15164 u8 random_hw_addr = 1;
15167 memset (hw_addr, 0, sizeof (hw_addr));
15169 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15171 if (unformat (i, "name %s", &host_if_name))
15172 vec_add1 (host_if_name, 0);
15173 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
15174 random_hw_addr = 0;
15179 if (!vec_len (host_if_name))
15181 errmsg ("host-interface name must be specified");
15185 if (vec_len (host_if_name) > 64)
15187 errmsg ("host-interface name too long");
15191 M (AF_PACKET_CREATE, mp);
15193 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
15194 clib_memcpy (mp->hw_addr, hw_addr, 6);
15195 mp->use_random_hw_addr = random_hw_addr;
15196 vec_free (host_if_name);
15199 W2 (ret, fprintf (vam->ofp, " new sw_if_index = %d ", vam->sw_if_index));
15204 api_af_packet_delete (vat_main_t * vam)
15206 unformat_input_t *i = vam->input;
15207 vl_api_af_packet_delete_t *mp;
15208 u8 *host_if_name = 0;
15211 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15213 if (unformat (i, "name %s", &host_if_name))
15214 vec_add1 (host_if_name, 0);
15219 if (!vec_len (host_if_name))
15221 errmsg ("host-interface name must be specified");
15225 if (vec_len (host_if_name) > 64)
15227 errmsg ("host-interface name too long");
15231 M (AF_PACKET_DELETE, mp);
15233 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
15234 vec_free (host_if_name);
15242 api_policer_add_del (vat_main_t * vam)
15244 unformat_input_t *i = vam->input;
15245 vl_api_policer_add_del_t *mp;
15255 u8 color_aware = 0;
15256 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
15259 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
15260 conform_action.dscp = 0;
15261 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
15262 exceed_action.dscp = 0;
15263 violate_action.action_type = SSE2_QOS_ACTION_DROP;
15264 violate_action.dscp = 0;
15266 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15268 if (unformat (i, "del"))
15270 else if (unformat (i, "name %s", &name))
15271 vec_add1 (name, 0);
15272 else if (unformat (i, "cir %u", &cir))
15274 else if (unformat (i, "eir %u", &eir))
15276 else if (unformat (i, "cb %u", &cb))
15278 else if (unformat (i, "eb %u", &eb))
15280 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
15283 else if (unformat (i, "round_type %U", unformat_policer_round_type,
15286 else if (unformat (i, "type %U", unformat_policer_type, &type))
15288 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
15291 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
15294 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
15297 else if (unformat (i, "color-aware"))
15303 if (!vec_len (name))
15305 errmsg ("policer name must be specified");
15309 if (vec_len (name) > 64)
15311 errmsg ("policer name too long");
15315 M (POLICER_ADD_DEL, mp);
15317 clib_memcpy (mp->name, name, vec_len (name));
15319 mp->is_add = is_add;
15324 mp->rate_type = rate_type;
15325 mp->round_type = round_type;
15327 mp->conform_action_type = conform_action.action_type;
15328 mp->conform_dscp = conform_action.dscp;
15329 mp->exceed_action_type = exceed_action.action_type;
15330 mp->exceed_dscp = exceed_action.dscp;
15331 mp->violate_action_type = violate_action.action_type;
15332 mp->violate_dscp = violate_action.dscp;
15333 mp->color_aware = color_aware;
15341 api_policer_dump (vat_main_t * vam)
15343 unformat_input_t *i = vam->input;
15344 vl_api_policer_dump_t *mp;
15345 u8 *match_name = 0;
15346 u8 match_name_valid = 0;
15349 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15351 if (unformat (i, "name %s", &match_name))
15353 vec_add1 (match_name, 0);
15354 match_name_valid = 1;
15360 M (POLICER_DUMP, mp);
15361 mp->match_name_valid = match_name_valid;
15362 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
15363 vec_free (match_name);
15367 /* Use a control ping for synchronization */
15369 vl_api_control_ping_t *mp;
15370 M (CONTROL_PING, mp);
15373 /* Wait for a reply... */
15379 api_policer_classify_set_interface (vat_main_t * vam)
15381 unformat_input_t *i = vam->input;
15382 vl_api_policer_classify_set_interface_t *mp;
15384 int sw_if_index_set;
15385 u32 ip4_table_index = ~0;
15386 u32 ip6_table_index = ~0;
15387 u32 l2_table_index = ~0;
15391 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15393 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15394 sw_if_index_set = 1;
15395 else if (unformat (i, "sw_if_index %d", &sw_if_index))
15396 sw_if_index_set = 1;
15397 else if (unformat (i, "del"))
15399 else if (unformat (i, "ip4-table %d", &ip4_table_index))
15401 else if (unformat (i, "ip6-table %d", &ip6_table_index))
15403 else if (unformat (i, "l2-table %d", &l2_table_index))
15407 clib_warning ("parse error '%U'", format_unformat_error, i);
15412 if (sw_if_index_set == 0)
15414 errmsg ("missing interface name or sw_if_index");
15418 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
15420 mp->sw_if_index = ntohl (sw_if_index);
15421 mp->ip4_table_index = ntohl (ip4_table_index);
15422 mp->ip6_table_index = ntohl (ip6_table_index);
15423 mp->l2_table_index = ntohl (l2_table_index);
15424 mp->is_add = is_add;
15432 api_policer_classify_dump (vat_main_t * vam)
15434 unformat_input_t *i = vam->input;
15435 vl_api_policer_classify_dump_t *mp;
15436 u8 type = POLICER_CLASSIFY_N_TABLES;
15439 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
15443 errmsg ("classify table type must be specified");
15447 if (!vam->json_output)
15449 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
15452 M (POLICER_CLASSIFY_DUMP, mp);
15457 /* Use a control ping for synchronization */
15459 vl_api_control_ping_t *mp;
15460 M (CONTROL_PING, mp);
15463 /* Wait for a reply... */
15469 api_netmap_create (vat_main_t * vam)
15471 unformat_input_t *i = vam->input;
15472 vl_api_netmap_create_t *mp;
15475 u8 random_hw_addr = 1;
15480 memset (hw_addr, 0, sizeof (hw_addr));
15482 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15484 if (unformat (i, "name %s", &if_name))
15485 vec_add1 (if_name, 0);
15486 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
15487 random_hw_addr = 0;
15488 else if (unformat (i, "pipe"))
15490 else if (unformat (i, "master"))
15492 else if (unformat (i, "slave"))
15498 if (!vec_len (if_name))
15500 errmsg ("interface name must be specified");
15504 if (vec_len (if_name) > 64)
15506 errmsg ("interface name too long");
15510 M (NETMAP_CREATE, mp);
15512 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
15513 clib_memcpy (mp->hw_addr, hw_addr, 6);
15514 mp->use_random_hw_addr = random_hw_addr;
15515 mp->is_pipe = is_pipe;
15516 mp->is_master = is_master;
15517 vec_free (if_name);
15525 api_netmap_delete (vat_main_t * vam)
15527 unformat_input_t *i = vam->input;
15528 vl_api_netmap_delete_t *mp;
15532 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15534 if (unformat (i, "name %s", &if_name))
15535 vec_add1 (if_name, 0);
15540 if (!vec_len (if_name))
15542 errmsg ("interface name must be specified");
15546 if (vec_len (if_name) > 64)
15548 errmsg ("interface name too long");
15552 M (NETMAP_DELETE, mp);
15554 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
15555 vec_free (if_name);
15562 static void vl_api_mpls_tunnel_details_t_handler
15563 (vl_api_mpls_tunnel_details_t * mp)
15565 vat_main_t *vam = &vat_main;
15566 i32 len = mp->mt_next_hop_n_labels;
15569 print (vam->ofp, "[%d]: via %U %d labels ",
15571 format_ip4_address, mp->mt_next_hop,
15572 ntohl (mp->mt_next_hop_sw_if_index));
15573 for (i = 0; i < len; i++)
15575 print (vam->ofp, "%u ", ntohl (mp->mt_next_hop_out_labels[i]));
15577 print (vam->ofp, "");
15580 static void vl_api_mpls_tunnel_details_t_handler_json
15581 (vl_api_mpls_tunnel_details_t * mp)
15583 vat_main_t *vam = &vat_main;
15584 vat_json_node_t *node = NULL;
15585 struct in_addr ip4;
15587 i32 len = mp->mt_next_hop_n_labels;
15589 if (VAT_JSON_ARRAY != vam->json_tree.type)
15591 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15592 vat_json_init_array (&vam->json_tree);
15594 node = vat_json_array_add (&vam->json_tree);
15596 vat_json_init_object (node);
15597 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
15598 clib_memcpy (&ip4, &(mp->mt_next_hop), sizeof (ip4));
15599 vat_json_object_add_ip4 (node, "next_hop", ip4);
15600 vat_json_object_add_uint (node, "next_hop_sw_if_index",
15601 ntohl (mp->mt_next_hop_sw_if_index));
15602 vat_json_object_add_uint (node, "l2_only", ntohl (mp->mt_l2_only));
15603 vat_json_object_add_uint (node, "label_count", len);
15604 for (i = 0; i < len; i++)
15606 vat_json_object_add_uint (node, "label",
15607 ntohl (mp->mt_next_hop_out_labels[i]));
15612 api_mpls_tunnel_dump (vat_main_t * vam)
15614 vl_api_mpls_tunnel_dump_t *mp;
15618 /* Parse args required to build the message */
15619 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
15621 if (!unformat (vam->input, "tunnel_index %d", &index))
15628 print (vam->ofp, " tunnel_index %d", index);
15630 M (MPLS_TUNNEL_DUMP, mp);
15631 mp->tunnel_index = htonl (index);
15634 /* Use a control ping for synchronization */
15636 vl_api_control_ping_t *mp;
15637 M (CONTROL_PING, mp);
15644 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
15645 #define vl_api_mpls_fib_details_t_print vl_noop_handler
15648 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
15650 vat_main_t *vam = &vat_main;
15651 int count = ntohl (mp->count);
15652 vl_api_fib_path2_t *fp;
15656 "table-id %d, label %u, ess_bit %u",
15657 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
15659 for (i = 0; i < count; i++)
15661 if (fp->afi == IP46_TYPE_IP6)
15663 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15664 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15665 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15666 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15667 format_ip6_address, fp->next_hop);
15668 else if (fp->afi == IP46_TYPE_IP4)
15670 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15671 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15672 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15673 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15674 format_ip4_address, fp->next_hop);
15679 static void vl_api_mpls_fib_details_t_handler_json
15680 (vl_api_mpls_fib_details_t * mp)
15682 vat_main_t *vam = &vat_main;
15683 int count = ntohl (mp->count);
15684 vat_json_node_t *node = NULL;
15685 struct in_addr ip4;
15686 struct in6_addr ip6;
15687 vl_api_fib_path2_t *fp;
15690 if (VAT_JSON_ARRAY != vam->json_tree.type)
15692 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15693 vat_json_init_array (&vam->json_tree);
15695 node = vat_json_array_add (&vam->json_tree);
15697 vat_json_init_object (node);
15698 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
15699 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
15700 vat_json_object_add_uint (node, "label", ntohl (mp->label));
15701 vat_json_object_add_uint (node, "path_count", count);
15703 for (i = 0; i < count; i++)
15705 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
15706 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
15707 vat_json_object_add_uint (node, "is_local", fp->is_local);
15708 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
15709 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
15710 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
15711 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
15712 if (fp->afi == IP46_TYPE_IP4)
15714 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
15715 vat_json_object_add_ip4 (node, "next_hop", ip4);
15717 else if (fp->afi == IP46_TYPE_IP6)
15719 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
15720 vat_json_object_add_ip6 (node, "next_hop", ip6);
15726 api_mpls_fib_dump (vat_main_t * vam)
15728 vl_api_mpls_fib_dump_t *mp;
15731 M (MPLS_FIB_DUMP, mp);
15734 /* Use a control ping for synchronization */
15736 vl_api_control_ping_t *mp;
15737 M (CONTROL_PING, mp);
15744 #define vl_api_ip_fib_details_t_endian vl_noop_handler
15745 #define vl_api_ip_fib_details_t_print vl_noop_handler
15748 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
15750 vat_main_t *vam = &vat_main;
15751 int count = ntohl (mp->count);
15752 vl_api_fib_path_t *fp;
15756 "table-id %d, prefix %U/%d",
15757 ntohl (mp->table_id), format_ip4_address, mp->address,
15758 mp->address_length);
15760 for (i = 0; i < count; i++)
15762 if (fp->afi == IP46_TYPE_IP6)
15764 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15765 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15766 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15767 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15768 format_ip6_address, fp->next_hop);
15769 else if (fp->afi == IP46_TYPE_IP4)
15771 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15772 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15773 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15774 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15775 format_ip4_address, fp->next_hop);
15780 static void vl_api_ip_fib_details_t_handler_json
15781 (vl_api_ip_fib_details_t * mp)
15783 vat_main_t *vam = &vat_main;
15784 int count = ntohl (mp->count);
15785 vat_json_node_t *node = NULL;
15786 struct in_addr ip4;
15787 struct in6_addr ip6;
15788 vl_api_fib_path_t *fp;
15791 if (VAT_JSON_ARRAY != vam->json_tree.type)
15793 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15794 vat_json_init_array (&vam->json_tree);
15796 node = vat_json_array_add (&vam->json_tree);
15798 vat_json_init_object (node);
15799 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
15800 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
15801 vat_json_object_add_ip4 (node, "prefix", ip4);
15802 vat_json_object_add_uint (node, "mask_length", mp->address_length);
15803 vat_json_object_add_uint (node, "path_count", count);
15805 for (i = 0; i < count; i++)
15807 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
15808 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
15809 vat_json_object_add_uint (node, "is_local", fp->is_local);
15810 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
15811 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
15812 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
15813 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
15814 if (fp->afi == IP46_TYPE_IP4)
15816 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
15817 vat_json_object_add_ip4 (node, "next_hop", ip4);
15819 else if (fp->afi == IP46_TYPE_IP6)
15821 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
15822 vat_json_object_add_ip6 (node, "next_hop", ip6);
15828 api_ip_fib_dump (vat_main_t * vam)
15830 vl_api_ip_fib_dump_t *mp;
15833 M (IP_FIB_DUMP, mp);
15836 /* Use a control ping for synchronization */
15838 vl_api_control_ping_t *mp;
15839 M (CONTROL_PING, mp);
15846 static void vl_api_ip_neighbor_details_t_handler
15847 (vl_api_ip_neighbor_details_t * mp)
15849 vat_main_t *vam = &vat_main;
15851 print (vam->ofp, "%c %U %U",
15852 (mp->is_static) ? 'S' : 'D',
15853 format_ethernet_address, &mp->mac_address,
15854 (mp->is_ipv6) ? format_ip6_address : format_ip4_address,
15858 static void vl_api_ip_neighbor_details_t_handler_json
15859 (vl_api_ip_neighbor_details_t * mp)
15862 vat_main_t *vam = &vat_main;
15863 vat_json_node_t *node;
15864 struct in_addr ip4;
15865 struct in6_addr ip6;
15867 if (VAT_JSON_ARRAY != vam->json_tree.type)
15869 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15870 vat_json_init_array (&vam->json_tree);
15872 node = vat_json_array_add (&vam->json_tree);
15874 vat_json_init_object (node);
15875 vat_json_object_add_string_copy (node, "flag",
15876 (mp->is_static) ? (u8 *) "static" : (u8 *)
15879 vat_json_object_add_string_copy (node, "link_layer",
15880 format (0, "%U", format_ethernet_address,
15881 &mp->mac_address));
15885 clib_memcpy (&ip6, &mp->ip_address, sizeof (ip6));
15886 vat_json_object_add_ip6 (node, "ip_address", ip6);
15890 clib_memcpy (&ip4, &mp->ip_address, sizeof (ip4));
15891 vat_json_object_add_ip4 (node, "ip_address", ip4);
15896 api_ip_neighbor_dump (vat_main_t * vam)
15898 unformat_input_t *i = vam->input;
15899 vl_api_ip_neighbor_dump_t *mp;
15901 u32 sw_if_index = ~0;
15904 /* Parse args required to build the message */
15905 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15907 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15909 else if (unformat (i, "sw_if_index %d", &sw_if_index))
15911 else if (unformat (i, "ip6"))
15917 if (sw_if_index == ~0)
15919 errmsg ("missing interface name or sw_if_index");
15923 M (IP_NEIGHBOR_DUMP, mp);
15924 mp->is_ipv6 = (u8) is_ipv6;
15925 mp->sw_if_index = ntohl (sw_if_index);
15928 /* Use a control ping for synchronization */
15930 vl_api_control_ping_t *mp;
15931 M (CONTROL_PING, mp);
15938 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
15939 #define vl_api_ip6_fib_details_t_print vl_noop_handler
15942 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
15944 vat_main_t *vam = &vat_main;
15945 int count = ntohl (mp->count);
15946 vl_api_fib_path_t *fp;
15950 "table-id %d, prefix %U/%d",
15951 ntohl (mp->table_id), format_ip6_address, mp->address,
15952 mp->address_length);
15954 for (i = 0; i < count; i++)
15956 if (fp->afi == IP46_TYPE_IP6)
15958 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15959 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15960 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15961 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15962 format_ip6_address, fp->next_hop);
15963 else if (fp->afi == IP46_TYPE_IP4)
15965 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15966 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15967 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15968 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15969 format_ip4_address, fp->next_hop);
15974 static void vl_api_ip6_fib_details_t_handler_json
15975 (vl_api_ip6_fib_details_t * mp)
15977 vat_main_t *vam = &vat_main;
15978 int count = ntohl (mp->count);
15979 vat_json_node_t *node = NULL;
15980 struct in_addr ip4;
15981 struct in6_addr ip6;
15982 vl_api_fib_path_t *fp;
15985 if (VAT_JSON_ARRAY != vam->json_tree.type)
15987 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15988 vat_json_init_array (&vam->json_tree);
15990 node = vat_json_array_add (&vam->json_tree);
15992 vat_json_init_object (node);
15993 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
15994 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
15995 vat_json_object_add_ip6 (node, "prefix", ip6);
15996 vat_json_object_add_uint (node, "mask_length", mp->address_length);
15997 vat_json_object_add_uint (node, "path_count", count);
15999 for (i = 0; i < count; i++)
16001 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
16002 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
16003 vat_json_object_add_uint (node, "is_local", fp->is_local);
16004 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
16005 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
16006 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
16007 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
16008 if (fp->afi == IP46_TYPE_IP4)
16010 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
16011 vat_json_object_add_ip4 (node, "next_hop", ip4);
16013 else if (fp->afi == IP46_TYPE_IP6)
16015 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
16016 vat_json_object_add_ip6 (node, "next_hop", ip6);
16022 api_ip6_fib_dump (vat_main_t * vam)
16024 vl_api_ip6_fib_dump_t *mp;
16027 M (IP6_FIB_DUMP, mp);
16030 /* Use a control ping for synchronization */
16032 vl_api_control_ping_t *mp;
16033 M (CONTROL_PING, mp);
16041 api_classify_table_ids (vat_main_t * vam)
16043 vl_api_classify_table_ids_t *mp;
16046 /* Construct the API message */
16047 M (CLASSIFY_TABLE_IDS, mp);
16056 api_classify_table_by_interface (vat_main_t * vam)
16058 unformat_input_t *input = vam->input;
16059 vl_api_classify_table_by_interface_t *mp;
16061 u32 sw_if_index = ~0;
16063 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16065 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16067 else if (unformat (input, "sw_if_index %d", &sw_if_index))
16072 if (sw_if_index == ~0)
16074 errmsg ("missing interface name or sw_if_index");
16078 /* Construct the API message */
16079 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
16081 mp->sw_if_index = ntohl (sw_if_index);
16089 api_classify_table_info (vat_main_t * vam)
16091 unformat_input_t *input = vam->input;
16092 vl_api_classify_table_info_t *mp;
16096 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16098 if (unformat (input, "table_id %d", &table_id))
16103 if (table_id == ~0)
16105 errmsg ("missing table id");
16109 /* Construct the API message */
16110 M (CLASSIFY_TABLE_INFO, mp);
16112 mp->table_id = ntohl (table_id);
16120 api_classify_session_dump (vat_main_t * vam)
16122 unformat_input_t *input = vam->input;
16123 vl_api_classify_session_dump_t *mp;
16127 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16129 if (unformat (input, "table_id %d", &table_id))
16134 if (table_id == ~0)
16136 errmsg ("missing table id");
16140 /* Construct the API message */
16141 M (CLASSIFY_SESSION_DUMP, mp);
16143 mp->table_id = ntohl (table_id);
16146 /* Use a control ping for synchronization */
16148 vl_api_control_ping_t *mp;
16149 M (CONTROL_PING, mp);
16157 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
16159 vat_main_t *vam = &vat_main;
16161 print (vam->ofp, "collector_address %U, collector_port %d, "
16162 "src_address %U, vrf_id %d, path_mtu %u, "
16163 "template_interval %u, udp_checksum %d",
16164 format_ip4_address, mp->collector_address,
16165 ntohs (mp->collector_port),
16166 format_ip4_address, mp->src_address,
16167 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
16168 ntohl (mp->template_interval), mp->udp_checksum);
16171 vam->result_ready = 1;
16175 vl_api_ipfix_exporter_details_t_handler_json
16176 (vl_api_ipfix_exporter_details_t * mp)
16178 vat_main_t *vam = &vat_main;
16179 vat_json_node_t node;
16180 struct in_addr collector_address;
16181 struct in_addr src_address;
16183 vat_json_init_object (&node);
16184 clib_memcpy (&collector_address, &mp->collector_address,
16185 sizeof (collector_address));
16186 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
16187 vat_json_object_add_uint (&node, "collector_port",
16188 ntohs (mp->collector_port));
16189 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
16190 vat_json_object_add_ip4 (&node, "src_address", src_address);
16191 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
16192 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
16193 vat_json_object_add_uint (&node, "template_interval",
16194 ntohl (mp->template_interval));
16195 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
16197 vat_json_print (vam->ofp, &node);
16198 vat_json_free (&node);
16200 vam->result_ready = 1;
16204 api_ipfix_exporter_dump (vat_main_t * vam)
16206 vl_api_ipfix_exporter_dump_t *mp;
16209 /* Construct the API message */
16210 M (IPFIX_EXPORTER_DUMP, mp);
16219 api_ipfix_classify_stream_dump (vat_main_t * vam)
16221 vl_api_ipfix_classify_stream_dump_t *mp;
16224 /* Construct the API message */
16225 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
16236 vl_api_ipfix_classify_stream_details_t_handler
16237 (vl_api_ipfix_classify_stream_details_t * mp)
16239 vat_main_t *vam = &vat_main;
16240 print (vam->ofp, "domain_id %d, src_port %d",
16241 ntohl (mp->domain_id), ntohs (mp->src_port));
16243 vam->result_ready = 1;
16247 vl_api_ipfix_classify_stream_details_t_handler_json
16248 (vl_api_ipfix_classify_stream_details_t * mp)
16250 vat_main_t *vam = &vat_main;
16251 vat_json_node_t node;
16253 vat_json_init_object (&node);
16254 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
16255 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
16257 vat_json_print (vam->ofp, &node);
16258 vat_json_free (&node);
16260 vam->result_ready = 1;
16264 api_ipfix_classify_table_dump (vat_main_t * vam)
16266 vl_api_ipfix_classify_table_dump_t *mp;
16269 if (!vam->json_output)
16271 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
16272 "transport_protocol");
16275 /* Construct the API message */
16276 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
16281 /* Use a control ping for synchronization */
16283 vl_api_control_ping_t *mp;
16284 M (CONTROL_PING, mp);
16292 vl_api_ipfix_classify_table_details_t_handler
16293 (vl_api_ipfix_classify_table_details_t * mp)
16295 vat_main_t *vam = &vat_main;
16296 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
16297 mp->transport_protocol);
16301 vl_api_ipfix_classify_table_details_t_handler_json
16302 (vl_api_ipfix_classify_table_details_t * mp)
16304 vat_json_node_t *node = NULL;
16305 vat_main_t *vam = &vat_main;
16307 if (VAT_JSON_ARRAY != vam->json_tree.type)
16309 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16310 vat_json_init_array (&vam->json_tree);
16313 node = vat_json_array_add (&vam->json_tree);
16314 vat_json_init_object (node);
16316 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
16317 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
16318 vat_json_object_add_uint (node, "transport_protocol",
16319 mp->transport_protocol);
16323 api_sw_interface_span_enable_disable (vat_main_t * vam)
16325 unformat_input_t *i = vam->input;
16326 vl_api_sw_interface_span_enable_disable_t *mp;
16327 u32 src_sw_if_index = ~0;
16328 u32 dst_sw_if_index = ~0;
16332 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16335 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
16337 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
16341 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
16343 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
16345 else if (unformat (i, "disable"))
16347 else if (unformat (i, "rx"))
16349 else if (unformat (i, "tx"))
16351 else if (unformat (i, "both"))
16357 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
16359 mp->sw_if_index_from = htonl (src_sw_if_index);
16360 mp->sw_if_index_to = htonl (dst_sw_if_index);
16369 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
16372 vat_main_t *vam = &vat_main;
16373 u8 *sw_if_from_name = 0;
16374 u8 *sw_if_to_name = 0;
16375 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
16376 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
16377 char *states[] = { "none", "rx", "tx", "both" };
16381 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
16383 if ((u32) p->value[0] == sw_if_index_from)
16385 sw_if_from_name = (u8 *)(p->key);
16389 if ((u32) p->value[0] == sw_if_index_to)
16391 sw_if_to_name = (u8 *)(p->key);
16392 if (sw_if_from_name)
16397 print (vam->ofp, "%20s => %20s (%s)",
16398 sw_if_from_name, sw_if_to_name, states[mp->state]);
16402 vl_api_sw_interface_span_details_t_handler_json
16403 (vl_api_sw_interface_span_details_t * mp)
16405 vat_main_t *vam = &vat_main;
16406 vat_json_node_t *node = NULL;
16407 u8 *sw_if_from_name = 0;
16408 u8 *sw_if_to_name = 0;
16409 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
16410 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
16414 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
16416 if ((u32) p->value[0] == sw_if_index_from)
16418 sw_if_from_name = (u8 *)(p->key);
16422 if ((u32) p->value[0] == sw_if_index_to)
16424 sw_if_to_name = (u8 *)(p->key);
16425 if (sw_if_from_name)
16431 if (VAT_JSON_ARRAY != vam->json_tree.type)
16433 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16434 vat_json_init_array (&vam->json_tree);
16436 node = vat_json_array_add (&vam->json_tree);
16438 vat_json_init_object (node);
16439 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
16440 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
16441 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
16442 if (0 != sw_if_to_name)
16444 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
16446 vat_json_object_add_uint (node, "state", mp->state);
16450 api_sw_interface_span_dump (vat_main_t * vam)
16452 vl_api_sw_interface_span_dump_t *mp;
16455 M (SW_INTERFACE_SPAN_DUMP, mp);
16458 /* Use a control ping for synchronization */
16460 vl_api_control_ping_t *mp;
16461 M (CONTROL_PING, mp);
16469 api_pg_create_interface (vat_main_t * vam)
16471 unformat_input_t *input = vam->input;
16472 vl_api_pg_create_interface_t *mp;
16476 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16478 if (unformat (input, "if_id %d", &if_id))
16485 errmsg ("missing pg interface index");
16489 /* Construct the API message */
16490 M (PG_CREATE_INTERFACE, mp);
16492 mp->interface_id = ntohl (if_id);
16500 api_pg_capture (vat_main_t * vam)
16502 unformat_input_t *input = vam->input;
16503 vl_api_pg_capture_t *mp;
16508 u8 pcap_file_set = 0;
16511 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16513 if (unformat (input, "if_id %d", &if_id))
16515 else if (unformat (input, "pcap %s", &pcap_file))
16517 else if (unformat (input, "count %d", &count))
16519 else if (unformat (input, "disable"))
16526 errmsg ("missing pg interface index");
16529 if (pcap_file_set > 0)
16531 if (vec_len (pcap_file) > 255)
16533 errmsg ("pcap file name is too long");
16538 u32 name_len = vec_len (pcap_file);
16539 /* Construct the API message */
16540 M (PG_CAPTURE, mp);
16542 mp->interface_id = ntohl (if_id);
16543 mp->is_enabled = enable;
16544 mp->count = ntohl (count);
16545 mp->pcap_name_length = ntohl (name_len);
16546 if (pcap_file_set != 0)
16548 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
16550 vec_free (pcap_file);
16558 api_pg_enable_disable (vat_main_t * vam)
16560 unformat_input_t *input = vam->input;
16561 vl_api_pg_enable_disable_t *mp;
16564 u8 stream_name_set = 0;
16565 u8 *stream_name = 0;
16567 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16569 if (unformat (input, "stream %s", &stream_name))
16570 stream_name_set = 1;
16571 else if (unformat (input, "disable"))
16577 if (stream_name_set > 0)
16579 if (vec_len (stream_name) > 255)
16581 errmsg ("stream name too long");
16586 u32 name_len = vec_len (stream_name);
16587 /* Construct the API message */
16588 M (PG_ENABLE_DISABLE, mp);
16590 mp->is_enabled = enable;
16591 if (stream_name_set != 0)
16593 mp->stream_name_length = ntohl (name_len);
16594 clib_memcpy (mp->stream_name, stream_name, name_len);
16596 vec_free (stream_name);
16604 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
16606 unformat_input_t *input = vam->input;
16607 vl_api_ip_source_and_port_range_check_add_del_t *mp;
16609 u16 *low_ports = 0;
16610 u16 *high_ports = 0;
16613 ip4_address_t ip4_addr;
16614 ip6_address_t ip6_addr;
16623 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16625 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
16631 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
16636 else if (unformat (input, "vrf %d", &vrf_id))
16638 else if (unformat (input, "del"))
16640 else if (unformat (input, "port %d", &tmp))
16642 if (tmp == 0 || tmp > 65535)
16644 errmsg ("port %d out of range", tmp);
16648 this_hi = this_low + 1;
16649 vec_add1 (low_ports, this_low);
16650 vec_add1 (high_ports, this_hi);
16652 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
16654 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
16656 errmsg ("incorrect range parameters");
16660 /* Note: in debug CLI +1 is added to high before
16661 passing to real fn that does "the work"
16662 (ip_source_and_port_range_check_add_del).
16663 This fn is a wrapper around the binary API fn a
16664 control plane will call, which expects this increment
16665 to have occurred. Hence letting the binary API control
16666 plane fn do the increment for consistency between VAT
16667 and other control planes.
16670 vec_add1 (low_ports, this_low);
16671 vec_add1 (high_ports, this_hi);
16677 if (prefix_set == 0)
16679 errmsg ("<address>/<mask> not specified");
16685 errmsg ("VRF ID required, not specified");
16692 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
16696 if (vec_len (low_ports) == 0)
16698 errmsg ("At least one port or port range required");
16702 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
16704 mp->is_add = is_add;
16709 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
16714 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
16717 mp->mask_length = length;
16718 mp->number_of_ranges = vec_len (low_ports);
16720 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
16721 vec_free (low_ports);
16723 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
16724 vec_free (high_ports);
16726 mp->vrf_id = ntohl (vrf_id);
16734 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
16736 unformat_input_t *input = vam->input;
16737 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
16738 u32 sw_if_index = ~0;
16740 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
16741 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
16745 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16747 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16749 else if (unformat (input, "sw_if_index %d", &sw_if_index))
16751 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
16753 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
16755 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
16757 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
16759 else if (unformat (input, "del"))
16765 if (sw_if_index == ~0)
16767 errmsg ("Interface required but not specified");
16773 errmsg ("VRF ID required but not specified");
16777 if (tcp_out_vrf_id == 0
16778 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
16781 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
16785 /* Construct the API message */
16786 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
16788 mp->sw_if_index = ntohl (sw_if_index);
16789 mp->is_add = is_add;
16790 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
16791 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
16792 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
16793 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
16798 /* Wait for a reply... */
16804 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
16806 unformat_input_t *i = vam->input;
16807 vl_api_ipsec_gre_add_del_tunnel_t *mp;
16808 u32 local_sa_id = 0;
16809 u32 remote_sa_id = 0;
16810 ip4_address_t src_address;
16811 ip4_address_t dst_address;
16815 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16817 if (unformat (i, "local_sa %d", &local_sa_id))
16819 else if (unformat (i, "remote_sa %d", &remote_sa_id))
16821 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
16823 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
16825 else if (unformat (i, "del"))
16829 clib_warning ("parse error '%U'", format_unformat_error, i);
16834 M (IPSEC_GRE_ADD_DEL_TUNNEL, mp);
16836 mp->local_sa_id = ntohl (local_sa_id);
16837 mp->remote_sa_id = ntohl (remote_sa_id);
16838 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
16839 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
16840 mp->is_add = is_add;
16848 api_punt (vat_main_t * vam)
16850 unformat_input_t *i = vam->input;
16858 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16860 if (unformat (i, "ip %d", &ipv))
16862 else if (unformat (i, "protocol %d", &protocol))
16864 else if (unformat (i, "port %d", &port))
16866 else if (unformat (i, "del"))
16870 clib_warning ("parse error '%U'", format_unformat_error, i);
16877 mp->is_add = (u8) is_add;
16878 mp->ipv = (u8) ipv;
16879 mp->l4_protocol = (u8) protocol;
16880 mp->l4_port = htons ((u16) port);
16887 static void vl_api_ipsec_gre_tunnel_details_t_handler
16888 (vl_api_ipsec_gre_tunnel_details_t * mp)
16890 vat_main_t *vam = &vat_main;
16892 print (vam->ofp, "%11d%15U%15U%14d%14d",
16893 ntohl (mp->sw_if_index),
16894 format_ip4_address, &mp->src_address,
16895 format_ip4_address, &mp->dst_address,
16896 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
16899 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
16900 (vl_api_ipsec_gre_tunnel_details_t * mp)
16902 vat_main_t *vam = &vat_main;
16903 vat_json_node_t *node = NULL;
16904 struct in_addr ip4;
16906 if (VAT_JSON_ARRAY != vam->json_tree.type)
16908 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16909 vat_json_init_array (&vam->json_tree);
16911 node = vat_json_array_add (&vam->json_tree);
16913 vat_json_init_object (node);
16914 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
16915 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
16916 vat_json_object_add_ip4 (node, "src_address", ip4);
16917 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
16918 vat_json_object_add_ip4 (node, "dst_address", ip4);
16919 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
16920 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
16924 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
16926 unformat_input_t *i = vam->input;
16927 vl_api_ipsec_gre_tunnel_dump_t *mp;
16929 u8 sw_if_index_set = 0;
16932 /* Parse args required to build the message */
16933 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16935 if (unformat (i, "sw_if_index %d", &sw_if_index))
16936 sw_if_index_set = 1;
16941 if (sw_if_index_set == 0)
16946 if (!vam->json_output)
16948 print (vam->ofp, "%11s%15s%15s%14s%14s",
16949 "sw_if_index", "src_address", "dst_address",
16950 "local_sa_id", "remote_sa_id");
16953 /* Get list of gre-tunnel interfaces */
16954 M (IPSEC_GRE_TUNNEL_DUMP, mp);
16956 mp->sw_if_index = htonl (sw_if_index);
16960 /* Use a control ping for synchronization */
16962 vl_api_control_ping_t *mp;
16963 M (CONTROL_PING, mp);
16971 api_delete_subif (vat_main_t * vam)
16973 unformat_input_t *i = vam->input;
16974 vl_api_delete_subif_t *mp;
16975 u32 sw_if_index = ~0;
16978 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16980 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16982 if (unformat (i, "sw_if_index %d", &sw_if_index))
16988 if (sw_if_index == ~0)
16990 errmsg ("missing sw_if_index");
16994 /* Construct the API message */
16995 M (DELETE_SUBIF, mp);
16996 mp->sw_if_index = ntohl (sw_if_index);
17003 #define foreach_pbb_vtr_op \
17004 _("disable", L2_VTR_DISABLED) \
17005 _("pop", L2_VTR_POP_2) \
17006 _("push", L2_VTR_PUSH_2)
17009 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
17011 unformat_input_t *i = vam->input;
17012 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
17013 u32 sw_if_index = ~0, vtr_op = ~0;
17014 u16 outer_tag = ~0;
17015 u8 dmac[6], smac[6];
17016 u8 dmac_set = 0, smac_set = 0;
17022 /* Shut up coverity */
17023 memset (dmac, 0, sizeof (dmac));
17024 memset (smac, 0, sizeof (smac));
17026 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17028 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17030 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17032 else if (unformat (i, "vtr_op %d", &vtr_op))
17034 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
17037 else if (unformat (i, "translate_pbb_stag"))
17039 if (unformat (i, "%d", &tmp))
17041 vtr_op = L2_VTR_TRANSLATE_2_1;
17047 ("translate_pbb_stag operation requires outer tag definition");
17051 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
17053 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
17055 else if (unformat (i, "sid %d", &sid))
17057 else if (unformat (i, "vlanid %d", &tmp))
17061 clib_warning ("parse error '%U'", format_unformat_error, i);
17066 if ((sw_if_index == ~0) || (vtr_op == ~0))
17068 errmsg ("missing sw_if_index or vtr operation");
17071 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
17072 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
17075 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
17079 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
17080 mp->sw_if_index = ntohl (sw_if_index);
17081 mp->vtr_op = ntohl (vtr_op);
17082 mp->outer_tag = ntohs (outer_tag);
17083 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
17084 clib_memcpy (mp->b_smac, smac, sizeof (smac));
17085 mp->b_vlanid = ntohs (vlanid);
17086 mp->i_sid = ntohl (sid);
17094 api_flow_classify_set_interface (vat_main_t * vam)
17096 unformat_input_t *i = vam->input;
17097 vl_api_flow_classify_set_interface_t *mp;
17099 int sw_if_index_set;
17100 u32 ip4_table_index = ~0;
17101 u32 ip6_table_index = ~0;
17105 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17107 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17108 sw_if_index_set = 1;
17109 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17110 sw_if_index_set = 1;
17111 else if (unformat (i, "del"))
17113 else if (unformat (i, "ip4-table %d", &ip4_table_index))
17115 else if (unformat (i, "ip6-table %d", &ip6_table_index))
17119 clib_warning ("parse error '%U'", format_unformat_error, i);
17124 if (sw_if_index_set == 0)
17126 errmsg ("missing interface name or sw_if_index");
17130 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
17132 mp->sw_if_index = ntohl (sw_if_index);
17133 mp->ip4_table_index = ntohl (ip4_table_index);
17134 mp->ip6_table_index = ntohl (ip6_table_index);
17135 mp->is_add = is_add;
17143 api_flow_classify_dump (vat_main_t * vam)
17145 unformat_input_t *i = vam->input;
17146 vl_api_flow_classify_dump_t *mp;
17147 u8 type = FLOW_CLASSIFY_N_TABLES;
17150 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
17154 errmsg ("classify table type must be specified");
17158 if (!vam->json_output)
17160 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
17163 M (FLOW_CLASSIFY_DUMP, mp);
17168 /* Use a control ping for synchronization */
17170 vl_api_control_ping_t *mp;
17171 M (CONTROL_PING, mp);
17174 /* Wait for a reply... */
17180 api_feature_enable_disable (vat_main_t * vam)
17182 unformat_input_t *i = vam->input;
17183 vl_api_feature_enable_disable_t *mp;
17185 u8 *feature_name = 0;
17186 u32 sw_if_index = ~0;
17190 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17192 if (unformat (i, "arc_name %s", &arc_name))
17194 else if (unformat (i, "feature_name %s", &feature_name))
17197 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17199 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17201 else if (unformat (i, "disable"))
17209 errmsg ("missing arc name");
17212 if (vec_len (arc_name) > 63)
17214 errmsg ("arc name too long");
17217 if (feature_name == 0)
17219 errmsg ("missing feature name");
17222 if (vec_len (feature_name) > 63)
17224 errmsg ("feature name too long");
17227 if (sw_if_index == ~0)
17229 errmsg ("missing interface name or sw_if_index");
17233 /* Construct the API message */
17234 M (FEATURE_ENABLE_DISABLE, mp);
17235 mp->sw_if_index = ntohl (sw_if_index);
17236 mp->enable = enable;
17237 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
17238 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
17239 vec_free (arc_name);
17240 vec_free (feature_name);
17248 api_sw_interface_tag_add_del (vat_main_t * vam)
17250 unformat_input_t *i = vam->input;
17251 vl_api_sw_interface_tag_add_del_t *mp;
17252 u32 sw_if_index = ~0;
17257 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17259 if (unformat (i, "tag %s", &tag))
17261 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17263 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17265 else if (unformat (i, "del"))
17271 if (sw_if_index == ~0)
17273 errmsg ("missing interface name or sw_if_index");
17277 if (enable && (tag == 0))
17279 errmsg ("no tag specified");
17283 /* Construct the API message */
17284 M (SW_INTERFACE_TAG_ADD_DEL, mp);
17285 mp->sw_if_index = ntohl (sw_if_index);
17286 mp->is_add = enable;
17288 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
17296 static void vl_api_l2_xconnect_details_t_handler
17297 (vl_api_l2_xconnect_details_t * mp)
17299 vat_main_t *vam = &vat_main;
17301 print (vam->ofp, "%15d%15d",
17302 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
17305 static void vl_api_l2_xconnect_details_t_handler_json
17306 (vl_api_l2_xconnect_details_t * mp)
17308 vat_main_t *vam = &vat_main;
17309 vat_json_node_t *node = NULL;
17311 if (VAT_JSON_ARRAY != vam->json_tree.type)
17313 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17314 vat_json_init_array (&vam->json_tree);
17316 node = vat_json_array_add (&vam->json_tree);
17318 vat_json_init_object (node);
17319 vat_json_object_add_uint (node, "rx_sw_if_index",
17320 ntohl (mp->rx_sw_if_index));
17321 vat_json_object_add_uint (node, "tx_sw_if_index",
17322 ntohl (mp->tx_sw_if_index));
17326 api_l2_xconnect_dump (vat_main_t * vam)
17328 vl_api_l2_xconnect_dump_t *mp;
17331 if (!vam->json_output)
17333 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
17336 M (L2_XCONNECT_DUMP, mp);
17340 /* Use a control ping for synchronization */
17342 vl_api_control_ping_t *mp;
17343 M (CONTROL_PING, mp);
17351 api_sw_interface_set_mtu (vat_main_t * vam)
17353 unformat_input_t *i = vam->input;
17354 vl_api_sw_interface_set_mtu_t *mp;
17355 u32 sw_if_index = ~0;
17359 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17361 if (unformat (i, "mtu %d", &mtu))
17363 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17365 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17371 if (sw_if_index == ~0)
17373 errmsg ("missing interface name or sw_if_index");
17379 errmsg ("no mtu specified");
17383 /* Construct the API message */
17384 M (SW_INTERFACE_SET_MTU, mp);
17385 mp->sw_if_index = ntohl (sw_if_index);
17386 mp->mtu = ntohs ((u16) mtu);
17395 q_or_quit (vat_main_t * vam)
17397 longjmp (vam->jump_buf, 1);
17398 return 0; /* not so much */
17402 q (vat_main_t * vam)
17404 return q_or_quit (vam);
17408 quit (vat_main_t * vam)
17410 return q_or_quit (vam);
17414 comment (vat_main_t * vam)
17420 cmd_cmp (void *a1, void *a2)
17425 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
17429 help (vat_main_t * vam)
17434 unformat_input_t *i = vam->input;
17437 if (unformat (i, "%s", &name))
17441 vec_add1 (name, 0);
17443 hs = hash_get_mem (vam->help_by_name, name);
17445 print (vam->ofp, "usage: %s %s", name, hs[0]);
17447 print (vam->ofp, "No such msg / command '%s'", name);
17452 print (vam->ofp, "Help is available for the following:");
17455 hash_foreach_pair (p, vam->function_by_name,
17457 vec_add1 (cmds, (u8 *)(p->key));
17461 vec_sort_with_function (cmds, cmd_cmp);
17463 for (j = 0; j < vec_len (cmds); j++)
17464 print (vam->ofp, "%s", cmds[j]);
17471 set (vat_main_t * vam)
17473 u8 *name = 0, *value = 0;
17474 unformat_input_t *i = vam->input;
17476 if (unformat (i, "%s", &name))
17478 /* The input buffer is a vector, not a string. */
17479 value = vec_dup (i->buffer);
17480 vec_delete (value, i->index, 0);
17481 /* Almost certainly has a trailing newline */
17482 if (value[vec_len (value) - 1] == '\n')
17483 value[vec_len (value) - 1] = 0;
17484 /* Make sure it's a proper string, one way or the other */
17485 vec_add1 (value, 0);
17486 (void) clib_macro_set_value (&vam->macro_main,
17487 (char *) name, (char *) value);
17490 errmsg ("usage: set <name> <value>");
17498 unset (vat_main_t * vam)
17502 if (unformat (vam->input, "%s", &name))
17503 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
17504 errmsg ("unset: %s wasn't set", name);
17517 macro_sort_cmp (void *a1, void *a2)
17519 macro_sort_t *s1 = a1;
17520 macro_sort_t *s2 = a2;
17522 return strcmp ((char *) (s1->name), (char *) (s2->name));
17526 dump_macro_table (vat_main_t * vam)
17528 macro_sort_t *sort_me = 0, *sm;
17533 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
17535 vec_add2 (sort_me, sm, 1);
17536 sm->name = (u8 *)(p->key);
17537 sm->value = (u8 *) (p->value[0]);
17541 vec_sort_with_function (sort_me, macro_sort_cmp);
17543 if (vec_len (sort_me))
17544 print (vam->ofp, "%-15s%s", "Name", "Value");
17546 print (vam->ofp, "The macro table is empty...");
17548 for (i = 0; i < vec_len (sort_me); i++)
17549 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
17554 dump_node_table (vat_main_t * vam)
17557 vlib_node_t *node, *next_node;
17559 if (vec_len (vam->graph_nodes) == 0)
17561 print (vam->ofp, "Node table empty, issue get_node_graph...");
17565 for (i = 0; i < vec_len (vam->graph_nodes); i++)
17567 node = vam->graph_nodes[i];
17568 print (vam->ofp, "[%d] %s", i, node->name);
17569 for (j = 0; j < vec_len (node->next_nodes); j++)
17571 if (node->next_nodes[j] != ~0)
17573 next_node = vam->graph_nodes[node->next_nodes[j]];
17574 print (vam->ofp, " [%d] %s", j, next_node->name);
17582 value_sort_cmp (void *a1, void *a2)
17584 name_sort_t *n1 = a1;
17585 name_sort_t *n2 = a2;
17587 if (n1->value < n2->value)
17589 if (n1->value > n2->value)
17596 dump_msg_api_table (vat_main_t * vam)
17598 api_main_t *am = &api_main;
17599 name_sort_t *nses = 0, *ns;
17604 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
17606 vec_add2 (nses, ns, 1);
17607 ns->name = (u8 *)(hp->key);
17608 ns->value = (u32) hp->value[0];
17612 vec_sort_with_function (nses, value_sort_cmp);
17614 for (i = 0; i < vec_len (nses); i++)
17615 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
17621 get_msg_id (vat_main_t * vam)
17626 if (unformat (vam->input, "%s", &name_and_crc))
17628 message_index = vl_api_get_msg_index (name_and_crc);
17629 if (message_index == ~0)
17631 print (vam->ofp, " '%s' not found", name_and_crc);
17634 print (vam->ofp, " '%s' has message index %d",
17635 name_and_crc, message_index);
17638 errmsg ("name_and_crc required...");
17643 search_node_table (vat_main_t * vam)
17645 unformat_input_t *line_input = vam->input;
17648 vlib_node_t *node, *next_node;
17651 if (vam->graph_node_index_by_name == 0)
17653 print (vam->ofp, "Node table empty, issue get_node_graph...");
17657 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
17659 if (unformat (line_input, "%s", &node_to_find))
17661 vec_add1 (node_to_find, 0);
17662 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
17665 print (vam->ofp, "%s not found...", node_to_find);
17668 node = vam->graph_nodes[p[0]];
17669 print (vam->ofp, "[%d] %s", p[0], node->name);
17670 for (j = 0; j < vec_len (node->next_nodes); j++)
17672 if (node->next_nodes[j] != ~0)
17674 next_node = vam->graph_nodes[node->next_nodes[j]];
17675 print (vam->ofp, " [%d] %s", j, next_node->name);
17682 clib_warning ("parse error '%U'", format_unformat_error,
17688 vec_free (node_to_find);
17697 script (vat_main_t * vam)
17699 #if (VPP_API_TEST_BUILTIN==0)
17701 char *save_current_file;
17702 unformat_input_t save_input;
17703 jmp_buf save_jump_buf;
17704 u32 save_line_number;
17706 FILE *new_fp, *save_ifp;
17708 if (unformat (vam->input, "%s", &s))
17710 new_fp = fopen ((char *) s, "r");
17713 errmsg ("Couldn't open script file %s", s);
17720 errmsg ("Missing script name");
17724 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
17725 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
17726 save_ifp = vam->ifp;
17727 save_line_number = vam->input_line_number;
17728 save_current_file = (char *) vam->current_file;
17730 vam->input_line_number = 0;
17732 vam->current_file = s;
17735 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
17736 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
17737 vam->ifp = save_ifp;
17738 vam->input_line_number = save_line_number;
17739 vam->current_file = (u8 *) save_current_file;
17744 clib_warning ("use the exec command...");
17750 echo (vat_main_t * vam)
17752 print (vam->ofp, "%v", vam->input->buffer);
17756 /* List of API message constructors, CLI names map to api_xxx */
17757 #define foreach_vpe_api_msg \
17758 _(create_loopback,"[mac <mac-addr>]") \
17759 _(sw_interface_dump,"") \
17760 _(sw_interface_set_flags, \
17761 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
17762 _(sw_interface_add_del_address, \
17763 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
17764 _(sw_interface_set_table, \
17765 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
17766 _(sw_interface_set_mpls_enable, \
17767 "<intfc> | sw_if_index [disable | dis]") \
17768 _(sw_interface_set_vpath, \
17769 "<intfc> | sw_if_index <id> enable | disable") \
17770 _(sw_interface_set_vxlan_bypass, \
17771 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
17772 _(sw_interface_set_l2_xconnect, \
17773 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
17774 "enable | disable") \
17775 _(sw_interface_set_l2_bridge, \
17776 "<intfc> | sw_if_index <id> bd_id <bridge-domain-id>\n" \
17777 "[shg <split-horizon-group>] [bvi]\n" \
17778 "enable | disable") \
17779 _(bridge_domain_add_del, \
17780 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n") \
17781 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
17783 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
17785 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
17787 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
17789 "tapname <name> mac <mac-addr> | random-mac [tag <string>]") \
17791 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
17793 "<vpp-if-name> | sw_if_index <id>") \
17794 _(sw_interface_tap_dump, "") \
17795 _(ip_add_del_route, \
17796 "<addr>/<mask> via <addr> [table-id <n>]\n" \
17797 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
17798 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
17799 "[multipath] [count <n>]") \
17800 _(ip_mroute_add_del, \
17801 "<src> <grp>/<mask> [table-id <n>]\n" \
17802 "[<intfc> | sw_if_index <id>] [local] [del]") \
17803 _(mpls_route_add_del, \
17804 "<label> <eos> via <addr> [table-id <n>]\n" \
17805 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
17806 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
17807 "[multipath] [count <n>]") \
17808 _(mpls_ip_bind_unbind, \
17809 "<label> <addr/len>") \
17810 _(mpls_tunnel_add_del, \
17811 " via <addr> [table-id <n>]\n" \
17812 "sw_if_index <id>] [l2] [del]") \
17813 _(proxy_arp_add_del, \
17814 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
17815 _(proxy_arp_intfc_enable_disable, \
17816 "<intfc> | sw_if_index <id> enable | disable") \
17817 _(sw_interface_set_unnumbered, \
17818 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
17819 _(ip_neighbor_add_del, \
17820 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
17821 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
17822 _(reset_vrf, "vrf <id> [ipv6]") \
17823 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
17824 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
17825 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
17826 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
17827 "[outer_vlan_id_any][inner_vlan_id_any]") \
17828 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
17829 _(reset_fib, "vrf <n> [ipv6]") \
17830 _(dhcp_proxy_config, \
17831 "svr <v46-address> src <v46-address>\n" \
17832 "insert-cid <n> [del]") \
17833 _(dhcp_proxy_config_2, \
17834 "svr <v46-address> src <v46-address>\n" \
17835 "rx_vrf_id <nn> server_vrf_id <nn> insert-cid <n> [del]") \
17836 _(dhcp_proxy_set_vss, \
17837 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
17838 _(dhcp_client_config, \
17839 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
17840 _(set_ip_flow_hash, \
17841 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
17842 _(sw_interface_ip6_enable_disable, \
17843 "<intfc> | sw_if_index <id> enable | disable") \
17844 _(sw_interface_ip6_set_link_local_address, \
17845 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
17846 _(sw_interface_ip6nd_ra_prefix, \
17847 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
17848 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
17849 "[nolink] [isno]") \
17850 _(sw_interface_ip6nd_ra_config, \
17851 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
17852 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
17853 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
17854 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
17855 _(l2_patch_add_del, \
17856 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
17857 "enable | disable") \
17858 _(sr_tunnel_add_del, \
17859 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
17860 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
17861 "[policy <policy_name>]") \
17862 _(sr_policy_add_del, \
17863 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
17864 _(sr_multicast_map_add_del, \
17865 "address [ip6 multicast address] sr-policy [policy name] [del]") \
17866 _(classify_add_del_table, \
17867 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
17868 " [del] [del-chain] mask <mask-value>\n" \
17869 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
17870 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
17871 _(classify_add_del_session, \
17872 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
17873 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
17874 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
17875 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
17876 _(classify_set_interface_ip_table, \
17877 "<intfc> | sw_if_index <nn> table <nn>") \
17878 _(classify_set_interface_l2_tables, \
17879 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
17880 " [other-table <nn>]") \
17881 _(get_node_index, "node <node-name") \
17882 _(add_node_next, "node <node-name> next <next-node-name>") \
17883 _(l2tpv3_create_tunnel, \
17884 "client_address <ip6-addr> our_address <ip6-addr>\n" \
17885 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
17886 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
17887 _(l2tpv3_set_tunnel_cookies, \
17888 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
17889 "[new_remote_cookie <nn>]\n") \
17890 _(l2tpv3_interface_enable_disable, \
17891 "<intfc> | sw_if_index <nn> enable | disable") \
17892 _(l2tpv3_set_lookup_key, \
17893 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
17894 _(sw_if_l2tpv3_tunnel_dump, "") \
17895 _(vxlan_add_del_tunnel, \
17896 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
17897 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
17898 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
17899 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
17900 _(gre_add_del_tunnel, \
17901 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [teb] [del]\n") \
17902 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
17903 _(l2_fib_clear_table, "") \
17904 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
17905 _(l2_interface_vlan_tag_rewrite, \
17906 "<intfc> | sw_if_index <nn> \n" \
17907 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
17908 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
17909 _(create_vhost_user_if, \
17910 "socket <filename> [server] [renumber <dev_instance>] " \
17911 "[mac <mac_address>]") \
17912 _(modify_vhost_user_if, \
17913 "<intfc> | sw_if_index <nn> socket <filename>\n" \
17914 "[server] [renumber <dev_instance>]") \
17915 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
17916 _(sw_interface_vhost_user_dump, "") \
17917 _(show_version, "") \
17918 _(vxlan_gpe_add_del_tunnel, \
17919 "local <addr> remote <addr> vni <nn>\n" \
17920 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
17921 "[next-ethernet] [next-nsh]\n") \
17922 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
17923 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
17924 _(interface_name_renumber, \
17925 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
17926 _(input_acl_set_interface, \
17927 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
17928 " [l2-table <nn>] [del]") \
17929 _(want_ip4_arp_events, "address <ip4-address> [del]") \
17930 _(want_ip6_nd_events, "address <ip6-address> [del]") \
17931 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
17932 _(ip_dump, "ipv4 | ipv6") \
17933 _(ipsec_spd_add_del, "spd_id <n> [del]") \
17934 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
17936 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
17937 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
17938 " integ_alg <alg> integ_key <hex>") \
17939 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
17940 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
17941 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
17942 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
17943 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
17944 _(ikev2_profile_add_del, "name <profile_name> [del]") \
17945 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
17946 "(auth_data 0x<data> | auth_data <data>)") \
17947 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
17948 "(id_data 0x<data> | id_data <data>) (local|remote)") \
17949 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
17950 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
17951 "(local|remote)") \
17952 _(ikev2_set_local_key, "file <absolute_file_path>") \
17953 _(delete_loopback,"sw_if_index <nn>") \
17954 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
17955 _(map_add_domain, \
17956 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
17957 "ip6-src <ip6addr> " \
17958 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
17959 _(map_del_domain, "index <n>") \
17960 _(map_add_del_rule, \
17961 "index <n> psid <n> dst <ip6addr> [del]") \
17962 _(map_domain_dump, "") \
17963 _(map_rule_dump, "index <map-domain>") \
17964 _(want_interface_events, "enable|disable") \
17965 _(want_stats,"enable|disable") \
17966 _(get_first_msg_id, "client <name>") \
17967 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
17968 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
17969 "fib-id <nn> [ip4][ip6][default]") \
17970 _(get_node_graph, " ") \
17971 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
17972 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
17973 _(ioam_disable, "") \
17974 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
17975 " sw_if_index <sw_if_index> p <priority> " \
17976 "w <weight>] [del]") \
17977 _(lisp_add_del_locator, "locator-set <locator_name> " \
17978 "iface <intf> | sw_if_index <sw_if_index> " \
17979 "p <priority> w <weight> [del]") \
17980 _(lisp_add_del_local_eid,"vni <vni> eid " \
17981 "<ipv4|ipv6>/<prefix> | <L2 address> " \
17982 "locator-set <locator_name> [del]" \
17983 "[key-id sha1|sha256 secret-key <secret-key>]") \
17984 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
17985 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
17986 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
17987 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
17988 _(lisp_gpe_enable_disable, "enable|disable") \
17989 _(lisp_enable_disable, "enable|disable") \
17990 _(lisp_map_register_enable_disable, "enable|disable") \
17991 _(lisp_rloc_probe_enable_disable, "enable|disable") \
17992 _(lisp_gpe_add_del_iface, "up|down") \
17993 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
17995 "rloc <locator> p <prio> " \
17996 "w <weight> [rloc <loc> ... ] " \
17997 "action <action> [del-all]") \
17998 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
18000 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
18001 _(lisp_map_request_mode, "src-dst|dst-only") \
18002 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
18003 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
18004 _(lisp_locator_set_dump, "[local | remote]") \
18005 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
18006 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
18007 "[local] | [remote]") \
18008 _(lisp_eid_table_vni_dump, "") \
18009 _(lisp_eid_table_map_dump, "l2|l3") \
18010 _(lisp_map_resolver_dump, "") \
18011 _(lisp_map_server_dump, "") \
18012 _(lisp_adjacencies_get, "vni <vni>") \
18013 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
18014 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
18015 _(show_lisp_rloc_probe_state, "") \
18016 _(show_lisp_map_register_state, "") \
18017 _(show_lisp_status, "") \
18018 _(lisp_get_map_request_itr_rlocs, "") \
18019 _(show_lisp_pitr, "") \
18020 _(show_lisp_map_request_mode, "") \
18021 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
18022 _(af_packet_delete, "name <host interface name>") \
18023 _(policer_add_del, "name <policer name> <params> [del]") \
18024 _(policer_dump, "[name <policer name>]") \
18025 _(policer_classify_set_interface, \
18026 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
18027 " [l2-table <nn>] [del]") \
18028 _(policer_classify_dump, "type [ip4|ip6|l2]") \
18029 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
18030 "[master|slave]") \
18031 _(netmap_delete, "name <interface name>") \
18032 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
18033 _(mpls_fib_dump, "") \
18034 _(classify_table_ids, "") \
18035 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
18036 _(classify_table_info, "table_id <nn>") \
18037 _(classify_session_dump, "table_id <nn>") \
18038 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
18039 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
18040 "[template_interval <nn>] [udp_checksum]") \
18041 _(ipfix_exporter_dump, "") \
18042 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
18043 _(ipfix_classify_stream_dump, "") \
18044 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
18045 _(ipfix_classify_table_dump, "") \
18046 _(sw_interface_span_enable_disable, "[src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
18047 _(sw_interface_span_dump, "") \
18048 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
18049 _(pg_create_interface, "if_id <nn>") \
18050 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
18051 _(pg_enable_disable, "[stream <id>] disable") \
18052 _(ip_source_and_port_range_check_add_del, \
18053 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
18054 _(ip_source_and_port_range_check_interface_add_del, \
18055 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
18056 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
18057 _(ipsec_gre_add_del_tunnel, \
18058 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
18059 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
18060 _(delete_subif,"<intfc> | sw_if_index <nn>") \
18061 _(l2_interface_pbb_tag_rewrite, \
18062 "<intfc> | sw_if_index <nn> \n" \
18063 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
18064 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
18065 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
18066 _(flow_classify_set_interface, \
18067 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
18068 _(flow_classify_dump, "type [ip4|ip6]") \
18069 _(ip_fib_dump, "") \
18070 _(ip6_fib_dump, "") \
18071 _(feature_enable_disable, "arc_name <arc_name> " \
18072 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
18073 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
18075 _(l2_xconnect_dump, "") \
18076 _(sw_interface_set_mtu, "<intfc> | sw_if_index <nn> mtu <nn>") \
18077 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
18078 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]")
18081 #define foreach_vpe_dpdk_api_msg \
18082 _(sw_interface_set_dpdk_hqos_pipe, \
18083 "rx <intfc> | sw_if_index <id> subport <subport-id> pipe <pipe-id>\n" \
18084 "profile <profile-id>\n") \
18085 _(sw_interface_set_dpdk_hqos_subport, \
18086 "rx <intfc> | sw_if_index <id> subport <subport-id> [rate <n>]\n" \
18087 "[bktsize <n>] [tc0 <n>] [tc1 <n>] [tc2 <n>] [tc3 <n>] [period <n>]\n") \
18088 _(sw_interface_set_dpdk_hqos_tctbl, \
18089 "rx <intfc> | sw_if_index <id> entry <n> tc <n> queue <n>\n")
18092 /* List of command functions, CLI names map directly to functions */
18093 #define foreach_cli_function \
18094 _(comment, "usage: comment <ignore-rest-of-line>") \
18095 _(dump_interface_table, "usage: dump_interface_table") \
18096 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
18097 _(dump_ipv4_table, "usage: dump_ipv4_table") \
18098 _(dump_ipv6_table, "usage: dump_ipv6_table") \
18099 _(dump_stats_table, "usage: dump_stats_table") \
18100 _(dump_macro_table, "usage: dump_macro_table ") \
18101 _(dump_node_table, "usage: dump_node_table") \
18102 _(dump_msg_api_table, "usage: dump_msg_api_table") \
18103 _(get_msg_id, "usage: get_msg_id name_and_crc") \
18104 _(echo, "usage: echo <message>") \
18105 _(exec, "usage: exec <vpe-debug-CLI-command>") \
18106 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
18107 _(help, "usage: help") \
18108 _(q, "usage: quit") \
18109 _(quit, "usage: quit") \
18110 _(search_node_table, "usage: search_node_table <name>...") \
18111 _(set, "usage: set <variable-name> <value>") \
18112 _(script, "usage: script <file-name>") \
18113 _(unset, "usage: unset <variable-name>")
18116 static void vl_api_##n##_t_handler_uni \
18117 (vl_api_##n##_t * mp) \
18119 vat_main_t * vam = &vat_main; \
18120 if (vam->json_output) { \
18121 vl_api_##n##_t_handler_json(mp); \
18123 vl_api_##n##_t_handler(mp); \
18126 foreach_vpe_api_reply_msg;
18131 static void vl_api_##n##_t_handler_uni \
18132 (vl_api_##n##_t * mp) \
18134 vat_main_t * vam = &vat_main; \
18135 if (vam->json_output) { \
18136 vl_api_##n##_t_handler_json(mp); \
18138 vl_api_##n##_t_handler(mp); \
18141 foreach_vpe_dpdk_api_reply_msg;
18146 vat_api_hookup (vat_main_t * vam)
18149 vl_msg_api_set_handlers(VL_API_##N, #n, \
18150 vl_api_##n##_t_handler_uni, \
18152 vl_api_##n##_t_endian, \
18153 vl_api_##n##_t_print, \
18154 sizeof(vl_api_##n##_t), 1);
18155 foreach_vpe_api_reply_msg;
18160 vl_msg_api_set_handlers(VL_API_##N, #n, \
18161 vl_api_##n##_t_handler_uni, \
18163 vl_api_##n##_t_endian, \
18164 vl_api_##n##_t_print, \
18165 sizeof(vl_api_##n##_t), 1);
18166 foreach_vpe_dpdk_api_reply_msg;
18170 #if (VPP_API_TEST_BUILTIN==0)
18171 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
18174 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
18176 vam->function_by_name = hash_create_string (0, sizeof (uword));
18178 vam->help_by_name = hash_create_string (0, sizeof (uword));
18180 /* API messages we can send */
18181 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
18182 foreach_vpe_api_msg;
18185 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
18186 foreach_vpe_dpdk_api_msg;
18191 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
18192 foreach_vpe_api_msg;
18195 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
18196 foreach_vpe_dpdk_api_msg;
18200 /* CLI functions */
18201 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
18202 foreach_cli_function;
18206 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
18207 foreach_cli_function;
18212 * fd.io coding-style-patch-verification: ON
18215 * eval: (c-set-style "gnu")