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 _(ikev2_set_responder_reply) \
3847 _(ikev2_set_ike_transforms_reply) \
3848 _(ikev2_set_esp_transforms_reply) \
3849 _(ikev2_set_sa_lifetime_reply) \
3850 _(ikev2_initiate_sa_init_reply) \
3851 _(ikev2_initiate_del_ike_sa_reply) \
3852 _(ikev2_initiate_del_child_sa_reply) \
3853 _(ikev2_initiate_rekey_child_sa_reply) \
3854 _(delete_loopback_reply) \
3855 _(bd_ip_mac_add_del_reply) \
3856 _(map_del_domain_reply) \
3857 _(map_add_del_rule_reply) \
3858 _(want_interface_events_reply) \
3859 _(want_stats_reply) \
3860 _(cop_interface_enable_disable_reply) \
3861 _(cop_whitelist_enable_disable_reply) \
3862 _(sw_interface_clear_stats_reply) \
3863 _(ioam_enable_reply) \
3864 _(ioam_disable_reply) \
3865 _(lisp_add_del_locator_reply) \
3866 _(lisp_add_del_local_eid_reply) \
3867 _(lisp_add_del_remote_mapping_reply) \
3868 _(lisp_add_del_adjacency_reply) \
3869 _(lisp_gpe_add_del_fwd_entry_reply) \
3870 _(lisp_add_del_map_resolver_reply) \
3871 _(lisp_add_del_map_server_reply) \
3872 _(lisp_gpe_enable_disable_reply) \
3873 _(lisp_gpe_add_del_iface_reply) \
3874 _(lisp_enable_disable_reply) \
3875 _(lisp_rloc_probe_enable_disable_reply) \
3876 _(lisp_map_register_enable_disable_reply) \
3877 _(lisp_pitr_set_locator_set_reply) \
3878 _(lisp_map_request_mode_reply) \
3879 _(lisp_add_del_map_request_itr_rlocs_reply) \
3880 _(lisp_eid_table_add_del_map_reply) \
3881 _(vxlan_gpe_add_del_tunnel_reply) \
3882 _(af_packet_delete_reply) \
3883 _(policer_classify_set_interface_reply) \
3884 _(netmap_create_reply) \
3885 _(netmap_delete_reply) \
3886 _(set_ipfix_exporter_reply) \
3887 _(set_ipfix_classify_stream_reply) \
3888 _(ipfix_classify_table_add_del_reply) \
3889 _(flow_classify_set_interface_reply) \
3890 _(sw_interface_span_enable_disable_reply) \
3891 _(pg_capture_reply) \
3892 _(pg_enable_disable_reply) \
3893 _(ip_source_and_port_range_check_add_del_reply) \
3894 _(ip_source_and_port_range_check_interface_add_del_reply)\
3895 _(delete_subif_reply) \
3896 _(l2_interface_pbb_tag_rewrite_reply) \
3898 _(feature_enable_disable_reply) \
3899 _(sw_interface_tag_add_del_reply) \
3900 _(sw_interface_set_mtu_reply)
3903 #define foreach_standard_dpdk_reply_retval_handler \
3904 _(sw_interface_set_dpdk_hqos_pipe_reply) \
3905 _(sw_interface_set_dpdk_hqos_subport_reply) \
3906 _(sw_interface_set_dpdk_hqos_tctbl_reply)
3910 static void vl_api_##n##_t_handler \
3911 (vl_api_##n##_t * mp) \
3913 vat_main_t * vam = &vat_main; \
3914 i32 retval = ntohl(mp->retval); \
3915 if (vam->async_mode) { \
3916 vam->async_errors += (retval < 0); \
3918 vam->retval = retval; \
3919 vam->result_ready = 1; \
3922 foreach_standard_reply_retval_handler;
3926 static void vl_api_##n##_t_handler_json \
3927 (vl_api_##n##_t * mp) \
3929 vat_main_t * vam = &vat_main; \
3930 vat_json_node_t node; \
3931 vat_json_init_object(&node); \
3932 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
3933 vat_json_print(vam->ofp, &node); \
3934 vam->retval = ntohl(mp->retval); \
3935 vam->result_ready = 1; \
3937 foreach_standard_reply_retval_handler;
3942 static void vl_api_##n##_t_handler \
3943 (vl_api_##n##_t * mp) \
3945 vat_main_t * vam = &vat_main; \
3946 i32 retval = ntohl(mp->retval); \
3947 if (vam->async_mode) { \
3948 vam->async_errors += (retval < 0); \
3950 vam->retval = retval; \
3951 vam->result_ready = 1; \
3954 foreach_standard_dpdk_reply_retval_handler;
3958 static void vl_api_##n##_t_handler_json \
3959 (vl_api_##n##_t * mp) \
3961 vat_main_t * vam = &vat_main; \
3962 vat_json_node_t node; \
3963 vat_json_init_object(&node); \
3964 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
3965 vat_json_print(vam->ofp, &node); \
3966 vam->retval = ntohl(mp->retval); \
3967 vam->result_ready = 1; \
3969 foreach_standard_dpdk_reply_retval_handler;
3974 * Table of message reply handlers, must include boilerplate handlers
3978 #define foreach_vpe_api_reply_msg \
3979 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
3980 _(SW_INTERFACE_DETAILS, sw_interface_details) \
3981 _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
3982 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
3983 _(CONTROL_PING_REPLY, control_ping_reply) \
3984 _(CLI_REPLY, cli_reply) \
3985 _(CLI_INBAND_REPLY, cli_inband_reply) \
3986 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
3987 sw_interface_add_del_address_reply) \
3988 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
3989 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
3990 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
3991 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
3992 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
3993 sw_interface_set_l2_xconnect_reply) \
3994 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
3995 sw_interface_set_l2_bridge_reply) \
3996 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
3997 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
3998 _(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
3999 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
4000 _(L2_FLAGS_REPLY, l2_flags_reply) \
4001 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
4002 _(TAP_CONNECT_REPLY, tap_connect_reply) \
4003 _(TAP_MODIFY_REPLY, tap_modify_reply) \
4004 _(TAP_DELETE_REPLY, tap_delete_reply) \
4005 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
4006 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
4007 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
4008 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
4009 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
4010 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
4011 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
4012 proxy_arp_intfc_enable_disable_reply) \
4013 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
4014 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
4015 sw_interface_set_unnumbered_reply) \
4016 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
4017 _(RESET_VRF_REPLY, reset_vrf_reply) \
4018 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
4019 _(CREATE_SUBIF_REPLY, create_subif_reply) \
4020 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
4021 _(RESET_FIB_REPLY, reset_fib_reply) \
4022 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
4023 _(DHCP_PROXY_CONFIG_2_REPLY, dhcp_proxy_config_2_reply) \
4024 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
4025 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
4026 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
4027 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
4028 sw_interface_ip6_enable_disable_reply) \
4029 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
4030 sw_interface_ip6_set_link_local_address_reply) \
4031 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
4032 sw_interface_ip6nd_ra_prefix_reply) \
4033 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
4034 sw_interface_ip6nd_ra_config_reply) \
4035 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
4036 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
4037 _(SR_TUNNEL_ADD_DEL_REPLY, sr_tunnel_add_del_reply) \
4038 _(SR_POLICY_ADD_DEL_REPLY, sr_policy_add_del_reply) \
4039 _(SR_MULTICAST_MAP_ADD_DEL_REPLY, sr_multicast_map_add_del_reply) \
4040 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
4041 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
4042 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
4043 classify_set_interface_ip_table_reply) \
4044 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
4045 classify_set_interface_l2_tables_reply) \
4046 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
4047 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
4048 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
4049 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
4050 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
4051 l2tpv3_interface_enable_disable_reply) \
4052 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
4053 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
4054 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
4055 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
4056 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
4057 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
4058 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
4059 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
4060 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
4061 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
4062 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
4063 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
4064 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
4065 _(SHOW_VERSION_REPLY, show_version_reply) \
4066 _(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
4067 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
4068 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
4069 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
4070 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
4071 _(IP4_ARP_EVENT, ip4_arp_event) \
4072 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
4073 _(IP6_ND_EVENT, ip6_nd_event) \
4074 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
4075 _(IP_ADDRESS_DETAILS, ip_address_details) \
4076 _(IP_DETAILS, ip_details) \
4077 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
4078 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
4079 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
4080 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
4081 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
4082 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
4083 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
4084 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
4085 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
4086 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
4087 _(IKEV2_SET_RESPONDER_REPLY, ikev2_set_responder_reply) \
4088 _(IKEV2_SET_IKE_TRANSFORMS_REPLY, ikev2_set_ike_transforms_reply) \
4089 _(IKEV2_SET_ESP_TRANSFORMS_REPLY, ikev2_set_esp_transforms_reply) \
4090 _(IKEV2_SET_SA_LIFETIME_REPLY, ikev2_set_sa_lifetime_reply) \
4091 _(IKEV2_INITIATE_SA_INIT_REPLY, ikev2_initiate_sa_init_reply) \
4092 _(IKEV2_INITIATE_DEL_IKE_SA_REPLY, ikev2_initiate_del_ike_sa_reply) \
4093 _(IKEV2_INITIATE_DEL_CHILD_SA_REPLY, ikev2_initiate_del_child_sa_reply) \
4094 _(IKEV2_INITIATE_REKEY_CHILD_SA_REPLY, ikev2_initiate_rekey_child_sa_reply) \
4095 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
4096 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
4097 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
4098 _(VNET_INTERFACE_COUNTERS, vnet_interface_counters) \
4099 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
4100 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
4101 _(VNET_IP4_NBR_COUNTERS, vnet_ip4_nbr_counters) \
4102 _(VNET_IP6_NBR_COUNTERS, vnet_ip6_nbr_counters) \
4103 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
4104 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
4105 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
4106 _(MAP_DOMAIN_DETAILS, map_domain_details) \
4107 _(MAP_RULE_DETAILS, map_rule_details) \
4108 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
4109 _(WANT_STATS_REPLY, want_stats_reply) \
4110 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
4111 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
4112 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
4113 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
4114 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
4115 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
4116 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
4117 _(LISP_ADD_DEL_LOCATOR_SET_REPLY, lisp_add_del_locator_set_reply) \
4118 _(LISP_ADD_DEL_LOCATOR_REPLY, lisp_add_del_locator_reply) \
4119 _(LISP_ADD_DEL_LOCAL_EID_REPLY, lisp_add_del_local_eid_reply) \
4120 _(LISP_ADD_DEL_REMOTE_MAPPING_REPLY, lisp_add_del_remote_mapping_reply) \
4121 _(LISP_ADD_DEL_ADJACENCY_REPLY, lisp_add_del_adjacency_reply) \
4122 _(LISP_GPE_ADD_DEL_FWD_ENTRY_REPLY, lisp_gpe_add_del_fwd_entry_reply) \
4123 _(LISP_ADD_DEL_MAP_RESOLVER_REPLY, lisp_add_del_map_resolver_reply) \
4124 _(LISP_ADD_DEL_MAP_SERVER_REPLY, lisp_add_del_map_server_reply) \
4125 _(LISP_GPE_ENABLE_DISABLE_REPLY, lisp_gpe_enable_disable_reply) \
4126 _(LISP_ENABLE_DISABLE_REPLY, lisp_enable_disable_reply) \
4127 _(LISP_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
4128 lisp_map_register_enable_disable_reply) \
4129 _(LISP_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
4130 lisp_rloc_probe_enable_disable_reply) \
4131 _(LISP_PITR_SET_LOCATOR_SET_REPLY, lisp_pitr_set_locator_set_reply) \
4132 _(LISP_MAP_REQUEST_MODE_REPLY, lisp_map_request_mode_reply) \
4133 _(LISP_EID_TABLE_ADD_DEL_MAP_REPLY, lisp_eid_table_add_del_map_reply) \
4134 _(LISP_GPE_ADD_DEL_IFACE_REPLY, lisp_gpe_add_del_iface_reply) \
4135 _(LISP_LOCATOR_SET_DETAILS, lisp_locator_set_details) \
4136 _(LISP_LOCATOR_DETAILS, lisp_locator_details) \
4137 _(LISP_EID_TABLE_DETAILS, lisp_eid_table_details) \
4138 _(LISP_EID_TABLE_MAP_DETAILS, lisp_eid_table_map_details) \
4139 _(LISP_EID_TABLE_VNI_DETAILS, lisp_eid_table_vni_details) \
4140 _(LISP_MAP_RESOLVER_DETAILS, lisp_map_resolver_details) \
4141 _(LISP_MAP_SERVER_DETAILS, lisp_map_server_details) \
4142 _(LISP_ADJACENCIES_GET_REPLY, lisp_adjacencies_get_reply) \
4143 _(LISP_GPE_FWD_ENTRIES_GET_REPLY, lisp_gpe_fwd_entries_get_reply) \
4144 _(LISP_GPE_FWD_ENTRY_PATH_DETAILS, \
4145 lisp_gpe_fwd_entry_path_details) \
4146 _(SHOW_LISP_STATUS_REPLY, show_lisp_status_reply) \
4147 _(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
4148 lisp_add_del_map_request_itr_rlocs_reply) \
4149 _(LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
4150 lisp_get_map_request_itr_rlocs_reply) \
4151 _(SHOW_LISP_PITR_REPLY, show_lisp_pitr_reply) \
4152 _(SHOW_LISP_MAP_REQUEST_MODE_REPLY, show_lisp_map_request_mode_reply) \
4153 _(SHOW_LISP_RLOC_PROBE_STATE_REPLY, show_lisp_rloc_probe_state_reply) \
4154 _(SHOW_LISP_MAP_REGISTER_STATE_REPLY, \
4155 show_lisp_map_register_state_reply) \
4156 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
4157 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
4158 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
4159 _(POLICER_DETAILS, policer_details) \
4160 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
4161 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
4162 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
4163 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
4164 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
4165 _(MPLS_FIB_DETAILS, mpls_fib_details) \
4166 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
4167 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
4168 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
4169 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
4170 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
4171 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
4172 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
4173 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
4174 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
4175 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
4176 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
4177 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
4178 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
4179 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
4180 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
4181 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
4182 _(PG_CAPTURE_REPLY, pg_capture_reply) \
4183 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
4184 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
4185 ip_source_and_port_range_check_add_del_reply) \
4186 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
4187 ip_source_and_port_range_check_interface_add_del_reply) \
4188 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
4189 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
4190 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
4191 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
4192 _(PUNT_REPLY, punt_reply) \
4193 _(IP_FIB_DETAILS, ip_fib_details) \
4194 _(IP6_FIB_DETAILS, ip6_fib_details) \
4195 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
4196 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
4197 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
4198 _(SW_INTERFACE_SET_MTU_REPLY, sw_interface_set_mtu_reply) \
4199 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
4200 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply)
4203 #define foreach_vpe_dpdk_api_reply_msg \
4204 _(SW_INTERFACE_SET_DPDK_HQOS_PIPE_REPLY, \
4205 sw_interface_set_dpdk_hqos_pipe_reply) \
4206 _(SW_INTERFACE_SET_DPDK_HQOS_SUBPORT_REPLY, \
4207 sw_interface_set_dpdk_hqos_subport_reply) \
4208 _(SW_INTERFACE_SET_DPDK_HQOS_TCTBL_REPLY, \
4209 sw_interface_set_dpdk_hqos_tctbl_reply)
4219 #define STR_VTR_OP_CASE(op) \
4220 case L2_VTR_ ## op: \
4224 str_vtr_op (u32 vtr_op)
4228 STR_VTR_OP_CASE (DISABLED);
4229 STR_VTR_OP_CASE (PUSH_1);
4230 STR_VTR_OP_CASE (PUSH_2);
4231 STR_VTR_OP_CASE (POP_1);
4232 STR_VTR_OP_CASE (POP_2);
4233 STR_VTR_OP_CASE (TRANSLATE_1_1);
4234 STR_VTR_OP_CASE (TRANSLATE_1_2);
4235 STR_VTR_OP_CASE (TRANSLATE_2_1);
4236 STR_VTR_OP_CASE (TRANSLATE_2_2);
4243 dump_sub_interface_table (vat_main_t * vam)
4245 const sw_interface_subif_t *sub = NULL;
4247 if (vam->json_output)
4250 ("JSON output supported only for VPE API calls and dump_stats_table");
4255 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
4256 "Interface", "sw_if_index",
4257 "sub id", "dot1ad", "tags", "outer id",
4258 "inner id", "exact", "default", "outer any", "inner any");
4260 vec_foreach (sub, vam->sw_if_subif_table)
4263 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
4264 sub->interface_name,
4266 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
4267 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
4268 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
4269 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
4270 if (sub->vtr_op != L2_VTR_DISABLED)
4273 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
4274 "tag1: %d tag2: %d ]",
4275 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
4276 sub->vtr_tag1, sub->vtr_tag2);
4284 name_sort_cmp (void *a1, void *a2)
4286 name_sort_t *n1 = a1;
4287 name_sort_t *n2 = a2;
4289 return strcmp ((char *) n1->name, (char *) n2->name);
4293 dump_interface_table (vat_main_t * vam)
4296 name_sort_t *nses = 0, *ns;
4298 if (vam->json_output)
4301 ("JSON output supported only for VPE API calls and dump_stats_table");
4306 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4308 vec_add2 (nses, ns, 1);
4309 ns->name = (u8 *)(p->key);
4310 ns->value = (u32) p->value[0];
4314 vec_sort_with_function (nses, name_sort_cmp);
4316 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
4317 vec_foreach (ns, nses)
4319 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
4326 dump_ip_table (vat_main_t * vam, int is_ipv6)
4328 const ip_details_t *det = NULL;
4329 const ip_address_details_t *address = NULL;
4332 print (vam->ofp, "%-12s", "sw_if_index");
4334 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
4341 print (vam->ofp, "%-12d", i);
4342 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
4347 vec_foreach (address, det->addr)
4351 is_ipv6 ? format_ip6_address : format_ip4_address,
4352 address->ip, address->prefix_length);
4360 dump_ipv4_table (vat_main_t * vam)
4362 if (vam->json_output)
4365 ("JSON output supported only for VPE API calls and dump_stats_table");
4369 return dump_ip_table (vam, 0);
4373 dump_ipv6_table (vat_main_t * vam)
4375 if (vam->json_output)
4378 ("JSON output supported only for VPE API calls and dump_stats_table");
4382 return dump_ip_table (vam, 1);
4386 counter_type_to_str (u8 counter_type, u8 is_combined)
4390 switch (counter_type)
4392 case VNET_INTERFACE_COUNTER_DROP:
4394 case VNET_INTERFACE_COUNTER_PUNT:
4396 case VNET_INTERFACE_COUNTER_IP4:
4398 case VNET_INTERFACE_COUNTER_IP6:
4400 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
4402 case VNET_INTERFACE_COUNTER_RX_MISS:
4404 case VNET_INTERFACE_COUNTER_RX_ERROR:
4406 case VNET_INTERFACE_COUNTER_TX_ERROR:
4409 return "INVALID-COUNTER-TYPE";
4414 switch (counter_type)
4416 case VNET_INTERFACE_COUNTER_RX:
4418 case VNET_INTERFACE_COUNTER_TX:
4421 return "INVALID-COUNTER-TYPE";
4427 dump_stats_table (vat_main_t * vam)
4429 vat_json_node_t node;
4430 vat_json_node_t *msg_array;
4431 vat_json_node_t *msg;
4432 vat_json_node_t *counter_array;
4433 vat_json_node_t *counter;
4434 interface_counter_t c;
4436 ip4_fib_counter_t *c4;
4437 ip6_fib_counter_t *c6;
4438 ip4_nbr_counter_t *n4;
4439 ip6_nbr_counter_t *n6;
4442 if (!vam->json_output)
4444 clib_warning ("dump_stats_table supported only in JSON format");
4448 vat_json_init_object (&node);
4450 /* interface counters */
4451 msg_array = vat_json_object_add (&node, "interface_counters");
4452 vat_json_init_array (msg_array);
4453 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
4455 msg = vat_json_array_add (msg_array);
4456 vat_json_init_object (msg);
4457 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4458 (u8 *) counter_type_to_str (i, 0));
4459 vat_json_object_add_int (msg, "is_combined", 0);
4460 counter_array = vat_json_object_add (msg, "data");
4461 vat_json_init_array (counter_array);
4462 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
4464 packets = vam->simple_interface_counters[i][j];
4465 vat_json_array_add_uint (counter_array, packets);
4468 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
4470 msg = vat_json_array_add (msg_array);
4471 vat_json_init_object (msg);
4472 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4473 (u8 *) counter_type_to_str (i, 1));
4474 vat_json_object_add_int (msg, "is_combined", 1);
4475 counter_array = vat_json_object_add (msg, "data");
4476 vat_json_init_array (counter_array);
4477 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
4479 c = vam->combined_interface_counters[i][j];
4480 counter = vat_json_array_add (counter_array);
4481 vat_json_init_object (counter);
4482 vat_json_object_add_uint (counter, "packets", c.packets);
4483 vat_json_object_add_uint (counter, "bytes", c.bytes);
4487 /* ip4 fib counters */
4488 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
4489 vat_json_init_array (msg_array);
4490 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
4492 msg = vat_json_array_add (msg_array);
4493 vat_json_init_object (msg);
4494 vat_json_object_add_uint (msg, "vrf_id",
4495 vam->ip4_fib_counters_vrf_id_by_index[i]);
4496 counter_array = vat_json_object_add (msg, "c");
4497 vat_json_init_array (counter_array);
4498 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
4500 counter = vat_json_array_add (counter_array);
4501 vat_json_init_object (counter);
4502 c4 = &vam->ip4_fib_counters[i][j];
4503 vat_json_object_add_ip4 (counter, "address", c4->address);
4504 vat_json_object_add_uint (counter, "address_length",
4505 c4->address_length);
4506 vat_json_object_add_uint (counter, "packets", c4->packets);
4507 vat_json_object_add_uint (counter, "bytes", c4->bytes);
4511 /* ip6 fib counters */
4512 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
4513 vat_json_init_array (msg_array);
4514 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
4516 msg = vat_json_array_add (msg_array);
4517 vat_json_init_object (msg);
4518 vat_json_object_add_uint (msg, "vrf_id",
4519 vam->ip6_fib_counters_vrf_id_by_index[i]);
4520 counter_array = vat_json_object_add (msg, "c");
4521 vat_json_init_array (counter_array);
4522 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
4524 counter = vat_json_array_add (counter_array);
4525 vat_json_init_object (counter);
4526 c6 = &vam->ip6_fib_counters[i][j];
4527 vat_json_object_add_ip6 (counter, "address", c6->address);
4528 vat_json_object_add_uint (counter, "address_length",
4529 c6->address_length);
4530 vat_json_object_add_uint (counter, "packets", c6->packets);
4531 vat_json_object_add_uint (counter, "bytes", c6->bytes);
4535 /* ip4 nbr counters */
4536 msg_array = vat_json_object_add (&node, "ip4_nbr_counters");
4537 vat_json_init_array (msg_array);
4538 for (i = 0; i < vec_len (vam->ip4_nbr_counters); i++)
4540 msg = vat_json_array_add (msg_array);
4541 vat_json_init_object (msg);
4542 vat_json_object_add_uint (msg, "sw_if_index", i);
4543 counter_array = vat_json_object_add (msg, "c");
4544 vat_json_init_array (counter_array);
4545 for (j = 0; j < vec_len (vam->ip4_nbr_counters[i]); j++)
4547 counter = vat_json_array_add (counter_array);
4548 vat_json_init_object (counter);
4549 n4 = &vam->ip4_nbr_counters[i][j];
4550 vat_json_object_add_ip4 (counter, "address", n4->address);
4551 vat_json_object_add_uint (counter, "link-type", n4->linkt);
4552 vat_json_object_add_uint (counter, "packets", n4->packets);
4553 vat_json_object_add_uint (counter, "bytes", n4->bytes);
4557 /* ip6 nbr counters */
4558 msg_array = vat_json_object_add (&node, "ip6_nbr_counters");
4559 vat_json_init_array (msg_array);
4560 for (i = 0; i < vec_len (vam->ip6_nbr_counters); i++)
4562 msg = vat_json_array_add (msg_array);
4563 vat_json_init_object (msg);
4564 vat_json_object_add_uint (msg, "sw_if_index", i);
4565 counter_array = vat_json_object_add (msg, "c");
4566 vat_json_init_array (counter_array);
4567 for (j = 0; j < vec_len (vam->ip6_nbr_counters[i]); j++)
4569 counter = vat_json_array_add (counter_array);
4570 vat_json_init_object (counter);
4571 n6 = &vam->ip6_nbr_counters[i][j];
4572 vat_json_object_add_ip6 (counter, "address", n6->address);
4573 vat_json_object_add_uint (counter, "packets", n6->packets);
4574 vat_json_object_add_uint (counter, "bytes", n6->bytes);
4578 vat_json_print (vam->ofp, &node);
4579 vat_json_free (&node);
4585 exec (vat_main_t * vam)
4587 api_main_t *am = &api_main;
4588 vl_api_cli_request_t *mp;
4592 unformat_input_t *i = vam->input;
4594 if (vec_len (i->buffer) == 0)
4597 if (vam->exec_mode == 0 && unformat (i, "mode"))
4602 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4609 M (CLI_REQUEST, mp);
4612 * Copy cmd into shared memory.
4613 * In order for the CLI command to work, it
4614 * must be a vector ending in \n, not a C-string ending
4617 pthread_mutex_lock (&am->vlib_rp->mutex);
4618 oldheap = svm_push_data_heap (am->vlib_rp);
4620 vec_validate (cmd, vec_len (vam->input->buffer) - 1);
4621 clib_memcpy (cmd, vam->input->buffer, vec_len (vam->input->buffer));
4623 svm_pop_heap (oldheap);
4624 pthread_mutex_unlock (&am->vlib_rp->mutex);
4626 mp->cmd_in_shmem = (u64) cmd;
4628 timeout = vat_time_now (vam) + 10.0;
4630 while (vat_time_now (vam) < timeout)
4632 if (vam->result_ready == 1)
4635 if (vam->shmem_result != NULL)
4636 print (vam->ofp, "%s", vam->shmem_result);
4637 pthread_mutex_lock (&am->vlib_rp->mutex);
4638 oldheap = svm_push_data_heap (am->vlib_rp);
4640 free_me = (u8 *) vam->shmem_result;
4643 svm_pop_heap (oldheap);
4644 pthread_mutex_unlock (&am->vlib_rp->mutex);
4652 * Future replacement of exec() that passes CLI buffers directly in
4653 * the API messages instead of an additional shared memory area.
4656 exec_inband (vat_main_t * vam)
4658 vl_api_cli_inband_t *mp;
4659 unformat_input_t *i = vam->input;
4662 if (vec_len (i->buffer) == 0)
4665 if (vam->exec_mode == 0 && unformat (i, "mode"))
4670 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4677 * In order for the CLI command to work, it
4678 * must be a vector ending in \n, not a C-string ending
4681 u32 len = vec_len (vam->input->buffer);
4682 M2 (CLI_INBAND, mp, len);
4683 clib_memcpy (mp->cmd, vam->input->buffer, len);
4684 mp->length = htonl (len);
4687 W2 (ret, print (vam->ofp, "%s", vam->cmd_reply));
4692 api_create_loopback (vat_main_t * vam)
4694 unformat_input_t *i = vam->input;
4695 vl_api_create_loopback_t *mp;
4700 memset (mac_address, 0, sizeof (mac_address));
4702 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4704 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
4710 /* Construct the API message */
4711 M (CREATE_LOOPBACK, mp);
4713 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
4721 api_delete_loopback (vat_main_t * vam)
4723 unformat_input_t *i = vam->input;
4724 vl_api_delete_loopback_t *mp;
4725 u32 sw_if_index = ~0;
4728 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4730 if (unformat (i, "sw_if_index %d", &sw_if_index))
4736 if (sw_if_index == ~0)
4738 errmsg ("missing sw_if_index");
4742 /* Construct the API message */
4743 M (DELETE_LOOPBACK, mp);
4744 mp->sw_if_index = ntohl (sw_if_index);
4752 api_want_stats (vat_main_t * vam)
4754 unformat_input_t *i = vam->input;
4755 vl_api_want_stats_t *mp;
4759 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4761 if (unformat (i, "enable"))
4763 else if (unformat (i, "disable"))
4771 errmsg ("missing enable|disable");
4776 mp->enable_disable = enable;
4784 api_want_interface_events (vat_main_t * vam)
4786 unformat_input_t *i = vam->input;
4787 vl_api_want_interface_events_t *mp;
4791 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4793 if (unformat (i, "enable"))
4795 else if (unformat (i, "disable"))
4803 errmsg ("missing enable|disable");
4807 M (WANT_INTERFACE_EVENTS, mp);
4808 mp->enable_disable = enable;
4810 vam->interface_event_display = enable;
4818 /* Note: non-static, called once to set up the initial intfc table */
4820 api_sw_interface_dump (vat_main_t * vam)
4822 vl_api_sw_interface_dump_t *mp;
4823 vl_api_control_ping_t *mp_ping;
4825 name_sort_t *nses = 0, *ns;
4826 sw_interface_subif_t *sub = NULL;
4829 /* Toss the old name table */
4831 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4833 vec_add2 (nses, ns, 1);
4834 ns->name = (u8 *)(p->key);
4835 ns->value = (u32) p->value[0];
4839 hash_free (vam->sw_if_index_by_interface_name);
4841 vec_foreach (ns, nses) vec_free (ns->name);
4845 vec_foreach (sub, vam->sw_if_subif_table)
4847 vec_free (sub->interface_name);
4849 vec_free (vam->sw_if_subif_table);
4851 /* recreate the interface name hash table */
4852 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
4854 /* Get list of ethernets */
4855 M (SW_INTERFACE_DUMP, mp);
4856 mp->name_filter_valid = 1;
4857 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
4860 /* and local / loopback interfaces */
4861 M (SW_INTERFACE_DUMP, mp);
4862 mp->name_filter_valid = 1;
4863 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
4866 /* and packet-generator interfaces */
4867 M (SW_INTERFACE_DUMP, mp);
4868 mp->name_filter_valid = 1;
4869 strncpy ((char *) mp->name_filter, "pg", sizeof (mp->name_filter) - 1);
4872 /* and vxlan-gpe tunnel interfaces */
4873 M (SW_INTERFACE_DUMP, mp);
4874 mp->name_filter_valid = 1;
4875 strncpy ((char *) mp->name_filter, "vxlan_gpe",
4876 sizeof (mp->name_filter) - 1);
4879 /* and vxlan tunnel interfaces */
4880 M (SW_INTERFACE_DUMP, mp);
4881 mp->name_filter_valid = 1;
4882 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
4885 /* and host (af_packet) interfaces */
4886 M (SW_INTERFACE_DUMP, mp);
4887 mp->name_filter_valid = 1;
4888 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
4891 /* and l2tpv3 tunnel interfaces */
4892 M (SW_INTERFACE_DUMP, mp);
4893 mp->name_filter_valid = 1;
4894 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
4895 sizeof (mp->name_filter) - 1);
4898 /* and GRE tunnel interfaces */
4899 M (SW_INTERFACE_DUMP, mp);
4900 mp->name_filter_valid = 1;
4901 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
4904 /* and LISP-GPE interfaces */
4905 M (SW_INTERFACE_DUMP, mp);
4906 mp->name_filter_valid = 1;
4907 strncpy ((char *) mp->name_filter, "lisp_gpe",
4908 sizeof (mp->name_filter) - 1);
4911 /* and IPSEC tunnel interfaces */
4912 M (SW_INTERFACE_DUMP, mp);
4913 mp->name_filter_valid = 1;
4914 strncpy ((char *) mp->name_filter, "ipsec", sizeof (mp->name_filter) - 1);
4917 /* Use a control ping for synchronization */
4918 M (CONTROL_PING, mp_ping);
4926 api_sw_interface_set_flags (vat_main_t * vam)
4928 unformat_input_t *i = vam->input;
4929 vl_api_sw_interface_set_flags_t *mp;
4931 u8 sw_if_index_set = 0;
4932 u8 admin_up = 0, link_up = 0;
4935 /* Parse args required to build the message */
4936 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4938 if (unformat (i, "admin-up"))
4940 else if (unformat (i, "admin-down"))
4942 else if (unformat (i, "link-up"))
4944 else if (unformat (i, "link-down"))
4947 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4948 sw_if_index_set = 1;
4949 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4950 sw_if_index_set = 1;
4955 if (sw_if_index_set == 0)
4957 errmsg ("missing interface name or sw_if_index");
4961 /* Construct the API message */
4962 M (SW_INTERFACE_SET_FLAGS, mp);
4963 mp->sw_if_index = ntohl (sw_if_index);
4964 mp->admin_up_down = admin_up;
4965 mp->link_up_down = link_up;
4970 /* Wait for a reply, return the good/bad news... */
4976 api_sw_interface_clear_stats (vat_main_t * vam)
4978 unformat_input_t *i = vam->input;
4979 vl_api_sw_interface_clear_stats_t *mp;
4981 u8 sw_if_index_set = 0;
4984 /* Parse args required to build the message */
4985 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4987 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4988 sw_if_index_set = 1;
4989 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4990 sw_if_index_set = 1;
4995 /* Construct the API message */
4996 M (SW_INTERFACE_CLEAR_STATS, mp);
4998 if (sw_if_index_set == 1)
4999 mp->sw_if_index = ntohl (sw_if_index);
5001 mp->sw_if_index = ~0;
5006 /* Wait for a reply, return the good/bad news... */
5013 api_sw_interface_set_dpdk_hqos_pipe (vat_main_t * vam)
5015 unformat_input_t *i = vam->input;
5016 vl_api_sw_interface_set_dpdk_hqos_pipe_t *mp;
5018 u8 sw_if_index_set = 0;
5027 /* Parse args required to build the message */
5028 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5030 if (unformat (i, "rx %U", api_unformat_sw_if_index, vam, &sw_if_index))
5031 sw_if_index_set = 1;
5032 else if (unformat (i, "sw_if_index %u", &sw_if_index))
5033 sw_if_index_set = 1;
5034 else if (unformat (i, "subport %u", &subport))
5037 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5038 sw_if_index_set = 1;
5039 else if (unformat (i, "pipe %u", &pipe))
5041 else if (unformat (i, "profile %u", &profile))
5047 if (sw_if_index_set == 0)
5049 errmsg ("missing interface name or sw_if_index");
5053 if (subport_set == 0)
5055 errmsg ("missing subport ");
5061 errmsg ("missing pipe");
5065 if (profile_set == 0)
5067 errmsg ("missing profile");
5071 M (SW_INTERFACE_SET_DPDK_HQOS_PIPE, mp);
5073 mp->sw_if_index = ntohl (sw_if_index);
5074 mp->subport = ntohl (subport);
5075 mp->pipe = ntohl (pipe);
5076 mp->profile = ntohl (profile);
5085 api_sw_interface_set_dpdk_hqos_subport (vat_main_t * vam)
5087 unformat_input_t *i = vam->input;
5088 vl_api_sw_interface_set_dpdk_hqos_subport_t *mp;
5090 u8 sw_if_index_set = 0;
5093 u32 tb_rate = 1250000000; /* 10GbE */
5094 u32 tb_size = 1000000;
5095 u32 tc_rate[] = { 1250000000, 1250000000, 1250000000, 1250000000 };
5099 /* Parse args required to build the message */
5100 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5102 if (unformat (i, "rx %U", api_unformat_sw_if_index, vam, &sw_if_index))
5103 sw_if_index_set = 1;
5104 else if (unformat (i, "sw_if_index %u", &sw_if_index))
5105 sw_if_index_set = 1;
5106 else if (unformat (i, "subport %u", &subport))
5109 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5110 sw_if_index_set = 1;
5111 else if (unformat (i, "rate %u", &tb_rate))
5115 for (tc_id = 0; tc_id < (sizeof (tc_rate) / sizeof (tc_rate[0]));
5117 tc_rate[tc_id] = tb_rate;
5119 else if (unformat (i, "bktsize %u", &tb_size))
5121 else if (unformat (i, "tc0 %u", &tc_rate[0]))
5123 else if (unformat (i, "tc1 %u", &tc_rate[1]))
5125 else if (unformat (i, "tc2 %u", &tc_rate[2]))
5127 else if (unformat (i, "tc3 %u", &tc_rate[3]))
5129 else if (unformat (i, "period %u", &tc_period))
5135 if (sw_if_index_set == 0)
5137 errmsg ("missing interface name or sw_if_index");
5141 if (subport_set == 0)
5143 errmsg ("missing subport ");
5147 M (SW_INTERFACE_SET_DPDK_HQOS_SUBPORT, mp);
5149 mp->sw_if_index = ntohl (sw_if_index);
5150 mp->subport = ntohl (subport);
5151 mp->tb_rate = ntohl (tb_rate);
5152 mp->tb_size = ntohl (tb_size);
5153 mp->tc_rate[0] = ntohl (tc_rate[0]);
5154 mp->tc_rate[1] = ntohl (tc_rate[1]);
5155 mp->tc_rate[2] = ntohl (tc_rate[2]);
5156 mp->tc_rate[3] = ntohl (tc_rate[3]);
5157 mp->tc_period = ntohl (tc_period);
5165 api_sw_interface_set_dpdk_hqos_tctbl (vat_main_t * vam)
5167 unformat_input_t *i = vam->input;
5168 vl_api_sw_interface_set_dpdk_hqos_tctbl_t *mp;
5170 u8 sw_if_index_set = 0;
5174 u32 entry, tc, queue;
5177 /* Parse args required to build the message */
5178 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5180 if (unformat (i, "rx %U", api_unformat_sw_if_index, vam, &sw_if_index))
5181 sw_if_index_set = 1;
5182 else if (unformat (i, "sw_if_index %u", &sw_if_index))
5183 sw_if_index_set = 1;
5184 else if (unformat (i, "entry %d", &entry))
5186 else if (unformat (i, "tc %d", &tc))
5188 else if (unformat (i, "queue %d", &queue))
5194 if (sw_if_index_set == 0)
5196 errmsg ("missing interface name or sw_if_index");
5202 errmsg ("missing entry ");
5208 errmsg ("missing traffic class ");
5214 errmsg ("missing queue ");
5218 M (SW_INTERFACE_SET_DPDK_HQOS_TCTBL, mp);
5220 mp->sw_if_index = ntohl (sw_if_index);
5221 mp->entry = ntohl (entry);
5222 mp->tc = ntohl (tc);
5223 mp->queue = ntohl (queue);
5232 api_sw_interface_add_del_address (vat_main_t * vam)
5234 unformat_input_t *i = vam->input;
5235 vl_api_sw_interface_add_del_address_t *mp;
5237 u8 sw_if_index_set = 0;
5238 u8 is_add = 1, del_all = 0;
5239 u32 address_length = 0;
5240 u8 v4_address_set = 0;
5241 u8 v6_address_set = 0;
5242 ip4_address_t v4address;
5243 ip6_address_t v6address;
5246 /* Parse args required to build the message */
5247 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5249 if (unformat (i, "del-all"))
5251 else if (unformat (i, "del"))
5254 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5255 sw_if_index_set = 1;
5256 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5257 sw_if_index_set = 1;
5258 else if (unformat (i, "%U/%d",
5259 unformat_ip4_address, &v4address, &address_length))
5261 else if (unformat (i, "%U/%d",
5262 unformat_ip6_address, &v6address, &address_length))
5268 if (sw_if_index_set == 0)
5270 errmsg ("missing interface name or sw_if_index");
5273 if (v4_address_set && v6_address_set)
5275 errmsg ("both v4 and v6 addresses set");
5278 if (!v4_address_set && !v6_address_set && !del_all)
5280 errmsg ("no addresses set");
5284 /* Construct the API message */
5285 M (SW_INTERFACE_ADD_DEL_ADDRESS, mp);
5287 mp->sw_if_index = ntohl (sw_if_index);
5288 mp->is_add = is_add;
5289 mp->del_all = del_all;
5293 clib_memcpy (mp->address, &v6address, sizeof (v6address));
5297 clib_memcpy (mp->address, &v4address, sizeof (v4address));
5299 mp->address_length = address_length;
5304 /* Wait for a reply, return good/bad news */
5310 api_sw_interface_set_mpls_enable (vat_main_t * vam)
5312 unformat_input_t *i = vam->input;
5313 vl_api_sw_interface_set_mpls_enable_t *mp;
5315 u8 sw_if_index_set = 0;
5319 /* Parse args required to build the message */
5320 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5322 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5323 sw_if_index_set = 1;
5324 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5325 sw_if_index_set = 1;
5326 else if (unformat (i, "disable"))
5328 else if (unformat (i, "dis"))
5334 if (sw_if_index_set == 0)
5336 errmsg ("missing interface name or sw_if_index");
5340 /* Construct the API message */
5341 M (SW_INTERFACE_SET_MPLS_ENABLE, mp);
5343 mp->sw_if_index = ntohl (sw_if_index);
5344 mp->enable = enable;
5349 /* Wait for a reply... */
5355 api_sw_interface_set_table (vat_main_t * vam)
5357 unformat_input_t *i = vam->input;
5358 vl_api_sw_interface_set_table_t *mp;
5359 u32 sw_if_index, vrf_id = 0;
5360 u8 sw_if_index_set = 0;
5364 /* Parse args required to build the message */
5365 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5367 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5368 sw_if_index_set = 1;
5369 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5370 sw_if_index_set = 1;
5371 else if (unformat (i, "vrf %d", &vrf_id))
5373 else if (unformat (i, "ipv6"))
5379 if (sw_if_index_set == 0)
5381 errmsg ("missing interface name or sw_if_index");
5385 /* Construct the API message */
5386 M (SW_INTERFACE_SET_TABLE, mp);
5388 mp->sw_if_index = ntohl (sw_if_index);
5389 mp->is_ipv6 = is_ipv6;
5390 mp->vrf_id = ntohl (vrf_id);
5395 /* Wait for a reply... */
5400 static void vl_api_sw_interface_get_table_reply_t_handler
5401 (vl_api_sw_interface_get_table_reply_t * mp)
5403 vat_main_t *vam = &vat_main;
5405 print (vam->ofp, "%d", ntohl (mp->vrf_id));
5407 vam->retval = ntohl (mp->retval);
5408 vam->result_ready = 1;
5412 static void vl_api_sw_interface_get_table_reply_t_handler_json
5413 (vl_api_sw_interface_get_table_reply_t * mp)
5415 vat_main_t *vam = &vat_main;
5416 vat_json_node_t node;
5418 vat_json_init_object (&node);
5419 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
5420 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
5422 vat_json_print (vam->ofp, &node);
5423 vat_json_free (&node);
5425 vam->retval = ntohl (mp->retval);
5426 vam->result_ready = 1;
5430 api_sw_interface_get_table (vat_main_t * vam)
5432 unformat_input_t *i = vam->input;
5433 vl_api_sw_interface_get_table_t *mp;
5435 u8 sw_if_index_set = 0;
5439 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5441 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5442 sw_if_index_set = 1;
5443 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5444 sw_if_index_set = 1;
5445 else if (unformat (i, "ipv6"))
5451 if (sw_if_index_set == 0)
5453 errmsg ("missing interface name or sw_if_index");
5457 M (SW_INTERFACE_GET_TABLE, mp);
5458 mp->sw_if_index = htonl (sw_if_index);
5459 mp->is_ipv6 = is_ipv6;
5467 api_sw_interface_set_vpath (vat_main_t * vam)
5469 unformat_input_t *i = vam->input;
5470 vl_api_sw_interface_set_vpath_t *mp;
5471 u32 sw_if_index = 0;
5472 u8 sw_if_index_set = 0;
5476 /* Parse args required to build the message */
5477 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5479 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5480 sw_if_index_set = 1;
5481 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5482 sw_if_index_set = 1;
5483 else if (unformat (i, "enable"))
5485 else if (unformat (i, "disable"))
5491 if (sw_if_index_set == 0)
5493 errmsg ("missing interface name or sw_if_index");
5497 /* Construct the API message */
5498 M (SW_INTERFACE_SET_VPATH, mp);
5500 mp->sw_if_index = ntohl (sw_if_index);
5501 mp->enable = is_enable;
5506 /* Wait for a reply... */
5512 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
5514 unformat_input_t *i = vam->input;
5515 vl_api_sw_interface_set_vxlan_bypass_t *mp;
5516 u32 sw_if_index = 0;
5517 u8 sw_if_index_set = 0;
5522 /* Parse args required to build the message */
5523 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5525 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5526 sw_if_index_set = 1;
5527 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5528 sw_if_index_set = 1;
5529 else if (unformat (i, "enable"))
5531 else if (unformat (i, "disable"))
5533 else if (unformat (i, "ip4"))
5535 else if (unformat (i, "ip6"))
5541 if (sw_if_index_set == 0)
5543 errmsg ("missing interface name or sw_if_index");
5547 /* Construct the API message */
5548 M (SW_INTERFACE_SET_VXLAN_BYPASS, mp);
5550 mp->sw_if_index = ntohl (sw_if_index);
5551 mp->enable = is_enable;
5552 mp->is_ipv6 = is_ipv6;
5557 /* Wait for a reply... */
5563 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
5565 unformat_input_t *i = vam->input;
5566 vl_api_sw_interface_set_l2_xconnect_t *mp;
5568 u8 rx_sw_if_index_set = 0;
5570 u8 tx_sw_if_index_set = 0;
5574 /* Parse args required to build the message */
5575 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5577 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
5578 rx_sw_if_index_set = 1;
5579 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5580 tx_sw_if_index_set = 1;
5581 else if (unformat (i, "rx"))
5583 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5585 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
5587 rx_sw_if_index_set = 1;
5592 else if (unformat (i, "tx"))
5594 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5596 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
5598 tx_sw_if_index_set = 1;
5603 else if (unformat (i, "enable"))
5605 else if (unformat (i, "disable"))
5611 if (rx_sw_if_index_set == 0)
5613 errmsg ("missing rx interface name or rx_sw_if_index");
5617 if (enable && (tx_sw_if_index_set == 0))
5619 errmsg ("missing tx interface name or tx_sw_if_index");
5623 M (SW_INTERFACE_SET_L2_XCONNECT, mp);
5625 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5626 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
5627 mp->enable = enable;
5635 api_sw_interface_set_l2_bridge (vat_main_t * vam)
5637 unformat_input_t *i = vam->input;
5638 vl_api_sw_interface_set_l2_bridge_t *mp;
5640 u8 rx_sw_if_index_set = 0;
5648 /* Parse args required to build the message */
5649 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5651 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
5652 rx_sw_if_index_set = 1;
5653 else if (unformat (i, "bd_id %d", &bd_id))
5657 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
5658 rx_sw_if_index_set = 1;
5659 else if (unformat (i, "shg %d", &shg))
5661 else if (unformat (i, "bvi"))
5663 else if (unformat (i, "enable"))
5665 else if (unformat (i, "disable"))
5671 if (rx_sw_if_index_set == 0)
5673 errmsg ("missing rx interface name or sw_if_index");
5677 if (enable && (bd_id_set == 0))
5679 errmsg ("missing bridge domain");
5683 M (SW_INTERFACE_SET_L2_BRIDGE, mp);
5685 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5686 mp->bd_id = ntohl (bd_id);
5689 mp->enable = enable;
5697 api_bridge_domain_dump (vat_main_t * vam)
5699 unformat_input_t *i = vam->input;
5700 vl_api_bridge_domain_dump_t *mp;
5701 vl_api_control_ping_t *mp_ping;
5705 /* Parse args required to build the message */
5706 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5708 if (unformat (i, "bd_id %d", &bd_id))
5714 M (BRIDGE_DOMAIN_DUMP, mp);
5715 mp->bd_id = ntohl (bd_id);
5718 /* Use a control ping for synchronization */
5719 M (CONTROL_PING, mp_ping);
5727 api_bridge_domain_add_del (vat_main_t * vam)
5729 unformat_input_t *i = vam->input;
5730 vl_api_bridge_domain_add_del_t *mp;
5733 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
5737 /* Parse args required to build the message */
5738 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5740 if (unformat (i, "bd_id %d", &bd_id))
5742 else if (unformat (i, "flood %d", &flood))
5744 else if (unformat (i, "uu-flood %d", &uu_flood))
5746 else if (unformat (i, "forward %d", &forward))
5748 else if (unformat (i, "learn %d", &learn))
5750 else if (unformat (i, "arp-term %d", &arp_term))
5752 else if (unformat (i, "mac-age %d", &mac_age))
5754 else if (unformat (i, "del"))
5757 flood = uu_flood = forward = learn = 0;
5765 errmsg ("missing bridge domain");
5771 errmsg ("mac age must be less than 256 ");
5775 M (BRIDGE_DOMAIN_ADD_DEL, mp);
5777 mp->bd_id = ntohl (bd_id);
5779 mp->uu_flood = uu_flood;
5780 mp->forward = forward;
5782 mp->arp_term = arp_term;
5783 mp->is_add = is_add;
5784 mp->mac_age = (u8) mac_age;
5792 api_l2fib_add_del (vat_main_t * vam)
5794 unformat_input_t *i = vam->input;
5795 vl_api_l2fib_add_del_t *mp;
5801 u32 sw_if_index = ~0;
5802 u8 sw_if_index_set = 0;
5811 /* Parse args required to build the message */
5812 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5814 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
5816 else if (unformat (i, "bd_id %d", &bd_id))
5818 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5819 sw_if_index_set = 1;
5820 else if (unformat (i, "sw_if"))
5822 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5825 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5826 sw_if_index_set = 1;
5831 else if (unformat (i, "static"))
5833 else if (unformat (i, "filter"))
5838 else if (unformat (i, "bvi"))
5843 else if (unformat (i, "del"))
5845 else if (unformat (i, "count %d", &count))
5853 errmsg ("missing mac address");
5859 errmsg ("missing bridge domain");
5863 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
5865 errmsg ("missing interface name or sw_if_index");
5871 /* Turn on async mode */
5872 vam->async_mode = 1;
5873 vam->async_errors = 0;
5874 before = vat_time_now (vam);
5877 for (j = 0; j < count; j++)
5879 M (L2FIB_ADD_DEL, mp);
5882 mp->bd_id = ntohl (bd_id);
5883 mp->is_add = is_add;
5887 mp->sw_if_index = ntohl (sw_if_index);
5888 mp->static_mac = static_mac;
5889 mp->filter_mac = filter_mac;
5890 mp->bvi_mac = bvi_mac;
5892 increment_mac_address (&mac);
5899 vl_api_control_ping_t *mp_ping;
5902 /* Shut off async mode */
5903 vam->async_mode = 0;
5905 M (CONTROL_PING, mp_ping);
5908 timeout = vat_time_now (vam) + 1.0;
5909 while (vat_time_now (vam) < timeout)
5910 if (vam->result_ready == 1)
5915 if (vam->retval == -99)
5918 if (vam->async_errors > 0)
5920 errmsg ("%d asynchronous errors", vam->async_errors);
5923 vam->async_errors = 0;
5924 after = vat_time_now (vam);
5926 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
5927 count, after - before, count / (after - before));
5933 /* Wait for a reply... */
5937 /* Return the good/bad news */
5938 return (vam->retval);
5942 api_l2_flags (vat_main_t * vam)
5944 unformat_input_t *i = vam->input;
5945 vl_api_l2_flags_t *mp;
5947 u32 feature_bitmap = 0;
5948 u8 sw_if_index_set = 0;
5951 /* Parse args required to build the message */
5952 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5954 if (unformat (i, "sw_if_index %d", &sw_if_index))
5955 sw_if_index_set = 1;
5956 else if (unformat (i, "sw_if"))
5958 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5961 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5962 sw_if_index_set = 1;
5967 else if (unformat (i, "learn"))
5968 feature_bitmap |= L2INPUT_FEAT_LEARN;
5969 else if (unformat (i, "forward"))
5970 feature_bitmap |= L2INPUT_FEAT_FWD;
5971 else if (unformat (i, "flood"))
5972 feature_bitmap |= L2INPUT_FEAT_FLOOD;
5973 else if (unformat (i, "uu-flood"))
5974 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
5979 if (sw_if_index_set == 0)
5981 errmsg ("missing interface name or sw_if_index");
5987 mp->sw_if_index = ntohl (sw_if_index);
5988 mp->feature_bitmap = ntohl (feature_bitmap);
5996 api_bridge_flags (vat_main_t * vam)
5998 unformat_input_t *i = vam->input;
5999 vl_api_bridge_flags_t *mp;
6006 /* Parse args required to build the message */
6007 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6009 if (unformat (i, "bd_id %d", &bd_id))
6011 else if (unformat (i, "learn"))
6013 else if (unformat (i, "forward"))
6015 else if (unformat (i, "flood"))
6017 else if (unformat (i, "uu-flood"))
6018 flags |= L2_UU_FLOOD;
6019 else if (unformat (i, "arp-term"))
6020 flags |= L2_ARP_TERM;
6021 else if (unformat (i, "off"))
6023 else if (unformat (i, "disable"))
6031 errmsg ("missing bridge domain");
6035 M (BRIDGE_FLAGS, mp);
6037 mp->bd_id = ntohl (bd_id);
6038 mp->feature_bitmap = ntohl (flags);
6039 mp->is_set = is_set;
6047 api_bd_ip_mac_add_del (vat_main_t * vam)
6049 unformat_input_t *i = vam->input;
6050 vl_api_bd_ip_mac_add_del_t *mp;
6057 ip4_address_t v4addr;
6058 ip6_address_t v6addr;
6063 /* Parse args required to build the message */
6064 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6066 if (unformat (i, "bd_id %d", &bd_id))
6070 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
6074 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
6079 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
6083 else if (unformat (i, "del"))
6091 errmsg ("missing bridge domain");
6094 else if (ip_set == 0)
6096 errmsg ("missing IP address");
6099 else if (mac_set == 0)
6101 errmsg ("missing MAC address");
6105 M (BD_IP_MAC_ADD_DEL, mp);
6107 mp->bd_id = ntohl (bd_id);
6108 mp->is_ipv6 = is_ipv6;
6109 mp->is_add = is_add;
6111 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
6113 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
6114 clib_memcpy (mp->mac_address, macaddr, 6);
6121 api_tap_connect (vat_main_t * vam)
6123 unformat_input_t *i = vam->input;
6124 vl_api_tap_connect_t *mp;
6130 ip4_address_t ip4_address;
6132 int ip4_address_set = 0;
6133 ip6_address_t ip6_address;
6135 int ip6_address_set = 0;
6138 memset (mac_address, 0, sizeof (mac_address));
6140 /* Parse args required to build the message */
6141 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6143 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6147 else if (unformat (i, "random-mac"))
6149 else if (unformat (i, "tapname %s", &tap_name))
6151 else if (unformat (i, "tag %s", &tag))
6153 else if (unformat (i, "address %U/%d",
6154 unformat_ip4_address, &ip4_address, &ip4_mask_width))
6155 ip4_address_set = 1;
6156 else if (unformat (i, "address %U/%d",
6157 unformat_ip6_address, &ip6_address, &ip6_mask_width))
6158 ip6_address_set = 1;
6165 errmsg ("missing tap name");
6168 if (vec_len (tap_name) > 63)
6170 errmsg ("tap name too long");
6173 vec_add1 (tap_name, 0);
6175 if (vec_len (tag) > 63)
6177 errmsg ("tag too long");
6181 /* Construct the API message */
6182 M (TAP_CONNECT, mp);
6184 mp->use_random_mac = random_mac;
6185 clib_memcpy (mp->mac_address, mac_address, 6);
6186 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
6188 clib_memcpy (mp->tag, tag, vec_len (tag));
6190 if (ip4_address_set)
6192 mp->ip4_address_set = 1;
6193 clib_memcpy (mp->ip4_address, &ip4_address, sizeof (mp->ip4_address));
6194 mp->ip4_mask_width = ip4_mask_width;
6196 if (ip6_address_set)
6198 mp->ip6_address_set = 1;
6199 clib_memcpy (mp->ip6_address, &ip6_address, sizeof (mp->ip6_address));
6200 mp->ip6_mask_width = ip6_mask_width;
6203 vec_free (tap_name);
6209 /* Wait for a reply... */
6215 api_tap_modify (vat_main_t * vam)
6217 unformat_input_t *i = vam->input;
6218 vl_api_tap_modify_t *mp;
6223 u32 sw_if_index = ~0;
6224 u8 sw_if_index_set = 0;
6227 memset (mac_address, 0, sizeof (mac_address));
6229 /* Parse args required to build the message */
6230 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6232 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6233 sw_if_index_set = 1;
6234 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6235 sw_if_index_set = 1;
6236 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6240 else if (unformat (i, "random-mac"))
6242 else if (unformat (i, "tapname %s", &tap_name))
6248 if (sw_if_index_set == 0)
6250 errmsg ("missing vpp interface name");
6255 errmsg ("missing tap name");
6258 if (vec_len (tap_name) > 63)
6260 errmsg ("tap name too long");
6262 vec_add1 (tap_name, 0);
6264 /* Construct the API message */
6267 mp->use_random_mac = random_mac;
6268 mp->sw_if_index = ntohl (sw_if_index);
6269 clib_memcpy (mp->mac_address, mac_address, 6);
6270 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
6271 vec_free (tap_name);
6276 /* Wait for a reply... */
6282 api_tap_delete (vat_main_t * vam)
6284 unformat_input_t *i = vam->input;
6285 vl_api_tap_delete_t *mp;
6286 u32 sw_if_index = ~0;
6287 u8 sw_if_index_set = 0;
6290 /* Parse args required to build the message */
6291 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6293 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6294 sw_if_index_set = 1;
6295 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6296 sw_if_index_set = 1;
6301 if (sw_if_index_set == 0)
6303 errmsg ("missing vpp interface name");
6307 /* Construct the API message */
6310 mp->sw_if_index = ntohl (sw_if_index);
6315 /* Wait for a reply... */
6321 api_ip_add_del_route (vat_main_t * vam)
6323 unformat_input_t *i = vam->input;
6324 vl_api_ip_add_del_route_t *mp;
6325 u32 sw_if_index = ~0, vrf_id = 0;
6327 u8 is_local = 0, is_drop = 0;
6328 u8 is_unreach = 0, is_prohibit = 0;
6329 u8 create_vrf_if_needed = 0;
6331 u32 next_hop_weight = 1;
6333 u8 is_multipath = 0;
6335 u8 address_length_set = 0;
6336 u32 next_hop_table_id = 0;
6337 u32 resolve_attempts = 0;
6338 u32 dst_address_length = 0;
6339 u8 next_hop_set = 0;
6340 ip4_address_t v4_dst_address, v4_next_hop_address;
6341 ip6_address_t v6_dst_address, v6_next_hop_address;
6345 u32 random_add_del = 0;
6346 u32 *random_vector = 0;
6348 u32 random_seed = 0xdeaddabe;
6349 u32 classify_table_index = ~0;
6351 u8 resolve_host = 0, resolve_attached = 0;
6352 mpls_label_t *next_hop_out_label_stack = NULL;
6353 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6354 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
6356 /* Parse args required to build the message */
6357 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6359 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6361 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6363 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
6368 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
6373 else if (unformat (i, "/%d", &dst_address_length))
6375 address_length_set = 1;
6378 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
6379 &v4_next_hop_address))
6383 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
6384 &v6_next_hop_address))
6388 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
6390 else if (unformat (i, "weight %d", &next_hop_weight))
6392 else if (unformat (i, "drop"))
6396 else if (unformat (i, "null-send-unreach"))
6400 else if (unformat (i, "null-send-prohibit"))
6404 else if (unformat (i, "local"))
6408 else if (unformat (i, "classify %d", &classify_table_index))
6412 else if (unformat (i, "del"))
6414 else if (unformat (i, "add"))
6416 else if (unformat (i, "not-last"))
6418 else if (unformat (i, "resolve-via-host"))
6420 else if (unformat (i, "resolve-via-attached"))
6421 resolve_attached = 1;
6422 else if (unformat (i, "multipath"))
6424 else if (unformat (i, "vrf %d", &vrf_id))
6426 else if (unformat (i, "create-vrf"))
6427 create_vrf_if_needed = 1;
6428 else if (unformat (i, "count %d", &count))
6430 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
6432 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6434 else if (unformat (i, "out-label %d", &next_hop_out_label))
6435 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
6436 else if (unformat (i, "via-label %d", &next_hop_via_label))
6438 else if (unformat (i, "random"))
6440 else if (unformat (i, "seed %d", &random_seed))
6444 clib_warning ("parse error '%U'", format_unformat_error, i);
6449 if (!next_hop_set && !is_drop && !is_local &&
6450 !is_classify && !is_unreach && !is_prohibit &&
6451 MPLS_LABEL_INVALID == next_hop_via_label)
6454 ("next hop / local / drop / unreach / prohibit / classify not set");
6458 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
6460 errmsg ("next hop and next-hop via label set");
6463 if (address_set == 0)
6465 errmsg ("missing addresses");
6469 if (address_length_set == 0)
6471 errmsg ("missing address length");
6475 /* Generate a pile of unique, random routes */
6478 u32 this_random_address;
6479 random_hash = hash_create (count, sizeof (uword));
6481 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
6482 for (j = 0; j <= count; j++)
6486 this_random_address = random_u32 (&random_seed);
6487 this_random_address =
6488 clib_host_to_net_u32 (this_random_address);
6490 while (hash_get (random_hash, this_random_address));
6491 vec_add1 (random_vector, this_random_address);
6492 hash_set (random_hash, this_random_address, 1);
6494 hash_free (random_hash);
6495 v4_dst_address.as_u32 = random_vector[0];
6500 /* Turn on async mode */
6501 vam->async_mode = 1;
6502 vam->async_errors = 0;
6503 before = vat_time_now (vam);
6506 for (j = 0; j < count; j++)
6508 /* Construct the API message */
6509 M2 (IP_ADD_DEL_ROUTE, mp,
6510 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
6512 mp->next_hop_sw_if_index = ntohl (sw_if_index);
6513 mp->table_id = ntohl (vrf_id);
6514 mp->create_vrf_if_needed = create_vrf_if_needed;
6516 mp->is_add = is_add;
6517 mp->is_drop = is_drop;
6518 mp->is_unreach = is_unreach;
6519 mp->is_prohibit = is_prohibit;
6520 mp->is_ipv6 = is_ipv6;
6521 mp->is_local = is_local;
6522 mp->is_classify = is_classify;
6523 mp->is_multipath = is_multipath;
6524 mp->is_resolve_host = resolve_host;
6525 mp->is_resolve_attached = resolve_attached;
6526 mp->not_last = not_last;
6527 mp->next_hop_weight = next_hop_weight;
6528 mp->dst_address_length = dst_address_length;
6529 mp->next_hop_table_id = ntohl (next_hop_table_id);
6530 mp->classify_table_index = ntohl (classify_table_index);
6531 mp->next_hop_via_label = ntohl (next_hop_via_label);
6532 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
6533 if (0 != mp->next_hop_n_out_labels)
6535 memcpy (mp->next_hop_out_label_stack,
6536 next_hop_out_label_stack,
6537 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
6538 vec_free (next_hop_out_label_stack);
6543 clib_memcpy (mp->dst_address, &v6_dst_address,
6544 sizeof (v6_dst_address));
6546 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
6547 sizeof (v6_next_hop_address));
6548 increment_v6_address (&v6_dst_address);
6552 clib_memcpy (mp->dst_address, &v4_dst_address,
6553 sizeof (v4_dst_address));
6555 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
6556 sizeof (v4_next_hop_address));
6558 v4_dst_address.as_u32 = random_vector[j + 1];
6560 increment_v4_address (&v4_dst_address);
6564 /* If we receive SIGTERM, stop now... */
6569 /* When testing multiple add/del ops, use a control-ping to sync */
6572 vl_api_control_ping_t *mp_ping;
6576 /* Shut off async mode */
6577 vam->async_mode = 0;
6579 M (CONTROL_PING, mp_ping);
6582 timeout = vat_time_now (vam) + 1.0;
6583 while (vat_time_now (vam) < timeout)
6584 if (vam->result_ready == 1)
6589 if (vam->retval == -99)
6592 if (vam->async_errors > 0)
6594 errmsg ("%d asynchronous errors", vam->async_errors);
6597 vam->async_errors = 0;
6598 after = vat_time_now (vam);
6600 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6604 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6605 count, after - before, count / (after - before));
6611 /* Wait for a reply... */
6616 /* Return the good/bad news */
6617 return (vam->retval);
6621 api_ip_mroute_add_del (vat_main_t * vam)
6623 unformat_input_t *i = vam->input;
6624 vl_api_ip_mroute_add_del_t *mp;
6625 u32 sw_if_index = ~0, vrf_id = 0;
6628 u8 create_vrf_if_needed = 0;
6631 u32 grp_address_length = 0;
6632 ip4_address_t v4_grp_address, v4_src_address;
6633 ip6_address_t v6_grp_address, v6_src_address;
6634 mfib_itf_flags_t iflags = 0;
6635 mfib_entry_flags_t eflags = 0;
6638 /* Parse args required to build the message */
6639 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6641 if (unformat (i, "sw_if_index %d", &sw_if_index))
6643 else if (unformat (i, "%U %U",
6644 unformat_ip4_address, &v4_src_address,
6645 unformat_ip4_address, &v4_grp_address))
6647 grp_address_length = 64;
6651 else if (unformat (i, "%U %U",
6652 unformat_ip6_address, &v6_src_address,
6653 unformat_ip6_address, &v6_grp_address))
6655 grp_address_length = 256;
6659 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
6661 memset (&v4_src_address, 0, sizeof (v4_src_address));
6662 grp_address_length = 32;
6666 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
6668 memset (&v6_src_address, 0, sizeof (v6_src_address));
6669 grp_address_length = 128;
6673 else if (unformat (i, "/%d", &grp_address_length))
6675 else if (unformat (i, "local"))
6679 else if (unformat (i, "del"))
6681 else if (unformat (i, "add"))
6683 else if (unformat (i, "vrf %d", &vrf_id))
6685 else if (unformat (i, "create-vrf"))
6686 create_vrf_if_needed = 1;
6687 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
6689 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
6693 clib_warning ("parse error '%U'", format_unformat_error, i);
6698 if (address_set == 0)
6700 errmsg ("missing addresses\n");
6704 /* Construct the API message */
6705 M (IP_MROUTE_ADD_DEL, mp);
6707 mp->next_hop_sw_if_index = ntohl (sw_if_index);
6708 mp->table_id = ntohl (vrf_id);
6709 mp->create_vrf_if_needed = create_vrf_if_needed;
6711 mp->is_add = is_add;
6712 mp->is_ipv6 = is_ipv6;
6713 mp->is_local = is_local;
6714 mp->itf_flags = ntohl (iflags);
6715 mp->entry_flags = ntohl (eflags);
6716 mp->grp_address_length = grp_address_length;
6717 mp->grp_address_length = ntohs (mp->grp_address_length);
6721 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
6722 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
6726 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
6727 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
6733 /* Wait for a reply... */
6739 api_mpls_route_add_del (vat_main_t * vam)
6741 unformat_input_t *i = vam->input;
6742 vl_api_mpls_route_add_del_t *mp;
6743 u32 sw_if_index = ~0, table_id = 0;
6744 u8 create_table_if_needed = 0;
6746 u32 next_hop_weight = 1;
6747 u8 is_multipath = 0;
6748 u32 next_hop_table_id = 0;
6749 u8 next_hop_set = 0;
6750 ip4_address_t v4_next_hop_address = {
6753 ip6_address_t v6_next_hop_address = { {0} };
6757 u32 classify_table_index = ~0;
6759 u8 resolve_host = 0, resolve_attached = 0;
6760 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
6761 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6762 mpls_label_t *next_hop_out_label_stack = NULL;
6763 mpls_label_t local_label = MPLS_LABEL_INVALID;
6765 u8 next_hop_proto_is_ip4 = 1;
6767 /* Parse args required to build the message */
6768 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6770 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6772 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6774 else if (unformat (i, "%d", &local_label))
6776 else if (unformat (i, "eos"))
6778 else if (unformat (i, "non-eos"))
6780 else if (unformat (i, "via %U", unformat_ip4_address,
6781 &v4_next_hop_address))
6784 next_hop_proto_is_ip4 = 1;
6786 else if (unformat (i, "via %U", unformat_ip6_address,
6787 &v6_next_hop_address))
6790 next_hop_proto_is_ip4 = 0;
6792 else if (unformat (i, "weight %d", &next_hop_weight))
6794 else if (unformat (i, "create-table"))
6795 create_table_if_needed = 1;
6796 else if (unformat (i, "classify %d", &classify_table_index))
6800 else if (unformat (i, "del"))
6802 else if (unformat (i, "add"))
6804 else if (unformat (i, "resolve-via-host"))
6806 else if (unformat (i, "resolve-via-attached"))
6807 resolve_attached = 1;
6808 else if (unformat (i, "multipath"))
6810 else if (unformat (i, "count %d", &count))
6812 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
6815 next_hop_proto_is_ip4 = 1;
6817 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
6820 next_hop_proto_is_ip4 = 0;
6822 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6824 else if (unformat (i, "via-label %d", &next_hop_via_label))
6826 else if (unformat (i, "out-label %d", &next_hop_out_label))
6827 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
6830 clib_warning ("parse error '%U'", format_unformat_error, i);
6835 if (!next_hop_set && !is_classify)
6837 errmsg ("next hop / classify not set");
6841 if (MPLS_LABEL_INVALID == local_label)
6843 errmsg ("missing label");
6849 /* Turn on async mode */
6850 vam->async_mode = 1;
6851 vam->async_errors = 0;
6852 before = vat_time_now (vam);
6855 for (j = 0; j < count; j++)
6857 /* Construct the API message */
6858 M2 (MPLS_ROUTE_ADD_DEL, mp,
6859 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
6861 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
6862 mp->mr_table_id = ntohl (table_id);
6863 mp->mr_create_table_if_needed = create_table_if_needed;
6865 mp->mr_is_add = is_add;
6866 mp->mr_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
6867 mp->mr_is_classify = is_classify;
6868 mp->mr_is_multipath = is_multipath;
6869 mp->mr_is_resolve_host = resolve_host;
6870 mp->mr_is_resolve_attached = resolve_attached;
6871 mp->mr_next_hop_weight = next_hop_weight;
6872 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
6873 mp->mr_classify_table_index = ntohl (classify_table_index);
6874 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
6875 mp->mr_label = ntohl (local_label);
6876 mp->mr_eos = is_eos;
6878 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
6879 if (0 != mp->mr_next_hop_n_out_labels)
6881 memcpy (mp->mr_next_hop_out_label_stack,
6882 next_hop_out_label_stack,
6883 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
6884 vec_free (next_hop_out_label_stack);
6889 if (next_hop_proto_is_ip4)
6891 clib_memcpy (mp->mr_next_hop,
6892 &v4_next_hop_address,
6893 sizeof (v4_next_hop_address));
6897 clib_memcpy (mp->mr_next_hop,
6898 &v6_next_hop_address,
6899 sizeof (v6_next_hop_address));
6906 /* If we receive SIGTERM, stop now... */
6911 /* When testing multiple add/del ops, use a control-ping to sync */
6914 vl_api_control_ping_t *mp_ping;
6918 /* Shut off async mode */
6919 vam->async_mode = 0;
6921 M (CONTROL_PING, mp_ping);
6924 timeout = vat_time_now (vam) + 1.0;
6925 while (vat_time_now (vam) < timeout)
6926 if (vam->result_ready == 1)
6931 if (vam->retval == -99)
6934 if (vam->async_errors > 0)
6936 errmsg ("%d asynchronous errors", vam->async_errors);
6939 vam->async_errors = 0;
6940 after = vat_time_now (vam);
6942 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6946 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6947 count, after - before, count / (after - before));
6953 /* Wait for a reply... */
6958 /* Return the good/bad news */
6959 return (vam->retval);
6963 api_mpls_ip_bind_unbind (vat_main_t * vam)
6965 unformat_input_t *i = vam->input;
6966 vl_api_mpls_ip_bind_unbind_t *mp;
6967 u32 ip_table_id = 0;
6968 u8 create_table_if_needed = 0;
6971 ip4_address_t v4_address;
6972 ip6_address_t v6_address;
6975 mpls_label_t local_label = MPLS_LABEL_INVALID;
6978 /* Parse args required to build the message */
6979 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6981 if (unformat (i, "%U/%d", unformat_ip4_address,
6982 &v4_address, &address_length))
6987 else if (unformat (i, "%U/%d", unformat_ip6_address,
6988 &v6_address, &address_length))
6993 else if (unformat (i, "%d", &local_label))
6995 else if (unformat (i, "create-table"))
6996 create_table_if_needed = 1;
6997 else if (unformat (i, "table-id %d", &ip_table_id))
6999 else if (unformat (i, "unbind"))
7001 else if (unformat (i, "bind"))
7005 clib_warning ("parse error '%U'", format_unformat_error, i);
7012 errmsg ("IP addres not set");
7016 if (MPLS_LABEL_INVALID == local_label)
7018 errmsg ("missing label");
7022 /* Construct the API message */
7023 M (MPLS_IP_BIND_UNBIND, mp);
7025 mp->mb_create_table_if_needed = create_table_if_needed;
7026 mp->mb_is_bind = is_bind;
7027 mp->mb_is_ip4 = is_ip4;
7028 mp->mb_ip_table_id = ntohl (ip_table_id);
7029 mp->mb_mpls_table_id = 0;
7030 mp->mb_label = ntohl (local_label);
7031 mp->mb_address_length = address_length;
7034 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
7036 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
7041 /* Wait for a reply... */
7047 api_proxy_arp_add_del (vat_main_t * vam)
7049 unformat_input_t *i = vam->input;
7050 vl_api_proxy_arp_add_del_t *mp;
7053 ip4_address_t lo, hi;
7057 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7059 if (unformat (i, "vrf %d", &vrf_id))
7061 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
7062 unformat_ip4_address, &hi))
7064 else if (unformat (i, "del"))
7068 clib_warning ("parse error '%U'", format_unformat_error, i);
7075 errmsg ("address range not set");
7079 M (PROXY_ARP_ADD_DEL, mp);
7081 mp->vrf_id = ntohl (vrf_id);
7082 mp->is_add = is_add;
7083 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
7084 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
7092 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
7094 unformat_input_t *i = vam->input;
7095 vl_api_proxy_arp_intfc_enable_disable_t *mp;
7098 u8 sw_if_index_set = 0;
7101 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7103 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7104 sw_if_index_set = 1;
7105 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7106 sw_if_index_set = 1;
7107 else if (unformat (i, "enable"))
7109 else if (unformat (i, "disable"))
7113 clib_warning ("parse error '%U'", format_unformat_error, i);
7118 if (sw_if_index_set == 0)
7120 errmsg ("missing interface name or sw_if_index");
7124 M (PROXY_ARP_INTFC_ENABLE_DISABLE, mp);
7126 mp->sw_if_index = ntohl (sw_if_index);
7127 mp->enable_disable = enable;
7135 api_mpls_tunnel_add_del (vat_main_t * vam)
7137 unformat_input_t *i = vam->input;
7138 vl_api_mpls_tunnel_add_del_t *mp;
7142 u32 sw_if_index = ~0;
7143 u32 next_hop_sw_if_index = ~0;
7144 u32 next_hop_proto_is_ip4 = 1;
7146 u32 next_hop_table_id = 0;
7147 ip4_address_t v4_next_hop_address = {
7150 ip6_address_t v6_next_hop_address = { {0} };
7151 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID, *labels = NULL;
7154 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7156 if (unformat (i, "add"))
7158 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
7160 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
7162 else if (unformat (i, "via %U",
7163 unformat_ip4_address, &v4_next_hop_address))
7165 next_hop_proto_is_ip4 = 1;
7167 else if (unformat (i, "via %U",
7168 unformat_ip6_address, &v6_next_hop_address))
7170 next_hop_proto_is_ip4 = 0;
7172 else if (unformat (i, "l2-only"))
7174 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
7176 else if (unformat (i, "out-label %d", &next_hop_out_label))
7177 vec_add1 (labels, ntohl (next_hop_out_label));
7180 clib_warning ("parse error '%U'", format_unformat_error, i);
7185 M2 (MPLS_TUNNEL_ADD_DEL, mp, sizeof (mpls_label_t) * vec_len (labels));
7187 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
7188 mp->mt_sw_if_index = ntohl (sw_if_index);
7189 mp->mt_is_add = is_add;
7190 mp->mt_l2_only = l2_only;
7191 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
7192 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
7194 mp->mt_next_hop_n_out_labels = vec_len (labels);
7196 if (0 != mp->mt_next_hop_n_out_labels)
7198 clib_memcpy (mp->mt_next_hop_out_label_stack, labels,
7199 sizeof (mpls_label_t) * mp->mt_next_hop_n_out_labels);
7203 if (next_hop_proto_is_ip4)
7205 clib_memcpy (mp->mt_next_hop,
7206 &v4_next_hop_address, sizeof (v4_next_hop_address));
7210 clib_memcpy (mp->mt_next_hop,
7211 &v6_next_hop_address, sizeof (v6_next_hop_address));
7220 api_sw_interface_set_unnumbered (vat_main_t * vam)
7222 unformat_input_t *i = vam->input;
7223 vl_api_sw_interface_set_unnumbered_t *mp;
7225 u32 unnum_sw_index = ~0;
7227 u8 sw_if_index_set = 0;
7230 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7232 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7233 sw_if_index_set = 1;
7234 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7235 sw_if_index_set = 1;
7236 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
7238 else if (unformat (i, "del"))
7242 clib_warning ("parse error '%U'", format_unformat_error, i);
7247 if (sw_if_index_set == 0)
7249 errmsg ("missing interface name or sw_if_index");
7253 M (SW_INTERFACE_SET_UNNUMBERED, mp);
7255 mp->sw_if_index = ntohl (sw_if_index);
7256 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
7257 mp->is_add = is_add;
7265 api_ip_neighbor_add_del (vat_main_t * vam)
7267 unformat_input_t *i = vam->input;
7268 vl_api_ip_neighbor_add_del_t *mp;
7270 u8 sw_if_index_set = 0;
7276 u8 v4_address_set = 0;
7277 u8 v6_address_set = 0;
7278 ip4_address_t v4address;
7279 ip6_address_t v6address;
7282 memset (mac_address, 0, sizeof (mac_address));
7284 /* Parse args required to build the message */
7285 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7287 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
7291 else if (unformat (i, "del"))
7294 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7295 sw_if_index_set = 1;
7296 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7297 sw_if_index_set = 1;
7298 else if (unformat (i, "is_static"))
7300 else if (unformat (i, "vrf %d", &vrf_id))
7302 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
7304 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
7308 clib_warning ("parse error '%U'", format_unformat_error, i);
7313 if (sw_if_index_set == 0)
7315 errmsg ("missing interface name or sw_if_index");
7318 if (v4_address_set && v6_address_set)
7320 errmsg ("both v4 and v6 addresses set");
7323 if (!v4_address_set && !v6_address_set)
7325 errmsg ("no address set");
7329 /* Construct the API message */
7330 M (IP_NEIGHBOR_ADD_DEL, mp);
7332 mp->sw_if_index = ntohl (sw_if_index);
7333 mp->is_add = is_add;
7334 mp->vrf_id = ntohl (vrf_id);
7335 mp->is_static = is_static;
7337 clib_memcpy (mp->mac_address, mac_address, 6);
7341 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
7345 /* mp->is_ipv6 = 0; via memset in M macro above */
7346 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
7352 /* Wait for a reply, return good/bad news */
7358 api_reset_vrf (vat_main_t * vam)
7360 unformat_input_t *i = vam->input;
7361 vl_api_reset_vrf_t *mp;
7367 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7369 if (unformat (i, "vrf %d", &vrf_id))
7371 else if (unformat (i, "ipv6"))
7375 clib_warning ("parse error '%U'", format_unformat_error, i);
7380 if (vrf_id_set == 0)
7382 errmsg ("missing vrf id");
7388 mp->vrf_id = ntohl (vrf_id);
7389 mp->is_ipv6 = is_ipv6;
7397 api_create_vlan_subif (vat_main_t * vam)
7399 unformat_input_t *i = vam->input;
7400 vl_api_create_vlan_subif_t *mp;
7402 u8 sw_if_index_set = 0;
7407 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7409 if (unformat (i, "sw_if_index %d", &sw_if_index))
7410 sw_if_index_set = 1;
7412 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7413 sw_if_index_set = 1;
7414 else if (unformat (i, "vlan %d", &vlan_id))
7418 clib_warning ("parse error '%U'", format_unformat_error, i);
7423 if (sw_if_index_set == 0)
7425 errmsg ("missing interface name or sw_if_index");
7429 if (vlan_id_set == 0)
7431 errmsg ("missing vlan_id");
7434 M (CREATE_VLAN_SUBIF, mp);
7436 mp->sw_if_index = ntohl (sw_if_index);
7437 mp->vlan_id = ntohl (vlan_id);
7444 #define foreach_create_subif_bit \
7451 _(outer_vlan_id_any) \
7452 _(inner_vlan_id_any)
7455 api_create_subif (vat_main_t * vam)
7457 unformat_input_t *i = vam->input;
7458 vl_api_create_subif_t *mp;
7460 u8 sw_if_index_set = 0;
7467 u32 exact_match = 0;
7468 u32 default_sub = 0;
7469 u32 outer_vlan_id_any = 0;
7470 u32 inner_vlan_id_any = 0;
7472 u16 outer_vlan_id = 0;
7473 u16 inner_vlan_id = 0;
7476 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7478 if (unformat (i, "sw_if_index %d", &sw_if_index))
7479 sw_if_index_set = 1;
7481 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7482 sw_if_index_set = 1;
7483 else if (unformat (i, "sub_id %d", &sub_id))
7485 else if (unformat (i, "outer_vlan_id %d", &tmp))
7486 outer_vlan_id = tmp;
7487 else if (unformat (i, "inner_vlan_id %d", &tmp))
7488 inner_vlan_id = tmp;
7490 #define _(a) else if (unformat (i, #a)) a = 1 ;
7491 foreach_create_subif_bit
7495 clib_warning ("parse error '%U'", format_unformat_error, i);
7500 if (sw_if_index_set == 0)
7502 errmsg ("missing interface name or sw_if_index");
7506 if (sub_id_set == 0)
7508 errmsg ("missing sub_id");
7511 M (CREATE_SUBIF, mp);
7513 mp->sw_if_index = ntohl (sw_if_index);
7514 mp->sub_id = ntohl (sub_id);
7516 #define _(a) mp->a = a;
7517 foreach_create_subif_bit;
7520 mp->outer_vlan_id = ntohs (outer_vlan_id);
7521 mp->inner_vlan_id = ntohs (inner_vlan_id);
7529 api_oam_add_del (vat_main_t * vam)
7531 unformat_input_t *i = vam->input;
7532 vl_api_oam_add_del_t *mp;
7535 ip4_address_t src, dst;
7540 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7542 if (unformat (i, "vrf %d", &vrf_id))
7544 else if (unformat (i, "src %U", unformat_ip4_address, &src))
7546 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
7548 else if (unformat (i, "del"))
7552 clib_warning ("parse error '%U'", format_unformat_error, i);
7559 errmsg ("missing src addr");
7565 errmsg ("missing dst addr");
7569 M (OAM_ADD_DEL, mp);
7571 mp->vrf_id = ntohl (vrf_id);
7572 mp->is_add = is_add;
7573 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
7574 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
7582 api_reset_fib (vat_main_t * vam)
7584 unformat_input_t *i = vam->input;
7585 vl_api_reset_fib_t *mp;
7591 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7593 if (unformat (i, "vrf %d", &vrf_id))
7595 else if (unformat (i, "ipv6"))
7599 clib_warning ("parse error '%U'", format_unformat_error, i);
7604 if (vrf_id_set == 0)
7606 errmsg ("missing vrf id");
7612 mp->vrf_id = ntohl (vrf_id);
7613 mp->is_ipv6 = is_ipv6;
7621 api_dhcp_proxy_config (vat_main_t * vam)
7623 unformat_input_t *i = vam->input;
7624 vl_api_dhcp_proxy_config_t *mp;
7628 u8 v4_address_set = 0;
7629 u8 v6_address_set = 0;
7630 ip4_address_t v4address;
7631 ip6_address_t v6address;
7632 u8 v4_src_address_set = 0;
7633 u8 v6_src_address_set = 0;
7634 ip4_address_t v4srcaddress;
7635 ip6_address_t v6srcaddress;
7638 /* Parse args required to build the message */
7639 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7641 if (unformat (i, "del"))
7643 else if (unformat (i, "vrf %d", &vrf_id))
7645 else if (unformat (i, "insert-cid %d", &insert_cid))
7647 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
7649 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
7651 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
7652 v4_src_address_set = 1;
7653 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
7654 v6_src_address_set = 1;
7659 if (v4_address_set && v6_address_set)
7661 errmsg ("both v4 and v6 server addresses set");
7664 if (!v4_address_set && !v6_address_set)
7666 errmsg ("no server addresses set");
7670 if (v4_src_address_set && v6_src_address_set)
7672 errmsg ("both v4 and v6 src addresses set");
7675 if (!v4_src_address_set && !v6_src_address_set)
7677 errmsg ("no src addresses set");
7681 if (!(v4_src_address_set && v4_address_set) &&
7682 !(v6_src_address_set && v6_address_set))
7684 errmsg ("no matching server and src addresses set");
7688 /* Construct the API message */
7689 M (DHCP_PROXY_CONFIG, mp);
7691 mp->insert_circuit_id = insert_cid;
7692 mp->is_add = is_add;
7693 mp->vrf_id = ntohl (vrf_id);
7697 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
7698 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
7702 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
7703 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
7709 /* Wait for a reply, return good/bad news */
7715 api_dhcp_proxy_config_2 (vat_main_t * vam)
7717 unformat_input_t *i = vam->input;
7718 vl_api_dhcp_proxy_config_2_t *mp;
7720 u32 server_vrf_id = 0;
7723 u8 v4_address_set = 0;
7724 u8 v6_address_set = 0;
7725 ip4_address_t v4address;
7726 ip6_address_t v6address;
7727 u8 v4_src_address_set = 0;
7728 u8 v6_src_address_set = 0;
7729 ip4_address_t v4srcaddress;
7730 ip6_address_t v6srcaddress;
7733 /* Parse args required to build the message */
7734 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7736 if (unformat (i, "del"))
7738 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
7740 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
7742 else if (unformat (i, "insert-cid %d", &insert_cid))
7744 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
7746 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
7748 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
7749 v4_src_address_set = 1;
7750 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
7751 v6_src_address_set = 1;
7756 if (v4_address_set && v6_address_set)
7758 errmsg ("both v4 and v6 server addresses set");
7761 if (!v4_address_set && !v6_address_set)
7763 errmsg ("no server addresses set");
7767 if (v4_src_address_set && v6_src_address_set)
7769 errmsg ("both v4 and v6 src addresses set");
7772 if (!v4_src_address_set && !v6_src_address_set)
7774 errmsg ("no src addresses set");
7778 if (!(v4_src_address_set && v4_address_set) &&
7779 !(v6_src_address_set && v6_address_set))
7781 errmsg ("no matching server and src addresses set");
7785 /* Construct the API message */
7786 M (DHCP_PROXY_CONFIG_2, mp);
7788 mp->insert_circuit_id = insert_cid;
7789 mp->is_add = is_add;
7790 mp->rx_vrf_id = ntohl (rx_vrf_id);
7791 mp->server_vrf_id = ntohl (server_vrf_id);
7795 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
7796 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
7800 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
7801 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
7807 /* Wait for a reply, return good/bad news */
7813 api_dhcp_proxy_set_vss (vat_main_t * vam)
7815 unformat_input_t *i = vam->input;
7816 vl_api_dhcp_proxy_set_vss_t *mp;
7827 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7829 if (unformat (i, "tbl_id %d", &tbl_id))
7831 if (unformat (i, "fib_id %d", &fib_id))
7833 if (unformat (i, "oui %d", &oui))
7835 else if (unformat (i, "ipv6"))
7837 else if (unformat (i, "del"))
7841 clib_warning ("parse error '%U'", format_unformat_error, i);
7846 if (tbl_id_set == 0)
7848 errmsg ("missing tbl id");
7852 if (fib_id_set == 0)
7854 errmsg ("missing fib id");
7859 errmsg ("missing oui");
7863 M (DHCP_PROXY_SET_VSS, mp);
7864 mp->tbl_id = ntohl (tbl_id);
7865 mp->fib_id = ntohl (fib_id);
7866 mp->oui = ntohl (oui);
7867 mp->is_ipv6 = is_ipv6;
7868 mp->is_add = is_add;
7876 api_dhcp_client_config (vat_main_t * vam)
7878 unformat_input_t *i = vam->input;
7879 vl_api_dhcp_client_config_t *mp;
7881 u8 sw_if_index_set = 0;
7884 u8 disable_event = 0;
7887 /* Parse args required to build the message */
7888 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7890 if (unformat (i, "del"))
7893 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7894 sw_if_index_set = 1;
7895 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7896 sw_if_index_set = 1;
7897 else if (unformat (i, "hostname %s", &hostname))
7899 else if (unformat (i, "disable_event"))
7905 if (sw_if_index_set == 0)
7907 errmsg ("missing interface name or sw_if_index");
7911 if (vec_len (hostname) > 63)
7913 errmsg ("hostname too long");
7915 vec_add1 (hostname, 0);
7917 /* Construct the API message */
7918 M (DHCP_CLIENT_CONFIG, mp);
7920 mp->sw_if_index = ntohl (sw_if_index);
7921 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
7922 vec_free (hostname);
7923 mp->is_add = is_add;
7924 mp->want_dhcp_event = disable_event ? 0 : 1;
7925 mp->pid = getpid ();
7930 /* Wait for a reply, return good/bad news */
7936 api_set_ip_flow_hash (vat_main_t * vam)
7938 unformat_input_t *i = vam->input;
7939 vl_api_set_ip_flow_hash_t *mp;
7951 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7953 if (unformat (i, "vrf %d", &vrf_id))
7955 else if (unformat (i, "ipv6"))
7957 else if (unformat (i, "src"))
7959 else if (unformat (i, "dst"))
7961 else if (unformat (i, "sport"))
7963 else if (unformat (i, "dport"))
7965 else if (unformat (i, "proto"))
7967 else if (unformat (i, "reverse"))
7972 clib_warning ("parse error '%U'", format_unformat_error, i);
7977 if (vrf_id_set == 0)
7979 errmsg ("missing vrf id");
7983 M (SET_IP_FLOW_HASH, mp);
7989 mp->reverse = reverse;
7990 mp->vrf_id = ntohl (vrf_id);
7991 mp->is_ipv6 = is_ipv6;
7999 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
8001 unformat_input_t *i = vam->input;
8002 vl_api_sw_interface_ip6_enable_disable_t *mp;
8004 u8 sw_if_index_set = 0;
8008 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8010 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8011 sw_if_index_set = 1;
8012 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8013 sw_if_index_set = 1;
8014 else if (unformat (i, "enable"))
8016 else if (unformat (i, "disable"))
8020 clib_warning ("parse error '%U'", format_unformat_error, i);
8025 if (sw_if_index_set == 0)
8027 errmsg ("missing interface name or sw_if_index");
8031 M (SW_INTERFACE_IP6_ENABLE_DISABLE, mp);
8033 mp->sw_if_index = ntohl (sw_if_index);
8034 mp->enable = enable;
8042 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
8044 unformat_input_t *i = vam->input;
8045 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
8047 u8 sw_if_index_set = 0;
8048 u8 v6_address_set = 0;
8049 ip6_address_t v6address;
8052 /* Parse args required to build the message */
8053 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8055 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8056 sw_if_index_set = 1;
8057 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8058 sw_if_index_set = 1;
8059 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
8065 if (sw_if_index_set == 0)
8067 errmsg ("missing interface name or sw_if_index");
8070 if (!v6_address_set)
8072 errmsg ("no address set");
8076 /* Construct the API message */
8077 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, mp);
8079 mp->sw_if_index = ntohl (sw_if_index);
8080 clib_memcpy (mp->address, &v6address, sizeof (v6address));
8085 /* Wait for a reply, return good/bad news */
8092 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
8094 unformat_input_t *i = vam->input;
8095 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
8097 u8 sw_if_index_set = 0;
8098 u32 address_length = 0;
8099 u8 v6_address_set = 0;
8100 ip6_address_t v6address;
8102 u8 no_advertise = 0;
8104 u8 no_autoconfig = 0;
8107 u32 val_lifetime = 0;
8108 u32 pref_lifetime = 0;
8111 /* Parse args required to build the message */
8112 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8114 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8115 sw_if_index_set = 1;
8116 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8117 sw_if_index_set = 1;
8118 else if (unformat (i, "%U/%d",
8119 unformat_ip6_address, &v6address, &address_length))
8121 else if (unformat (i, "val_life %d", &val_lifetime))
8123 else if (unformat (i, "pref_life %d", &pref_lifetime))
8125 else if (unformat (i, "def"))
8127 else if (unformat (i, "noadv"))
8129 else if (unformat (i, "offl"))
8131 else if (unformat (i, "noauto"))
8133 else if (unformat (i, "nolink"))
8135 else if (unformat (i, "isno"))
8139 clib_warning ("parse error '%U'", format_unformat_error, i);
8144 if (sw_if_index_set == 0)
8146 errmsg ("missing interface name or sw_if_index");
8149 if (!v6_address_set)
8151 errmsg ("no address set");
8155 /* Construct the API message */
8156 M (SW_INTERFACE_IP6ND_RA_PREFIX, mp);
8158 mp->sw_if_index = ntohl (sw_if_index);
8159 clib_memcpy (mp->address, &v6address, sizeof (v6address));
8160 mp->address_length = address_length;
8161 mp->use_default = use_default;
8162 mp->no_advertise = no_advertise;
8163 mp->off_link = off_link;
8164 mp->no_autoconfig = no_autoconfig;
8165 mp->no_onlink = no_onlink;
8167 mp->val_lifetime = ntohl (val_lifetime);
8168 mp->pref_lifetime = ntohl (pref_lifetime);
8173 /* Wait for a reply, return good/bad news */
8179 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
8181 unformat_input_t *i = vam->input;
8182 vl_api_sw_interface_ip6nd_ra_config_t *mp;
8184 u8 sw_if_index_set = 0;
8189 u8 send_unicast = 0;
8192 u8 default_router = 0;
8193 u32 max_interval = 0;
8194 u32 min_interval = 0;
8196 u32 initial_count = 0;
8197 u32 initial_interval = 0;
8201 /* Parse args required to build the message */
8202 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8204 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8205 sw_if_index_set = 1;
8206 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8207 sw_if_index_set = 1;
8208 else if (unformat (i, "maxint %d", &max_interval))
8210 else if (unformat (i, "minint %d", &min_interval))
8212 else if (unformat (i, "life %d", &lifetime))
8214 else if (unformat (i, "count %d", &initial_count))
8216 else if (unformat (i, "interval %d", &initial_interval))
8218 else if (unformat (i, "suppress") || unformat (i, "surpress"))
8220 else if (unformat (i, "managed"))
8222 else if (unformat (i, "other"))
8224 else if (unformat (i, "ll"))
8226 else if (unformat (i, "send"))
8228 else if (unformat (i, "cease"))
8230 else if (unformat (i, "isno"))
8232 else if (unformat (i, "def"))
8236 clib_warning ("parse error '%U'", format_unformat_error, i);
8241 if (sw_if_index_set == 0)
8243 errmsg ("missing interface name or sw_if_index");
8247 /* Construct the API message */
8248 M (SW_INTERFACE_IP6ND_RA_CONFIG, mp);
8250 mp->sw_if_index = ntohl (sw_if_index);
8251 mp->max_interval = ntohl (max_interval);
8252 mp->min_interval = ntohl (min_interval);
8253 mp->lifetime = ntohl (lifetime);
8254 mp->initial_count = ntohl (initial_count);
8255 mp->initial_interval = ntohl (initial_interval);
8256 mp->suppress = suppress;
8257 mp->managed = managed;
8259 mp->ll_option = ll_option;
8260 mp->send_unicast = send_unicast;
8263 mp->default_router = default_router;
8268 /* Wait for a reply, return good/bad news */
8274 api_set_arp_neighbor_limit (vat_main_t * vam)
8276 unformat_input_t *i = vam->input;
8277 vl_api_set_arp_neighbor_limit_t *mp;
8283 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8285 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
8287 else if (unformat (i, "ipv6"))
8291 clib_warning ("parse error '%U'", format_unformat_error, i);
8298 errmsg ("missing limit value");
8302 M (SET_ARP_NEIGHBOR_LIMIT, mp);
8304 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
8305 mp->is_ipv6 = is_ipv6;
8313 api_l2_patch_add_del (vat_main_t * vam)
8315 unformat_input_t *i = vam->input;
8316 vl_api_l2_patch_add_del_t *mp;
8318 u8 rx_sw_if_index_set = 0;
8320 u8 tx_sw_if_index_set = 0;
8324 /* Parse args required to build the message */
8325 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8327 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
8328 rx_sw_if_index_set = 1;
8329 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
8330 tx_sw_if_index_set = 1;
8331 else if (unformat (i, "rx"))
8333 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8335 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
8337 rx_sw_if_index_set = 1;
8342 else if (unformat (i, "tx"))
8344 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8346 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
8348 tx_sw_if_index_set = 1;
8353 else if (unformat (i, "del"))
8359 if (rx_sw_if_index_set == 0)
8361 errmsg ("missing rx interface name or rx_sw_if_index");
8365 if (tx_sw_if_index_set == 0)
8367 errmsg ("missing tx interface name or tx_sw_if_index");
8371 M (L2_PATCH_ADD_DEL, mp);
8373 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
8374 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
8375 mp->is_add = is_add;
8383 api_ioam_enable (vat_main_t * vam)
8385 unformat_input_t *input = vam->input;
8386 vl_api_ioam_enable_t *mp;
8388 int has_trace_option = 0;
8389 int has_pot_option = 0;
8390 int has_seqno_option = 0;
8391 int has_analyse_option = 0;
8394 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8396 if (unformat (input, "trace"))
8397 has_trace_option = 1;
8398 else if (unformat (input, "pot"))
8400 else if (unformat (input, "seqno"))
8401 has_seqno_option = 1;
8402 else if (unformat (input, "analyse"))
8403 has_analyse_option = 1;
8407 M (IOAM_ENABLE, mp);
8408 mp->id = htons (id);
8409 mp->seqno = has_seqno_option;
8410 mp->analyse = has_analyse_option;
8411 mp->pot_enable = has_pot_option;
8412 mp->trace_enable = has_trace_option;
8421 api_ioam_disable (vat_main_t * vam)
8423 vl_api_ioam_disable_t *mp;
8426 M (IOAM_DISABLE, mp);
8433 api_sr_tunnel_add_del (vat_main_t * vam)
8435 unformat_input_t *i = vam->input;
8436 vl_api_sr_tunnel_add_del_t *mp;
8439 ip6_address_t src_address;
8440 int src_address_set = 0;
8441 ip6_address_t dst_address;
8443 int dst_address_set = 0;
8445 u32 rx_table_id = 0;
8446 u32 tx_table_id = 0;
8447 ip6_address_t *segments = 0;
8448 ip6_address_t *this_seg;
8449 ip6_address_t *tags = 0;
8450 ip6_address_t *this_tag;
8451 ip6_address_t next_address, tag;
8453 u8 *policy_name = 0;
8456 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8458 if (unformat (i, "del"))
8460 else if (unformat (i, "name %s", &name))
8462 else if (unformat (i, "policy %s", &policy_name))
8464 else if (unformat (i, "rx_fib_id %d", &rx_table_id))
8466 else if (unformat (i, "tx_fib_id %d", &tx_table_id))
8468 else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
8469 src_address_set = 1;
8470 else if (unformat (i, "dst %U/%d",
8471 unformat_ip6_address, &dst_address, &dst_mask_width))
8472 dst_address_set = 1;
8473 else if (unformat (i, "next %U", unformat_ip6_address, &next_address))
8475 vec_add2 (segments, this_seg, 1);
8476 clib_memcpy (this_seg->as_u8, next_address.as_u8,
8477 sizeof (*this_seg));
8479 else if (unformat (i, "tag %U", unformat_ip6_address, &tag))
8481 vec_add2 (tags, this_tag, 1);
8482 clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
8484 else if (unformat (i, "clean"))
8485 flags |= IP6_SR_HEADER_FLAG_CLEANUP;
8486 else if (unformat (i, "protected"))
8487 flags |= IP6_SR_HEADER_FLAG_PROTECTED;
8488 else if (unformat (i, "InPE %d", &pl_index))
8490 if (pl_index <= 0 || pl_index > 4)
8492 pl_index_range_error:
8493 errmsg ("pl index %d out of range", pl_index);
8497 IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE << (3 * (pl_index - 1));
8499 else if (unformat (i, "EgPE %d", &pl_index))
8501 if (pl_index <= 0 || pl_index > 4)
8502 goto pl_index_range_error;
8504 IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE << (3 * (pl_index - 1));
8506 else if (unformat (i, "OrgSrc %d", &pl_index))
8508 if (pl_index <= 0 || pl_index > 4)
8509 goto pl_index_range_error;
8511 IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3 * (pl_index - 1));
8517 if (!src_address_set)
8519 errmsg ("src address required");
8523 if (!dst_address_set)
8525 errmsg ("dst address required");
8531 errmsg ("at least one sr segment required");
8535 M2 (SR_TUNNEL_ADD_DEL, mp,
8536 vec_len (segments) * sizeof (ip6_address_t)
8537 + vec_len (tags) * sizeof (ip6_address_t));
8539 clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
8540 clib_memcpy (mp->dst_address, &dst_address, sizeof (mp->dst_address));
8541 mp->dst_mask_width = dst_mask_width;
8542 mp->flags_net_byte_order = clib_host_to_net_u16 (flags);
8543 mp->n_segments = vec_len (segments);
8544 mp->n_tags = vec_len (tags);
8545 mp->is_add = is_del == 0;
8546 clib_memcpy (mp->segs_and_tags, segments,
8547 vec_len (segments) * sizeof (ip6_address_t));
8548 clib_memcpy (mp->segs_and_tags +
8549 vec_len (segments) * sizeof (ip6_address_t), tags,
8550 vec_len (tags) * sizeof (ip6_address_t));
8552 mp->outer_vrf_id = ntohl (rx_table_id);
8553 mp->inner_vrf_id = ntohl (tx_table_id);
8554 memcpy (mp->name, name, vec_len (name));
8555 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
8557 vec_free (segments);
8566 api_sr_policy_add_del (vat_main_t * vam)
8568 unformat_input_t *input = vam->input;
8569 vl_api_sr_policy_add_del_t *mp;
8572 u8 *tunnel_name = 0;
8573 u8 **tunnel_names = 0;
8578 int tunnel_names_length = 1; // Init to 1 to offset the #tunnel_names counter byte
8579 int tun_name_len = 0; // Different naming convention used as confusing these would be "bad" (TM)
8582 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8584 if (unformat (input, "del"))
8586 else if (unformat (input, "name %s", &name))
8588 else if (unformat (input, "tunnel %s", &tunnel_name))
8592 vec_add1 (tunnel_names, tunnel_name);
8594 - length = #bytes to store in serial vector
8595 - +1 = byte to store that length
8597 tunnel_names_length += (vec_len (tunnel_name) + 1);
8608 errmsg ("policy name required");
8612 if ((!tunnel_set) && (!is_del))
8614 errmsg ("tunnel name required");
8618 M2 (SR_POLICY_ADD_DEL, mp, tunnel_names_length);
8622 mp->is_add = !is_del;
8624 memcpy (mp->name, name, vec_len (name));
8625 // Since mp->tunnel_names is of type u8[0] and not a u8 *, u8 ** needs to be serialized
8626 u8 *serial_orig = 0;
8627 vec_validate (serial_orig, tunnel_names_length);
8628 *serial_orig = vec_len (tunnel_names); // Store the number of tunnels as length in first byte of serialized vector
8629 serial_orig += 1; // Move along one byte to store the length of first tunnel_name
8631 for (j = 0; j < vec_len (tunnel_names); j++)
8633 tun_name_len = vec_len (tunnel_names[j]);
8634 *serial_orig = tun_name_len; // Store length of tunnel name in first byte of Length/Value pair
8635 serial_orig += 1; // Move along one byte to store the actual tunnel name
8636 memcpy (serial_orig, tunnel_names[j], tun_name_len);
8637 serial_orig += tun_name_len; // Advance past the copy
8639 memcpy (mp->tunnel_names, serial_orig - tunnel_names_length, tunnel_names_length); // Regress serial_orig to head then copy fwd
8641 vec_free (tunnel_names);
8642 vec_free (tunnel_name);
8650 api_sr_multicast_map_add_del (vat_main_t * vam)
8652 unformat_input_t *input = vam->input;
8653 vl_api_sr_multicast_map_add_del_t *mp;
8655 ip6_address_t multicast_address;
8656 u8 *policy_name = 0;
8657 int multicast_address_set = 0;
8660 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8662 if (unformat (input, "del"))
8666 (input, "address %U", unformat_ip6_address, &multicast_address))
8667 multicast_address_set = 1;
8668 else if (unformat (input, "sr-policy %s", &policy_name))
8674 if (!is_del && !policy_name)
8676 errmsg ("sr-policy name required");
8681 if (!multicast_address_set)
8683 errmsg ("address required");
8687 M (SR_MULTICAST_MAP_ADD_DEL, mp);
8689 mp->is_add = !is_del;
8690 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
8691 clib_memcpy (mp->multicast_address, &multicast_address,
8692 sizeof (mp->multicast_address));
8695 vec_free (policy_name);
8703 #define foreach_tcp_proto_field \
8707 #define foreach_udp_proto_field \
8711 #define foreach_ip4_proto_field \
8722 unformat_tcp_mask (unformat_input_t * input, va_list * args)
8724 u8 **maskp = va_arg (*args, u8 **);
8726 u8 found_something = 0;
8729 #define _(a) u8 a=0;
8730 foreach_tcp_proto_field;
8733 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8736 #define _(a) else if (unformat (input, #a)) a=1;
8737 foreach_tcp_proto_field
8743 #define _(a) found_something += a;
8744 foreach_tcp_proto_field;
8747 if (found_something == 0)
8750 vec_validate (mask, sizeof (*tcp) - 1);
8752 tcp = (tcp_header_t *) mask;
8754 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
8755 foreach_tcp_proto_field;
8763 unformat_udp_mask (unformat_input_t * input, va_list * args)
8765 u8 **maskp = va_arg (*args, u8 **);
8767 u8 found_something = 0;
8770 #define _(a) u8 a=0;
8771 foreach_udp_proto_field;
8774 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8777 #define _(a) else if (unformat (input, #a)) a=1;
8778 foreach_udp_proto_field
8784 #define _(a) found_something += a;
8785 foreach_udp_proto_field;
8788 if (found_something == 0)
8791 vec_validate (mask, sizeof (*udp) - 1);
8793 udp = (udp_header_t *) mask;
8795 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
8796 foreach_udp_proto_field;
8805 u16 src_port, dst_port;
8809 unformat_l4_mask (unformat_input_t * input, va_list * args)
8811 u8 **maskp = va_arg (*args, u8 **);
8812 u16 src_port = 0, dst_port = 0;
8813 tcpudp_header_t *tcpudp;
8815 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8817 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
8819 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
8821 else if (unformat (input, "src_port"))
8823 else if (unformat (input, "dst_port"))
8829 if (!src_port && !dst_port)
8833 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
8835 tcpudp = (tcpudp_header_t *) mask;
8836 tcpudp->src_port = src_port;
8837 tcpudp->dst_port = dst_port;
8845 unformat_ip4_mask (unformat_input_t * input, va_list * args)
8847 u8 **maskp = va_arg (*args, u8 **);
8849 u8 found_something = 0;
8852 #define _(a) u8 a=0;
8853 foreach_ip4_proto_field;
8859 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8861 if (unformat (input, "version"))
8863 else if (unformat (input, "hdr_length"))
8865 else if (unformat (input, "src"))
8867 else if (unformat (input, "dst"))
8869 else if (unformat (input, "proto"))
8872 #define _(a) else if (unformat (input, #a)) a=1;
8873 foreach_ip4_proto_field
8879 #define _(a) found_something += a;
8880 foreach_ip4_proto_field;
8883 if (found_something == 0)
8886 vec_validate (mask, sizeof (*ip) - 1);
8888 ip = (ip4_header_t *) mask;
8890 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
8891 foreach_ip4_proto_field;
8894 ip->ip_version_and_header_length = 0;
8897 ip->ip_version_and_header_length |= 0xF0;
8900 ip->ip_version_and_header_length |= 0x0F;
8906 #define foreach_ip6_proto_field \
8914 unformat_ip6_mask (unformat_input_t * input, va_list * args)
8916 u8 **maskp = va_arg (*args, u8 **);
8918 u8 found_something = 0;
8920 u32 ip_version_traffic_class_and_flow_label;
8922 #define _(a) u8 a=0;
8923 foreach_ip6_proto_field;
8926 u8 traffic_class = 0;
8929 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8931 if (unformat (input, "version"))
8933 else if (unformat (input, "traffic-class"))
8935 else if (unformat (input, "flow-label"))
8937 else if (unformat (input, "src"))
8939 else if (unformat (input, "dst"))
8941 else if (unformat (input, "proto"))
8944 #define _(a) else if (unformat (input, #a)) a=1;
8945 foreach_ip6_proto_field
8951 #define _(a) found_something += a;
8952 foreach_ip6_proto_field;
8955 if (found_something == 0)
8958 vec_validate (mask, sizeof (*ip) - 1);
8960 ip = (ip6_header_t *) mask;
8962 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
8963 foreach_ip6_proto_field;
8966 ip_version_traffic_class_and_flow_label = 0;
8969 ip_version_traffic_class_and_flow_label |= 0xF0000000;
8972 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
8975 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
8977 ip->ip_version_traffic_class_and_flow_label =
8978 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
8985 unformat_l3_mask (unformat_input_t * input, va_list * args)
8987 u8 **maskp = va_arg (*args, u8 **);
8989 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8991 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
8993 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
9002 unformat_l2_mask (unformat_input_t * input, va_list * args)
9004 u8 **maskp = va_arg (*args, u8 **);
9019 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9021 if (unformat (input, "src"))
9023 else if (unformat (input, "dst"))
9025 else if (unformat (input, "proto"))
9027 else if (unformat (input, "tag1"))
9029 else if (unformat (input, "tag2"))
9031 else if (unformat (input, "ignore-tag1"))
9033 else if (unformat (input, "ignore-tag2"))
9035 else if (unformat (input, "cos1"))
9037 else if (unformat (input, "cos2"))
9039 else if (unformat (input, "dot1q"))
9041 else if (unformat (input, "dot1ad"))
9046 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
9047 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9050 if (tag1 || ignore_tag1 || cos1 || dot1q)
9052 if (tag2 || ignore_tag2 || cos2 || dot1ad)
9055 vec_validate (mask, len - 1);
9058 memset (mask, 0xff, 6);
9061 memset (mask + 6, 0xff, 6);
9065 /* inner vlan tag */
9074 mask[21] = mask[20] = 0xff;
9095 mask[16] = mask[17] = 0xff;
9105 mask[12] = mask[13] = 0xff;
9112 unformat_classify_mask (unformat_input_t * input, va_list * args)
9114 u8 **maskp = va_arg (*args, u8 **);
9115 u32 *skipp = va_arg (*args, u32 *);
9116 u32 *matchp = va_arg (*args, u32 *);
9124 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9126 if (unformat (input, "hex %U", unformat_hex_string, &mask))
9128 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
9130 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
9132 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
9146 if (mask || l2 || l3 || l4)
9150 /* "With a free Ethernet header in every package" */
9152 vec_validate (l2, 13);
9156 vec_append (mask, l3);
9161 vec_append (mask, l4);
9166 /* Scan forward looking for the first significant mask octet */
9167 for (i = 0; i < vec_len (mask); i++)
9171 /* compute (skip, match) params */
9172 *skipp = i / sizeof (u32x4);
9173 vec_delete (mask, *skipp * sizeof (u32x4), 0);
9175 /* Pad mask to an even multiple of the vector size */
9176 while (vec_len (mask) % sizeof (u32x4))
9179 match = vec_len (mask) / sizeof (u32x4);
9181 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
9183 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
9184 if (*tmp || *(tmp + 1))
9189 clib_warning ("BUG: match 0");
9191 _vec_len (mask) = match * sizeof (u32x4);
9202 #define foreach_l2_next \
9204 _(ethernet, ETHERNET_INPUT) \
9209 unformat_l2_next_index (unformat_input_t * input, va_list * args)
9211 u32 *miss_next_indexp = va_arg (*args, u32 *);
9216 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
9220 if (unformat (input, "%d", &tmp))
9229 *miss_next_indexp = next_index;
9233 #define foreach_ip_next \
9239 unformat_ip_next_index (unformat_input_t * input, va_list * args)
9241 u32 *miss_next_indexp = va_arg (*args, u32 *);
9246 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
9250 if (unformat (input, "%d", &tmp))
9259 *miss_next_indexp = next_index;
9263 #define foreach_acl_next \
9267 unformat_acl_next_index (unformat_input_t * input, va_list * args)
9269 u32 *miss_next_indexp = va_arg (*args, u32 *);
9274 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
9278 if (unformat (input, "permit"))
9283 else if (unformat (input, "%d", &tmp))
9292 *miss_next_indexp = next_index;
9297 unformat_policer_precolor (unformat_input_t * input, va_list * args)
9299 u32 *r = va_arg (*args, u32 *);
9301 if (unformat (input, "conform-color"))
9302 *r = POLICE_CONFORM;
9303 else if (unformat (input, "exceed-color"))
9312 api_classify_add_del_table (vat_main_t * vam)
9314 unformat_input_t *i = vam->input;
9315 vl_api_classify_add_del_table_t *mp;
9322 u32 table_index = ~0;
9323 u32 next_table_index = ~0;
9324 u32 miss_next_index = ~0;
9325 u32 memory_size = 32 << 20;
9327 u32 current_data_flag = 0;
9328 int current_data_offset = 0;
9331 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9333 if (unformat (i, "del"))
9335 else if (unformat (i, "del-chain"))
9340 else if (unformat (i, "buckets %d", &nbuckets))
9342 else if (unformat (i, "memory_size %d", &memory_size))
9344 else if (unformat (i, "skip %d", &skip))
9346 else if (unformat (i, "match %d", &match))
9348 else if (unformat (i, "table %d", &table_index))
9350 else if (unformat (i, "mask %U", unformat_classify_mask,
9351 &mask, &skip, &match))
9353 else if (unformat (i, "next-table %d", &next_table_index))
9355 else if (unformat (i, "miss-next %U", unformat_ip_next_index,
9358 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
9361 else if (unformat (i, "acl-miss-next %U", unformat_acl_next_index,
9364 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
9366 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
9372 if (is_add && mask == 0)
9374 errmsg ("Mask required");
9378 if (is_add && skip == ~0)
9380 errmsg ("skip count required");
9384 if (is_add && match == ~0)
9386 errmsg ("match count required");
9390 if (!is_add && table_index == ~0)
9392 errmsg ("table index required for delete");
9396 M2 (CLASSIFY_ADD_DEL_TABLE, mp, vec_len (mask));
9398 mp->is_add = is_add;
9399 mp->del_chain = del_chain;
9400 mp->table_index = ntohl (table_index);
9401 mp->nbuckets = ntohl (nbuckets);
9402 mp->memory_size = ntohl (memory_size);
9403 mp->skip_n_vectors = ntohl (skip);
9404 mp->match_n_vectors = ntohl (match);
9405 mp->next_table_index = ntohl (next_table_index);
9406 mp->miss_next_index = ntohl (miss_next_index);
9407 mp->current_data_flag = ntohl (current_data_flag);
9408 mp->current_data_offset = ntohl (current_data_offset);
9409 clib_memcpy (mp->mask, mask, vec_len (mask));
9419 unformat_l4_match (unformat_input_t * input, va_list * args)
9421 u8 **matchp = va_arg (*args, u8 **);
9423 u8 *proto_header = 0;
9429 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9431 if (unformat (input, "src_port %d", &src_port))
9433 else if (unformat (input, "dst_port %d", &dst_port))
9439 h.src_port = clib_host_to_net_u16 (src_port);
9440 h.dst_port = clib_host_to_net_u16 (dst_port);
9441 vec_validate (proto_header, sizeof (h) - 1);
9442 memcpy (proto_header, &h, sizeof (h));
9444 *matchp = proto_header;
9450 unformat_ip4_match (unformat_input_t * input, va_list * args)
9452 u8 **matchp = va_arg (*args, u8 **);
9459 int src = 0, dst = 0;
9460 ip4_address_t src_val, dst_val;
9467 int fragment_id = 0;
9468 u32 fragment_id_val;
9474 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9476 if (unformat (input, "version %d", &version_val))
9478 else if (unformat (input, "hdr_length %d", &hdr_length_val))
9480 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
9482 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
9484 else if (unformat (input, "proto %d", &proto_val))
9486 else if (unformat (input, "tos %d", &tos_val))
9488 else if (unformat (input, "length %d", &length_val))
9490 else if (unformat (input, "fragment_id %d", &fragment_id_val))
9492 else if (unformat (input, "ttl %d", &ttl_val))
9494 else if (unformat (input, "checksum %d", &checksum_val))
9500 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
9501 + ttl + checksum == 0)
9505 * Aligned because we use the real comparison functions
9507 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
9509 ip = (ip4_header_t *) match;
9511 /* These are realistically matched in practice */
9513 ip->src_address.as_u32 = src_val.as_u32;
9516 ip->dst_address.as_u32 = dst_val.as_u32;
9519 ip->protocol = proto_val;
9522 /* These are not, but they're included for completeness */
9524 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
9527 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
9533 ip->length = clib_host_to_net_u16 (length_val);
9539 ip->checksum = clib_host_to_net_u16 (checksum_val);
9546 unformat_ip6_match (unformat_input_t * input, va_list * args)
9548 u8 **matchp = va_arg (*args, u8 **);
9553 u8 traffic_class = 0;
9554 u32 traffic_class_val = 0;
9557 int src = 0, dst = 0;
9558 ip6_address_t src_val, dst_val;
9561 int payload_length = 0;
9562 u32 payload_length_val;
9565 u32 ip_version_traffic_class_and_flow_label;
9567 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9569 if (unformat (input, "version %d", &version_val))
9571 else if (unformat (input, "traffic_class %d", &traffic_class_val))
9573 else if (unformat (input, "flow_label %d", &flow_label_val))
9575 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
9577 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
9579 else if (unformat (input, "proto %d", &proto_val))
9581 else if (unformat (input, "payload_length %d", &payload_length_val))
9583 else if (unformat (input, "hop_limit %d", &hop_limit_val))
9589 if (version + traffic_class + flow_label + src + dst + proto +
9590 payload_length + hop_limit == 0)
9594 * Aligned because we use the real comparison functions
9596 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
9598 ip = (ip6_header_t *) match;
9601 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
9604 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
9607 ip->protocol = proto_val;
9609 ip_version_traffic_class_and_flow_label = 0;
9612 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
9615 ip_version_traffic_class_and_flow_label |=
9616 (traffic_class_val & 0xFF) << 20;
9619 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
9621 ip->ip_version_traffic_class_and_flow_label =
9622 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9625 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
9628 ip->hop_limit = hop_limit_val;
9635 unformat_l3_match (unformat_input_t * input, va_list * args)
9637 u8 **matchp = va_arg (*args, u8 **);
9639 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9641 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
9643 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
9652 unformat_vlan_tag (unformat_input_t * input, va_list * args)
9654 u8 *tagp = va_arg (*args, u8 *);
9657 if (unformat (input, "%d", &tag))
9659 tagp[0] = (tag >> 8) & 0x0F;
9660 tagp[1] = tag & 0xFF;
9668 unformat_l2_match (unformat_input_t * input, va_list * args)
9670 u8 **matchp = va_arg (*args, u8 **);
9690 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9692 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
9695 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
9697 else if (unformat (input, "proto %U",
9698 unformat_ethernet_type_host_byte_order, &proto_val))
9700 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
9702 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
9704 else if (unformat (input, "ignore-tag1"))
9706 else if (unformat (input, "ignore-tag2"))
9708 else if (unformat (input, "cos1 %d", &cos1_val))
9710 else if (unformat (input, "cos2 %d", &cos2_val))
9715 if ((src + dst + proto + tag1 + tag2 +
9716 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9719 if (tag1 || ignore_tag1 || cos1)
9721 if (tag2 || ignore_tag2 || cos2)
9724 vec_validate_aligned (match, len - 1, sizeof (u32x4));
9727 clib_memcpy (match, dst_val, 6);
9730 clib_memcpy (match + 6, src_val, 6);
9734 /* inner vlan tag */
9735 match[19] = tag2_val[1];
9736 match[18] = tag2_val[0];
9738 match[18] |= (cos2_val & 0x7) << 5;
9741 match[21] = proto_val & 0xff;
9742 match[20] = proto_val >> 8;
9746 match[15] = tag1_val[1];
9747 match[14] = tag1_val[0];
9750 match[14] |= (cos1_val & 0x7) << 5;
9756 match[15] = tag1_val[1];
9757 match[14] = tag1_val[0];
9760 match[17] = proto_val & 0xff;
9761 match[16] = proto_val >> 8;
9764 match[14] |= (cos1_val & 0x7) << 5;
9770 match[18] |= (cos2_val & 0x7) << 5;
9772 match[14] |= (cos1_val & 0x7) << 5;
9775 match[13] = proto_val & 0xff;
9776 match[12] = proto_val >> 8;
9785 unformat_classify_match (unformat_input_t * input, va_list * args)
9787 u8 **matchp = va_arg (*args, u8 **);
9788 u32 skip_n_vectors = va_arg (*args, u32);
9789 u32 match_n_vectors = va_arg (*args, u32);
9796 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9798 if (unformat (input, "hex %U", unformat_hex_string, &match))
9800 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
9802 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
9804 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
9818 if (match || l2 || l3 || l4)
9822 /* "Win a free Ethernet header in every packet" */
9824 vec_validate_aligned (l2, 13, sizeof (u32x4));
9828 vec_append_aligned (match, l3, sizeof (u32x4));
9833 vec_append_aligned (match, l4, sizeof (u32x4));
9838 /* Make sure the vector is big enough even if key is all 0's */
9839 vec_validate_aligned
9840 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
9843 /* Set size, include skipped vectors */
9844 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
9855 api_classify_add_del_session (vat_main_t * vam)
9857 unformat_input_t *i = vam->input;
9858 vl_api_classify_add_del_session_t *mp;
9860 u32 table_index = ~0;
9861 u32 hit_next_index = ~0;
9862 u32 opaque_index = ~0;
9865 u32 skip_n_vectors = 0;
9866 u32 match_n_vectors = 0;
9872 * Warning: you have to supply skip_n and match_n
9873 * because the API client cant simply look at the classify
9877 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9879 if (unformat (i, "del"))
9881 else if (unformat (i, "hit-next %U", unformat_ip_next_index,
9884 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
9887 else if (unformat (i, "acl-hit-next %U", unformat_acl_next_index,
9890 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
9892 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
9894 else if (unformat (i, "opaque-index %d", &opaque_index))
9896 else if (unformat (i, "skip_n %d", &skip_n_vectors))
9898 else if (unformat (i, "match_n %d", &match_n_vectors))
9900 else if (unformat (i, "match %U", unformat_classify_match,
9901 &match, skip_n_vectors, match_n_vectors))
9903 else if (unformat (i, "advance %d", &advance))
9905 else if (unformat (i, "table-index %d", &table_index))
9907 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
9909 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
9911 else if (unformat (i, "action %d", &action))
9913 else if (unformat (i, "metadata %d", &metadata))
9919 if (table_index == ~0)
9921 errmsg ("Table index required");
9925 if (is_add && match == 0)
9927 errmsg ("Match value required");
9931 M2 (CLASSIFY_ADD_DEL_SESSION, mp, vec_len (match));
9933 mp->is_add = is_add;
9934 mp->table_index = ntohl (table_index);
9935 mp->hit_next_index = ntohl (hit_next_index);
9936 mp->opaque_index = ntohl (opaque_index);
9937 mp->advance = ntohl (advance);
9938 mp->action = action;
9939 mp->metadata = ntohl (metadata);
9940 clib_memcpy (mp->match, match, vec_len (match));
9949 api_classify_set_interface_ip_table (vat_main_t * vam)
9951 unformat_input_t *i = vam->input;
9952 vl_api_classify_set_interface_ip_table_t *mp;
9954 int sw_if_index_set;
9955 u32 table_index = ~0;
9959 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9961 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9962 sw_if_index_set = 1;
9963 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9964 sw_if_index_set = 1;
9965 else if (unformat (i, "table %d", &table_index))
9969 clib_warning ("parse error '%U'", format_unformat_error, i);
9974 if (sw_if_index_set == 0)
9976 errmsg ("missing interface name or sw_if_index");
9981 M (CLASSIFY_SET_INTERFACE_IP_TABLE, mp);
9983 mp->sw_if_index = ntohl (sw_if_index);
9984 mp->table_index = ntohl (table_index);
9985 mp->is_ipv6 = is_ipv6;
9993 api_classify_set_interface_l2_tables (vat_main_t * vam)
9995 unformat_input_t *i = vam->input;
9996 vl_api_classify_set_interface_l2_tables_t *mp;
9998 int sw_if_index_set;
9999 u32 ip4_table_index = ~0;
10000 u32 ip6_table_index = ~0;
10001 u32 other_table_index = ~0;
10005 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10007 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10008 sw_if_index_set = 1;
10009 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10010 sw_if_index_set = 1;
10011 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10013 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10015 else if (unformat (i, "other-table %d", &other_table_index))
10017 else if (unformat (i, "is-input %d", &is_input))
10021 clib_warning ("parse error '%U'", format_unformat_error, i);
10026 if (sw_if_index_set == 0)
10028 errmsg ("missing interface name or sw_if_index");
10033 M (CLASSIFY_SET_INTERFACE_L2_TABLES, mp);
10035 mp->sw_if_index = ntohl (sw_if_index);
10036 mp->ip4_table_index = ntohl (ip4_table_index);
10037 mp->ip6_table_index = ntohl (ip6_table_index);
10038 mp->other_table_index = ntohl (other_table_index);
10039 mp->is_input = (u8) is_input;
10047 api_set_ipfix_exporter (vat_main_t * vam)
10049 unformat_input_t *i = vam->input;
10050 vl_api_set_ipfix_exporter_t *mp;
10051 ip4_address_t collector_address;
10052 u8 collector_address_set = 0;
10053 u32 collector_port = ~0;
10054 ip4_address_t src_address;
10055 u8 src_address_set = 0;
10058 u32 template_interval = ~0;
10059 u8 udp_checksum = 0;
10062 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10064 if (unformat (i, "collector_address %U", unformat_ip4_address,
10065 &collector_address))
10066 collector_address_set = 1;
10067 else if (unformat (i, "collector_port %d", &collector_port))
10069 else if (unformat (i, "src_address %U", unformat_ip4_address,
10071 src_address_set = 1;
10072 else if (unformat (i, "vrf_id %d", &vrf_id))
10074 else if (unformat (i, "path_mtu %d", &path_mtu))
10076 else if (unformat (i, "template_interval %d", &template_interval))
10078 else if (unformat (i, "udp_checksum"))
10084 if (collector_address_set == 0)
10086 errmsg ("collector_address required");
10090 if (src_address_set == 0)
10092 errmsg ("src_address required");
10096 M (SET_IPFIX_EXPORTER, mp);
10098 memcpy (mp->collector_address, collector_address.data,
10099 sizeof (collector_address.data));
10100 mp->collector_port = htons ((u16) collector_port);
10101 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
10102 mp->vrf_id = htonl (vrf_id);
10103 mp->path_mtu = htonl (path_mtu);
10104 mp->template_interval = htonl (template_interval);
10105 mp->udp_checksum = udp_checksum;
10113 api_set_ipfix_classify_stream (vat_main_t * vam)
10115 unformat_input_t *i = vam->input;
10116 vl_api_set_ipfix_classify_stream_t *mp;
10118 u32 src_port = UDP_DST_PORT_ipfix;
10121 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10123 if (unformat (i, "domain %d", &domain_id))
10125 else if (unformat (i, "src_port %d", &src_port))
10129 errmsg ("unknown input `%U'", format_unformat_error, i);
10134 M (SET_IPFIX_CLASSIFY_STREAM, mp);
10136 mp->domain_id = htonl (domain_id);
10137 mp->src_port = htons ((u16) src_port);
10145 api_ipfix_classify_table_add_del (vat_main_t * vam)
10147 unformat_input_t *i = vam->input;
10148 vl_api_ipfix_classify_table_add_del_t *mp;
10150 u32 classify_table_index = ~0;
10152 u8 transport_protocol = 255;
10155 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10157 if (unformat (i, "add"))
10159 else if (unformat (i, "del"))
10161 else if (unformat (i, "table %d", &classify_table_index))
10163 else if (unformat (i, "ip4"))
10165 else if (unformat (i, "ip6"))
10167 else if (unformat (i, "tcp"))
10168 transport_protocol = 6;
10169 else if (unformat (i, "udp"))
10170 transport_protocol = 17;
10173 errmsg ("unknown input `%U'", format_unformat_error, i);
10180 errmsg ("expecting: add|del");
10183 if (classify_table_index == ~0)
10185 errmsg ("classifier table not specified");
10188 if (ip_version == 0)
10190 errmsg ("IP version not specified");
10194 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, mp);
10196 mp->is_add = is_add;
10197 mp->table_id = htonl (classify_table_index);
10198 mp->ip_version = ip_version;
10199 mp->transport_protocol = transport_protocol;
10207 api_get_node_index (vat_main_t * vam)
10209 unformat_input_t *i = vam->input;
10210 vl_api_get_node_index_t *mp;
10214 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10216 if (unformat (i, "node %s", &name))
10223 errmsg ("node name required");
10226 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10228 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10232 M (GET_NODE_INDEX, mp);
10233 clib_memcpy (mp->node_name, name, vec_len (name));
10242 api_get_next_index (vat_main_t * vam)
10244 unformat_input_t *i = vam->input;
10245 vl_api_get_next_index_t *mp;
10246 u8 *node_name = 0, *next_node_name = 0;
10249 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10251 if (unformat (i, "node-name %s", &node_name))
10253 else if (unformat (i, "next-node-name %s", &next_node_name))
10257 if (node_name == 0)
10259 errmsg ("node name required");
10262 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
10264 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10268 if (next_node_name == 0)
10270 errmsg ("next node name required");
10273 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
10275 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
10279 M (GET_NEXT_INDEX, mp);
10280 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
10281 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
10282 vec_free (node_name);
10283 vec_free (next_node_name);
10291 api_add_node_next (vat_main_t * vam)
10293 unformat_input_t *i = vam->input;
10294 vl_api_add_node_next_t *mp;
10299 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10301 if (unformat (i, "node %s", &name))
10303 else if (unformat (i, "next %s", &next))
10310 errmsg ("node name required");
10313 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10315 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10320 errmsg ("next node required");
10323 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
10325 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
10329 M (ADD_NODE_NEXT, mp);
10330 clib_memcpy (mp->node_name, name, vec_len (name));
10331 clib_memcpy (mp->next_name, next, vec_len (next));
10341 api_l2tpv3_create_tunnel (vat_main_t * vam)
10343 unformat_input_t *i = vam->input;
10344 ip6_address_t client_address, our_address;
10345 int client_address_set = 0;
10346 int our_address_set = 0;
10347 u32 local_session_id = 0;
10348 u32 remote_session_id = 0;
10349 u64 local_cookie = 0;
10350 u64 remote_cookie = 0;
10351 u8 l2_sublayer_present = 0;
10352 vl_api_l2tpv3_create_tunnel_t *mp;
10355 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10357 if (unformat (i, "client_address %U", unformat_ip6_address,
10359 client_address_set = 1;
10360 else if (unformat (i, "our_address %U", unformat_ip6_address,
10362 our_address_set = 1;
10363 else if (unformat (i, "local_session_id %d", &local_session_id))
10365 else if (unformat (i, "remote_session_id %d", &remote_session_id))
10367 else if (unformat (i, "local_cookie %lld", &local_cookie))
10369 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
10371 else if (unformat (i, "l2-sublayer-present"))
10372 l2_sublayer_present = 1;
10377 if (client_address_set == 0)
10379 errmsg ("client_address required");
10383 if (our_address_set == 0)
10385 errmsg ("our_address required");
10389 M (L2TPV3_CREATE_TUNNEL, mp);
10391 clib_memcpy (mp->client_address, client_address.as_u8,
10392 sizeof (mp->client_address));
10394 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
10396 mp->local_session_id = ntohl (local_session_id);
10397 mp->remote_session_id = ntohl (remote_session_id);
10398 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
10399 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
10400 mp->l2_sublayer_present = l2_sublayer_present;
10409 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
10411 unformat_input_t *i = vam->input;
10413 u8 sw_if_index_set = 0;
10414 u64 new_local_cookie = 0;
10415 u64 new_remote_cookie = 0;
10416 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
10419 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10421 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10422 sw_if_index_set = 1;
10423 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10424 sw_if_index_set = 1;
10425 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
10427 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
10433 if (sw_if_index_set == 0)
10435 errmsg ("missing interface name or sw_if_index");
10439 M (L2TPV3_SET_TUNNEL_COOKIES, mp);
10441 mp->sw_if_index = ntohl (sw_if_index);
10442 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
10443 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
10451 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
10453 unformat_input_t *i = vam->input;
10454 vl_api_l2tpv3_interface_enable_disable_t *mp;
10456 u8 sw_if_index_set = 0;
10457 u8 enable_disable = 1;
10460 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10462 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10463 sw_if_index_set = 1;
10464 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10465 sw_if_index_set = 1;
10466 else if (unformat (i, "enable"))
10467 enable_disable = 1;
10468 else if (unformat (i, "disable"))
10469 enable_disable = 0;
10474 if (sw_if_index_set == 0)
10476 errmsg ("missing interface name or sw_if_index");
10480 M (L2TPV3_INTERFACE_ENABLE_DISABLE, mp);
10482 mp->sw_if_index = ntohl (sw_if_index);
10483 mp->enable_disable = enable_disable;
10491 api_l2tpv3_set_lookup_key (vat_main_t * vam)
10493 unformat_input_t *i = vam->input;
10494 vl_api_l2tpv3_set_lookup_key_t *mp;
10498 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10500 if (unformat (i, "lookup_v6_src"))
10501 key = L2T_LOOKUP_SRC_ADDRESS;
10502 else if (unformat (i, "lookup_v6_dst"))
10503 key = L2T_LOOKUP_DST_ADDRESS;
10504 else if (unformat (i, "lookup_session_id"))
10505 key = L2T_LOOKUP_SESSION_ID;
10510 if (key == (u8) ~ 0)
10512 errmsg ("l2tp session lookup key unset");
10516 M (L2TPV3_SET_LOOKUP_KEY, mp);
10525 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
10526 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
10528 vat_main_t *vam = &vat_main;
10530 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
10531 format_ip6_address, mp->our_address,
10532 format_ip6_address, mp->client_address,
10533 clib_net_to_host_u32 (mp->sw_if_index));
10536 " local cookies %016llx %016llx remote cookie %016llx",
10537 clib_net_to_host_u64 (mp->local_cookie[0]),
10538 clib_net_to_host_u64 (mp->local_cookie[1]),
10539 clib_net_to_host_u64 (mp->remote_cookie));
10541 print (vam->ofp, " local session-id %d remote session-id %d",
10542 clib_net_to_host_u32 (mp->local_session_id),
10543 clib_net_to_host_u32 (mp->remote_session_id));
10545 print (vam->ofp, " l2 specific sublayer %s\n",
10546 mp->l2_sublayer_present ? "preset" : "absent");
10550 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
10551 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
10553 vat_main_t *vam = &vat_main;
10554 vat_json_node_t *node = NULL;
10555 struct in6_addr addr;
10557 if (VAT_JSON_ARRAY != vam->json_tree.type)
10559 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10560 vat_json_init_array (&vam->json_tree);
10562 node = vat_json_array_add (&vam->json_tree);
10564 vat_json_init_object (node);
10566 clib_memcpy (&addr, mp->our_address, sizeof (addr));
10567 vat_json_object_add_ip6 (node, "our_address", addr);
10568 clib_memcpy (&addr, mp->client_address, sizeof (addr));
10569 vat_json_object_add_ip6 (node, "client_address", addr);
10571 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
10572 vat_json_init_array (lc);
10573 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
10574 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
10575 vat_json_object_add_uint (node, "remote_cookie",
10576 clib_net_to_host_u64 (mp->remote_cookie));
10578 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
10579 vat_json_object_add_uint (node, "local_session_id",
10580 clib_net_to_host_u32 (mp->local_session_id));
10581 vat_json_object_add_uint (node, "remote_session_id",
10582 clib_net_to_host_u32 (mp->remote_session_id));
10583 vat_json_object_add_string_copy (node, "l2_sublayer",
10584 mp->l2_sublayer_present ? (u8 *) "present"
10585 : (u8 *) "absent");
10589 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
10591 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
10592 vl_api_control_ping_t *mp_ping;
10595 /* Get list of l2tpv3-tunnel interfaces */
10596 M (SW_IF_L2TPV3_TUNNEL_DUMP, mp);
10599 /* Use a control ping for synchronization */
10600 M (CONTROL_PING, mp_ping);
10608 static void vl_api_sw_interface_tap_details_t_handler
10609 (vl_api_sw_interface_tap_details_t * mp)
10611 vat_main_t *vam = &vat_main;
10613 print (vam->ofp, "%-16s %d",
10614 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
10617 static void vl_api_sw_interface_tap_details_t_handler_json
10618 (vl_api_sw_interface_tap_details_t * mp)
10620 vat_main_t *vam = &vat_main;
10621 vat_json_node_t *node = NULL;
10623 if (VAT_JSON_ARRAY != vam->json_tree.type)
10625 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10626 vat_json_init_array (&vam->json_tree);
10628 node = vat_json_array_add (&vam->json_tree);
10630 vat_json_init_object (node);
10631 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10632 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
10636 api_sw_interface_tap_dump (vat_main_t * vam)
10638 vl_api_sw_interface_tap_dump_t *mp;
10639 vl_api_control_ping_t *mp_ping;
10642 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
10643 /* Get list of tap interfaces */
10644 M (SW_INTERFACE_TAP_DUMP, mp);
10647 /* Use a control ping for synchronization */
10648 M (CONTROL_PING, mp_ping);
10655 static uword unformat_vxlan_decap_next
10656 (unformat_input_t * input, va_list * args)
10658 u32 *result = va_arg (*args, u32 *);
10661 if (unformat (input, "l2"))
10662 *result = VXLAN_INPUT_NEXT_L2_INPUT;
10663 else if (unformat (input, "%d", &tmp))
10671 api_vxlan_add_del_tunnel (vat_main_t * vam)
10673 unformat_input_t *line_input = vam->input;
10674 vl_api_vxlan_add_del_tunnel_t *mp;
10675 ip46_address_t src, dst;
10677 u8 ipv4_set = 0, ipv6_set = 0;
10681 u32 mcast_sw_if_index = ~0;
10682 u32 encap_vrf_id = 0;
10683 u32 decap_next_index = ~0;
10687 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
10688 memset (&src, 0, sizeof src);
10689 memset (&dst, 0, sizeof dst);
10691 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10693 if (unformat (line_input, "del"))
10696 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
10702 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
10708 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
10714 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
10719 else if (unformat (line_input, "group %U %U",
10720 unformat_ip4_address, &dst.ip4,
10721 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
10723 grp_set = dst_set = 1;
10726 else if (unformat (line_input, "group %U",
10727 unformat_ip4_address, &dst.ip4))
10729 grp_set = dst_set = 1;
10732 else if (unformat (line_input, "group %U %U",
10733 unformat_ip6_address, &dst.ip6,
10734 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
10736 grp_set = dst_set = 1;
10739 else if (unformat (line_input, "group %U",
10740 unformat_ip6_address, &dst.ip6))
10742 grp_set = dst_set = 1;
10746 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
10748 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
10750 else if (unformat (line_input, "decap-next %U",
10751 unformat_vxlan_decap_next, &decap_next_index))
10753 else if (unformat (line_input, "vni %d", &vni))
10757 errmsg ("parse error '%U'", format_unformat_error, line_input);
10764 errmsg ("tunnel src address not specified");
10769 errmsg ("tunnel dst address not specified");
10773 if (grp_set && !ip46_address_is_multicast (&dst))
10775 errmsg ("tunnel group address not multicast");
10778 if (grp_set && mcast_sw_if_index == ~0)
10780 errmsg ("tunnel nonexistent multicast device");
10783 if (grp_set == 0 && ip46_address_is_multicast (&dst))
10785 errmsg ("tunnel dst address must be unicast");
10790 if (ipv4_set && ipv6_set)
10792 errmsg ("both IPv4 and IPv6 addresses specified");
10796 if ((vni == 0) || (vni >> 24))
10798 errmsg ("vni not specified or out of range");
10802 M (VXLAN_ADD_DEL_TUNNEL, mp);
10806 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
10807 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
10811 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
10812 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
10814 mp->encap_vrf_id = ntohl (encap_vrf_id);
10815 mp->decap_next_index = ntohl (decap_next_index);
10816 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
10817 mp->vni = ntohl (vni);
10818 mp->is_add = is_add;
10819 mp->is_ipv6 = ipv6_set;
10826 static void vl_api_vxlan_tunnel_details_t_handler
10827 (vl_api_vxlan_tunnel_details_t * mp)
10829 vat_main_t *vam = &vat_main;
10830 ip46_address_t src, dst;
10832 ip46_from_addr_buf (mp->is_ipv6, mp->src_address, &src);
10833 ip46_from_addr_buf (mp->is_ipv6, mp->dst_address, &dst);
10835 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
10836 ntohl (mp->sw_if_index),
10837 format_ip46_address, &src, IP46_TYPE_ANY,
10838 format_ip46_address, &dst, IP46_TYPE_ANY,
10839 ntohl (mp->encap_vrf_id),
10840 ntohl (mp->decap_next_index), ntohl (mp->vni),
10841 ntohl (mp->mcast_sw_if_index));
10844 static void vl_api_vxlan_tunnel_details_t_handler_json
10845 (vl_api_vxlan_tunnel_details_t * mp)
10847 vat_main_t *vam = &vat_main;
10848 vat_json_node_t *node = NULL;
10850 if (VAT_JSON_ARRAY != vam->json_tree.type)
10852 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10853 vat_json_init_array (&vam->json_tree);
10855 node = vat_json_array_add (&vam->json_tree);
10857 vat_json_init_object (node);
10858 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10861 struct in6_addr ip6;
10863 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
10864 vat_json_object_add_ip6 (node, "src_address", ip6);
10865 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
10866 vat_json_object_add_ip6 (node, "dst_address", ip6);
10870 struct in_addr ip4;
10872 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
10873 vat_json_object_add_ip4 (node, "src_address", ip4);
10874 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
10875 vat_json_object_add_ip4 (node, "dst_address", ip4);
10877 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
10878 vat_json_object_add_uint (node, "decap_next_index",
10879 ntohl (mp->decap_next_index));
10880 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
10881 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
10882 vat_json_object_add_uint (node, "mcast_sw_if_index",
10883 ntohl (mp->mcast_sw_if_index));
10887 api_vxlan_tunnel_dump (vat_main_t * vam)
10889 unformat_input_t *i = vam->input;
10890 vl_api_vxlan_tunnel_dump_t *mp;
10891 vl_api_control_ping_t *mp_ping;
10893 u8 sw_if_index_set = 0;
10896 /* Parse args required to build the message */
10897 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10899 if (unformat (i, "sw_if_index %d", &sw_if_index))
10900 sw_if_index_set = 1;
10905 if (sw_if_index_set == 0)
10910 if (!vam->json_output)
10912 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
10913 "sw_if_index", "src_address", "dst_address",
10914 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
10917 /* Get list of vxlan-tunnel interfaces */
10918 M (VXLAN_TUNNEL_DUMP, mp);
10920 mp->sw_if_index = htonl (sw_if_index);
10924 /* Use a control ping for synchronization */
10925 M (CONTROL_PING, mp_ping);
10933 api_gre_add_del_tunnel (vat_main_t * vam)
10935 unformat_input_t *line_input = vam->input;
10936 vl_api_gre_add_del_tunnel_t *mp;
10937 ip4_address_t src4, dst4;
10942 u32 outer_fib_id = 0;
10945 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10947 if (unformat (line_input, "del"))
10949 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
10951 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
10953 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
10955 else if (unformat (line_input, "teb"))
10959 errmsg ("parse error '%U'", format_unformat_error, line_input);
10966 errmsg ("tunnel src address not specified");
10971 errmsg ("tunnel dst address not specified");
10976 M (GRE_ADD_DEL_TUNNEL, mp);
10978 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
10979 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
10980 mp->outer_fib_id = ntohl (outer_fib_id);
10981 mp->is_add = is_add;
10989 static void vl_api_gre_tunnel_details_t_handler
10990 (vl_api_gre_tunnel_details_t * mp)
10992 vat_main_t *vam = &vat_main;
10994 print (vam->ofp, "%11d%15U%15U%6d%14d",
10995 ntohl (mp->sw_if_index),
10996 format_ip4_address, &mp->src_address,
10997 format_ip4_address, &mp->dst_address,
10998 mp->teb, ntohl (mp->outer_fib_id));
11001 static void vl_api_gre_tunnel_details_t_handler_json
11002 (vl_api_gre_tunnel_details_t * mp)
11004 vat_main_t *vam = &vat_main;
11005 vat_json_node_t *node = NULL;
11006 struct in_addr ip4;
11008 if (VAT_JSON_ARRAY != vam->json_tree.type)
11010 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11011 vat_json_init_array (&vam->json_tree);
11013 node = vat_json_array_add (&vam->json_tree);
11015 vat_json_init_object (node);
11016 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11017 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
11018 vat_json_object_add_ip4 (node, "src_address", ip4);
11019 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
11020 vat_json_object_add_ip4 (node, "dst_address", ip4);
11021 vat_json_object_add_uint (node, "teb", mp->teb);
11022 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
11026 api_gre_tunnel_dump (vat_main_t * vam)
11028 unformat_input_t *i = vam->input;
11029 vl_api_gre_tunnel_dump_t *mp;
11030 vl_api_control_ping_t *mp_ping;
11032 u8 sw_if_index_set = 0;
11035 /* Parse args required to build the message */
11036 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11038 if (unformat (i, "sw_if_index %d", &sw_if_index))
11039 sw_if_index_set = 1;
11044 if (sw_if_index_set == 0)
11049 if (!vam->json_output)
11051 print (vam->ofp, "%11s%15s%15s%6s%14s",
11052 "sw_if_index", "src_address", "dst_address", "teb",
11056 /* Get list of gre-tunnel interfaces */
11057 M (GRE_TUNNEL_DUMP, mp);
11059 mp->sw_if_index = htonl (sw_if_index);
11063 /* Use a control ping for synchronization */
11064 M (CONTROL_PING, mp_ping);
11072 api_l2_fib_clear_table (vat_main_t * vam)
11074 // unformat_input_t * i = vam->input;
11075 vl_api_l2_fib_clear_table_t *mp;
11078 M (L2_FIB_CLEAR_TABLE, mp);
11086 api_l2_interface_efp_filter (vat_main_t * vam)
11088 unformat_input_t *i = vam->input;
11089 vl_api_l2_interface_efp_filter_t *mp;
11092 u8 sw_if_index_set = 0;
11095 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11097 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11098 sw_if_index_set = 1;
11099 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11100 sw_if_index_set = 1;
11101 else if (unformat (i, "enable"))
11103 else if (unformat (i, "disable"))
11107 clib_warning ("parse error '%U'", format_unformat_error, i);
11112 if (sw_if_index_set == 0)
11114 errmsg ("missing sw_if_index");
11118 M (L2_INTERFACE_EFP_FILTER, mp);
11120 mp->sw_if_index = ntohl (sw_if_index);
11121 mp->enable_disable = enable;
11128 #define foreach_vtr_op \
11129 _("disable", L2_VTR_DISABLED) \
11130 _("push-1", L2_VTR_PUSH_1) \
11131 _("push-2", L2_VTR_PUSH_2) \
11132 _("pop-1", L2_VTR_POP_1) \
11133 _("pop-2", L2_VTR_POP_2) \
11134 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
11135 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
11136 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
11137 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
11140 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
11142 unformat_input_t *i = vam->input;
11143 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
11145 u8 sw_if_index_set = 0;
11148 u32 push_dot1q = 1;
11153 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11155 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11156 sw_if_index_set = 1;
11157 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11158 sw_if_index_set = 1;
11159 else if (unformat (i, "vtr_op %d", &vtr_op))
11161 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
11164 else if (unformat (i, "push_dot1q %d", &push_dot1q))
11166 else if (unformat (i, "tag1 %d", &tag1))
11168 else if (unformat (i, "tag2 %d", &tag2))
11172 clib_warning ("parse error '%U'", format_unformat_error, i);
11177 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
11179 errmsg ("missing vtr operation or sw_if_index");
11183 M (L2_INTERFACE_VLAN_TAG_REWRITE, mp);
11184 mp->sw_if_index = ntohl (sw_if_index);
11185 mp->vtr_op = ntohl (vtr_op);
11186 mp->push_dot1q = ntohl (push_dot1q);
11187 mp->tag1 = ntohl (tag1);
11188 mp->tag2 = ntohl (tag2);
11196 api_create_vhost_user_if (vat_main_t * vam)
11198 unformat_input_t *i = vam->input;
11199 vl_api_create_vhost_user_if_t *mp;
11202 u8 file_name_set = 0;
11203 u32 custom_dev_instance = ~0;
11205 u8 use_custom_mac = 0;
11209 /* Shut up coverity */
11210 memset (hwaddr, 0, sizeof (hwaddr));
11212 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11214 if (unformat (i, "socket %s", &file_name))
11218 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
11220 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
11221 use_custom_mac = 1;
11222 else if (unformat (i, "server"))
11224 else if (unformat (i, "tag %s", &tag))
11230 if (file_name_set == 0)
11232 errmsg ("missing socket file name");
11236 if (vec_len (file_name) > 255)
11238 errmsg ("socket file name too long");
11241 vec_add1 (file_name, 0);
11243 M (CREATE_VHOST_USER_IF, mp);
11245 mp->is_server = is_server;
11246 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
11247 vec_free (file_name);
11248 if (custom_dev_instance != ~0)
11251 mp->custom_dev_instance = ntohl (custom_dev_instance);
11253 mp->use_custom_mac = use_custom_mac;
11254 clib_memcpy (mp->mac_address, hwaddr, 6);
11256 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
11265 api_modify_vhost_user_if (vat_main_t * vam)
11267 unformat_input_t *i = vam->input;
11268 vl_api_modify_vhost_user_if_t *mp;
11271 u8 file_name_set = 0;
11272 u32 custom_dev_instance = ~0;
11273 u8 sw_if_index_set = 0;
11274 u32 sw_if_index = (u32) ~ 0;
11277 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11279 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11280 sw_if_index_set = 1;
11281 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11282 sw_if_index_set = 1;
11283 else if (unformat (i, "socket %s", &file_name))
11287 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
11289 else if (unformat (i, "server"))
11295 if (sw_if_index_set == 0)
11297 errmsg ("missing sw_if_index or interface name");
11301 if (file_name_set == 0)
11303 errmsg ("missing socket file name");
11307 if (vec_len (file_name) > 255)
11309 errmsg ("socket file name too long");
11312 vec_add1 (file_name, 0);
11314 M (MODIFY_VHOST_USER_IF, mp);
11316 mp->sw_if_index = ntohl (sw_if_index);
11317 mp->is_server = is_server;
11318 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
11319 vec_free (file_name);
11320 if (custom_dev_instance != ~0)
11323 mp->custom_dev_instance = ntohl (custom_dev_instance);
11332 api_delete_vhost_user_if (vat_main_t * vam)
11334 unformat_input_t *i = vam->input;
11335 vl_api_delete_vhost_user_if_t *mp;
11336 u32 sw_if_index = ~0;
11337 u8 sw_if_index_set = 0;
11340 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11342 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11343 sw_if_index_set = 1;
11344 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11345 sw_if_index_set = 1;
11350 if (sw_if_index_set == 0)
11352 errmsg ("missing sw_if_index or interface name");
11357 M (DELETE_VHOST_USER_IF, mp);
11359 mp->sw_if_index = ntohl (sw_if_index);
11366 static void vl_api_sw_interface_vhost_user_details_t_handler
11367 (vl_api_sw_interface_vhost_user_details_t * mp)
11369 vat_main_t *vam = &vat_main;
11371 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
11372 (char *) mp->interface_name,
11373 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
11374 clib_net_to_host_u64 (mp->features), mp->is_server,
11375 ntohl (mp->num_regions), (char *) mp->sock_filename);
11376 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
11379 static void vl_api_sw_interface_vhost_user_details_t_handler_json
11380 (vl_api_sw_interface_vhost_user_details_t * mp)
11382 vat_main_t *vam = &vat_main;
11383 vat_json_node_t *node = NULL;
11385 if (VAT_JSON_ARRAY != vam->json_tree.type)
11387 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11388 vat_json_init_array (&vam->json_tree);
11390 node = vat_json_array_add (&vam->json_tree);
11392 vat_json_init_object (node);
11393 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11394 vat_json_object_add_string_copy (node, "interface_name",
11395 mp->interface_name);
11396 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
11397 ntohl (mp->virtio_net_hdr_sz));
11398 vat_json_object_add_uint (node, "features",
11399 clib_net_to_host_u64 (mp->features));
11400 vat_json_object_add_uint (node, "is_server", mp->is_server);
11401 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
11402 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
11403 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
11407 api_sw_interface_vhost_user_dump (vat_main_t * vam)
11409 vl_api_sw_interface_vhost_user_dump_t *mp;
11410 vl_api_control_ping_t *mp_ping;
11413 "Interface name idx hdr_sz features server regions filename");
11415 /* Get list of vhost-user interfaces */
11416 M (SW_INTERFACE_VHOST_USER_DUMP, mp);
11419 /* Use a control ping for synchronization */
11420 M (CONTROL_PING, mp_ping);
11428 api_show_version (vat_main_t * vam)
11430 vl_api_show_version_t *mp;
11433 M (SHOW_VERSION, mp);
11442 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
11444 unformat_input_t *line_input = vam->input;
11445 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
11446 ip4_address_t local4, remote4;
11447 ip6_address_t local6, remote6;
11449 u8 ipv4_set = 0, ipv6_set = 0;
11452 u32 encap_vrf_id = 0;
11453 u32 decap_vrf_id = 0;
11459 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11461 if (unformat (line_input, "del"))
11463 else if (unformat (line_input, "local %U",
11464 unformat_ip4_address, &local4))
11469 else if (unformat (line_input, "remote %U",
11470 unformat_ip4_address, &remote4))
11475 else if (unformat (line_input, "local %U",
11476 unformat_ip6_address, &local6))
11481 else if (unformat (line_input, "remote %U",
11482 unformat_ip6_address, &remote6))
11487 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11489 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
11491 else if (unformat (line_input, "vni %d", &vni))
11493 else if (unformat (line_input, "next-ip4"))
11495 else if (unformat (line_input, "next-ip6"))
11497 else if (unformat (line_input, "next-ethernet"))
11499 else if (unformat (line_input, "next-nsh"))
11503 errmsg ("parse error '%U'", format_unformat_error, line_input);
11508 if (local_set == 0)
11510 errmsg ("tunnel local address not specified");
11513 if (remote_set == 0)
11515 errmsg ("tunnel remote address not specified");
11518 if (ipv4_set && ipv6_set)
11520 errmsg ("both IPv4 and IPv6 addresses specified");
11526 errmsg ("vni not specified");
11530 M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
11535 clib_memcpy (&mp->local, &local6, sizeof (local6));
11536 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
11540 clib_memcpy (&mp->local, &local4, sizeof (local4));
11541 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
11544 mp->encap_vrf_id = ntohl (encap_vrf_id);
11545 mp->decap_vrf_id = ntohl (decap_vrf_id);
11546 mp->protocol = protocol;
11547 mp->vni = ntohl (vni);
11548 mp->is_add = is_add;
11549 mp->is_ipv6 = ipv6_set;
11556 static void vl_api_vxlan_gpe_tunnel_details_t_handler
11557 (vl_api_vxlan_gpe_tunnel_details_t * mp)
11559 vat_main_t *vam = &vat_main;
11561 print (vam->ofp, "%11d%24U%24U%13d%12d%14d%14d",
11562 ntohl (mp->sw_if_index),
11563 format_ip46_address, &(mp->local[0]),
11564 format_ip46_address, &(mp->remote[0]),
11566 ntohl (mp->protocol),
11567 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
11570 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
11571 (vl_api_vxlan_gpe_tunnel_details_t * mp)
11573 vat_main_t *vam = &vat_main;
11574 vat_json_node_t *node = NULL;
11575 struct in_addr ip4;
11576 struct in6_addr ip6;
11578 if (VAT_JSON_ARRAY != vam->json_tree.type)
11580 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11581 vat_json_init_array (&vam->json_tree);
11583 node = vat_json_array_add (&vam->json_tree);
11585 vat_json_init_object (node);
11586 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11589 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
11590 vat_json_object_add_ip6 (node, "local", ip6);
11591 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
11592 vat_json_object_add_ip6 (node, "remote", ip6);
11596 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
11597 vat_json_object_add_ip4 (node, "local", ip4);
11598 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
11599 vat_json_object_add_ip4 (node, "remote", ip4);
11601 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
11602 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
11603 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
11604 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
11605 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
11609 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
11611 unformat_input_t *i = vam->input;
11612 vl_api_vxlan_gpe_tunnel_dump_t *mp;
11613 vl_api_control_ping_t *mp_ping;
11615 u8 sw_if_index_set = 0;
11618 /* Parse args required to build the message */
11619 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11621 if (unformat (i, "sw_if_index %d", &sw_if_index))
11622 sw_if_index_set = 1;
11627 if (sw_if_index_set == 0)
11632 if (!vam->json_output)
11634 print (vam->ofp, "%11s%24s%24s%13s%15s%14s%14s",
11635 "sw_if_index", "local", "remote", "vni",
11636 "protocol", "encap_vrf_id", "decap_vrf_id");
11639 /* Get list of vxlan-tunnel interfaces */
11640 M (VXLAN_GPE_TUNNEL_DUMP, mp);
11642 mp->sw_if_index = htonl (sw_if_index);
11646 /* Use a control ping for synchronization */
11647 M (CONTROL_PING, mp_ping);
11655 format_l2_fib_mac_address (u8 * s, va_list * args)
11657 u8 *a = va_arg (*args, u8 *);
11659 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
11660 a[2], a[3], a[4], a[5], a[6], a[7]);
11663 static void vl_api_l2_fib_table_entry_t_handler
11664 (vl_api_l2_fib_table_entry_t * mp)
11666 vat_main_t *vam = &vat_main;
11668 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
11670 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
11671 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
11675 static void vl_api_l2_fib_table_entry_t_handler_json
11676 (vl_api_l2_fib_table_entry_t * mp)
11678 vat_main_t *vam = &vat_main;
11679 vat_json_node_t *node = NULL;
11681 if (VAT_JSON_ARRAY != vam->json_tree.type)
11683 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11684 vat_json_init_array (&vam->json_tree);
11686 node = vat_json_array_add (&vam->json_tree);
11688 vat_json_init_object (node);
11689 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
11690 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
11691 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11692 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
11693 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
11694 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
11698 api_l2_fib_table_dump (vat_main_t * vam)
11700 unformat_input_t *i = vam->input;
11701 vl_api_l2_fib_table_dump_t *mp;
11702 vl_api_control_ping_t *mp_ping;
11707 /* Parse args required to build the message */
11708 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11710 if (unformat (i, "bd_id %d", &bd_id))
11716 if (bd_id_set == 0)
11718 errmsg ("missing bridge domain");
11722 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
11724 /* Get list of l2 fib entries */
11725 M (L2_FIB_TABLE_DUMP, mp);
11727 mp->bd_id = ntohl (bd_id);
11730 /* Use a control ping for synchronization */
11731 M (CONTROL_PING, mp_ping);
11740 api_interface_name_renumber (vat_main_t * vam)
11742 unformat_input_t *line_input = vam->input;
11743 vl_api_interface_name_renumber_t *mp;
11744 u32 sw_if_index = ~0;
11745 u32 new_show_dev_instance = ~0;
11748 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11750 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
11753 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11755 else if (unformat (line_input, "new_show_dev_instance %d",
11756 &new_show_dev_instance))
11762 if (sw_if_index == ~0)
11764 errmsg ("missing interface name or sw_if_index");
11768 if (new_show_dev_instance == ~0)
11770 errmsg ("missing new_show_dev_instance");
11774 M (INTERFACE_NAME_RENUMBER, mp);
11776 mp->sw_if_index = ntohl (sw_if_index);
11777 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
11785 api_want_ip4_arp_events (vat_main_t * vam)
11787 unformat_input_t *line_input = vam->input;
11788 vl_api_want_ip4_arp_events_t *mp;
11789 ip4_address_t address;
11790 int address_set = 0;
11791 u32 enable_disable = 1;
11794 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11796 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
11798 else if (unformat (line_input, "del"))
11799 enable_disable = 0;
11804 if (address_set == 0)
11806 errmsg ("missing addresses");
11810 M (WANT_IP4_ARP_EVENTS, mp);
11811 mp->enable_disable = enable_disable;
11812 mp->pid = getpid ();
11813 mp->address = address.as_u32;
11821 api_want_ip6_nd_events (vat_main_t * vam)
11823 unformat_input_t *line_input = vam->input;
11824 vl_api_want_ip6_nd_events_t *mp;
11825 ip6_address_t address;
11826 int address_set = 0;
11827 u32 enable_disable = 1;
11830 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11832 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
11834 else if (unformat (line_input, "del"))
11835 enable_disable = 0;
11840 if (address_set == 0)
11842 errmsg ("missing addresses");
11846 M (WANT_IP6_ND_EVENTS, mp);
11847 mp->enable_disable = enable_disable;
11848 mp->pid = getpid ();
11849 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
11857 api_input_acl_set_interface (vat_main_t * vam)
11859 unformat_input_t *i = vam->input;
11860 vl_api_input_acl_set_interface_t *mp;
11862 int sw_if_index_set;
11863 u32 ip4_table_index = ~0;
11864 u32 ip6_table_index = ~0;
11865 u32 l2_table_index = ~0;
11869 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11871 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11872 sw_if_index_set = 1;
11873 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11874 sw_if_index_set = 1;
11875 else if (unformat (i, "del"))
11877 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11879 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11881 else if (unformat (i, "l2-table %d", &l2_table_index))
11885 clib_warning ("parse error '%U'", format_unformat_error, i);
11890 if (sw_if_index_set == 0)
11892 errmsg ("missing interface name or sw_if_index");
11896 M (INPUT_ACL_SET_INTERFACE, mp);
11898 mp->sw_if_index = ntohl (sw_if_index);
11899 mp->ip4_table_index = ntohl (ip4_table_index);
11900 mp->ip6_table_index = ntohl (ip6_table_index);
11901 mp->l2_table_index = ntohl (l2_table_index);
11902 mp->is_add = is_add;
11910 api_ip_address_dump (vat_main_t * vam)
11912 unformat_input_t *i = vam->input;
11913 vl_api_ip_address_dump_t *mp;
11914 vl_api_control_ping_t *mp_ping;
11915 u32 sw_if_index = ~0;
11916 u8 sw_if_index_set = 0;
11921 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11923 if (unformat (i, "sw_if_index %d", &sw_if_index))
11924 sw_if_index_set = 1;
11926 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11927 sw_if_index_set = 1;
11928 else if (unformat (i, "ipv4"))
11930 else if (unformat (i, "ipv6"))
11936 if (ipv4_set && ipv6_set)
11938 errmsg ("ipv4 and ipv6 flags cannot be both set");
11942 if ((!ipv4_set) && (!ipv6_set))
11944 errmsg ("no ipv4 nor ipv6 flag set");
11948 if (sw_if_index_set == 0)
11950 errmsg ("missing interface name or sw_if_index");
11954 vam->current_sw_if_index = sw_if_index;
11955 vam->is_ipv6 = ipv6_set;
11957 M (IP_ADDRESS_DUMP, mp);
11958 mp->sw_if_index = ntohl (sw_if_index);
11959 mp->is_ipv6 = ipv6_set;
11962 /* Use a control ping for synchronization */
11963 M (CONTROL_PING, mp_ping);
11971 api_ip_dump (vat_main_t * vam)
11973 vl_api_ip_dump_t *mp;
11974 vl_api_control_ping_t *mp_ping;
11975 unformat_input_t *in = vam->input;
11982 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
11984 if (unformat (in, "ipv4"))
11986 else if (unformat (in, "ipv6"))
11992 if (ipv4_set && ipv6_set)
11994 errmsg ("ipv4 and ipv6 flags cannot be both set");
11998 if ((!ipv4_set) && (!ipv6_set))
12000 errmsg ("no ipv4 nor ipv6 flag set");
12004 is_ipv6 = ipv6_set;
12005 vam->is_ipv6 = is_ipv6;
12007 /* free old data */
12008 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
12010 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
12012 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
12015 mp->is_ipv6 = ipv6_set;
12018 /* Use a control ping for synchronization */
12019 M (CONTROL_PING, mp_ping);
12027 api_ipsec_spd_add_del (vat_main_t * vam)
12029 unformat_input_t *i = vam->input;
12030 vl_api_ipsec_spd_add_del_t *mp;
12035 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12037 if (unformat (i, "spd_id %d", &spd_id))
12039 else if (unformat (i, "del"))
12043 clib_warning ("parse error '%U'", format_unformat_error, i);
12049 errmsg ("spd_id must be set");
12053 M (IPSEC_SPD_ADD_DEL, mp);
12055 mp->spd_id = ntohl (spd_id);
12056 mp->is_add = is_add;
12064 api_ipsec_interface_add_del_spd (vat_main_t * vam)
12066 unformat_input_t *i = vam->input;
12067 vl_api_ipsec_interface_add_del_spd_t *mp;
12069 u8 sw_if_index_set = 0;
12070 u32 spd_id = (u32) ~ 0;
12074 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12076 if (unformat (i, "del"))
12078 else if (unformat (i, "spd_id %d", &spd_id))
12081 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12082 sw_if_index_set = 1;
12083 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12084 sw_if_index_set = 1;
12087 clib_warning ("parse error '%U'", format_unformat_error, i);
12093 if (spd_id == (u32) ~ 0)
12095 errmsg ("spd_id must be set");
12099 if (sw_if_index_set == 0)
12101 errmsg ("missing interface name or sw_if_index");
12105 M (IPSEC_INTERFACE_ADD_DEL_SPD, mp);
12107 mp->spd_id = ntohl (spd_id);
12108 mp->sw_if_index = ntohl (sw_if_index);
12109 mp->is_add = is_add;
12117 api_ipsec_spd_add_del_entry (vat_main_t * vam)
12119 unformat_input_t *i = vam->input;
12120 vl_api_ipsec_spd_add_del_entry_t *mp;
12121 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
12122 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
12124 u32 rport_start = 0, rport_stop = (u32) ~ 0;
12125 u32 lport_start = 0, lport_stop = (u32) ~ 0;
12126 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
12127 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
12130 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
12131 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
12132 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
12133 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
12134 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
12135 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
12137 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12139 if (unformat (i, "del"))
12141 if (unformat (i, "outbound"))
12143 if (unformat (i, "inbound"))
12145 else if (unformat (i, "spd_id %d", &spd_id))
12147 else if (unformat (i, "sa_id %d", &sa_id))
12149 else if (unformat (i, "priority %d", &priority))
12151 else if (unformat (i, "protocol %d", &protocol))
12153 else if (unformat (i, "lport_start %d", &lport_start))
12155 else if (unformat (i, "lport_stop %d", &lport_stop))
12157 else if (unformat (i, "rport_start %d", &rport_start))
12159 else if (unformat (i, "rport_stop %d", &rport_stop))
12163 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
12169 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
12176 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
12182 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
12189 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
12195 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
12202 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
12208 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
12214 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
12216 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
12218 clib_warning ("unsupported action: 'resolve'");
12224 clib_warning ("parse error '%U'", format_unformat_error, i);
12230 M (IPSEC_SPD_ADD_DEL_ENTRY, mp);
12232 mp->spd_id = ntohl (spd_id);
12233 mp->priority = ntohl (priority);
12234 mp->is_outbound = is_outbound;
12236 mp->is_ipv6 = is_ipv6;
12237 if (is_ipv6 || is_ip_any)
12239 clib_memcpy (mp->remote_address_start, &raddr6_start,
12240 sizeof (ip6_address_t));
12241 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
12242 sizeof (ip6_address_t));
12243 clib_memcpy (mp->local_address_start, &laddr6_start,
12244 sizeof (ip6_address_t));
12245 clib_memcpy (mp->local_address_stop, &laddr6_stop,
12246 sizeof (ip6_address_t));
12250 clib_memcpy (mp->remote_address_start, &raddr4_start,
12251 sizeof (ip4_address_t));
12252 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
12253 sizeof (ip4_address_t));
12254 clib_memcpy (mp->local_address_start, &laddr4_start,
12255 sizeof (ip4_address_t));
12256 clib_memcpy (mp->local_address_stop, &laddr4_stop,
12257 sizeof (ip4_address_t));
12259 mp->protocol = (u8) protocol;
12260 mp->local_port_start = ntohs ((u16) lport_start);
12261 mp->local_port_stop = ntohs ((u16) lport_stop);
12262 mp->remote_port_start = ntohs ((u16) rport_start);
12263 mp->remote_port_stop = ntohs ((u16) rport_stop);
12264 mp->policy = (u8) policy;
12265 mp->sa_id = ntohl (sa_id);
12266 mp->is_add = is_add;
12267 mp->is_ip_any = is_ip_any;
12274 api_ipsec_sad_add_del_entry (vat_main_t * vam)
12276 unformat_input_t *i = vam->input;
12277 vl_api_ipsec_sad_add_del_entry_t *mp;
12278 u32 sad_id = 0, spi = 0;
12279 u8 *ck = 0, *ik = 0;
12282 u8 protocol = IPSEC_PROTOCOL_AH;
12283 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
12284 u32 crypto_alg = 0, integ_alg = 0;
12285 ip4_address_t tun_src4;
12286 ip4_address_t tun_dst4;
12287 ip6_address_t tun_src6;
12288 ip6_address_t tun_dst6;
12291 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12293 if (unformat (i, "del"))
12295 else if (unformat (i, "sad_id %d", &sad_id))
12297 else if (unformat (i, "spi %d", &spi))
12299 else if (unformat (i, "esp"))
12300 protocol = IPSEC_PROTOCOL_ESP;
12301 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
12304 is_tunnel_ipv6 = 0;
12306 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
12309 is_tunnel_ipv6 = 0;
12311 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
12314 is_tunnel_ipv6 = 1;
12316 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
12319 is_tunnel_ipv6 = 1;
12323 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
12325 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
12326 crypto_alg >= IPSEC_CRYPTO_N_ALG)
12328 clib_warning ("unsupported crypto-alg: '%U'",
12329 format_ipsec_crypto_alg, crypto_alg);
12333 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
12337 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
12339 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
12340 integ_alg >= IPSEC_INTEG_N_ALG)
12342 clib_warning ("unsupported integ-alg: '%U'",
12343 format_ipsec_integ_alg, integ_alg);
12347 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
12351 clib_warning ("parse error '%U'", format_unformat_error, i);
12357 M (IPSEC_SAD_ADD_DEL_ENTRY, mp);
12359 mp->sad_id = ntohl (sad_id);
12360 mp->is_add = is_add;
12361 mp->protocol = protocol;
12362 mp->spi = ntohl (spi);
12363 mp->is_tunnel = is_tunnel;
12364 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
12365 mp->crypto_algorithm = crypto_alg;
12366 mp->integrity_algorithm = integ_alg;
12367 mp->crypto_key_length = vec_len (ck);
12368 mp->integrity_key_length = vec_len (ik);
12370 if (mp->crypto_key_length > sizeof (mp->crypto_key))
12371 mp->crypto_key_length = sizeof (mp->crypto_key);
12373 if (mp->integrity_key_length > sizeof (mp->integrity_key))
12374 mp->integrity_key_length = sizeof (mp->integrity_key);
12377 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
12379 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
12383 if (is_tunnel_ipv6)
12385 clib_memcpy (mp->tunnel_src_address, &tun_src6,
12386 sizeof (ip6_address_t));
12387 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
12388 sizeof (ip6_address_t));
12392 clib_memcpy (mp->tunnel_src_address, &tun_src4,
12393 sizeof (ip4_address_t));
12394 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
12395 sizeof (ip4_address_t));
12405 api_ipsec_sa_set_key (vat_main_t * vam)
12407 unformat_input_t *i = vam->input;
12408 vl_api_ipsec_sa_set_key_t *mp;
12410 u8 *ck = 0, *ik = 0;
12413 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12415 if (unformat (i, "sa_id %d", &sa_id))
12417 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
12419 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
12423 clib_warning ("parse error '%U'", format_unformat_error, i);
12428 M (IPSEC_SA_SET_KEY, mp);
12430 mp->sa_id = ntohl (sa_id);
12431 mp->crypto_key_length = vec_len (ck);
12432 mp->integrity_key_length = vec_len (ik);
12434 if (mp->crypto_key_length > sizeof (mp->crypto_key))
12435 mp->crypto_key_length = sizeof (mp->crypto_key);
12437 if (mp->integrity_key_length > sizeof (mp->integrity_key))
12438 mp->integrity_key_length = sizeof (mp->integrity_key);
12441 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
12443 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
12451 api_ikev2_profile_add_del (vat_main_t * vam)
12453 unformat_input_t *i = vam->input;
12454 vl_api_ikev2_profile_add_del_t *mp;
12459 const char *valid_chars = "a-zA-Z0-9_";
12461 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12463 if (unformat (i, "del"))
12465 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12466 vec_add1 (name, 0);
12469 errmsg ("parse error '%U'", format_unformat_error, i);
12474 if (!vec_len (name))
12476 errmsg ("profile name must be specified");
12480 if (vec_len (name) > 64)
12482 errmsg ("profile name too long");
12486 M (IKEV2_PROFILE_ADD_DEL, mp);
12488 clib_memcpy (mp->name, name, vec_len (name));
12489 mp->is_add = is_add;
12498 api_ikev2_profile_set_auth (vat_main_t * vam)
12500 unformat_input_t *i = vam->input;
12501 vl_api_ikev2_profile_set_auth_t *mp;
12504 u32 auth_method = 0;
12508 const char *valid_chars = "a-zA-Z0-9_";
12510 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12512 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12513 vec_add1 (name, 0);
12514 else if (unformat (i, "auth_method %U",
12515 unformat_ikev2_auth_method, &auth_method))
12517 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
12519 else if (unformat (i, "auth_data %v", &data))
12523 errmsg ("parse error '%U'", format_unformat_error, i);
12528 if (!vec_len (name))
12530 errmsg ("profile name must be specified");
12534 if (vec_len (name) > 64)
12536 errmsg ("profile name too long");
12540 if (!vec_len (data))
12542 errmsg ("auth_data must be specified");
12548 errmsg ("auth_method must be specified");
12552 M (IKEV2_PROFILE_SET_AUTH, mp);
12554 mp->is_hex = is_hex;
12555 mp->auth_method = (u8) auth_method;
12556 mp->data_len = vec_len (data);
12557 clib_memcpy (mp->name, name, vec_len (name));
12558 clib_memcpy (mp->data, data, vec_len (data));
12568 api_ikev2_profile_set_id (vat_main_t * vam)
12570 unformat_input_t *i = vam->input;
12571 vl_api_ikev2_profile_set_id_t *mp;
12579 const char *valid_chars = "a-zA-Z0-9_";
12581 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12583 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12584 vec_add1 (name, 0);
12585 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
12587 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
12589 data = vec_new (u8, 4);
12590 clib_memcpy (data, ip4.as_u8, 4);
12592 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
12594 else if (unformat (i, "id_data %v", &data))
12596 else if (unformat (i, "local"))
12598 else if (unformat (i, "remote"))
12602 errmsg ("parse error '%U'", format_unformat_error, i);
12607 if (!vec_len (name))
12609 errmsg ("profile name must be specified");
12613 if (vec_len (name) > 64)
12615 errmsg ("profile name too long");
12619 if (!vec_len (data))
12621 errmsg ("id_data must be specified");
12627 errmsg ("id_type must be specified");
12631 M (IKEV2_PROFILE_SET_ID, mp);
12633 mp->is_local = is_local;
12634 mp->id_type = (u8) id_type;
12635 mp->data_len = vec_len (data);
12636 clib_memcpy (mp->name, name, vec_len (name));
12637 clib_memcpy (mp->data, data, vec_len (data));
12647 api_ikev2_profile_set_ts (vat_main_t * vam)
12649 unformat_input_t *i = vam->input;
12650 vl_api_ikev2_profile_set_ts_t *mp;
12653 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
12654 ip4_address_t start_addr, end_addr;
12656 const char *valid_chars = "a-zA-Z0-9_";
12659 start_addr.as_u32 = 0;
12660 end_addr.as_u32 = (u32) ~ 0;
12662 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12664 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12665 vec_add1 (name, 0);
12666 else if (unformat (i, "protocol %d", &proto))
12668 else if (unformat (i, "start_port %d", &start_port))
12670 else if (unformat (i, "end_port %d", &end_port))
12673 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
12675 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
12677 else if (unformat (i, "local"))
12679 else if (unformat (i, "remote"))
12683 errmsg ("parse error '%U'", format_unformat_error, i);
12688 if (!vec_len (name))
12690 errmsg ("profile name must be specified");
12694 if (vec_len (name) > 64)
12696 errmsg ("profile name too long");
12700 M (IKEV2_PROFILE_SET_TS, mp);
12702 mp->is_local = is_local;
12703 mp->proto = (u8) proto;
12704 mp->start_port = (u16) start_port;
12705 mp->end_port = (u16) end_port;
12706 mp->start_addr = start_addr.as_u32;
12707 mp->end_addr = end_addr.as_u32;
12708 clib_memcpy (mp->name, name, vec_len (name));
12717 api_ikev2_set_local_key (vat_main_t * vam)
12719 unformat_input_t *i = vam->input;
12720 vl_api_ikev2_set_local_key_t *mp;
12724 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12726 if (unformat (i, "file %v", &file))
12727 vec_add1 (file, 0);
12730 errmsg ("parse error '%U'", format_unformat_error, i);
12735 if (!vec_len (file))
12737 errmsg ("RSA key file must be specified");
12741 if (vec_len (file) > 256)
12743 errmsg ("file name too long");
12747 M (IKEV2_SET_LOCAL_KEY, mp);
12749 clib_memcpy (mp->key_file, file, vec_len (file));
12758 api_ikev2_set_responder (vat_main_t * vam)
12760 unformat_input_t *i = vam->input;
12761 vl_api_ikev2_set_responder_t *mp;
12764 u32 sw_if_index = ~0;
12765 ip4_address_t address;
12767 const char *valid_chars = "a-zA-Z0-9_";
12769 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12772 (i, "%U interface %d address %U", unformat_token, valid_chars,
12773 &name, &sw_if_index, unformat_ip4_address, &address))
12774 vec_add1 (name, 0);
12777 errmsg ("parse error '%U'", format_unformat_error, i);
12782 if (!vec_len (name))
12784 errmsg ("profile name must be specified");
12788 if (vec_len (name) > 64)
12790 errmsg ("profile name too long");
12794 M (IKEV2_SET_RESPONDER, mp);
12796 clib_memcpy (mp->name, name, vec_len (name));
12799 mp->sw_if_index = sw_if_index;
12800 clib_memcpy (mp->address, &address, sizeof (address));
12808 api_ikev2_set_ike_transforms (vat_main_t * vam)
12810 unformat_input_t *i = vam->input;
12811 vl_api_ikev2_set_ike_transforms_t *mp;
12814 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
12816 const char *valid_chars = "a-zA-Z0-9_";
12818 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12820 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
12821 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
12822 vec_add1 (name, 0);
12825 errmsg ("parse error '%U'", format_unformat_error, i);
12830 if (!vec_len (name))
12832 errmsg ("profile name must be specified");
12836 if (vec_len (name) > 64)
12838 errmsg ("profile name too long");
12842 M (IKEV2_SET_IKE_TRANSFORMS, mp);
12844 clib_memcpy (mp->name, name, vec_len (name));
12846 mp->crypto_alg = crypto_alg;
12847 mp->crypto_key_size = crypto_key_size;
12848 mp->integ_alg = integ_alg;
12849 mp->dh_group = dh_group;
12858 api_ikev2_set_esp_transforms (vat_main_t * vam)
12860 unformat_input_t *i = vam->input;
12861 vl_api_ikev2_set_esp_transforms_t *mp;
12864 u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
12866 const char *valid_chars = "a-zA-Z0-9_";
12868 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12870 if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
12871 &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
12872 vec_add1 (name, 0);
12875 errmsg ("parse error '%U'", format_unformat_error, i);
12880 if (!vec_len (name))
12882 errmsg ("profile name must be specified");
12886 if (vec_len (name) > 64)
12888 errmsg ("profile name too long");
12892 M (IKEV2_SET_ESP_TRANSFORMS, mp);
12894 clib_memcpy (mp->name, name, vec_len (name));
12896 mp->crypto_alg = crypto_alg;
12897 mp->crypto_key_size = crypto_key_size;
12898 mp->integ_alg = integ_alg;
12899 mp->dh_group = dh_group;
12907 api_ikev2_set_sa_lifetime (vat_main_t * vam)
12909 unformat_input_t *i = vam->input;
12910 vl_api_ikev2_set_sa_lifetime_t *mp;
12913 u64 lifetime, lifetime_maxdata;
12914 u32 lifetime_jitter, handover;
12916 const char *valid_chars = "a-zA-Z0-9_";
12918 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12920 if (unformat (i, "%U %lu %u %u %lu", unformat_token, valid_chars, &name,
12921 &lifetime, &lifetime_jitter, &handover,
12922 &lifetime_maxdata))
12923 vec_add1 (name, 0);
12926 errmsg ("parse error '%U'", format_unformat_error, i);
12931 if (!vec_len (name))
12933 errmsg ("profile name must be specified");
12937 if (vec_len (name) > 64)
12939 errmsg ("profile name too long");
12943 M (IKEV2_SET_SA_LIFETIME, mp);
12945 clib_memcpy (mp->name, name, vec_len (name));
12947 mp->lifetime = lifetime;
12948 mp->lifetime_jitter = lifetime_jitter;
12949 mp->handover = handover;
12950 mp->lifetime_maxdata = lifetime_maxdata;
12958 api_ikev2_initiate_sa_init (vat_main_t * vam)
12960 unformat_input_t *i = vam->input;
12961 vl_api_ikev2_initiate_sa_init_t *mp;
12965 const char *valid_chars = "a-zA-Z0-9_";
12967 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12969 if (unformat (i, "%U", unformat_token, valid_chars, &name))
12970 vec_add1 (name, 0);
12973 errmsg ("parse error '%U'", format_unformat_error, i);
12978 if (!vec_len (name))
12980 errmsg ("profile name must be specified");
12984 if (vec_len (name) > 64)
12986 errmsg ("profile name too long");
12990 M (IKEV2_INITIATE_SA_INIT, mp);
12992 clib_memcpy (mp->name, name, vec_len (name));
13001 api_ikev2_initiate_del_ike_sa (vat_main_t * vam)
13003 unformat_input_t *i = vam->input;
13004 vl_api_ikev2_initiate_del_ike_sa_t *mp;
13009 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13011 if (unformat (i, "%lx", &ispi))
13015 errmsg ("parse error '%U'", format_unformat_error, i);
13020 M (IKEV2_INITIATE_DEL_IKE_SA, mp);
13030 api_ikev2_initiate_del_child_sa (vat_main_t * vam)
13032 unformat_input_t *i = vam->input;
13033 vl_api_ikev2_initiate_del_child_sa_t *mp;
13038 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13040 if (unformat (i, "%x", &ispi))
13044 errmsg ("parse error '%U'", format_unformat_error, i);
13049 M (IKEV2_INITIATE_DEL_CHILD_SA, mp);
13059 api_ikev2_initiate_rekey_child_sa (vat_main_t * vam)
13061 unformat_input_t *i = vam->input;
13062 vl_api_ikev2_initiate_rekey_child_sa_t *mp;
13067 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13069 if (unformat (i, "%x", &ispi))
13073 errmsg ("parse error '%U'", format_unformat_error, i);
13078 M (IKEV2_INITIATE_REKEY_CHILD_SA, mp);
13091 api_map_add_domain (vat_main_t * vam)
13093 unformat_input_t *i = vam->input;
13094 vl_api_map_add_domain_t *mp;
13096 ip4_address_t ip4_prefix;
13097 ip6_address_t ip6_prefix;
13098 ip6_address_t ip6_src;
13099 u32 num_m_args = 0;
13100 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
13101 0, psid_length = 0;
13102 u8 is_translation = 0;
13104 u32 ip6_src_len = 128;
13107 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13109 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
13110 &ip4_prefix, &ip4_prefix_len))
13112 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
13113 &ip6_prefix, &ip6_prefix_len))
13117 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
13120 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
13122 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
13124 else if (unformat (i, "psid-offset %d", &psid_offset))
13126 else if (unformat (i, "psid-len %d", &psid_length))
13128 else if (unformat (i, "mtu %d", &mtu))
13130 else if (unformat (i, "map-t"))
13131 is_translation = 1;
13134 clib_warning ("parse error '%U'", format_unformat_error, i);
13139 if (num_m_args < 3)
13141 errmsg ("mandatory argument(s) missing");
13145 /* Construct the API message */
13146 M (MAP_ADD_DOMAIN, mp);
13148 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
13149 mp->ip4_prefix_len = ip4_prefix_len;
13151 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
13152 mp->ip6_prefix_len = ip6_prefix_len;
13154 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
13155 mp->ip6_src_prefix_len = ip6_src_len;
13157 mp->ea_bits_len = ea_bits_len;
13158 mp->psid_offset = psid_offset;
13159 mp->psid_length = psid_length;
13160 mp->is_translation = is_translation;
13161 mp->mtu = htons (mtu);
13166 /* Wait for a reply, return good/bad news */
13172 api_map_del_domain (vat_main_t * vam)
13174 unformat_input_t *i = vam->input;
13175 vl_api_map_del_domain_t *mp;
13177 u32 num_m_args = 0;
13181 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13183 if (unformat (i, "index %d", &index))
13187 clib_warning ("parse error '%U'", format_unformat_error, i);
13192 if (num_m_args != 1)
13194 errmsg ("mandatory argument(s) missing");
13198 /* Construct the API message */
13199 M (MAP_DEL_DOMAIN, mp);
13201 mp->index = ntohl (index);
13206 /* Wait for a reply, return good/bad news */
13212 api_map_add_del_rule (vat_main_t * vam)
13214 unformat_input_t *i = vam->input;
13215 vl_api_map_add_del_rule_t *mp;
13217 ip6_address_t ip6_dst;
13218 u32 num_m_args = 0, index, psid = 0;
13221 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13223 if (unformat (i, "index %d", &index))
13225 else if (unformat (i, "psid %d", &psid))
13227 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
13229 else if (unformat (i, "del"))
13235 clib_warning ("parse error '%U'", format_unformat_error, i);
13240 /* Construct the API message */
13241 M (MAP_ADD_DEL_RULE, mp);
13243 mp->index = ntohl (index);
13244 mp->is_add = is_add;
13245 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
13246 mp->psid = ntohs (psid);
13251 /* Wait for a reply, return good/bad news */
13257 api_map_domain_dump (vat_main_t * vam)
13259 vl_api_map_domain_dump_t *mp;
13260 vl_api_control_ping_t *mp_ping;
13263 /* Construct the API message */
13264 M (MAP_DOMAIN_DUMP, mp);
13269 /* Use a control ping for synchronization */
13270 M (CONTROL_PING, mp_ping);
13278 api_map_rule_dump (vat_main_t * vam)
13280 unformat_input_t *i = vam->input;
13281 vl_api_map_rule_dump_t *mp;
13282 vl_api_control_ping_t *mp_ping;
13283 u32 domain_index = ~0;
13286 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13288 if (unformat (i, "index %u", &domain_index))
13294 if (domain_index == ~0)
13296 clib_warning ("parse error: domain index expected");
13300 /* Construct the API message */
13301 M (MAP_RULE_DUMP, mp);
13303 mp->domain_index = htonl (domain_index);
13308 /* Use a control ping for synchronization */
13309 M (CONTROL_PING, mp_ping);
13316 static void vl_api_map_add_domain_reply_t_handler
13317 (vl_api_map_add_domain_reply_t * mp)
13319 vat_main_t *vam = &vat_main;
13320 i32 retval = ntohl (mp->retval);
13322 if (vam->async_mode)
13324 vam->async_errors += (retval < 0);
13328 vam->retval = retval;
13329 vam->result_ready = 1;
13333 static void vl_api_map_add_domain_reply_t_handler_json
13334 (vl_api_map_add_domain_reply_t * mp)
13336 vat_main_t *vam = &vat_main;
13337 vat_json_node_t node;
13339 vat_json_init_object (&node);
13340 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
13341 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
13343 vat_json_print (vam->ofp, &node);
13344 vat_json_free (&node);
13346 vam->retval = ntohl (mp->retval);
13347 vam->result_ready = 1;
13351 api_get_first_msg_id (vat_main_t * vam)
13353 vl_api_get_first_msg_id_t *mp;
13354 unformat_input_t *i = vam->input;
13359 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13361 if (unformat (i, "client %s", &name))
13369 errmsg ("missing client name");
13372 vec_add1 (name, 0);
13374 if (vec_len (name) > 63)
13376 errmsg ("client name too long");
13380 M (GET_FIRST_MSG_ID, mp);
13381 clib_memcpy (mp->name, name, vec_len (name));
13388 api_cop_interface_enable_disable (vat_main_t * vam)
13390 unformat_input_t *line_input = vam->input;
13391 vl_api_cop_interface_enable_disable_t *mp;
13392 u32 sw_if_index = ~0;
13393 u8 enable_disable = 1;
13396 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13398 if (unformat (line_input, "disable"))
13399 enable_disable = 0;
13400 if (unformat (line_input, "enable"))
13401 enable_disable = 1;
13402 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
13403 vam, &sw_if_index))
13405 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13411 if (sw_if_index == ~0)
13413 errmsg ("missing interface name or sw_if_index");
13417 /* Construct the API message */
13418 M (COP_INTERFACE_ENABLE_DISABLE, mp);
13419 mp->sw_if_index = ntohl (sw_if_index);
13420 mp->enable_disable = enable_disable;
13424 /* Wait for the reply */
13430 api_cop_whitelist_enable_disable (vat_main_t * vam)
13432 unformat_input_t *line_input = vam->input;
13433 vl_api_cop_whitelist_enable_disable_t *mp;
13434 u32 sw_if_index = ~0;
13435 u8 ip4 = 0, ip6 = 0, default_cop = 0;
13439 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13441 if (unformat (line_input, "ip4"))
13443 else if (unformat (line_input, "ip6"))
13445 else if (unformat (line_input, "default"))
13447 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
13448 vam, &sw_if_index))
13450 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13452 else if (unformat (line_input, "fib-id %d", &fib_id))
13458 if (sw_if_index == ~0)
13460 errmsg ("missing interface name or sw_if_index");
13464 /* Construct the API message */
13465 M (COP_WHITELIST_ENABLE_DISABLE, mp);
13466 mp->sw_if_index = ntohl (sw_if_index);
13467 mp->fib_id = ntohl (fib_id);
13470 mp->default_cop = default_cop;
13474 /* Wait for the reply */
13480 api_get_node_graph (vat_main_t * vam)
13482 vl_api_get_node_graph_t *mp;
13485 M (GET_NODE_GRAPH, mp);
13489 /* Wait for the reply */
13495 /** Used for parsing LISP eids */
13496 typedef CLIB_PACKED(struct{
13497 u8 addr[16]; /**< eid address */
13498 u32 len; /**< prefix length if IP */
13499 u8 type; /**< type of eid */
13504 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
13506 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
13508 memset (a, 0, sizeof (a[0]));
13510 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
13512 a->type = 0; /* ipv4 type */
13514 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
13516 a->type = 1; /* ipv6 type */
13518 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
13520 a->type = 2; /* mac type */
13527 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
13536 lisp_eid_size_vat (u8 type)
13551 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
13553 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
13557 api_lisp_add_del_locator_set (vat_main_t * vam)
13559 unformat_input_t *input = vam->input;
13560 vl_api_lisp_add_del_locator_set_t *mp;
13562 u8 *locator_set_name = NULL;
13563 u8 locator_set_name_set = 0;
13564 vl_api_local_locator_t locator, *locators = 0;
13565 u32 sw_if_index, priority, weight;
13569 /* Parse args required to build the message */
13570 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13572 if (unformat (input, "del"))
13576 else if (unformat (input, "locator-set %s", &locator_set_name))
13578 locator_set_name_set = 1;
13580 else if (unformat (input, "sw_if_index %u p %u w %u",
13581 &sw_if_index, &priority, &weight))
13583 locator.sw_if_index = htonl (sw_if_index);
13584 locator.priority = priority;
13585 locator.weight = weight;
13586 vec_add1 (locators, locator);
13590 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
13591 &sw_if_index, &priority, &weight))
13593 locator.sw_if_index = htonl (sw_if_index);
13594 locator.priority = priority;
13595 locator.weight = weight;
13596 vec_add1 (locators, locator);
13602 if (locator_set_name_set == 0)
13604 errmsg ("missing locator-set name");
13605 vec_free (locators);
13609 if (vec_len (locator_set_name) > 64)
13611 errmsg ("locator-set name too long");
13612 vec_free (locator_set_name);
13613 vec_free (locators);
13616 vec_add1 (locator_set_name, 0);
13618 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
13620 /* Construct the API message */
13621 M2 (LISP_ADD_DEL_LOCATOR_SET, mp, data_len);
13623 mp->is_add = is_add;
13624 clib_memcpy (mp->locator_set_name, locator_set_name,
13625 vec_len (locator_set_name));
13626 vec_free (locator_set_name);
13628 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
13630 clib_memcpy (mp->locators, locators, data_len);
13631 vec_free (locators);
13636 /* Wait for a reply... */
13642 api_lisp_add_del_locator (vat_main_t * vam)
13644 unformat_input_t *input = vam->input;
13645 vl_api_lisp_add_del_locator_t *mp;
13646 u32 tmp_if_index = ~0;
13647 u32 sw_if_index = ~0;
13648 u8 sw_if_index_set = 0;
13649 u8 sw_if_index_if_name_set = 0;
13651 u8 priority_set = 0;
13655 u8 *locator_set_name = NULL;
13656 u8 locator_set_name_set = 0;
13659 /* Parse args required to build the message */
13660 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13662 if (unformat (input, "del"))
13666 else if (unformat (input, "locator-set %s", &locator_set_name))
13668 locator_set_name_set = 1;
13670 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
13673 sw_if_index_if_name_set = 1;
13674 sw_if_index = tmp_if_index;
13676 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
13678 sw_if_index_set = 1;
13679 sw_if_index = tmp_if_index;
13681 else if (unformat (input, "p %d", &priority))
13685 else if (unformat (input, "w %d", &weight))
13693 if (locator_set_name_set == 0)
13695 errmsg ("missing locator-set name");
13699 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
13701 errmsg ("missing sw_if_index");
13702 vec_free (locator_set_name);
13706 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
13708 errmsg ("cannot use both params interface name and sw_if_index");
13709 vec_free (locator_set_name);
13713 if (priority_set == 0)
13715 errmsg ("missing locator-set priority");
13716 vec_free (locator_set_name);
13720 if (weight_set == 0)
13722 errmsg ("missing locator-set weight");
13723 vec_free (locator_set_name);
13727 if (vec_len (locator_set_name) > 64)
13729 errmsg ("locator-set name too long");
13730 vec_free (locator_set_name);
13733 vec_add1 (locator_set_name, 0);
13735 /* Construct the API message */
13736 M (LISP_ADD_DEL_LOCATOR, mp);
13738 mp->is_add = is_add;
13739 mp->sw_if_index = ntohl (sw_if_index);
13740 mp->priority = priority;
13741 mp->weight = weight;
13742 clib_memcpy (mp->locator_set_name, locator_set_name,
13743 vec_len (locator_set_name));
13744 vec_free (locator_set_name);
13749 /* Wait for a reply... */
13755 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
13757 u32 *key_id = va_arg (*args, u32 *);
13760 if (unformat (input, "%s", &s))
13762 if (!strcmp ((char *) s, "sha1"))
13763 key_id[0] = HMAC_SHA_1_96;
13764 else if (!strcmp ((char *) s, "sha256"))
13765 key_id[0] = HMAC_SHA_256_128;
13768 clib_warning ("invalid key_id: '%s'", s);
13769 key_id[0] = HMAC_NO_KEY;
13780 api_lisp_add_del_local_eid (vat_main_t * vam)
13782 unformat_input_t *input = vam->input;
13783 vl_api_lisp_add_del_local_eid_t *mp;
13786 lisp_eid_vat_t _eid, *eid = &_eid;
13787 u8 *locator_set_name = 0;
13788 u8 locator_set_name_set = 0;
13794 /* Parse args required to build the message */
13795 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13797 if (unformat (input, "del"))
13801 else if (unformat (input, "vni %d", &vni))
13805 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
13809 else if (unformat (input, "locator-set %s", &locator_set_name))
13811 locator_set_name_set = 1;
13813 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
13815 else if (unformat (input, "secret-key %_%v%_", &key))
13821 if (locator_set_name_set == 0)
13823 errmsg ("missing locator-set name");
13829 errmsg ("EID address not set!");
13830 vec_free (locator_set_name);
13834 if (key && (0 == key_id))
13836 errmsg ("invalid key_id!");
13840 if (vec_len (key) > 64)
13842 errmsg ("key too long");
13847 if (vec_len (locator_set_name) > 64)
13849 errmsg ("locator-set name too long");
13850 vec_free (locator_set_name);
13853 vec_add1 (locator_set_name, 0);
13855 /* Construct the API message */
13856 M (LISP_ADD_DEL_LOCAL_EID, mp);
13858 mp->is_add = is_add;
13859 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
13860 mp->eid_type = eid->type;
13861 mp->prefix_len = eid->len;
13862 mp->vni = clib_host_to_net_u32 (vni);
13863 mp->key_id = clib_host_to_net_u16 (key_id);
13864 clib_memcpy (mp->locator_set_name, locator_set_name,
13865 vec_len (locator_set_name));
13866 clib_memcpy (mp->key, key, vec_len (key));
13868 vec_free (locator_set_name);
13874 /* Wait for a reply... */
13880 /** Used for transferring locators via VPP API */
13881 typedef CLIB_PACKED(struct
13883 u8 is_ip4; /**< is locator an IPv4 address? */
13884 u8 priority; /**< locator priority */
13885 u8 weight; /**< locator weight */
13886 u8 addr[16]; /**< IPv4/IPv6 address */
13891 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
13893 u32 dp_table = 0, vni = 0;;
13894 unformat_input_t *input = vam->input;
13895 vl_api_lisp_gpe_add_del_fwd_entry_t *mp;
13897 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
13898 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
13899 u8 rmt_eid_set = 0, lcl_eid_set = 0;
13900 u32 action = ~0, w;
13901 ip4_address_t rmt_rloc4, lcl_rloc4;
13902 ip6_address_t rmt_rloc6, lcl_rloc6;
13903 vl_api_lisp_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc =
13907 memset (&rloc, 0, sizeof (rloc));
13909 /* Parse args required to build the message */
13910 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13912 if (unformat (input, "del"))
13914 else if (unformat (input, "add"))
13916 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
13920 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
13924 else if (unformat (input, "vrf %d", &dp_table))
13926 else if (unformat (input, "bd %d", &dp_table))
13928 else if (unformat (input, "vni %d", &vni))
13930 else if (unformat (input, "w %d", &w))
13934 errmsg ("No RLOC configured for setting priority/weight!");
13937 curr_rloc->weight = w;
13939 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
13940 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
13944 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
13946 vec_add1 (lcl_locs, rloc);
13948 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
13949 vec_add1 (rmt_locs, rloc);
13950 /* weight saved in rmt loc */
13951 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
13953 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
13954 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
13957 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
13959 vec_add1 (lcl_locs, rloc);
13961 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
13962 vec_add1 (rmt_locs, rloc);
13963 /* weight saved in rmt loc */
13964 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
13966 else if (unformat (input, "action %d", &action))
13972 clib_warning ("parse error '%U'", format_unformat_error, input);
13979 errmsg ("remote eid addresses not set");
13983 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
13985 errmsg ("eid types don't match");
13989 if (0 == rmt_locs && (u32) ~ 0 == action)
13991 errmsg ("action not set for negative mapping");
13995 /* Construct the API message */
13996 M2 (LISP_GPE_ADD_DEL_FWD_ENTRY, mp,
13997 sizeof (vl_api_lisp_gpe_locator_t) * vec_len (rmt_locs) * 2);
13999 mp->is_add = is_add;
14000 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
14001 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
14002 mp->eid_type = rmt_eid->type;
14003 mp->dp_table = clib_host_to_net_u32 (dp_table);
14004 mp->vni = clib_host_to_net_u32 (vni);
14005 mp->rmt_len = rmt_eid->len;
14006 mp->lcl_len = lcl_eid->len;
14007 mp->action = action;
14009 if (0 != rmt_locs && 0 != lcl_locs)
14011 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
14012 clib_memcpy (mp->locs, lcl_locs,
14013 (sizeof (vl_api_lisp_gpe_locator_t) * vec_len (lcl_locs)));
14015 u32 offset = sizeof (vl_api_lisp_gpe_locator_t) * vec_len (lcl_locs);
14016 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
14017 (sizeof (vl_api_lisp_gpe_locator_t) * vec_len (rmt_locs)));
14019 vec_free (lcl_locs);
14020 vec_free (rmt_locs);
14025 /* Wait for a reply... */
14031 api_lisp_add_del_map_server (vat_main_t * vam)
14033 unformat_input_t *input = vam->input;
14034 vl_api_lisp_add_del_map_server_t *mp;
14038 ip4_address_t ipv4;
14039 ip6_address_t ipv6;
14042 /* Parse args required to build the message */
14043 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14045 if (unformat (input, "del"))
14049 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14053 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14061 if (ipv4_set && ipv6_set)
14063 errmsg ("both eid v4 and v6 addresses set");
14067 if (!ipv4_set && !ipv6_set)
14069 errmsg ("eid addresses not set");
14073 /* Construct the API message */
14074 M (LISP_ADD_DEL_MAP_SERVER, mp);
14076 mp->is_add = is_add;
14080 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
14085 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
14091 /* Wait for a reply... */
14097 api_lisp_add_del_map_resolver (vat_main_t * vam)
14099 unformat_input_t *input = vam->input;
14100 vl_api_lisp_add_del_map_resolver_t *mp;
14104 ip4_address_t ipv4;
14105 ip6_address_t ipv6;
14108 /* Parse args required to build the message */
14109 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14111 if (unformat (input, "del"))
14115 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
14119 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
14127 if (ipv4_set && ipv6_set)
14129 errmsg ("both eid v4 and v6 addresses set");
14133 if (!ipv4_set && !ipv6_set)
14135 errmsg ("eid addresses not set");
14139 /* Construct the API message */
14140 M (LISP_ADD_DEL_MAP_RESOLVER, mp);
14142 mp->is_add = is_add;
14146 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
14151 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
14157 /* Wait for a reply... */
14163 api_lisp_gpe_enable_disable (vat_main_t * vam)
14165 unformat_input_t *input = vam->input;
14166 vl_api_lisp_gpe_enable_disable_t *mp;
14171 /* Parse args required to build the message */
14172 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14174 if (unformat (input, "enable"))
14179 else if (unformat (input, "disable"))
14190 errmsg ("Value not set");
14194 /* Construct the API message */
14195 M (LISP_GPE_ENABLE_DISABLE, mp);
14202 /* Wait for a reply... */
14208 api_lisp_rloc_probe_enable_disable (vat_main_t * vam)
14210 unformat_input_t *input = vam->input;
14211 vl_api_lisp_rloc_probe_enable_disable_t *mp;
14216 /* Parse args required to build the message */
14217 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14219 if (unformat (input, "enable"))
14224 else if (unformat (input, "disable"))
14232 errmsg ("Value not set");
14236 /* Construct the API message */
14237 M (LISP_RLOC_PROBE_ENABLE_DISABLE, mp);
14239 mp->is_enabled = is_en;
14244 /* Wait for a reply... */
14250 api_lisp_map_register_enable_disable (vat_main_t * vam)
14252 unformat_input_t *input = vam->input;
14253 vl_api_lisp_map_register_enable_disable_t *mp;
14258 /* Parse args required to build the message */
14259 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14261 if (unformat (input, "enable"))
14266 else if (unformat (input, "disable"))
14274 errmsg ("Value not set");
14278 /* Construct the API message */
14279 M (LISP_MAP_REGISTER_ENABLE_DISABLE, mp);
14281 mp->is_enabled = is_en;
14286 /* Wait for a reply... */
14292 api_lisp_enable_disable (vat_main_t * vam)
14294 unformat_input_t *input = vam->input;
14295 vl_api_lisp_enable_disable_t *mp;
14300 /* Parse args required to build the message */
14301 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14303 if (unformat (input, "enable"))
14308 else if (unformat (input, "disable"))
14318 errmsg ("Value not set");
14322 /* Construct the API message */
14323 M (LISP_ENABLE_DISABLE, mp);
14330 /* Wait for a reply... */
14336 api_show_lisp_map_register_state (vat_main_t * vam)
14338 vl_api_show_lisp_map_register_state_t *mp;
14341 M (SHOW_LISP_MAP_REGISTER_STATE, mp);
14346 /* wait for reply */
14352 api_show_lisp_rloc_probe_state (vat_main_t * vam)
14354 vl_api_show_lisp_rloc_probe_state_t *mp;
14357 M (SHOW_LISP_RLOC_PROBE_STATE, mp);
14362 /* wait for reply */
14368 api_show_lisp_map_request_mode (vat_main_t * vam)
14370 vl_api_show_lisp_map_request_mode_t *mp;
14373 M (SHOW_LISP_MAP_REQUEST_MODE, mp);
14378 /* wait for reply */
14384 api_lisp_map_request_mode (vat_main_t * vam)
14386 unformat_input_t *input = vam->input;
14387 vl_api_lisp_map_request_mode_t *mp;
14391 /* Parse args required to build the message */
14392 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14394 if (unformat (input, "dst-only"))
14396 else if (unformat (input, "src-dst"))
14400 errmsg ("parse error '%U'", format_unformat_error, input);
14405 M (LISP_MAP_REQUEST_MODE, mp);
14412 /* wait for reply */
14418 * Enable/disable LISP proxy ITR.
14420 * @param vam vpp API test context
14421 * @return return code
14424 api_lisp_pitr_set_locator_set (vat_main_t * vam)
14426 u8 ls_name_set = 0;
14427 unformat_input_t *input = vam->input;
14428 vl_api_lisp_pitr_set_locator_set_t *mp;
14433 /* Parse args required to build the message */
14434 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14436 if (unformat (input, "del"))
14438 else if (unformat (input, "locator-set %s", &ls_name))
14442 errmsg ("parse error '%U'", format_unformat_error, input);
14449 errmsg ("locator-set name not set!");
14453 M (LISP_PITR_SET_LOCATOR_SET, mp);
14455 mp->is_add = is_add;
14456 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
14457 vec_free (ls_name);
14462 /* wait for reply */
14468 api_show_lisp_pitr (vat_main_t * vam)
14470 vl_api_show_lisp_pitr_t *mp;
14473 if (!vam->json_output)
14475 print (vam->ofp, "%=20s", "lisp status:");
14478 M (SHOW_LISP_PITR, mp);
14482 /* Wait for a reply... */
14488 * Add/delete mapping between vni and vrf
14491 api_lisp_eid_table_add_del_map (vat_main_t * vam)
14493 unformat_input_t *input = vam->input;
14494 vl_api_lisp_eid_table_add_del_map_t *mp;
14495 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
14496 u32 vni, vrf, bd_index;
14499 /* Parse args required to build the message */
14500 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14502 if (unformat (input, "del"))
14504 else if (unformat (input, "vrf %d", &vrf))
14506 else if (unformat (input, "bd_index %d", &bd_index))
14508 else if (unformat (input, "vni %d", &vni))
14514 if (!vni_set || (!vrf_set && !bd_index_set))
14516 errmsg ("missing arguments!");
14520 if (vrf_set && bd_index_set)
14522 errmsg ("error: both vrf and bd entered!");
14526 M (LISP_EID_TABLE_ADD_DEL_MAP, mp);
14528 mp->is_add = is_add;
14529 mp->vni = htonl (vni);
14530 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
14531 mp->is_l2 = bd_index_set;
14536 /* wait for reply */
14542 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
14544 u32 *action = va_arg (*args, u32 *);
14547 if (unformat (input, "%s", &s))
14549 if (!strcmp ((char *) s, "no-action"))
14551 else if (!strcmp ((char *) s, "natively-forward"))
14553 else if (!strcmp ((char *) s, "send-map-request"))
14555 else if (!strcmp ((char *) s, "drop"))
14559 clib_warning ("invalid action: '%s'", s);
14571 * Add/del remote mapping to/from LISP control plane
14573 * @param vam vpp API test context
14574 * @return return code
14577 api_lisp_add_del_remote_mapping (vat_main_t * vam)
14579 unformat_input_t *input = vam->input;
14580 vl_api_lisp_add_del_remote_mapping_t *mp;
14582 lisp_eid_vat_t _eid, *eid = &_eid;
14583 lisp_eid_vat_t _seid, *seid = &_seid;
14584 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
14585 u32 action = ~0, p, w, data_len;
14586 ip4_address_t rloc4;
14587 ip6_address_t rloc6;
14588 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
14591 memset (&rloc, 0, sizeof (rloc));
14593 /* Parse args required to build the message */
14594 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14596 if (unformat (input, "del-all"))
14600 else if (unformat (input, "del"))
14604 else if (unformat (input, "add"))
14608 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
14612 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
14616 else if (unformat (input, "vni %d", &vni))
14620 else if (unformat (input, "p %d w %d", &p, &w))
14624 errmsg ("No RLOC configured for setting priority/weight!");
14627 curr_rloc->priority = p;
14628 curr_rloc->weight = w;
14630 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
14633 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
14634 vec_add1 (rlocs, rloc);
14635 curr_rloc = &rlocs[vec_len (rlocs) - 1];
14637 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
14640 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
14641 vec_add1 (rlocs, rloc);
14642 curr_rloc = &rlocs[vec_len (rlocs) - 1];
14644 else if (unformat (input, "action %U",
14645 unformat_negative_mapping_action, &action))
14651 clib_warning ("parse error '%U'", format_unformat_error, input);
14658 errmsg ("missing params!");
14662 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
14664 errmsg ("no action set for negative map-reply!");
14668 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
14670 M2 (LISP_ADD_DEL_REMOTE_MAPPING, mp, data_len);
14671 mp->is_add = is_add;
14672 mp->vni = htonl (vni);
14673 mp->action = (u8) action;
14674 mp->is_src_dst = seid_set;
14675 mp->eid_len = eid->len;
14676 mp->seid_len = seid->len;
14677 mp->del_all = del_all;
14678 mp->eid_type = eid->type;
14679 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
14680 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
14682 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
14683 clib_memcpy (mp->rlocs, rlocs, data_len);
14689 /* Wait for a reply... */
14695 * Add/del LISP adjacency. Saves mapping in LISP control plane and updates
14696 * forwarding entries in data-plane accordingly.
14698 * @param vam vpp API test context
14699 * @return return code
14702 api_lisp_add_del_adjacency (vat_main_t * vam)
14704 unformat_input_t *input = vam->input;
14705 vl_api_lisp_add_del_adjacency_t *mp;
14707 ip4_address_t leid4, reid4;
14708 ip6_address_t leid6, reid6;
14709 u8 reid_mac[6] = { 0 };
14710 u8 leid_mac[6] = { 0 };
14711 u8 reid_type, leid_type;
14712 u32 leid_len = 0, reid_len = 0, len;
14716 leid_type = reid_type = (u8) ~ 0;
14718 /* Parse args required to build the message */
14719 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14721 if (unformat (input, "del"))
14725 else if (unformat (input, "add"))
14729 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
14732 reid_type = 0; /* ipv4 */
14735 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
14738 reid_type = 1; /* ipv6 */
14741 else if (unformat (input, "reid %U", unformat_ethernet_address,
14744 reid_type = 2; /* mac */
14746 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
14749 leid_type = 0; /* ipv4 */
14752 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
14755 leid_type = 1; /* ipv6 */
14758 else if (unformat (input, "leid %U", unformat_ethernet_address,
14761 leid_type = 2; /* mac */
14763 else if (unformat (input, "vni %d", &vni))
14769 errmsg ("parse error '%U'", format_unformat_error, input);
14774 if ((u8) ~ 0 == reid_type)
14776 errmsg ("missing params!");
14780 if (leid_type != reid_type)
14782 errmsg ("remote and local EIDs are of different types!");
14786 M (LISP_ADD_DEL_ADJACENCY, mp);
14787 mp->is_add = is_add;
14788 mp->vni = htonl (vni);
14789 mp->leid_len = leid_len;
14790 mp->reid_len = reid_len;
14791 mp->eid_type = reid_type;
14793 switch (mp->eid_type)
14796 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
14797 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
14800 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
14801 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
14804 clib_memcpy (mp->leid, leid_mac, 6);
14805 clib_memcpy (mp->reid, reid_mac, 6);
14808 errmsg ("unknown EID type %d!", mp->eid_type);
14815 /* Wait for a reply... */
14821 api_lisp_gpe_add_del_iface (vat_main_t * vam)
14823 unformat_input_t *input = vam->input;
14824 vl_api_lisp_gpe_add_del_iface_t *mp;
14825 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
14826 u32 dp_table = 0, vni = 0;
14829 /* Parse args required to build the message */
14830 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14832 if (unformat (input, "up"))
14837 else if (unformat (input, "down"))
14842 else if (unformat (input, "table_id %d", &dp_table))
14846 else if (unformat (input, "bd_id %d", &dp_table))
14851 else if (unformat (input, "vni %d", &vni))
14859 if (action_set == 0)
14861 errmsg ("Action not set");
14864 if (dp_table_set == 0 || vni_set == 0)
14866 errmsg ("vni and dp_table must be set");
14870 /* Construct the API message */
14871 M (LISP_GPE_ADD_DEL_IFACE, mp);
14873 mp->is_add = is_add;
14874 mp->dp_table = dp_table;
14881 /* Wait for a reply... */
14887 * Add/del map request itr rlocs from LISP control plane and updates
14889 * @param vam vpp API test context
14890 * @return return code
14893 api_lisp_add_del_map_request_itr_rlocs (vat_main_t * vam)
14895 unformat_input_t *input = vam->input;
14896 vl_api_lisp_add_del_map_request_itr_rlocs_t *mp;
14897 u8 *locator_set_name = 0;
14898 u8 locator_set_name_set = 0;
14902 /* Parse args required to build the message */
14903 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14905 if (unformat (input, "del"))
14909 else if (unformat (input, "%_%v%_", &locator_set_name))
14911 locator_set_name_set = 1;
14915 clib_warning ("parse error '%U'", format_unformat_error, input);
14920 if (is_add && !locator_set_name_set)
14922 errmsg ("itr-rloc is not set!");
14926 if (is_add && vec_len (locator_set_name) > 64)
14928 errmsg ("itr-rloc locator-set name too long");
14929 vec_free (locator_set_name);
14933 M (LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, mp);
14934 mp->is_add = is_add;
14937 clib_memcpy (mp->locator_set_name, locator_set_name,
14938 vec_len (locator_set_name));
14942 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
14944 vec_free (locator_set_name);
14949 /* Wait for a reply... */
14955 api_lisp_locator_dump (vat_main_t * vam)
14957 unformat_input_t *input = vam->input;
14958 vl_api_lisp_locator_dump_t *mp;
14959 vl_api_control_ping_t *mp_ping;
14960 u8 is_index_set = 0, is_name_set = 0;
14965 /* Parse args required to build the message */
14966 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14968 if (unformat (input, "ls_name %_%v%_", &ls_name))
14972 else if (unformat (input, "ls_index %d", &ls_index))
14978 errmsg ("parse error '%U'", format_unformat_error, input);
14983 if (!is_index_set && !is_name_set)
14985 errmsg ("error: expected one of index or name!");
14989 if (is_index_set && is_name_set)
14991 errmsg ("error: only one param expected!");
14995 if (vec_len (ls_name) > 62)
14997 errmsg ("error: locator set name too long!");
15001 if (!vam->json_output)
15003 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
15006 M (LISP_LOCATOR_DUMP, mp);
15007 mp->is_index_set = is_index_set;
15010 mp->ls_index = clib_host_to_net_u32 (ls_index);
15013 vec_add1 (ls_name, 0);
15014 strncpy ((char *) mp->ls_name, (char *) ls_name,
15015 sizeof (mp->ls_name) - 1);
15021 /* Use a control ping for synchronization */
15022 M (CONTROL_PING, mp_ping);
15025 /* Wait for a reply... */
15031 api_lisp_locator_set_dump (vat_main_t * vam)
15033 vl_api_lisp_locator_set_dump_t *mp;
15034 vl_api_control_ping_t *mp_ping;
15035 unformat_input_t *input = vam->input;
15039 /* Parse args required to build the message */
15040 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15042 if (unformat (input, "local"))
15046 else if (unformat (input, "remote"))
15052 errmsg ("parse error '%U'", format_unformat_error, input);
15057 if (!vam->json_output)
15059 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
15062 M (LISP_LOCATOR_SET_DUMP, mp);
15064 mp->filter = filter;
15069 /* Use a control ping for synchronization */
15070 M (CONTROL_PING, mp_ping);
15073 /* Wait for a reply... */
15079 api_lisp_eid_table_map_dump (vat_main_t * vam)
15083 unformat_input_t *input = vam->input;
15084 vl_api_lisp_eid_table_map_dump_t *mp;
15085 vl_api_control_ping_t *mp_ping;
15088 /* Parse args required to build the message */
15089 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15091 if (unformat (input, "l2"))
15096 else if (unformat (input, "l3"))
15103 errmsg ("parse error '%U'", format_unformat_error, input);
15110 errmsg ("expected one of 'l2' or 'l3' parameter!");
15114 if (!vam->json_output)
15116 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
15119 M (LISP_EID_TABLE_MAP_DUMP, mp);
15125 /* Use a control ping for synchronization */
15126 M (CONTROL_PING, mp_ping);
15129 /* Wait for a reply... */
15135 api_lisp_eid_table_vni_dump (vat_main_t * vam)
15137 vl_api_lisp_eid_table_vni_dump_t *mp;
15138 vl_api_control_ping_t *mp_ping;
15141 if (!vam->json_output)
15143 print (vam->ofp, "VNI");
15146 M (LISP_EID_TABLE_VNI_DUMP, mp);
15151 /* Use a control ping for synchronization */
15152 M (CONTROL_PING, mp_ping);
15155 /* Wait for a reply... */
15161 api_lisp_eid_table_dump (vat_main_t * vam)
15163 unformat_input_t *i = vam->input;
15164 vl_api_lisp_eid_table_dump_t *mp;
15165 vl_api_control_ping_t *mp_ping;
15166 struct in_addr ip4;
15167 struct in6_addr ip6;
15169 u8 eid_type = ~0, eid_set = 0;
15170 u32 prefix_length = ~0, t, vni = 0;
15174 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15176 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
15182 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
15188 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
15193 else if (unformat (i, "vni %d", &t))
15197 else if (unformat (i, "local"))
15201 else if (unformat (i, "remote"))
15207 errmsg ("parse error '%U'", format_unformat_error, i);
15212 if (!vam->json_output)
15214 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
15215 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
15218 M (LISP_EID_TABLE_DUMP, mp);
15220 mp->filter = filter;
15224 mp->vni = htonl (vni);
15225 mp->eid_type = eid_type;
15229 mp->prefix_length = prefix_length;
15230 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
15233 mp->prefix_length = prefix_length;
15234 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
15237 clib_memcpy (mp->eid, mac, sizeof (mac));
15240 errmsg ("unknown EID type %d!", eid_type);
15248 /* Use a control ping for synchronization */
15249 M (CONTROL_PING, mp_ping);
15252 /* Wait for a reply... */
15258 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
15260 unformat_input_t *i = vam->input;
15261 vl_api_lisp_gpe_fwd_entries_get_t *mp;
15266 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15268 if (unformat (i, "vni %d", &vni))
15274 errmsg ("parse error '%U'", format_unformat_error, i);
15281 errmsg ("vni not set!");
15285 if (!vam->json_output)
15287 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
15291 M (LISP_GPE_FWD_ENTRIES_GET, mp);
15292 mp->vni = clib_host_to_net_u32 (vni);
15297 /* Wait for a reply... */
15302 #define vl_api_lisp_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
15303 #define vl_api_lisp_gpe_fwd_entries_get_reply_t_print vl_noop_handler
15304 #define vl_api_lisp_gpe_fwd_entry_path_details_t_endian vl_noop_handler
15305 #define vl_api_lisp_gpe_fwd_entry_path_details_t_print vl_noop_handler
15308 api_lisp_adjacencies_get (vat_main_t * vam)
15310 unformat_input_t *i = vam->input;
15311 vl_api_lisp_adjacencies_get_t *mp;
15316 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15318 if (unformat (i, "vni %d", &vni))
15324 errmsg ("parse error '%U'", format_unformat_error, i);
15331 errmsg ("vni not set!");
15335 if (!vam->json_output)
15337 print (vam->ofp, "%s %40s", "leid", "reid");
15340 M (LISP_ADJACENCIES_GET, mp);
15341 mp->vni = clib_host_to_net_u32 (vni);
15346 /* Wait for a reply... */
15352 api_lisp_map_server_dump (vat_main_t * vam)
15354 vl_api_lisp_map_server_dump_t *mp;
15355 vl_api_control_ping_t *mp_ping;
15358 if (!vam->json_output)
15360 print (vam->ofp, "%=20s", "Map server");
15363 M (LISP_MAP_SERVER_DUMP, mp);
15367 /* Use a control ping for synchronization */
15368 M (CONTROL_PING, mp_ping);
15371 /* Wait for a reply... */
15377 api_lisp_map_resolver_dump (vat_main_t * vam)
15379 vl_api_lisp_map_resolver_dump_t *mp;
15380 vl_api_control_ping_t *mp_ping;
15383 if (!vam->json_output)
15385 print (vam->ofp, "%=20s", "Map resolver");
15388 M (LISP_MAP_RESOLVER_DUMP, mp);
15392 /* Use a control ping for synchronization */
15393 M (CONTROL_PING, mp_ping);
15396 /* Wait for a reply... */
15402 api_show_lisp_status (vat_main_t * vam)
15404 vl_api_show_lisp_status_t *mp;
15407 if (!vam->json_output)
15409 print (vam->ofp, "%-20s%-16s", "lisp status", "locator-set");
15412 M (SHOW_LISP_STATUS, mp);
15415 /* Wait for a reply... */
15421 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
15423 vl_api_lisp_gpe_fwd_entry_path_dump_t *mp;
15424 vl_api_control_ping_t *mp_ping;
15425 unformat_input_t *i = vam->input;
15426 u32 fwd_entry_index = ~0;
15429 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15431 if (unformat (i, "index %d", &fwd_entry_index))
15437 if (~0 == fwd_entry_index)
15439 errmsg ("no index specified!");
15443 if (!vam->json_output)
15445 print (vam->ofp, "first line");
15448 M (LISP_GPE_FWD_ENTRY_PATH_DUMP, mp);
15452 /* Use a control ping for synchronization */
15453 M (CONTROL_PING, mp_ping);
15456 /* Wait for a reply... */
15462 api_lisp_get_map_request_itr_rlocs (vat_main_t * vam)
15464 vl_api_lisp_get_map_request_itr_rlocs_t *mp;
15467 if (!vam->json_output)
15469 print (vam->ofp, "%=20s", "itr-rlocs:");
15472 M (LISP_GET_MAP_REQUEST_ITR_RLOCS, mp);
15475 /* Wait for a reply... */
15481 api_af_packet_create (vat_main_t * vam)
15483 unformat_input_t *i = vam->input;
15484 vl_api_af_packet_create_t *mp;
15485 u8 *host_if_name = 0;
15487 u8 random_hw_addr = 1;
15490 memset (hw_addr, 0, sizeof (hw_addr));
15492 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15494 if (unformat (i, "name %s", &host_if_name))
15495 vec_add1 (host_if_name, 0);
15496 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
15497 random_hw_addr = 0;
15502 if (!vec_len (host_if_name))
15504 errmsg ("host-interface name must be specified");
15508 if (vec_len (host_if_name) > 64)
15510 errmsg ("host-interface name too long");
15514 M (AF_PACKET_CREATE, mp);
15516 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
15517 clib_memcpy (mp->hw_addr, hw_addr, 6);
15518 mp->use_random_hw_addr = random_hw_addr;
15519 vec_free (host_if_name);
15522 W2 (ret, fprintf (vam->ofp, " new sw_if_index = %d ", vam->sw_if_index));
15527 api_af_packet_delete (vat_main_t * vam)
15529 unformat_input_t *i = vam->input;
15530 vl_api_af_packet_delete_t *mp;
15531 u8 *host_if_name = 0;
15534 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15536 if (unformat (i, "name %s", &host_if_name))
15537 vec_add1 (host_if_name, 0);
15542 if (!vec_len (host_if_name))
15544 errmsg ("host-interface name must be specified");
15548 if (vec_len (host_if_name) > 64)
15550 errmsg ("host-interface name too long");
15554 M (AF_PACKET_DELETE, mp);
15556 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
15557 vec_free (host_if_name);
15565 api_policer_add_del (vat_main_t * vam)
15567 unformat_input_t *i = vam->input;
15568 vl_api_policer_add_del_t *mp;
15578 u8 color_aware = 0;
15579 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
15582 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
15583 conform_action.dscp = 0;
15584 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
15585 exceed_action.dscp = 0;
15586 violate_action.action_type = SSE2_QOS_ACTION_DROP;
15587 violate_action.dscp = 0;
15589 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15591 if (unformat (i, "del"))
15593 else if (unformat (i, "name %s", &name))
15594 vec_add1 (name, 0);
15595 else if (unformat (i, "cir %u", &cir))
15597 else if (unformat (i, "eir %u", &eir))
15599 else if (unformat (i, "cb %u", &cb))
15601 else if (unformat (i, "eb %u", &eb))
15603 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
15606 else if (unformat (i, "round_type %U", unformat_policer_round_type,
15609 else if (unformat (i, "type %U", unformat_policer_type, &type))
15611 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
15614 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
15617 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
15620 else if (unformat (i, "color-aware"))
15626 if (!vec_len (name))
15628 errmsg ("policer name must be specified");
15632 if (vec_len (name) > 64)
15634 errmsg ("policer name too long");
15638 M (POLICER_ADD_DEL, mp);
15640 clib_memcpy (mp->name, name, vec_len (name));
15642 mp->is_add = is_add;
15647 mp->rate_type = rate_type;
15648 mp->round_type = round_type;
15650 mp->conform_action_type = conform_action.action_type;
15651 mp->conform_dscp = conform_action.dscp;
15652 mp->exceed_action_type = exceed_action.action_type;
15653 mp->exceed_dscp = exceed_action.dscp;
15654 mp->violate_action_type = violate_action.action_type;
15655 mp->violate_dscp = violate_action.dscp;
15656 mp->color_aware = color_aware;
15664 api_policer_dump (vat_main_t * vam)
15666 unformat_input_t *i = vam->input;
15667 vl_api_policer_dump_t *mp;
15668 vl_api_control_ping_t *mp_ping;
15669 u8 *match_name = 0;
15670 u8 match_name_valid = 0;
15673 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15675 if (unformat (i, "name %s", &match_name))
15677 vec_add1 (match_name, 0);
15678 match_name_valid = 1;
15684 M (POLICER_DUMP, mp);
15685 mp->match_name_valid = match_name_valid;
15686 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
15687 vec_free (match_name);
15691 /* Use a control ping for synchronization */
15692 M (CONTROL_PING, mp_ping);
15695 /* Wait for a reply... */
15701 api_policer_classify_set_interface (vat_main_t * vam)
15703 unformat_input_t *i = vam->input;
15704 vl_api_policer_classify_set_interface_t *mp;
15706 int sw_if_index_set;
15707 u32 ip4_table_index = ~0;
15708 u32 ip6_table_index = ~0;
15709 u32 l2_table_index = ~0;
15713 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15715 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15716 sw_if_index_set = 1;
15717 else if (unformat (i, "sw_if_index %d", &sw_if_index))
15718 sw_if_index_set = 1;
15719 else if (unformat (i, "del"))
15721 else if (unformat (i, "ip4-table %d", &ip4_table_index))
15723 else if (unformat (i, "ip6-table %d", &ip6_table_index))
15725 else if (unformat (i, "l2-table %d", &l2_table_index))
15729 clib_warning ("parse error '%U'", format_unformat_error, i);
15734 if (sw_if_index_set == 0)
15736 errmsg ("missing interface name or sw_if_index");
15740 M (POLICER_CLASSIFY_SET_INTERFACE, mp);
15742 mp->sw_if_index = ntohl (sw_if_index);
15743 mp->ip4_table_index = ntohl (ip4_table_index);
15744 mp->ip6_table_index = ntohl (ip6_table_index);
15745 mp->l2_table_index = ntohl (l2_table_index);
15746 mp->is_add = is_add;
15754 api_policer_classify_dump (vat_main_t * vam)
15756 unformat_input_t *i = vam->input;
15757 vl_api_policer_classify_dump_t *mp;
15758 vl_api_control_ping_t *mp_ping;
15759 u8 type = POLICER_CLASSIFY_N_TABLES;
15762 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
15766 errmsg ("classify table type must be specified");
15770 if (!vam->json_output)
15772 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
15775 M (POLICER_CLASSIFY_DUMP, mp);
15780 /* Use a control ping for synchronization */
15781 M (CONTROL_PING, mp_ping);
15784 /* Wait for a reply... */
15790 api_netmap_create (vat_main_t * vam)
15792 unformat_input_t *i = vam->input;
15793 vl_api_netmap_create_t *mp;
15796 u8 random_hw_addr = 1;
15801 memset (hw_addr, 0, sizeof (hw_addr));
15803 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15805 if (unformat (i, "name %s", &if_name))
15806 vec_add1 (if_name, 0);
15807 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
15808 random_hw_addr = 0;
15809 else if (unformat (i, "pipe"))
15811 else if (unformat (i, "master"))
15813 else if (unformat (i, "slave"))
15819 if (!vec_len (if_name))
15821 errmsg ("interface name must be specified");
15825 if (vec_len (if_name) > 64)
15827 errmsg ("interface name too long");
15831 M (NETMAP_CREATE, mp);
15833 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
15834 clib_memcpy (mp->hw_addr, hw_addr, 6);
15835 mp->use_random_hw_addr = random_hw_addr;
15836 mp->is_pipe = is_pipe;
15837 mp->is_master = is_master;
15838 vec_free (if_name);
15846 api_netmap_delete (vat_main_t * vam)
15848 unformat_input_t *i = vam->input;
15849 vl_api_netmap_delete_t *mp;
15853 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15855 if (unformat (i, "name %s", &if_name))
15856 vec_add1 (if_name, 0);
15861 if (!vec_len (if_name))
15863 errmsg ("interface name must be specified");
15867 if (vec_len (if_name) > 64)
15869 errmsg ("interface name too long");
15873 M (NETMAP_DELETE, mp);
15875 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
15876 vec_free (if_name);
15883 static void vl_api_mpls_tunnel_details_t_handler
15884 (vl_api_mpls_tunnel_details_t * mp)
15886 vat_main_t *vam = &vat_main;
15887 i32 len = mp->mt_next_hop_n_labels;
15890 print (vam->ofp, "[%d]: via %U %d labels ",
15892 format_ip4_address, mp->mt_next_hop,
15893 ntohl (mp->mt_next_hop_sw_if_index));
15894 for (i = 0; i < len; i++)
15896 print (vam->ofp, "%u ", ntohl (mp->mt_next_hop_out_labels[i]));
15898 print (vam->ofp, "");
15901 static void vl_api_mpls_tunnel_details_t_handler_json
15902 (vl_api_mpls_tunnel_details_t * mp)
15904 vat_main_t *vam = &vat_main;
15905 vat_json_node_t *node = NULL;
15906 struct in_addr ip4;
15908 i32 len = mp->mt_next_hop_n_labels;
15910 if (VAT_JSON_ARRAY != vam->json_tree.type)
15912 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15913 vat_json_init_array (&vam->json_tree);
15915 node = vat_json_array_add (&vam->json_tree);
15917 vat_json_init_object (node);
15918 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
15919 clib_memcpy (&ip4, &(mp->mt_next_hop), sizeof (ip4));
15920 vat_json_object_add_ip4 (node, "next_hop", ip4);
15921 vat_json_object_add_uint (node, "next_hop_sw_if_index",
15922 ntohl (mp->mt_next_hop_sw_if_index));
15923 vat_json_object_add_uint (node, "l2_only", ntohl (mp->mt_l2_only));
15924 vat_json_object_add_uint (node, "label_count", len);
15925 for (i = 0; i < len; i++)
15927 vat_json_object_add_uint (node, "label",
15928 ntohl (mp->mt_next_hop_out_labels[i]));
15933 api_mpls_tunnel_dump (vat_main_t * vam)
15935 vl_api_mpls_tunnel_dump_t *mp;
15936 vl_api_control_ping_t *mp_ping;
15940 /* Parse args required to build the message */
15941 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
15943 if (!unformat (vam->input, "tunnel_index %d", &index))
15950 print (vam->ofp, " tunnel_index %d", index);
15952 M (MPLS_TUNNEL_DUMP, mp);
15953 mp->tunnel_index = htonl (index);
15956 /* Use a control ping for synchronization */
15957 M (CONTROL_PING, mp_ping);
15964 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
15965 #define vl_api_mpls_fib_details_t_print vl_noop_handler
15968 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
15970 vat_main_t *vam = &vat_main;
15971 int count = ntohl (mp->count);
15972 vl_api_fib_path2_t *fp;
15976 "table-id %d, label %u, ess_bit %u",
15977 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
15979 for (i = 0; i < count; i++)
15981 if (fp->afi == IP46_TYPE_IP6)
15983 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15984 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15985 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15986 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15987 format_ip6_address, fp->next_hop);
15988 else if (fp->afi == IP46_TYPE_IP4)
15990 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15991 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15992 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15993 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15994 format_ip4_address, fp->next_hop);
15999 static void vl_api_mpls_fib_details_t_handler_json
16000 (vl_api_mpls_fib_details_t * mp)
16002 vat_main_t *vam = &vat_main;
16003 int count = ntohl (mp->count);
16004 vat_json_node_t *node = NULL;
16005 struct in_addr ip4;
16006 struct in6_addr ip6;
16007 vl_api_fib_path2_t *fp;
16010 if (VAT_JSON_ARRAY != vam->json_tree.type)
16012 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16013 vat_json_init_array (&vam->json_tree);
16015 node = vat_json_array_add (&vam->json_tree);
16017 vat_json_init_object (node);
16018 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
16019 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
16020 vat_json_object_add_uint (node, "label", ntohl (mp->label));
16021 vat_json_object_add_uint (node, "path_count", count);
16023 for (i = 0; i < count; i++)
16025 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
16026 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
16027 vat_json_object_add_uint (node, "is_local", fp->is_local);
16028 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
16029 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
16030 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
16031 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
16032 if (fp->afi == IP46_TYPE_IP4)
16034 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
16035 vat_json_object_add_ip4 (node, "next_hop", ip4);
16037 else if (fp->afi == IP46_TYPE_IP6)
16039 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
16040 vat_json_object_add_ip6 (node, "next_hop", ip6);
16046 api_mpls_fib_dump (vat_main_t * vam)
16048 vl_api_mpls_fib_dump_t *mp;
16049 vl_api_control_ping_t *mp_ping;
16052 M (MPLS_FIB_DUMP, mp);
16055 /* Use a control ping for synchronization */
16056 M (CONTROL_PING, mp_ping);
16063 #define vl_api_ip_fib_details_t_endian vl_noop_handler
16064 #define vl_api_ip_fib_details_t_print vl_noop_handler
16067 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
16069 vat_main_t *vam = &vat_main;
16070 int count = ntohl (mp->count);
16071 vl_api_fib_path_t *fp;
16075 "table-id %d, prefix %U/%d",
16076 ntohl (mp->table_id), format_ip4_address, mp->address,
16077 mp->address_length);
16079 for (i = 0; i < count; i++)
16081 if (fp->afi == IP46_TYPE_IP6)
16083 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16084 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16085 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16086 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16087 format_ip6_address, fp->next_hop);
16088 else if (fp->afi == IP46_TYPE_IP4)
16090 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16091 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16092 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16093 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16094 format_ip4_address, fp->next_hop);
16099 static void vl_api_ip_fib_details_t_handler_json
16100 (vl_api_ip_fib_details_t * mp)
16102 vat_main_t *vam = &vat_main;
16103 int count = ntohl (mp->count);
16104 vat_json_node_t *node = NULL;
16105 struct in_addr ip4;
16106 struct in6_addr ip6;
16107 vl_api_fib_path_t *fp;
16110 if (VAT_JSON_ARRAY != vam->json_tree.type)
16112 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16113 vat_json_init_array (&vam->json_tree);
16115 node = vat_json_array_add (&vam->json_tree);
16117 vat_json_init_object (node);
16118 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
16119 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
16120 vat_json_object_add_ip4 (node, "prefix", ip4);
16121 vat_json_object_add_uint (node, "mask_length", mp->address_length);
16122 vat_json_object_add_uint (node, "path_count", count);
16124 for (i = 0; i < count; i++)
16126 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
16127 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
16128 vat_json_object_add_uint (node, "is_local", fp->is_local);
16129 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
16130 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
16131 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
16132 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
16133 if (fp->afi == IP46_TYPE_IP4)
16135 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
16136 vat_json_object_add_ip4 (node, "next_hop", ip4);
16138 else if (fp->afi == IP46_TYPE_IP6)
16140 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
16141 vat_json_object_add_ip6 (node, "next_hop", ip6);
16147 api_ip_fib_dump (vat_main_t * vam)
16149 vl_api_ip_fib_dump_t *mp;
16150 vl_api_control_ping_t *mp_ping;
16153 M (IP_FIB_DUMP, mp);
16156 /* Use a control ping for synchronization */
16157 M (CONTROL_PING, mp_ping);
16165 api_ip_mfib_dump (vat_main_t * vam)
16167 vl_api_ip_mfib_dump_t *mp;
16168 vl_api_control_ping_t *mp_ping;
16171 M (IP_MFIB_DUMP, mp);
16174 /* Use a control ping for synchronization */
16175 M (CONTROL_PING, mp_ping);
16182 static void vl_api_ip_neighbor_details_t_handler
16183 (vl_api_ip_neighbor_details_t * mp)
16185 vat_main_t *vam = &vat_main;
16187 print (vam->ofp, "%c %U %U",
16188 (mp->is_static) ? 'S' : 'D',
16189 format_ethernet_address, &mp->mac_address,
16190 (mp->is_ipv6) ? format_ip6_address : format_ip4_address,
16194 static void vl_api_ip_neighbor_details_t_handler_json
16195 (vl_api_ip_neighbor_details_t * mp)
16198 vat_main_t *vam = &vat_main;
16199 vat_json_node_t *node;
16200 struct in_addr ip4;
16201 struct in6_addr ip6;
16203 if (VAT_JSON_ARRAY != vam->json_tree.type)
16205 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16206 vat_json_init_array (&vam->json_tree);
16208 node = vat_json_array_add (&vam->json_tree);
16210 vat_json_init_object (node);
16211 vat_json_object_add_string_copy (node, "flag",
16212 (mp->is_static) ? (u8 *) "static" : (u8 *)
16215 vat_json_object_add_string_copy (node, "link_layer",
16216 format (0, "%U", format_ethernet_address,
16217 &mp->mac_address));
16221 clib_memcpy (&ip6, &mp->ip_address, sizeof (ip6));
16222 vat_json_object_add_ip6 (node, "ip_address", ip6);
16226 clib_memcpy (&ip4, &mp->ip_address, sizeof (ip4));
16227 vat_json_object_add_ip4 (node, "ip_address", ip4);
16232 api_ip_neighbor_dump (vat_main_t * vam)
16234 unformat_input_t *i = vam->input;
16235 vl_api_ip_neighbor_dump_t *mp;
16236 vl_api_control_ping_t *mp_ping;
16238 u32 sw_if_index = ~0;
16241 /* Parse args required to build the message */
16242 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16244 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16246 else if (unformat (i, "sw_if_index %d", &sw_if_index))
16248 else if (unformat (i, "ip6"))
16254 if (sw_if_index == ~0)
16256 errmsg ("missing interface name or sw_if_index");
16260 M (IP_NEIGHBOR_DUMP, mp);
16261 mp->is_ipv6 = (u8) is_ipv6;
16262 mp->sw_if_index = ntohl (sw_if_index);
16265 /* Use a control ping for synchronization */
16266 M (CONTROL_PING, mp_ping);
16273 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
16274 #define vl_api_ip6_fib_details_t_print vl_noop_handler
16277 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
16279 vat_main_t *vam = &vat_main;
16280 int count = ntohl (mp->count);
16281 vl_api_fib_path_t *fp;
16285 "table-id %d, prefix %U/%d",
16286 ntohl (mp->table_id), format_ip6_address, mp->address,
16287 mp->address_length);
16289 for (i = 0; i < count; i++)
16291 if (fp->afi == IP46_TYPE_IP6)
16293 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16294 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16295 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16296 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16297 format_ip6_address, fp->next_hop);
16298 else if (fp->afi == IP46_TYPE_IP4)
16300 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16301 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16302 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16303 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16304 format_ip4_address, fp->next_hop);
16309 static void vl_api_ip6_fib_details_t_handler_json
16310 (vl_api_ip6_fib_details_t * mp)
16312 vat_main_t *vam = &vat_main;
16313 int count = ntohl (mp->count);
16314 vat_json_node_t *node = NULL;
16315 struct in_addr ip4;
16316 struct in6_addr ip6;
16317 vl_api_fib_path_t *fp;
16320 if (VAT_JSON_ARRAY != vam->json_tree.type)
16322 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16323 vat_json_init_array (&vam->json_tree);
16325 node = vat_json_array_add (&vam->json_tree);
16327 vat_json_init_object (node);
16328 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
16329 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
16330 vat_json_object_add_ip6 (node, "prefix", ip6);
16331 vat_json_object_add_uint (node, "mask_length", mp->address_length);
16332 vat_json_object_add_uint (node, "path_count", count);
16334 for (i = 0; i < count; i++)
16336 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
16337 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
16338 vat_json_object_add_uint (node, "is_local", fp->is_local);
16339 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
16340 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
16341 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
16342 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
16343 if (fp->afi == IP46_TYPE_IP4)
16345 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
16346 vat_json_object_add_ip4 (node, "next_hop", ip4);
16348 else if (fp->afi == IP46_TYPE_IP6)
16350 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
16351 vat_json_object_add_ip6 (node, "next_hop", ip6);
16357 api_ip6_fib_dump (vat_main_t * vam)
16359 vl_api_ip6_fib_dump_t *mp;
16360 vl_api_control_ping_t *mp_ping;
16363 M (IP6_FIB_DUMP, mp);
16366 /* Use a control ping for synchronization */
16367 M (CONTROL_PING, mp_ping);
16375 api_ip6_mfib_dump (vat_main_t * vam)
16377 vl_api_ip6_mfib_dump_t *mp;
16378 vl_api_control_ping_t *mp_ping;
16381 M (IP6_MFIB_DUMP, mp);
16384 /* Use a control ping for synchronization */
16385 M (CONTROL_PING, mp_ping);
16393 api_classify_table_ids (vat_main_t * vam)
16395 vl_api_classify_table_ids_t *mp;
16398 /* Construct the API message */
16399 M (CLASSIFY_TABLE_IDS, mp);
16408 api_classify_table_by_interface (vat_main_t * vam)
16410 unformat_input_t *input = vam->input;
16411 vl_api_classify_table_by_interface_t *mp;
16413 u32 sw_if_index = ~0;
16415 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16417 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16419 else if (unformat (input, "sw_if_index %d", &sw_if_index))
16424 if (sw_if_index == ~0)
16426 errmsg ("missing interface name or sw_if_index");
16430 /* Construct the API message */
16431 M (CLASSIFY_TABLE_BY_INTERFACE, mp);
16433 mp->sw_if_index = ntohl (sw_if_index);
16441 api_classify_table_info (vat_main_t * vam)
16443 unformat_input_t *input = vam->input;
16444 vl_api_classify_table_info_t *mp;
16448 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16450 if (unformat (input, "table_id %d", &table_id))
16455 if (table_id == ~0)
16457 errmsg ("missing table id");
16461 /* Construct the API message */
16462 M (CLASSIFY_TABLE_INFO, mp);
16464 mp->table_id = ntohl (table_id);
16472 api_classify_session_dump (vat_main_t * vam)
16474 unformat_input_t *input = vam->input;
16475 vl_api_classify_session_dump_t *mp;
16476 vl_api_control_ping_t *mp_ping;
16480 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16482 if (unformat (input, "table_id %d", &table_id))
16487 if (table_id == ~0)
16489 errmsg ("missing table id");
16493 /* Construct the API message */
16494 M (CLASSIFY_SESSION_DUMP, mp);
16496 mp->table_id = ntohl (table_id);
16499 /* Use a control ping for synchronization */
16500 M (CONTROL_PING, mp_ping);
16508 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
16510 vat_main_t *vam = &vat_main;
16512 print (vam->ofp, "collector_address %U, collector_port %d, "
16513 "src_address %U, vrf_id %d, path_mtu %u, "
16514 "template_interval %u, udp_checksum %d",
16515 format_ip4_address, mp->collector_address,
16516 ntohs (mp->collector_port),
16517 format_ip4_address, mp->src_address,
16518 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
16519 ntohl (mp->template_interval), mp->udp_checksum);
16522 vam->result_ready = 1;
16526 vl_api_ipfix_exporter_details_t_handler_json
16527 (vl_api_ipfix_exporter_details_t * mp)
16529 vat_main_t *vam = &vat_main;
16530 vat_json_node_t node;
16531 struct in_addr collector_address;
16532 struct in_addr src_address;
16534 vat_json_init_object (&node);
16535 clib_memcpy (&collector_address, &mp->collector_address,
16536 sizeof (collector_address));
16537 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
16538 vat_json_object_add_uint (&node, "collector_port",
16539 ntohs (mp->collector_port));
16540 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
16541 vat_json_object_add_ip4 (&node, "src_address", src_address);
16542 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
16543 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
16544 vat_json_object_add_uint (&node, "template_interval",
16545 ntohl (mp->template_interval));
16546 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
16548 vat_json_print (vam->ofp, &node);
16549 vat_json_free (&node);
16551 vam->result_ready = 1;
16555 api_ipfix_exporter_dump (vat_main_t * vam)
16557 vl_api_ipfix_exporter_dump_t *mp;
16560 /* Construct the API message */
16561 M (IPFIX_EXPORTER_DUMP, mp);
16570 api_ipfix_classify_stream_dump (vat_main_t * vam)
16572 vl_api_ipfix_classify_stream_dump_t *mp;
16575 /* Construct the API message */
16576 M (IPFIX_CLASSIFY_STREAM_DUMP, mp);
16587 vl_api_ipfix_classify_stream_details_t_handler
16588 (vl_api_ipfix_classify_stream_details_t * mp)
16590 vat_main_t *vam = &vat_main;
16591 print (vam->ofp, "domain_id %d, src_port %d",
16592 ntohl (mp->domain_id), ntohs (mp->src_port));
16594 vam->result_ready = 1;
16598 vl_api_ipfix_classify_stream_details_t_handler_json
16599 (vl_api_ipfix_classify_stream_details_t * mp)
16601 vat_main_t *vam = &vat_main;
16602 vat_json_node_t node;
16604 vat_json_init_object (&node);
16605 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
16606 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
16608 vat_json_print (vam->ofp, &node);
16609 vat_json_free (&node);
16611 vam->result_ready = 1;
16615 api_ipfix_classify_table_dump (vat_main_t * vam)
16617 vl_api_ipfix_classify_table_dump_t *mp;
16618 vl_api_control_ping_t *mp_ping;
16621 if (!vam->json_output)
16623 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
16624 "transport_protocol");
16627 /* Construct the API message */
16628 M (IPFIX_CLASSIFY_TABLE_DUMP, mp);
16633 /* Use a control ping for synchronization */
16634 M (CONTROL_PING, mp_ping);
16642 vl_api_ipfix_classify_table_details_t_handler
16643 (vl_api_ipfix_classify_table_details_t * mp)
16645 vat_main_t *vam = &vat_main;
16646 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
16647 mp->transport_protocol);
16651 vl_api_ipfix_classify_table_details_t_handler_json
16652 (vl_api_ipfix_classify_table_details_t * mp)
16654 vat_json_node_t *node = NULL;
16655 vat_main_t *vam = &vat_main;
16657 if (VAT_JSON_ARRAY != vam->json_tree.type)
16659 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16660 vat_json_init_array (&vam->json_tree);
16663 node = vat_json_array_add (&vam->json_tree);
16664 vat_json_init_object (node);
16666 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
16667 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
16668 vat_json_object_add_uint (node, "transport_protocol",
16669 mp->transport_protocol);
16673 api_sw_interface_span_enable_disable (vat_main_t * vam)
16675 unformat_input_t *i = vam->input;
16676 vl_api_sw_interface_span_enable_disable_t *mp;
16677 u32 src_sw_if_index = ~0;
16678 u32 dst_sw_if_index = ~0;
16682 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16685 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
16687 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
16691 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
16693 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
16695 else if (unformat (i, "disable"))
16697 else if (unformat (i, "rx"))
16699 else if (unformat (i, "tx"))
16701 else if (unformat (i, "both"))
16707 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, mp);
16709 mp->sw_if_index_from = htonl (src_sw_if_index);
16710 mp->sw_if_index_to = htonl (dst_sw_if_index);
16719 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
16722 vat_main_t *vam = &vat_main;
16723 u8 *sw_if_from_name = 0;
16724 u8 *sw_if_to_name = 0;
16725 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
16726 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
16727 char *states[] = { "none", "rx", "tx", "both" };
16731 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
16733 if ((u32) p->value[0] == sw_if_index_from)
16735 sw_if_from_name = (u8 *)(p->key);
16739 if ((u32) p->value[0] == sw_if_index_to)
16741 sw_if_to_name = (u8 *)(p->key);
16742 if (sw_if_from_name)
16747 print (vam->ofp, "%20s => %20s (%s)",
16748 sw_if_from_name, sw_if_to_name, states[mp->state]);
16752 vl_api_sw_interface_span_details_t_handler_json
16753 (vl_api_sw_interface_span_details_t * mp)
16755 vat_main_t *vam = &vat_main;
16756 vat_json_node_t *node = NULL;
16757 u8 *sw_if_from_name = 0;
16758 u8 *sw_if_to_name = 0;
16759 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
16760 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
16764 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
16766 if ((u32) p->value[0] == sw_if_index_from)
16768 sw_if_from_name = (u8 *)(p->key);
16772 if ((u32) p->value[0] == sw_if_index_to)
16774 sw_if_to_name = (u8 *)(p->key);
16775 if (sw_if_from_name)
16781 if (VAT_JSON_ARRAY != vam->json_tree.type)
16783 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16784 vat_json_init_array (&vam->json_tree);
16786 node = vat_json_array_add (&vam->json_tree);
16788 vat_json_init_object (node);
16789 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
16790 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
16791 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
16792 if (0 != sw_if_to_name)
16794 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
16796 vat_json_object_add_uint (node, "state", mp->state);
16800 api_sw_interface_span_dump (vat_main_t * vam)
16802 vl_api_sw_interface_span_dump_t *mp;
16803 vl_api_control_ping_t *mp_ping;
16806 M (SW_INTERFACE_SPAN_DUMP, mp);
16809 /* Use a control ping for synchronization */
16810 M (CONTROL_PING, mp_ping);
16818 api_pg_create_interface (vat_main_t * vam)
16820 unformat_input_t *input = vam->input;
16821 vl_api_pg_create_interface_t *mp;
16825 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16827 if (unformat (input, "if_id %d", &if_id))
16834 errmsg ("missing pg interface index");
16838 /* Construct the API message */
16839 M (PG_CREATE_INTERFACE, mp);
16841 mp->interface_id = ntohl (if_id);
16849 api_pg_capture (vat_main_t * vam)
16851 unformat_input_t *input = vam->input;
16852 vl_api_pg_capture_t *mp;
16857 u8 pcap_file_set = 0;
16860 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16862 if (unformat (input, "if_id %d", &if_id))
16864 else if (unformat (input, "pcap %s", &pcap_file))
16866 else if (unformat (input, "count %d", &count))
16868 else if (unformat (input, "disable"))
16875 errmsg ("missing pg interface index");
16878 if (pcap_file_set > 0)
16880 if (vec_len (pcap_file) > 255)
16882 errmsg ("pcap file name is too long");
16887 u32 name_len = vec_len (pcap_file);
16888 /* Construct the API message */
16889 M (PG_CAPTURE, mp);
16891 mp->interface_id = ntohl (if_id);
16892 mp->is_enabled = enable;
16893 mp->count = ntohl (count);
16894 mp->pcap_name_length = ntohl (name_len);
16895 if (pcap_file_set != 0)
16897 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
16899 vec_free (pcap_file);
16907 api_pg_enable_disable (vat_main_t * vam)
16909 unformat_input_t *input = vam->input;
16910 vl_api_pg_enable_disable_t *mp;
16913 u8 stream_name_set = 0;
16914 u8 *stream_name = 0;
16916 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16918 if (unformat (input, "stream %s", &stream_name))
16919 stream_name_set = 1;
16920 else if (unformat (input, "disable"))
16926 if (stream_name_set > 0)
16928 if (vec_len (stream_name) > 255)
16930 errmsg ("stream name too long");
16935 u32 name_len = vec_len (stream_name);
16936 /* Construct the API message */
16937 M (PG_ENABLE_DISABLE, mp);
16939 mp->is_enabled = enable;
16940 if (stream_name_set != 0)
16942 mp->stream_name_length = ntohl (name_len);
16943 clib_memcpy (mp->stream_name, stream_name, name_len);
16945 vec_free (stream_name);
16953 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
16955 unformat_input_t *input = vam->input;
16956 vl_api_ip_source_and_port_range_check_add_del_t *mp;
16958 u16 *low_ports = 0;
16959 u16 *high_ports = 0;
16962 ip4_address_t ip4_addr;
16963 ip6_address_t ip6_addr;
16972 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16974 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
16980 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
16985 else if (unformat (input, "vrf %d", &vrf_id))
16987 else if (unformat (input, "del"))
16989 else if (unformat (input, "port %d", &tmp))
16991 if (tmp == 0 || tmp > 65535)
16993 errmsg ("port %d out of range", tmp);
16997 this_hi = this_low + 1;
16998 vec_add1 (low_ports, this_low);
16999 vec_add1 (high_ports, this_hi);
17001 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
17003 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
17005 errmsg ("incorrect range parameters");
17009 /* Note: in debug CLI +1 is added to high before
17010 passing to real fn that does "the work"
17011 (ip_source_and_port_range_check_add_del).
17012 This fn is a wrapper around the binary API fn a
17013 control plane will call, which expects this increment
17014 to have occurred. Hence letting the binary API control
17015 plane fn do the increment for consistency between VAT
17016 and other control planes.
17019 vec_add1 (low_ports, this_low);
17020 vec_add1 (high_ports, this_hi);
17026 if (prefix_set == 0)
17028 errmsg ("<address>/<mask> not specified");
17034 errmsg ("VRF ID required, not specified");
17041 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
17045 if (vec_len (low_ports) == 0)
17047 errmsg ("At least one port or port range required");
17051 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, mp);
17053 mp->is_add = is_add;
17058 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
17063 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
17066 mp->mask_length = length;
17067 mp->number_of_ranges = vec_len (low_ports);
17069 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
17070 vec_free (low_ports);
17072 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
17073 vec_free (high_ports);
17075 mp->vrf_id = ntohl (vrf_id);
17083 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
17085 unformat_input_t *input = vam->input;
17086 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
17087 u32 sw_if_index = ~0;
17089 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
17090 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
17094 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
17096 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17098 else if (unformat (input, "sw_if_index %d", &sw_if_index))
17100 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
17102 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
17104 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
17106 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
17108 else if (unformat (input, "del"))
17114 if (sw_if_index == ~0)
17116 errmsg ("Interface required but not specified");
17122 errmsg ("VRF ID required but not specified");
17126 if (tcp_out_vrf_id == 0
17127 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
17130 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
17134 /* Construct the API message */
17135 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, mp);
17137 mp->sw_if_index = ntohl (sw_if_index);
17138 mp->is_add = is_add;
17139 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
17140 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
17141 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
17142 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
17147 /* Wait for a reply... */
17153 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
17155 unformat_input_t *i = vam->input;
17156 vl_api_ipsec_gre_add_del_tunnel_t *mp;
17157 u32 local_sa_id = 0;
17158 u32 remote_sa_id = 0;
17159 ip4_address_t src_address;
17160 ip4_address_t dst_address;
17164 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17166 if (unformat (i, "local_sa %d", &local_sa_id))
17168 else if (unformat (i, "remote_sa %d", &remote_sa_id))
17170 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
17172 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
17174 else if (unformat (i, "del"))
17178 clib_warning ("parse error '%U'", format_unformat_error, i);
17183 M (IPSEC_GRE_ADD_DEL_TUNNEL, mp);
17185 mp->local_sa_id = ntohl (local_sa_id);
17186 mp->remote_sa_id = ntohl (remote_sa_id);
17187 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
17188 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
17189 mp->is_add = is_add;
17197 api_punt (vat_main_t * vam)
17199 unformat_input_t *i = vam->input;
17207 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17209 if (unformat (i, "ip %d", &ipv))
17211 else if (unformat (i, "protocol %d", &protocol))
17213 else if (unformat (i, "port %d", &port))
17215 else if (unformat (i, "del"))
17219 clib_warning ("parse error '%U'", format_unformat_error, i);
17226 mp->is_add = (u8) is_add;
17227 mp->ipv = (u8) ipv;
17228 mp->l4_protocol = (u8) protocol;
17229 mp->l4_port = htons ((u16) port);
17236 static void vl_api_ipsec_gre_tunnel_details_t_handler
17237 (vl_api_ipsec_gre_tunnel_details_t * mp)
17239 vat_main_t *vam = &vat_main;
17241 print (vam->ofp, "%11d%15U%15U%14d%14d",
17242 ntohl (mp->sw_if_index),
17243 format_ip4_address, &mp->src_address,
17244 format_ip4_address, &mp->dst_address,
17245 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
17248 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
17249 (vl_api_ipsec_gre_tunnel_details_t * mp)
17251 vat_main_t *vam = &vat_main;
17252 vat_json_node_t *node = NULL;
17253 struct in_addr ip4;
17255 if (VAT_JSON_ARRAY != vam->json_tree.type)
17257 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17258 vat_json_init_array (&vam->json_tree);
17260 node = vat_json_array_add (&vam->json_tree);
17262 vat_json_init_object (node);
17263 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
17264 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
17265 vat_json_object_add_ip4 (node, "src_address", ip4);
17266 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
17267 vat_json_object_add_ip4 (node, "dst_address", ip4);
17268 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
17269 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
17273 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
17275 unformat_input_t *i = vam->input;
17276 vl_api_ipsec_gre_tunnel_dump_t *mp;
17277 vl_api_control_ping_t *mp_ping;
17279 u8 sw_if_index_set = 0;
17282 /* Parse args required to build the message */
17283 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17285 if (unformat (i, "sw_if_index %d", &sw_if_index))
17286 sw_if_index_set = 1;
17291 if (sw_if_index_set == 0)
17296 if (!vam->json_output)
17298 print (vam->ofp, "%11s%15s%15s%14s%14s",
17299 "sw_if_index", "src_address", "dst_address",
17300 "local_sa_id", "remote_sa_id");
17303 /* Get list of gre-tunnel interfaces */
17304 M (IPSEC_GRE_TUNNEL_DUMP, mp);
17306 mp->sw_if_index = htonl (sw_if_index);
17310 /* Use a control ping for synchronization */
17311 M (CONTROL_PING, mp_ping);
17319 api_delete_subif (vat_main_t * vam)
17321 unformat_input_t *i = vam->input;
17322 vl_api_delete_subif_t *mp;
17323 u32 sw_if_index = ~0;
17326 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17328 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17330 if (unformat (i, "sw_if_index %d", &sw_if_index))
17336 if (sw_if_index == ~0)
17338 errmsg ("missing sw_if_index");
17342 /* Construct the API message */
17343 M (DELETE_SUBIF, mp);
17344 mp->sw_if_index = ntohl (sw_if_index);
17351 #define foreach_pbb_vtr_op \
17352 _("disable", L2_VTR_DISABLED) \
17353 _("pop", L2_VTR_POP_2) \
17354 _("push", L2_VTR_PUSH_2)
17357 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
17359 unformat_input_t *i = vam->input;
17360 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
17361 u32 sw_if_index = ~0, vtr_op = ~0;
17362 u16 outer_tag = ~0;
17363 u8 dmac[6], smac[6];
17364 u8 dmac_set = 0, smac_set = 0;
17370 /* Shut up coverity */
17371 memset (dmac, 0, sizeof (dmac));
17372 memset (smac, 0, sizeof (smac));
17374 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17376 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17378 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17380 else if (unformat (i, "vtr_op %d", &vtr_op))
17382 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
17385 else if (unformat (i, "translate_pbb_stag"))
17387 if (unformat (i, "%d", &tmp))
17389 vtr_op = L2_VTR_TRANSLATE_2_1;
17395 ("translate_pbb_stag operation requires outer tag definition");
17399 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
17401 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
17403 else if (unformat (i, "sid %d", &sid))
17405 else if (unformat (i, "vlanid %d", &tmp))
17409 clib_warning ("parse error '%U'", format_unformat_error, i);
17414 if ((sw_if_index == ~0) || (vtr_op == ~0))
17416 errmsg ("missing sw_if_index or vtr operation");
17419 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
17420 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
17423 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
17427 M (L2_INTERFACE_PBB_TAG_REWRITE, mp);
17428 mp->sw_if_index = ntohl (sw_if_index);
17429 mp->vtr_op = ntohl (vtr_op);
17430 mp->outer_tag = ntohs (outer_tag);
17431 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
17432 clib_memcpy (mp->b_smac, smac, sizeof (smac));
17433 mp->b_vlanid = ntohs (vlanid);
17434 mp->i_sid = ntohl (sid);
17442 api_flow_classify_set_interface (vat_main_t * vam)
17444 unformat_input_t *i = vam->input;
17445 vl_api_flow_classify_set_interface_t *mp;
17447 int sw_if_index_set;
17448 u32 ip4_table_index = ~0;
17449 u32 ip6_table_index = ~0;
17453 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17455 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17456 sw_if_index_set = 1;
17457 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17458 sw_if_index_set = 1;
17459 else if (unformat (i, "del"))
17461 else if (unformat (i, "ip4-table %d", &ip4_table_index))
17463 else if (unformat (i, "ip6-table %d", &ip6_table_index))
17467 clib_warning ("parse error '%U'", format_unformat_error, i);
17472 if (sw_if_index_set == 0)
17474 errmsg ("missing interface name or sw_if_index");
17478 M (FLOW_CLASSIFY_SET_INTERFACE, mp);
17480 mp->sw_if_index = ntohl (sw_if_index);
17481 mp->ip4_table_index = ntohl (ip4_table_index);
17482 mp->ip6_table_index = ntohl (ip6_table_index);
17483 mp->is_add = is_add;
17491 api_flow_classify_dump (vat_main_t * vam)
17493 unformat_input_t *i = vam->input;
17494 vl_api_flow_classify_dump_t *mp;
17495 vl_api_control_ping_t *mp_ping;
17496 u8 type = FLOW_CLASSIFY_N_TABLES;
17499 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
17503 errmsg ("classify table type must be specified");
17507 if (!vam->json_output)
17509 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
17512 M (FLOW_CLASSIFY_DUMP, mp);
17517 /* Use a control ping for synchronization */
17518 M (CONTROL_PING, mp_ping);
17521 /* Wait for a reply... */
17527 api_feature_enable_disable (vat_main_t * vam)
17529 unformat_input_t *i = vam->input;
17530 vl_api_feature_enable_disable_t *mp;
17532 u8 *feature_name = 0;
17533 u32 sw_if_index = ~0;
17537 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17539 if (unformat (i, "arc_name %s", &arc_name))
17541 else if (unformat (i, "feature_name %s", &feature_name))
17544 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17546 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17548 else if (unformat (i, "disable"))
17556 errmsg ("missing arc name");
17559 if (vec_len (arc_name) > 63)
17561 errmsg ("arc name too long");
17564 if (feature_name == 0)
17566 errmsg ("missing feature name");
17569 if (vec_len (feature_name) > 63)
17571 errmsg ("feature name too long");
17574 if (sw_if_index == ~0)
17576 errmsg ("missing interface name or sw_if_index");
17580 /* Construct the API message */
17581 M (FEATURE_ENABLE_DISABLE, mp);
17582 mp->sw_if_index = ntohl (sw_if_index);
17583 mp->enable = enable;
17584 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
17585 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
17586 vec_free (arc_name);
17587 vec_free (feature_name);
17595 api_sw_interface_tag_add_del (vat_main_t * vam)
17597 unformat_input_t *i = vam->input;
17598 vl_api_sw_interface_tag_add_del_t *mp;
17599 u32 sw_if_index = ~0;
17604 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17606 if (unformat (i, "tag %s", &tag))
17608 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17610 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17612 else if (unformat (i, "del"))
17618 if (sw_if_index == ~0)
17620 errmsg ("missing interface name or sw_if_index");
17624 if (enable && (tag == 0))
17626 errmsg ("no tag specified");
17630 /* Construct the API message */
17631 M (SW_INTERFACE_TAG_ADD_DEL, mp);
17632 mp->sw_if_index = ntohl (sw_if_index);
17633 mp->is_add = enable;
17635 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
17643 static void vl_api_l2_xconnect_details_t_handler
17644 (vl_api_l2_xconnect_details_t * mp)
17646 vat_main_t *vam = &vat_main;
17648 print (vam->ofp, "%15d%15d",
17649 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
17652 static void vl_api_l2_xconnect_details_t_handler_json
17653 (vl_api_l2_xconnect_details_t * mp)
17655 vat_main_t *vam = &vat_main;
17656 vat_json_node_t *node = NULL;
17658 if (VAT_JSON_ARRAY != vam->json_tree.type)
17660 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17661 vat_json_init_array (&vam->json_tree);
17663 node = vat_json_array_add (&vam->json_tree);
17665 vat_json_init_object (node);
17666 vat_json_object_add_uint (node, "rx_sw_if_index",
17667 ntohl (mp->rx_sw_if_index));
17668 vat_json_object_add_uint (node, "tx_sw_if_index",
17669 ntohl (mp->tx_sw_if_index));
17673 api_l2_xconnect_dump (vat_main_t * vam)
17675 vl_api_l2_xconnect_dump_t *mp;
17676 vl_api_control_ping_t *mp_ping;
17679 if (!vam->json_output)
17681 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
17684 M (L2_XCONNECT_DUMP, mp);
17688 /* Use a control ping for synchronization */
17689 M (CONTROL_PING, mp_ping);
17697 api_sw_interface_set_mtu (vat_main_t * vam)
17699 unformat_input_t *i = vam->input;
17700 vl_api_sw_interface_set_mtu_t *mp;
17701 u32 sw_if_index = ~0;
17705 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17707 if (unformat (i, "mtu %d", &mtu))
17709 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17711 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17717 if (sw_if_index == ~0)
17719 errmsg ("missing interface name or sw_if_index");
17725 errmsg ("no mtu specified");
17729 /* Construct the API message */
17730 M (SW_INTERFACE_SET_MTU, mp);
17731 mp->sw_if_index = ntohl (sw_if_index);
17732 mp->mtu = ntohs ((u16) mtu);
17741 q_or_quit (vat_main_t * vam)
17743 longjmp (vam->jump_buf, 1);
17744 return 0; /* not so much */
17748 q (vat_main_t * vam)
17750 return q_or_quit (vam);
17754 quit (vat_main_t * vam)
17756 return q_or_quit (vam);
17760 comment (vat_main_t * vam)
17766 cmd_cmp (void *a1, void *a2)
17771 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
17775 help (vat_main_t * vam)
17780 unformat_input_t *i = vam->input;
17783 if (unformat (i, "%s", &name))
17787 vec_add1 (name, 0);
17789 hs = hash_get_mem (vam->help_by_name, name);
17791 print (vam->ofp, "usage: %s %s", name, hs[0]);
17793 print (vam->ofp, "No such msg / command '%s'", name);
17798 print (vam->ofp, "Help is available for the following:");
17801 hash_foreach_pair (p, vam->function_by_name,
17803 vec_add1 (cmds, (u8 *)(p->key));
17807 vec_sort_with_function (cmds, cmd_cmp);
17809 for (j = 0; j < vec_len (cmds); j++)
17810 print (vam->ofp, "%s", cmds[j]);
17817 set (vat_main_t * vam)
17819 u8 *name = 0, *value = 0;
17820 unformat_input_t *i = vam->input;
17822 if (unformat (i, "%s", &name))
17824 /* The input buffer is a vector, not a string. */
17825 value = vec_dup (i->buffer);
17826 vec_delete (value, i->index, 0);
17827 /* Almost certainly has a trailing newline */
17828 if (value[vec_len (value) - 1] == '\n')
17829 value[vec_len (value) - 1] = 0;
17830 /* Make sure it's a proper string, one way or the other */
17831 vec_add1 (value, 0);
17832 (void) clib_macro_set_value (&vam->macro_main,
17833 (char *) name, (char *) value);
17836 errmsg ("usage: set <name> <value>");
17844 unset (vat_main_t * vam)
17848 if (unformat (vam->input, "%s", &name))
17849 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
17850 errmsg ("unset: %s wasn't set", name);
17863 macro_sort_cmp (void *a1, void *a2)
17865 macro_sort_t *s1 = a1;
17866 macro_sort_t *s2 = a2;
17868 return strcmp ((char *) (s1->name), (char *) (s2->name));
17872 dump_macro_table (vat_main_t * vam)
17874 macro_sort_t *sort_me = 0, *sm;
17879 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
17881 vec_add2 (sort_me, sm, 1);
17882 sm->name = (u8 *)(p->key);
17883 sm->value = (u8 *) (p->value[0]);
17887 vec_sort_with_function (sort_me, macro_sort_cmp);
17889 if (vec_len (sort_me))
17890 print (vam->ofp, "%-15s%s", "Name", "Value");
17892 print (vam->ofp, "The macro table is empty...");
17894 for (i = 0; i < vec_len (sort_me); i++)
17895 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
17900 dump_node_table (vat_main_t * vam)
17903 vlib_node_t *node, *next_node;
17905 if (vec_len (vam->graph_nodes) == 0)
17907 print (vam->ofp, "Node table empty, issue get_node_graph...");
17911 for (i = 0; i < vec_len (vam->graph_nodes); i++)
17913 node = vam->graph_nodes[i];
17914 print (vam->ofp, "[%d] %s", i, node->name);
17915 for (j = 0; j < vec_len (node->next_nodes); j++)
17917 if (node->next_nodes[j] != ~0)
17919 next_node = vam->graph_nodes[node->next_nodes[j]];
17920 print (vam->ofp, " [%d] %s", j, next_node->name);
17928 value_sort_cmp (void *a1, void *a2)
17930 name_sort_t *n1 = a1;
17931 name_sort_t *n2 = a2;
17933 if (n1->value < n2->value)
17935 if (n1->value > n2->value)
17942 dump_msg_api_table (vat_main_t * vam)
17944 api_main_t *am = &api_main;
17945 name_sort_t *nses = 0, *ns;
17950 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
17952 vec_add2 (nses, ns, 1);
17953 ns->name = (u8 *)(hp->key);
17954 ns->value = (u32) hp->value[0];
17958 vec_sort_with_function (nses, value_sort_cmp);
17960 for (i = 0; i < vec_len (nses); i++)
17961 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
17967 get_msg_id (vat_main_t * vam)
17972 if (unformat (vam->input, "%s", &name_and_crc))
17974 message_index = vl_api_get_msg_index (name_and_crc);
17975 if (message_index == ~0)
17977 print (vam->ofp, " '%s' not found", name_and_crc);
17980 print (vam->ofp, " '%s' has message index %d",
17981 name_and_crc, message_index);
17984 errmsg ("name_and_crc required...");
17989 search_node_table (vat_main_t * vam)
17991 unformat_input_t *line_input = vam->input;
17994 vlib_node_t *node, *next_node;
17997 if (vam->graph_node_index_by_name == 0)
17999 print (vam->ofp, "Node table empty, issue get_node_graph...");
18003 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
18005 if (unformat (line_input, "%s", &node_to_find))
18007 vec_add1 (node_to_find, 0);
18008 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
18011 print (vam->ofp, "%s not found...", node_to_find);
18014 node = vam->graph_nodes[p[0]];
18015 print (vam->ofp, "[%d] %s", p[0], node->name);
18016 for (j = 0; j < vec_len (node->next_nodes); j++)
18018 if (node->next_nodes[j] != ~0)
18020 next_node = vam->graph_nodes[node->next_nodes[j]];
18021 print (vam->ofp, " [%d] %s", j, next_node->name);
18028 clib_warning ("parse error '%U'", format_unformat_error,
18034 vec_free (node_to_find);
18043 script (vat_main_t * vam)
18045 #if (VPP_API_TEST_BUILTIN==0)
18047 char *save_current_file;
18048 unformat_input_t save_input;
18049 jmp_buf save_jump_buf;
18050 u32 save_line_number;
18052 FILE *new_fp, *save_ifp;
18054 if (unformat (vam->input, "%s", &s))
18056 new_fp = fopen ((char *) s, "r");
18059 errmsg ("Couldn't open script file %s", s);
18066 errmsg ("Missing script name");
18070 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
18071 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
18072 save_ifp = vam->ifp;
18073 save_line_number = vam->input_line_number;
18074 save_current_file = (char *) vam->current_file;
18076 vam->input_line_number = 0;
18078 vam->current_file = s;
18081 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
18082 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
18083 vam->ifp = save_ifp;
18084 vam->input_line_number = save_line_number;
18085 vam->current_file = (u8 *) save_current_file;
18090 clib_warning ("use the exec command...");
18096 echo (vat_main_t * vam)
18098 print (vam->ofp, "%v", vam->input->buffer);
18102 /* List of API message constructors, CLI names map to api_xxx */
18103 #define foreach_vpe_api_msg \
18104 _(create_loopback,"[mac <mac-addr>]") \
18105 _(sw_interface_dump,"") \
18106 _(sw_interface_set_flags, \
18107 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
18108 _(sw_interface_add_del_address, \
18109 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
18110 _(sw_interface_set_table, \
18111 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
18112 _(sw_interface_set_mpls_enable, \
18113 "<intfc> | sw_if_index [disable | dis]") \
18114 _(sw_interface_set_vpath, \
18115 "<intfc> | sw_if_index <id> enable | disable") \
18116 _(sw_interface_set_vxlan_bypass, \
18117 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
18118 _(sw_interface_set_l2_xconnect, \
18119 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
18120 "enable | disable") \
18121 _(sw_interface_set_l2_bridge, \
18122 "<intfc> | sw_if_index <id> bd_id <bridge-domain-id>\n" \
18123 "[shg <split-horizon-group>] [bvi]\n" \
18124 "enable | disable") \
18125 _(bridge_domain_add_del, \
18126 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n") \
18127 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
18129 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
18131 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
18133 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
18135 "tapname <name> mac <mac-addr> | random-mac [tag <string>]") \
18137 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
18139 "<vpp-if-name> | sw_if_index <id>") \
18140 _(sw_interface_tap_dump, "") \
18141 _(ip_add_del_route, \
18142 "<addr>/<mask> via <addr> [table-id <n>]\n" \
18143 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
18144 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
18145 "[multipath] [count <n>]") \
18146 _(ip_mroute_add_del, \
18147 "<src> <grp>/<mask> [table-id <n>]\n" \
18148 "[<intfc> | sw_if_index <id>] [local] [del]") \
18149 _(mpls_route_add_del, \
18150 "<label> <eos> via <addr> [table-id <n>]\n" \
18151 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
18152 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
18153 "[multipath] [count <n>]") \
18154 _(mpls_ip_bind_unbind, \
18155 "<label> <addr/len>") \
18156 _(mpls_tunnel_add_del, \
18157 " via <addr> [table-id <n>]\n" \
18158 "sw_if_index <id>] [l2] [del]") \
18159 _(proxy_arp_add_del, \
18160 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
18161 _(proxy_arp_intfc_enable_disable, \
18162 "<intfc> | sw_if_index <id> enable | disable") \
18163 _(sw_interface_set_unnumbered, \
18164 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
18165 _(ip_neighbor_add_del, \
18166 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
18167 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
18168 _(reset_vrf, "vrf <id> [ipv6]") \
18169 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
18170 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
18171 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
18172 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
18173 "[outer_vlan_id_any][inner_vlan_id_any]") \
18174 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
18175 _(reset_fib, "vrf <n> [ipv6]") \
18176 _(dhcp_proxy_config, \
18177 "svr <v46-address> src <v46-address>\n" \
18178 "insert-cid <n> [del]") \
18179 _(dhcp_proxy_config_2, \
18180 "svr <v46-address> src <v46-address>\n" \
18181 "rx_vrf_id <nn> server_vrf_id <nn> insert-cid <n> [del]") \
18182 _(dhcp_proxy_set_vss, \
18183 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
18184 _(dhcp_client_config, \
18185 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
18186 _(set_ip_flow_hash, \
18187 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
18188 _(sw_interface_ip6_enable_disable, \
18189 "<intfc> | sw_if_index <id> enable | disable") \
18190 _(sw_interface_ip6_set_link_local_address, \
18191 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
18192 _(sw_interface_ip6nd_ra_prefix, \
18193 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
18194 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
18195 "[nolink] [isno]") \
18196 _(sw_interface_ip6nd_ra_config, \
18197 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
18198 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
18199 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
18200 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
18201 _(l2_patch_add_del, \
18202 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
18203 "enable | disable") \
18204 _(sr_tunnel_add_del, \
18205 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
18206 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
18207 "[policy <policy_name>]") \
18208 _(sr_policy_add_del, \
18209 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
18210 _(sr_multicast_map_add_del, \
18211 "address [ip6 multicast address] sr-policy [policy name] [del]") \
18212 _(classify_add_del_table, \
18213 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
18214 " [del] [del-chain] mask <mask-value>\n" \
18215 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
18216 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
18217 _(classify_add_del_session, \
18218 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
18219 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
18220 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
18221 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
18222 _(classify_set_interface_ip_table, \
18223 "<intfc> | sw_if_index <nn> table <nn>") \
18224 _(classify_set_interface_l2_tables, \
18225 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
18226 " [other-table <nn>]") \
18227 _(get_node_index, "node <node-name") \
18228 _(add_node_next, "node <node-name> next <next-node-name>") \
18229 _(l2tpv3_create_tunnel, \
18230 "client_address <ip6-addr> our_address <ip6-addr>\n" \
18231 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
18232 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
18233 _(l2tpv3_set_tunnel_cookies, \
18234 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
18235 "[new_remote_cookie <nn>]\n") \
18236 _(l2tpv3_interface_enable_disable, \
18237 "<intfc> | sw_if_index <nn> enable | disable") \
18238 _(l2tpv3_set_lookup_key, \
18239 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
18240 _(sw_if_l2tpv3_tunnel_dump, "") \
18241 _(vxlan_add_del_tunnel, \
18242 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
18243 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
18244 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
18245 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
18246 _(gre_add_del_tunnel, \
18247 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [teb] [del]\n") \
18248 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
18249 _(l2_fib_clear_table, "") \
18250 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
18251 _(l2_interface_vlan_tag_rewrite, \
18252 "<intfc> | sw_if_index <nn> \n" \
18253 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
18254 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
18255 _(create_vhost_user_if, \
18256 "socket <filename> [server] [renumber <dev_instance>] " \
18257 "[mac <mac_address>]") \
18258 _(modify_vhost_user_if, \
18259 "<intfc> | sw_if_index <nn> socket <filename>\n" \
18260 "[server] [renumber <dev_instance>]") \
18261 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
18262 _(sw_interface_vhost_user_dump, "") \
18263 _(show_version, "") \
18264 _(vxlan_gpe_add_del_tunnel, \
18265 "local <addr> remote <addr> vni <nn>\n" \
18266 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
18267 "[next-ethernet] [next-nsh]\n") \
18268 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
18269 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
18270 _(interface_name_renumber, \
18271 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
18272 _(input_acl_set_interface, \
18273 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
18274 " [l2-table <nn>] [del]") \
18275 _(want_ip4_arp_events, "address <ip4-address> [del]") \
18276 _(want_ip6_nd_events, "address <ip6-address> [del]") \
18277 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
18278 _(ip_dump, "ipv4 | ipv6") \
18279 _(ipsec_spd_add_del, "spd_id <n> [del]") \
18280 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
18282 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
18283 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
18284 " integ_alg <alg> integ_key <hex>") \
18285 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
18286 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
18287 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
18288 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
18289 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
18290 _(ikev2_profile_add_del, "name <profile_name> [del]") \
18291 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
18292 "(auth_data 0x<data> | auth_data <data>)") \
18293 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
18294 "(id_data 0x<data> | id_data <data>) (local|remote)") \
18295 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
18296 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
18297 "(local|remote)") \
18298 _(ikev2_set_local_key, "file <absolute_file_path>") \
18299 _(ikev2_set_responder, "<profile_name> interface <interface> address <addr>") \
18300 _(ikev2_set_ike_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
18301 _(ikev2_set_esp_transforms, "<profile_name> <crypto alg> <key size> <integrity alg> <DH group>") \
18302 _(ikev2_set_sa_lifetime, "<profile_name> <seconds> <jitter> <handover> <max bytes>") \
18303 _(ikev2_initiate_sa_init, "<profile_name>") \
18304 _(ikev2_initiate_del_ike_sa, "<ispi>") \
18305 _(ikev2_initiate_del_child_sa, "<ispi>") \
18306 _(ikev2_initiate_rekey_child_sa, "<ispi>") \
18307 _(delete_loopback,"sw_if_index <nn>") \
18308 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
18309 _(map_add_domain, \
18310 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
18311 "ip6-src <ip6addr> " \
18312 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
18313 _(map_del_domain, "index <n>") \
18314 _(map_add_del_rule, \
18315 "index <n> psid <n> dst <ip6addr> [del]") \
18316 _(map_domain_dump, "") \
18317 _(map_rule_dump, "index <map-domain>") \
18318 _(want_interface_events, "enable|disable") \
18319 _(want_stats,"enable|disable") \
18320 _(get_first_msg_id, "client <name>") \
18321 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
18322 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
18323 "fib-id <nn> [ip4][ip6][default]") \
18324 _(get_node_graph, " ") \
18325 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
18326 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
18327 _(ioam_disable, "") \
18328 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
18329 " sw_if_index <sw_if_index> p <priority> " \
18330 "w <weight>] [del]") \
18331 _(lisp_add_del_locator, "locator-set <locator_name> " \
18332 "iface <intf> | sw_if_index <sw_if_index> " \
18333 "p <priority> w <weight> [del]") \
18334 _(lisp_add_del_local_eid,"vni <vni> eid " \
18335 "<ipv4|ipv6>/<prefix> | <L2 address> " \
18336 "locator-set <locator_name> [del]" \
18337 "[key-id sha1|sha256 secret-key <secret-key>]") \
18338 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
18339 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
18340 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
18341 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
18342 _(lisp_gpe_enable_disable, "enable|disable") \
18343 _(lisp_enable_disable, "enable|disable") \
18344 _(lisp_map_register_enable_disable, "enable|disable") \
18345 _(lisp_rloc_probe_enable_disable, "enable|disable") \
18346 _(lisp_gpe_add_del_iface, "up|down") \
18347 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
18349 "rloc <locator> p <prio> " \
18350 "w <weight> [rloc <loc> ... ] " \
18351 "action <action> [del-all]") \
18352 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
18354 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
18355 _(lisp_map_request_mode, "src-dst|dst-only") \
18356 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
18357 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
18358 _(lisp_locator_set_dump, "[local | remote]") \
18359 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
18360 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
18361 "[local] | [remote]") \
18362 _(lisp_eid_table_vni_dump, "") \
18363 _(lisp_eid_table_map_dump, "l2|l3") \
18364 _(lisp_map_resolver_dump, "") \
18365 _(lisp_map_server_dump, "") \
18366 _(lisp_adjacencies_get, "vni <vni>") \
18367 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
18368 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
18369 _(show_lisp_rloc_probe_state, "") \
18370 _(show_lisp_map_register_state, "") \
18371 _(show_lisp_status, "") \
18372 _(lisp_get_map_request_itr_rlocs, "") \
18373 _(show_lisp_pitr, "") \
18374 _(show_lisp_map_request_mode, "") \
18375 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
18376 _(af_packet_delete, "name <host interface name>") \
18377 _(policer_add_del, "name <policer name> <params> [del]") \
18378 _(policer_dump, "[name <policer name>]") \
18379 _(policer_classify_set_interface, \
18380 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
18381 " [l2-table <nn>] [del]") \
18382 _(policer_classify_dump, "type [ip4|ip6|l2]") \
18383 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
18384 "[master|slave]") \
18385 _(netmap_delete, "name <interface name>") \
18386 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
18387 _(mpls_fib_dump, "") \
18388 _(classify_table_ids, "") \
18389 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
18390 _(classify_table_info, "table_id <nn>") \
18391 _(classify_session_dump, "table_id <nn>") \
18392 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
18393 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
18394 "[template_interval <nn>] [udp_checksum]") \
18395 _(ipfix_exporter_dump, "") \
18396 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
18397 _(ipfix_classify_stream_dump, "") \
18398 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
18399 _(ipfix_classify_table_dump, "") \
18400 _(sw_interface_span_enable_disable, "[src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
18401 _(sw_interface_span_dump, "") \
18402 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
18403 _(pg_create_interface, "if_id <nn>") \
18404 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
18405 _(pg_enable_disable, "[stream <id>] disable") \
18406 _(ip_source_and_port_range_check_add_del, \
18407 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
18408 _(ip_source_and_port_range_check_interface_add_del, \
18409 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
18410 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
18411 _(ipsec_gre_add_del_tunnel, \
18412 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
18413 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
18414 _(delete_subif,"<intfc> | sw_if_index <nn>") \
18415 _(l2_interface_pbb_tag_rewrite, \
18416 "<intfc> | sw_if_index <nn> \n" \
18417 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
18418 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
18419 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
18420 _(flow_classify_set_interface, \
18421 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
18422 _(flow_classify_dump, "type [ip4|ip6]") \
18423 _(ip_fib_dump, "") \
18424 _(ip_mfib_dump, "") \
18425 _(ip6_fib_dump, "") \
18426 _(ip6_mfib_dump, "") \
18427 _(feature_enable_disable, "arc_name <arc_name> " \
18428 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
18429 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
18431 _(l2_xconnect_dump, "") \
18432 _(sw_interface_set_mtu, "<intfc> | sw_if_index <nn> mtu <nn>") \
18433 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
18434 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]")
18437 #define foreach_vpe_dpdk_api_msg \
18438 _(sw_interface_set_dpdk_hqos_pipe, \
18439 "rx <intfc> | sw_if_index <id> subport <subport-id> pipe <pipe-id>\n" \
18440 "profile <profile-id>\n") \
18441 _(sw_interface_set_dpdk_hqos_subport, \
18442 "rx <intfc> | sw_if_index <id> subport <subport-id> [rate <n>]\n" \
18443 "[bktsize <n>] [tc0 <n>] [tc1 <n>] [tc2 <n>] [tc3 <n>] [period <n>]\n") \
18444 _(sw_interface_set_dpdk_hqos_tctbl, \
18445 "rx <intfc> | sw_if_index <id> entry <n> tc <n> queue <n>\n")
18448 /* List of command functions, CLI names map directly to functions */
18449 #define foreach_cli_function \
18450 _(comment, "usage: comment <ignore-rest-of-line>") \
18451 _(dump_interface_table, "usage: dump_interface_table") \
18452 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
18453 _(dump_ipv4_table, "usage: dump_ipv4_table") \
18454 _(dump_ipv6_table, "usage: dump_ipv6_table") \
18455 _(dump_stats_table, "usage: dump_stats_table") \
18456 _(dump_macro_table, "usage: dump_macro_table ") \
18457 _(dump_node_table, "usage: dump_node_table") \
18458 _(dump_msg_api_table, "usage: dump_msg_api_table") \
18459 _(get_msg_id, "usage: get_msg_id name_and_crc") \
18460 _(echo, "usage: echo <message>") \
18461 _(exec, "usage: exec <vpe-debug-CLI-command>") \
18462 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
18463 _(help, "usage: help") \
18464 _(q, "usage: quit") \
18465 _(quit, "usage: quit") \
18466 _(search_node_table, "usage: search_node_table <name>...") \
18467 _(set, "usage: set <variable-name> <value>") \
18468 _(script, "usage: script <file-name>") \
18469 _(unset, "usage: unset <variable-name>")
18472 static void vl_api_##n##_t_handler_uni \
18473 (vl_api_##n##_t * mp) \
18475 vat_main_t * vam = &vat_main; \
18476 if (vam->json_output) { \
18477 vl_api_##n##_t_handler_json(mp); \
18479 vl_api_##n##_t_handler(mp); \
18482 foreach_vpe_api_reply_msg;
18487 static void vl_api_##n##_t_handler_uni \
18488 (vl_api_##n##_t * mp) \
18490 vat_main_t * vam = &vat_main; \
18491 if (vam->json_output) { \
18492 vl_api_##n##_t_handler_json(mp); \
18494 vl_api_##n##_t_handler(mp); \
18497 foreach_vpe_dpdk_api_reply_msg;
18502 vat_api_hookup (vat_main_t * vam)
18505 vl_msg_api_set_handlers(VL_API_##N, #n, \
18506 vl_api_##n##_t_handler_uni, \
18508 vl_api_##n##_t_endian, \
18509 vl_api_##n##_t_print, \
18510 sizeof(vl_api_##n##_t), 1);
18511 foreach_vpe_api_reply_msg;
18516 vl_msg_api_set_handlers(VL_API_##N, #n, \
18517 vl_api_##n##_t_handler_uni, \
18519 vl_api_##n##_t_endian, \
18520 vl_api_##n##_t_print, \
18521 sizeof(vl_api_##n##_t), 1);
18522 foreach_vpe_dpdk_api_reply_msg;
18526 #if (VPP_API_TEST_BUILTIN==0)
18527 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
18530 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
18532 vam->function_by_name = hash_create_string (0, sizeof (uword));
18534 vam->help_by_name = hash_create_string (0, sizeof (uword));
18536 /* API messages we can send */
18537 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
18538 foreach_vpe_api_msg;
18541 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
18542 foreach_vpe_dpdk_api_msg;
18547 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
18548 foreach_vpe_api_msg;
18551 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
18552 foreach_vpe_dpdk_api_msg;
18556 /* CLI functions */
18557 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
18558 foreach_cli_function;
18562 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
18563 foreach_cli_function;
18568 * fd.io coding-style-patch-verification: ON
18571 * eval: (c-set-style "gnu")