2 *------------------------------------------------------------------
5 * Copyright (c) 2014-2016 Cisco and/or its affiliates.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at:
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *------------------------------------------------------------------
21 #include <vlibapi/api.h>
22 #include <vlibmemory/api.h>
23 #include <vlibsocket/api.h>
24 #include <vnet/ip/ip.h>
25 #include <vnet/sr/sr_packet.h>
26 #include <vnet/l2/l2_input.h>
27 #include <vnet/l2tp/l2tp.h>
28 #include <vnet/vxlan/vxlan.h>
29 #include <vnet/gre/gre.h>
30 #include <vnet/vxlan-gpe/vxlan_gpe.h>
31 #include <vnet/lisp-gpe/lisp_gpe.h>
33 #include <vpp/api/vpe_msg_enum.h>
34 #include <vnet/l2/l2_classify.h>
35 #include <vnet/l2/l2_vtr.h>
36 #include <vnet/classify/input_acl.h>
37 #include <vnet/classify/policer_classify.h>
38 #include <vnet/classify/flow_classify.h>
39 #include <vnet/mpls/mpls.h>
40 #include <vnet/ipsec/ipsec.h>
41 #include <vnet/ipsec/ikev2.h>
43 #include <vnet/map/map.h>
44 #include <vnet/cop/cop.h>
45 #include <vnet/ip/ip6_hop_by_hop.h>
46 #include <vnet/ip/ip_source_and_port_range_check.h>
47 #include <vnet/policer/xlate.h>
48 #include <vnet/span/span.h>
49 #include <vnet/policer/policer.h>
50 #include <vnet/policer/police.h>
51 #include <vnet/mfib/mfib_types.h>
53 #include "vat/json_format.h"
58 #define vl_typedefs /* define message structures */
59 #include <vpp/api/vpe_all_api_h.h>
62 /* declare message handlers for each api */
64 #define vl_endianfun /* define message structures */
65 #include <vpp/api/vpe_all_api_h.h>
68 /* instantiate all the print functions we know about */
69 #define vl_print(handle, ...)
71 #include <vpp/api/vpe_all_api_h.h>
74 #define __plugin_msg_base 0
75 #include <vlibapi/vat_helper_macros.h>
78 vat_time_now (vat_main_t * vam)
80 #if VPP_API_TEST_BUILTIN
81 return vlib_time_now (vam->vlib_main);
83 return clib_time_now (&vam->clib_time);
88 errmsg (char *fmt, ...)
90 vat_main_t *vam = &vat_main;
95 s = va_format (0, fmt, &va);
100 #if VPP_API_TEST_BUILTIN
101 vlib_cli_output (vam->vlib_main, (char *) s);
104 if (vam->ifp != stdin)
105 fformat (vam->ofp, "%s(%d): \n", vam->current_file,
106 vam->input_line_number);
107 fformat (vam->ofp, (char *) s);
116 api_unformat_sw_if_index (unformat_input_t * input, va_list * args)
118 vat_main_t *vam = va_arg (*args, vat_main_t *);
119 u32 *result = va_arg (*args, u32 *);
123 if (!unformat (input, "%s", &if_name))
126 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
133 #if VPP_API_TEST_BUILTIN == 0
134 /* Parse an IP4 address %d.%d.%d.%d. */
136 unformat_ip4_address (unformat_input_t * input, va_list * args)
138 u8 *result = va_arg (*args, u8 *);
141 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
144 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
156 unformat_ethernet_address (unformat_input_t * input, va_list * args)
158 u8 *result = va_arg (*args, u8 *);
161 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
162 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
166 for (i = 0; i < 6; i++)
167 if (a[i] >= (1 << 8))
170 for (i = 0; i < 6; i++)
176 /* Returns ethernet type as an int in host byte order. */
178 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
181 u16 *result = va_arg (*args, u16 *);
185 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
187 if (type >= (1 << 16))
195 /* Parse an IP6 address. */
197 unformat_ip6_address (unformat_input_t * input, va_list * args)
199 ip6_address_t *result = va_arg (*args, ip6_address_t *);
201 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
202 uword c, n_colon, double_colon_index;
204 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
205 double_colon_index = ARRAY_LEN (hex_quads);
206 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
209 if (c >= '0' && c <= '9')
211 else if (c >= 'a' && c <= 'f')
212 hex_digit = c + 10 - 'a';
213 else if (c >= 'A' && c <= 'F')
214 hex_digit = c + 10 - 'A';
215 else if (c == ':' && n_colon < 2)
219 unformat_put_input (input);
223 /* Too many hex quads. */
224 if (n_hex_quads >= ARRAY_LEN (hex_quads))
229 hex_quad = (hex_quad << 4) | hex_digit;
231 /* Hex quad must fit in 16 bits. */
232 if (n_hex_digits >= 4)
239 /* Save position of :: */
242 /* More than one :: ? */
243 if (double_colon_index < ARRAY_LEN (hex_quads))
245 double_colon_index = n_hex_quads;
248 if (n_colon > 0 && n_hex_digits > 0)
250 hex_quads[n_hex_quads++] = hex_quad;
256 if (n_hex_digits > 0)
257 hex_quads[n_hex_quads++] = hex_quad;
262 /* Expand :: to appropriate number of zero hex quads. */
263 if (double_colon_index < ARRAY_LEN (hex_quads))
265 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
267 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
268 hex_quads[n_zero + i] = hex_quads[i];
270 for (i = 0; i < n_zero; i++)
271 hex_quads[double_colon_index + i] = 0;
273 n_hex_quads = ARRAY_LEN (hex_quads);
276 /* Too few hex quads given. */
277 if (n_hex_quads < ARRAY_LEN (hex_quads))
280 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
281 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
288 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
290 u32 *r = va_arg (*args, u32 *);
293 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
294 foreach_ipsec_policy_action
302 unformat_ipsec_crypto_alg (unformat_input_t * input, va_list * args)
304 u32 *r = va_arg (*args, u32 *);
307 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_CRYPTO_ALG_##f;
308 foreach_ipsec_crypto_alg
316 format_ipsec_crypto_alg (u8 * s, va_list * args)
318 u32 i = va_arg (*args, u32);
323 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
324 foreach_ipsec_crypto_alg
327 return format (s, "unknown");
329 return format (s, "%s", t);
333 unformat_ipsec_integ_alg (unformat_input_t * input, va_list * args)
335 u32 *r = va_arg (*args, u32 *);
338 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_INTEG_ALG_##f;
339 foreach_ipsec_integ_alg
347 format_ipsec_integ_alg (u8 * s, va_list * args)
349 u32 i = va_arg (*args, u32);
354 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
355 foreach_ipsec_integ_alg
358 return format (s, "unknown");
360 return format (s, "%s", t);
364 unformat_ikev2_auth_method (unformat_input_t * input, va_list * args)
366 u32 *r = va_arg (*args, u32 *);
369 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_AUTH_METHOD_##f;
370 foreach_ikev2_auth_method
378 unformat_ikev2_id_type (unformat_input_t * input, va_list * args)
380 u32 *r = va_arg (*args, u32 *);
383 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_ID_TYPE_##f;
384 foreach_ikev2_id_type
390 #endif /* VPP_API_TEST_BUILTIN */
393 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
395 u8 *r = va_arg (*args, u8 *);
397 if (unformat (input, "kbps"))
398 *r = SSE2_QOS_RATE_KBPS;
399 else if (unformat (input, "pps"))
400 *r = SSE2_QOS_RATE_PPS;
407 unformat_policer_round_type (unformat_input_t * input, va_list * args)
409 u8 *r = va_arg (*args, u8 *);
411 if (unformat (input, "closest"))
412 *r = SSE2_QOS_ROUND_TO_CLOSEST;
413 else if (unformat (input, "up"))
414 *r = SSE2_QOS_ROUND_TO_UP;
415 else if (unformat (input, "down"))
416 *r = SSE2_QOS_ROUND_TO_DOWN;
423 unformat_policer_type (unformat_input_t * input, va_list * args)
425 u8 *r = va_arg (*args, u8 *);
427 if (unformat (input, "1r2c"))
428 *r = SSE2_QOS_POLICER_TYPE_1R2C;
429 else if (unformat (input, "1r3c"))
430 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
431 else if (unformat (input, "2r3c-2698"))
432 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
433 else if (unformat (input, "2r3c-4115"))
434 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
435 else if (unformat (input, "2r3c-mef5cf1"))
436 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
443 unformat_dscp (unformat_input_t * input, va_list * va)
445 u8 *r = va_arg (*va, u8 *);
448 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
457 unformat_policer_action_type (unformat_input_t * input, va_list * va)
459 sse2_qos_pol_action_params_st *a
460 = va_arg (*va, sse2_qos_pol_action_params_st *);
462 if (unformat (input, "drop"))
463 a->action_type = SSE2_QOS_ACTION_DROP;
464 else if (unformat (input, "transmit"))
465 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
466 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
467 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
474 unformat_policer_classify_table_type (unformat_input_t * input, va_list * va)
476 u32 *r = va_arg (*va, u32 *);
479 if (unformat (input, "ip4"))
480 tid = POLICER_CLASSIFY_TABLE_IP4;
481 else if (unformat (input, "ip6"))
482 tid = POLICER_CLASSIFY_TABLE_IP6;
483 else if (unformat (input, "l2"))
484 tid = POLICER_CLASSIFY_TABLE_L2;
493 unformat_flow_classify_table_type (unformat_input_t * input, va_list * va)
495 u32 *r = va_arg (*va, u32 *);
498 if (unformat (input, "ip4"))
499 tid = FLOW_CLASSIFY_TABLE_IP4;
500 else if (unformat (input, "ip6"))
501 tid = FLOW_CLASSIFY_TABLE_IP6;
509 static const char *mfib_flag_names[] = MFIB_ENTRY_NAMES_SHORT;
510 static const char *mfib_flag_long_names[] = MFIB_ENTRY_NAMES_LONG;
511 static const char *mfib_itf_flag_long_names[] = MFIB_ITF_NAMES_LONG;
512 static const char *mfib_itf_flag_names[] = MFIB_ITF_NAMES_SHORT;
515 unformat_mfib_itf_flags (unformat_input_t * input, va_list * args)
517 mfib_itf_flags_t old, *iflags = va_arg (*args, mfib_itf_flags_t *);
518 mfib_itf_attribute_t attr;
521 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
523 if (unformat (input, mfib_itf_flag_long_names[attr]))
524 *iflags |= (1 << attr);
526 FOR_EACH_MFIB_ITF_ATTRIBUTE (attr)
528 if (unformat (input, mfib_itf_flag_names[attr]))
529 *iflags |= (1 << attr);
532 return (old == *iflags ? 0 : 1);
536 unformat_mfib_entry_flags (unformat_input_t * input, va_list * args)
538 mfib_entry_flags_t old, *eflags = va_arg (*args, mfib_entry_flags_t *);
539 mfib_entry_attribute_t attr;
542 FOR_EACH_MFIB_ATTRIBUTE (attr)
544 if (unformat (input, mfib_flag_long_names[attr]))
545 *eflags |= (1 << attr);
547 FOR_EACH_MFIB_ATTRIBUTE (attr)
549 if (unformat (input, mfib_flag_names[attr]))
550 *eflags |= (1 << attr);
553 return (old == *eflags ? 0 : 1);
556 #if (VPP_API_TEST_BUILTIN==0)
558 format_ip4_address (u8 * s, va_list * args)
560 u8 *a = va_arg (*args, u8 *);
561 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
565 format_ip6_address (u8 * s, va_list * args)
567 ip6_address_t *a = va_arg (*args, ip6_address_t *);
568 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
570 i_max_n_zero = ARRAY_LEN (a->as_u16);
572 i_first_zero = i_max_n_zero;
574 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
576 u32 is_zero = a->as_u16[i] == 0;
577 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
583 if ((!is_zero && n_zeros > max_n_zeros)
584 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
586 i_max_n_zero = i_first_zero;
587 max_n_zeros = n_zeros;
588 i_first_zero = ARRAY_LEN (a->as_u16);
593 last_double_colon = 0;
594 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
596 if (i == i_max_n_zero && max_n_zeros > 1)
598 s = format (s, "::");
599 i += max_n_zeros - 1;
600 last_double_colon = 1;
604 s = format (s, "%s%x",
605 (last_double_colon || i == 0) ? "" : ":",
606 clib_net_to_host_u16 (a->as_u16[i]));
607 last_double_colon = 0;
614 /* Format an IP46 address. */
616 format_ip46_address (u8 * s, va_list * args)
618 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
619 ip46_type_t type = va_arg (*args, ip46_type_t);
625 is_ip4 = ip46_address_is_ip4 (ip46);
636 format (s, "%U", format_ip4_address, &ip46->ip4) :
637 format (s, "%U", format_ip6_address, &ip46->ip6);
641 format_ethernet_address (u8 * s, va_list * args)
643 u8 *a = va_arg (*args, u8 *);
645 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
646 a[0], a[1], a[2], a[3], a[4], a[5]);
651 increment_v4_address (ip4_address_t * a)
655 v = ntohl (a->as_u32) + 1;
656 a->as_u32 = ntohl (v);
660 increment_v6_address (ip6_address_t * a)
664 v0 = clib_net_to_host_u64 (a->as_u64[0]);
665 v1 = clib_net_to_host_u64 (a->as_u64[1]);
670 a->as_u64[0] = clib_net_to_host_u64 (v0);
671 a->as_u64[1] = clib_net_to_host_u64 (v1);
675 increment_mac_address (u64 * mac)
679 tmp = clib_net_to_host_u64 (tmp);
680 tmp += 1 << 16; /* skip unused (least significant) octets */
681 tmp = clib_host_to_net_u64 (tmp);
685 static void vl_api_create_loopback_reply_t_handler
686 (vl_api_create_loopback_reply_t * mp)
688 vat_main_t *vam = &vat_main;
689 i32 retval = ntohl (mp->retval);
691 vam->retval = retval;
692 vam->regenerate_interface_table = 1;
693 vam->sw_if_index = ntohl (mp->sw_if_index);
694 vam->result_ready = 1;
697 static void vl_api_create_loopback_reply_t_handler_json
698 (vl_api_create_loopback_reply_t * mp)
700 vat_main_t *vam = &vat_main;
701 vat_json_node_t node;
703 vat_json_init_object (&node);
704 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
705 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
707 vat_json_print (vam->ofp, &node);
708 vat_json_free (&node);
709 vam->retval = ntohl (mp->retval);
710 vam->result_ready = 1;
713 static void vl_api_af_packet_create_reply_t_handler
714 (vl_api_af_packet_create_reply_t * mp)
716 vat_main_t *vam = &vat_main;
717 i32 retval = ntohl (mp->retval);
719 vam->retval = retval;
720 vam->regenerate_interface_table = 1;
721 vam->sw_if_index = ntohl (mp->sw_if_index);
722 vam->result_ready = 1;
725 static void vl_api_af_packet_create_reply_t_handler_json
726 (vl_api_af_packet_create_reply_t * mp)
728 vat_main_t *vam = &vat_main;
729 vat_json_node_t node;
731 vat_json_init_object (&node);
732 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
733 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
735 vat_json_print (vam->ofp, &node);
736 vat_json_free (&node);
738 vam->retval = ntohl (mp->retval);
739 vam->result_ready = 1;
742 static void vl_api_create_vlan_subif_reply_t_handler
743 (vl_api_create_vlan_subif_reply_t * mp)
745 vat_main_t *vam = &vat_main;
746 i32 retval = ntohl (mp->retval);
748 vam->retval = retval;
749 vam->regenerate_interface_table = 1;
750 vam->sw_if_index = ntohl (mp->sw_if_index);
751 vam->result_ready = 1;
754 static void vl_api_create_vlan_subif_reply_t_handler_json
755 (vl_api_create_vlan_subif_reply_t * mp)
757 vat_main_t *vam = &vat_main;
758 vat_json_node_t node;
760 vat_json_init_object (&node);
761 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
762 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
764 vat_json_print (vam->ofp, &node);
765 vat_json_free (&node);
767 vam->retval = ntohl (mp->retval);
768 vam->result_ready = 1;
771 static void vl_api_create_subif_reply_t_handler
772 (vl_api_create_subif_reply_t * mp)
774 vat_main_t *vam = &vat_main;
775 i32 retval = ntohl (mp->retval);
777 vam->retval = retval;
778 vam->regenerate_interface_table = 1;
779 vam->sw_if_index = ntohl (mp->sw_if_index);
780 vam->result_ready = 1;
783 static void vl_api_create_subif_reply_t_handler_json
784 (vl_api_create_subif_reply_t * mp)
786 vat_main_t *vam = &vat_main;
787 vat_json_node_t node;
789 vat_json_init_object (&node);
790 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
791 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
793 vat_json_print (vam->ofp, &node);
794 vat_json_free (&node);
796 vam->retval = ntohl (mp->retval);
797 vam->result_ready = 1;
800 static void vl_api_interface_name_renumber_reply_t_handler
801 (vl_api_interface_name_renumber_reply_t * mp)
803 vat_main_t *vam = &vat_main;
804 i32 retval = ntohl (mp->retval);
806 vam->retval = retval;
807 vam->regenerate_interface_table = 1;
808 vam->result_ready = 1;
811 static void vl_api_interface_name_renumber_reply_t_handler_json
812 (vl_api_interface_name_renumber_reply_t * mp)
814 vat_main_t *vam = &vat_main;
815 vat_json_node_t node;
817 vat_json_init_object (&node);
818 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
820 vat_json_print (vam->ofp, &node);
821 vat_json_free (&node);
823 vam->retval = ntohl (mp->retval);
824 vam->result_ready = 1;
828 * Special-case: build the interface table, maintain
829 * the next loopback sw_if_index vbl.
831 static void vl_api_sw_interface_details_t_handler
832 (vl_api_sw_interface_details_t * mp)
834 vat_main_t *vam = &vat_main;
835 u8 *s = format (0, "%s%c", mp->interface_name, 0);
837 hash_set_mem (vam->sw_if_index_by_interface_name, s,
838 ntohl (mp->sw_if_index));
840 /* In sub interface case, fill the sub interface table entry */
841 if (mp->sw_if_index != mp->sup_sw_if_index)
843 sw_interface_subif_t *sub = NULL;
845 vec_add2 (vam->sw_if_subif_table, sub, 1);
847 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
848 strncpy ((char *) sub->interface_name, (char *) s,
849 vec_len (sub->interface_name));
850 sub->sw_if_index = ntohl (mp->sw_if_index);
851 sub->sub_id = ntohl (mp->sub_id);
853 sub->sub_dot1ad = mp->sub_dot1ad;
854 sub->sub_number_of_tags = mp->sub_number_of_tags;
855 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
856 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
857 sub->sub_exact_match = mp->sub_exact_match;
858 sub->sub_default = mp->sub_default;
859 sub->sub_outer_vlan_id_any = mp->sub_outer_vlan_id_any;
860 sub->sub_inner_vlan_id_any = mp->sub_inner_vlan_id_any;
862 /* vlan tag rewrite */
863 sub->vtr_op = ntohl (mp->vtr_op);
864 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
865 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
866 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
870 static void vl_api_sw_interface_details_t_handler_json
871 (vl_api_sw_interface_details_t * mp)
873 vat_main_t *vam = &vat_main;
874 vat_json_node_t *node = NULL;
876 if (VAT_JSON_ARRAY != vam->json_tree.type)
878 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
879 vat_json_init_array (&vam->json_tree);
881 node = vat_json_array_add (&vam->json_tree);
883 vat_json_init_object (node);
884 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
885 vat_json_object_add_uint (node, "sup_sw_if_index",
886 ntohl (mp->sup_sw_if_index));
887 vat_json_object_add_uint (node, "l2_address_length",
888 ntohl (mp->l2_address_length));
889 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
890 sizeof (mp->l2_address));
891 vat_json_object_add_string_copy (node, "interface_name",
893 vat_json_object_add_uint (node, "admin_up_down", mp->admin_up_down);
894 vat_json_object_add_uint (node, "link_up_down", mp->link_up_down);
895 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
896 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
897 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
898 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
899 vat_json_object_add_uint (node, "sub_dot1ad", mp->sub_dot1ad);
900 vat_json_object_add_uint (node, "sub_number_of_tags",
901 mp->sub_number_of_tags);
902 vat_json_object_add_uint (node, "sub_outer_vlan_id",
903 ntohs (mp->sub_outer_vlan_id));
904 vat_json_object_add_uint (node, "sub_inner_vlan_id",
905 ntohs (mp->sub_inner_vlan_id));
906 vat_json_object_add_uint (node, "sub_exact_match", mp->sub_exact_match);
907 vat_json_object_add_uint (node, "sub_default", mp->sub_default);
908 vat_json_object_add_uint (node, "sub_outer_vlan_id_any",
909 mp->sub_outer_vlan_id_any);
910 vat_json_object_add_uint (node, "sub_inner_vlan_id_any",
911 mp->sub_inner_vlan_id_any);
912 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
913 vat_json_object_add_uint (node, "vtr_push_dot1q",
914 ntohl (mp->vtr_push_dot1q));
915 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
916 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
919 static void vl_api_sw_interface_set_flags_t_handler
920 (vl_api_sw_interface_set_flags_t * mp)
922 vat_main_t *vam = &vat_main;
923 if (vam->interface_event_display)
924 errmsg ("interface flags: sw_if_index %d %s %s",
925 ntohl (mp->sw_if_index),
926 mp->admin_up_down ? "admin-up" : "admin-down",
927 mp->link_up_down ? "link-up" : "link-down");
930 static void vl_api_sw_interface_set_flags_t_handler_json
931 (vl_api_sw_interface_set_flags_t * mp)
933 /* JSON output not supported */
937 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
939 vat_main_t *vam = &vat_main;
940 i32 retval = ntohl (mp->retval);
942 vam->retval = retval;
943 vam->shmem_result = (u8 *) mp->reply_in_shmem;
944 vam->result_ready = 1;
948 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
950 vat_main_t *vam = &vat_main;
951 vat_json_node_t node;
952 api_main_t *am = &api_main;
956 vat_json_init_object (&node);
957 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
958 vat_json_object_add_uint (&node, "reply_in_shmem",
959 ntohl (mp->reply_in_shmem));
960 /* Toss the shared-memory original... */
961 pthread_mutex_lock (&am->vlib_rp->mutex);
962 oldheap = svm_push_data_heap (am->vlib_rp);
964 reply = (u8 *) (mp->reply_in_shmem);
967 svm_pop_heap (oldheap);
968 pthread_mutex_unlock (&am->vlib_rp->mutex);
970 vat_json_print (vam->ofp, &node);
971 vat_json_free (&node);
973 vam->retval = ntohl (mp->retval);
974 vam->result_ready = 1;
978 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
980 vat_main_t *vam = &vat_main;
981 i32 retval = ntohl (mp->retval);
983 vam->retval = retval;
984 vam->cmd_reply = mp->reply;
985 vam->result_ready = 1;
989 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
991 vat_main_t *vam = &vat_main;
992 vat_json_node_t node;
994 vat_json_init_object (&node);
995 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
996 vat_json_object_add_string_copy (&node, "reply", mp->reply);
998 vat_json_print (vam->ofp, &node);
999 vat_json_free (&node);
1001 vam->retval = ntohl (mp->retval);
1002 vam->result_ready = 1;
1005 static void vl_api_classify_add_del_table_reply_t_handler
1006 (vl_api_classify_add_del_table_reply_t * mp)
1008 vat_main_t *vam = &vat_main;
1009 i32 retval = ntohl (mp->retval);
1010 if (vam->async_mode)
1012 vam->async_errors += (retval < 0);
1016 vam->retval = retval;
1018 ((mp->new_table_index != 0xFFFFFFFF) ||
1019 (mp->skip_n_vectors != 0xFFFFFFFF) ||
1020 (mp->match_n_vectors != 0xFFFFFFFF)))
1022 * Note: this is just barely thread-safe, depends on
1023 * the main thread spinning waiting for an answer...
1025 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d",
1026 ntohl (mp->new_table_index),
1027 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
1028 vam->result_ready = 1;
1032 static void vl_api_classify_add_del_table_reply_t_handler_json
1033 (vl_api_classify_add_del_table_reply_t * mp)
1035 vat_main_t *vam = &vat_main;
1036 vat_json_node_t node;
1038 vat_json_init_object (&node);
1039 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1040 vat_json_object_add_uint (&node, "new_table_index",
1041 ntohl (mp->new_table_index));
1042 vat_json_object_add_uint (&node, "skip_n_vectors",
1043 ntohl (mp->skip_n_vectors));
1044 vat_json_object_add_uint (&node, "match_n_vectors",
1045 ntohl (mp->match_n_vectors));
1047 vat_json_print (vam->ofp, &node);
1048 vat_json_free (&node);
1050 vam->retval = ntohl (mp->retval);
1051 vam->result_ready = 1;
1054 static void vl_api_get_node_index_reply_t_handler
1055 (vl_api_get_node_index_reply_t * mp)
1057 vat_main_t *vam = &vat_main;
1058 i32 retval = ntohl (mp->retval);
1059 if (vam->async_mode)
1061 vam->async_errors += (retval < 0);
1065 vam->retval = retval;
1067 errmsg ("node index %d", ntohl (mp->node_index));
1068 vam->result_ready = 1;
1072 static void vl_api_get_node_index_reply_t_handler_json
1073 (vl_api_get_node_index_reply_t * mp)
1075 vat_main_t *vam = &vat_main;
1076 vat_json_node_t node;
1078 vat_json_init_object (&node);
1079 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1080 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1082 vat_json_print (vam->ofp, &node);
1083 vat_json_free (&node);
1085 vam->retval = ntohl (mp->retval);
1086 vam->result_ready = 1;
1089 static void vl_api_get_next_index_reply_t_handler
1090 (vl_api_get_next_index_reply_t * mp)
1092 vat_main_t *vam = &vat_main;
1093 i32 retval = ntohl (mp->retval);
1094 if (vam->async_mode)
1096 vam->async_errors += (retval < 0);
1100 vam->retval = retval;
1102 errmsg ("next node index %d", ntohl (mp->next_index));
1103 vam->result_ready = 1;
1107 static void vl_api_get_next_index_reply_t_handler_json
1108 (vl_api_get_next_index_reply_t * mp)
1110 vat_main_t *vam = &vat_main;
1111 vat_json_node_t node;
1113 vat_json_init_object (&node);
1114 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1115 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1117 vat_json_print (vam->ofp, &node);
1118 vat_json_free (&node);
1120 vam->retval = ntohl (mp->retval);
1121 vam->result_ready = 1;
1124 static void vl_api_add_node_next_reply_t_handler
1125 (vl_api_add_node_next_reply_t * mp)
1127 vat_main_t *vam = &vat_main;
1128 i32 retval = ntohl (mp->retval);
1129 if (vam->async_mode)
1131 vam->async_errors += (retval < 0);
1135 vam->retval = retval;
1137 errmsg ("next index %d", ntohl (mp->next_index));
1138 vam->result_ready = 1;
1142 static void vl_api_add_node_next_reply_t_handler_json
1143 (vl_api_add_node_next_reply_t * mp)
1145 vat_main_t *vam = &vat_main;
1146 vat_json_node_t node;
1148 vat_json_init_object (&node);
1149 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1150 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1152 vat_json_print (vam->ofp, &node);
1153 vat_json_free (&node);
1155 vam->retval = ntohl (mp->retval);
1156 vam->result_ready = 1;
1159 static void vl_api_show_version_reply_t_handler
1160 (vl_api_show_version_reply_t * mp)
1162 vat_main_t *vam = &vat_main;
1163 i32 retval = ntohl (mp->retval);
1167 errmsg (" program: %s", mp->program);
1168 errmsg (" version: %s", mp->version);
1169 errmsg (" build date: %s", mp->build_date);
1170 errmsg ("build directory: %s", mp->build_directory);
1172 vam->retval = retval;
1173 vam->result_ready = 1;
1176 static void vl_api_show_version_reply_t_handler_json
1177 (vl_api_show_version_reply_t * mp)
1179 vat_main_t *vam = &vat_main;
1180 vat_json_node_t node;
1182 vat_json_init_object (&node);
1183 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1184 vat_json_object_add_string_copy (&node, "program", mp->program);
1185 vat_json_object_add_string_copy (&node, "version", mp->version);
1186 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1187 vat_json_object_add_string_copy (&node, "build_directory",
1188 mp->build_directory);
1190 vat_json_print (vam->ofp, &node);
1191 vat_json_free (&node);
1193 vam->retval = ntohl (mp->retval);
1194 vam->result_ready = 1;
1198 vl_api_ip4_arp_event_t_handler (vl_api_ip4_arp_event_t * mp)
1200 errmsg ("arp %s event: address %U new mac %U sw_if_index %d",
1201 mp->mac_ip ? "mac/ip binding" : "address resolution",
1202 format_ip4_address, &mp->address,
1203 format_ethernet_address, mp->new_mac, mp->sw_if_index);
1207 vl_api_ip4_arp_event_t_handler_json (vl_api_ip4_arp_event_t * mp)
1209 /* JSON output not supported */
1213 vl_api_ip6_nd_event_t_handler (vl_api_ip6_nd_event_t * mp)
1215 errmsg ("ip6 nd %s event: address %U new mac %U sw_if_index %d",
1216 mp->mac_ip ? "mac/ip binding" : "address resolution",
1217 format_ip6_address, mp->address,
1218 format_ethernet_address, mp->new_mac, mp->sw_if_index);
1222 vl_api_ip6_nd_event_t_handler_json (vl_api_ip6_nd_event_t * mp)
1224 /* JSON output not supported */
1228 * Special-case: build the bridge domain table, maintain
1229 * the next bd id vbl.
1231 static void vl_api_bridge_domain_details_t_handler
1232 (vl_api_bridge_domain_details_t * mp)
1234 vat_main_t *vam = &vat_main;
1235 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1237 print (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-3s",
1238 " ID", "LRN", "FWD", "FLD", "BVI", "#IF");
1240 print (vam->ofp, "%3d %3d %3d %3d %3d %3d",
1241 ntohl (mp->bd_id), mp->learn, mp->forward,
1242 mp->flood, ntohl (mp->bvi_sw_if_index), n_sw_ifs);
1245 print (vam->ofp, "\n\n%s %s %s", "sw_if_index", "SHG", "Interface Name");
1248 static void vl_api_bridge_domain_details_t_handler_json
1249 (vl_api_bridge_domain_details_t * mp)
1251 vat_main_t *vam = &vat_main;
1252 vat_json_node_t *node, *array = NULL;
1254 if (VAT_JSON_ARRAY != vam->json_tree.type)
1256 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1257 vat_json_init_array (&vam->json_tree);
1259 node = vat_json_array_add (&vam->json_tree);
1261 vat_json_init_object (node);
1262 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1263 vat_json_object_add_uint (node, "flood", mp->flood);
1264 vat_json_object_add_uint (node, "forward", mp->forward);
1265 vat_json_object_add_uint (node, "learn", mp->learn);
1266 vat_json_object_add_uint (node, "bvi_sw_if_index",
1267 ntohl (mp->bvi_sw_if_index));
1268 vat_json_object_add_uint (node, "n_sw_ifs", ntohl (mp->n_sw_ifs));
1269 array = vat_json_object_add (node, "sw_if");
1270 vat_json_init_array (array);
1274 * Special-case: build the bridge domain sw if table.
1276 static void vl_api_bridge_domain_sw_if_details_t_handler
1277 (vl_api_bridge_domain_sw_if_details_t * mp)
1279 vat_main_t *vam = &vat_main;
1284 sw_if_index = ntohl (mp->sw_if_index);
1286 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1288 if ((u32) p->value[0] == sw_if_index)
1290 sw_if_name = (u8 *)(p->key);
1296 print (vam->ofp, "%7d %3d %s", sw_if_index,
1297 mp->shg, sw_if_name ? (char *) sw_if_name :
1298 "sw_if_index not found!");
1301 static void vl_api_bridge_domain_sw_if_details_t_handler_json
1302 (vl_api_bridge_domain_sw_if_details_t * mp)
1304 vat_main_t *vam = &vat_main;
1305 vat_json_node_t *node = NULL;
1306 uword last_index = 0;
1308 ASSERT (VAT_JSON_ARRAY == vam->json_tree.type);
1309 ASSERT (vec_len (vam->json_tree.array) >= 1);
1310 last_index = vec_len (vam->json_tree.array) - 1;
1311 node = &vam->json_tree.array[last_index];
1312 node = vat_json_object_get_element (node, "sw_if");
1313 ASSERT (NULL != node);
1314 node = vat_json_array_add (node);
1316 vat_json_init_object (node);
1317 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1318 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
1319 vat_json_object_add_uint (node, "shg", mp->shg);
1322 static void vl_api_control_ping_reply_t_handler
1323 (vl_api_control_ping_reply_t * mp)
1325 vat_main_t *vam = &vat_main;
1326 i32 retval = ntohl (mp->retval);
1327 if (vam->async_mode)
1329 vam->async_errors += (retval < 0);
1333 vam->retval = retval;
1334 vam->result_ready = 1;
1338 static void vl_api_control_ping_reply_t_handler_json
1339 (vl_api_control_ping_reply_t * mp)
1341 vat_main_t *vam = &vat_main;
1342 i32 retval = ntohl (mp->retval);
1344 if (VAT_JSON_NONE != vam->json_tree.type)
1346 vat_json_print (vam->ofp, &vam->json_tree);
1347 vat_json_free (&vam->json_tree);
1348 vam->json_tree.type = VAT_JSON_NONE;
1353 vat_json_init_array (&vam->json_tree);
1354 vat_json_print (vam->ofp, &vam->json_tree);
1355 vam->json_tree.type = VAT_JSON_NONE;
1358 vam->retval = retval;
1359 vam->result_ready = 1;
1363 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1365 vat_main_t *vam = &vat_main;
1366 i32 retval = ntohl (mp->retval);
1367 if (vam->async_mode)
1369 vam->async_errors += (retval < 0);
1373 vam->retval = retval;
1374 vam->result_ready = 1;
1378 static void vl_api_l2_flags_reply_t_handler_json
1379 (vl_api_l2_flags_reply_t * mp)
1381 vat_main_t *vam = &vat_main;
1382 vat_json_node_t node;
1384 vat_json_init_object (&node);
1385 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1386 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1387 ntohl (mp->resulting_feature_bitmap));
1389 vat_json_print (vam->ofp, &node);
1390 vat_json_free (&node);
1392 vam->retval = ntohl (mp->retval);
1393 vam->result_ready = 1;
1396 static void vl_api_bridge_flags_reply_t_handler
1397 (vl_api_bridge_flags_reply_t * mp)
1399 vat_main_t *vam = &vat_main;
1400 i32 retval = ntohl (mp->retval);
1401 if (vam->async_mode)
1403 vam->async_errors += (retval < 0);
1407 vam->retval = retval;
1408 vam->result_ready = 1;
1412 static void vl_api_bridge_flags_reply_t_handler_json
1413 (vl_api_bridge_flags_reply_t * mp)
1415 vat_main_t *vam = &vat_main;
1416 vat_json_node_t node;
1418 vat_json_init_object (&node);
1419 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1420 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1421 ntohl (mp->resulting_feature_bitmap));
1423 vat_json_print (vam->ofp, &node);
1424 vat_json_free (&node);
1426 vam->retval = ntohl (mp->retval);
1427 vam->result_ready = 1;
1430 static void vl_api_tap_connect_reply_t_handler
1431 (vl_api_tap_connect_reply_t * mp)
1433 vat_main_t *vam = &vat_main;
1434 i32 retval = ntohl (mp->retval);
1435 if (vam->async_mode)
1437 vam->async_errors += (retval < 0);
1441 vam->retval = retval;
1442 vam->sw_if_index = ntohl (mp->sw_if_index);
1443 vam->result_ready = 1;
1448 static void vl_api_tap_connect_reply_t_handler_json
1449 (vl_api_tap_connect_reply_t * mp)
1451 vat_main_t *vam = &vat_main;
1452 vat_json_node_t node;
1454 vat_json_init_object (&node);
1455 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1456 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1458 vat_json_print (vam->ofp, &node);
1459 vat_json_free (&node);
1461 vam->retval = ntohl (mp->retval);
1462 vam->result_ready = 1;
1467 vl_api_tap_modify_reply_t_handler (vl_api_tap_modify_reply_t * mp)
1469 vat_main_t *vam = &vat_main;
1470 i32 retval = ntohl (mp->retval);
1471 if (vam->async_mode)
1473 vam->async_errors += (retval < 0);
1477 vam->retval = retval;
1478 vam->sw_if_index = ntohl (mp->sw_if_index);
1479 vam->result_ready = 1;
1483 static void vl_api_tap_modify_reply_t_handler_json
1484 (vl_api_tap_modify_reply_t * mp)
1486 vat_main_t *vam = &vat_main;
1487 vat_json_node_t node;
1489 vat_json_init_object (&node);
1490 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1491 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1493 vat_json_print (vam->ofp, &node);
1494 vat_json_free (&node);
1496 vam->retval = ntohl (mp->retval);
1497 vam->result_ready = 1;
1501 vl_api_tap_delete_reply_t_handler (vl_api_tap_delete_reply_t * mp)
1503 vat_main_t *vam = &vat_main;
1504 i32 retval = ntohl (mp->retval);
1505 if (vam->async_mode)
1507 vam->async_errors += (retval < 0);
1511 vam->retval = retval;
1512 vam->result_ready = 1;
1516 static void vl_api_tap_delete_reply_t_handler_json
1517 (vl_api_tap_delete_reply_t * mp)
1519 vat_main_t *vam = &vat_main;
1520 vat_json_node_t node;
1522 vat_json_init_object (&node);
1523 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1525 vat_json_print (vam->ofp, &node);
1526 vat_json_free (&node);
1528 vam->retval = ntohl (mp->retval);
1529 vam->result_ready = 1;
1532 static void vl_api_mpls_tunnel_add_del_reply_t_handler
1533 (vl_api_mpls_tunnel_add_del_reply_t * mp)
1535 vat_main_t *vam = &vat_main;
1536 i32 retval = ntohl (mp->retval);
1537 if (vam->async_mode)
1539 vam->async_errors += (retval < 0);
1543 vam->retval = retval;
1544 vam->result_ready = 1;
1548 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
1549 (vl_api_mpls_tunnel_add_del_reply_t * mp)
1551 vat_main_t *vam = &vat_main;
1552 vat_json_node_t node;
1554 vat_json_init_object (&node);
1555 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1556 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
1557 ntohl (mp->sw_if_index));
1559 vat_json_print (vam->ofp, &node);
1560 vat_json_free (&node);
1562 vam->retval = ntohl (mp->retval);
1563 vam->result_ready = 1;
1566 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
1567 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1569 vat_main_t *vam = &vat_main;
1570 i32 retval = ntohl (mp->retval);
1571 if (vam->async_mode)
1573 vam->async_errors += (retval < 0);
1577 vam->retval = retval;
1578 vam->sw_if_index = ntohl (mp->sw_if_index);
1579 vam->result_ready = 1;
1583 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
1584 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1586 vat_main_t *vam = &vat_main;
1587 vat_json_node_t node;
1589 vat_json_init_object (&node);
1590 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1591 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1593 vat_json_print (vam->ofp, &node);
1594 vat_json_free (&node);
1596 vam->retval = ntohl (mp->retval);
1597 vam->result_ready = 1;
1601 static void vl_api_lisp_add_del_locator_set_reply_t_handler
1602 (vl_api_lisp_add_del_locator_set_reply_t * mp)
1604 vat_main_t *vam = &vat_main;
1605 i32 retval = ntohl (mp->retval);
1606 if (vam->async_mode)
1608 vam->async_errors += (retval < 0);
1612 vam->retval = retval;
1613 vam->result_ready = 1;
1617 static void vl_api_lisp_add_del_locator_set_reply_t_handler_json
1618 (vl_api_lisp_add_del_locator_set_reply_t * mp)
1620 vat_main_t *vam = &vat_main;
1621 vat_json_node_t node;
1623 vat_json_init_object (&node);
1624 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1625 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
1627 vat_json_print (vam->ofp, &node);
1628 vat_json_free (&node);
1630 vam->retval = ntohl (mp->retval);
1631 vam->result_ready = 1;
1634 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
1635 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1637 vat_main_t *vam = &vat_main;
1638 i32 retval = ntohl (mp->retval);
1639 if (vam->async_mode)
1641 vam->async_errors += (retval < 0);
1645 vam->retval = retval;
1646 vam->sw_if_index = ntohl (mp->sw_if_index);
1647 vam->result_ready = 1;
1651 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
1652 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1654 vat_main_t *vam = &vat_main;
1655 vat_json_node_t node;
1657 vat_json_init_object (&node);
1658 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1659 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1661 vat_json_print (vam->ofp, &node);
1662 vat_json_free (&node);
1664 vam->retval = ntohl (mp->retval);
1665 vam->result_ready = 1;
1668 static void vl_api_gre_add_del_tunnel_reply_t_handler
1669 (vl_api_gre_add_del_tunnel_reply_t * mp)
1671 vat_main_t *vam = &vat_main;
1672 i32 retval = ntohl (mp->retval);
1673 if (vam->async_mode)
1675 vam->async_errors += (retval < 0);
1679 vam->retval = retval;
1680 vam->sw_if_index = ntohl (mp->sw_if_index);
1681 vam->result_ready = 1;
1685 static void vl_api_gre_add_del_tunnel_reply_t_handler_json
1686 (vl_api_gre_add_del_tunnel_reply_t * mp)
1688 vat_main_t *vam = &vat_main;
1689 vat_json_node_t node;
1691 vat_json_init_object (&node);
1692 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1693 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1695 vat_json_print (vam->ofp, &node);
1696 vat_json_free (&node);
1698 vam->retval = ntohl (mp->retval);
1699 vam->result_ready = 1;
1702 static void vl_api_create_vhost_user_if_reply_t_handler
1703 (vl_api_create_vhost_user_if_reply_t * mp)
1705 vat_main_t *vam = &vat_main;
1706 i32 retval = ntohl (mp->retval);
1707 if (vam->async_mode)
1709 vam->async_errors += (retval < 0);
1713 vam->retval = retval;
1714 vam->sw_if_index = ntohl (mp->sw_if_index);
1715 vam->result_ready = 1;
1719 static void vl_api_create_vhost_user_if_reply_t_handler_json
1720 (vl_api_create_vhost_user_if_reply_t * mp)
1722 vat_main_t *vam = &vat_main;
1723 vat_json_node_t node;
1725 vat_json_init_object (&node);
1726 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1727 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1729 vat_json_print (vam->ofp, &node);
1730 vat_json_free (&node);
1732 vam->retval = ntohl (mp->retval);
1733 vam->result_ready = 1;
1736 static void vl_api_ip_address_details_t_handler
1737 (vl_api_ip_address_details_t * mp)
1739 vat_main_t *vam = &vat_main;
1740 static ip_address_details_t empty_ip_address_details = { {0} };
1741 ip_address_details_t *address = NULL;
1742 ip_details_t *current_ip_details = NULL;
1743 ip_details_t *details = NULL;
1745 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
1747 if (!details || vam->current_sw_if_index >= vec_len (details)
1748 || !details[vam->current_sw_if_index].present)
1750 errmsg ("ip address details arrived but not stored");
1751 errmsg ("ip_dump should be called first");
1755 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
1757 #define addresses (current_ip_details->addr)
1759 vec_validate_init_empty (addresses, vec_len (addresses),
1760 empty_ip_address_details);
1762 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
1764 clib_memcpy (&address->ip, &mp->ip, sizeof (address->ip));
1765 address->prefix_length = mp->prefix_length;
1769 static void vl_api_ip_address_details_t_handler_json
1770 (vl_api_ip_address_details_t * mp)
1772 vat_main_t *vam = &vat_main;
1773 vat_json_node_t *node = NULL;
1774 struct in6_addr ip6;
1777 if (VAT_JSON_ARRAY != vam->json_tree.type)
1779 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1780 vat_json_init_array (&vam->json_tree);
1782 node = vat_json_array_add (&vam->json_tree);
1784 vat_json_init_object (node);
1787 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
1788 vat_json_object_add_ip6 (node, "ip", ip6);
1792 clib_memcpy (&ip4, mp->ip, sizeof (ip4));
1793 vat_json_object_add_ip4 (node, "ip", ip4);
1795 vat_json_object_add_uint (node, "prefix_length", mp->prefix_length);
1799 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
1801 vat_main_t *vam = &vat_main;
1802 static ip_details_t empty_ip_details = { 0 };
1803 ip_details_t *ip = NULL;
1804 u32 sw_if_index = ~0;
1806 sw_if_index = ntohl (mp->sw_if_index);
1808 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1809 sw_if_index, empty_ip_details);
1811 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1818 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
1820 vat_main_t *vam = &vat_main;
1822 if (VAT_JSON_ARRAY != vam->json_tree.type)
1824 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1825 vat_json_init_array (&vam->json_tree);
1827 vat_json_array_add_uint (&vam->json_tree,
1828 clib_net_to_host_u32 (mp->sw_if_index));
1831 static void vl_api_map_domain_details_t_handler_json
1832 (vl_api_map_domain_details_t * mp)
1834 vat_json_node_t *node = NULL;
1835 vat_main_t *vam = &vat_main;
1836 struct in6_addr ip6;
1839 if (VAT_JSON_ARRAY != vam->json_tree.type)
1841 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1842 vat_json_init_array (&vam->json_tree);
1845 node = vat_json_array_add (&vam->json_tree);
1846 vat_json_init_object (node);
1848 vat_json_object_add_uint (node, "domain_index",
1849 clib_net_to_host_u32 (mp->domain_index));
1850 clib_memcpy (&ip6, mp->ip6_prefix, sizeof (ip6));
1851 vat_json_object_add_ip6 (node, "ip6_prefix", ip6);
1852 clib_memcpy (&ip4, mp->ip4_prefix, sizeof (ip4));
1853 vat_json_object_add_ip4 (node, "ip4_prefix", ip4);
1854 clib_memcpy (&ip6, mp->ip6_src, sizeof (ip6));
1855 vat_json_object_add_ip6 (node, "ip6_src", ip6);
1856 vat_json_object_add_int (node, "ip6_prefix_len", mp->ip6_prefix_len);
1857 vat_json_object_add_int (node, "ip4_prefix_len", mp->ip4_prefix_len);
1858 vat_json_object_add_int (node, "ip6_src_len", mp->ip6_src_len);
1859 vat_json_object_add_int (node, "ea_bits_len", mp->ea_bits_len);
1860 vat_json_object_add_int (node, "psid_offset", mp->psid_offset);
1861 vat_json_object_add_int (node, "psid_length", mp->psid_length);
1862 vat_json_object_add_uint (node, "flags", mp->flags);
1863 vat_json_object_add_uint (node, "mtu", clib_net_to_host_u16 (mp->mtu));
1864 vat_json_object_add_int (node, "is_translation", mp->is_translation);
1867 static void vl_api_map_domain_details_t_handler
1868 (vl_api_map_domain_details_t * mp)
1870 vat_main_t *vam = &vat_main;
1872 if (mp->is_translation)
1875 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U/%d (ip6-src) index: %u",
1876 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1877 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1878 format_ip6_address, mp->ip6_src, mp->ip6_src_len,
1879 clib_net_to_host_u32 (mp->domain_index));
1884 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U (ip6-src) index: %u",
1885 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1886 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1887 format_ip6_address, mp->ip6_src,
1888 clib_net_to_host_u32 (mp->domain_index));
1890 print (vam->ofp, " ea-len %d psid-offset %d psid-len %d mtu %d %s",
1891 mp->ea_bits_len, mp->psid_offset, mp->psid_length, mp->mtu,
1892 mp->is_translation ? "map-t" : "");
1895 static void vl_api_map_rule_details_t_handler_json
1896 (vl_api_map_rule_details_t * mp)
1898 struct in6_addr ip6;
1899 vat_json_node_t *node = NULL;
1900 vat_main_t *vam = &vat_main;
1902 if (VAT_JSON_ARRAY != vam->json_tree.type)
1904 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1905 vat_json_init_array (&vam->json_tree);
1908 node = vat_json_array_add (&vam->json_tree);
1909 vat_json_init_object (node);
1911 vat_json_object_add_uint (node, "psid", clib_net_to_host_u16 (mp->psid));
1912 clib_memcpy (&ip6, mp->ip6_dst, sizeof (ip6));
1913 vat_json_object_add_ip6 (node, "ip6_dst", ip6);
1917 vl_api_map_rule_details_t_handler (vl_api_map_rule_details_t * mp)
1919 vat_main_t *vam = &vat_main;
1920 print (vam->ofp, " %d (psid) %U (ip6-dst)",
1921 clib_net_to_host_u16 (mp->psid), format_ip6_address, mp->ip6_dst);
1925 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
1927 errmsg ("DHCP compl event: pid %d %s hostname %s host_addr %U "
1928 "router_addr %U host_mac %U",
1929 mp->pid, mp->is_ipv6 ? "ipv6" : "ipv4", mp->hostname,
1930 format_ip4_address, &mp->host_address,
1931 format_ip4_address, &mp->router_address,
1932 format_ethernet_address, mp->host_mac);
1935 static void vl_api_dhcp_compl_event_t_handler_json
1936 (vl_api_dhcp_compl_event_t * mp)
1938 /* JSON output not supported */
1942 set_simple_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1945 vat_main_t *vam = &vat_main;
1946 static u64 default_counter = 0;
1948 vec_validate_init_empty (vam->simple_interface_counters, vnet_counter_type,
1950 vec_validate_init_empty (vam->simple_interface_counters[vnet_counter_type],
1951 sw_if_index, default_counter);
1952 vam->simple_interface_counters[vnet_counter_type][sw_if_index] = counter;
1956 set_combined_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1957 interface_counter_t counter)
1959 vat_main_t *vam = &vat_main;
1960 static interface_counter_t default_counter = { 0, };
1962 vec_validate_init_empty (vam->combined_interface_counters,
1963 vnet_counter_type, NULL);
1964 vec_validate_init_empty (vam->combined_interface_counters
1965 [vnet_counter_type], sw_if_index, default_counter);
1966 vam->combined_interface_counters[vnet_counter_type][sw_if_index] = counter;
1969 static void vl_api_vnet_interface_counters_t_handler
1970 (vl_api_vnet_interface_counters_t * mp)
1975 static void vl_api_vnet_interface_counters_t_handler_json
1976 (vl_api_vnet_interface_counters_t * mp)
1978 interface_counter_t counter;
1983 u32 first_sw_if_index;
1986 count = ntohl (mp->count);
1987 first_sw_if_index = ntohl (mp->first_sw_if_index);
1989 if (!mp->is_combined)
1991 v_packets = (u64 *) & mp->data;
1992 for (i = 0; i < count; i++)
1995 clib_net_to_host_u64 (clib_mem_unaligned (v_packets, u64));
1996 set_simple_interface_counter (mp->vnet_counter_type,
1997 first_sw_if_index + i, packets);
2003 v = (vlib_counter_t *) & mp->data;
2004 for (i = 0; i < count; i++)
2007 clib_net_to_host_u64 (clib_mem_unaligned (&v->packets, u64));
2009 clib_net_to_host_u64 (clib_mem_unaligned (&v->bytes, u64));
2010 set_combined_interface_counter (mp->vnet_counter_type,
2011 first_sw_if_index + i, counter);
2018 ip4_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
2020 vat_main_t *vam = &vat_main;
2023 for (i = 0; i < vec_len (vam->ip4_fib_counters_vrf_id_by_index); i++)
2025 if (vam->ip4_fib_counters_vrf_id_by_index[i] == vrf_id)
2034 ip6_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
2036 vat_main_t *vam = &vat_main;
2039 for (i = 0; i < vec_len (vam->ip6_fib_counters_vrf_id_by_index); i++)
2041 if (vam->ip6_fib_counters_vrf_id_by_index[i] == vrf_id)
2049 static void vl_api_vnet_ip4_fib_counters_t_handler
2050 (vl_api_vnet_ip4_fib_counters_t * mp)
2055 static void vl_api_vnet_ip4_fib_counters_t_handler_json
2056 (vl_api_vnet_ip4_fib_counters_t * mp)
2058 vat_main_t *vam = &vat_main;
2059 vl_api_ip4_fib_counter_t *v;
2060 ip4_fib_counter_t *counter;
2067 vrf_id = ntohl (mp->vrf_id);
2068 vrf_index = ip4_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2069 if (~0 == vrf_index)
2071 vrf_index = vec_len (vam->ip4_fib_counters_vrf_id_by_index);
2072 vec_validate (vam->ip4_fib_counters_vrf_id_by_index, vrf_index);
2073 vam->ip4_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2074 vec_validate (vam->ip4_fib_counters, vrf_index);
2075 vam->ip4_fib_counters[vrf_index] = NULL;
2078 vec_free (vam->ip4_fib_counters[vrf_index]);
2079 v = (vl_api_ip4_fib_counter_t *) & mp->c;
2080 count = ntohl (mp->count);
2081 for (i = 0; i < count; i++)
2083 vec_validate (vam->ip4_fib_counters[vrf_index], i);
2084 counter = &vam->ip4_fib_counters[vrf_index][i];
2085 clib_memcpy (&ip4, &v->address, sizeof (ip4));
2086 counter->address = ip4;
2087 counter->address_length = v->address_length;
2088 counter->packets = clib_net_to_host_u64 (v->packets);
2089 counter->bytes = clib_net_to_host_u64 (v->bytes);
2094 static void vl_api_vnet_ip4_nbr_counters_t_handler
2095 (vl_api_vnet_ip4_nbr_counters_t * mp)
2100 static void vl_api_vnet_ip4_nbr_counters_t_handler_json
2101 (vl_api_vnet_ip4_nbr_counters_t * mp)
2103 vat_main_t *vam = &vat_main;
2104 vl_api_ip4_nbr_counter_t *v;
2105 ip4_nbr_counter_t *counter;
2110 sw_if_index = ntohl (mp->sw_if_index);
2111 count = ntohl (mp->count);
2112 vec_validate (vam->ip4_nbr_counters, sw_if_index);
2115 vec_free (vam->ip4_nbr_counters[sw_if_index]);
2117 v = (vl_api_ip4_nbr_counter_t *) & mp->c;
2118 for (i = 0; i < count; i++)
2120 vec_validate (vam->ip4_nbr_counters[sw_if_index], i);
2121 counter = &vam->ip4_nbr_counters[sw_if_index][i];
2122 counter->address.s_addr = v->address;
2123 counter->packets = clib_net_to_host_u64 (v->packets);
2124 counter->bytes = clib_net_to_host_u64 (v->bytes);
2125 counter->linkt = v->link_type;
2130 static void vl_api_vnet_ip6_fib_counters_t_handler
2131 (vl_api_vnet_ip6_fib_counters_t * mp)
2136 static void vl_api_vnet_ip6_fib_counters_t_handler_json
2137 (vl_api_vnet_ip6_fib_counters_t * mp)
2139 vat_main_t *vam = &vat_main;
2140 vl_api_ip6_fib_counter_t *v;
2141 ip6_fib_counter_t *counter;
2142 struct in6_addr ip6;
2148 vrf_id = ntohl (mp->vrf_id);
2149 vrf_index = ip6_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2150 if (~0 == vrf_index)
2152 vrf_index = vec_len (vam->ip6_fib_counters_vrf_id_by_index);
2153 vec_validate (vam->ip6_fib_counters_vrf_id_by_index, vrf_index);
2154 vam->ip6_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2155 vec_validate (vam->ip6_fib_counters, vrf_index);
2156 vam->ip6_fib_counters[vrf_index] = NULL;
2159 vec_free (vam->ip6_fib_counters[vrf_index]);
2160 v = (vl_api_ip6_fib_counter_t *) & mp->c;
2161 count = ntohl (mp->count);
2162 for (i = 0; i < count; i++)
2164 vec_validate (vam->ip6_fib_counters[vrf_index], i);
2165 counter = &vam->ip6_fib_counters[vrf_index][i];
2166 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2167 counter->address = ip6;
2168 counter->address_length = v->address_length;
2169 counter->packets = clib_net_to_host_u64 (v->packets);
2170 counter->bytes = clib_net_to_host_u64 (v->bytes);
2175 static void vl_api_vnet_ip6_nbr_counters_t_handler
2176 (vl_api_vnet_ip6_nbr_counters_t * mp)
2181 static void vl_api_vnet_ip6_nbr_counters_t_handler_json
2182 (vl_api_vnet_ip6_nbr_counters_t * mp)
2184 vat_main_t *vam = &vat_main;
2185 vl_api_ip6_nbr_counter_t *v;
2186 ip6_nbr_counter_t *counter;
2187 struct in6_addr ip6;
2192 sw_if_index = ntohl (mp->sw_if_index);
2193 count = ntohl (mp->count);
2194 vec_validate (vam->ip6_nbr_counters, sw_if_index);
2197 vec_free (vam->ip6_nbr_counters[sw_if_index]);
2199 v = (vl_api_ip6_nbr_counter_t *) & mp->c;
2200 for (i = 0; i < count; i++)
2202 vec_validate (vam->ip6_nbr_counters[sw_if_index], i);
2203 counter = &vam->ip6_nbr_counters[sw_if_index][i];
2204 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2205 counter->address = ip6;
2206 counter->packets = clib_net_to_host_u64 (v->packets);
2207 counter->bytes = clib_net_to_host_u64 (v->bytes);
2212 static void vl_api_get_first_msg_id_reply_t_handler
2213 (vl_api_get_first_msg_id_reply_t * mp)
2215 vat_main_t *vam = &vat_main;
2216 i32 retval = ntohl (mp->retval);
2218 if (vam->async_mode)
2220 vam->async_errors += (retval < 0);
2224 vam->retval = retval;
2225 vam->result_ready = 1;
2229 errmsg ("first message id %d", ntohs (mp->first_msg_id));
2233 static void vl_api_get_first_msg_id_reply_t_handler_json
2234 (vl_api_get_first_msg_id_reply_t * mp)
2236 vat_main_t *vam = &vat_main;
2237 vat_json_node_t node;
2239 vat_json_init_object (&node);
2240 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2241 vat_json_object_add_uint (&node, "first_msg_id",
2242 (uint) ntohs (mp->first_msg_id));
2244 vat_json_print (vam->ofp, &node);
2245 vat_json_free (&node);
2247 vam->retval = ntohl (mp->retval);
2248 vam->result_ready = 1;
2251 static void vl_api_get_node_graph_reply_t_handler
2252 (vl_api_get_node_graph_reply_t * mp)
2254 vat_main_t *vam = &vat_main;
2255 api_main_t *am = &api_main;
2256 i32 retval = ntohl (mp->retval);
2257 u8 *pvt_copy, *reply;
2262 if (vam->async_mode)
2264 vam->async_errors += (retval < 0);
2268 vam->retval = retval;
2269 vam->result_ready = 1;
2272 /* "Should never happen..." */
2276 reply = (u8 *) (mp->reply_in_shmem);
2277 pvt_copy = vec_dup (reply);
2279 /* Toss the shared-memory original... */
2280 pthread_mutex_lock (&am->vlib_rp->mutex);
2281 oldheap = svm_push_data_heap (am->vlib_rp);
2285 svm_pop_heap (oldheap);
2286 pthread_mutex_unlock (&am->vlib_rp->mutex);
2288 if (vam->graph_nodes)
2290 hash_free (vam->graph_node_index_by_name);
2292 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2294 node = vam->graph_nodes[i];
2295 vec_free (node->name);
2296 vec_free (node->next_nodes);
2299 vec_free (vam->graph_nodes);
2302 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2303 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2304 vec_free (pvt_copy);
2306 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2308 node = vam->graph_nodes[i];
2309 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2313 static void vl_api_get_node_graph_reply_t_handler_json
2314 (vl_api_get_node_graph_reply_t * mp)
2316 vat_main_t *vam = &vat_main;
2317 api_main_t *am = &api_main;
2319 vat_json_node_t node;
2322 /* $$$$ make this real? */
2323 vat_json_init_object (&node);
2324 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2325 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2327 reply = (u8 *) (mp->reply_in_shmem);
2329 /* Toss the shared-memory original... */
2330 pthread_mutex_lock (&am->vlib_rp->mutex);
2331 oldheap = svm_push_data_heap (am->vlib_rp);
2335 svm_pop_heap (oldheap);
2336 pthread_mutex_unlock (&am->vlib_rp->mutex);
2338 vat_json_print (vam->ofp, &node);
2339 vat_json_free (&node);
2341 vam->retval = ntohl (mp->retval);
2342 vam->result_ready = 1;
2346 vl_api_lisp_locator_details_t_handler (vl_api_lisp_locator_details_t * mp)
2348 vat_main_t *vam = &vat_main;
2353 s = format (s, "%=16d%=16d%=16d",
2354 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2358 s = format (s, "%=16U%=16d%=16d",
2359 mp->is_ipv6 ? format_ip6_address :
2361 mp->ip_address, mp->priority, mp->weight);
2364 print (vam->ofp, "%v", s);
2369 vl_api_lisp_locator_details_t_handler_json (vl_api_lisp_locator_details_t *
2372 vat_main_t *vam = &vat_main;
2373 vat_json_node_t *node = NULL;
2374 struct in6_addr ip6;
2377 if (VAT_JSON_ARRAY != vam->json_tree.type)
2379 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2380 vat_json_init_array (&vam->json_tree);
2382 node = vat_json_array_add (&vam->json_tree);
2383 vat_json_init_object (node);
2385 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2386 vat_json_object_add_uint (node, "priority", mp->priority);
2387 vat_json_object_add_uint (node, "weight", mp->weight);
2390 vat_json_object_add_uint (node, "sw_if_index",
2391 clib_net_to_host_u32 (mp->sw_if_index));
2396 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2397 vat_json_object_add_ip6 (node, "address", ip6);
2401 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2402 vat_json_object_add_ip4 (node, "address", ip4);
2408 vl_api_lisp_locator_set_details_t_handler (vl_api_lisp_locator_set_details_t *
2411 vat_main_t *vam = &vat_main;
2414 ls_name = format (0, "%s", mp->ls_name);
2416 print (vam->ofp, "%=10d%=15v", clib_net_to_host_u32 (mp->ls_index),
2422 vl_api_lisp_locator_set_details_t_handler_json
2423 (vl_api_lisp_locator_set_details_t * mp)
2425 vat_main_t *vam = &vat_main;
2426 vat_json_node_t *node = 0;
2429 ls_name = format (0, "%s", mp->ls_name);
2430 vec_add1 (ls_name, 0);
2432 if (VAT_JSON_ARRAY != vam->json_tree.type)
2434 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2435 vat_json_init_array (&vam->json_tree);
2437 node = vat_json_array_add (&vam->json_tree);
2439 vat_json_init_object (node);
2440 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2441 vat_json_object_add_uint (node, "ls_index",
2442 clib_net_to_host_u32 (mp->ls_index));
2447 format_lisp_flat_eid (u8 * s, va_list * args)
2449 u32 type = va_arg (*args, u32);
2450 u8 *eid = va_arg (*args, u8 *);
2451 u32 eid_len = va_arg (*args, u32);
2456 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
2458 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
2460 return format (s, "%U", format_ethernet_address, eid);
2466 format_lisp_eid_vat (u8 * s, va_list * args)
2468 u32 type = va_arg (*args, u32);
2469 u8 *eid = va_arg (*args, u8 *);
2470 u32 eid_len = va_arg (*args, u32);
2471 u8 *seid = va_arg (*args, u8 *);
2472 u32 seid_len = va_arg (*args, u32);
2473 u32 is_src_dst = va_arg (*args, u32);
2476 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
2478 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
2484 vl_api_lisp_eid_table_details_t_handler (vl_api_lisp_eid_table_details_t * mp)
2486 vat_main_t *vam = &vat_main;
2487 u8 *s = 0, *eid = 0;
2489 if (~0 == mp->locator_set_index)
2490 s = format (0, "action: %d", mp->action);
2492 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
2494 eid = format (0, "%U", format_lisp_eid_vat,
2498 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2501 print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
2502 clib_net_to_host_u32 (mp->vni),
2504 mp->is_local ? "local" : "remote",
2505 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
2506 clib_net_to_host_u16 (mp->key_id), mp->key);
2513 vl_api_lisp_eid_table_details_t_handler_json (vl_api_lisp_eid_table_details_t
2516 vat_main_t *vam = &vat_main;
2517 vat_json_node_t *node = 0;
2520 if (VAT_JSON_ARRAY != vam->json_tree.type)
2522 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2523 vat_json_init_array (&vam->json_tree);
2525 node = vat_json_array_add (&vam->json_tree);
2527 vat_json_init_object (node);
2528 if (~0 == mp->locator_set_index)
2529 vat_json_object_add_uint (node, "action", mp->action);
2531 vat_json_object_add_uint (node, "locator_set_index",
2532 clib_net_to_host_u32 (mp->locator_set_index));
2534 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
2535 eid = format (0, "%U", format_lisp_eid_vat,
2539 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2541 vat_json_object_add_string_copy (node, "eid", eid);
2542 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2543 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
2544 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
2548 vat_json_object_add_uint (node, "key_id",
2549 clib_net_to_host_u16 (mp->key_id));
2550 vat_json_object_add_string_copy (node, "key", mp->key);
2556 vl_api_lisp_eid_table_map_details_t_handler
2557 (vl_api_lisp_eid_table_map_details_t * mp)
2559 vat_main_t *vam = &vat_main;
2561 u8 *line = format (0, "%=10d%=10d",
2562 clib_net_to_host_u32 (mp->vni),
2563 clib_net_to_host_u32 (mp->dp_table));
2564 print (vam->ofp, "%v", line);
2569 vl_api_lisp_eid_table_map_details_t_handler_json
2570 (vl_api_lisp_eid_table_map_details_t * mp)
2572 vat_main_t *vam = &vat_main;
2573 vat_json_node_t *node = NULL;
2575 if (VAT_JSON_ARRAY != vam->json_tree.type)
2577 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2578 vat_json_init_array (&vam->json_tree);
2580 node = vat_json_array_add (&vam->json_tree);
2581 vat_json_init_object (node);
2582 vat_json_object_add_uint (node, "dp_table",
2583 clib_net_to_host_u32 (mp->dp_table));
2584 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2588 vl_api_lisp_eid_table_vni_details_t_handler
2589 (vl_api_lisp_eid_table_vni_details_t * mp)
2591 vat_main_t *vam = &vat_main;
2593 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
2594 print (vam->ofp, "%v", line);
2599 vl_api_lisp_eid_table_vni_details_t_handler_json
2600 (vl_api_lisp_eid_table_vni_details_t * mp)
2602 vat_main_t *vam = &vat_main;
2603 vat_json_node_t *node = NULL;
2605 if (VAT_JSON_ARRAY != vam->json_tree.type)
2607 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2608 vat_json_init_array (&vam->json_tree);
2610 node = vat_json_array_add (&vam->json_tree);
2611 vat_json_init_object (node);
2612 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2616 vl_api_show_lisp_map_register_state_reply_t_handler
2617 (vl_api_show_lisp_map_register_state_reply_t * mp)
2619 vat_main_t *vam = &vat_main;
2620 int retval = clib_net_to_host_u32 (mp->retval);
2622 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
2624 vam->retval = retval;
2625 vam->result_ready = 1;
2629 vl_api_show_lisp_map_register_state_reply_t_handler_json
2630 (vl_api_show_lisp_map_register_state_reply_t * mp)
2632 vat_main_t *vam = &vat_main;
2633 vat_json_node_t _node, *node = &_node;
2634 int retval = clib_net_to_host_u32 (mp->retval);
2636 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
2638 vat_json_init_object (node);
2639 vat_json_object_add_string_copy (node, "state", s);
2641 vat_json_print (vam->ofp, node);
2642 vat_json_free (node);
2644 vam->retval = retval;
2645 vam->result_ready = 1;
2650 vl_api_show_lisp_rloc_probe_state_reply_t_handler
2651 (vl_api_show_lisp_rloc_probe_state_reply_t * mp)
2653 vat_main_t *vam = &vat_main;
2654 int retval = clib_net_to_host_u32 (mp->retval);
2659 print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
2661 vam->retval = retval;
2662 vam->result_ready = 1;
2666 vl_api_show_lisp_rloc_probe_state_reply_t_handler_json
2667 (vl_api_show_lisp_rloc_probe_state_reply_t * mp)
2669 vat_main_t *vam = &vat_main;
2670 vat_json_node_t _node, *node = &_node;
2671 int retval = clib_net_to_host_u32 (mp->retval);
2673 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
2674 vat_json_init_object (node);
2675 vat_json_object_add_string_copy (node, "state", s);
2677 vat_json_print (vam->ofp, node);
2678 vat_json_free (node);
2680 vam->retval = retval;
2681 vam->result_ready = 1;
2686 api_lisp_gpe_fwd_entry_net_to_host (vl_api_lisp_gpe_fwd_entry_t * e)
2688 e->dp_table = clib_net_to_host_u32 (e->dp_table);
2689 e->fwd_entry_index = clib_net_to_host_u32 (e->fwd_entry_index);
2693 lisp_gpe_fwd_entries_get_reply_t_net_to_host
2694 (vl_api_lisp_gpe_fwd_entries_get_reply_t * mp)
2698 mp->count = clib_net_to_host_u32 (mp->count);
2699 for (i = 0; i < mp->count; i++)
2701 api_lisp_gpe_fwd_entry_net_to_host (&mp->entries[i]);
2706 vl_api_lisp_gpe_fwd_entry_path_details_t_handler
2707 (vl_api_lisp_gpe_fwd_entry_path_details_t * mp)
2709 vat_main_t *vam = &vat_main;
2710 u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
2712 if (mp->lcl_loc.is_ip4)
2713 format_ip_address_fcn = format_ip4_address;
2715 format_ip_address_fcn = format_ip6_address;
2717 print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
2718 format_ip_address_fcn, &mp->lcl_loc,
2719 format_ip_address_fcn, &mp->rmt_loc);
2723 lisp_fill_locator_node (vat_json_node_t * n, vl_api_lisp_gpe_locator_t * loc)
2725 struct in6_addr ip6;
2730 clib_memcpy (&ip4, loc->addr, sizeof (ip4));
2731 vat_json_object_add_ip4 (n, "address", ip4);
2735 clib_memcpy (&ip6, loc->addr, sizeof (ip6));
2736 vat_json_object_add_ip6 (n, "address", ip6);
2738 vat_json_object_add_uint (n, "weight", loc->weight);
2742 vl_api_lisp_gpe_fwd_entry_path_details_t_handler_json
2743 (vl_api_lisp_gpe_fwd_entry_path_details_t * mp)
2745 vat_main_t *vam = &vat_main;
2746 vat_json_node_t *node = NULL;
2747 vat_json_node_t *loc_node;
2749 if (VAT_JSON_ARRAY != vam->json_tree.type)
2751 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2752 vat_json_init_array (&vam->json_tree);
2754 node = vat_json_array_add (&vam->json_tree);
2755 vat_json_init_object (node);
2757 loc_node = vat_json_object_add (node, "local_locator");
2758 vat_json_init_object (loc_node);
2759 lisp_fill_locator_node (loc_node, &mp->lcl_loc);
2761 loc_node = vat_json_object_add (node, "remote_locator");
2762 vat_json_init_object (loc_node);
2763 lisp_fill_locator_node (loc_node, &mp->rmt_loc);
2767 vl_api_lisp_gpe_fwd_entries_get_reply_t_handler
2768 (vl_api_lisp_gpe_fwd_entries_get_reply_t * mp)
2770 vat_main_t *vam = &vat_main;
2772 int retval = clib_net_to_host_u32 (mp->retval);
2773 vl_api_lisp_gpe_fwd_entry_t *e;
2778 lisp_gpe_fwd_entries_get_reply_t_net_to_host (mp);
2780 for (i = 0; i < mp->count; i++)
2782 e = &mp->entries[i];
2783 print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
2784 format_lisp_flat_eid, e->eid_type, e->leid, e->leid_prefix_len,
2785 format_lisp_flat_eid, e->eid_type, e->reid, e->reid_prefix_len);
2789 vam->retval = retval;
2790 vam->result_ready = 1;
2794 vl_api_lisp_gpe_fwd_entries_get_reply_t_handler_json
2795 (vl_api_lisp_gpe_fwd_entries_get_reply_t * mp)
2798 vat_main_t *vam = &vat_main;
2799 vat_json_node_t *e = 0, root;
2801 int retval = clib_net_to_host_u32 (mp->retval);
2802 vl_api_lisp_gpe_fwd_entry_t *fwd;
2807 lisp_gpe_fwd_entries_get_reply_t_net_to_host (mp);
2808 vat_json_init_array (&root);
2810 for (i = 0; i < mp->count; i++)
2812 e = vat_json_array_add (&root);
2813 fwd = &mp->entries[i];
2815 vat_json_init_object (e);
2816 vat_json_object_add_int (e, "fwd_entry_index", fwd->fwd_entry_index);
2817 vat_json_object_add_int (e, "dp_table", fwd->dp_table);
2819 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->leid,
2820 fwd->leid_prefix_len);
2822 vat_json_object_add_string_copy (e, "leid", s);
2825 s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->reid,
2826 fwd->reid_prefix_len);
2828 vat_json_object_add_string_copy (e, "reid", s);
2832 vat_json_print (vam->ofp, &root);
2833 vat_json_free (&root);
2836 vam->retval = retval;
2837 vam->result_ready = 1;
2841 vl_api_lisp_adjacencies_get_reply_t_handler
2842 (vl_api_lisp_adjacencies_get_reply_t * mp)
2844 vat_main_t *vam = &vat_main;
2846 int retval = clib_net_to_host_u32 (mp->retval);
2847 vl_api_lisp_adjacency_t *a;
2852 n = clib_net_to_host_u32 (mp->count);
2854 for (i = 0; i < n; i++)
2856 a = &mp->adjacencies[i];
2857 print (vam->ofp, "%U %40U",
2858 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
2859 format_lisp_flat_eid, a->eid_type, a->reid, a->reid_prefix_len);
2863 vam->retval = retval;
2864 vam->result_ready = 1;
2868 vl_api_lisp_adjacencies_get_reply_t_handler_json
2869 (vl_api_lisp_adjacencies_get_reply_t * mp)
2872 vat_main_t *vam = &vat_main;
2873 vat_json_node_t *e = 0, root;
2875 int retval = clib_net_to_host_u32 (mp->retval);
2876 vl_api_lisp_adjacency_t *a;
2881 n = clib_net_to_host_u32 (mp->count);
2882 vat_json_init_array (&root);
2884 for (i = 0; i < n; i++)
2886 e = vat_json_array_add (&root);
2887 a = &mp->adjacencies[i];
2889 vat_json_init_object (e);
2890 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
2891 a->leid_prefix_len);
2893 vat_json_object_add_string_copy (e, "leid", s);
2896 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
2897 a->reid_prefix_len);
2899 vat_json_object_add_string_copy (e, "reid", s);
2903 vat_json_print (vam->ofp, &root);
2904 vat_json_free (&root);
2907 vam->retval = retval;
2908 vam->result_ready = 1;
2912 vl_api_lisp_map_server_details_t_handler (vl_api_lisp_map_server_details_t
2915 vat_main_t *vam = &vat_main;
2917 print (vam->ofp, "%=20U",
2918 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2923 vl_api_lisp_map_server_details_t_handler_json
2924 (vl_api_lisp_map_server_details_t * mp)
2926 vat_main_t *vam = &vat_main;
2927 vat_json_node_t *node = NULL;
2928 struct in6_addr ip6;
2931 if (VAT_JSON_ARRAY != vam->json_tree.type)
2933 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2934 vat_json_init_array (&vam->json_tree);
2936 node = vat_json_array_add (&vam->json_tree);
2938 vat_json_init_object (node);
2941 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2942 vat_json_object_add_ip6 (node, "map-server", ip6);
2946 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2947 vat_json_object_add_ip4 (node, "map-server", ip4);
2952 vl_api_lisp_map_resolver_details_t_handler (vl_api_lisp_map_resolver_details_t
2955 vat_main_t *vam = &vat_main;
2957 print (vam->ofp, "%=20U",
2958 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2963 vl_api_lisp_map_resolver_details_t_handler_json
2964 (vl_api_lisp_map_resolver_details_t * mp)
2966 vat_main_t *vam = &vat_main;
2967 vat_json_node_t *node = NULL;
2968 struct in6_addr ip6;
2971 if (VAT_JSON_ARRAY != vam->json_tree.type)
2973 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2974 vat_json_init_array (&vam->json_tree);
2976 node = vat_json_array_add (&vam->json_tree);
2978 vat_json_init_object (node);
2981 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2982 vat_json_object_add_ip6 (node, "map resolver", ip6);
2986 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2987 vat_json_object_add_ip4 (node, "map resolver", ip4);
2992 vl_api_show_lisp_status_reply_t_handler
2993 (vl_api_show_lisp_status_reply_t * mp)
2995 vat_main_t *vam = &vat_main;
2996 i32 retval = ntohl (mp->retval);
3000 print (vam->ofp, "feature: %s\ngpe: %s",
3001 mp->feature_status ? "enabled" : "disabled",
3002 mp->gpe_status ? "enabled" : "disabled");
3005 vam->retval = retval;
3006 vam->result_ready = 1;
3010 vl_api_show_lisp_status_reply_t_handler_json
3011 (vl_api_show_lisp_status_reply_t * mp)
3013 vat_main_t *vam = &vat_main;
3014 vat_json_node_t node;
3015 u8 *gpe_status = NULL;
3016 u8 *feature_status = NULL;
3018 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
3019 feature_status = format (0, "%s",
3020 mp->feature_status ? "enabled" : "disabled");
3021 vec_add1 (gpe_status, 0);
3022 vec_add1 (feature_status, 0);
3024 vat_json_init_object (&node);
3025 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
3026 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
3028 vec_free (gpe_status);
3029 vec_free (feature_status);
3031 vat_json_print (vam->ofp, &node);
3032 vat_json_free (&node);
3034 vam->retval = ntohl (mp->retval);
3035 vam->result_ready = 1;
3039 vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler
3040 (vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
3042 vat_main_t *vam = &vat_main;
3043 i32 retval = ntohl (mp->retval);
3047 print (vam->ofp, "%=20s", mp->locator_set_name);
3050 vam->retval = retval;
3051 vam->result_ready = 1;
3055 vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler_json
3056 (vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
3058 vat_main_t *vam = &vat_main;
3059 vat_json_node_t *node = NULL;
3061 if (VAT_JSON_ARRAY != vam->json_tree.type)
3063 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3064 vat_json_init_array (&vam->json_tree);
3066 node = vat_json_array_add (&vam->json_tree);
3068 vat_json_init_object (node);
3069 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
3071 vat_json_print (vam->ofp, node);
3072 vat_json_free (node);
3074 vam->retval = ntohl (mp->retval);
3075 vam->result_ready = 1;
3079 format_lisp_map_request_mode (u8 * s, va_list * args)
3081 u32 mode = va_arg (*args, u32);
3086 return format (0, "dst-only");
3088 return format (0, "src-dst");
3094 vl_api_show_lisp_map_request_mode_reply_t_handler
3095 (vl_api_show_lisp_map_request_mode_reply_t * mp)
3097 vat_main_t *vam = &vat_main;
3098 i32 retval = ntohl (mp->retval);
3102 u32 mode = mp->mode;
3103 print (vam->ofp, "map_request_mode: %U",
3104 format_lisp_map_request_mode, mode);
3107 vam->retval = retval;
3108 vam->result_ready = 1;
3112 vl_api_show_lisp_map_request_mode_reply_t_handler_json
3113 (vl_api_show_lisp_map_request_mode_reply_t * mp)
3115 vat_main_t *vam = &vat_main;
3116 vat_json_node_t node;
3121 s = format (0, "%U", format_lisp_map_request_mode, mode);
3124 vat_json_init_object (&node);
3125 vat_json_object_add_string_copy (&node, "map_request_mode", s);
3126 vat_json_print (vam->ofp, &node);
3127 vat_json_free (&node);
3130 vam->retval = ntohl (mp->retval);
3131 vam->result_ready = 1;
3135 vl_api_show_lisp_pitr_reply_t_handler (vl_api_show_lisp_pitr_reply_t * mp)
3137 vat_main_t *vam = &vat_main;
3138 i32 retval = ntohl (mp->retval);
3142 print (vam->ofp, "%-20s%-16s",
3143 mp->status ? "enabled" : "disabled",
3144 mp->status ? (char *) mp->locator_set_name : "");
3147 vam->retval = retval;
3148 vam->result_ready = 1;
3152 vl_api_show_lisp_pitr_reply_t_handler_json (vl_api_show_lisp_pitr_reply_t *
3155 vat_main_t *vam = &vat_main;
3156 vat_json_node_t node;
3159 status = format (0, "%s", mp->status ? "enabled" : "disabled");
3160 vec_add1 (status, 0);
3162 vat_json_init_object (&node);
3163 vat_json_object_add_string_copy (&node, "status", status);
3166 vat_json_object_add_string_copy (&node, "locator_set",
3167 mp->locator_set_name);
3172 vat_json_print (vam->ofp, &node);
3173 vat_json_free (&node);
3175 vam->retval = ntohl (mp->retval);
3176 vam->result_ready = 1;
3180 format_policer_type (u8 * s, va_list * va)
3182 u32 i = va_arg (*va, u32);
3184 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
3185 s = format (s, "1r2c");
3186 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
3187 s = format (s, "1r3c");
3188 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
3189 s = format (s, "2r3c-2698");
3190 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
3191 s = format (s, "2r3c-4115");
3192 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
3193 s = format (s, "2r3c-mef5cf1");
3195 s = format (s, "ILLEGAL");
3200 format_policer_rate_type (u8 * s, va_list * va)
3202 u32 i = va_arg (*va, u32);
3204 if (i == SSE2_QOS_RATE_KBPS)
3205 s = format (s, "kbps");
3206 else if (i == SSE2_QOS_RATE_PPS)
3207 s = format (s, "pps");
3209 s = format (s, "ILLEGAL");
3214 format_policer_round_type (u8 * s, va_list * va)
3216 u32 i = va_arg (*va, u32);
3218 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
3219 s = format (s, "closest");
3220 else if (i == SSE2_QOS_ROUND_TO_UP)
3221 s = format (s, "up");
3222 else if (i == SSE2_QOS_ROUND_TO_DOWN)
3223 s = format (s, "down");
3225 s = format (s, "ILLEGAL");
3230 format_policer_action_type (u8 * s, va_list * va)
3232 u32 i = va_arg (*va, u32);
3234 if (i == SSE2_QOS_ACTION_DROP)
3235 s = format (s, "drop");
3236 else if (i == SSE2_QOS_ACTION_TRANSMIT)
3237 s = format (s, "transmit");
3238 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3239 s = format (s, "mark-and-transmit");
3241 s = format (s, "ILLEGAL");
3246 format_dscp (u8 * s, va_list * va)
3248 u32 i = va_arg (*va, u32);
3253 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
3257 return format (s, "ILLEGAL");
3259 s = format (s, "%s", t);
3264 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
3266 vat_main_t *vam = &vat_main;
3267 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
3269 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3270 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
3272 conform_dscp_str = format (0, "");
3274 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3275 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
3277 exceed_dscp_str = format (0, "");
3279 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3280 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
3282 violate_dscp_str = format (0, "");
3284 print (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
3285 "rate type %U, round type %U, %s rate, %s color-aware, "
3286 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
3287 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
3288 "conform action %U%s, exceed action %U%s, violate action %U%s",
3290 format_policer_type, mp->type,
3293 clib_net_to_host_u64 (mp->cb),
3294 clib_net_to_host_u64 (mp->eb),
3295 format_policer_rate_type, mp->rate_type,
3296 format_policer_round_type, mp->round_type,
3297 mp->single_rate ? "single" : "dual",
3298 mp->color_aware ? "is" : "not",
3299 ntohl (mp->cir_tokens_per_period),
3300 ntohl (mp->pir_tokens_per_period),
3302 ntohl (mp->current_limit),
3303 ntohl (mp->current_bucket),
3304 ntohl (mp->extended_limit),
3305 ntohl (mp->extended_bucket),
3306 clib_net_to_host_u64 (mp->last_update_time),
3307 format_policer_action_type, mp->conform_action_type,
3309 format_policer_action_type, mp->exceed_action_type,
3311 format_policer_action_type, mp->violate_action_type,
3314 vec_free (conform_dscp_str);
3315 vec_free (exceed_dscp_str);
3316 vec_free (violate_dscp_str);
3319 static void vl_api_policer_details_t_handler_json
3320 (vl_api_policer_details_t * mp)
3322 vat_main_t *vam = &vat_main;
3323 vat_json_node_t *node;
3324 u8 *rate_type_str, *round_type_str, *type_str;
3325 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
3327 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
3329 format (0, "%U", format_policer_round_type, mp->round_type);
3330 type_str = format (0, "%U", format_policer_type, mp->type);
3331 conform_action_str = format (0, "%U", format_policer_action_type,
3332 mp->conform_action_type);
3333 exceed_action_str = format (0, "%U", format_policer_action_type,
3334 mp->exceed_action_type);
3335 violate_action_str = format (0, "%U", format_policer_action_type,
3336 mp->violate_action_type);
3338 if (VAT_JSON_ARRAY != vam->json_tree.type)
3340 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3341 vat_json_init_array (&vam->json_tree);
3343 node = vat_json_array_add (&vam->json_tree);
3345 vat_json_init_object (node);
3346 vat_json_object_add_string_copy (node, "name", mp->name);
3347 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
3348 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
3349 vat_json_object_add_uint (node, "cb", ntohl (mp->cb));
3350 vat_json_object_add_uint (node, "eb", ntohl (mp->eb));
3351 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
3352 vat_json_object_add_string_copy (node, "round_type", round_type_str);
3353 vat_json_object_add_string_copy (node, "type", type_str);
3354 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
3355 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
3356 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
3357 vat_json_object_add_uint (node, "cir_tokens_per_period",
3358 ntohl (mp->cir_tokens_per_period));
3359 vat_json_object_add_uint (node, "eir_tokens_per_period",
3360 ntohl (mp->pir_tokens_per_period));
3361 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
3362 vat_json_object_add_uint (node, "current_bucket",
3363 ntohl (mp->current_bucket));
3364 vat_json_object_add_uint (node, "extended_limit",
3365 ntohl (mp->extended_limit));
3366 vat_json_object_add_uint (node, "extended_bucket",
3367 ntohl (mp->extended_bucket));
3368 vat_json_object_add_uint (node, "last_update_time",
3369 ntohl (mp->last_update_time));
3370 vat_json_object_add_string_copy (node, "conform_action",
3371 conform_action_str);
3372 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3374 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
3375 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
3376 vec_free (dscp_str);
3378 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
3379 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3381 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
3382 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
3383 vec_free (dscp_str);
3385 vat_json_object_add_string_copy (node, "violate_action",
3386 violate_action_str);
3387 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3389 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
3390 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
3391 vec_free (dscp_str);
3394 vec_free (rate_type_str);
3395 vec_free (round_type_str);
3396 vec_free (type_str);
3397 vec_free (conform_action_str);
3398 vec_free (exceed_action_str);
3399 vec_free (violate_action_str);
3403 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
3406 vat_main_t *vam = &vat_main;
3407 int i, count = ntohl (mp->count);
3410 print (vam->ofp, "classify table ids (%d) : ", count);
3411 for (i = 0; i < count; i++)
3413 print (vam->ofp, "%d", ntohl (mp->ids[i]));
3414 print (vam->ofp, (i < count - 1) ? "," : "");
3416 vam->retval = ntohl (mp->retval);
3417 vam->result_ready = 1;
3421 vl_api_classify_table_ids_reply_t_handler_json
3422 (vl_api_classify_table_ids_reply_t * mp)
3424 vat_main_t *vam = &vat_main;
3425 int i, count = ntohl (mp->count);
3429 vat_json_node_t node;
3431 vat_json_init_object (&node);
3432 for (i = 0; i < count; i++)
3434 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
3436 vat_json_print (vam->ofp, &node);
3437 vat_json_free (&node);
3439 vam->retval = ntohl (mp->retval);
3440 vam->result_ready = 1;
3444 vl_api_classify_table_by_interface_reply_t_handler
3445 (vl_api_classify_table_by_interface_reply_t * mp)
3447 vat_main_t *vam = &vat_main;
3450 table_id = ntohl (mp->l2_table_id);
3452 print (vam->ofp, "l2 table id : %d", table_id);
3454 print (vam->ofp, "l2 table id : No input ACL tables configured");
3455 table_id = ntohl (mp->ip4_table_id);
3457 print (vam->ofp, "ip4 table id : %d", table_id);
3459 print (vam->ofp, "ip4 table id : No input ACL tables configured");
3460 table_id = ntohl (mp->ip6_table_id);
3462 print (vam->ofp, "ip6 table id : %d", table_id);
3464 print (vam->ofp, "ip6 table id : No input ACL tables configured");
3465 vam->retval = ntohl (mp->retval);
3466 vam->result_ready = 1;
3470 vl_api_classify_table_by_interface_reply_t_handler_json
3471 (vl_api_classify_table_by_interface_reply_t * mp)
3473 vat_main_t *vam = &vat_main;
3474 vat_json_node_t node;
3476 vat_json_init_object (&node);
3478 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
3479 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
3480 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
3482 vat_json_print (vam->ofp, &node);
3483 vat_json_free (&node);
3485 vam->retval = ntohl (mp->retval);
3486 vam->result_ready = 1;
3489 static void vl_api_policer_add_del_reply_t_handler
3490 (vl_api_policer_add_del_reply_t * mp)
3492 vat_main_t *vam = &vat_main;
3493 i32 retval = ntohl (mp->retval);
3494 if (vam->async_mode)
3496 vam->async_errors += (retval < 0);
3500 vam->retval = retval;
3501 vam->result_ready = 1;
3502 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
3504 * Note: this is just barely thread-safe, depends on
3505 * the main thread spinning waiting for an answer...
3507 errmsg ("policer index %d", ntohl (mp->policer_index));
3511 static void vl_api_policer_add_del_reply_t_handler_json
3512 (vl_api_policer_add_del_reply_t * mp)
3514 vat_main_t *vam = &vat_main;
3515 vat_json_node_t node;
3517 vat_json_init_object (&node);
3518 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3519 vat_json_object_add_uint (&node, "policer_index",
3520 ntohl (mp->policer_index));
3522 vat_json_print (vam->ofp, &node);
3523 vat_json_free (&node);
3525 vam->retval = ntohl (mp->retval);
3526 vam->result_ready = 1;
3529 /* Format hex dump. */
3531 format_hex_bytes (u8 * s, va_list * va)
3533 u8 *bytes = va_arg (*va, u8 *);
3534 int n_bytes = va_arg (*va, int);
3537 /* Print short or long form depending on byte count. */
3538 uword short_form = n_bytes <= 32;
3539 uword indent = format_get_indent (s);
3544 for (i = 0; i < n_bytes; i++)
3546 if (!short_form && (i % 32) == 0)
3547 s = format (s, "%08x: ", i);
3548 s = format (s, "%02x", bytes[i]);
3549 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
3550 s = format (s, "\n%U", format_white_space, indent);
3557 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
3560 vat_main_t *vam = &vat_main;
3561 i32 retval = ntohl (mp->retval);
3564 print (vam->ofp, "classify table info :");
3565 print (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d",
3566 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
3567 ntohl (mp->miss_next_index));
3568 print (vam->ofp, "nbuckets: %d skip: %d match: %d",
3569 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
3570 ntohl (mp->match_n_vectors));
3571 print (vam->ofp, "mask: %U", format_hex_bytes, mp->mask,
3572 ntohl (mp->mask_length));
3574 vam->retval = retval;
3575 vam->result_ready = 1;
3579 vl_api_classify_table_info_reply_t_handler_json
3580 (vl_api_classify_table_info_reply_t * mp)
3582 vat_main_t *vam = &vat_main;
3583 vat_json_node_t node;
3585 i32 retval = ntohl (mp->retval);
3588 vat_json_init_object (&node);
3590 vat_json_object_add_int (&node, "sessions",
3591 ntohl (mp->active_sessions));
3592 vat_json_object_add_int (&node, "nexttbl",
3593 ntohl (mp->next_table_index));
3594 vat_json_object_add_int (&node, "nextnode",
3595 ntohl (mp->miss_next_index));
3596 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
3597 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
3598 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
3599 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
3600 ntohl (mp->mask_length), 0);
3601 vat_json_object_add_string_copy (&node, "mask", s);
3603 vat_json_print (vam->ofp, &node);
3604 vat_json_free (&node);
3606 vam->retval = ntohl (mp->retval);
3607 vam->result_ready = 1;
3611 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
3614 vat_main_t *vam = &vat_main;
3616 print (vam->ofp, "next_index: %d advance: %d opaque: %d ",
3617 ntohl (mp->hit_next_index), ntohl (mp->advance),
3618 ntohl (mp->opaque_index));
3619 print (vam->ofp, "mask: %U", format_hex_bytes, mp->match,
3620 ntohl (mp->match_length));
3624 vl_api_classify_session_details_t_handler_json
3625 (vl_api_classify_session_details_t * mp)
3627 vat_main_t *vam = &vat_main;
3628 vat_json_node_t *node = NULL;
3630 if (VAT_JSON_ARRAY != vam->json_tree.type)
3632 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3633 vat_json_init_array (&vam->json_tree);
3635 node = vat_json_array_add (&vam->json_tree);
3637 vat_json_init_object (node);
3638 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
3639 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
3640 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
3642 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
3644 vat_json_object_add_string_copy (node, "match", s);
3647 static void vl_api_pg_create_interface_reply_t_handler
3648 (vl_api_pg_create_interface_reply_t * mp)
3650 vat_main_t *vam = &vat_main;
3652 vam->retval = ntohl (mp->retval);
3653 vam->result_ready = 1;
3656 static void vl_api_pg_create_interface_reply_t_handler_json
3657 (vl_api_pg_create_interface_reply_t * mp)
3659 vat_main_t *vam = &vat_main;
3660 vat_json_node_t node;
3662 i32 retval = ntohl (mp->retval);
3665 vat_json_init_object (&node);
3667 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
3669 vat_json_print (vam->ofp, &node);
3670 vat_json_free (&node);
3672 vam->retval = ntohl (mp->retval);
3673 vam->result_ready = 1;
3676 static void vl_api_policer_classify_details_t_handler
3677 (vl_api_policer_classify_details_t * mp)
3679 vat_main_t *vam = &vat_main;
3681 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
3682 ntohl (mp->table_index));
3685 static void vl_api_policer_classify_details_t_handler_json
3686 (vl_api_policer_classify_details_t * mp)
3688 vat_main_t *vam = &vat_main;
3689 vat_json_node_t *node;
3691 if (VAT_JSON_ARRAY != vam->json_tree.type)
3693 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3694 vat_json_init_array (&vam->json_tree);
3696 node = vat_json_array_add (&vam->json_tree);
3698 vat_json_init_object (node);
3699 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
3700 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
3703 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler
3704 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3706 vat_main_t *vam = &vat_main;
3707 i32 retval = ntohl (mp->retval);
3708 if (vam->async_mode)
3710 vam->async_errors += (retval < 0);
3714 vam->retval = retval;
3715 vam->sw_if_index = ntohl (mp->sw_if_index);
3716 vam->result_ready = 1;
3720 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler_json
3721 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3723 vat_main_t *vam = &vat_main;
3724 vat_json_node_t node;
3726 vat_json_init_object (&node);
3727 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3728 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
3730 vat_json_print (vam->ofp, &node);
3731 vat_json_free (&node);
3733 vam->retval = ntohl (mp->retval);
3734 vam->result_ready = 1;
3737 static void vl_api_flow_classify_details_t_handler
3738 (vl_api_flow_classify_details_t * mp)
3740 vat_main_t *vam = &vat_main;
3742 print (vam->ofp, "%10d%20d", ntohl (mp->sw_if_index),
3743 ntohl (mp->table_index));
3746 static void vl_api_flow_classify_details_t_handler_json
3747 (vl_api_flow_classify_details_t * mp)
3749 vat_main_t *vam = &vat_main;
3750 vat_json_node_t *node;
3752 if (VAT_JSON_ARRAY != vam->json_tree.type)
3754 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3755 vat_json_init_array (&vam->json_tree);
3757 node = vat_json_array_add (&vam->json_tree);
3759 vat_json_init_object (node);
3760 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
3761 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
3766 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
3767 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
3768 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
3769 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
3770 #define vl_api_vnet_ip4_nbr_counters_t_endian vl_noop_handler
3771 #define vl_api_vnet_ip4_nbr_counters_t_print vl_noop_handler
3772 #define vl_api_vnet_ip6_nbr_counters_t_endian vl_noop_handler
3773 #define vl_api_vnet_ip6_nbr_counters_t_print vl_noop_handler
3774 #define vl_api_lisp_adjacencies_get_reply_t_endian vl_noop_handler
3775 #define vl_api_lisp_adjacencies_get_reply_t_print vl_noop_handler
3778 * Generate boilerplate reply handlers, which
3779 * dig the return value out of the xxx_reply_t API message,
3780 * stick it into vam->retval, and set vam->result_ready
3782 * Could also do this by pointing N message decode slots at
3783 * a single function, but that could break in subtle ways.
3786 #define foreach_standard_reply_retval_handler \
3787 _(sw_interface_set_flags_reply) \
3788 _(sw_interface_add_del_address_reply) \
3789 _(sw_interface_set_table_reply) \
3790 _(sw_interface_set_mpls_enable_reply) \
3791 _(sw_interface_set_vpath_reply) \
3792 _(sw_interface_set_vxlan_bypass_reply) \
3793 _(sw_interface_set_l2_bridge_reply) \
3794 _(bridge_domain_add_del_reply) \
3795 _(sw_interface_set_l2_xconnect_reply) \
3796 _(l2fib_add_del_reply) \
3797 _(ip_add_del_route_reply) \
3798 _(ip_mroute_add_del_reply) \
3799 _(mpls_route_add_del_reply) \
3800 _(mpls_ip_bind_unbind_reply) \
3801 _(proxy_arp_add_del_reply) \
3802 _(proxy_arp_intfc_enable_disable_reply) \
3803 _(sw_interface_set_unnumbered_reply) \
3804 _(ip_neighbor_add_del_reply) \
3805 _(reset_vrf_reply) \
3806 _(oam_add_del_reply) \
3807 _(reset_fib_reply) \
3808 _(dhcp_proxy_config_reply) \
3809 _(dhcp_proxy_config_2_reply) \
3810 _(dhcp_proxy_set_vss_reply) \
3811 _(dhcp_client_config_reply) \
3812 _(set_ip_flow_hash_reply) \
3813 _(sw_interface_ip6_enable_disable_reply) \
3814 _(sw_interface_ip6_set_link_local_address_reply) \
3815 _(sw_interface_ip6nd_ra_prefix_reply) \
3816 _(sw_interface_ip6nd_ra_config_reply) \
3817 _(set_arp_neighbor_limit_reply) \
3818 _(l2_patch_add_del_reply) \
3819 _(sr_tunnel_add_del_reply) \
3820 _(sr_policy_add_del_reply) \
3821 _(sr_multicast_map_add_del_reply) \
3822 _(classify_add_del_session_reply) \
3823 _(classify_set_interface_ip_table_reply) \
3824 _(classify_set_interface_l2_tables_reply) \
3825 _(l2tpv3_set_tunnel_cookies_reply) \
3826 _(l2tpv3_interface_enable_disable_reply) \
3827 _(l2tpv3_set_lookup_key_reply) \
3828 _(l2_fib_clear_table_reply) \
3829 _(l2_interface_efp_filter_reply) \
3830 _(l2_interface_vlan_tag_rewrite_reply) \
3831 _(modify_vhost_user_if_reply) \
3832 _(delete_vhost_user_if_reply) \
3833 _(want_ip4_arp_events_reply) \
3834 _(want_ip6_nd_events_reply) \
3835 _(input_acl_set_interface_reply) \
3836 _(ipsec_spd_add_del_reply) \
3837 _(ipsec_interface_add_del_spd_reply) \
3838 _(ipsec_spd_add_del_entry_reply) \
3839 _(ipsec_sad_add_del_entry_reply) \
3840 _(ipsec_sa_set_key_reply) \
3841 _(ikev2_profile_add_del_reply) \
3842 _(ikev2_profile_set_auth_reply) \
3843 _(ikev2_profile_set_id_reply) \
3844 _(ikev2_profile_set_ts_reply) \
3845 _(ikev2_set_local_key_reply) \
3846 _(delete_loopback_reply) \
3847 _(bd_ip_mac_add_del_reply) \
3848 _(map_del_domain_reply) \
3849 _(map_add_del_rule_reply) \
3850 _(want_interface_events_reply) \
3851 _(want_stats_reply) \
3852 _(cop_interface_enable_disable_reply) \
3853 _(cop_whitelist_enable_disable_reply) \
3854 _(sw_interface_clear_stats_reply) \
3855 _(ioam_enable_reply) \
3856 _(ioam_disable_reply) \
3857 _(lisp_add_del_locator_reply) \
3858 _(lisp_add_del_local_eid_reply) \
3859 _(lisp_add_del_remote_mapping_reply) \
3860 _(lisp_add_del_adjacency_reply) \
3861 _(lisp_gpe_add_del_fwd_entry_reply) \
3862 _(lisp_add_del_map_resolver_reply) \
3863 _(lisp_add_del_map_server_reply) \
3864 _(lisp_gpe_enable_disable_reply) \
3865 _(lisp_gpe_add_del_iface_reply) \
3866 _(lisp_enable_disable_reply) \
3867 _(lisp_rloc_probe_enable_disable_reply) \
3868 _(lisp_map_register_enable_disable_reply) \
3869 _(lisp_pitr_set_locator_set_reply) \
3870 _(lisp_map_request_mode_reply) \
3871 _(lisp_add_del_map_request_itr_rlocs_reply) \
3872 _(lisp_eid_table_add_del_map_reply) \
3873 _(vxlan_gpe_add_del_tunnel_reply) \
3874 _(af_packet_delete_reply) \
3875 _(policer_classify_set_interface_reply) \
3876 _(netmap_create_reply) \
3877 _(netmap_delete_reply) \
3878 _(set_ipfix_exporter_reply) \
3879 _(set_ipfix_classify_stream_reply) \
3880 _(ipfix_classify_table_add_del_reply) \
3881 _(flow_classify_set_interface_reply) \
3882 _(sw_interface_span_enable_disable_reply) \
3883 _(pg_capture_reply) \
3884 _(pg_enable_disable_reply) \
3885 _(ip_source_and_port_range_check_add_del_reply) \
3886 _(ip_source_and_port_range_check_interface_add_del_reply)\
3887 _(delete_subif_reply) \
3888 _(l2_interface_pbb_tag_rewrite_reply) \
3890 _(feature_enable_disable_reply) \
3891 _(sw_interface_tag_add_del_reply) \
3892 _(sw_interface_set_mtu_reply)
3895 #define foreach_standard_dpdk_reply_retval_handler \
3896 _(sw_interface_set_dpdk_hqos_pipe_reply) \
3897 _(sw_interface_set_dpdk_hqos_subport_reply) \
3898 _(sw_interface_set_dpdk_hqos_tctbl_reply)
3902 static void vl_api_##n##_t_handler \
3903 (vl_api_##n##_t * mp) \
3905 vat_main_t * vam = &vat_main; \
3906 i32 retval = ntohl(mp->retval); \
3907 if (vam->async_mode) { \
3908 vam->async_errors += (retval < 0); \
3910 vam->retval = retval; \
3911 vam->result_ready = 1; \
3914 foreach_standard_reply_retval_handler;
3918 static void vl_api_##n##_t_handler_json \
3919 (vl_api_##n##_t * mp) \
3921 vat_main_t * vam = &vat_main; \
3922 vat_json_node_t node; \
3923 vat_json_init_object(&node); \
3924 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
3925 vat_json_print(vam->ofp, &node); \
3926 vam->retval = ntohl(mp->retval); \
3927 vam->result_ready = 1; \
3929 foreach_standard_reply_retval_handler;
3934 static void vl_api_##n##_t_handler \
3935 (vl_api_##n##_t * mp) \
3937 vat_main_t * vam = &vat_main; \
3938 i32 retval = ntohl(mp->retval); \
3939 if (vam->async_mode) { \
3940 vam->async_errors += (retval < 0); \
3942 vam->retval = retval; \
3943 vam->result_ready = 1; \
3946 foreach_standard_dpdk_reply_retval_handler;
3950 static void vl_api_##n##_t_handler_json \
3951 (vl_api_##n##_t * mp) \
3953 vat_main_t * vam = &vat_main; \
3954 vat_json_node_t node; \
3955 vat_json_init_object(&node); \
3956 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
3957 vat_json_print(vam->ofp, &node); \
3958 vam->retval = ntohl(mp->retval); \
3959 vam->result_ready = 1; \
3961 foreach_standard_dpdk_reply_retval_handler;
3966 * Table of message reply handlers, must include boilerplate handlers
3970 #define foreach_vpe_api_reply_msg \
3971 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
3972 _(SW_INTERFACE_DETAILS, sw_interface_details) \
3973 _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
3974 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
3975 _(CONTROL_PING_REPLY, control_ping_reply) \
3976 _(CLI_REPLY, cli_reply) \
3977 _(CLI_INBAND_REPLY, cli_inband_reply) \
3978 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
3979 sw_interface_add_del_address_reply) \
3980 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
3981 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
3982 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
3983 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
3984 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
3985 sw_interface_set_l2_xconnect_reply) \
3986 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
3987 sw_interface_set_l2_bridge_reply) \
3988 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
3989 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
3990 _(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
3991 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
3992 _(L2_FLAGS_REPLY, l2_flags_reply) \
3993 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
3994 _(TAP_CONNECT_REPLY, tap_connect_reply) \
3995 _(TAP_MODIFY_REPLY, tap_modify_reply) \
3996 _(TAP_DELETE_REPLY, tap_delete_reply) \
3997 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
3998 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
3999 _(IP_MROUTE_ADD_DEL_REPLY, ip_mroute_add_del_reply) \
4000 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
4001 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
4002 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
4003 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
4004 proxy_arp_intfc_enable_disable_reply) \
4005 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
4006 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
4007 sw_interface_set_unnumbered_reply) \
4008 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
4009 _(RESET_VRF_REPLY, reset_vrf_reply) \
4010 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
4011 _(CREATE_SUBIF_REPLY, create_subif_reply) \
4012 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
4013 _(RESET_FIB_REPLY, reset_fib_reply) \
4014 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
4015 _(DHCP_PROXY_CONFIG_2_REPLY, dhcp_proxy_config_2_reply) \
4016 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
4017 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
4018 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
4019 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
4020 sw_interface_ip6_enable_disable_reply) \
4021 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
4022 sw_interface_ip6_set_link_local_address_reply) \
4023 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
4024 sw_interface_ip6nd_ra_prefix_reply) \
4025 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
4026 sw_interface_ip6nd_ra_config_reply) \
4027 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
4028 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
4029 _(SR_TUNNEL_ADD_DEL_REPLY, sr_tunnel_add_del_reply) \
4030 _(SR_POLICY_ADD_DEL_REPLY, sr_policy_add_del_reply) \
4031 _(SR_MULTICAST_MAP_ADD_DEL_REPLY, sr_multicast_map_add_del_reply) \
4032 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
4033 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
4034 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
4035 classify_set_interface_ip_table_reply) \
4036 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
4037 classify_set_interface_l2_tables_reply) \
4038 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
4039 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
4040 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
4041 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
4042 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
4043 l2tpv3_interface_enable_disable_reply) \
4044 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
4045 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
4046 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
4047 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
4048 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
4049 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
4050 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
4051 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
4052 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
4053 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
4054 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
4055 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
4056 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
4057 _(SHOW_VERSION_REPLY, show_version_reply) \
4058 _(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
4059 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
4060 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
4061 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
4062 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
4063 _(IP4_ARP_EVENT, ip4_arp_event) \
4064 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
4065 _(IP6_ND_EVENT, ip6_nd_event) \
4066 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
4067 _(IP_ADDRESS_DETAILS, ip_address_details) \
4068 _(IP_DETAILS, ip_details) \
4069 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
4070 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
4071 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
4072 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
4073 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
4074 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
4075 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
4076 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
4077 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
4078 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
4079 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
4080 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
4081 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
4082 _(VNET_INTERFACE_COUNTERS, vnet_interface_counters) \
4083 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
4084 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
4085 _(VNET_IP4_NBR_COUNTERS, vnet_ip4_nbr_counters) \
4086 _(VNET_IP6_NBR_COUNTERS, vnet_ip6_nbr_counters) \
4087 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
4088 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
4089 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
4090 _(MAP_DOMAIN_DETAILS, map_domain_details) \
4091 _(MAP_RULE_DETAILS, map_rule_details) \
4092 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
4093 _(WANT_STATS_REPLY, want_stats_reply) \
4094 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
4095 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
4096 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
4097 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
4098 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
4099 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
4100 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
4101 _(LISP_ADD_DEL_LOCATOR_SET_REPLY, lisp_add_del_locator_set_reply) \
4102 _(LISP_ADD_DEL_LOCATOR_REPLY, lisp_add_del_locator_reply) \
4103 _(LISP_ADD_DEL_LOCAL_EID_REPLY, lisp_add_del_local_eid_reply) \
4104 _(LISP_ADD_DEL_REMOTE_MAPPING_REPLY, lisp_add_del_remote_mapping_reply) \
4105 _(LISP_ADD_DEL_ADJACENCY_REPLY, lisp_add_del_adjacency_reply) \
4106 _(LISP_GPE_ADD_DEL_FWD_ENTRY_REPLY, lisp_gpe_add_del_fwd_entry_reply) \
4107 _(LISP_ADD_DEL_MAP_RESOLVER_REPLY, lisp_add_del_map_resolver_reply) \
4108 _(LISP_ADD_DEL_MAP_SERVER_REPLY, lisp_add_del_map_server_reply) \
4109 _(LISP_GPE_ENABLE_DISABLE_REPLY, lisp_gpe_enable_disable_reply) \
4110 _(LISP_ENABLE_DISABLE_REPLY, lisp_enable_disable_reply) \
4111 _(LISP_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
4112 lisp_map_register_enable_disable_reply) \
4113 _(LISP_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
4114 lisp_rloc_probe_enable_disable_reply) \
4115 _(LISP_PITR_SET_LOCATOR_SET_REPLY, lisp_pitr_set_locator_set_reply) \
4116 _(LISP_MAP_REQUEST_MODE_REPLY, lisp_map_request_mode_reply) \
4117 _(LISP_EID_TABLE_ADD_DEL_MAP_REPLY, lisp_eid_table_add_del_map_reply) \
4118 _(LISP_GPE_ADD_DEL_IFACE_REPLY, lisp_gpe_add_del_iface_reply) \
4119 _(LISP_LOCATOR_SET_DETAILS, lisp_locator_set_details) \
4120 _(LISP_LOCATOR_DETAILS, lisp_locator_details) \
4121 _(LISP_EID_TABLE_DETAILS, lisp_eid_table_details) \
4122 _(LISP_EID_TABLE_MAP_DETAILS, lisp_eid_table_map_details) \
4123 _(LISP_EID_TABLE_VNI_DETAILS, lisp_eid_table_vni_details) \
4124 _(LISP_MAP_RESOLVER_DETAILS, lisp_map_resolver_details) \
4125 _(LISP_MAP_SERVER_DETAILS, lisp_map_server_details) \
4126 _(LISP_ADJACENCIES_GET_REPLY, lisp_adjacencies_get_reply) \
4127 _(LISP_GPE_FWD_ENTRIES_GET_REPLY, lisp_gpe_fwd_entries_get_reply) \
4128 _(LISP_GPE_FWD_ENTRY_PATH_DETAILS, \
4129 lisp_gpe_fwd_entry_path_details) \
4130 _(SHOW_LISP_STATUS_REPLY, show_lisp_status_reply) \
4131 _(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
4132 lisp_add_del_map_request_itr_rlocs_reply) \
4133 _(LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
4134 lisp_get_map_request_itr_rlocs_reply) \
4135 _(SHOW_LISP_PITR_REPLY, show_lisp_pitr_reply) \
4136 _(SHOW_LISP_MAP_REQUEST_MODE_REPLY, show_lisp_map_request_mode_reply) \
4137 _(SHOW_LISP_RLOC_PROBE_STATE_REPLY, show_lisp_rloc_probe_state_reply) \
4138 _(SHOW_LISP_MAP_REGISTER_STATE_REPLY, \
4139 show_lisp_map_register_state_reply) \
4140 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
4141 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
4142 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
4143 _(POLICER_DETAILS, policer_details) \
4144 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
4145 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
4146 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
4147 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
4148 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
4149 _(MPLS_FIB_DETAILS, mpls_fib_details) \
4150 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
4151 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
4152 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
4153 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
4154 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
4155 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
4156 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
4157 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
4158 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
4159 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
4160 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
4161 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
4162 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
4163 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
4164 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
4165 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
4166 _(PG_CAPTURE_REPLY, pg_capture_reply) \
4167 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
4168 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
4169 ip_source_and_port_range_check_add_del_reply) \
4170 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
4171 ip_source_and_port_range_check_interface_add_del_reply) \
4172 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
4173 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
4174 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
4175 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
4176 _(PUNT_REPLY, punt_reply) \
4177 _(IP_FIB_DETAILS, ip_fib_details) \
4178 _(IP6_FIB_DETAILS, ip6_fib_details) \
4179 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
4180 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
4181 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
4182 _(SW_INTERFACE_SET_MTU_REPLY, sw_interface_set_mtu_reply) \
4183 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
4184 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply)
4187 #define foreach_vpe_dpdk_api_reply_msg \
4188 _(SW_INTERFACE_SET_DPDK_HQOS_PIPE_REPLY, \
4189 sw_interface_set_dpdk_hqos_pipe_reply) \
4190 _(SW_INTERFACE_SET_DPDK_HQOS_SUBPORT_REPLY, \
4191 sw_interface_set_dpdk_hqos_subport_reply) \
4192 _(SW_INTERFACE_SET_DPDK_HQOS_TCTBL_REPLY, \
4193 sw_interface_set_dpdk_hqos_tctbl_reply)
4203 #define STR_VTR_OP_CASE(op) \
4204 case L2_VTR_ ## op: \
4208 str_vtr_op (u32 vtr_op)
4212 STR_VTR_OP_CASE (DISABLED);
4213 STR_VTR_OP_CASE (PUSH_1);
4214 STR_VTR_OP_CASE (PUSH_2);
4215 STR_VTR_OP_CASE (POP_1);
4216 STR_VTR_OP_CASE (POP_2);
4217 STR_VTR_OP_CASE (TRANSLATE_1_1);
4218 STR_VTR_OP_CASE (TRANSLATE_1_2);
4219 STR_VTR_OP_CASE (TRANSLATE_2_1);
4220 STR_VTR_OP_CASE (TRANSLATE_2_2);
4227 dump_sub_interface_table (vat_main_t * vam)
4229 const sw_interface_subif_t *sub = NULL;
4231 if (vam->json_output)
4234 ("JSON output supported only for VPE API calls and dump_stats_table");
4239 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s",
4240 "Interface", "sw_if_index",
4241 "sub id", "dot1ad", "tags", "outer id",
4242 "inner id", "exact", "default", "outer any", "inner any");
4244 vec_foreach (sub, vam->sw_if_subif_table)
4247 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d",
4248 sub->interface_name,
4250 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
4251 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
4252 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
4253 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
4254 if (sub->vtr_op != L2_VTR_DISABLED)
4257 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
4258 "tag1: %d tag2: %d ]",
4259 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
4260 sub->vtr_tag1, sub->vtr_tag2);
4268 name_sort_cmp (void *a1, void *a2)
4270 name_sort_t *n1 = a1;
4271 name_sort_t *n2 = a2;
4273 return strcmp ((char *) n1->name, (char *) n2->name);
4277 dump_interface_table (vat_main_t * vam)
4280 name_sort_t *nses = 0, *ns;
4282 if (vam->json_output)
4285 ("JSON output supported only for VPE API calls and dump_stats_table");
4290 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4292 vec_add2 (nses, ns, 1);
4293 ns->name = (u8 *)(p->key);
4294 ns->value = (u32) p->value[0];
4298 vec_sort_with_function (nses, name_sort_cmp);
4300 print (vam->ofp, "%-25s%-15s", "Interface", "sw_if_index");
4301 vec_foreach (ns, nses)
4303 print (vam->ofp, "%-25s%-15d", ns->name, ns->value);
4310 dump_ip_table (vat_main_t * vam, int is_ipv6)
4312 const ip_details_t *det = NULL;
4313 const ip_address_details_t *address = NULL;
4316 print (vam->ofp, "%-12s", "sw_if_index");
4318 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
4325 print (vam->ofp, "%-12d", i);
4326 print (vam->ofp, " %-30s%-13s", "Address", "Prefix length");
4331 vec_foreach (address, det->addr)
4335 is_ipv6 ? format_ip6_address : format_ip4_address,
4336 address->ip, address->prefix_length);
4344 dump_ipv4_table (vat_main_t * vam)
4346 if (vam->json_output)
4349 ("JSON output supported only for VPE API calls and dump_stats_table");
4353 return dump_ip_table (vam, 0);
4357 dump_ipv6_table (vat_main_t * vam)
4359 if (vam->json_output)
4362 ("JSON output supported only for VPE API calls and dump_stats_table");
4366 return dump_ip_table (vam, 1);
4370 counter_type_to_str (u8 counter_type, u8 is_combined)
4374 switch (counter_type)
4376 case VNET_INTERFACE_COUNTER_DROP:
4378 case VNET_INTERFACE_COUNTER_PUNT:
4380 case VNET_INTERFACE_COUNTER_IP4:
4382 case VNET_INTERFACE_COUNTER_IP6:
4384 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
4386 case VNET_INTERFACE_COUNTER_RX_MISS:
4388 case VNET_INTERFACE_COUNTER_RX_ERROR:
4390 case VNET_INTERFACE_COUNTER_TX_ERROR:
4393 return "INVALID-COUNTER-TYPE";
4398 switch (counter_type)
4400 case VNET_INTERFACE_COUNTER_RX:
4402 case VNET_INTERFACE_COUNTER_TX:
4405 return "INVALID-COUNTER-TYPE";
4411 dump_stats_table (vat_main_t * vam)
4413 vat_json_node_t node;
4414 vat_json_node_t *msg_array;
4415 vat_json_node_t *msg;
4416 vat_json_node_t *counter_array;
4417 vat_json_node_t *counter;
4418 interface_counter_t c;
4420 ip4_fib_counter_t *c4;
4421 ip6_fib_counter_t *c6;
4422 ip4_nbr_counter_t *n4;
4423 ip6_nbr_counter_t *n6;
4426 if (!vam->json_output)
4428 clib_warning ("dump_stats_table supported only in JSON format");
4432 vat_json_init_object (&node);
4434 /* interface counters */
4435 msg_array = vat_json_object_add (&node, "interface_counters");
4436 vat_json_init_array (msg_array);
4437 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
4439 msg = vat_json_array_add (msg_array);
4440 vat_json_init_object (msg);
4441 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4442 (u8 *) counter_type_to_str (i, 0));
4443 vat_json_object_add_int (msg, "is_combined", 0);
4444 counter_array = vat_json_object_add (msg, "data");
4445 vat_json_init_array (counter_array);
4446 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
4448 packets = vam->simple_interface_counters[i][j];
4449 vat_json_array_add_uint (counter_array, packets);
4452 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
4454 msg = vat_json_array_add (msg_array);
4455 vat_json_init_object (msg);
4456 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4457 (u8 *) counter_type_to_str (i, 1));
4458 vat_json_object_add_int (msg, "is_combined", 1);
4459 counter_array = vat_json_object_add (msg, "data");
4460 vat_json_init_array (counter_array);
4461 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
4463 c = vam->combined_interface_counters[i][j];
4464 counter = vat_json_array_add (counter_array);
4465 vat_json_init_object (counter);
4466 vat_json_object_add_uint (counter, "packets", c.packets);
4467 vat_json_object_add_uint (counter, "bytes", c.bytes);
4471 /* ip4 fib counters */
4472 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
4473 vat_json_init_array (msg_array);
4474 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
4476 msg = vat_json_array_add (msg_array);
4477 vat_json_init_object (msg);
4478 vat_json_object_add_uint (msg, "vrf_id",
4479 vam->ip4_fib_counters_vrf_id_by_index[i]);
4480 counter_array = vat_json_object_add (msg, "c");
4481 vat_json_init_array (counter_array);
4482 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
4484 counter = vat_json_array_add (counter_array);
4485 vat_json_init_object (counter);
4486 c4 = &vam->ip4_fib_counters[i][j];
4487 vat_json_object_add_ip4 (counter, "address", c4->address);
4488 vat_json_object_add_uint (counter, "address_length",
4489 c4->address_length);
4490 vat_json_object_add_uint (counter, "packets", c4->packets);
4491 vat_json_object_add_uint (counter, "bytes", c4->bytes);
4495 /* ip6 fib counters */
4496 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
4497 vat_json_init_array (msg_array);
4498 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
4500 msg = vat_json_array_add (msg_array);
4501 vat_json_init_object (msg);
4502 vat_json_object_add_uint (msg, "vrf_id",
4503 vam->ip6_fib_counters_vrf_id_by_index[i]);
4504 counter_array = vat_json_object_add (msg, "c");
4505 vat_json_init_array (counter_array);
4506 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
4508 counter = vat_json_array_add (counter_array);
4509 vat_json_init_object (counter);
4510 c6 = &vam->ip6_fib_counters[i][j];
4511 vat_json_object_add_ip6 (counter, "address", c6->address);
4512 vat_json_object_add_uint (counter, "address_length",
4513 c6->address_length);
4514 vat_json_object_add_uint (counter, "packets", c6->packets);
4515 vat_json_object_add_uint (counter, "bytes", c6->bytes);
4519 /* ip4 nbr counters */
4520 msg_array = vat_json_object_add (&node, "ip4_nbr_counters");
4521 vat_json_init_array (msg_array);
4522 for (i = 0; i < vec_len (vam->ip4_nbr_counters); i++)
4524 msg = vat_json_array_add (msg_array);
4525 vat_json_init_object (msg);
4526 vat_json_object_add_uint (msg, "sw_if_index", i);
4527 counter_array = vat_json_object_add (msg, "c");
4528 vat_json_init_array (counter_array);
4529 for (j = 0; j < vec_len (vam->ip4_nbr_counters[i]); j++)
4531 counter = vat_json_array_add (counter_array);
4532 vat_json_init_object (counter);
4533 n4 = &vam->ip4_nbr_counters[i][j];
4534 vat_json_object_add_ip4 (counter, "address", n4->address);
4535 vat_json_object_add_uint (counter, "link-type", n4->linkt);
4536 vat_json_object_add_uint (counter, "packets", n4->packets);
4537 vat_json_object_add_uint (counter, "bytes", n4->bytes);
4541 /* ip6 nbr counters */
4542 msg_array = vat_json_object_add (&node, "ip6_nbr_counters");
4543 vat_json_init_array (msg_array);
4544 for (i = 0; i < vec_len (vam->ip6_nbr_counters); i++)
4546 msg = vat_json_array_add (msg_array);
4547 vat_json_init_object (msg);
4548 vat_json_object_add_uint (msg, "sw_if_index", i);
4549 counter_array = vat_json_object_add (msg, "c");
4550 vat_json_init_array (counter_array);
4551 for (j = 0; j < vec_len (vam->ip6_nbr_counters[i]); j++)
4553 counter = vat_json_array_add (counter_array);
4554 vat_json_init_object (counter);
4555 n6 = &vam->ip6_nbr_counters[i][j];
4556 vat_json_object_add_ip6 (counter, "address", n6->address);
4557 vat_json_object_add_uint (counter, "packets", n6->packets);
4558 vat_json_object_add_uint (counter, "bytes", n6->bytes);
4562 vat_json_print (vam->ofp, &node);
4563 vat_json_free (&node);
4569 exec (vat_main_t * vam)
4571 api_main_t *am = &api_main;
4572 vl_api_cli_request_t *mp;
4576 unformat_input_t *i = vam->input;
4578 if (vec_len (i->buffer) == 0)
4581 if (vam->exec_mode == 0 && unformat (i, "mode"))
4586 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4593 M (CLI_REQUEST, cli_request);
4596 * Copy cmd into shared memory.
4597 * In order for the CLI command to work, it
4598 * must be a vector ending in \n, not a C-string ending
4601 pthread_mutex_lock (&am->vlib_rp->mutex);
4602 oldheap = svm_push_data_heap (am->vlib_rp);
4604 vec_validate (cmd, vec_len (vam->input->buffer) - 1);
4605 clib_memcpy (cmd, vam->input->buffer, vec_len (vam->input->buffer));
4607 svm_pop_heap (oldheap);
4608 pthread_mutex_unlock (&am->vlib_rp->mutex);
4610 mp->cmd_in_shmem = (u64) cmd;
4612 timeout = vat_time_now (vam) + 10.0;
4614 while (vat_time_now (vam) < timeout)
4616 if (vam->result_ready == 1)
4619 if (vam->shmem_result != NULL)
4620 print (vam->ofp, "%s", vam->shmem_result);
4621 pthread_mutex_lock (&am->vlib_rp->mutex);
4622 oldheap = svm_push_data_heap (am->vlib_rp);
4624 free_me = (u8 *) vam->shmem_result;
4627 svm_pop_heap (oldheap);
4628 pthread_mutex_unlock (&am->vlib_rp->mutex);
4636 * Future replacement of exec() that passes CLI buffers directly in
4637 * the API messages instead of an additional shared memory area.
4640 exec_inband (vat_main_t * vam)
4642 vl_api_cli_inband_t *mp;
4644 unformat_input_t *i = vam->input;
4646 if (vec_len (i->buffer) == 0)
4649 if (vam->exec_mode == 0 && unformat (i, "mode"))
4654 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4661 * In order for the CLI command to work, it
4662 * must be a vector ending in \n, not a C-string ending
4665 u32 len = vec_len (vam->input->buffer);
4666 M2 (CLI_INBAND, cli_inband, len);
4667 clib_memcpy (mp->cmd, vam->input->buffer, len);
4668 mp->length = htonl (len);
4671 W2 (print (vam->ofp, "%s", vam->cmd_reply));
4675 api_create_loopback (vat_main_t * vam)
4677 unformat_input_t *i = vam->input;
4678 vl_api_create_loopback_t *mp;
4683 memset (mac_address, 0, sizeof (mac_address));
4685 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4687 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
4693 /* Construct the API message */
4694 M (CREATE_LOOPBACK, create_loopback);
4696 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
4703 api_delete_loopback (vat_main_t * vam)
4705 unformat_input_t *i = vam->input;
4706 vl_api_delete_loopback_t *mp;
4708 u32 sw_if_index = ~0;
4710 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4712 if (unformat (i, "sw_if_index %d", &sw_if_index))
4718 if (sw_if_index == ~0)
4720 errmsg ("missing sw_if_index");
4724 /* Construct the API message */
4725 M (DELETE_LOOPBACK, delete_loopback);
4726 mp->sw_if_index = ntohl (sw_if_index);
4733 api_want_stats (vat_main_t * vam)
4735 unformat_input_t *i = vam->input;
4736 vl_api_want_stats_t *mp;
4740 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4742 if (unformat (i, "enable"))
4744 else if (unformat (i, "disable"))
4752 errmsg ("missing enable|disable");
4756 M (WANT_STATS, want_stats);
4757 mp->enable_disable = enable;
4764 api_want_interface_events (vat_main_t * vam)
4766 unformat_input_t *i = vam->input;
4767 vl_api_want_interface_events_t *mp;
4771 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4773 if (unformat (i, "enable"))
4775 else if (unformat (i, "disable"))
4783 errmsg ("missing enable|disable");
4787 M (WANT_INTERFACE_EVENTS, want_interface_events);
4788 mp->enable_disable = enable;
4790 vam->interface_event_display = enable;
4797 /* Note: non-static, called once to set up the initial intfc table */
4799 api_sw_interface_dump (vat_main_t * vam)
4801 vl_api_sw_interface_dump_t *mp;
4804 name_sort_t *nses = 0, *ns;
4805 sw_interface_subif_t *sub = NULL;
4807 /* Toss the old name table */
4809 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4811 vec_add2 (nses, ns, 1);
4812 ns->name = (u8 *)(p->key);
4813 ns->value = (u32) p->value[0];
4817 hash_free (vam->sw_if_index_by_interface_name);
4819 vec_foreach (ns, nses) vec_free (ns->name);
4823 vec_foreach (sub, vam->sw_if_subif_table)
4825 vec_free (sub->interface_name);
4827 vec_free (vam->sw_if_subif_table);
4829 /* recreate the interface name hash table */
4830 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
4832 /* Get list of ethernets */
4833 M (SW_INTERFACE_DUMP, sw_interface_dump);
4834 mp->name_filter_valid = 1;
4835 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
4838 /* and local / loopback interfaces */
4839 M (SW_INTERFACE_DUMP, sw_interface_dump);
4840 mp->name_filter_valid = 1;
4841 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
4844 /* and packet-generator interfaces */
4845 M (SW_INTERFACE_DUMP, sw_interface_dump);
4846 mp->name_filter_valid = 1;
4847 strncpy ((char *) mp->name_filter, "pg", sizeof (mp->name_filter) - 1);
4850 /* and vxlan-gpe tunnel interfaces */
4851 M (SW_INTERFACE_DUMP, sw_interface_dump);
4852 mp->name_filter_valid = 1;
4853 strncpy ((char *) mp->name_filter, "vxlan_gpe",
4854 sizeof (mp->name_filter) - 1);
4857 /* and vxlan tunnel interfaces */
4858 M (SW_INTERFACE_DUMP, sw_interface_dump);
4859 mp->name_filter_valid = 1;
4860 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
4863 /* and host (af_packet) interfaces */
4864 M (SW_INTERFACE_DUMP, sw_interface_dump);
4865 mp->name_filter_valid = 1;
4866 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
4869 /* and l2tpv3 tunnel interfaces */
4870 M (SW_INTERFACE_DUMP, sw_interface_dump);
4871 mp->name_filter_valid = 1;
4872 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
4873 sizeof (mp->name_filter) - 1);
4876 /* and GRE tunnel interfaces */
4877 M (SW_INTERFACE_DUMP, sw_interface_dump);
4878 mp->name_filter_valid = 1;
4879 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
4882 /* and LISP-GPE interfaces */
4883 M (SW_INTERFACE_DUMP, sw_interface_dump);
4884 mp->name_filter_valid = 1;
4885 strncpy ((char *) mp->name_filter, "lisp_gpe",
4886 sizeof (mp->name_filter) - 1);
4889 /* and IPSEC tunnel interfaces */
4890 M (SW_INTERFACE_DUMP, sw_interface_dump);
4891 mp->name_filter_valid = 1;
4892 strncpy ((char *) mp->name_filter, "ipsec", sizeof (mp->name_filter) - 1);
4895 /* Use a control ping for synchronization */
4897 vl_api_control_ping_t *mp;
4898 M (CONTROL_PING, control_ping);
4905 api_sw_interface_set_flags (vat_main_t * vam)
4907 unformat_input_t *i = vam->input;
4908 vl_api_sw_interface_set_flags_t *mp;
4911 u8 sw_if_index_set = 0;
4912 u8 admin_up = 0, link_up = 0;
4914 /* Parse args required to build the message */
4915 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4917 if (unformat (i, "admin-up"))
4919 else if (unformat (i, "admin-down"))
4921 else if (unformat (i, "link-up"))
4923 else if (unformat (i, "link-down"))
4926 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4927 sw_if_index_set = 1;
4928 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4929 sw_if_index_set = 1;
4934 if (sw_if_index_set == 0)
4936 errmsg ("missing interface name or sw_if_index");
4940 /* Construct the API message */
4941 M (SW_INTERFACE_SET_FLAGS, sw_interface_set_flags);
4942 mp->sw_if_index = ntohl (sw_if_index);
4943 mp->admin_up_down = admin_up;
4944 mp->link_up_down = link_up;
4949 /* Wait for a reply, return the good/bad news... */
4954 api_sw_interface_clear_stats (vat_main_t * vam)
4956 unformat_input_t *i = vam->input;
4957 vl_api_sw_interface_clear_stats_t *mp;
4960 u8 sw_if_index_set = 0;
4962 /* Parse args required to build the message */
4963 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4965 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
4966 sw_if_index_set = 1;
4967 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4968 sw_if_index_set = 1;
4973 /* Construct the API message */
4974 M (SW_INTERFACE_CLEAR_STATS, sw_interface_clear_stats);
4976 if (sw_if_index_set == 1)
4977 mp->sw_if_index = ntohl (sw_if_index);
4979 mp->sw_if_index = ~0;
4984 /* Wait for a reply, return the good/bad news... */
4990 api_sw_interface_set_dpdk_hqos_pipe (vat_main_t * vam)
4992 unformat_input_t *i = vam->input;
4993 vl_api_sw_interface_set_dpdk_hqos_pipe_t *mp;
4996 u8 sw_if_index_set = 0;
5004 /* Parse args required to build the message */
5005 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5007 if (unformat (i, "rx %U", api_unformat_sw_if_index, vam, &sw_if_index))
5008 sw_if_index_set = 1;
5009 else if (unformat (i, "sw_if_index %u", &sw_if_index))
5010 sw_if_index_set = 1;
5011 else if (unformat (i, "subport %u", &subport))
5014 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5015 sw_if_index_set = 1;
5016 else if (unformat (i, "pipe %u", &pipe))
5018 else if (unformat (i, "profile %u", &profile))
5024 if (sw_if_index_set == 0)
5026 errmsg ("missing interface name or sw_if_index");
5030 if (subport_set == 0)
5032 errmsg ("missing subport ");
5038 errmsg ("missing pipe");
5042 if (profile_set == 0)
5044 errmsg ("missing profile");
5048 M (SW_INTERFACE_SET_DPDK_HQOS_PIPE, sw_interface_set_dpdk_hqos_pipe);
5050 mp->sw_if_index = ntohl (sw_if_index);
5051 mp->subport = ntohl (subport);
5052 mp->pipe = ntohl (pipe);
5053 mp->profile = ntohl (profile);
5063 api_sw_interface_set_dpdk_hqos_subport (vat_main_t * vam)
5065 unformat_input_t *i = vam->input;
5066 vl_api_sw_interface_set_dpdk_hqos_subport_t *mp;
5069 u8 sw_if_index_set = 0;
5072 u32 tb_rate = 1250000000; /* 10GbE */
5073 u32 tb_size = 1000000;
5074 u32 tc_rate[] = { 1250000000, 1250000000, 1250000000, 1250000000 };
5077 /* Parse args required to build the message */
5078 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5080 if (unformat (i, "rx %U", api_unformat_sw_if_index, vam, &sw_if_index))
5081 sw_if_index_set = 1;
5082 else if (unformat (i, "sw_if_index %u", &sw_if_index))
5083 sw_if_index_set = 1;
5084 else if (unformat (i, "subport %u", &subport))
5087 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5088 sw_if_index_set = 1;
5089 else if (unformat (i, "rate %u", &tb_rate))
5093 for (tc_id = 0; tc_id < (sizeof (tc_rate) / sizeof (tc_rate[0]));
5095 tc_rate[tc_id] = tb_rate;
5097 else if (unformat (i, "bktsize %u", &tb_size))
5099 else if (unformat (i, "tc0 %u", &tc_rate[0]))
5101 else if (unformat (i, "tc1 %u", &tc_rate[1]))
5103 else if (unformat (i, "tc2 %u", &tc_rate[2]))
5105 else if (unformat (i, "tc3 %u", &tc_rate[3]))
5107 else if (unformat (i, "period %u", &tc_period))
5113 if (sw_if_index_set == 0)
5115 errmsg ("missing interface name or sw_if_index");
5119 if (subport_set == 0)
5121 errmsg ("missing subport ");
5125 M (SW_INTERFACE_SET_DPDK_HQOS_SUBPORT, sw_interface_set_dpdk_hqos_subport);
5127 mp->sw_if_index = ntohl (sw_if_index);
5128 mp->subport = ntohl (subport);
5129 mp->tb_rate = ntohl (tb_rate);
5130 mp->tb_size = ntohl (tb_size);
5131 mp->tc_rate[0] = ntohl (tc_rate[0]);
5132 mp->tc_rate[1] = ntohl (tc_rate[1]);
5133 mp->tc_rate[2] = ntohl (tc_rate[2]);
5134 mp->tc_rate[3] = ntohl (tc_rate[3]);
5135 mp->tc_period = ntohl (tc_period);
5144 api_sw_interface_set_dpdk_hqos_tctbl (vat_main_t * vam)
5146 unformat_input_t *i = vam->input;
5147 vl_api_sw_interface_set_dpdk_hqos_tctbl_t *mp;
5150 u8 sw_if_index_set = 0;
5154 u32 entry, tc, queue;
5156 /* Parse args required to build the message */
5157 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5159 if (unformat (i, "rx %U", api_unformat_sw_if_index, vam, &sw_if_index))
5160 sw_if_index_set = 1;
5161 else if (unformat (i, "sw_if_index %u", &sw_if_index))
5162 sw_if_index_set = 1;
5163 else if (unformat (i, "entry %d", &entry))
5165 else if (unformat (i, "tc %d", &tc))
5167 else if (unformat (i, "queue %d", &queue))
5173 if (sw_if_index_set == 0)
5175 errmsg ("missing interface name or sw_if_index");
5181 errmsg ("missing entry ");
5187 errmsg ("missing traffic class ");
5193 errmsg ("missing queue ");
5197 M (SW_INTERFACE_SET_DPDK_HQOS_TCTBL, sw_interface_set_dpdk_hqos_tctbl);
5199 mp->sw_if_index = ntohl (sw_if_index);
5200 mp->entry = ntohl (entry);
5201 mp->tc = ntohl (tc);
5202 mp->queue = ntohl (queue);
5212 api_sw_interface_add_del_address (vat_main_t * vam)
5214 unformat_input_t *i = vam->input;
5215 vl_api_sw_interface_add_del_address_t *mp;
5218 u8 sw_if_index_set = 0;
5219 u8 is_add = 1, del_all = 0;
5220 u32 address_length = 0;
5221 u8 v4_address_set = 0;
5222 u8 v6_address_set = 0;
5223 ip4_address_t v4address;
5224 ip6_address_t v6address;
5226 /* Parse args required to build the message */
5227 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5229 if (unformat (i, "del-all"))
5231 else if (unformat (i, "del"))
5234 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5235 sw_if_index_set = 1;
5236 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5237 sw_if_index_set = 1;
5238 else if (unformat (i, "%U/%d",
5239 unformat_ip4_address, &v4address, &address_length))
5241 else if (unformat (i, "%U/%d",
5242 unformat_ip6_address, &v6address, &address_length))
5248 if (sw_if_index_set == 0)
5250 errmsg ("missing interface name or sw_if_index");
5253 if (v4_address_set && v6_address_set)
5255 errmsg ("both v4 and v6 addresses set");
5258 if (!v4_address_set && !v6_address_set && !del_all)
5260 errmsg ("no addresses set");
5264 /* Construct the API message */
5265 M (SW_INTERFACE_ADD_DEL_ADDRESS, sw_interface_add_del_address);
5267 mp->sw_if_index = ntohl (sw_if_index);
5268 mp->is_add = is_add;
5269 mp->del_all = del_all;
5273 clib_memcpy (mp->address, &v6address, sizeof (v6address));
5277 clib_memcpy (mp->address, &v4address, sizeof (v4address));
5279 mp->address_length = address_length;
5284 /* Wait for a reply, return good/bad news */
5289 api_sw_interface_set_mpls_enable (vat_main_t * vam)
5291 unformat_input_t *i = vam->input;
5292 vl_api_sw_interface_set_mpls_enable_t *mp;
5295 u8 sw_if_index_set = 0;
5298 /* Parse args required to build the message */
5299 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5301 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5302 sw_if_index_set = 1;
5303 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5304 sw_if_index_set = 1;
5305 else if (unformat (i, "disable"))
5307 else if (unformat (i, "dis"))
5313 if (sw_if_index_set == 0)
5315 errmsg ("missing interface name or sw_if_index");
5319 /* Construct the API message */
5320 M (SW_INTERFACE_SET_MPLS_ENABLE, sw_interface_set_mpls_enable);
5322 mp->sw_if_index = ntohl (sw_if_index);
5323 mp->enable = enable;
5328 /* Wait for a reply... */
5333 api_sw_interface_set_table (vat_main_t * vam)
5335 unformat_input_t *i = vam->input;
5336 vl_api_sw_interface_set_table_t *mp;
5338 u32 sw_if_index, vrf_id = 0;
5339 u8 sw_if_index_set = 0;
5342 /* Parse args required to build the message */
5343 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5345 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5346 sw_if_index_set = 1;
5347 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5348 sw_if_index_set = 1;
5349 else if (unformat (i, "vrf %d", &vrf_id))
5351 else if (unformat (i, "ipv6"))
5357 if (sw_if_index_set == 0)
5359 errmsg ("missing interface name or sw_if_index");
5363 /* Construct the API message */
5364 M (SW_INTERFACE_SET_TABLE, sw_interface_set_table);
5366 mp->sw_if_index = ntohl (sw_if_index);
5367 mp->is_ipv6 = is_ipv6;
5368 mp->vrf_id = ntohl (vrf_id);
5373 /* Wait for a reply... */
5377 static void vl_api_sw_interface_get_table_reply_t_handler
5378 (vl_api_sw_interface_get_table_reply_t * mp)
5380 vat_main_t *vam = &vat_main;
5382 print (vam->ofp, "%d", ntohl (mp->vrf_id));
5384 vam->retval = ntohl (mp->retval);
5385 vam->result_ready = 1;
5389 static void vl_api_sw_interface_get_table_reply_t_handler_json
5390 (vl_api_sw_interface_get_table_reply_t * mp)
5392 vat_main_t *vam = &vat_main;
5393 vat_json_node_t node;
5395 vat_json_init_object (&node);
5396 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
5397 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
5399 vat_json_print (vam->ofp, &node);
5400 vat_json_free (&node);
5402 vam->retval = ntohl (mp->retval);
5403 vam->result_ready = 1;
5407 api_sw_interface_get_table (vat_main_t * vam)
5409 unformat_input_t *i = vam->input;
5410 vl_api_sw_interface_get_table_t *mp;
5412 u8 sw_if_index_set = 0;
5416 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5418 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5419 sw_if_index_set = 1;
5420 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5421 sw_if_index_set = 1;
5422 else if (unformat (i, "ipv6"))
5428 if (sw_if_index_set == 0)
5430 errmsg ("missing interface name or sw_if_index");
5434 M (SW_INTERFACE_GET_TABLE, sw_interface_get_table);
5435 mp->sw_if_index = htonl (sw_if_index);
5436 mp->is_ipv6 = is_ipv6;
5443 api_sw_interface_set_vpath (vat_main_t * vam)
5445 unformat_input_t *i = vam->input;
5446 vl_api_sw_interface_set_vpath_t *mp;
5448 u32 sw_if_index = 0;
5449 u8 sw_if_index_set = 0;
5452 /* Parse args required to build the message */
5453 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5455 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5456 sw_if_index_set = 1;
5457 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5458 sw_if_index_set = 1;
5459 else if (unformat (i, "enable"))
5461 else if (unformat (i, "disable"))
5467 if (sw_if_index_set == 0)
5469 errmsg ("missing interface name or sw_if_index");
5473 /* Construct the API message */
5474 M (SW_INTERFACE_SET_VPATH, sw_interface_set_vpath);
5476 mp->sw_if_index = ntohl (sw_if_index);
5477 mp->enable = is_enable;
5482 /* Wait for a reply... */
5487 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
5489 unformat_input_t *i = vam->input;
5490 vl_api_sw_interface_set_vxlan_bypass_t *mp;
5492 u32 sw_if_index = 0;
5493 u8 sw_if_index_set = 0;
5497 /* Parse args required to build the message */
5498 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5500 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5501 sw_if_index_set = 1;
5502 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5503 sw_if_index_set = 1;
5504 else if (unformat (i, "enable"))
5506 else if (unformat (i, "disable"))
5508 else if (unformat (i, "ip4"))
5510 else if (unformat (i, "ip6"))
5516 if (sw_if_index_set == 0)
5518 errmsg ("missing interface name or sw_if_index");
5522 /* Construct the API message */
5523 M (SW_INTERFACE_SET_VXLAN_BYPASS, sw_interface_set_vxlan_bypass);
5525 mp->sw_if_index = ntohl (sw_if_index);
5526 mp->enable = is_enable;
5527 mp->is_ipv6 = is_ipv6;
5532 /* Wait for a reply... */
5537 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
5539 unformat_input_t *i = vam->input;
5540 vl_api_sw_interface_set_l2_xconnect_t *mp;
5543 u8 rx_sw_if_index_set = 0;
5545 u8 tx_sw_if_index_set = 0;
5548 /* Parse args required to build the message */
5549 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5551 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
5552 rx_sw_if_index_set = 1;
5553 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5554 tx_sw_if_index_set = 1;
5555 else if (unformat (i, "rx"))
5557 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5559 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
5561 rx_sw_if_index_set = 1;
5566 else if (unformat (i, "tx"))
5568 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5570 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
5572 tx_sw_if_index_set = 1;
5577 else if (unformat (i, "enable"))
5579 else if (unformat (i, "disable"))
5585 if (rx_sw_if_index_set == 0)
5587 errmsg ("missing rx interface name or rx_sw_if_index");
5591 if (enable && (tx_sw_if_index_set == 0))
5593 errmsg ("missing tx interface name or tx_sw_if_index");
5597 M (SW_INTERFACE_SET_L2_XCONNECT, sw_interface_set_l2_xconnect);
5599 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5600 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
5601 mp->enable = enable;
5610 api_sw_interface_set_l2_bridge (vat_main_t * vam)
5612 unformat_input_t *i = vam->input;
5613 vl_api_sw_interface_set_l2_bridge_t *mp;
5616 u8 rx_sw_if_index_set = 0;
5623 /* Parse args required to build the message */
5624 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5626 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
5627 rx_sw_if_index_set = 1;
5628 else if (unformat (i, "bd_id %d", &bd_id))
5632 (i, "%U", api_unformat_sw_if_index, vam, &rx_sw_if_index))
5633 rx_sw_if_index_set = 1;
5634 else if (unformat (i, "shg %d", &shg))
5636 else if (unformat (i, "bvi"))
5638 else if (unformat (i, "enable"))
5640 else if (unformat (i, "disable"))
5646 if (rx_sw_if_index_set == 0)
5648 errmsg ("missing rx interface name or sw_if_index");
5652 if (enable && (bd_id_set == 0))
5654 errmsg ("missing bridge domain");
5658 M (SW_INTERFACE_SET_L2_BRIDGE, sw_interface_set_l2_bridge);
5660 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5661 mp->bd_id = ntohl (bd_id);
5664 mp->enable = enable;
5673 api_bridge_domain_dump (vat_main_t * vam)
5675 unformat_input_t *i = vam->input;
5676 vl_api_bridge_domain_dump_t *mp;
5680 /* Parse args required to build the message */
5681 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5683 if (unformat (i, "bd_id %d", &bd_id))
5689 M (BRIDGE_DOMAIN_DUMP, bridge_domain_dump);
5690 mp->bd_id = ntohl (bd_id);
5693 /* Use a control ping for synchronization */
5695 vl_api_control_ping_t *mp;
5696 M (CONTROL_PING, control_ping);
5706 api_bridge_domain_add_del (vat_main_t * vam)
5708 unformat_input_t *i = vam->input;
5709 vl_api_bridge_domain_add_del_t *mp;
5713 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
5716 /* Parse args required to build the message */
5717 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5719 if (unformat (i, "bd_id %d", &bd_id))
5721 else if (unformat (i, "flood %d", &flood))
5723 else if (unformat (i, "uu-flood %d", &uu_flood))
5725 else if (unformat (i, "forward %d", &forward))
5727 else if (unformat (i, "learn %d", &learn))
5729 else if (unformat (i, "arp-term %d", &arp_term))
5731 else if (unformat (i, "mac-age %d", &mac_age))
5733 else if (unformat (i, "del"))
5736 flood = uu_flood = forward = learn = 0;
5744 errmsg ("missing bridge domain");
5750 errmsg ("mac age must be less than 256 ");
5754 M (BRIDGE_DOMAIN_ADD_DEL, bridge_domain_add_del);
5756 mp->bd_id = ntohl (bd_id);
5758 mp->uu_flood = uu_flood;
5759 mp->forward = forward;
5761 mp->arp_term = arp_term;
5762 mp->is_add = is_add;
5763 mp->mac_age = (u8) mac_age;
5772 api_l2fib_add_del (vat_main_t * vam)
5774 unformat_input_t *i = vam->input;
5775 vl_api_l2fib_add_del_t *mp;
5781 u32 sw_if_index = ~0;
5782 u8 sw_if_index_set = 0;
5791 /* Parse args required to build the message */
5792 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5794 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
5796 else if (unformat (i, "bd_id %d", &bd_id))
5798 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5799 sw_if_index_set = 1;
5800 else if (unformat (i, "sw_if"))
5802 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5805 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5806 sw_if_index_set = 1;
5811 else if (unformat (i, "static"))
5813 else if (unformat (i, "filter"))
5818 else if (unformat (i, "bvi"))
5823 else if (unformat (i, "del"))
5825 else if (unformat (i, "count %d", &count))
5833 errmsg ("missing mac address");
5839 errmsg ("missing bridge domain");
5843 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
5845 errmsg ("missing interface name or sw_if_index");
5851 /* Turn on async mode */
5852 vam->async_mode = 1;
5853 vam->async_errors = 0;
5854 before = vat_time_now (vam);
5857 for (j = 0; j < count; j++)
5859 M (L2FIB_ADD_DEL, l2fib_add_del);
5862 mp->bd_id = ntohl (bd_id);
5863 mp->is_add = is_add;
5867 mp->sw_if_index = ntohl (sw_if_index);
5868 mp->static_mac = static_mac;
5869 mp->filter_mac = filter_mac;
5870 mp->bvi_mac = bvi_mac;
5872 increment_mac_address (&mac);
5879 vl_api_control_ping_t *mp;
5882 /* Shut off async mode */
5883 vam->async_mode = 0;
5885 M (CONTROL_PING, control_ping);
5888 timeout = vat_time_now (vam) + 1.0;
5889 while (vat_time_now (vam) < timeout)
5890 if (vam->result_ready == 1)
5895 if (vam->retval == -99)
5898 if (vam->async_errors > 0)
5900 errmsg ("%d asynchronous errors", vam->async_errors);
5903 vam->async_errors = 0;
5904 after = vat_time_now (vam);
5906 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
5907 count, after - before, count / (after - before));
5911 /* Wait for a reply... */
5914 /* Return the good/bad news */
5915 return (vam->retval);
5919 api_l2_flags (vat_main_t * vam)
5921 unformat_input_t *i = vam->input;
5922 vl_api_l2_flags_t *mp;
5925 u32 feature_bitmap = 0;
5926 u8 sw_if_index_set = 0;
5928 /* Parse args required to build the message */
5929 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5931 if (unformat (i, "sw_if_index %d", &sw_if_index))
5932 sw_if_index_set = 1;
5933 else if (unformat (i, "sw_if"))
5935 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5938 (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
5939 sw_if_index_set = 1;
5944 else if (unformat (i, "learn"))
5945 feature_bitmap |= L2INPUT_FEAT_LEARN;
5946 else if (unformat (i, "forward"))
5947 feature_bitmap |= L2INPUT_FEAT_FWD;
5948 else if (unformat (i, "flood"))
5949 feature_bitmap |= L2INPUT_FEAT_FLOOD;
5950 else if (unformat (i, "uu-flood"))
5951 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
5956 if (sw_if_index_set == 0)
5958 errmsg ("missing interface name or sw_if_index");
5962 M (L2_FLAGS, l2_flags);
5964 mp->sw_if_index = ntohl (sw_if_index);
5965 mp->feature_bitmap = ntohl (feature_bitmap);
5974 api_bridge_flags (vat_main_t * vam)
5976 unformat_input_t *i = vam->input;
5977 vl_api_bridge_flags_t *mp;
5984 /* Parse args required to build the message */
5985 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5987 if (unformat (i, "bd_id %d", &bd_id))
5989 else if (unformat (i, "learn"))
5991 else if (unformat (i, "forward"))
5993 else if (unformat (i, "flood"))
5995 else if (unformat (i, "uu-flood"))
5996 flags |= L2_UU_FLOOD;
5997 else if (unformat (i, "arp-term"))
5998 flags |= L2_ARP_TERM;
5999 else if (unformat (i, "off"))
6001 else if (unformat (i, "disable"))
6009 errmsg ("missing bridge domain");
6013 M (BRIDGE_FLAGS, bridge_flags);
6015 mp->bd_id = ntohl (bd_id);
6016 mp->feature_bitmap = ntohl (flags);
6017 mp->is_set = is_set;
6026 api_bd_ip_mac_add_del (vat_main_t * vam)
6028 unformat_input_t *i = vam->input;
6029 vl_api_bd_ip_mac_add_del_t *mp;
6037 ip4_address_t v4addr;
6038 ip6_address_t v6addr;
6042 /* Parse args required to build the message */
6043 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6045 if (unformat (i, "bd_id %d", &bd_id))
6049 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
6053 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
6058 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
6062 else if (unformat (i, "del"))
6070 errmsg ("missing bridge domain");
6073 else if (ip_set == 0)
6075 errmsg ("missing IP address");
6078 else if (mac_set == 0)
6080 errmsg ("missing MAC address");
6084 M (BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del);
6086 mp->bd_id = ntohl (bd_id);
6087 mp->is_ipv6 = is_ipv6;
6088 mp->is_add = is_add;
6090 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
6092 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
6093 clib_memcpy (mp->mac_address, macaddr, 6);
6101 api_tap_connect (vat_main_t * vam)
6103 unformat_input_t *i = vam->input;
6104 vl_api_tap_connect_t *mp;
6111 ip4_address_t ip4_address;
6113 int ip4_address_set = 0;
6114 ip6_address_t ip6_address;
6116 int ip6_address_set = 0;
6118 memset (mac_address, 0, sizeof (mac_address));
6120 /* Parse args required to build the message */
6121 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6123 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6127 else if (unformat (i, "random-mac"))
6129 else if (unformat (i, "tapname %s", &tap_name))
6131 else if (unformat (i, "tag %s", &tag))
6133 else if (unformat (i, "address %U/%d",
6134 unformat_ip4_address, &ip4_address, &ip4_mask_width))
6135 ip4_address_set = 1;
6136 else if (unformat (i, "address %U/%d",
6137 unformat_ip6_address, &ip6_address, &ip6_mask_width))
6138 ip6_address_set = 1;
6145 errmsg ("missing tap name");
6148 if (vec_len (tap_name) > 63)
6150 errmsg ("tap name too long");
6153 vec_add1 (tap_name, 0);
6155 if (vec_len (tag) > 63)
6157 errmsg ("tag too long");
6161 /* Construct the API message */
6162 M (TAP_CONNECT, tap_connect);
6164 mp->use_random_mac = random_mac;
6165 clib_memcpy (mp->mac_address, mac_address, 6);
6166 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
6168 clib_memcpy (mp->tag, tag, vec_len (tag));
6170 if (ip4_address_set)
6172 mp->ip4_address_set = 1;
6173 clib_memcpy (mp->ip4_address, &ip4_address, sizeof (mp->ip4_address));
6174 mp->ip4_mask_width = ip4_mask_width;
6176 if (ip6_address_set)
6178 mp->ip6_address_set = 1;
6179 clib_memcpy (mp->ip6_address, &ip6_address, sizeof (mp->ip6_address));
6180 mp->ip6_mask_width = ip6_mask_width;
6183 vec_free (tap_name);
6189 /* Wait for a reply... */
6194 api_tap_modify (vat_main_t * vam)
6196 unformat_input_t *i = vam->input;
6197 vl_api_tap_modify_t *mp;
6203 u32 sw_if_index = ~0;
6204 u8 sw_if_index_set = 0;
6206 memset (mac_address, 0, sizeof (mac_address));
6208 /* Parse args required to build the message */
6209 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6211 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6212 sw_if_index_set = 1;
6213 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6214 sw_if_index_set = 1;
6215 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6219 else if (unformat (i, "random-mac"))
6221 else if (unformat (i, "tapname %s", &tap_name))
6227 if (sw_if_index_set == 0)
6229 errmsg ("missing vpp interface name");
6234 errmsg ("missing tap name");
6237 if (vec_len (tap_name) > 63)
6239 errmsg ("tap name too long");
6241 vec_add1 (tap_name, 0);
6243 /* Construct the API message */
6244 M (TAP_MODIFY, tap_modify);
6246 mp->use_random_mac = random_mac;
6247 mp->sw_if_index = ntohl (sw_if_index);
6248 clib_memcpy (mp->mac_address, mac_address, 6);
6249 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
6250 vec_free (tap_name);
6255 /* Wait for a reply... */
6260 api_tap_delete (vat_main_t * vam)
6262 unformat_input_t *i = vam->input;
6263 vl_api_tap_delete_t *mp;
6265 u32 sw_if_index = ~0;
6266 u8 sw_if_index_set = 0;
6268 /* Parse args required to build the message */
6269 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6271 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6272 sw_if_index_set = 1;
6273 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6274 sw_if_index_set = 1;
6279 if (sw_if_index_set == 0)
6281 errmsg ("missing vpp interface name");
6285 /* Construct the API message */
6286 M (TAP_DELETE, tap_delete);
6288 mp->sw_if_index = ntohl (sw_if_index);
6293 /* Wait for a reply... */
6298 api_ip_add_del_route (vat_main_t * vam)
6300 unformat_input_t *i = vam->input;
6301 vl_api_ip_add_del_route_t *mp;
6303 u32 sw_if_index = ~0, vrf_id = 0;
6305 u8 is_local = 0, is_drop = 0;
6306 u8 is_unreach = 0, is_prohibit = 0;
6307 u8 create_vrf_if_needed = 0;
6309 u32 next_hop_weight = 1;
6311 u8 is_multipath = 0;
6313 u8 address_length_set = 0;
6314 u32 next_hop_table_id = 0;
6315 u32 resolve_attempts = 0;
6316 u32 dst_address_length = 0;
6317 u8 next_hop_set = 0;
6318 ip4_address_t v4_dst_address, v4_next_hop_address;
6319 ip6_address_t v6_dst_address, v6_next_hop_address;
6323 u32 random_add_del = 0;
6324 u32 *random_vector = 0;
6326 u32 random_seed = 0xdeaddabe;
6327 u32 classify_table_index = ~0;
6329 u8 resolve_host = 0, resolve_attached = 0;
6330 mpls_label_t *next_hop_out_label_stack = NULL;
6331 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6332 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
6334 /* Parse args required to build the message */
6335 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6337 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6339 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6341 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
6346 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
6351 else if (unformat (i, "/%d", &dst_address_length))
6353 address_length_set = 1;
6356 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
6357 &v4_next_hop_address))
6361 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
6362 &v6_next_hop_address))
6366 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
6368 else if (unformat (i, "weight %d", &next_hop_weight))
6370 else if (unformat (i, "drop"))
6374 else if (unformat (i, "null-send-unreach"))
6378 else if (unformat (i, "null-send-prohibit"))
6382 else if (unformat (i, "local"))
6386 else if (unformat (i, "classify %d", &classify_table_index))
6390 else if (unformat (i, "del"))
6392 else if (unformat (i, "add"))
6394 else if (unformat (i, "not-last"))
6396 else if (unformat (i, "resolve-via-host"))
6398 else if (unformat (i, "resolve-via-attached"))
6399 resolve_attached = 1;
6400 else if (unformat (i, "multipath"))
6402 else if (unformat (i, "vrf %d", &vrf_id))
6404 else if (unformat (i, "create-vrf"))
6405 create_vrf_if_needed = 1;
6406 else if (unformat (i, "count %d", &count))
6408 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
6410 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6412 else if (unformat (i, "out-label %d", &next_hop_out_label))
6413 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
6414 else if (unformat (i, "via-label %d", &next_hop_via_label))
6416 else if (unformat (i, "random"))
6418 else if (unformat (i, "seed %d", &random_seed))
6422 clib_warning ("parse error '%U'", format_unformat_error, i);
6427 if (!next_hop_set && !is_drop && !is_local &&
6428 !is_classify && !is_unreach && !is_prohibit &&
6429 MPLS_LABEL_INVALID == next_hop_via_label)
6432 ("next hop / local / drop / unreach / prohibit / classify not set");
6436 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
6438 errmsg ("next hop and next-hop via label set");
6441 if (address_set == 0)
6443 errmsg ("missing addresses");
6447 if (address_length_set == 0)
6449 errmsg ("missing address length");
6453 /* Generate a pile of unique, random routes */
6456 u32 this_random_address;
6457 random_hash = hash_create (count, sizeof (uword));
6459 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
6460 for (j = 0; j <= count; j++)
6464 this_random_address = random_u32 (&random_seed);
6465 this_random_address =
6466 clib_host_to_net_u32 (this_random_address);
6468 while (hash_get (random_hash, this_random_address));
6469 vec_add1 (random_vector, this_random_address);
6470 hash_set (random_hash, this_random_address, 1);
6472 hash_free (random_hash);
6473 v4_dst_address.as_u32 = random_vector[0];
6478 /* Turn on async mode */
6479 vam->async_mode = 1;
6480 vam->async_errors = 0;
6481 before = vat_time_now (vam);
6484 for (j = 0; j < count; j++)
6486 /* Construct the API message */
6487 M2 (IP_ADD_DEL_ROUTE, ip_add_del_route,
6488 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
6490 mp->next_hop_sw_if_index = ntohl (sw_if_index);
6491 mp->table_id = ntohl (vrf_id);
6492 mp->create_vrf_if_needed = create_vrf_if_needed;
6494 mp->is_add = is_add;
6495 mp->is_drop = is_drop;
6496 mp->is_unreach = is_unreach;
6497 mp->is_prohibit = is_prohibit;
6498 mp->is_ipv6 = is_ipv6;
6499 mp->is_local = is_local;
6500 mp->is_classify = is_classify;
6501 mp->is_multipath = is_multipath;
6502 mp->is_resolve_host = resolve_host;
6503 mp->is_resolve_attached = resolve_attached;
6504 mp->not_last = not_last;
6505 mp->next_hop_weight = next_hop_weight;
6506 mp->dst_address_length = dst_address_length;
6507 mp->next_hop_table_id = ntohl (next_hop_table_id);
6508 mp->classify_table_index = ntohl (classify_table_index);
6509 mp->next_hop_via_label = ntohl (next_hop_via_label);
6510 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
6511 if (0 != mp->next_hop_n_out_labels)
6513 memcpy (mp->next_hop_out_label_stack,
6514 next_hop_out_label_stack,
6515 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
6516 vec_free (next_hop_out_label_stack);
6521 clib_memcpy (mp->dst_address, &v6_dst_address,
6522 sizeof (v6_dst_address));
6524 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
6525 sizeof (v6_next_hop_address));
6526 increment_v6_address (&v6_dst_address);
6530 clib_memcpy (mp->dst_address, &v4_dst_address,
6531 sizeof (v4_dst_address));
6533 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
6534 sizeof (v4_next_hop_address));
6536 v4_dst_address.as_u32 = random_vector[j + 1];
6538 increment_v4_address (&v4_dst_address);
6542 /* If we receive SIGTERM, stop now... */
6547 /* When testing multiple add/del ops, use a control-ping to sync */
6550 vl_api_control_ping_t *mp;
6553 /* Shut off async mode */
6554 vam->async_mode = 0;
6556 M (CONTROL_PING, control_ping);
6559 timeout = vat_time_now (vam) + 1.0;
6560 while (vat_time_now (vam) < timeout)
6561 if (vam->result_ready == 1)
6566 if (vam->retval == -99)
6569 if (vam->async_errors > 0)
6571 errmsg ("%d asynchronous errors", vam->async_errors);
6574 vam->async_errors = 0;
6575 after = vat_time_now (vam);
6577 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6581 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6582 count, after - before, count / (after - before));
6586 /* Wait for a reply... */
6590 /* Return the good/bad news */
6591 return (vam->retval);
6595 api_ip_mroute_add_del (vat_main_t * vam)
6597 unformat_input_t *i = vam->input;
6598 vl_api_ip_mroute_add_del_t *mp;
6600 u32 sw_if_index = ~0, vrf_id = 0;
6603 u8 create_vrf_if_needed = 0;
6606 u32 grp_address_length = 0;
6607 ip4_address_t v4_grp_address, v4_src_address;
6608 ip6_address_t v6_grp_address, v6_src_address;
6609 mfib_itf_flags_t iflags = 0;
6610 mfib_entry_flags_t eflags = 0;
6612 /* Parse args required to build the message */
6613 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6615 if (unformat (i, "sw_if_index %d", &sw_if_index))
6617 else if (unformat (i, "%U %U",
6618 unformat_ip4_address, &v4_src_address,
6619 unformat_ip4_address, &v4_grp_address))
6621 grp_address_length = 64;
6625 else if (unformat (i, "%U %U",
6626 unformat_ip6_address, &v6_src_address,
6627 unformat_ip6_address, &v6_grp_address))
6629 grp_address_length = 256;
6633 else if (unformat (i, "%U", unformat_ip4_address, &v4_grp_address))
6635 memset (&v4_src_address, 0, sizeof (v4_src_address));
6636 grp_address_length = 32;
6640 else if (unformat (i, "%U", unformat_ip6_address, &v6_grp_address))
6642 memset (&v6_src_address, 0, sizeof (v6_src_address));
6643 grp_address_length = 128;
6647 else if (unformat (i, "/%d", &grp_address_length))
6649 else if (unformat (i, "local"))
6653 else if (unformat (i, "del"))
6655 else if (unformat (i, "add"))
6657 else if (unformat (i, "vrf %d", &vrf_id))
6659 else if (unformat (i, "create-vrf"))
6660 create_vrf_if_needed = 1;
6661 else if (unformat (i, "%U", unformat_mfib_itf_flags, &iflags))
6663 else if (unformat (i, "%U", unformat_mfib_entry_flags, &eflags))
6667 clib_warning ("parse error '%U'", format_unformat_error, i);
6672 if (address_set == 0)
6674 errmsg ("missing addresses\n");
6678 /* Construct the API message */
6679 M (IP_MROUTE_ADD_DEL, ip_mroute_add_del);
6681 mp->next_hop_sw_if_index = ntohl (sw_if_index);
6682 mp->table_id = ntohl (vrf_id);
6683 mp->create_vrf_if_needed = create_vrf_if_needed;
6685 mp->is_add = is_add;
6686 mp->is_ipv6 = is_ipv6;
6687 mp->is_local = is_local;
6688 mp->itf_flags = ntohl (iflags);
6689 mp->entry_flags = ntohl (eflags);
6690 mp->grp_address_length = grp_address_length;
6691 mp->grp_address_length = ntohs (mp->grp_address_length);
6695 clib_memcpy (mp->grp_address, &v6_grp_address, sizeof (v6_grp_address));
6696 clib_memcpy (mp->src_address, &v6_src_address, sizeof (v6_src_address));
6700 clib_memcpy (mp->grp_address, &v4_grp_address, sizeof (v4_grp_address));
6701 clib_memcpy (mp->src_address, &v4_src_address, sizeof (v4_src_address));
6707 /* Wait for a reply... */
6710 /* Return the good/bad news */
6711 return (vam->retval);
6715 api_mpls_route_add_del (vat_main_t * vam)
6717 unformat_input_t *i = vam->input;
6718 vl_api_mpls_route_add_del_t *mp;
6720 u32 sw_if_index = ~0, table_id = 0;
6721 u8 create_table_if_needed = 0;
6723 u32 next_hop_weight = 1;
6724 u8 is_multipath = 0;
6725 u32 next_hop_table_id = 0;
6726 u8 next_hop_set = 0;
6727 ip4_address_t v4_next_hop_address = {
6730 ip6_address_t v6_next_hop_address = { {0} };
6734 u32 classify_table_index = ~0;
6736 u8 resolve_host = 0, resolve_attached = 0;
6737 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
6738 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6739 mpls_label_t *next_hop_out_label_stack = NULL;
6740 mpls_label_t local_label = MPLS_LABEL_INVALID;
6742 u8 next_hop_proto_is_ip4 = 1;
6744 /* Parse args required to build the message */
6745 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6747 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6749 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6751 else if (unformat (i, "%d", &local_label))
6753 else if (unformat (i, "eos"))
6755 else if (unformat (i, "non-eos"))
6757 else if (unformat (i, "via %U", unformat_ip4_address,
6758 &v4_next_hop_address))
6761 next_hop_proto_is_ip4 = 1;
6763 else if (unformat (i, "via %U", unformat_ip6_address,
6764 &v6_next_hop_address))
6767 next_hop_proto_is_ip4 = 0;
6769 else if (unformat (i, "weight %d", &next_hop_weight))
6771 else if (unformat (i, "create-table"))
6772 create_table_if_needed = 1;
6773 else if (unformat (i, "classify %d", &classify_table_index))
6777 else if (unformat (i, "del"))
6779 else if (unformat (i, "add"))
6781 else if (unformat (i, "resolve-via-host"))
6783 else if (unformat (i, "resolve-via-attached"))
6784 resolve_attached = 1;
6785 else if (unformat (i, "multipath"))
6787 else if (unformat (i, "count %d", &count))
6789 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
6792 next_hop_proto_is_ip4 = 1;
6794 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
6797 next_hop_proto_is_ip4 = 0;
6799 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6801 else if (unformat (i, "via-label %d", &next_hop_via_label))
6803 else if (unformat (i, "out-label %d", &next_hop_out_label))
6804 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
6807 clib_warning ("parse error '%U'", format_unformat_error, i);
6812 if (!next_hop_set && !is_classify)
6814 errmsg ("next hop / classify not set");
6818 if (MPLS_LABEL_INVALID == local_label)
6820 errmsg ("missing label");
6826 /* Turn on async mode */
6827 vam->async_mode = 1;
6828 vam->async_errors = 0;
6829 before = vat_time_now (vam);
6832 for (j = 0; j < count; j++)
6834 /* Construct the API message */
6835 M2 (MPLS_ROUTE_ADD_DEL, mpls_route_add_del,
6836 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
6838 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
6839 mp->mr_table_id = ntohl (table_id);
6840 mp->mr_create_table_if_needed = create_table_if_needed;
6842 mp->mr_is_add = is_add;
6843 mp->mr_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
6844 mp->mr_is_classify = is_classify;
6845 mp->mr_is_multipath = is_multipath;
6846 mp->mr_is_resolve_host = resolve_host;
6847 mp->mr_is_resolve_attached = resolve_attached;
6848 mp->mr_next_hop_weight = next_hop_weight;
6849 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
6850 mp->mr_classify_table_index = ntohl (classify_table_index);
6851 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
6852 mp->mr_label = ntohl (local_label);
6853 mp->mr_eos = is_eos;
6855 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
6856 if (0 != mp->mr_next_hop_n_out_labels)
6858 memcpy (mp->mr_next_hop_out_label_stack,
6859 next_hop_out_label_stack,
6860 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
6861 vec_free (next_hop_out_label_stack);
6866 if (next_hop_proto_is_ip4)
6868 clib_memcpy (mp->mr_next_hop,
6869 &v4_next_hop_address,
6870 sizeof (v4_next_hop_address));
6874 clib_memcpy (mp->mr_next_hop,
6875 &v6_next_hop_address,
6876 sizeof (v6_next_hop_address));
6883 /* If we receive SIGTERM, stop now... */
6888 /* When testing multiple add/del ops, use a control-ping to sync */
6891 vl_api_control_ping_t *mp;
6894 /* Shut off async mode */
6895 vam->async_mode = 0;
6897 M (CONTROL_PING, control_ping);
6900 timeout = vat_time_now (vam) + 1.0;
6901 while (vat_time_now (vam) < timeout)
6902 if (vam->result_ready == 1)
6907 if (vam->retval == -99)
6910 if (vam->async_errors > 0)
6912 errmsg ("%d asynchronous errors", vam->async_errors);
6915 vam->async_errors = 0;
6916 after = vat_time_now (vam);
6918 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6922 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6923 count, after - before, count / (after - before));
6927 /* Wait for a reply... */
6931 /* Return the good/bad news */
6932 return (vam->retval);
6936 api_mpls_ip_bind_unbind (vat_main_t * vam)
6938 unformat_input_t *i = vam->input;
6939 vl_api_mpls_ip_bind_unbind_t *mp;
6941 u32 ip_table_id = 0;
6942 u8 create_table_if_needed = 0;
6945 ip4_address_t v4_address;
6946 ip6_address_t v6_address;
6949 mpls_label_t local_label = MPLS_LABEL_INVALID;
6951 /* Parse args required to build the message */
6952 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6954 if (unformat (i, "%U/%d", unformat_ip4_address,
6955 &v4_address, &address_length))
6960 else if (unformat (i, "%U/%d", unformat_ip6_address,
6961 &v6_address, &address_length))
6966 else if (unformat (i, "%d", &local_label))
6968 else if (unformat (i, "create-table"))
6969 create_table_if_needed = 1;
6970 else if (unformat (i, "table-id %d", &ip_table_id))
6972 else if (unformat (i, "unbind"))
6974 else if (unformat (i, "bind"))
6978 clib_warning ("parse error '%U'", format_unformat_error, i);
6985 errmsg ("IP addres not set");
6989 if (MPLS_LABEL_INVALID == local_label)
6991 errmsg ("missing label");
6995 /* Construct the API message */
6996 M (MPLS_IP_BIND_UNBIND, mpls_ip_bind_unbind);
6998 mp->mb_create_table_if_needed = create_table_if_needed;
6999 mp->mb_is_bind = is_bind;
7000 mp->mb_is_ip4 = is_ip4;
7001 mp->mb_ip_table_id = ntohl (ip_table_id);
7002 mp->mb_mpls_table_id = 0;
7003 mp->mb_label = ntohl (local_label);
7004 mp->mb_address_length = address_length;
7007 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
7009 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
7014 /* Wait for a reply... */
7019 api_proxy_arp_add_del (vat_main_t * vam)
7021 unformat_input_t *i = vam->input;
7022 vl_api_proxy_arp_add_del_t *mp;
7026 ip4_address_t lo, hi;
7029 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7031 if (unformat (i, "vrf %d", &vrf_id))
7033 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
7034 unformat_ip4_address, &hi))
7036 else if (unformat (i, "del"))
7040 clib_warning ("parse error '%U'", format_unformat_error, i);
7047 errmsg ("address range not set");
7051 M (PROXY_ARP_ADD_DEL, proxy_arp_add_del);
7053 mp->vrf_id = ntohl (vrf_id);
7054 mp->is_add = is_add;
7055 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
7056 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
7065 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
7067 unformat_input_t *i = vam->input;
7068 vl_api_proxy_arp_intfc_enable_disable_t *mp;
7072 u8 sw_if_index_set = 0;
7074 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7076 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7077 sw_if_index_set = 1;
7078 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7079 sw_if_index_set = 1;
7080 else if (unformat (i, "enable"))
7082 else if (unformat (i, "disable"))
7086 clib_warning ("parse error '%U'", format_unformat_error, i);
7091 if (sw_if_index_set == 0)
7093 errmsg ("missing interface name or sw_if_index");
7097 M (PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable);
7099 mp->sw_if_index = ntohl (sw_if_index);
7100 mp->enable_disable = enable;
7109 api_mpls_tunnel_add_del (vat_main_t * vam)
7111 unformat_input_t *i = vam->input;
7112 vl_api_mpls_tunnel_add_del_t *mp;
7117 u32 sw_if_index = ~0;
7118 u32 next_hop_sw_if_index = ~0;
7119 u32 next_hop_proto_is_ip4 = 1;
7121 u32 next_hop_table_id = 0;
7122 ip4_address_t v4_next_hop_address = {
7125 ip6_address_t v6_next_hop_address = { {0} };
7126 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID, *labels = NULL;
7128 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7130 if (unformat (i, "add"))
7132 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
7134 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
7136 else if (unformat (i, "via %U",
7137 unformat_ip4_address, &v4_next_hop_address))
7139 next_hop_proto_is_ip4 = 1;
7141 else if (unformat (i, "via %U",
7142 unformat_ip6_address, &v6_next_hop_address))
7144 next_hop_proto_is_ip4 = 0;
7146 else if (unformat (i, "l2-only"))
7148 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
7150 else if (unformat (i, "out-label %d", &next_hop_out_label))
7151 vec_add1 (labels, ntohl (next_hop_out_label));
7154 clib_warning ("parse error '%U'", format_unformat_error, i);
7159 M2 (MPLS_TUNNEL_ADD_DEL, mpls_tunnel_add_del,
7160 sizeof (mpls_label_t) * vec_len (labels));
7162 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
7163 mp->mt_sw_if_index = ntohl (sw_if_index);
7164 mp->mt_is_add = is_add;
7165 mp->mt_l2_only = l2_only;
7166 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
7167 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
7169 mp->mt_next_hop_n_out_labels = vec_len (labels);
7171 if (0 != mp->mt_next_hop_n_out_labels)
7173 clib_memcpy (mp->mt_next_hop_out_label_stack, labels,
7174 sizeof (mpls_label_t) * mp->mt_next_hop_n_out_labels);
7178 if (next_hop_proto_is_ip4)
7180 clib_memcpy (mp->mt_next_hop,
7181 &v4_next_hop_address, sizeof (v4_next_hop_address));
7185 clib_memcpy (mp->mt_next_hop,
7186 &v6_next_hop_address, sizeof (v6_next_hop_address));
7196 api_sw_interface_set_unnumbered (vat_main_t * vam)
7198 unformat_input_t *i = vam->input;
7199 vl_api_sw_interface_set_unnumbered_t *mp;
7202 u32 unnum_sw_index = ~0;
7204 u8 sw_if_index_set = 0;
7206 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7208 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7209 sw_if_index_set = 1;
7210 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7211 sw_if_index_set = 1;
7212 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
7214 else if (unformat (i, "del"))
7218 clib_warning ("parse error '%U'", format_unformat_error, i);
7223 if (sw_if_index_set == 0)
7225 errmsg ("missing interface name or sw_if_index");
7229 M (SW_INTERFACE_SET_UNNUMBERED, sw_interface_set_unnumbered);
7231 mp->sw_if_index = ntohl (sw_if_index);
7232 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
7233 mp->is_add = is_add;
7242 api_ip_neighbor_add_del (vat_main_t * vam)
7244 unformat_input_t *i = vam->input;
7245 vl_api_ip_neighbor_add_del_t *mp;
7248 u8 sw_if_index_set = 0;
7254 u8 v4_address_set = 0;
7255 u8 v6_address_set = 0;
7256 ip4_address_t v4address;
7257 ip6_address_t v6address;
7259 memset (mac_address, 0, sizeof (mac_address));
7261 /* Parse args required to build the message */
7262 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7264 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
7268 else if (unformat (i, "del"))
7271 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7272 sw_if_index_set = 1;
7273 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7274 sw_if_index_set = 1;
7275 else if (unformat (i, "is_static"))
7277 else if (unformat (i, "vrf %d", &vrf_id))
7279 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
7281 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
7285 clib_warning ("parse error '%U'", format_unformat_error, i);
7290 if (sw_if_index_set == 0)
7292 errmsg ("missing interface name or sw_if_index");
7295 if (v4_address_set && v6_address_set)
7297 errmsg ("both v4 and v6 addresses set");
7300 if (!v4_address_set && !v6_address_set)
7302 errmsg ("no address set");
7306 /* Construct the API message */
7307 M (IP_NEIGHBOR_ADD_DEL, ip_neighbor_add_del);
7309 mp->sw_if_index = ntohl (sw_if_index);
7310 mp->is_add = is_add;
7311 mp->vrf_id = ntohl (vrf_id);
7312 mp->is_static = is_static;
7314 clib_memcpy (mp->mac_address, mac_address, 6);
7318 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
7322 /* mp->is_ipv6 = 0; via memset in M macro above */
7323 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
7329 /* Wait for a reply, return good/bad news */
7337 api_reset_vrf (vat_main_t * vam)
7339 unformat_input_t *i = vam->input;
7340 vl_api_reset_vrf_t *mp;
7346 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7348 if (unformat (i, "vrf %d", &vrf_id))
7350 else if (unformat (i, "ipv6"))
7354 clib_warning ("parse error '%U'", format_unformat_error, i);
7359 if (vrf_id_set == 0)
7361 errmsg ("missing vrf id");
7365 M (RESET_VRF, reset_vrf);
7367 mp->vrf_id = ntohl (vrf_id);
7368 mp->is_ipv6 = is_ipv6;
7377 api_create_vlan_subif (vat_main_t * vam)
7379 unformat_input_t *i = vam->input;
7380 vl_api_create_vlan_subif_t *mp;
7383 u8 sw_if_index_set = 0;
7387 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7389 if (unformat (i, "sw_if_index %d", &sw_if_index))
7390 sw_if_index_set = 1;
7392 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7393 sw_if_index_set = 1;
7394 else if (unformat (i, "vlan %d", &vlan_id))
7398 clib_warning ("parse error '%U'", format_unformat_error, i);
7403 if (sw_if_index_set == 0)
7405 errmsg ("missing interface name or sw_if_index");
7409 if (vlan_id_set == 0)
7411 errmsg ("missing vlan_id");
7414 M (CREATE_VLAN_SUBIF, create_vlan_subif);
7416 mp->sw_if_index = ntohl (sw_if_index);
7417 mp->vlan_id = ntohl (vlan_id);
7425 #define foreach_create_subif_bit \
7432 _(outer_vlan_id_any) \
7433 _(inner_vlan_id_any)
7436 api_create_subif (vat_main_t * vam)
7438 unformat_input_t *i = vam->input;
7439 vl_api_create_subif_t *mp;
7442 u8 sw_if_index_set = 0;
7449 u32 exact_match = 0;
7450 u32 default_sub = 0;
7451 u32 outer_vlan_id_any = 0;
7452 u32 inner_vlan_id_any = 0;
7454 u16 outer_vlan_id = 0;
7455 u16 inner_vlan_id = 0;
7457 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7459 if (unformat (i, "sw_if_index %d", &sw_if_index))
7460 sw_if_index_set = 1;
7462 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7463 sw_if_index_set = 1;
7464 else if (unformat (i, "sub_id %d", &sub_id))
7466 else if (unformat (i, "outer_vlan_id %d", &tmp))
7467 outer_vlan_id = tmp;
7468 else if (unformat (i, "inner_vlan_id %d", &tmp))
7469 inner_vlan_id = tmp;
7471 #define _(a) else if (unformat (i, #a)) a = 1 ;
7472 foreach_create_subif_bit
7476 clib_warning ("parse error '%U'", format_unformat_error, i);
7481 if (sw_if_index_set == 0)
7483 errmsg ("missing interface name or sw_if_index");
7487 if (sub_id_set == 0)
7489 errmsg ("missing sub_id");
7492 M (CREATE_SUBIF, create_subif);
7494 mp->sw_if_index = ntohl (sw_if_index);
7495 mp->sub_id = ntohl (sub_id);
7497 #define _(a) mp->a = a;
7498 foreach_create_subif_bit;
7501 mp->outer_vlan_id = ntohs (outer_vlan_id);
7502 mp->inner_vlan_id = ntohs (inner_vlan_id);
7511 api_oam_add_del (vat_main_t * vam)
7513 unformat_input_t *i = vam->input;
7514 vl_api_oam_add_del_t *mp;
7518 ip4_address_t src, dst;
7522 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7524 if (unformat (i, "vrf %d", &vrf_id))
7526 else if (unformat (i, "src %U", unformat_ip4_address, &src))
7528 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
7530 else if (unformat (i, "del"))
7534 clib_warning ("parse error '%U'", format_unformat_error, i);
7541 errmsg ("missing src addr");
7547 errmsg ("missing dst addr");
7551 M (OAM_ADD_DEL, oam_add_del);
7553 mp->vrf_id = ntohl (vrf_id);
7554 mp->is_add = is_add;
7555 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
7556 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
7565 api_reset_fib (vat_main_t * vam)
7567 unformat_input_t *i = vam->input;
7568 vl_api_reset_fib_t *mp;
7574 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7576 if (unformat (i, "vrf %d", &vrf_id))
7578 else if (unformat (i, "ipv6"))
7582 clib_warning ("parse error '%U'", format_unformat_error, i);
7587 if (vrf_id_set == 0)
7589 errmsg ("missing vrf id");
7593 M (RESET_FIB, reset_fib);
7595 mp->vrf_id = ntohl (vrf_id);
7596 mp->is_ipv6 = is_ipv6;
7605 api_dhcp_proxy_config (vat_main_t * vam)
7607 unformat_input_t *i = vam->input;
7608 vl_api_dhcp_proxy_config_t *mp;
7613 u8 v4_address_set = 0;
7614 u8 v6_address_set = 0;
7615 ip4_address_t v4address;
7616 ip6_address_t v6address;
7617 u8 v4_src_address_set = 0;
7618 u8 v6_src_address_set = 0;
7619 ip4_address_t v4srcaddress;
7620 ip6_address_t v6srcaddress;
7622 /* Parse args required to build the message */
7623 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7625 if (unformat (i, "del"))
7627 else if (unformat (i, "vrf %d", &vrf_id))
7629 else if (unformat (i, "insert-cid %d", &insert_cid))
7631 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
7633 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
7635 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
7636 v4_src_address_set = 1;
7637 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
7638 v6_src_address_set = 1;
7643 if (v4_address_set && v6_address_set)
7645 errmsg ("both v4 and v6 server addresses set");
7648 if (!v4_address_set && !v6_address_set)
7650 errmsg ("no server addresses set");
7654 if (v4_src_address_set && v6_src_address_set)
7656 errmsg ("both v4 and v6 src addresses set");
7659 if (!v4_src_address_set && !v6_src_address_set)
7661 errmsg ("no src addresses set");
7665 if (!(v4_src_address_set && v4_address_set) &&
7666 !(v6_src_address_set && v6_address_set))
7668 errmsg ("no matching server and src addresses set");
7672 /* Construct the API message */
7673 M (DHCP_PROXY_CONFIG, dhcp_proxy_config);
7675 mp->insert_circuit_id = insert_cid;
7676 mp->is_add = is_add;
7677 mp->vrf_id = ntohl (vrf_id);
7681 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
7682 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
7686 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
7687 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
7693 /* Wait for a reply, return good/bad news */
7700 api_dhcp_proxy_config_2 (vat_main_t * vam)
7702 unformat_input_t *i = vam->input;
7703 vl_api_dhcp_proxy_config_2_t *mp;
7706 u32 server_vrf_id = 0;
7709 u8 v4_address_set = 0;
7710 u8 v6_address_set = 0;
7711 ip4_address_t v4address;
7712 ip6_address_t v6address;
7713 u8 v4_src_address_set = 0;
7714 u8 v6_src_address_set = 0;
7715 ip4_address_t v4srcaddress;
7716 ip6_address_t v6srcaddress;
7718 /* Parse args required to build the message */
7719 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7721 if (unformat (i, "del"))
7723 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
7725 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
7727 else if (unformat (i, "insert-cid %d", &insert_cid))
7729 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
7731 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
7733 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
7734 v4_src_address_set = 1;
7735 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
7736 v6_src_address_set = 1;
7741 if (v4_address_set && v6_address_set)
7743 errmsg ("both v4 and v6 server addresses set");
7746 if (!v4_address_set && !v6_address_set)
7748 errmsg ("no server addresses set");
7752 if (v4_src_address_set && v6_src_address_set)
7754 errmsg ("both v4 and v6 src addresses set");
7757 if (!v4_src_address_set && !v6_src_address_set)
7759 errmsg ("no src addresses set");
7763 if (!(v4_src_address_set && v4_address_set) &&
7764 !(v6_src_address_set && v6_address_set))
7766 errmsg ("no matching server and src addresses set");
7770 /* Construct the API message */
7771 M (DHCP_PROXY_CONFIG_2, dhcp_proxy_config_2);
7773 mp->insert_circuit_id = insert_cid;
7774 mp->is_add = is_add;
7775 mp->rx_vrf_id = ntohl (rx_vrf_id);
7776 mp->server_vrf_id = ntohl (server_vrf_id);
7780 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
7781 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
7785 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
7786 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
7792 /* Wait for a reply, return good/bad news */
7799 api_dhcp_proxy_set_vss (vat_main_t * vam)
7801 unformat_input_t *i = vam->input;
7802 vl_api_dhcp_proxy_set_vss_t *mp;
7813 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7815 if (unformat (i, "tbl_id %d", &tbl_id))
7817 if (unformat (i, "fib_id %d", &fib_id))
7819 if (unformat (i, "oui %d", &oui))
7821 else if (unformat (i, "ipv6"))
7823 else if (unformat (i, "del"))
7827 clib_warning ("parse error '%U'", format_unformat_error, i);
7832 if (tbl_id_set == 0)
7834 errmsg ("missing tbl id");
7838 if (fib_id_set == 0)
7840 errmsg ("missing fib id");
7845 errmsg ("missing oui");
7849 M (DHCP_PROXY_SET_VSS, dhcp_proxy_set_vss);
7850 mp->tbl_id = ntohl (tbl_id);
7851 mp->fib_id = ntohl (fib_id);
7852 mp->oui = ntohl (oui);
7853 mp->is_ipv6 = is_ipv6;
7854 mp->is_add = is_add;
7863 api_dhcp_client_config (vat_main_t * vam)
7865 unformat_input_t *i = vam->input;
7866 vl_api_dhcp_client_config_t *mp;
7869 u8 sw_if_index_set = 0;
7872 u8 disable_event = 0;
7874 /* Parse args required to build the message */
7875 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7877 if (unformat (i, "del"))
7880 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7881 sw_if_index_set = 1;
7882 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7883 sw_if_index_set = 1;
7884 else if (unformat (i, "hostname %s", &hostname))
7886 else if (unformat (i, "disable_event"))
7892 if (sw_if_index_set == 0)
7894 errmsg ("missing interface name or sw_if_index");
7898 if (vec_len (hostname) > 63)
7900 errmsg ("hostname too long");
7902 vec_add1 (hostname, 0);
7904 /* Construct the API message */
7905 M (DHCP_CLIENT_CONFIG, dhcp_client_config);
7907 mp->sw_if_index = ntohl (sw_if_index);
7908 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
7909 vec_free (hostname);
7910 mp->is_add = is_add;
7911 mp->want_dhcp_event = disable_event ? 0 : 1;
7912 mp->pid = getpid ();
7917 /* Wait for a reply, return good/bad news */
7924 api_set_ip_flow_hash (vat_main_t * vam)
7926 unformat_input_t *i = vam->input;
7927 vl_api_set_ip_flow_hash_t *mp;
7939 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7941 if (unformat (i, "vrf %d", &vrf_id))
7943 else if (unformat (i, "ipv6"))
7945 else if (unformat (i, "src"))
7947 else if (unformat (i, "dst"))
7949 else if (unformat (i, "sport"))
7951 else if (unformat (i, "dport"))
7953 else if (unformat (i, "proto"))
7955 else if (unformat (i, "reverse"))
7960 clib_warning ("parse error '%U'", format_unformat_error, i);
7965 if (vrf_id_set == 0)
7967 errmsg ("missing vrf id");
7971 M (SET_IP_FLOW_HASH, set_ip_flow_hash);
7977 mp->reverse = reverse;
7978 mp->vrf_id = ntohl (vrf_id);
7979 mp->is_ipv6 = is_ipv6;
7988 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
7990 unformat_input_t *i = vam->input;
7991 vl_api_sw_interface_ip6_enable_disable_t *mp;
7994 u8 sw_if_index_set = 0;
7997 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7999 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8000 sw_if_index_set = 1;
8001 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8002 sw_if_index_set = 1;
8003 else if (unformat (i, "enable"))
8005 else if (unformat (i, "disable"))
8009 clib_warning ("parse error '%U'", format_unformat_error, i);
8014 if (sw_if_index_set == 0)
8016 errmsg ("missing interface name or sw_if_index");
8020 M (SW_INTERFACE_IP6_ENABLE_DISABLE, sw_interface_ip6_enable_disable);
8022 mp->sw_if_index = ntohl (sw_if_index);
8023 mp->enable = enable;
8032 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
8034 unformat_input_t *i = vam->input;
8035 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
8038 u8 sw_if_index_set = 0;
8039 u8 v6_address_set = 0;
8040 ip6_address_t v6address;
8042 /* Parse args required to build the message */
8043 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8045 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8046 sw_if_index_set = 1;
8047 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8048 sw_if_index_set = 1;
8049 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
8055 if (sw_if_index_set == 0)
8057 errmsg ("missing interface name or sw_if_index");
8060 if (!v6_address_set)
8062 errmsg ("no address set");
8066 /* Construct the API message */
8067 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS,
8068 sw_interface_ip6_set_link_local_address);
8070 mp->sw_if_index = ntohl (sw_if_index);
8071 clib_memcpy (mp->address, &v6address, sizeof (v6address));
8076 /* Wait for a reply, return good/bad news */
8085 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
8087 unformat_input_t *i = vam->input;
8088 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
8091 u8 sw_if_index_set = 0;
8092 u32 address_length = 0;
8093 u8 v6_address_set = 0;
8094 ip6_address_t v6address;
8096 u8 no_advertise = 0;
8098 u8 no_autoconfig = 0;
8101 u32 val_lifetime = 0;
8102 u32 pref_lifetime = 0;
8104 /* Parse args required to build the message */
8105 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8107 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8108 sw_if_index_set = 1;
8109 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8110 sw_if_index_set = 1;
8111 else if (unformat (i, "%U/%d",
8112 unformat_ip6_address, &v6address, &address_length))
8114 else if (unformat (i, "val_life %d", &val_lifetime))
8116 else if (unformat (i, "pref_life %d", &pref_lifetime))
8118 else if (unformat (i, "def"))
8120 else if (unformat (i, "noadv"))
8122 else if (unformat (i, "offl"))
8124 else if (unformat (i, "noauto"))
8126 else if (unformat (i, "nolink"))
8128 else if (unformat (i, "isno"))
8132 clib_warning ("parse error '%U'", format_unformat_error, i);
8137 if (sw_if_index_set == 0)
8139 errmsg ("missing interface name or sw_if_index");
8142 if (!v6_address_set)
8144 errmsg ("no address set");
8148 /* Construct the API message */
8149 M (SW_INTERFACE_IP6ND_RA_PREFIX, sw_interface_ip6nd_ra_prefix);
8151 mp->sw_if_index = ntohl (sw_if_index);
8152 clib_memcpy (mp->address, &v6address, sizeof (v6address));
8153 mp->address_length = address_length;
8154 mp->use_default = use_default;
8155 mp->no_advertise = no_advertise;
8156 mp->off_link = off_link;
8157 mp->no_autoconfig = no_autoconfig;
8158 mp->no_onlink = no_onlink;
8160 mp->val_lifetime = ntohl (val_lifetime);
8161 mp->pref_lifetime = ntohl (pref_lifetime);
8166 /* Wait for a reply, return good/bad news */
8174 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
8176 unformat_input_t *i = vam->input;
8177 vl_api_sw_interface_ip6nd_ra_config_t *mp;
8180 u8 sw_if_index_set = 0;
8185 u8 send_unicast = 0;
8188 u8 default_router = 0;
8189 u32 max_interval = 0;
8190 u32 min_interval = 0;
8192 u32 initial_count = 0;
8193 u32 initial_interval = 0;
8196 /* Parse args required to build the message */
8197 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8199 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8200 sw_if_index_set = 1;
8201 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8202 sw_if_index_set = 1;
8203 else if (unformat (i, "maxint %d", &max_interval))
8205 else if (unformat (i, "minint %d", &min_interval))
8207 else if (unformat (i, "life %d", &lifetime))
8209 else if (unformat (i, "count %d", &initial_count))
8211 else if (unformat (i, "interval %d", &initial_interval))
8213 else if (unformat (i, "suppress") || unformat (i, "surpress"))
8215 else if (unformat (i, "managed"))
8217 else if (unformat (i, "other"))
8219 else if (unformat (i, "ll"))
8221 else if (unformat (i, "send"))
8223 else if (unformat (i, "cease"))
8225 else if (unformat (i, "isno"))
8227 else if (unformat (i, "def"))
8231 clib_warning ("parse error '%U'", format_unformat_error, i);
8236 if (sw_if_index_set == 0)
8238 errmsg ("missing interface name or sw_if_index");
8242 /* Construct the API message */
8243 M (SW_INTERFACE_IP6ND_RA_CONFIG, sw_interface_ip6nd_ra_config);
8245 mp->sw_if_index = ntohl (sw_if_index);
8246 mp->max_interval = ntohl (max_interval);
8247 mp->min_interval = ntohl (min_interval);
8248 mp->lifetime = ntohl (lifetime);
8249 mp->initial_count = ntohl (initial_count);
8250 mp->initial_interval = ntohl (initial_interval);
8251 mp->suppress = suppress;
8252 mp->managed = managed;
8254 mp->ll_option = ll_option;
8255 mp->send_unicast = send_unicast;
8258 mp->default_router = default_router;
8263 /* Wait for a reply, return good/bad news */
8271 api_set_arp_neighbor_limit (vat_main_t * vam)
8273 unformat_input_t *i = vam->input;
8274 vl_api_set_arp_neighbor_limit_t *mp;
8280 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8282 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
8284 else if (unformat (i, "ipv6"))
8288 clib_warning ("parse error '%U'", format_unformat_error, i);
8295 errmsg ("missing limit value");
8299 M (SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit);
8301 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
8302 mp->is_ipv6 = is_ipv6;
8311 api_l2_patch_add_del (vat_main_t * vam)
8313 unformat_input_t *i = vam->input;
8314 vl_api_l2_patch_add_del_t *mp;
8317 u8 rx_sw_if_index_set = 0;
8319 u8 tx_sw_if_index_set = 0;
8322 /* Parse args required to build the message */
8323 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8325 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
8326 rx_sw_if_index_set = 1;
8327 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
8328 tx_sw_if_index_set = 1;
8329 else if (unformat (i, "rx"))
8331 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8333 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
8335 rx_sw_if_index_set = 1;
8340 else if (unformat (i, "tx"))
8342 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8344 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
8346 tx_sw_if_index_set = 1;
8351 else if (unformat (i, "del"))
8357 if (rx_sw_if_index_set == 0)
8359 errmsg ("missing rx interface name or rx_sw_if_index");
8363 if (tx_sw_if_index_set == 0)
8365 errmsg ("missing tx interface name or tx_sw_if_index");
8369 M (L2_PATCH_ADD_DEL, l2_patch_add_del);
8371 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
8372 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
8373 mp->is_add = is_add;
8382 api_ioam_enable (vat_main_t * vam)
8384 unformat_input_t *input = vam->input;
8385 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;
8393 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8395 if (unformat (input, "trace"))
8396 has_trace_option = 1;
8397 else if (unformat (input, "pot"))
8399 else if (unformat (input, "seqno"))
8400 has_seqno_option = 1;
8401 else if (unformat (input, "analyse"))
8402 has_analyse_option = 1;
8406 M (IOAM_ENABLE, ioam_enable);
8407 mp->id = htons (id);
8408 mp->seqno = has_seqno_option;
8409 mp->analyse = has_analyse_option;
8410 mp->pot_enable = has_pot_option;
8411 mp->trace_enable = has_trace_option;
8422 api_ioam_disable (vat_main_t * vam)
8424 vl_api_ioam_disable_t *mp;
8427 M (IOAM_DISABLE, ioam_disable);
8434 api_sr_tunnel_add_del (vat_main_t * vam)
8436 unformat_input_t *i = vam->input;
8437 vl_api_sr_tunnel_add_del_t *mp;
8441 ip6_address_t src_address;
8442 int src_address_set = 0;
8443 ip6_address_t dst_address;
8445 int dst_address_set = 0;
8447 u32 rx_table_id = 0;
8448 u32 tx_table_id = 0;
8449 ip6_address_t *segments = 0;
8450 ip6_address_t *this_seg;
8451 ip6_address_t *tags = 0;
8452 ip6_address_t *this_tag;
8453 ip6_address_t next_address, tag;
8455 u8 *policy_name = 0;
8457 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8459 if (unformat (i, "del"))
8461 else if (unformat (i, "name %s", &name))
8463 else if (unformat (i, "policy %s", &policy_name))
8465 else if (unformat (i, "rx_fib_id %d", &rx_table_id))
8467 else if (unformat (i, "tx_fib_id %d", &tx_table_id))
8469 else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
8470 src_address_set = 1;
8471 else if (unformat (i, "dst %U/%d",
8472 unformat_ip6_address, &dst_address, &dst_mask_width))
8473 dst_address_set = 1;
8474 else if (unformat (i, "next %U", unformat_ip6_address, &next_address))
8476 vec_add2 (segments, this_seg, 1);
8477 clib_memcpy (this_seg->as_u8, next_address.as_u8,
8478 sizeof (*this_seg));
8480 else if (unformat (i, "tag %U", unformat_ip6_address, &tag))
8482 vec_add2 (tags, this_tag, 1);
8483 clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
8485 else if (unformat (i, "clean"))
8486 flags |= IP6_SR_HEADER_FLAG_CLEANUP;
8487 else if (unformat (i, "protected"))
8488 flags |= IP6_SR_HEADER_FLAG_PROTECTED;
8489 else if (unformat (i, "InPE %d", &pl_index))
8491 if (pl_index <= 0 || pl_index > 4)
8493 pl_index_range_error:
8494 errmsg ("pl index %d out of range", pl_index);
8498 IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE << (3 * (pl_index - 1));
8500 else if (unformat (i, "EgPE %d", &pl_index))
8502 if (pl_index <= 0 || pl_index > 4)
8503 goto pl_index_range_error;
8505 IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE << (3 * (pl_index - 1));
8507 else if (unformat (i, "OrgSrc %d", &pl_index))
8509 if (pl_index <= 0 || pl_index > 4)
8510 goto pl_index_range_error;
8512 IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3 * (pl_index - 1));
8518 if (!src_address_set)
8520 errmsg ("src address required");
8524 if (!dst_address_set)
8526 errmsg ("dst address required");
8532 errmsg ("at least one sr segment required");
8536 M2 (SR_TUNNEL_ADD_DEL, sr_tunnel_add_del,
8537 vec_len (segments) * sizeof (ip6_address_t)
8538 + vec_len (tags) * sizeof (ip6_address_t));
8540 clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
8541 clib_memcpy (mp->dst_address, &dst_address, sizeof (mp->dst_address));
8542 mp->dst_mask_width = dst_mask_width;
8543 mp->flags_net_byte_order = clib_host_to_net_u16 (flags);
8544 mp->n_segments = vec_len (segments);
8545 mp->n_tags = vec_len (tags);
8546 mp->is_add = is_del == 0;
8547 clib_memcpy (mp->segs_and_tags, segments,
8548 vec_len (segments) * sizeof (ip6_address_t));
8549 clib_memcpy (mp->segs_and_tags +
8550 vec_len (segments) * sizeof (ip6_address_t), tags,
8551 vec_len (tags) * sizeof (ip6_address_t));
8553 mp->outer_vrf_id = ntohl (rx_table_id);
8554 mp->inner_vrf_id = ntohl (tx_table_id);
8555 memcpy (mp->name, name, vec_len (name));
8556 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
8558 vec_free (segments);
8567 api_sr_policy_add_del (vat_main_t * vam)
8569 unformat_input_t *input = vam->input;
8570 vl_api_sr_policy_add_del_t *mp;
8574 u8 *tunnel_name = 0;
8575 u8 **tunnel_names = 0;
8580 int tunnel_names_length = 1; // Init to 1 to offset the #tunnel_names counter byte
8581 int tun_name_len = 0; // Different naming convention used as confusing these would be "bad" (TM)
8583 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8585 if (unformat (input, "del"))
8587 else if (unformat (input, "name %s", &name))
8589 else if (unformat (input, "tunnel %s", &tunnel_name))
8593 vec_add1 (tunnel_names, tunnel_name);
8595 - length = #bytes to store in serial vector
8596 - +1 = byte to store that length
8598 tunnel_names_length += (vec_len (tunnel_name) + 1);
8609 errmsg ("policy name required");
8613 if ((!tunnel_set) && (!is_del))
8615 errmsg ("tunnel name required");
8619 M2 (SR_POLICY_ADD_DEL, sr_policy_add_del, tunnel_names_length);
8623 mp->is_add = !is_del;
8625 memcpy (mp->name, name, vec_len (name));
8626 // Since mp->tunnel_names is of type u8[0] and not a u8 *, u8 ** needs to be serialized
8627 u8 *serial_orig = 0;
8628 vec_validate (serial_orig, tunnel_names_length);
8629 *serial_orig = vec_len (tunnel_names); // Store the number of tunnels as length in first byte of serialized vector
8630 serial_orig += 1; // Move along one byte to store the length of first tunnel_name
8632 for (j = 0; j < vec_len (tunnel_names); j++)
8634 tun_name_len = vec_len (tunnel_names[j]);
8635 *serial_orig = tun_name_len; // Store length of tunnel name in first byte of Length/Value pair
8636 serial_orig += 1; // Move along one byte to store the actual tunnel name
8637 memcpy (serial_orig, tunnel_names[j], tun_name_len);
8638 serial_orig += tun_name_len; // Advance past the copy
8640 memcpy (mp->tunnel_names, serial_orig - tunnel_names_length, tunnel_names_length); // Regress serial_orig to head then copy fwd
8642 vec_free (tunnel_names);
8643 vec_free (tunnel_name);
8651 api_sr_multicast_map_add_del (vat_main_t * vam)
8653 unformat_input_t *input = vam->input;
8654 vl_api_sr_multicast_map_add_del_t *mp;
8657 ip6_address_t multicast_address;
8658 u8 *policy_name = 0;
8659 int multicast_address_set = 0;
8661 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8663 if (unformat (input, "del"))
8667 (input, "address %U", unformat_ip6_address, &multicast_address))
8668 multicast_address_set = 1;
8669 else if (unformat (input, "sr-policy %s", &policy_name))
8675 if (!is_del && !policy_name)
8677 errmsg ("sr-policy name required");
8682 if (!multicast_address_set)
8684 errmsg ("address required");
8688 M (SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del);
8690 mp->is_add = !is_del;
8691 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
8692 clib_memcpy (mp->multicast_address, &multicast_address,
8693 sizeof (mp->multicast_address));
8696 vec_free (policy_name);
8704 #define foreach_tcp_proto_field \
8708 #define foreach_udp_proto_field \
8712 #define foreach_ip4_proto_field \
8723 unformat_tcp_mask (unformat_input_t * input, va_list * args)
8725 u8 **maskp = va_arg (*args, u8 **);
8727 u8 found_something = 0;
8730 #define _(a) u8 a=0;
8731 foreach_tcp_proto_field;
8734 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8737 #define _(a) else if (unformat (input, #a)) a=1;
8738 foreach_tcp_proto_field
8744 #define _(a) found_something += a;
8745 foreach_tcp_proto_field;
8748 if (found_something == 0)
8751 vec_validate (mask, sizeof (*tcp) - 1);
8753 tcp = (tcp_header_t *) mask;
8755 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
8756 foreach_tcp_proto_field;
8764 unformat_udp_mask (unformat_input_t * input, va_list * args)
8766 u8 **maskp = va_arg (*args, u8 **);
8768 u8 found_something = 0;
8771 #define _(a) u8 a=0;
8772 foreach_udp_proto_field;
8775 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8778 #define _(a) else if (unformat (input, #a)) a=1;
8779 foreach_udp_proto_field
8785 #define _(a) found_something += a;
8786 foreach_udp_proto_field;
8789 if (found_something == 0)
8792 vec_validate (mask, sizeof (*udp) - 1);
8794 udp = (udp_header_t *) mask;
8796 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
8797 foreach_udp_proto_field;
8806 u16 src_port, dst_port;
8810 unformat_l4_mask (unformat_input_t * input, va_list * args)
8812 u8 **maskp = va_arg (*args, u8 **);
8813 u16 src_port = 0, dst_port = 0;
8814 tcpudp_header_t *tcpudp;
8816 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8818 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
8820 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
8822 else if (unformat (input, "src_port"))
8824 else if (unformat (input, "dst_port"))
8830 if (!src_port && !dst_port)
8834 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
8836 tcpudp = (tcpudp_header_t *) mask;
8837 tcpudp->src_port = src_port;
8838 tcpudp->dst_port = dst_port;
8846 unformat_ip4_mask (unformat_input_t * input, va_list * args)
8848 u8 **maskp = va_arg (*args, u8 **);
8850 u8 found_something = 0;
8853 #define _(a) u8 a=0;
8854 foreach_ip4_proto_field;
8860 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8862 if (unformat (input, "version"))
8864 else if (unformat (input, "hdr_length"))
8866 else if (unformat (input, "src"))
8868 else if (unformat (input, "dst"))
8870 else if (unformat (input, "proto"))
8873 #define _(a) else if (unformat (input, #a)) a=1;
8874 foreach_ip4_proto_field
8880 #define _(a) found_something += a;
8881 foreach_ip4_proto_field;
8884 if (found_something == 0)
8887 vec_validate (mask, sizeof (*ip) - 1);
8889 ip = (ip4_header_t *) mask;
8891 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
8892 foreach_ip4_proto_field;
8895 ip->ip_version_and_header_length = 0;
8898 ip->ip_version_and_header_length |= 0xF0;
8901 ip->ip_version_and_header_length |= 0x0F;
8907 #define foreach_ip6_proto_field \
8915 unformat_ip6_mask (unformat_input_t * input, va_list * args)
8917 u8 **maskp = va_arg (*args, u8 **);
8919 u8 found_something = 0;
8921 u32 ip_version_traffic_class_and_flow_label;
8923 #define _(a) u8 a=0;
8924 foreach_ip6_proto_field;
8927 u8 traffic_class = 0;
8930 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8932 if (unformat (input, "version"))
8934 else if (unformat (input, "traffic-class"))
8936 else if (unformat (input, "flow-label"))
8938 else if (unformat (input, "src"))
8940 else if (unformat (input, "dst"))
8942 else if (unformat (input, "proto"))
8945 #define _(a) else if (unformat (input, #a)) a=1;
8946 foreach_ip6_proto_field
8952 #define _(a) found_something += a;
8953 foreach_ip6_proto_field;
8956 if (found_something == 0)
8959 vec_validate (mask, sizeof (*ip) - 1);
8961 ip = (ip6_header_t *) mask;
8963 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
8964 foreach_ip6_proto_field;
8967 ip_version_traffic_class_and_flow_label = 0;
8970 ip_version_traffic_class_and_flow_label |= 0xF0000000;
8973 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
8976 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
8978 ip->ip_version_traffic_class_and_flow_label =
8979 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
8986 unformat_l3_mask (unformat_input_t * input, va_list * args)
8988 u8 **maskp = va_arg (*args, u8 **);
8990 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8992 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
8994 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
9003 unformat_l2_mask (unformat_input_t * input, va_list * args)
9005 u8 **maskp = va_arg (*args, u8 **);
9020 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9022 if (unformat (input, "src"))
9024 else if (unformat (input, "dst"))
9026 else if (unformat (input, "proto"))
9028 else if (unformat (input, "tag1"))
9030 else if (unformat (input, "tag2"))
9032 else if (unformat (input, "ignore-tag1"))
9034 else if (unformat (input, "ignore-tag2"))
9036 else if (unformat (input, "cos1"))
9038 else if (unformat (input, "cos2"))
9040 else if (unformat (input, "dot1q"))
9042 else if (unformat (input, "dot1ad"))
9047 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
9048 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9051 if (tag1 || ignore_tag1 || cos1 || dot1q)
9053 if (tag2 || ignore_tag2 || cos2 || dot1ad)
9056 vec_validate (mask, len - 1);
9059 memset (mask, 0xff, 6);
9062 memset (mask + 6, 0xff, 6);
9066 /* inner vlan tag */
9075 mask[21] = mask[20] = 0xff;
9096 mask[16] = mask[17] = 0xff;
9106 mask[12] = mask[13] = 0xff;
9113 unformat_classify_mask (unformat_input_t * input, va_list * args)
9115 u8 **maskp = va_arg (*args, u8 **);
9116 u32 *skipp = va_arg (*args, u32 *);
9117 u32 *matchp = va_arg (*args, u32 *);
9125 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9127 if (unformat (input, "hex %U", unformat_hex_string, &mask))
9129 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
9131 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
9133 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
9147 if (mask || l2 || l3 || l4)
9151 /* "With a free Ethernet header in every package" */
9153 vec_validate (l2, 13);
9157 vec_append (mask, l3);
9162 vec_append (mask, l4);
9167 /* Scan forward looking for the first significant mask octet */
9168 for (i = 0; i < vec_len (mask); i++)
9172 /* compute (skip, match) params */
9173 *skipp = i / sizeof (u32x4);
9174 vec_delete (mask, *skipp * sizeof (u32x4), 0);
9176 /* Pad mask to an even multiple of the vector size */
9177 while (vec_len (mask) % sizeof (u32x4))
9180 match = vec_len (mask) / sizeof (u32x4);
9182 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
9184 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
9185 if (*tmp || *(tmp + 1))
9190 clib_warning ("BUG: match 0");
9192 _vec_len (mask) = match * sizeof (u32x4);
9203 #define foreach_l2_next \
9205 _(ethernet, ETHERNET_INPUT) \
9210 unformat_l2_next_index (unformat_input_t * input, va_list * args)
9212 u32 *miss_next_indexp = va_arg (*args, u32 *);
9217 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
9221 if (unformat (input, "%d", &tmp))
9230 *miss_next_indexp = next_index;
9234 #define foreach_ip_next \
9240 unformat_ip_next_index (unformat_input_t * input, va_list * args)
9242 u32 *miss_next_indexp = va_arg (*args, u32 *);
9247 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
9251 if (unformat (input, "%d", &tmp))
9260 *miss_next_indexp = next_index;
9264 #define foreach_acl_next \
9268 unformat_acl_next_index (unformat_input_t * input, va_list * args)
9270 u32 *miss_next_indexp = va_arg (*args, u32 *);
9275 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
9279 if (unformat (input, "permit"))
9284 else if (unformat (input, "%d", &tmp))
9293 *miss_next_indexp = next_index;
9298 unformat_policer_precolor (unformat_input_t * input, va_list * args)
9300 u32 *r = va_arg (*args, u32 *);
9302 if (unformat (input, "conform-color"))
9303 *r = POLICE_CONFORM;
9304 else if (unformat (input, "exceed-color"))
9313 api_classify_add_del_table (vat_main_t * vam)
9315 unformat_input_t *i = vam->input;
9316 vl_api_classify_add_del_table_t *mp;
9323 u32 table_index = ~0;
9324 u32 next_table_index = ~0;
9325 u32 miss_next_index = ~0;
9326 u32 memory_size = 32 << 20;
9329 u32 current_data_flag = 0;
9330 int current_data_offset = 0;
9332 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9334 if (unformat (i, "del"))
9336 else if (unformat (i, "del-chain"))
9341 else if (unformat (i, "buckets %d", &nbuckets))
9343 else if (unformat (i, "memory_size %d", &memory_size))
9345 else if (unformat (i, "skip %d", &skip))
9347 else if (unformat (i, "match %d", &match))
9349 else if (unformat (i, "table %d", &table_index))
9351 else if (unformat (i, "mask %U", unformat_classify_mask,
9352 &mask, &skip, &match))
9354 else if (unformat (i, "next-table %d", &next_table_index))
9356 else if (unformat (i, "miss-next %U", unformat_ip_next_index,
9359 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
9362 else if (unformat (i, "acl-miss-next %U", unformat_acl_next_index,
9365 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
9367 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
9373 if (is_add && mask == 0)
9375 errmsg ("Mask required");
9379 if (is_add && skip == ~0)
9381 errmsg ("skip count required");
9385 if (is_add && match == ~0)
9387 errmsg ("match count required");
9391 if (!is_add && table_index == ~0)
9393 errmsg ("table index required for delete");
9397 M2 (CLASSIFY_ADD_DEL_TABLE, classify_add_del_table, vec_len (mask));
9399 mp->is_add = is_add;
9400 mp->del_chain = del_chain;
9401 mp->table_index = ntohl (table_index);
9402 mp->nbuckets = ntohl (nbuckets);
9403 mp->memory_size = ntohl (memory_size);
9404 mp->skip_n_vectors = ntohl (skip);
9405 mp->match_n_vectors = ntohl (match);
9406 mp->next_table_index = ntohl (next_table_index);
9407 mp->miss_next_index = ntohl (miss_next_index);
9408 mp->current_data_flag = ntohl (current_data_flag);
9409 mp->current_data_offset = ntohl (current_data_offset);
9410 clib_memcpy (mp->mask, mask, vec_len (mask));
9420 unformat_l4_match (unformat_input_t * input, va_list * args)
9422 u8 **matchp = va_arg (*args, u8 **);
9424 u8 *proto_header = 0;
9430 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9432 if (unformat (input, "src_port %d", &src_port))
9434 else if (unformat (input, "dst_port %d", &dst_port))
9440 h.src_port = clib_host_to_net_u16 (src_port);
9441 h.dst_port = clib_host_to_net_u16 (dst_port);
9442 vec_validate (proto_header, sizeof (h) - 1);
9443 memcpy (proto_header, &h, sizeof (h));
9445 *matchp = proto_header;
9451 unformat_ip4_match (unformat_input_t * input, va_list * args)
9453 u8 **matchp = va_arg (*args, u8 **);
9460 int src = 0, dst = 0;
9461 ip4_address_t src_val, dst_val;
9468 int fragment_id = 0;
9469 u32 fragment_id_val;
9475 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9477 if (unformat (input, "version %d", &version_val))
9479 else if (unformat (input, "hdr_length %d", &hdr_length_val))
9481 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
9483 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
9485 else if (unformat (input, "proto %d", &proto_val))
9487 else if (unformat (input, "tos %d", &tos_val))
9489 else if (unformat (input, "length %d", &length_val))
9491 else if (unformat (input, "fragment_id %d", &fragment_id_val))
9493 else if (unformat (input, "ttl %d", &ttl_val))
9495 else if (unformat (input, "checksum %d", &checksum_val))
9501 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
9502 + ttl + checksum == 0)
9506 * Aligned because we use the real comparison functions
9508 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
9510 ip = (ip4_header_t *) match;
9512 /* These are realistically matched in practice */
9514 ip->src_address.as_u32 = src_val.as_u32;
9517 ip->dst_address.as_u32 = dst_val.as_u32;
9520 ip->protocol = proto_val;
9523 /* These are not, but they're included for completeness */
9525 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
9528 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
9534 ip->length = clib_host_to_net_u16 (length_val);
9540 ip->checksum = clib_host_to_net_u16 (checksum_val);
9547 unformat_ip6_match (unformat_input_t * input, va_list * args)
9549 u8 **matchp = va_arg (*args, u8 **);
9554 u8 traffic_class = 0;
9555 u32 traffic_class_val = 0;
9558 int src = 0, dst = 0;
9559 ip6_address_t src_val, dst_val;
9562 int payload_length = 0;
9563 u32 payload_length_val;
9566 u32 ip_version_traffic_class_and_flow_label;
9568 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9570 if (unformat (input, "version %d", &version_val))
9572 else if (unformat (input, "traffic_class %d", &traffic_class_val))
9574 else if (unformat (input, "flow_label %d", &flow_label_val))
9576 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
9578 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
9580 else if (unformat (input, "proto %d", &proto_val))
9582 else if (unformat (input, "payload_length %d", &payload_length_val))
9584 else if (unformat (input, "hop_limit %d", &hop_limit_val))
9590 if (version + traffic_class + flow_label + src + dst + proto +
9591 payload_length + hop_limit == 0)
9595 * Aligned because we use the real comparison functions
9597 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
9599 ip = (ip6_header_t *) match;
9602 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
9605 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
9608 ip->protocol = proto_val;
9610 ip_version_traffic_class_and_flow_label = 0;
9613 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
9616 ip_version_traffic_class_and_flow_label |=
9617 (traffic_class_val & 0xFF) << 20;
9620 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
9622 ip->ip_version_traffic_class_and_flow_label =
9623 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9626 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
9629 ip->hop_limit = hop_limit_val;
9636 unformat_l3_match (unformat_input_t * input, va_list * args)
9638 u8 **matchp = va_arg (*args, u8 **);
9640 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9642 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
9644 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
9653 unformat_vlan_tag (unformat_input_t * input, va_list * args)
9655 u8 *tagp = va_arg (*args, u8 *);
9658 if (unformat (input, "%d", &tag))
9660 tagp[0] = (tag >> 8) & 0x0F;
9661 tagp[1] = tag & 0xFF;
9669 unformat_l2_match (unformat_input_t * input, va_list * args)
9671 u8 **matchp = va_arg (*args, u8 **);
9691 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9693 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
9696 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
9698 else if (unformat (input, "proto %U",
9699 unformat_ethernet_type_host_byte_order, &proto_val))
9701 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
9703 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
9705 else if (unformat (input, "ignore-tag1"))
9707 else if (unformat (input, "ignore-tag2"))
9709 else if (unformat (input, "cos1 %d", &cos1_val))
9711 else if (unformat (input, "cos2 %d", &cos2_val))
9716 if ((src + dst + proto + tag1 + tag2 +
9717 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9720 if (tag1 || ignore_tag1 || cos1)
9722 if (tag2 || ignore_tag2 || cos2)
9725 vec_validate_aligned (match, len - 1, sizeof (u32x4));
9728 clib_memcpy (match, dst_val, 6);
9731 clib_memcpy (match + 6, src_val, 6);
9735 /* inner vlan tag */
9736 match[19] = tag2_val[1];
9737 match[18] = tag2_val[0];
9739 match[18] |= (cos2_val & 0x7) << 5;
9742 match[21] = proto_val & 0xff;
9743 match[20] = proto_val >> 8;
9747 match[15] = tag1_val[1];
9748 match[14] = tag1_val[0];
9751 match[14] |= (cos1_val & 0x7) << 5;
9757 match[15] = tag1_val[1];
9758 match[14] = tag1_val[0];
9761 match[17] = proto_val & 0xff;
9762 match[16] = proto_val >> 8;
9765 match[14] |= (cos1_val & 0x7) << 5;
9771 match[18] |= (cos2_val & 0x7) << 5;
9773 match[14] |= (cos1_val & 0x7) << 5;
9776 match[13] = proto_val & 0xff;
9777 match[12] = proto_val >> 8;
9786 unformat_classify_match (unformat_input_t * input, va_list * args)
9788 u8 **matchp = va_arg (*args, u8 **);
9789 u32 skip_n_vectors = va_arg (*args, u32);
9790 u32 match_n_vectors = va_arg (*args, u32);
9797 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9799 if (unformat (input, "hex %U", unformat_hex_string, &match))
9801 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
9803 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
9805 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
9819 if (match || l2 || l3 || l4)
9823 /* "Win a free Ethernet header in every packet" */
9825 vec_validate_aligned (l2, 13, sizeof (u32x4));
9829 vec_append_aligned (match, l3, sizeof (u32x4));
9834 vec_append_aligned (match, l4, sizeof (u32x4));
9839 /* Make sure the vector is big enough even if key is all 0's */
9840 vec_validate_aligned
9841 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
9844 /* Set size, include skipped vectors */
9845 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
9856 api_classify_add_del_session (vat_main_t * vam)
9858 unformat_input_t *i = vam->input;
9859 vl_api_classify_add_del_session_t *mp;
9861 u32 table_index = ~0;
9862 u32 hit_next_index = ~0;
9863 u32 opaque_index = ~0;
9867 u32 skip_n_vectors = 0;
9868 u32 match_n_vectors = 0;
9873 * Warning: you have to supply skip_n and match_n
9874 * because the API client cant simply look at the classify
9878 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9880 if (unformat (i, "del"))
9882 else if (unformat (i, "hit-next %U", unformat_ip_next_index,
9885 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
9888 else if (unformat (i, "acl-hit-next %U", unformat_acl_next_index,
9891 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
9893 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
9895 else if (unformat (i, "opaque-index %d", &opaque_index))
9897 else if (unformat (i, "skip_n %d", &skip_n_vectors))
9899 else if (unformat (i, "match_n %d", &match_n_vectors))
9901 else if (unformat (i, "match %U", unformat_classify_match,
9902 &match, skip_n_vectors, match_n_vectors))
9904 else if (unformat (i, "advance %d", &advance))
9906 else if (unformat (i, "table-index %d", &table_index))
9908 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
9910 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
9912 else if (unformat (i, "action %d", &action))
9914 else if (unformat (i, "metadata %d", &metadata))
9920 if (table_index == ~0)
9922 errmsg ("Table index required");
9926 if (is_add && match == 0)
9928 errmsg ("Match value required");
9932 M2 (CLASSIFY_ADD_DEL_SESSION, classify_add_del_session, vec_len (match));
9934 mp->is_add = is_add;
9935 mp->table_index = ntohl (table_index);
9936 mp->hit_next_index = ntohl (hit_next_index);
9937 mp->opaque_index = ntohl (opaque_index);
9938 mp->advance = ntohl (advance);
9939 mp->action = action;
9940 mp->metadata = ntohl (metadata);
9941 clib_memcpy (mp->match, match, vec_len (match));
9950 api_classify_set_interface_ip_table (vat_main_t * vam)
9952 unformat_input_t *i = vam->input;
9953 vl_api_classify_set_interface_ip_table_t *mp;
9956 int sw_if_index_set;
9957 u32 table_index = ~0;
9960 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9962 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9963 sw_if_index_set = 1;
9964 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9965 sw_if_index_set = 1;
9966 else if (unformat (i, "table %d", &table_index))
9970 clib_warning ("parse error '%U'", format_unformat_error, i);
9975 if (sw_if_index_set == 0)
9977 errmsg ("missing interface name or sw_if_index");
9982 M (CLASSIFY_SET_INTERFACE_IP_TABLE, classify_set_interface_ip_table);
9984 mp->sw_if_index = ntohl (sw_if_index);
9985 mp->table_index = ntohl (table_index);
9986 mp->is_ipv6 = is_ipv6;
9995 api_classify_set_interface_l2_tables (vat_main_t * vam)
9997 unformat_input_t *i = vam->input;
9998 vl_api_classify_set_interface_l2_tables_t *mp;
10001 int sw_if_index_set;
10002 u32 ip4_table_index = ~0;
10003 u32 ip6_table_index = ~0;
10004 u32 other_table_index = ~0;
10007 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10009 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10010 sw_if_index_set = 1;
10011 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10012 sw_if_index_set = 1;
10013 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10015 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10017 else if (unformat (i, "other-table %d", &other_table_index))
10019 else if (unformat (i, "is-input %d", &is_input))
10023 clib_warning ("parse error '%U'", format_unformat_error, i);
10028 if (sw_if_index_set == 0)
10030 errmsg ("missing interface name or sw_if_index");
10035 M (CLASSIFY_SET_INTERFACE_L2_TABLES, classify_set_interface_l2_tables);
10037 mp->sw_if_index = ntohl (sw_if_index);
10038 mp->ip4_table_index = ntohl (ip4_table_index);
10039 mp->ip6_table_index = ntohl (ip6_table_index);
10040 mp->other_table_index = ntohl (other_table_index);
10041 mp->is_input = (u8) is_input;
10050 api_set_ipfix_exporter (vat_main_t * vam)
10052 unformat_input_t *i = vam->input;
10053 vl_api_set_ipfix_exporter_t *mp;
10054 ip4_address_t collector_address;
10055 u8 collector_address_set = 0;
10056 u32 collector_port = ~0;
10057 ip4_address_t src_address;
10058 u8 src_address_set = 0;
10061 u32 template_interval = ~0;
10062 u8 udp_checksum = 0;
10065 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10067 if (unformat (i, "collector_address %U", unformat_ip4_address,
10068 &collector_address))
10069 collector_address_set = 1;
10070 else if (unformat (i, "collector_port %d", &collector_port))
10072 else if (unformat (i, "src_address %U", unformat_ip4_address,
10074 src_address_set = 1;
10075 else if (unformat (i, "vrf_id %d", &vrf_id))
10077 else if (unformat (i, "path_mtu %d", &path_mtu))
10079 else if (unformat (i, "template_interval %d", &template_interval))
10081 else if (unformat (i, "udp_checksum"))
10087 if (collector_address_set == 0)
10089 errmsg ("collector_address required");
10093 if (src_address_set == 0)
10095 errmsg ("src_address required");
10099 M (SET_IPFIX_EXPORTER, set_ipfix_exporter);
10101 memcpy (mp->collector_address, collector_address.data,
10102 sizeof (collector_address.data));
10103 mp->collector_port = htons ((u16) collector_port);
10104 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
10105 mp->vrf_id = htonl (vrf_id);
10106 mp->path_mtu = htonl (path_mtu);
10107 mp->template_interval = htonl (template_interval);
10108 mp->udp_checksum = udp_checksum;
10116 api_set_ipfix_classify_stream (vat_main_t * vam)
10118 unformat_input_t *i = vam->input;
10119 vl_api_set_ipfix_classify_stream_t *mp;
10121 u32 src_port = UDP_DST_PORT_ipfix;
10124 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10126 if (unformat (i, "domain %d", &domain_id))
10128 else if (unformat (i, "src_port %d", &src_port))
10132 errmsg ("unknown input `%U'", format_unformat_error, i);
10137 M (SET_IPFIX_CLASSIFY_STREAM, set_ipfix_classify_stream);
10139 mp->domain_id = htonl (domain_id);
10140 mp->src_port = htons ((u16) src_port);
10148 api_ipfix_classify_table_add_del (vat_main_t * vam)
10150 unformat_input_t *i = vam->input;
10151 vl_api_ipfix_classify_table_add_del_t *mp;
10153 u32 classify_table_index = ~0;
10155 u8 transport_protocol = 255;
10158 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10160 if (unformat (i, "add"))
10162 else if (unformat (i, "del"))
10164 else if (unformat (i, "table %d", &classify_table_index))
10166 else if (unformat (i, "ip4"))
10168 else if (unformat (i, "ip6"))
10170 else if (unformat (i, "tcp"))
10171 transport_protocol = 6;
10172 else if (unformat (i, "udp"))
10173 transport_protocol = 17;
10176 errmsg ("unknown input `%U'", format_unformat_error, i);
10183 errmsg ("expecting: add|del");
10186 if (classify_table_index == ~0)
10188 errmsg ("classifier table not specified");
10191 if (ip_version == 0)
10193 errmsg ("IP version not specified");
10197 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, ipfix_classify_table_add_del);
10199 mp->is_add = is_add;
10200 mp->table_id = htonl (classify_table_index);
10201 mp->ip_version = ip_version;
10202 mp->transport_protocol = transport_protocol;
10210 api_get_node_index (vat_main_t * vam)
10212 unformat_input_t *i = vam->input;
10213 vl_api_get_node_index_t *mp;
10217 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10219 if (unformat (i, "node %s", &name))
10226 errmsg ("node name required");
10229 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10231 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10235 M (GET_NODE_INDEX, get_node_index);
10236 clib_memcpy (mp->node_name, name, vec_len (name));
10246 api_get_next_index (vat_main_t * vam)
10248 unformat_input_t *i = vam->input;
10249 vl_api_get_next_index_t *mp;
10251 u8 *node_name = 0, *next_node_name = 0;
10253 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10255 if (unformat (i, "node-name %s", &node_name))
10257 else if (unformat (i, "next-node-name %s", &next_node_name))
10261 if (node_name == 0)
10263 errmsg ("node name required");
10266 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
10268 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10272 if (next_node_name == 0)
10274 errmsg ("next node name required");
10277 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
10279 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
10283 M (GET_NEXT_INDEX, get_next_index);
10284 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
10285 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
10286 vec_free (node_name);
10287 vec_free (next_node_name);
10296 api_add_node_next (vat_main_t * vam)
10298 unformat_input_t *i = vam->input;
10299 vl_api_add_node_next_t *mp;
10304 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10306 if (unformat (i, "node %s", &name))
10308 else if (unformat (i, "next %s", &next))
10315 errmsg ("node name required");
10318 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10320 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10325 errmsg ("next node required");
10328 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
10330 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
10334 M (ADD_NODE_NEXT, add_node_next);
10335 clib_memcpy (mp->node_name, name, vec_len (name));
10336 clib_memcpy (mp->next_name, next, vec_len (next));
10347 api_l2tpv3_create_tunnel (vat_main_t * vam)
10349 unformat_input_t *i = vam->input;
10350 ip6_address_t client_address, our_address;
10351 int client_address_set = 0;
10352 int our_address_set = 0;
10353 u32 local_session_id = 0;
10354 u32 remote_session_id = 0;
10355 u64 local_cookie = 0;
10356 u64 remote_cookie = 0;
10357 u8 l2_sublayer_present = 0;
10358 vl_api_l2tpv3_create_tunnel_t *mp;
10361 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10363 if (unformat (i, "client_address %U", unformat_ip6_address,
10365 client_address_set = 1;
10366 else if (unformat (i, "our_address %U", unformat_ip6_address,
10368 our_address_set = 1;
10369 else if (unformat (i, "local_session_id %d", &local_session_id))
10371 else if (unformat (i, "remote_session_id %d", &remote_session_id))
10373 else if (unformat (i, "local_cookie %lld", &local_cookie))
10375 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
10377 else if (unformat (i, "l2-sublayer-present"))
10378 l2_sublayer_present = 1;
10383 if (client_address_set == 0)
10385 errmsg ("client_address required");
10389 if (our_address_set == 0)
10391 errmsg ("our_address required");
10395 M (L2TPV3_CREATE_TUNNEL, l2tpv3_create_tunnel);
10397 clib_memcpy (mp->client_address, client_address.as_u8,
10398 sizeof (mp->client_address));
10400 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
10402 mp->local_session_id = ntohl (local_session_id);
10403 mp->remote_session_id = ntohl (remote_session_id);
10404 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
10405 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
10406 mp->l2_sublayer_present = l2_sublayer_present;
10416 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
10418 unformat_input_t *i = vam->input;
10420 u8 sw_if_index_set = 0;
10421 u64 new_local_cookie = 0;
10422 u64 new_remote_cookie = 0;
10423 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
10426 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10428 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10429 sw_if_index_set = 1;
10430 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10431 sw_if_index_set = 1;
10432 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
10434 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
10440 if (sw_if_index_set == 0)
10442 errmsg ("missing interface name or sw_if_index");
10446 M (L2TPV3_SET_TUNNEL_COOKIES, l2tpv3_set_tunnel_cookies);
10448 mp->sw_if_index = ntohl (sw_if_index);
10449 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
10450 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
10459 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
10461 unformat_input_t *i = vam->input;
10462 vl_api_l2tpv3_interface_enable_disable_t *mp;
10465 u8 sw_if_index_set = 0;
10466 u8 enable_disable = 1;
10468 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10470 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10471 sw_if_index_set = 1;
10472 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10473 sw_if_index_set = 1;
10474 else if (unformat (i, "enable"))
10475 enable_disable = 1;
10476 else if (unformat (i, "disable"))
10477 enable_disable = 0;
10482 if (sw_if_index_set == 0)
10484 errmsg ("missing interface name or sw_if_index");
10488 M (L2TPV3_INTERFACE_ENABLE_DISABLE, l2tpv3_interface_enable_disable);
10490 mp->sw_if_index = ntohl (sw_if_index);
10491 mp->enable_disable = enable_disable;
10500 api_l2tpv3_set_lookup_key (vat_main_t * vam)
10502 unformat_input_t *i = vam->input;
10503 vl_api_l2tpv3_set_lookup_key_t *mp;
10507 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10509 if (unformat (i, "lookup_v6_src"))
10510 key = L2T_LOOKUP_SRC_ADDRESS;
10511 else if (unformat (i, "lookup_v6_dst"))
10512 key = L2T_LOOKUP_DST_ADDRESS;
10513 else if (unformat (i, "lookup_session_id"))
10514 key = L2T_LOOKUP_SESSION_ID;
10519 if (key == (u8) ~ 0)
10521 errmsg ("l2tp session lookup key unset");
10525 M (L2TPV3_SET_LOOKUP_KEY, l2tpv3_set_lookup_key);
10535 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
10536 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
10538 vat_main_t *vam = &vat_main;
10540 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
10541 format_ip6_address, mp->our_address,
10542 format_ip6_address, mp->client_address,
10543 clib_net_to_host_u32 (mp->sw_if_index));
10546 " local cookies %016llx %016llx remote cookie %016llx",
10547 clib_net_to_host_u64 (mp->local_cookie[0]),
10548 clib_net_to_host_u64 (mp->local_cookie[1]),
10549 clib_net_to_host_u64 (mp->remote_cookie));
10551 print (vam->ofp, " local session-id %d remote session-id %d",
10552 clib_net_to_host_u32 (mp->local_session_id),
10553 clib_net_to_host_u32 (mp->remote_session_id));
10555 print (vam->ofp, " l2 specific sublayer %s\n",
10556 mp->l2_sublayer_present ? "preset" : "absent");
10560 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
10561 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
10563 vat_main_t *vam = &vat_main;
10564 vat_json_node_t *node = NULL;
10565 struct in6_addr addr;
10567 if (VAT_JSON_ARRAY != vam->json_tree.type)
10569 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10570 vat_json_init_array (&vam->json_tree);
10572 node = vat_json_array_add (&vam->json_tree);
10574 vat_json_init_object (node);
10576 clib_memcpy (&addr, mp->our_address, sizeof (addr));
10577 vat_json_object_add_ip6 (node, "our_address", addr);
10578 clib_memcpy (&addr, mp->client_address, sizeof (addr));
10579 vat_json_object_add_ip6 (node, "client_address", addr);
10581 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
10582 vat_json_init_array (lc);
10583 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
10584 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
10585 vat_json_object_add_uint (node, "remote_cookie",
10586 clib_net_to_host_u64 (mp->remote_cookie));
10588 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
10589 vat_json_object_add_uint (node, "local_session_id",
10590 clib_net_to_host_u32 (mp->local_session_id));
10591 vat_json_object_add_uint (node, "remote_session_id",
10592 clib_net_to_host_u32 (mp->remote_session_id));
10593 vat_json_object_add_string_copy (node, "l2_sublayer",
10594 mp->l2_sublayer_present ? (u8 *) "present"
10595 : (u8 *) "absent");
10599 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
10601 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
10604 /* Get list of l2tpv3-tunnel interfaces */
10605 M (SW_IF_L2TPV3_TUNNEL_DUMP, sw_if_l2tpv3_tunnel_dump);
10608 /* Use a control ping for synchronization */
10610 vl_api_control_ping_t *mp;
10611 M (CONTROL_PING, control_ping);
10618 static void vl_api_sw_interface_tap_details_t_handler
10619 (vl_api_sw_interface_tap_details_t * mp)
10621 vat_main_t *vam = &vat_main;
10623 print (vam->ofp, "%-16s %d",
10624 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
10627 static void vl_api_sw_interface_tap_details_t_handler_json
10628 (vl_api_sw_interface_tap_details_t * mp)
10630 vat_main_t *vam = &vat_main;
10631 vat_json_node_t *node = NULL;
10633 if (VAT_JSON_ARRAY != vam->json_tree.type)
10635 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10636 vat_json_init_array (&vam->json_tree);
10638 node = vat_json_array_add (&vam->json_tree);
10640 vat_json_init_object (node);
10641 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10642 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
10646 api_sw_interface_tap_dump (vat_main_t * vam)
10648 vl_api_sw_interface_tap_dump_t *mp;
10651 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
10652 /* Get list of tap interfaces */
10653 M (SW_INTERFACE_TAP_DUMP, sw_interface_tap_dump);
10656 /* Use a control ping for synchronization */
10658 vl_api_control_ping_t *mp;
10659 M (CONTROL_PING, control_ping);
10665 static uword unformat_vxlan_decap_next
10666 (unformat_input_t * input, va_list * args)
10668 u32 *result = va_arg (*args, u32 *);
10671 if (unformat (input, "l2"))
10672 *result = VXLAN_INPUT_NEXT_L2_INPUT;
10673 else if (unformat (input, "%d", &tmp))
10681 api_vxlan_add_del_tunnel (vat_main_t * vam)
10683 unformat_input_t *line_input = vam->input;
10684 vl_api_vxlan_add_del_tunnel_t *mp;
10686 ip46_address_t src, dst;
10688 u8 ipv4_set = 0, ipv6_set = 0;
10692 u32 mcast_sw_if_index = ~0;
10693 u32 encap_vrf_id = 0;
10694 u32 decap_next_index = ~0;
10697 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
10698 memset (&src, 0, sizeof src);
10699 memset (&dst, 0, sizeof dst);
10701 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10703 if (unformat (line_input, "del"))
10706 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
10712 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
10718 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
10724 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
10729 else if (unformat (line_input, "group %U %U",
10730 unformat_ip4_address, &dst.ip4,
10731 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
10733 grp_set = dst_set = 1;
10736 else if (unformat (line_input, "group %U",
10737 unformat_ip4_address, &dst.ip4))
10739 grp_set = dst_set = 1;
10742 else if (unformat (line_input, "group %U %U",
10743 unformat_ip6_address, &dst.ip6,
10744 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
10746 grp_set = dst_set = 1;
10749 else if (unformat (line_input, "group %U",
10750 unformat_ip6_address, &dst.ip6))
10752 grp_set = dst_set = 1;
10756 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
10758 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
10760 else if (unformat (line_input, "decap-next %U",
10761 unformat_vxlan_decap_next, &decap_next_index))
10763 else if (unformat (line_input, "vni %d", &vni))
10767 errmsg ("parse error '%U'", format_unformat_error, line_input);
10774 errmsg ("tunnel src address not specified");
10779 errmsg ("tunnel dst address not specified");
10783 if (grp_set && !ip46_address_is_multicast (&dst))
10785 errmsg ("tunnel group address not multicast");
10788 if (grp_set && mcast_sw_if_index == ~0)
10790 errmsg ("tunnel nonexistent multicast device");
10793 if (grp_set == 0 && ip46_address_is_multicast (&dst))
10795 errmsg ("tunnel dst address must be unicast");
10800 if (ipv4_set && ipv6_set)
10802 errmsg ("both IPv4 and IPv6 addresses specified");
10806 if ((vni == 0) || (vni >> 24))
10808 errmsg ("vni not specified or out of range");
10812 M (VXLAN_ADD_DEL_TUNNEL, vxlan_add_del_tunnel);
10816 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
10817 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
10821 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
10822 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
10824 mp->encap_vrf_id = ntohl (encap_vrf_id);
10825 mp->decap_next_index = ntohl (decap_next_index);
10826 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
10827 mp->vni = ntohl (vni);
10828 mp->is_add = is_add;
10829 mp->is_ipv6 = ipv6_set;
10837 static void vl_api_vxlan_tunnel_details_t_handler
10838 (vl_api_vxlan_tunnel_details_t * mp)
10840 vat_main_t *vam = &vat_main;
10841 ip46_address_t src, dst;
10843 ip46_from_addr_buf (mp->is_ipv6, mp->src_address, &src);
10844 ip46_from_addr_buf (mp->is_ipv6, mp->dst_address, &dst);
10846 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
10847 ntohl (mp->sw_if_index),
10848 format_ip46_address, &src, IP46_TYPE_ANY,
10849 format_ip46_address, &dst, IP46_TYPE_ANY,
10850 ntohl (mp->encap_vrf_id),
10851 ntohl (mp->decap_next_index), ntohl (mp->vni),
10852 ntohl (mp->mcast_sw_if_index));
10855 static void vl_api_vxlan_tunnel_details_t_handler_json
10856 (vl_api_vxlan_tunnel_details_t * mp)
10858 vat_main_t *vam = &vat_main;
10859 vat_json_node_t *node = NULL;
10861 if (VAT_JSON_ARRAY != vam->json_tree.type)
10863 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10864 vat_json_init_array (&vam->json_tree);
10866 node = vat_json_array_add (&vam->json_tree);
10868 vat_json_init_object (node);
10869 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10872 struct in6_addr ip6;
10874 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
10875 vat_json_object_add_ip6 (node, "src_address", ip6);
10876 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
10877 vat_json_object_add_ip6 (node, "dst_address", ip6);
10881 struct in_addr ip4;
10883 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
10884 vat_json_object_add_ip4 (node, "src_address", ip4);
10885 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
10886 vat_json_object_add_ip4 (node, "dst_address", ip4);
10888 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
10889 vat_json_object_add_uint (node, "decap_next_index",
10890 ntohl (mp->decap_next_index));
10891 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
10892 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
10893 vat_json_object_add_uint (node, "mcast_sw_if_index",
10894 ntohl (mp->mcast_sw_if_index));
10898 api_vxlan_tunnel_dump (vat_main_t * vam)
10900 unformat_input_t *i = vam->input;
10901 vl_api_vxlan_tunnel_dump_t *mp;
10904 u8 sw_if_index_set = 0;
10906 /* Parse args required to build the message */
10907 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10909 if (unformat (i, "sw_if_index %d", &sw_if_index))
10910 sw_if_index_set = 1;
10915 if (sw_if_index_set == 0)
10920 if (!vam->json_output)
10922 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
10923 "sw_if_index", "src_address", "dst_address",
10924 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
10927 /* Get list of vxlan-tunnel interfaces */
10928 M (VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump);
10930 mp->sw_if_index = htonl (sw_if_index);
10934 /* Use a control ping for synchronization */
10936 vl_api_control_ping_t *mp;
10937 M (CONTROL_PING, control_ping);
10944 api_gre_add_del_tunnel (vat_main_t * vam)
10946 unformat_input_t *line_input = vam->input;
10947 vl_api_gre_add_del_tunnel_t *mp;
10949 ip4_address_t src4, dst4;
10954 u32 outer_fib_id = 0;
10956 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10958 if (unformat (line_input, "del"))
10960 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
10962 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
10964 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
10966 else if (unformat (line_input, "teb"))
10970 errmsg ("parse error '%U'", format_unformat_error, line_input);
10977 errmsg ("tunnel src address not specified");
10982 errmsg ("tunnel dst address not specified");
10987 M (GRE_ADD_DEL_TUNNEL, gre_add_del_tunnel);
10989 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
10990 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
10991 mp->outer_fib_id = ntohl (outer_fib_id);
10992 mp->is_add = is_add;
11001 static void vl_api_gre_tunnel_details_t_handler
11002 (vl_api_gre_tunnel_details_t * mp)
11004 vat_main_t *vam = &vat_main;
11006 print (vam->ofp, "%11d%15U%15U%6d%14d",
11007 ntohl (mp->sw_if_index),
11008 format_ip4_address, &mp->src_address,
11009 format_ip4_address, &mp->dst_address,
11010 mp->teb, ntohl (mp->outer_fib_id));
11013 static void vl_api_gre_tunnel_details_t_handler_json
11014 (vl_api_gre_tunnel_details_t * mp)
11016 vat_main_t *vam = &vat_main;
11017 vat_json_node_t *node = NULL;
11018 struct in_addr ip4;
11020 if (VAT_JSON_ARRAY != vam->json_tree.type)
11022 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11023 vat_json_init_array (&vam->json_tree);
11025 node = vat_json_array_add (&vam->json_tree);
11027 vat_json_init_object (node);
11028 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11029 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
11030 vat_json_object_add_ip4 (node, "src_address", ip4);
11031 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
11032 vat_json_object_add_ip4 (node, "dst_address", ip4);
11033 vat_json_object_add_uint (node, "teb", mp->teb);
11034 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
11038 api_gre_tunnel_dump (vat_main_t * vam)
11040 unformat_input_t *i = vam->input;
11041 vl_api_gre_tunnel_dump_t *mp;
11044 u8 sw_if_index_set = 0;
11046 /* Parse args required to build the message */
11047 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11049 if (unformat (i, "sw_if_index %d", &sw_if_index))
11050 sw_if_index_set = 1;
11055 if (sw_if_index_set == 0)
11060 if (!vam->json_output)
11062 print (vam->ofp, "%11s%15s%15s%6s%14s",
11063 "sw_if_index", "src_address", "dst_address", "teb",
11067 /* Get list of gre-tunnel interfaces */
11068 M (GRE_TUNNEL_DUMP, gre_tunnel_dump);
11070 mp->sw_if_index = htonl (sw_if_index);
11074 /* Use a control ping for synchronization */
11076 vl_api_control_ping_t *mp;
11077 M (CONTROL_PING, control_ping);
11084 api_l2_fib_clear_table (vat_main_t * vam)
11086 // unformat_input_t * i = vam->input;
11087 vl_api_l2_fib_clear_table_t *mp;
11090 M (L2_FIB_CLEAR_TABLE, l2_fib_clear_table);
11099 api_l2_interface_efp_filter (vat_main_t * vam)
11101 unformat_input_t *i = vam->input;
11102 vl_api_l2_interface_efp_filter_t *mp;
11106 u8 sw_if_index_set = 0;
11108 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11110 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11111 sw_if_index_set = 1;
11112 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11113 sw_if_index_set = 1;
11114 else if (unformat (i, "enable"))
11116 else if (unformat (i, "disable"))
11120 clib_warning ("parse error '%U'", format_unformat_error, i);
11125 if (sw_if_index_set == 0)
11127 errmsg ("missing sw_if_index");
11131 M (L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter);
11133 mp->sw_if_index = ntohl (sw_if_index);
11134 mp->enable_disable = enable;
11142 #define foreach_vtr_op \
11143 _("disable", L2_VTR_DISABLED) \
11144 _("push-1", L2_VTR_PUSH_1) \
11145 _("push-2", L2_VTR_PUSH_2) \
11146 _("pop-1", L2_VTR_POP_1) \
11147 _("pop-2", L2_VTR_POP_2) \
11148 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
11149 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
11150 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
11151 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
11154 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
11156 unformat_input_t *i = vam->input;
11157 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
11160 u8 sw_if_index_set = 0;
11163 u32 push_dot1q = 1;
11167 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11169 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11170 sw_if_index_set = 1;
11171 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11172 sw_if_index_set = 1;
11173 else if (unformat (i, "vtr_op %d", &vtr_op))
11175 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
11178 else if (unformat (i, "push_dot1q %d", &push_dot1q))
11180 else if (unformat (i, "tag1 %d", &tag1))
11182 else if (unformat (i, "tag2 %d", &tag2))
11186 clib_warning ("parse error '%U'", format_unformat_error, i);
11191 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
11193 errmsg ("missing vtr operation or sw_if_index");
11197 M (L2_INTERFACE_VLAN_TAG_REWRITE, l2_interface_vlan_tag_rewrite)
11198 mp->sw_if_index = ntohl (sw_if_index);
11199 mp->vtr_op = ntohl (vtr_op);
11200 mp->push_dot1q = ntohl (push_dot1q);
11201 mp->tag1 = ntohl (tag1);
11202 mp->tag2 = ntohl (tag2);
11211 api_create_vhost_user_if (vat_main_t * vam)
11213 unformat_input_t *i = vam->input;
11214 vl_api_create_vhost_user_if_t *mp;
11218 u8 file_name_set = 0;
11219 u32 custom_dev_instance = ~0;
11221 u8 use_custom_mac = 0;
11224 /* Shut up coverity */
11225 memset (hwaddr, 0, sizeof (hwaddr));
11227 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11229 if (unformat (i, "socket %s", &file_name))
11233 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
11235 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
11236 use_custom_mac = 1;
11237 else if (unformat (i, "server"))
11239 else if (unformat (i, "tag %s", &tag))
11245 if (file_name_set == 0)
11247 errmsg ("missing socket file name");
11251 if (vec_len (file_name) > 255)
11253 errmsg ("socket file name too long");
11256 vec_add1 (file_name, 0);
11258 M (CREATE_VHOST_USER_IF, create_vhost_user_if);
11260 mp->is_server = is_server;
11261 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
11262 vec_free (file_name);
11263 if (custom_dev_instance != ~0)
11266 mp->custom_dev_instance = ntohl (custom_dev_instance);
11268 mp->use_custom_mac = use_custom_mac;
11269 clib_memcpy (mp->mac_address, hwaddr, 6);
11271 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
11281 api_modify_vhost_user_if (vat_main_t * vam)
11283 unformat_input_t *i = vam->input;
11284 vl_api_modify_vhost_user_if_t *mp;
11288 u8 file_name_set = 0;
11289 u32 custom_dev_instance = ~0;
11290 u8 sw_if_index_set = 0;
11291 u32 sw_if_index = (u32) ~ 0;
11293 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11295 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11296 sw_if_index_set = 1;
11297 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11298 sw_if_index_set = 1;
11299 else if (unformat (i, "socket %s", &file_name))
11303 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
11305 else if (unformat (i, "server"))
11311 if (sw_if_index_set == 0)
11313 errmsg ("missing sw_if_index or interface name");
11317 if (file_name_set == 0)
11319 errmsg ("missing socket file name");
11323 if (vec_len (file_name) > 255)
11325 errmsg ("socket file name too long");
11328 vec_add1 (file_name, 0);
11330 M (MODIFY_VHOST_USER_IF, modify_vhost_user_if);
11332 mp->sw_if_index = ntohl (sw_if_index);
11333 mp->is_server = is_server;
11334 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
11335 vec_free (file_name);
11336 if (custom_dev_instance != ~0)
11339 mp->custom_dev_instance = ntohl (custom_dev_instance);
11349 api_delete_vhost_user_if (vat_main_t * vam)
11351 unformat_input_t *i = vam->input;
11352 vl_api_delete_vhost_user_if_t *mp;
11354 u32 sw_if_index = ~0;
11355 u8 sw_if_index_set = 0;
11357 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11359 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11360 sw_if_index_set = 1;
11361 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11362 sw_if_index_set = 1;
11367 if (sw_if_index_set == 0)
11369 errmsg ("missing sw_if_index or interface name");
11374 M (DELETE_VHOST_USER_IF, delete_vhost_user_if);
11376 mp->sw_if_index = ntohl (sw_if_index);
11384 static void vl_api_sw_interface_vhost_user_details_t_handler
11385 (vl_api_sw_interface_vhost_user_details_t * mp)
11387 vat_main_t *vam = &vat_main;
11389 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
11390 (char *) mp->interface_name,
11391 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
11392 clib_net_to_host_u64 (mp->features), mp->is_server,
11393 ntohl (mp->num_regions), (char *) mp->sock_filename);
11394 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
11397 static void vl_api_sw_interface_vhost_user_details_t_handler_json
11398 (vl_api_sw_interface_vhost_user_details_t * mp)
11400 vat_main_t *vam = &vat_main;
11401 vat_json_node_t *node = NULL;
11403 if (VAT_JSON_ARRAY != vam->json_tree.type)
11405 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11406 vat_json_init_array (&vam->json_tree);
11408 node = vat_json_array_add (&vam->json_tree);
11410 vat_json_init_object (node);
11411 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11412 vat_json_object_add_string_copy (node, "interface_name",
11413 mp->interface_name);
11414 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
11415 ntohl (mp->virtio_net_hdr_sz));
11416 vat_json_object_add_uint (node, "features",
11417 clib_net_to_host_u64 (mp->features));
11418 vat_json_object_add_uint (node, "is_server", mp->is_server);
11419 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
11420 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
11421 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
11425 api_sw_interface_vhost_user_dump (vat_main_t * vam)
11427 vl_api_sw_interface_vhost_user_dump_t *mp;
11430 "Interface name idx hdr_sz features server regions filename");
11432 /* Get list of vhost-user interfaces */
11433 M (SW_INTERFACE_VHOST_USER_DUMP, sw_interface_vhost_user_dump);
11436 /* Use a control ping for synchronization */
11438 vl_api_control_ping_t *mp;
11439 M (CONTROL_PING, control_ping);
11446 api_show_version (vat_main_t * vam)
11448 vl_api_show_version_t *mp;
11451 M (SHOW_VERSION, show_version);
11461 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
11463 unformat_input_t *line_input = vam->input;
11464 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
11466 ip4_address_t local4, remote4;
11467 ip6_address_t local6, remote6;
11469 u8 ipv4_set = 0, ipv6_set = 0;
11472 u32 encap_vrf_id = 0;
11473 u32 decap_vrf_id = 0;
11478 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11480 if (unformat (line_input, "del"))
11482 else if (unformat (line_input, "local %U",
11483 unformat_ip4_address, &local4))
11488 else if (unformat (line_input, "remote %U",
11489 unformat_ip4_address, &remote4))
11494 else if (unformat (line_input, "local %U",
11495 unformat_ip6_address, &local6))
11500 else if (unformat (line_input, "remote %U",
11501 unformat_ip6_address, &remote6))
11506 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11508 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
11510 else if (unformat (line_input, "vni %d", &vni))
11512 else if (unformat (line_input, "next-ip4"))
11514 else if (unformat (line_input, "next-ip6"))
11516 else if (unformat (line_input, "next-ethernet"))
11518 else if (unformat (line_input, "next-nsh"))
11522 errmsg ("parse error '%U'", format_unformat_error, line_input);
11527 if (local_set == 0)
11529 errmsg ("tunnel local address not specified");
11532 if (remote_set == 0)
11534 errmsg ("tunnel remote address not specified");
11537 if (ipv4_set && ipv6_set)
11539 errmsg ("both IPv4 and IPv6 addresses specified");
11545 errmsg ("vni not specified");
11549 M (VXLAN_GPE_ADD_DEL_TUNNEL, vxlan_gpe_add_del_tunnel);
11554 clib_memcpy (&mp->local, &local6, sizeof (local6));
11555 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
11559 clib_memcpy (&mp->local, &local4, sizeof (local4));
11560 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
11563 mp->encap_vrf_id = ntohl (encap_vrf_id);
11564 mp->decap_vrf_id = ntohl (decap_vrf_id);
11565 mp->protocol = protocol;
11566 mp->vni = ntohl (vni);
11567 mp->is_add = is_add;
11568 mp->is_ipv6 = ipv6_set;
11576 static void vl_api_vxlan_gpe_tunnel_details_t_handler
11577 (vl_api_vxlan_gpe_tunnel_details_t * mp)
11579 vat_main_t *vam = &vat_main;
11581 print (vam->ofp, "%11d%24U%24U%13d%12d%14d%14d",
11582 ntohl (mp->sw_if_index),
11583 format_ip46_address, &(mp->local[0]),
11584 format_ip46_address, &(mp->remote[0]),
11586 ntohl (mp->protocol),
11587 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
11590 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
11591 (vl_api_vxlan_gpe_tunnel_details_t * mp)
11593 vat_main_t *vam = &vat_main;
11594 vat_json_node_t *node = NULL;
11595 struct in_addr ip4;
11596 struct in6_addr ip6;
11598 if (VAT_JSON_ARRAY != vam->json_tree.type)
11600 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11601 vat_json_init_array (&vam->json_tree);
11603 node = vat_json_array_add (&vam->json_tree);
11605 vat_json_init_object (node);
11606 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11609 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
11610 vat_json_object_add_ip6 (node, "local", ip6);
11611 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
11612 vat_json_object_add_ip6 (node, "remote", ip6);
11616 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
11617 vat_json_object_add_ip4 (node, "local", ip4);
11618 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
11619 vat_json_object_add_ip4 (node, "remote", ip4);
11621 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
11622 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
11623 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
11624 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
11625 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
11629 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
11631 unformat_input_t *i = vam->input;
11632 vl_api_vxlan_gpe_tunnel_dump_t *mp;
11635 u8 sw_if_index_set = 0;
11637 /* Parse args required to build the message */
11638 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11640 if (unformat (i, "sw_if_index %d", &sw_if_index))
11641 sw_if_index_set = 1;
11646 if (sw_if_index_set == 0)
11651 if (!vam->json_output)
11653 print (vam->ofp, "%11s%24s%24s%13s%15s%14s%14s",
11654 "sw_if_index", "local", "remote", "vni",
11655 "protocol", "encap_vrf_id", "decap_vrf_id");
11658 /* Get list of vxlan-tunnel interfaces */
11659 M (VXLAN_GPE_TUNNEL_DUMP, vxlan_gpe_tunnel_dump);
11661 mp->sw_if_index = htonl (sw_if_index);
11665 /* Use a control ping for synchronization */
11667 vl_api_control_ping_t *mp;
11668 M (CONTROL_PING, control_ping);
11675 format_l2_fib_mac_address (u8 * s, va_list * args)
11677 u8 *a = va_arg (*args, u8 *);
11679 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
11680 a[2], a[3], a[4], a[5], a[6], a[7]);
11683 static void vl_api_l2_fib_table_entry_t_handler
11684 (vl_api_l2_fib_table_entry_t * mp)
11686 vat_main_t *vam = &vat_main;
11688 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
11690 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
11691 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
11695 static void vl_api_l2_fib_table_entry_t_handler_json
11696 (vl_api_l2_fib_table_entry_t * mp)
11698 vat_main_t *vam = &vat_main;
11699 vat_json_node_t *node = NULL;
11701 if (VAT_JSON_ARRAY != vam->json_tree.type)
11703 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11704 vat_json_init_array (&vam->json_tree);
11706 node = vat_json_array_add (&vam->json_tree);
11708 vat_json_init_object (node);
11709 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
11710 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
11711 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11712 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
11713 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
11714 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
11718 api_l2_fib_table_dump (vat_main_t * vam)
11720 unformat_input_t *i = vam->input;
11721 vl_api_l2_fib_table_dump_t *mp;
11726 /* Parse args required to build the message */
11727 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11729 if (unformat (i, "bd_id %d", &bd_id))
11735 if (bd_id_set == 0)
11737 errmsg ("missing bridge domain");
11741 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
11743 /* Get list of l2 fib entries */
11744 M (L2_FIB_TABLE_DUMP, l2_fib_table_dump);
11746 mp->bd_id = ntohl (bd_id);
11749 /* Use a control ping for synchronization */
11751 vl_api_control_ping_t *mp;
11752 M (CONTROL_PING, control_ping);
11760 api_interface_name_renumber (vat_main_t * vam)
11762 unformat_input_t *line_input = vam->input;
11763 vl_api_interface_name_renumber_t *mp;
11764 u32 sw_if_index = ~0;
11766 u32 new_show_dev_instance = ~0;
11768 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11770 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
11773 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11775 else if (unformat (line_input, "new_show_dev_instance %d",
11776 &new_show_dev_instance))
11782 if (sw_if_index == ~0)
11784 errmsg ("missing interface name or sw_if_index");
11788 if (new_show_dev_instance == ~0)
11790 errmsg ("missing new_show_dev_instance");
11794 M (INTERFACE_NAME_RENUMBER, interface_name_renumber);
11796 mp->sw_if_index = ntohl (sw_if_index);
11797 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
11804 api_want_ip4_arp_events (vat_main_t * vam)
11806 unformat_input_t *line_input = vam->input;
11807 vl_api_want_ip4_arp_events_t *mp;
11809 ip4_address_t address;
11810 int address_set = 0;
11811 u32 enable_disable = 1;
11813 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11815 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
11817 else if (unformat (line_input, "del"))
11818 enable_disable = 0;
11823 if (address_set == 0)
11825 errmsg ("missing addresses");
11829 M (WANT_IP4_ARP_EVENTS, want_ip4_arp_events);
11830 mp->enable_disable = enable_disable;
11831 mp->pid = getpid ();
11832 mp->address = address.as_u32;
11839 api_want_ip6_nd_events (vat_main_t * vam)
11841 unformat_input_t *line_input = vam->input;
11842 vl_api_want_ip6_nd_events_t *mp;
11844 ip6_address_t address;
11845 int address_set = 0;
11846 u32 enable_disable = 1;
11848 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11850 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
11852 else if (unformat (line_input, "del"))
11853 enable_disable = 0;
11858 if (address_set == 0)
11860 errmsg ("missing addresses");
11864 M (WANT_IP6_ND_EVENTS, want_ip6_nd_events);
11865 mp->enable_disable = enable_disable;
11866 mp->pid = getpid ();
11867 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
11874 api_input_acl_set_interface (vat_main_t * vam)
11876 unformat_input_t *i = vam->input;
11877 vl_api_input_acl_set_interface_t *mp;
11880 int sw_if_index_set;
11881 u32 ip4_table_index = ~0;
11882 u32 ip6_table_index = ~0;
11883 u32 l2_table_index = ~0;
11886 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11888 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11889 sw_if_index_set = 1;
11890 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11891 sw_if_index_set = 1;
11892 else if (unformat (i, "del"))
11894 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11896 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11898 else if (unformat (i, "l2-table %d", &l2_table_index))
11902 clib_warning ("parse error '%U'", format_unformat_error, i);
11907 if (sw_if_index_set == 0)
11909 errmsg ("missing interface name or sw_if_index");
11913 M (INPUT_ACL_SET_INTERFACE, input_acl_set_interface);
11915 mp->sw_if_index = ntohl (sw_if_index);
11916 mp->ip4_table_index = ntohl (ip4_table_index);
11917 mp->ip6_table_index = ntohl (ip6_table_index);
11918 mp->l2_table_index = ntohl (l2_table_index);
11919 mp->is_add = is_add;
11928 api_ip_address_dump (vat_main_t * vam)
11930 unformat_input_t *i = vam->input;
11931 vl_api_ip_address_dump_t *mp;
11932 u32 sw_if_index = ~0;
11933 u8 sw_if_index_set = 0;
11938 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11940 if (unformat (i, "sw_if_index %d", &sw_if_index))
11941 sw_if_index_set = 1;
11943 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11944 sw_if_index_set = 1;
11945 else if (unformat (i, "ipv4"))
11947 else if (unformat (i, "ipv6"))
11953 if (ipv4_set && ipv6_set)
11955 errmsg ("ipv4 and ipv6 flags cannot be both set");
11959 if ((!ipv4_set) && (!ipv6_set))
11961 errmsg ("no ipv4 nor ipv6 flag set");
11965 if (sw_if_index_set == 0)
11967 errmsg ("missing interface name or sw_if_index");
11971 vam->current_sw_if_index = sw_if_index;
11972 vam->is_ipv6 = ipv6_set;
11974 M (IP_ADDRESS_DUMP, ip_address_dump);
11975 mp->sw_if_index = ntohl (sw_if_index);
11976 mp->is_ipv6 = ipv6_set;
11979 /* Use a control ping for synchronization */
11981 vl_api_control_ping_t *mp;
11982 M (CONTROL_PING, control_ping);
11989 api_ip_dump (vat_main_t * vam)
11991 vl_api_ip_dump_t *mp;
11992 unformat_input_t *in = vam->input;
11999 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
12001 if (unformat (in, "ipv4"))
12003 else if (unformat (in, "ipv6"))
12009 if (ipv4_set && ipv6_set)
12011 errmsg ("ipv4 and ipv6 flags cannot be both set");
12015 if ((!ipv4_set) && (!ipv6_set))
12017 errmsg ("no ipv4 nor ipv6 flag set");
12021 is_ipv6 = ipv6_set;
12022 vam->is_ipv6 = is_ipv6;
12024 /* free old data */
12025 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
12027 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
12029 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
12031 M (IP_DUMP, ip_dump);
12032 mp->is_ipv6 = ipv6_set;
12035 /* Use a control ping for synchronization */
12037 vl_api_control_ping_t *mp;
12038 M (CONTROL_PING, control_ping);
12045 api_ipsec_spd_add_del (vat_main_t * vam)
12047 unformat_input_t *i = vam->input;
12048 vl_api_ipsec_spd_add_del_t *mp;
12053 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12055 if (unformat (i, "spd_id %d", &spd_id))
12057 else if (unformat (i, "del"))
12061 clib_warning ("parse error '%U'", format_unformat_error, i);
12067 errmsg ("spd_id must be set");
12071 M (IPSEC_SPD_ADD_DEL, ipsec_spd_add_del);
12073 mp->spd_id = ntohl (spd_id);
12074 mp->is_add = is_add;
12083 api_ipsec_interface_add_del_spd (vat_main_t * vam)
12085 unformat_input_t *i = vam->input;
12086 vl_api_ipsec_interface_add_del_spd_t *mp;
12089 u8 sw_if_index_set = 0;
12090 u32 spd_id = (u32) ~ 0;
12093 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12095 if (unformat (i, "del"))
12097 else if (unformat (i, "spd_id %d", &spd_id))
12100 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12101 sw_if_index_set = 1;
12102 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12103 sw_if_index_set = 1;
12106 clib_warning ("parse error '%U'", format_unformat_error, i);
12112 if (spd_id == (u32) ~ 0)
12114 errmsg ("spd_id must be set");
12118 if (sw_if_index_set == 0)
12120 errmsg ("missing interface name or sw_if_index");
12124 M (IPSEC_INTERFACE_ADD_DEL_SPD, ipsec_interface_add_del_spd);
12126 mp->spd_id = ntohl (spd_id);
12127 mp->sw_if_index = ntohl (sw_if_index);
12128 mp->is_add = is_add;
12137 api_ipsec_spd_add_del_entry (vat_main_t * vam)
12139 unformat_input_t *i = vam->input;
12140 vl_api_ipsec_spd_add_del_entry_t *mp;
12142 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
12143 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
12145 u32 rport_start = 0, rport_stop = (u32) ~ 0;
12146 u32 lport_start = 0, lport_stop = (u32) ~ 0;
12147 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
12148 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
12150 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
12151 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
12152 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
12153 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
12154 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
12155 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
12157 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12159 if (unformat (i, "del"))
12161 if (unformat (i, "outbound"))
12163 if (unformat (i, "inbound"))
12165 else if (unformat (i, "spd_id %d", &spd_id))
12167 else if (unformat (i, "sa_id %d", &sa_id))
12169 else if (unformat (i, "priority %d", &priority))
12171 else if (unformat (i, "protocol %d", &protocol))
12173 else if (unformat (i, "lport_start %d", &lport_start))
12175 else if (unformat (i, "lport_stop %d", &lport_stop))
12177 else if (unformat (i, "rport_start %d", &rport_start))
12179 else if (unformat (i, "rport_stop %d", &rport_stop))
12183 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
12189 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
12196 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
12202 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
12209 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
12215 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
12222 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
12228 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
12234 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
12236 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
12238 clib_warning ("unsupported action: 'resolve'");
12244 clib_warning ("parse error '%U'", format_unformat_error, i);
12250 M (IPSEC_SPD_ADD_DEL_ENTRY, ipsec_spd_add_del_entry);
12252 mp->spd_id = ntohl (spd_id);
12253 mp->priority = ntohl (priority);
12254 mp->is_outbound = is_outbound;
12256 mp->is_ipv6 = is_ipv6;
12257 if (is_ipv6 || is_ip_any)
12259 clib_memcpy (mp->remote_address_start, &raddr6_start,
12260 sizeof (ip6_address_t));
12261 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
12262 sizeof (ip6_address_t));
12263 clib_memcpy (mp->local_address_start, &laddr6_start,
12264 sizeof (ip6_address_t));
12265 clib_memcpy (mp->local_address_stop, &laddr6_stop,
12266 sizeof (ip6_address_t));
12270 clib_memcpy (mp->remote_address_start, &raddr4_start,
12271 sizeof (ip4_address_t));
12272 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
12273 sizeof (ip4_address_t));
12274 clib_memcpy (mp->local_address_start, &laddr4_start,
12275 sizeof (ip4_address_t));
12276 clib_memcpy (mp->local_address_stop, &laddr4_stop,
12277 sizeof (ip4_address_t));
12279 mp->protocol = (u8) protocol;
12280 mp->local_port_start = ntohs ((u16) lport_start);
12281 mp->local_port_stop = ntohs ((u16) lport_stop);
12282 mp->remote_port_start = ntohs ((u16) rport_start);
12283 mp->remote_port_stop = ntohs ((u16) rport_stop);
12284 mp->policy = (u8) policy;
12285 mp->sa_id = ntohl (sa_id);
12286 mp->is_add = is_add;
12287 mp->is_ip_any = is_ip_any;
12295 api_ipsec_sad_add_del_entry (vat_main_t * vam)
12297 unformat_input_t *i = vam->input;
12298 vl_api_ipsec_sad_add_del_entry_t *mp;
12300 u32 sad_id = 0, spi = 0;
12301 u8 *ck = 0, *ik = 0;
12304 u8 protocol = IPSEC_PROTOCOL_AH;
12305 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
12306 u32 crypto_alg = 0, integ_alg = 0;
12307 ip4_address_t tun_src4;
12308 ip4_address_t tun_dst4;
12309 ip6_address_t tun_src6;
12310 ip6_address_t tun_dst6;
12312 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12314 if (unformat (i, "del"))
12316 else if (unformat (i, "sad_id %d", &sad_id))
12318 else if (unformat (i, "spi %d", &spi))
12320 else if (unformat (i, "esp"))
12321 protocol = IPSEC_PROTOCOL_ESP;
12322 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
12325 is_tunnel_ipv6 = 0;
12327 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
12330 is_tunnel_ipv6 = 0;
12332 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
12335 is_tunnel_ipv6 = 1;
12337 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
12340 is_tunnel_ipv6 = 1;
12344 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
12346 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
12347 crypto_alg >= IPSEC_CRYPTO_N_ALG)
12349 clib_warning ("unsupported crypto-alg: '%U'",
12350 format_ipsec_crypto_alg, crypto_alg);
12354 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
12358 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
12360 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
12361 integ_alg >= IPSEC_INTEG_N_ALG)
12363 clib_warning ("unsupported integ-alg: '%U'",
12364 format_ipsec_integ_alg, integ_alg);
12368 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
12372 clib_warning ("parse error '%U'", format_unformat_error, i);
12378 M (IPSEC_SAD_ADD_DEL_ENTRY, ipsec_sad_add_del_entry);
12380 mp->sad_id = ntohl (sad_id);
12381 mp->is_add = is_add;
12382 mp->protocol = protocol;
12383 mp->spi = ntohl (spi);
12384 mp->is_tunnel = is_tunnel;
12385 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
12386 mp->crypto_algorithm = crypto_alg;
12387 mp->integrity_algorithm = integ_alg;
12388 mp->crypto_key_length = vec_len (ck);
12389 mp->integrity_key_length = vec_len (ik);
12391 if (mp->crypto_key_length > sizeof (mp->crypto_key))
12392 mp->crypto_key_length = sizeof (mp->crypto_key);
12394 if (mp->integrity_key_length > sizeof (mp->integrity_key))
12395 mp->integrity_key_length = sizeof (mp->integrity_key);
12398 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
12400 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
12404 if (is_tunnel_ipv6)
12406 clib_memcpy (mp->tunnel_src_address, &tun_src6,
12407 sizeof (ip6_address_t));
12408 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
12409 sizeof (ip6_address_t));
12413 clib_memcpy (mp->tunnel_src_address, &tun_src4,
12414 sizeof (ip4_address_t));
12415 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
12416 sizeof (ip4_address_t));
12427 api_ipsec_sa_set_key (vat_main_t * vam)
12429 unformat_input_t *i = vam->input;
12430 vl_api_ipsec_sa_set_key_t *mp;
12433 u8 *ck = 0, *ik = 0;
12435 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12437 if (unformat (i, "sa_id %d", &sa_id))
12439 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
12441 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
12445 clib_warning ("parse error '%U'", format_unformat_error, i);
12450 M (IPSEC_SA_SET_KEY, ipsec_set_sa_key);
12452 mp->sa_id = ntohl (sa_id);
12453 mp->crypto_key_length = vec_len (ck);
12454 mp->integrity_key_length = vec_len (ik);
12456 if (mp->crypto_key_length > sizeof (mp->crypto_key))
12457 mp->crypto_key_length = sizeof (mp->crypto_key);
12459 if (mp->integrity_key_length > sizeof (mp->integrity_key))
12460 mp->integrity_key_length = sizeof (mp->integrity_key);
12463 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
12465 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
12474 api_ikev2_profile_add_del (vat_main_t * vam)
12476 unformat_input_t *i = vam->input;
12477 vl_api_ikev2_profile_add_del_t *mp;
12482 const char *valid_chars = "a-zA-Z0-9_";
12484 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12486 if (unformat (i, "del"))
12488 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12489 vec_add1 (name, 0);
12492 errmsg ("parse error '%U'", format_unformat_error, i);
12497 if (!vec_len (name))
12499 errmsg ("profile name must be specified");
12503 if (vec_len (name) > 64)
12505 errmsg ("profile name too long");
12509 M (IKEV2_PROFILE_ADD_DEL, ikev2_profile_add_del);
12511 clib_memcpy (mp->name, name, vec_len (name));
12512 mp->is_add = is_add;
12522 api_ikev2_profile_set_auth (vat_main_t * vam)
12524 unformat_input_t *i = vam->input;
12525 vl_api_ikev2_profile_set_auth_t *mp;
12529 u32 auth_method = 0;
12532 const char *valid_chars = "a-zA-Z0-9_";
12534 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12536 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12537 vec_add1 (name, 0);
12538 else if (unformat (i, "auth_method %U",
12539 unformat_ikev2_auth_method, &auth_method))
12541 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
12543 else if (unformat (i, "auth_data %v", &data))
12547 errmsg ("parse error '%U'", format_unformat_error, i);
12552 if (!vec_len (name))
12554 errmsg ("profile name must be specified");
12558 if (vec_len (name) > 64)
12560 errmsg ("profile name too long");
12564 if (!vec_len (data))
12566 errmsg ("auth_data must be specified");
12572 errmsg ("auth_method must be specified");
12576 M (IKEV2_PROFILE_SET_AUTH, ikev2_profile_set_auth);
12578 mp->is_hex = is_hex;
12579 mp->auth_method = (u8) auth_method;
12580 mp->data_len = vec_len (data);
12581 clib_memcpy (mp->name, name, vec_len (name));
12582 clib_memcpy (mp->data, data, vec_len (data));
12593 api_ikev2_profile_set_id (vat_main_t * vam)
12595 unformat_input_t *i = vam->input;
12596 vl_api_ikev2_profile_set_id_t *mp;
12604 const char *valid_chars = "a-zA-Z0-9_";
12606 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12608 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12609 vec_add1 (name, 0);
12610 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
12612 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
12614 data = vec_new (u8, 4);
12615 clib_memcpy (data, ip4.as_u8, 4);
12617 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
12619 else if (unformat (i, "id_data %v", &data))
12621 else if (unformat (i, "local"))
12623 else if (unformat (i, "remote"))
12627 errmsg ("parse error '%U'", format_unformat_error, i);
12632 if (!vec_len (name))
12634 errmsg ("profile name must be specified");
12638 if (vec_len (name) > 64)
12640 errmsg ("profile name too long");
12644 if (!vec_len (data))
12646 errmsg ("id_data must be specified");
12652 errmsg ("id_type must be specified");
12656 M (IKEV2_PROFILE_SET_ID, ikev2_profile_set_id);
12658 mp->is_local = is_local;
12659 mp->id_type = (u8) id_type;
12660 mp->data_len = vec_len (data);
12661 clib_memcpy (mp->name, name, vec_len (name));
12662 clib_memcpy (mp->data, data, vec_len (data));
12673 api_ikev2_profile_set_ts (vat_main_t * vam)
12675 unformat_input_t *i = vam->input;
12676 vl_api_ikev2_profile_set_ts_t *mp;
12680 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
12681 ip4_address_t start_addr, end_addr;
12683 const char *valid_chars = "a-zA-Z0-9_";
12685 start_addr.as_u32 = 0;
12686 end_addr.as_u32 = (u32) ~ 0;
12688 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12690 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12691 vec_add1 (name, 0);
12692 else if (unformat (i, "protocol %d", &proto))
12694 else if (unformat (i, "start_port %d", &start_port))
12696 else if (unformat (i, "end_port %d", &end_port))
12699 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
12701 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
12703 else if (unformat (i, "local"))
12705 else if (unformat (i, "remote"))
12709 errmsg ("parse error '%U'", format_unformat_error, i);
12714 if (!vec_len (name))
12716 errmsg ("profile name must be specified");
12720 if (vec_len (name) > 64)
12722 errmsg ("profile name too long");
12726 M (IKEV2_PROFILE_SET_TS, ikev2_profile_set_ts);
12728 mp->is_local = is_local;
12729 mp->proto = (u8) proto;
12730 mp->start_port = (u16) start_port;
12731 mp->end_port = (u16) end_port;
12732 mp->start_addr = start_addr.as_u32;
12733 mp->end_addr = end_addr.as_u32;
12734 clib_memcpy (mp->name, name, vec_len (name));
12744 api_ikev2_set_local_key (vat_main_t * vam)
12746 unformat_input_t *i = vam->input;
12747 vl_api_ikev2_set_local_key_t *mp;
12751 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12753 if (unformat (i, "file %v", &file))
12754 vec_add1 (file, 0);
12757 errmsg ("parse error '%U'", format_unformat_error, i);
12762 if (!vec_len (file))
12764 errmsg ("RSA key file must be specified");
12768 if (vec_len (file) > 256)
12770 errmsg ("file name too long");
12774 M (IKEV2_SET_LOCAL_KEY, ikev2_set_local_key);
12776 clib_memcpy (mp->key_file, file, vec_len (file));
12789 api_map_add_domain (vat_main_t * vam)
12791 unformat_input_t *i = vam->input;
12792 vl_api_map_add_domain_t *mp;
12795 ip4_address_t ip4_prefix;
12796 ip6_address_t ip6_prefix;
12797 ip6_address_t ip6_src;
12798 u32 num_m_args = 0;
12799 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
12800 0, psid_length = 0;
12801 u8 is_translation = 0;
12803 u32 ip6_src_len = 128;
12805 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12807 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
12808 &ip4_prefix, &ip4_prefix_len))
12810 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
12811 &ip6_prefix, &ip6_prefix_len))
12815 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
12818 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
12820 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
12822 else if (unformat (i, "psid-offset %d", &psid_offset))
12824 else if (unformat (i, "psid-len %d", &psid_length))
12826 else if (unformat (i, "mtu %d", &mtu))
12828 else if (unformat (i, "map-t"))
12829 is_translation = 1;
12832 clib_warning ("parse error '%U'", format_unformat_error, i);
12837 if (num_m_args < 3)
12839 errmsg ("mandatory argument(s) missing");
12843 /* Construct the API message */
12844 M (MAP_ADD_DOMAIN, map_add_domain);
12846 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
12847 mp->ip4_prefix_len = ip4_prefix_len;
12849 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
12850 mp->ip6_prefix_len = ip6_prefix_len;
12852 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
12853 mp->ip6_src_prefix_len = ip6_src_len;
12855 mp->ea_bits_len = ea_bits_len;
12856 mp->psid_offset = psid_offset;
12857 mp->psid_length = psid_length;
12858 mp->is_translation = is_translation;
12859 mp->mtu = htons (mtu);
12864 /* Wait for a reply, return good/bad news */
12869 api_map_del_domain (vat_main_t * vam)
12871 unformat_input_t *i = vam->input;
12872 vl_api_map_del_domain_t *mp;
12875 u32 num_m_args = 0;
12878 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12880 if (unformat (i, "index %d", &index))
12884 clib_warning ("parse error '%U'", format_unformat_error, i);
12889 if (num_m_args != 1)
12891 errmsg ("mandatory argument(s) missing");
12895 /* Construct the API message */
12896 M (MAP_DEL_DOMAIN, map_del_domain);
12898 mp->index = ntohl (index);
12903 /* Wait for a reply, return good/bad news */
12908 api_map_add_del_rule (vat_main_t * vam)
12910 unformat_input_t *i = vam->input;
12911 vl_api_map_add_del_rule_t *mp;
12914 ip6_address_t ip6_dst;
12915 u32 num_m_args = 0, index, psid = 0;
12917 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12919 if (unformat (i, "index %d", &index))
12921 else if (unformat (i, "psid %d", &psid))
12923 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
12925 else if (unformat (i, "del"))
12931 clib_warning ("parse error '%U'", format_unformat_error, i);
12936 /* Construct the API message */
12937 M (MAP_ADD_DEL_RULE, map_add_del_rule);
12939 mp->index = ntohl (index);
12940 mp->is_add = is_add;
12941 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
12942 mp->psid = ntohs (psid);
12947 /* Wait for a reply, return good/bad news */
12952 api_map_domain_dump (vat_main_t * vam)
12954 vl_api_map_domain_dump_t *mp;
12957 /* Construct the API message */
12958 M (MAP_DOMAIN_DUMP, map_domain_dump);
12963 /* Use a control ping for synchronization */
12965 vl_api_control_ping_t *mp;
12966 M (CONTROL_PING, control_ping);
12973 api_map_rule_dump (vat_main_t * vam)
12975 unformat_input_t *i = vam->input;
12976 vl_api_map_rule_dump_t *mp;
12978 u32 domain_index = ~0;
12980 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12982 if (unformat (i, "index %u", &domain_index))
12988 if (domain_index == ~0)
12990 clib_warning ("parse error: domain index expected");
12994 /* Construct the API message */
12995 M (MAP_RULE_DUMP, map_rule_dump);
12997 mp->domain_index = htonl (domain_index);
13002 /* Use a control ping for synchronization */
13004 vl_api_control_ping_t *mp;
13005 M (CONTROL_PING, control_ping);
13011 static void vl_api_map_add_domain_reply_t_handler
13012 (vl_api_map_add_domain_reply_t * mp)
13014 vat_main_t *vam = &vat_main;
13015 i32 retval = ntohl (mp->retval);
13017 if (vam->async_mode)
13019 vam->async_errors += (retval < 0);
13023 vam->retval = retval;
13024 vam->result_ready = 1;
13028 static void vl_api_map_add_domain_reply_t_handler_json
13029 (vl_api_map_add_domain_reply_t * mp)
13031 vat_main_t *vam = &vat_main;
13032 vat_json_node_t node;
13034 vat_json_init_object (&node);
13035 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
13036 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
13038 vat_json_print (vam->ofp, &node);
13039 vat_json_free (&node);
13041 vam->retval = ntohl (mp->retval);
13042 vam->result_ready = 1;
13046 api_get_first_msg_id (vat_main_t * vam)
13048 vl_api_get_first_msg_id_t *mp;
13050 unformat_input_t *i = vam->input;
13054 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13056 if (unformat (i, "client %s", &name))
13064 errmsg ("missing client name");
13067 vec_add1 (name, 0);
13069 if (vec_len (name) > 63)
13071 errmsg ("client name too long");
13075 M (GET_FIRST_MSG_ID, get_first_msg_id);
13076 clib_memcpy (mp->name, name, vec_len (name));
13084 api_cop_interface_enable_disable (vat_main_t * vam)
13086 unformat_input_t *line_input = vam->input;
13087 vl_api_cop_interface_enable_disable_t *mp;
13089 u32 sw_if_index = ~0;
13090 u8 enable_disable = 1;
13092 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13094 if (unformat (line_input, "disable"))
13095 enable_disable = 0;
13096 if (unformat (line_input, "enable"))
13097 enable_disable = 1;
13098 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
13099 vam, &sw_if_index))
13101 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13107 if (sw_if_index == ~0)
13109 errmsg ("missing interface name or sw_if_index");
13113 /* Construct the API message */
13114 M (COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable);
13115 mp->sw_if_index = ntohl (sw_if_index);
13116 mp->enable_disable = enable_disable;
13120 /* Wait for the reply */
13125 api_cop_whitelist_enable_disable (vat_main_t * vam)
13127 unformat_input_t *line_input = vam->input;
13128 vl_api_cop_whitelist_enable_disable_t *mp;
13130 u32 sw_if_index = ~0;
13131 u8 ip4 = 0, ip6 = 0, default_cop = 0;
13134 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13136 if (unformat (line_input, "ip4"))
13138 else if (unformat (line_input, "ip6"))
13140 else if (unformat (line_input, "default"))
13142 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
13143 vam, &sw_if_index))
13145 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13147 else if (unformat (line_input, "fib-id %d", &fib_id))
13153 if (sw_if_index == ~0)
13155 errmsg ("missing interface name or sw_if_index");
13159 /* Construct the API message */
13160 M (COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable);
13161 mp->sw_if_index = ntohl (sw_if_index);
13162 mp->fib_id = ntohl (fib_id);
13165 mp->default_cop = default_cop;
13169 /* Wait for the reply */
13174 api_get_node_graph (vat_main_t * vam)
13176 vl_api_get_node_graph_t *mp;
13179 M (GET_NODE_GRAPH, get_node_graph);
13183 /* Wait for the reply */
13188 /** Used for parsing LISP eids */
13189 typedef CLIB_PACKED(struct{
13190 u8 addr[16]; /**< eid address */
13191 u32 len; /**< prefix length if IP */
13192 u8 type; /**< type of eid */
13197 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
13199 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
13201 memset (a, 0, sizeof (a[0]));
13203 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
13205 a->type = 0; /* ipv4 type */
13207 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
13209 a->type = 1; /* ipv6 type */
13211 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
13213 a->type = 2; /* mac type */
13220 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
13229 lisp_eid_size_vat (u8 type)
13244 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
13246 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
13250 /** Used for transferring locators via VPP API */
13251 typedef CLIB_PACKED(struct
13253 u32 sw_if_index; /**< locator sw_if_index */
13254 u8 priority; /**< locator priority */
13255 u8 weight; /**< locator weight */
13260 api_lisp_add_del_locator_set (vat_main_t * vam)
13262 unformat_input_t *input = vam->input;
13263 vl_api_lisp_add_del_locator_set_t *mp;
13266 u8 *locator_set_name = NULL;
13267 u8 locator_set_name_set = 0;
13268 ls_locator_t locator, *locators = 0;
13269 u32 sw_if_index, priority, weight;
13272 /* Parse args required to build the message */
13273 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13275 if (unformat (input, "del"))
13279 else if (unformat (input, "locator-set %s", &locator_set_name))
13281 locator_set_name_set = 1;
13283 else if (unformat (input, "sw_if_index %u p %u w %u",
13284 &sw_if_index, &priority, &weight))
13286 locator.sw_if_index = htonl (sw_if_index);
13287 locator.priority = priority;
13288 locator.weight = weight;
13289 vec_add1 (locators, locator);
13293 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
13294 &sw_if_index, &priority, &weight))
13296 locator.sw_if_index = htonl (sw_if_index);
13297 locator.priority = priority;
13298 locator.weight = weight;
13299 vec_add1 (locators, locator);
13305 if (locator_set_name_set == 0)
13307 errmsg ("missing locator-set name");
13308 vec_free (locators);
13312 if (vec_len (locator_set_name) > 64)
13314 errmsg ("locator-set name too long");
13315 vec_free (locator_set_name);
13316 vec_free (locators);
13319 vec_add1 (locator_set_name, 0);
13321 data_len = sizeof (ls_locator_t) * vec_len (locators);
13323 /* Construct the API message */
13324 M2 (LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set, data_len);
13326 mp->is_add = is_add;
13327 clib_memcpy (mp->locator_set_name, locator_set_name,
13328 vec_len (locator_set_name));
13329 vec_free (locator_set_name);
13331 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
13333 clib_memcpy (mp->locators, locators, data_len);
13334 vec_free (locators);
13339 /* Wait for a reply... */
13347 api_lisp_add_del_locator (vat_main_t * vam)
13349 unformat_input_t *input = vam->input;
13350 vl_api_lisp_add_del_locator_t *mp;
13352 u32 tmp_if_index = ~0;
13353 u32 sw_if_index = ~0;
13354 u8 sw_if_index_set = 0;
13355 u8 sw_if_index_if_name_set = 0;
13357 u8 priority_set = 0;
13361 u8 *locator_set_name = NULL;
13362 u8 locator_set_name_set = 0;
13364 /* Parse args required to build the message */
13365 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13367 if (unformat (input, "del"))
13371 else if (unformat (input, "locator-set %s", &locator_set_name))
13373 locator_set_name_set = 1;
13375 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
13378 sw_if_index_if_name_set = 1;
13379 sw_if_index = tmp_if_index;
13381 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
13383 sw_if_index_set = 1;
13384 sw_if_index = tmp_if_index;
13386 else if (unformat (input, "p %d", &priority))
13390 else if (unformat (input, "w %d", &weight))
13398 if (locator_set_name_set == 0)
13400 errmsg ("missing locator-set name");
13404 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
13406 errmsg ("missing sw_if_index");
13407 vec_free (locator_set_name);
13411 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
13413 errmsg ("cannot use both params interface name and sw_if_index");
13414 vec_free (locator_set_name);
13418 if (priority_set == 0)
13420 errmsg ("missing locator-set priority");
13421 vec_free (locator_set_name);
13425 if (weight_set == 0)
13427 errmsg ("missing locator-set weight");
13428 vec_free (locator_set_name);
13432 if (vec_len (locator_set_name) > 64)
13434 errmsg ("locator-set name too long");
13435 vec_free (locator_set_name);
13438 vec_add1 (locator_set_name, 0);
13440 /* Construct the API message */
13441 M (LISP_ADD_DEL_LOCATOR, lisp_add_del_locator);
13443 mp->is_add = is_add;
13444 mp->sw_if_index = ntohl (sw_if_index);
13445 mp->priority = priority;
13446 mp->weight = weight;
13447 clib_memcpy (mp->locator_set_name, locator_set_name,
13448 vec_len (locator_set_name));
13449 vec_free (locator_set_name);
13454 /* Wait for a reply... */
13462 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
13464 u32 *key_id = va_arg (*args, u32 *);
13467 if (unformat (input, "%s", &s))
13469 if (!strcmp ((char *) s, "sha1"))
13470 key_id[0] = HMAC_SHA_1_96;
13471 else if (!strcmp ((char *) s, "sha256"))
13472 key_id[0] = HMAC_SHA_256_128;
13475 clib_warning ("invalid key_id: '%s'", s);
13476 key_id[0] = HMAC_NO_KEY;
13487 api_lisp_add_del_local_eid (vat_main_t * vam)
13489 unformat_input_t *input = vam->input;
13490 vl_api_lisp_add_del_local_eid_t *mp;
13494 lisp_eid_vat_t _eid, *eid = &_eid;
13495 u8 *locator_set_name = 0;
13496 u8 locator_set_name_set = 0;
13501 /* Parse args required to build the message */
13502 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13504 if (unformat (input, "del"))
13508 else if (unformat (input, "vni %d", &vni))
13512 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
13516 else if (unformat (input, "locator-set %s", &locator_set_name))
13518 locator_set_name_set = 1;
13520 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
13522 else if (unformat (input, "secret-key %_%v%_", &key))
13528 if (locator_set_name_set == 0)
13530 errmsg ("missing locator-set name");
13536 errmsg ("EID address not set!");
13537 vec_free (locator_set_name);
13541 if (key && (0 == key_id))
13543 errmsg ("invalid key_id!");
13547 if (vec_len (key) > 64)
13549 errmsg ("key too long");
13554 if (vec_len (locator_set_name) > 64)
13556 errmsg ("locator-set name too long");
13557 vec_free (locator_set_name);
13560 vec_add1 (locator_set_name, 0);
13562 /* Construct the API message */
13563 M (LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid);
13565 mp->is_add = is_add;
13566 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
13567 mp->eid_type = eid->type;
13568 mp->prefix_len = eid->len;
13569 mp->vni = clib_host_to_net_u32 (vni);
13570 mp->key_id = clib_host_to_net_u16 (key_id);
13571 clib_memcpy (mp->locator_set_name, locator_set_name,
13572 vec_len (locator_set_name));
13573 clib_memcpy (mp->key, key, vec_len (key));
13575 vec_free (locator_set_name);
13581 /* Wait for a reply... */
13589 /** Used for transferring locators via VPP API */
13590 typedef CLIB_PACKED(struct
13592 u8 is_ip4; /**< is locator an IPv4 address? */
13593 u8 priority; /**< locator priority */
13594 u8 weight; /**< locator weight */
13595 u8 addr[16]; /**< IPv4/IPv6 address */
13600 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
13602 u32 dp_table = 0, vni = 0;;
13603 unformat_input_t *input = vam->input;
13604 vl_api_lisp_gpe_add_del_fwd_entry_t *mp;
13607 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
13608 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
13609 u8 rmt_eid_set = 0, lcl_eid_set = 0;
13610 u32 action = ~0, w;
13611 ip4_address_t rmt_rloc4, lcl_rloc4;
13612 ip6_address_t rmt_rloc6, lcl_rloc6;
13613 vl_api_lisp_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc =
13616 memset (&rloc, 0, sizeof (rloc));
13618 /* Parse args required to build the message */
13619 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13621 if (unformat (input, "del"))
13623 else if (unformat (input, "add"))
13625 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
13629 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
13633 else if (unformat (input, "vrf %d", &dp_table))
13635 else if (unformat (input, "bd %d", &dp_table))
13637 else if (unformat (input, "vni %d", &vni))
13639 else if (unformat (input, "w %d", &w))
13643 errmsg ("No RLOC configured for setting priority/weight!");
13646 curr_rloc->weight = w;
13648 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
13649 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
13653 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
13655 vec_add1 (lcl_locs, rloc);
13657 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
13658 vec_add1 (rmt_locs, rloc);
13659 /* weight saved in rmt loc */
13660 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
13662 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
13663 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
13666 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
13668 vec_add1 (lcl_locs, rloc);
13670 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
13671 vec_add1 (rmt_locs, rloc);
13672 /* weight saved in rmt loc */
13673 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
13675 else if (unformat (input, "action %d", &action))
13681 clib_warning ("parse error '%U'", format_unformat_error, input);
13688 errmsg ("remote eid addresses not set");
13692 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
13694 errmsg ("eid types don't match");
13698 if (0 == rmt_locs && (u32) ~ 0 == action)
13700 errmsg ("action not set for negative mapping");
13704 /* Construct the API message */
13705 M2 (LISP_GPE_ADD_DEL_FWD_ENTRY, lisp_gpe_add_del_fwd_entry,
13706 sizeof (vl_api_lisp_gpe_locator_t) * vec_len (rmt_locs) * 2);
13708 mp->is_add = is_add;
13709 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
13710 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
13711 mp->eid_type = rmt_eid->type;
13712 mp->dp_table = clib_host_to_net_u32 (dp_table);
13713 mp->vni = clib_host_to_net_u32 (vni);
13714 mp->rmt_len = rmt_eid->len;
13715 mp->lcl_len = lcl_eid->len;
13716 mp->action = action;
13718 if (0 != rmt_locs && 0 != lcl_locs)
13720 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
13721 clib_memcpy (mp->locs, lcl_locs,
13722 (sizeof (vl_api_lisp_gpe_locator_t) * vec_len (lcl_locs)));
13724 u32 offset = sizeof (vl_api_lisp_gpe_locator_t) * vec_len (lcl_locs);
13725 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
13726 (sizeof (vl_api_lisp_gpe_locator_t) * vec_len (rmt_locs)));
13728 vec_free (lcl_locs);
13729 vec_free (rmt_locs);
13734 /* Wait for a reply... */
13742 api_lisp_add_del_map_server (vat_main_t * vam)
13744 unformat_input_t *input = vam->input;
13745 vl_api_lisp_add_del_map_server_t *mp;
13750 ip4_address_t ipv4;
13751 ip6_address_t ipv6;
13753 /* Parse args required to build the message */
13754 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13756 if (unformat (input, "del"))
13760 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
13764 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
13772 if (ipv4_set && ipv6_set)
13774 errmsg ("both eid v4 and v6 addresses set");
13778 if (!ipv4_set && !ipv6_set)
13780 errmsg ("eid addresses not set");
13784 /* Construct the API message */
13785 M (LISP_ADD_DEL_MAP_SERVER, lisp_add_del_map_server);
13787 mp->is_add = is_add;
13791 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
13796 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
13802 /* Wait for a reply... */
13810 api_lisp_add_del_map_resolver (vat_main_t * vam)
13812 unformat_input_t *input = vam->input;
13813 vl_api_lisp_add_del_map_resolver_t *mp;
13818 ip4_address_t ipv4;
13819 ip6_address_t ipv6;
13821 /* Parse args required to build the message */
13822 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13824 if (unformat (input, "del"))
13828 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
13832 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
13840 if (ipv4_set && ipv6_set)
13842 errmsg ("both eid v4 and v6 addresses set");
13846 if (!ipv4_set && !ipv6_set)
13848 errmsg ("eid addresses not set");
13852 /* Construct the API message */
13853 M (LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver);
13855 mp->is_add = is_add;
13859 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
13864 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
13870 /* Wait for a reply... */
13878 api_lisp_gpe_enable_disable (vat_main_t * vam)
13880 unformat_input_t *input = vam->input;
13881 vl_api_lisp_gpe_enable_disable_t *mp;
13886 /* Parse args required to build the message */
13887 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13889 if (unformat (input, "enable"))
13894 else if (unformat (input, "disable"))
13905 errmsg ("Value not set");
13909 /* Construct the API message */
13910 M (LISP_GPE_ENABLE_DISABLE, lisp_gpe_enable_disable);
13917 /* Wait for a reply... */
13925 api_lisp_rloc_probe_enable_disable (vat_main_t * vam)
13927 unformat_input_t *input = vam->input;
13928 vl_api_lisp_rloc_probe_enable_disable_t *mp;
13933 /* Parse args required to build the message */
13934 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13936 if (unformat (input, "enable"))
13941 else if (unformat (input, "disable"))
13949 errmsg ("Value not set");
13953 /* Construct the API message */
13954 M (LISP_RLOC_PROBE_ENABLE_DISABLE, lisp_rloc_probe_enable_disable);
13956 mp->is_enabled = is_en;
13961 /* Wait for a reply... */
13969 api_lisp_map_register_enable_disable (vat_main_t * vam)
13971 unformat_input_t *input = vam->input;
13972 vl_api_lisp_map_register_enable_disable_t *mp;
13977 /* Parse args required to build the message */
13978 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13980 if (unformat (input, "enable"))
13985 else if (unformat (input, "disable"))
13993 errmsg ("Value not set");
13997 /* Construct the API message */
13998 M (LISP_MAP_REGISTER_ENABLE_DISABLE, lisp_map_register_enable_disable);
14000 mp->is_enabled = is_en;
14005 /* Wait for a reply... */
14013 api_lisp_enable_disable (vat_main_t * vam)
14015 unformat_input_t *input = vam->input;
14016 vl_api_lisp_enable_disable_t *mp;
14021 /* Parse args required to build the message */
14022 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14024 if (unformat (input, "enable"))
14029 else if (unformat (input, "disable"))
14039 errmsg ("Value not set");
14043 /* Construct the API message */
14044 M (LISP_ENABLE_DISABLE, lisp_enable_disable);
14051 /* Wait for a reply... */
14059 api_show_lisp_map_register_state (vat_main_t * vam)
14062 vl_api_show_lisp_map_register_state_t *mp;
14064 M (SHOW_LISP_MAP_REGISTER_STATE, show_lisp_map_register_state);
14069 /* wait for reply */
14076 api_show_lisp_rloc_probe_state (vat_main_t * vam)
14079 vl_api_show_lisp_rloc_probe_state_t *mp;
14081 M (SHOW_LISP_RLOC_PROBE_STATE, show_lisp_rloc_probe_state);
14086 /* wait for reply */
14093 api_show_lisp_map_request_mode (vat_main_t * vam)
14096 vl_api_show_lisp_map_request_mode_t *mp;
14098 M (SHOW_LISP_MAP_REQUEST_MODE, show_lisp_map_request_mode);
14103 /* wait for reply */
14110 api_lisp_map_request_mode (vat_main_t * vam)
14113 unformat_input_t *input = vam->input;
14114 vl_api_lisp_map_request_mode_t *mp;
14117 /* Parse args required to build the message */
14118 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14120 if (unformat (input, "dst-only"))
14122 else if (unformat (input, "src-dst"))
14126 errmsg ("parse error '%U'", format_unformat_error, input);
14131 M (LISP_MAP_REQUEST_MODE, lisp_map_request_mode);
14138 /* wait for reply */
14146 * Enable/disable LISP proxy ITR.
14148 * @param vam vpp API test context
14149 * @return return code
14152 api_lisp_pitr_set_locator_set (vat_main_t * vam)
14155 u8 ls_name_set = 0;
14156 unformat_input_t *input = vam->input;
14157 vl_api_lisp_pitr_set_locator_set_t *mp;
14161 /* Parse args required to build the message */
14162 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14164 if (unformat (input, "del"))
14166 else if (unformat (input, "locator-set %s", &ls_name))
14170 errmsg ("parse error '%U'", format_unformat_error, input);
14177 errmsg ("locator-set name not set!");
14181 M (LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set);
14183 mp->is_add = is_add;
14184 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
14185 vec_free (ls_name);
14190 /* wait for reply */
14198 api_show_lisp_pitr (vat_main_t * vam)
14200 vl_api_show_lisp_pitr_t *mp;
14203 if (!vam->json_output)
14205 print (vam->ofp, "%=20s", "lisp status:");
14208 M (SHOW_LISP_PITR, show_lisp_pitr);
14212 /* Wait for a reply... */
14220 * Add/delete mapping between vni and vrf
14223 api_lisp_eid_table_add_del_map (vat_main_t * vam)
14226 unformat_input_t *input = vam->input;
14227 vl_api_lisp_eid_table_add_del_map_t *mp;
14228 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
14229 u32 vni, vrf, bd_index;
14231 /* Parse args required to build the message */
14232 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14234 if (unformat (input, "del"))
14236 else if (unformat (input, "vrf %d", &vrf))
14238 else if (unformat (input, "bd_index %d", &bd_index))
14240 else if (unformat (input, "vni %d", &vni))
14246 if (!vni_set || (!vrf_set && !bd_index_set))
14248 errmsg ("missing arguments!");
14252 if (vrf_set && bd_index_set)
14254 errmsg ("error: both vrf and bd entered!");
14258 M (LISP_EID_TABLE_ADD_DEL_MAP, lisp_eid_table_add_del_map);
14260 mp->is_add = is_add;
14261 mp->vni = htonl (vni);
14262 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
14263 mp->is_l2 = bd_index_set;
14268 /* wait for reply */
14276 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
14278 u32 *action = va_arg (*args, u32 *);
14281 if (unformat (input, "%s", &s))
14283 if (!strcmp ((char *) s, "no-action"))
14285 else if (!strcmp ((char *) s, "natively-forward"))
14287 else if (!strcmp ((char *) s, "send-map-request"))
14289 else if (!strcmp ((char *) s, "drop"))
14293 clib_warning ("invalid action: '%s'", s);
14305 * Add/del remote mapping to/from LISP control plane
14307 * @param vam vpp API test context
14308 * @return return code
14311 api_lisp_add_del_remote_mapping (vat_main_t * vam)
14313 unformat_input_t *input = vam->input;
14314 vl_api_lisp_add_del_remote_mapping_t *mp;
14317 lisp_eid_vat_t _eid, *eid = &_eid;
14318 lisp_eid_vat_t _seid, *seid = &_seid;
14319 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
14320 u32 action = ~0, p, w, data_len;
14321 ip4_address_t rloc4;
14322 ip6_address_t rloc6;
14323 rloc_t *rlocs = 0, rloc, *curr_rloc = 0;
14325 memset (&rloc, 0, sizeof (rloc));
14327 /* Parse args required to build the message */
14328 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14330 if (unformat (input, "del-all"))
14334 else if (unformat (input, "del"))
14338 else if (unformat (input, "add"))
14342 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
14346 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
14350 else if (unformat (input, "vni %d", &vni))
14354 else if (unformat (input, "p %d w %d", &p, &w))
14358 errmsg ("No RLOC configured for setting priority/weight!");
14361 curr_rloc->priority = p;
14362 curr_rloc->weight = w;
14364 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
14367 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
14368 vec_add1 (rlocs, rloc);
14369 curr_rloc = &rlocs[vec_len (rlocs) - 1];
14371 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
14374 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
14375 vec_add1 (rlocs, rloc);
14376 curr_rloc = &rlocs[vec_len (rlocs) - 1];
14378 else if (unformat (input, "action %U",
14379 unformat_negative_mapping_action, &action))
14385 clib_warning ("parse error '%U'", format_unformat_error, input);
14392 errmsg ("missing params!");
14396 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
14398 errmsg ("no action set for negative map-reply!");
14402 data_len = vec_len (rlocs) * sizeof (rloc_t);
14404 M2 (LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping, data_len);
14405 mp->is_add = is_add;
14406 mp->vni = htonl (vni);
14407 mp->action = (u8) action;
14408 mp->is_src_dst = seid_set;
14409 mp->eid_len = eid->len;
14410 mp->seid_len = seid->len;
14411 mp->del_all = del_all;
14412 mp->eid_type = eid->type;
14413 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
14414 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
14416 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
14417 clib_memcpy (mp->rlocs, rlocs, data_len);
14423 /* Wait for a reply... */
14431 * Add/del LISP adjacency. Saves mapping in LISP control plane and updates
14432 * forwarding entries in data-plane accordingly.
14434 * @param vam vpp API test context
14435 * @return return code
14438 api_lisp_add_del_adjacency (vat_main_t * vam)
14440 unformat_input_t *input = vam->input;
14441 vl_api_lisp_add_del_adjacency_t *mp;
14444 ip4_address_t leid4, reid4;
14445 ip6_address_t leid6, reid6;
14446 u8 reid_mac[6] = { 0 };
14447 u8 leid_mac[6] = { 0 };
14448 u8 reid_type, leid_type;
14449 u32 leid_len = 0, reid_len = 0, len;
14452 leid_type = reid_type = (u8) ~ 0;
14454 /* Parse args required to build the message */
14455 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14457 if (unformat (input, "del"))
14461 else if (unformat (input, "add"))
14465 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
14468 reid_type = 0; /* ipv4 */
14471 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
14474 reid_type = 1; /* ipv6 */
14477 else if (unformat (input, "reid %U", unformat_ethernet_address,
14480 reid_type = 2; /* mac */
14482 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
14485 leid_type = 0; /* ipv4 */
14488 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
14491 leid_type = 1; /* ipv6 */
14494 else if (unformat (input, "leid %U", unformat_ethernet_address,
14497 leid_type = 2; /* mac */
14499 else if (unformat (input, "vni %d", &vni))
14505 errmsg ("parse error '%U'", format_unformat_error, input);
14510 if ((u8) ~ 0 == reid_type)
14512 errmsg ("missing params!");
14516 if (leid_type != reid_type)
14518 errmsg ("remote and local EIDs are of different types!");
14522 M (LISP_ADD_DEL_ADJACENCY, lisp_add_del_adjacency);
14523 mp->is_add = is_add;
14524 mp->vni = htonl (vni);
14525 mp->leid_len = leid_len;
14526 mp->reid_len = reid_len;
14527 mp->eid_type = reid_type;
14529 switch (mp->eid_type)
14532 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
14533 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
14536 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
14537 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
14540 clib_memcpy (mp->leid, leid_mac, 6);
14541 clib_memcpy (mp->reid, reid_mac, 6);
14544 errmsg ("unknown EID type %d!", mp->eid_type);
14551 /* Wait for a reply... */
14559 api_lisp_gpe_add_del_iface (vat_main_t * vam)
14561 unformat_input_t *input = vam->input;
14562 vl_api_lisp_gpe_add_del_iface_t *mp;
14564 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
14565 u32 dp_table = 0, vni = 0;
14567 /* Parse args required to build the message */
14568 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14570 if (unformat (input, "up"))
14575 else if (unformat (input, "down"))
14580 else if (unformat (input, "table_id %d", &dp_table))
14584 else if (unformat (input, "bd_id %d", &dp_table))
14589 else if (unformat (input, "vni %d", &vni))
14597 if (action_set == 0)
14599 errmsg ("Action not set");
14602 if (dp_table_set == 0 || vni_set == 0)
14604 errmsg ("vni and dp_table must be set");
14608 /* Construct the API message */
14609 M (LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface);
14611 mp->is_add = is_add;
14612 mp->dp_table = dp_table;
14619 /* Wait for a reply... */
14627 * Add/del map request itr rlocs from LISP control plane and updates
14629 * @param vam vpp API test context
14630 * @return return code
14633 api_lisp_add_del_map_request_itr_rlocs (vat_main_t * vam)
14635 unformat_input_t *input = vam->input;
14636 vl_api_lisp_add_del_map_request_itr_rlocs_t *mp;
14638 u8 *locator_set_name = 0;
14639 u8 locator_set_name_set = 0;
14642 /* Parse args required to build the message */
14643 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14645 if (unformat (input, "del"))
14649 else if (unformat (input, "%_%v%_", &locator_set_name))
14651 locator_set_name_set = 1;
14655 clib_warning ("parse error '%U'", format_unformat_error, input);
14660 if (is_add && !locator_set_name_set)
14662 errmsg ("itr-rloc is not set!");
14666 if (is_add && vec_len (locator_set_name) > 64)
14668 errmsg ("itr-rloc locator-set name too long");
14669 vec_free (locator_set_name);
14673 M (LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, lisp_add_del_map_request_itr_rlocs);
14674 mp->is_add = is_add;
14677 clib_memcpy (mp->locator_set_name, locator_set_name,
14678 vec_len (locator_set_name));
14682 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
14684 vec_free (locator_set_name);
14689 /* Wait for a reply... */
14697 api_lisp_locator_dump (vat_main_t * vam)
14699 unformat_input_t *input = vam->input;
14700 vl_api_lisp_locator_dump_t *mp;
14702 u8 is_index_set = 0, is_name_set = 0;
14706 /* Parse args required to build the message */
14707 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14709 if (unformat (input, "ls_name %_%v%_", &ls_name))
14713 else if (unformat (input, "ls_index %d", &ls_index))
14719 errmsg ("parse error '%U'", format_unformat_error, input);
14724 if (!is_index_set && !is_name_set)
14726 errmsg ("error: expected one of index or name!");
14730 if (is_index_set && is_name_set)
14732 errmsg ("error: only one param expected!");
14736 if (vec_len (ls_name) > 62)
14738 errmsg ("error: locator set name too long!");
14742 if (!vam->json_output)
14744 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
14747 M (LISP_LOCATOR_DUMP, lisp_locator_dump);
14748 mp->is_index_set = is_index_set;
14751 mp->ls_index = clib_host_to_net_u32 (ls_index);
14754 vec_add1 (ls_name, 0);
14755 strncpy ((char *) mp->ls_name, (char *) ls_name,
14756 sizeof (mp->ls_name) - 1);
14762 /* Use a control ping for synchronization */
14764 vl_api_control_ping_t *mp;
14765 M (CONTROL_PING, control_ping);
14768 /* Wait for a reply... */
14776 api_lisp_locator_set_dump (vat_main_t * vam)
14778 vl_api_lisp_locator_set_dump_t *mp;
14779 unformat_input_t *input = vam->input;
14783 /* Parse args required to build the message */
14784 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14786 if (unformat (input, "local"))
14790 else if (unformat (input, "remote"))
14796 errmsg ("parse error '%U'", format_unformat_error, input);
14801 if (!vam->json_output)
14803 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
14806 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
14808 mp->filter = filter;
14813 /* Use a control ping for synchronization */
14815 vl_api_control_ping_t *mp;
14816 M (CONTROL_PING, control_ping);
14819 /* Wait for a reply... */
14827 api_lisp_eid_table_map_dump (vat_main_t * vam)
14831 unformat_input_t *input = vam->input;
14832 vl_api_lisp_eid_table_map_dump_t *mp;
14835 /* Parse args required to build the message */
14836 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14838 if (unformat (input, "l2"))
14843 else if (unformat (input, "l3"))
14850 errmsg ("parse error '%U'", format_unformat_error, input);
14857 errmsg ("expected one of 'l2' or 'l3' parameter!");
14861 if (!vam->json_output)
14863 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
14866 M (LISP_EID_TABLE_MAP_DUMP, lisp_eid_table_map_dump);
14872 /* Use a control ping for synchronization */
14874 vl_api_control_ping_t *mp;
14875 M (CONTROL_PING, control_ping);
14878 /* Wait for a reply... */
14886 api_lisp_eid_table_vni_dump (vat_main_t * vam)
14888 vl_api_lisp_eid_table_vni_dump_t *mp;
14891 if (!vam->json_output)
14893 print (vam->ofp, "VNI");
14896 M (LISP_EID_TABLE_VNI_DUMP, lisp_eid_table_vni_dump);
14901 /* Use a control ping for synchronization */
14903 vl_api_control_ping_t *mp;
14904 M (CONTROL_PING, control_ping);
14907 /* Wait for a reply... */
14915 api_lisp_eid_table_dump (vat_main_t * vam)
14917 unformat_input_t *i = vam->input;
14918 vl_api_lisp_eid_table_dump_t *mp;
14920 struct in_addr ip4;
14921 struct in6_addr ip6;
14923 u8 eid_type = ~0, eid_set = 0;
14924 u32 prefix_length = ~0, t, vni = 0;
14927 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14929 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
14935 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
14941 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
14946 else if (unformat (i, "vni %d", &t))
14950 else if (unformat (i, "local"))
14954 else if (unformat (i, "remote"))
14960 errmsg ("parse error '%U'", format_unformat_error, i);
14965 if (!vam->json_output)
14967 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
14968 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
14971 M (LISP_EID_TABLE_DUMP, lisp_eid_table_dump);
14973 mp->filter = filter;
14977 mp->vni = htonl (vni);
14978 mp->eid_type = eid_type;
14982 mp->prefix_length = prefix_length;
14983 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
14986 mp->prefix_length = prefix_length;
14987 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
14990 clib_memcpy (mp->eid, mac, sizeof (mac));
14993 errmsg ("unknown EID type %d!", eid_type);
15001 /* Use a control ping for synchronization */
15003 vl_api_control_ping_t *mp;
15004 M (CONTROL_PING, control_ping);
15008 /* Wait for a reply... */
15016 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
15018 unformat_input_t *i = vam->input;
15019 vl_api_lisp_gpe_fwd_entries_get_t *mp;
15024 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15026 if (unformat (i, "vni %d", &vni))
15032 errmsg ("parse error '%U'", format_unformat_error, i);
15039 errmsg ("vni not set!");
15043 if (!vam->json_output)
15045 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
15049 M (LISP_GPE_FWD_ENTRIES_GET, lisp_gpe_fwd_entries_get);
15050 mp->vni = clib_host_to_net_u32 (vni);
15055 /* Wait for a reply... */
15062 #define vl_api_lisp_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
15063 #define vl_api_lisp_gpe_fwd_entries_get_reply_t_print vl_noop_handler
15064 #define vl_api_lisp_gpe_fwd_entry_path_details_t_endian vl_noop_handler
15065 #define vl_api_lisp_gpe_fwd_entry_path_details_t_print vl_noop_handler
15068 api_lisp_adjacencies_get (vat_main_t * vam)
15070 unformat_input_t *i = vam->input;
15071 vl_api_lisp_adjacencies_get_t *mp;
15076 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15078 if (unformat (i, "vni %d", &vni))
15084 errmsg ("parse error '%U'", format_unformat_error, i);
15091 errmsg ("vni not set!");
15095 if (!vam->json_output)
15097 print (vam->ofp, "%s %40s", "leid", "reid");
15100 M (LISP_ADJACENCIES_GET, lisp_adjacencies_get);
15101 mp->vni = clib_host_to_net_u32 (vni);
15106 /* Wait for a reply... */
15114 api_lisp_map_server_dump (vat_main_t * vam)
15116 vl_api_lisp_map_server_dump_t *mp;
15119 if (!vam->json_output)
15121 print (vam->ofp, "%=20s", "Map server");
15124 M (LISP_MAP_SERVER_DUMP, lisp_map_server_dump);
15128 /* Use a control ping for synchronization */
15130 vl_api_control_ping_t *mp;
15131 M (CONTROL_PING, control_ping);
15134 /* Wait for a reply... */
15142 api_lisp_map_resolver_dump (vat_main_t * vam)
15144 vl_api_lisp_map_resolver_dump_t *mp;
15147 if (!vam->json_output)
15149 print (vam->ofp, "%=20s", "Map resolver");
15152 M (LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump);
15156 /* Use a control ping for synchronization */
15158 vl_api_control_ping_t *mp;
15159 M (CONTROL_PING, control_ping);
15162 /* Wait for a reply... */
15170 api_show_lisp_status (vat_main_t * vam)
15172 vl_api_show_lisp_status_t *mp;
15175 if (!vam->json_output)
15177 print (vam->ofp, "%-20s%-16s", "lisp status", "locator-set");
15180 M (SHOW_LISP_STATUS, show_lisp_status);
15183 /* Wait for a reply... */
15191 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
15193 vl_api_lisp_gpe_fwd_entry_path_dump_t *mp;
15195 unformat_input_t *i = vam->input;
15196 u32 fwd_entry_index = ~0;
15198 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15200 if (unformat (i, "index %d", &fwd_entry_index))
15206 if (~0 == fwd_entry_index)
15208 errmsg ("no index specified!");
15212 if (!vam->json_output)
15214 print (vam->ofp, "first line");
15217 M (LISP_GPE_FWD_ENTRY_PATH_DUMP, lisp_gpe_fwd_entry_path_dump);
15221 /* Use a control ping for synchronization */
15223 vl_api_control_ping_t *mp;
15224 M (CONTROL_PING, control_ping);
15227 /* Wait for a reply... */
15235 api_lisp_get_map_request_itr_rlocs (vat_main_t * vam)
15237 vl_api_lisp_get_map_request_itr_rlocs_t *mp;
15240 if (!vam->json_output)
15242 print (vam->ofp, "%=20s", "itr-rlocs:");
15245 M (LISP_GET_MAP_REQUEST_ITR_RLOCS, lisp_get_map_request_itr_rlocs);
15248 /* Wait for a reply... */
15256 api_af_packet_create (vat_main_t * vam)
15258 unformat_input_t *i = vam->input;
15259 vl_api_af_packet_create_t *mp;
15261 u8 *host_if_name = 0;
15263 u8 random_hw_addr = 1;
15265 memset (hw_addr, 0, sizeof (hw_addr));
15267 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15269 if (unformat (i, "name %s", &host_if_name))
15270 vec_add1 (host_if_name, 0);
15271 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
15272 random_hw_addr = 0;
15277 if (!vec_len (host_if_name))
15279 errmsg ("host-interface name must be specified");
15283 if (vec_len (host_if_name) > 64)
15285 errmsg ("host-interface name too long");
15289 M (AF_PACKET_CREATE, af_packet_create);
15291 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
15292 clib_memcpy (mp->hw_addr, hw_addr, 6);
15293 mp->use_random_hw_addr = random_hw_addr;
15294 vec_free (host_if_name);
15297 W2 (fprintf (vam->ofp, " new sw_if_index = %d ", vam->sw_if_index));
15303 api_af_packet_delete (vat_main_t * vam)
15305 unformat_input_t *i = vam->input;
15306 vl_api_af_packet_delete_t *mp;
15308 u8 *host_if_name = 0;
15310 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15312 if (unformat (i, "name %s", &host_if_name))
15313 vec_add1 (host_if_name, 0);
15318 if (!vec_len (host_if_name))
15320 errmsg ("host-interface name must be specified");
15324 if (vec_len (host_if_name) > 64)
15326 errmsg ("host-interface name too long");
15330 M (AF_PACKET_DELETE, af_packet_delete);
15332 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
15333 vec_free (host_if_name);
15342 api_policer_add_del (vat_main_t * vam)
15344 unformat_input_t *i = vam->input;
15345 vl_api_policer_add_del_t *mp;
15356 u8 color_aware = 0;
15357 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
15359 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
15360 conform_action.dscp = 0;
15361 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
15362 exceed_action.dscp = 0;
15363 violate_action.action_type = SSE2_QOS_ACTION_DROP;
15364 violate_action.dscp = 0;
15366 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15368 if (unformat (i, "del"))
15370 else if (unformat (i, "name %s", &name))
15371 vec_add1 (name, 0);
15372 else if (unformat (i, "cir %u", &cir))
15374 else if (unformat (i, "eir %u", &eir))
15376 else if (unformat (i, "cb %u", &cb))
15378 else if (unformat (i, "eb %u", &eb))
15380 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
15383 else if (unformat (i, "round_type %U", unformat_policer_round_type,
15386 else if (unformat (i, "type %U", unformat_policer_type, &type))
15388 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
15391 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
15394 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
15397 else if (unformat (i, "color-aware"))
15403 if (!vec_len (name))
15405 errmsg ("policer name must be specified");
15409 if (vec_len (name) > 64)
15411 errmsg ("policer name too long");
15415 M (POLICER_ADD_DEL, policer_add_del);
15417 clib_memcpy (mp->name, name, vec_len (name));
15419 mp->is_add = is_add;
15424 mp->rate_type = rate_type;
15425 mp->round_type = round_type;
15427 mp->conform_action_type = conform_action.action_type;
15428 mp->conform_dscp = conform_action.dscp;
15429 mp->exceed_action_type = exceed_action.action_type;
15430 mp->exceed_dscp = exceed_action.dscp;
15431 mp->violate_action_type = violate_action.action_type;
15432 mp->violate_dscp = violate_action.dscp;
15433 mp->color_aware = color_aware;
15442 api_policer_dump (vat_main_t * vam)
15444 unformat_input_t *i = vam->input;
15445 vl_api_policer_dump_t *mp;
15447 u8 *match_name = 0;
15448 u8 match_name_valid = 0;
15450 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15452 if (unformat (i, "name %s", &match_name))
15454 vec_add1 (match_name, 0);
15455 match_name_valid = 1;
15461 M (POLICER_DUMP, policer_dump);
15462 mp->match_name_valid = match_name_valid;
15463 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
15464 vec_free (match_name);
15468 /* Use a control ping for synchronization */
15470 vl_api_control_ping_t *mp;
15471 M (CONTROL_PING, control_ping);
15474 /* Wait for a reply... */
15482 api_policer_classify_set_interface (vat_main_t * vam)
15484 unformat_input_t *i = vam->input;
15485 vl_api_policer_classify_set_interface_t *mp;
15488 int sw_if_index_set;
15489 u32 ip4_table_index = ~0;
15490 u32 ip6_table_index = ~0;
15491 u32 l2_table_index = ~0;
15494 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15496 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15497 sw_if_index_set = 1;
15498 else if (unformat (i, "sw_if_index %d", &sw_if_index))
15499 sw_if_index_set = 1;
15500 else if (unformat (i, "del"))
15502 else if (unformat (i, "ip4-table %d", &ip4_table_index))
15504 else if (unformat (i, "ip6-table %d", &ip6_table_index))
15506 else if (unformat (i, "l2-table %d", &l2_table_index))
15510 clib_warning ("parse error '%U'", format_unformat_error, i);
15515 if (sw_if_index_set == 0)
15517 errmsg ("missing interface name or sw_if_index");
15521 M (POLICER_CLASSIFY_SET_INTERFACE, policer_classify_set_interface);
15523 mp->sw_if_index = ntohl (sw_if_index);
15524 mp->ip4_table_index = ntohl (ip4_table_index);
15525 mp->ip6_table_index = ntohl (ip6_table_index);
15526 mp->l2_table_index = ntohl (l2_table_index);
15527 mp->is_add = is_add;
15536 api_policer_classify_dump (vat_main_t * vam)
15538 unformat_input_t *i = vam->input;
15539 vl_api_policer_classify_dump_t *mp;
15541 u8 type = POLICER_CLASSIFY_N_TABLES;
15543 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
15547 errmsg ("classify table type must be specified");
15551 if (!vam->json_output)
15553 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
15556 M (POLICER_CLASSIFY_DUMP, policer_classify_dump);
15561 /* Use a control ping for synchronization */
15563 vl_api_control_ping_t *mp;
15564 M (CONTROL_PING, control_ping);
15567 /* Wait for a reply... */
15575 api_netmap_create (vat_main_t * vam)
15577 unformat_input_t *i = vam->input;
15578 vl_api_netmap_create_t *mp;
15582 u8 random_hw_addr = 1;
15586 memset (hw_addr, 0, sizeof (hw_addr));
15588 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15590 if (unformat (i, "name %s", &if_name))
15591 vec_add1 (if_name, 0);
15592 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
15593 random_hw_addr = 0;
15594 else if (unformat (i, "pipe"))
15596 else if (unformat (i, "master"))
15598 else if (unformat (i, "slave"))
15604 if (!vec_len (if_name))
15606 errmsg ("interface name must be specified");
15610 if (vec_len (if_name) > 64)
15612 errmsg ("interface name too long");
15616 M (NETMAP_CREATE, netmap_create);
15618 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
15619 clib_memcpy (mp->hw_addr, hw_addr, 6);
15620 mp->use_random_hw_addr = random_hw_addr;
15621 mp->is_pipe = is_pipe;
15622 mp->is_master = is_master;
15623 vec_free (if_name);
15632 api_netmap_delete (vat_main_t * vam)
15634 unformat_input_t *i = vam->input;
15635 vl_api_netmap_delete_t *mp;
15639 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15641 if (unformat (i, "name %s", &if_name))
15642 vec_add1 (if_name, 0);
15647 if (!vec_len (if_name))
15649 errmsg ("interface name must be specified");
15653 if (vec_len (if_name) > 64)
15655 errmsg ("interface name too long");
15659 M (NETMAP_DELETE, netmap_delete);
15661 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
15662 vec_free (if_name);
15670 static void vl_api_mpls_tunnel_details_t_handler
15671 (vl_api_mpls_tunnel_details_t * mp)
15673 vat_main_t *vam = &vat_main;
15674 i32 len = mp->mt_next_hop_n_labels;
15677 print (vam->ofp, "[%d]: via %U %d labels ",
15679 format_ip4_address, mp->mt_next_hop,
15680 ntohl (mp->mt_next_hop_sw_if_index));
15681 for (i = 0; i < len; i++)
15683 print (vam->ofp, "%u ", ntohl (mp->mt_next_hop_out_labels[i]));
15685 print (vam->ofp, "");
15688 static void vl_api_mpls_tunnel_details_t_handler_json
15689 (vl_api_mpls_tunnel_details_t * mp)
15691 vat_main_t *vam = &vat_main;
15692 vat_json_node_t *node = NULL;
15693 struct in_addr ip4;
15695 i32 len = mp->mt_next_hop_n_labels;
15697 if (VAT_JSON_ARRAY != vam->json_tree.type)
15699 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15700 vat_json_init_array (&vam->json_tree);
15702 node = vat_json_array_add (&vam->json_tree);
15704 vat_json_init_object (node);
15705 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
15706 clib_memcpy (&ip4, &(mp->mt_next_hop), sizeof (ip4));
15707 vat_json_object_add_ip4 (node, "next_hop", ip4);
15708 vat_json_object_add_uint (node, "next_hop_sw_if_index",
15709 ntohl (mp->mt_next_hop_sw_if_index));
15710 vat_json_object_add_uint (node, "l2_only", ntohl (mp->mt_l2_only));
15711 vat_json_object_add_uint (node, "label_count", len);
15712 for (i = 0; i < len; i++)
15714 vat_json_object_add_uint (node, "label",
15715 ntohl (mp->mt_next_hop_out_labels[i]));
15720 api_mpls_tunnel_dump (vat_main_t * vam)
15722 vl_api_mpls_tunnel_dump_t *mp;
15726 /* Parse args required to build the message */
15727 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
15729 if (!unformat (vam->input, "tunnel_index %d", &index))
15736 print (vam->ofp, " tunnel_index %d", index);
15738 M (MPLS_TUNNEL_DUMP, mpls_tunnel_dump);
15739 mp->tunnel_index = htonl (index);
15742 /* Use a control ping for synchronization */
15744 vl_api_control_ping_t *mp;
15745 M (CONTROL_PING, control_ping);
15751 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
15752 #define vl_api_mpls_fib_details_t_print vl_noop_handler
15755 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
15757 vat_main_t *vam = &vat_main;
15758 int count = ntohl (mp->count);
15759 vl_api_fib_path2_t *fp;
15763 "table-id %d, label %u, ess_bit %u",
15764 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
15766 for (i = 0; i < count; i++)
15768 if (fp->afi == IP46_TYPE_IP6)
15770 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15771 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15772 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15773 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15774 format_ip6_address, fp->next_hop);
15775 else if (fp->afi == IP46_TYPE_IP4)
15777 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15778 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15779 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15780 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15781 format_ip4_address, fp->next_hop);
15786 static void vl_api_mpls_fib_details_t_handler_json
15787 (vl_api_mpls_fib_details_t * mp)
15789 vat_main_t *vam = &vat_main;
15790 int count = ntohl (mp->count);
15791 vat_json_node_t *node = NULL;
15792 struct in_addr ip4;
15793 struct in6_addr ip6;
15794 vl_api_fib_path2_t *fp;
15797 if (VAT_JSON_ARRAY != vam->json_tree.type)
15799 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15800 vat_json_init_array (&vam->json_tree);
15802 node = vat_json_array_add (&vam->json_tree);
15804 vat_json_init_object (node);
15805 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
15806 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
15807 vat_json_object_add_uint (node, "label", ntohl (mp->label));
15808 vat_json_object_add_uint (node, "path_count", count);
15810 for (i = 0; i < count; i++)
15812 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
15813 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
15814 vat_json_object_add_uint (node, "is_local", fp->is_local);
15815 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
15816 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
15817 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
15818 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
15819 if (fp->afi == IP46_TYPE_IP4)
15821 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
15822 vat_json_object_add_ip4 (node, "next_hop", ip4);
15824 else if (fp->afi == IP46_TYPE_IP6)
15826 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
15827 vat_json_object_add_ip6 (node, "next_hop", ip6);
15833 api_mpls_fib_dump (vat_main_t * vam)
15835 vl_api_mpls_fib_dump_t *mp;
15838 M (MPLS_FIB_DUMP, mpls_fib_dump);
15841 /* Use a control ping for synchronization */
15843 vl_api_control_ping_t *mp;
15844 M (CONTROL_PING, control_ping);
15850 #define vl_api_ip_fib_details_t_endian vl_noop_handler
15851 #define vl_api_ip_fib_details_t_print vl_noop_handler
15854 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
15856 vat_main_t *vam = &vat_main;
15857 int count = ntohl (mp->count);
15858 vl_api_fib_path_t *fp;
15862 "table-id %d, prefix %U/%d",
15863 ntohl (mp->table_id), format_ip4_address, mp->address,
15864 mp->address_length);
15866 for (i = 0; i < count; i++)
15868 if (fp->afi == IP46_TYPE_IP6)
15870 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15871 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15872 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15873 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15874 format_ip6_address, fp->next_hop);
15875 else if (fp->afi == IP46_TYPE_IP4)
15877 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15878 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15879 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15880 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15881 format_ip4_address, fp->next_hop);
15886 static void vl_api_ip_fib_details_t_handler_json
15887 (vl_api_ip_fib_details_t * mp)
15889 vat_main_t *vam = &vat_main;
15890 int count = ntohl (mp->count);
15891 vat_json_node_t *node = NULL;
15892 struct in_addr ip4;
15893 struct in6_addr ip6;
15894 vl_api_fib_path_t *fp;
15897 if (VAT_JSON_ARRAY != vam->json_tree.type)
15899 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15900 vat_json_init_array (&vam->json_tree);
15902 node = vat_json_array_add (&vam->json_tree);
15904 vat_json_init_object (node);
15905 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
15906 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
15907 vat_json_object_add_ip4 (node, "prefix", ip4);
15908 vat_json_object_add_uint (node, "mask_length", mp->address_length);
15909 vat_json_object_add_uint (node, "path_count", count);
15911 for (i = 0; i < count; i++)
15913 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
15914 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
15915 vat_json_object_add_uint (node, "is_local", fp->is_local);
15916 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
15917 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
15918 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
15919 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
15920 if (fp->afi == IP46_TYPE_IP4)
15922 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
15923 vat_json_object_add_ip4 (node, "next_hop", ip4);
15925 else if (fp->afi == IP46_TYPE_IP6)
15927 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
15928 vat_json_object_add_ip6 (node, "next_hop", ip6);
15934 api_ip_fib_dump (vat_main_t * vam)
15936 vl_api_ip_fib_dump_t *mp;
15939 M (IP_FIB_DUMP, ip_fib_dump);
15942 /* Use a control ping for synchronization */
15944 vl_api_control_ping_t *mp;
15945 M (CONTROL_PING, control_ping);
15951 static void vl_api_ip_neighbor_details_t_handler
15952 (vl_api_ip_neighbor_details_t * mp)
15954 vat_main_t *vam = &vat_main;
15956 print (vam->ofp, "%c %U %U",
15957 (mp->is_static) ? 'S' : 'D',
15958 format_ethernet_address, &mp->mac_address,
15959 (mp->is_ipv6) ? format_ip6_address : format_ip4_address,
15963 static void vl_api_ip_neighbor_details_t_handler_json
15964 (vl_api_ip_neighbor_details_t * mp)
15967 vat_main_t *vam = &vat_main;
15968 vat_json_node_t *node;
15969 struct in_addr ip4;
15970 struct in6_addr ip6;
15972 if (VAT_JSON_ARRAY != vam->json_tree.type)
15974 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15975 vat_json_init_array (&vam->json_tree);
15977 node = vat_json_array_add (&vam->json_tree);
15979 vat_json_init_object (node);
15980 vat_json_object_add_string_copy (node, "flag",
15981 (mp->is_static) ? (u8 *) "static" : (u8 *)
15984 vat_json_object_add_string_copy (node, "link_layer",
15985 format (0, "%U", format_ethernet_address,
15986 &mp->mac_address));
15990 clib_memcpy (&ip6, &mp->ip_address, sizeof (ip6));
15991 vat_json_object_add_ip6 (node, "ip_address", ip6);
15995 clib_memcpy (&ip4, &mp->ip_address, sizeof (ip4));
15996 vat_json_object_add_ip4 (node, "ip_address", ip4);
16001 api_ip_neighbor_dump (vat_main_t * vam)
16003 unformat_input_t *i = vam->input;
16004 vl_api_ip_neighbor_dump_t *mp;
16007 u32 sw_if_index = ~0;
16009 /* Parse args required to build the message */
16010 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16012 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16014 else if (unformat (i, "sw_if_index %d", &sw_if_index))
16016 else if (unformat (i, "ip6"))
16022 if (sw_if_index == ~0)
16024 errmsg ("missing interface name or sw_if_index");
16028 M (IP_NEIGHBOR_DUMP, ip_neighbor_dump);
16029 mp->is_ipv6 = (u8) is_ipv6;
16030 mp->sw_if_index = ntohl (sw_if_index);
16033 /* Use a control ping for synchronization */
16035 vl_api_control_ping_t *mp;
16036 M (CONTROL_PING, control_ping);
16042 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
16043 #define vl_api_ip6_fib_details_t_print vl_noop_handler
16046 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
16048 vat_main_t *vam = &vat_main;
16049 int count = ntohl (mp->count);
16050 vl_api_fib_path_t *fp;
16054 "table-id %d, prefix %U/%d",
16055 ntohl (mp->table_id), format_ip6_address, mp->address,
16056 mp->address_length);
16058 for (i = 0; i < count; i++)
16060 if (fp->afi == IP46_TYPE_IP6)
16062 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16063 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16064 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16065 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16066 format_ip6_address, fp->next_hop);
16067 else if (fp->afi == IP46_TYPE_IP4)
16069 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16070 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16071 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16072 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16073 format_ip4_address, fp->next_hop);
16078 static void vl_api_ip6_fib_details_t_handler_json
16079 (vl_api_ip6_fib_details_t * mp)
16081 vat_main_t *vam = &vat_main;
16082 int count = ntohl (mp->count);
16083 vat_json_node_t *node = NULL;
16084 struct in_addr ip4;
16085 struct in6_addr ip6;
16086 vl_api_fib_path_t *fp;
16089 if (VAT_JSON_ARRAY != vam->json_tree.type)
16091 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16092 vat_json_init_array (&vam->json_tree);
16094 node = vat_json_array_add (&vam->json_tree);
16096 vat_json_init_object (node);
16097 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
16098 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
16099 vat_json_object_add_ip6 (node, "prefix", ip6);
16100 vat_json_object_add_uint (node, "mask_length", mp->address_length);
16101 vat_json_object_add_uint (node, "path_count", count);
16103 for (i = 0; i < count; i++)
16105 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
16106 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
16107 vat_json_object_add_uint (node, "is_local", fp->is_local);
16108 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
16109 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
16110 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
16111 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
16112 if (fp->afi == IP46_TYPE_IP4)
16114 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
16115 vat_json_object_add_ip4 (node, "next_hop", ip4);
16117 else if (fp->afi == IP46_TYPE_IP6)
16119 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
16120 vat_json_object_add_ip6 (node, "next_hop", ip6);
16126 api_ip6_fib_dump (vat_main_t * vam)
16128 vl_api_ip6_fib_dump_t *mp;
16131 M (IP6_FIB_DUMP, ip6_fib_dump);
16134 /* Use a control ping for synchronization */
16136 vl_api_control_ping_t *mp;
16137 M (CONTROL_PING, control_ping);
16144 api_classify_table_ids (vat_main_t * vam)
16146 vl_api_classify_table_ids_t *mp;
16149 /* Construct the API message */
16150 M (CLASSIFY_TABLE_IDS, classify_table_ids);
16160 api_classify_table_by_interface (vat_main_t * vam)
16162 unformat_input_t *input = vam->input;
16163 vl_api_classify_table_by_interface_t *mp;
16166 u32 sw_if_index = ~0;
16167 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16169 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16171 else if (unformat (input, "sw_if_index %d", &sw_if_index))
16176 if (sw_if_index == ~0)
16178 errmsg ("missing interface name or sw_if_index");
16182 /* Construct the API message */
16183 M (CLASSIFY_TABLE_BY_INTERFACE, classify_table_by_interface);
16185 mp->sw_if_index = ntohl (sw_if_index);
16194 api_classify_table_info (vat_main_t * vam)
16196 unformat_input_t *input = vam->input;
16197 vl_api_classify_table_info_t *mp;
16201 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16203 if (unformat (input, "table_id %d", &table_id))
16208 if (table_id == ~0)
16210 errmsg ("missing table id");
16214 /* Construct the API message */
16215 M (CLASSIFY_TABLE_INFO, classify_table_info);
16217 mp->table_id = ntohl (table_id);
16226 api_classify_session_dump (vat_main_t * vam)
16228 unformat_input_t *input = vam->input;
16229 vl_api_classify_session_dump_t *mp;
16233 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16235 if (unformat (input, "table_id %d", &table_id))
16240 if (table_id == ~0)
16242 errmsg ("missing table id");
16246 /* Construct the API message */
16247 M (CLASSIFY_SESSION_DUMP, classify_session_dump);
16249 mp->table_id = ntohl (table_id);
16252 /* Use a control ping for synchronization */
16254 vl_api_control_ping_t *mp;
16255 M (CONTROL_PING, control_ping);
16264 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
16266 vat_main_t *vam = &vat_main;
16268 print (vam->ofp, "collector_address %U, collector_port %d, "
16269 "src_address %U, vrf_id %d, path_mtu %u, "
16270 "template_interval %u, udp_checksum %d",
16271 format_ip4_address, mp->collector_address,
16272 ntohs (mp->collector_port),
16273 format_ip4_address, mp->src_address,
16274 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
16275 ntohl (mp->template_interval), mp->udp_checksum);
16278 vam->result_ready = 1;
16282 vl_api_ipfix_exporter_details_t_handler_json
16283 (vl_api_ipfix_exporter_details_t * mp)
16285 vat_main_t *vam = &vat_main;
16286 vat_json_node_t node;
16287 struct in_addr collector_address;
16288 struct in_addr src_address;
16290 vat_json_init_object (&node);
16291 clib_memcpy (&collector_address, &mp->collector_address,
16292 sizeof (collector_address));
16293 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
16294 vat_json_object_add_uint (&node, "collector_port",
16295 ntohs (mp->collector_port));
16296 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
16297 vat_json_object_add_ip4 (&node, "src_address", src_address);
16298 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
16299 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
16300 vat_json_object_add_uint (&node, "template_interval",
16301 ntohl (mp->template_interval));
16302 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
16304 vat_json_print (vam->ofp, &node);
16305 vat_json_free (&node);
16307 vam->result_ready = 1;
16311 api_ipfix_exporter_dump (vat_main_t * vam)
16313 vl_api_ipfix_exporter_dump_t *mp;
16316 /* Construct the API message */
16317 M (IPFIX_EXPORTER_DUMP, ipfix_exporter_dump);
16327 api_ipfix_classify_stream_dump (vat_main_t * vam)
16329 vl_api_ipfix_classify_stream_dump_t *mp;
16332 /* Construct the API message */
16333 M (IPFIX_CLASSIFY_STREAM_DUMP, ipfix_classify_stream_dump);
16343 vl_api_ipfix_classify_stream_details_t_handler
16344 (vl_api_ipfix_classify_stream_details_t * mp)
16346 vat_main_t *vam = &vat_main;
16347 print (vam->ofp, "domain_id %d, src_port %d",
16348 ntohl (mp->domain_id), ntohs (mp->src_port));
16350 vam->result_ready = 1;
16354 vl_api_ipfix_classify_stream_details_t_handler_json
16355 (vl_api_ipfix_classify_stream_details_t * mp)
16357 vat_main_t *vam = &vat_main;
16358 vat_json_node_t node;
16360 vat_json_init_object (&node);
16361 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
16362 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
16364 vat_json_print (vam->ofp, &node);
16365 vat_json_free (&node);
16367 vam->result_ready = 1;
16371 api_ipfix_classify_table_dump (vat_main_t * vam)
16373 vl_api_ipfix_classify_table_dump_t *mp;
16376 if (!vam->json_output)
16378 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
16379 "transport_protocol");
16382 /* Construct the API message */
16383 M (IPFIX_CLASSIFY_TABLE_DUMP, ipfix_classify_table_dump);
16388 /* Use a control ping for synchronization */
16390 vl_api_control_ping_t *mp;
16391 M (CONTROL_PING, control_ping);
16398 vl_api_ipfix_classify_table_details_t_handler
16399 (vl_api_ipfix_classify_table_details_t * mp)
16401 vat_main_t *vam = &vat_main;
16402 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
16403 mp->transport_protocol);
16407 vl_api_ipfix_classify_table_details_t_handler_json
16408 (vl_api_ipfix_classify_table_details_t * mp)
16410 vat_json_node_t *node = NULL;
16411 vat_main_t *vam = &vat_main;
16413 if (VAT_JSON_ARRAY != vam->json_tree.type)
16415 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16416 vat_json_init_array (&vam->json_tree);
16419 node = vat_json_array_add (&vam->json_tree);
16420 vat_json_init_object (node);
16422 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
16423 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
16424 vat_json_object_add_uint (node, "transport_protocol",
16425 mp->transport_protocol);
16429 api_sw_interface_span_enable_disable (vat_main_t * vam)
16431 unformat_input_t *i = vam->input;
16432 vl_api_sw_interface_span_enable_disable_t *mp;
16434 u32 src_sw_if_index = ~0;
16435 u32 dst_sw_if_index = ~0;
16438 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16441 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
16443 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
16447 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
16449 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
16451 else if (unformat (i, "disable"))
16453 else if (unformat (i, "rx"))
16455 else if (unformat (i, "tx"))
16457 else if (unformat (i, "both"))
16463 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, sw_interface_span_enable_disable);
16465 mp->sw_if_index_from = htonl (src_sw_if_index);
16466 mp->sw_if_index_to = htonl (dst_sw_if_index);
16476 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
16479 vat_main_t *vam = &vat_main;
16480 u8 *sw_if_from_name = 0;
16481 u8 *sw_if_to_name = 0;
16482 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
16483 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
16484 char *states[] = { "none", "rx", "tx", "both" };
16488 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
16490 if ((u32) p->value[0] == sw_if_index_from)
16492 sw_if_from_name = (u8 *)(p->key);
16496 if ((u32) p->value[0] == sw_if_index_to)
16498 sw_if_to_name = (u8 *)(p->key);
16499 if (sw_if_from_name)
16504 print (vam->ofp, "%20s => %20s (%s)",
16505 sw_if_from_name, sw_if_to_name, states[mp->state]);
16509 vl_api_sw_interface_span_details_t_handler_json
16510 (vl_api_sw_interface_span_details_t * mp)
16512 vat_main_t *vam = &vat_main;
16513 vat_json_node_t *node = NULL;
16514 u8 *sw_if_from_name = 0;
16515 u8 *sw_if_to_name = 0;
16516 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
16517 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
16521 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
16523 if ((u32) p->value[0] == sw_if_index_from)
16525 sw_if_from_name = (u8 *)(p->key);
16529 if ((u32) p->value[0] == sw_if_index_to)
16531 sw_if_to_name = (u8 *)(p->key);
16532 if (sw_if_from_name)
16538 if (VAT_JSON_ARRAY != vam->json_tree.type)
16540 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16541 vat_json_init_array (&vam->json_tree);
16543 node = vat_json_array_add (&vam->json_tree);
16545 vat_json_init_object (node);
16546 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
16547 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
16548 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
16549 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
16550 vat_json_object_add_uint (node, "state", mp->state);
16554 api_sw_interface_span_dump (vat_main_t * vam)
16556 vl_api_sw_interface_span_dump_t *mp;
16559 M (SW_INTERFACE_SPAN_DUMP, sw_interface_span_dump);
16562 /* Use a control ping for synchronization */
16564 vl_api_control_ping_t *mp;
16565 M (CONTROL_PING, control_ping);
16572 api_pg_create_interface (vat_main_t * vam)
16574 unformat_input_t *input = vam->input;
16575 vl_api_pg_create_interface_t *mp;
16579 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16581 if (unformat (input, "if_id %d", &if_id))
16588 errmsg ("missing pg interface index");
16592 /* Construct the API message */
16593 M (PG_CREATE_INTERFACE, pg_create_interface);
16595 mp->interface_id = ntohl (if_id);
16604 api_pg_capture (vat_main_t * vam)
16606 unformat_input_t *input = vam->input;
16607 vl_api_pg_capture_t *mp;
16613 u8 pcap_file_set = 0;
16615 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16617 if (unformat (input, "if_id %d", &if_id))
16619 else if (unformat (input, "pcap %s", &pcap_file))
16621 else if (unformat (input, "count %d", &count))
16623 else if (unformat (input, "disable"))
16630 errmsg ("missing pg interface index");
16633 if (pcap_file_set > 0)
16635 if (vec_len (pcap_file) > 255)
16637 errmsg ("pcap file name is too long");
16642 u32 name_len = vec_len (pcap_file);
16643 /* Construct the API message */
16644 M (PG_CAPTURE, pg_capture);
16646 mp->interface_id = ntohl (if_id);
16647 mp->is_enabled = enable;
16648 mp->count = ntohl (count);
16649 mp->pcap_name_length = ntohl (name_len);
16650 if (pcap_file_set != 0)
16652 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
16654 vec_free (pcap_file);
16663 api_pg_enable_disable (vat_main_t * vam)
16665 unformat_input_t *input = vam->input;
16666 vl_api_pg_enable_disable_t *mp;
16670 u8 stream_name_set = 0;
16671 u8 *stream_name = 0;
16672 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16674 if (unformat (input, "stream %s", &stream_name))
16675 stream_name_set = 1;
16676 else if (unformat (input, "disable"))
16682 if (stream_name_set > 0)
16684 if (vec_len (stream_name) > 255)
16686 errmsg ("stream name too long");
16691 u32 name_len = vec_len (stream_name);
16692 /* Construct the API message */
16693 M (PG_ENABLE_DISABLE, pg_enable_disable);
16695 mp->is_enabled = enable;
16696 if (stream_name_set != 0)
16698 mp->stream_name_length = ntohl (name_len);
16699 clib_memcpy (mp->stream_name, stream_name, name_len);
16701 vec_free (stream_name);
16710 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
16712 unformat_input_t *input = vam->input;
16713 vl_api_ip_source_and_port_range_check_add_del_t *mp;
16716 u16 *low_ports = 0;
16717 u16 *high_ports = 0;
16720 ip4_address_t ip4_addr;
16721 ip6_address_t ip6_addr;
16729 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16731 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
16737 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
16742 else if (unformat (input, "vrf %d", &vrf_id))
16744 else if (unformat (input, "del"))
16746 else if (unformat (input, "port %d", &tmp))
16748 if (tmp == 0 || tmp > 65535)
16750 errmsg ("port %d out of range", tmp);
16754 this_hi = this_low + 1;
16755 vec_add1 (low_ports, this_low);
16756 vec_add1 (high_ports, this_hi);
16758 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
16760 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
16762 errmsg ("incorrect range parameters");
16766 /* Note: in debug CLI +1 is added to high before
16767 passing to real fn that does "the work"
16768 (ip_source_and_port_range_check_add_del).
16769 This fn is a wrapper around the binary API fn a
16770 control plane will call, which expects this increment
16771 to have occurred. Hence letting the binary API control
16772 plane fn do the increment for consistency between VAT
16773 and other control planes.
16776 vec_add1 (low_ports, this_low);
16777 vec_add1 (high_ports, this_hi);
16783 if (prefix_set == 0)
16785 errmsg ("<address>/<mask> not specified");
16791 errmsg ("VRF ID required, not specified");
16798 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
16802 if (vec_len (low_ports) == 0)
16804 errmsg ("At least one port or port range required");
16808 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL,
16809 ip_source_and_port_range_check_add_del);
16811 mp->is_add = is_add;
16816 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
16821 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
16824 mp->mask_length = length;
16825 mp->number_of_ranges = vec_len (low_ports);
16827 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
16828 vec_free (low_ports);
16830 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
16831 vec_free (high_ports);
16833 mp->vrf_id = ntohl (vrf_id);
16842 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
16844 unformat_input_t *input = vam->input;
16845 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
16847 u32 sw_if_index = ~0;
16849 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
16850 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
16853 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16855 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16857 else if (unformat (input, "sw_if_index %d", &sw_if_index))
16859 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
16861 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
16863 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
16865 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
16867 else if (unformat (input, "del"))
16873 if (sw_if_index == ~0)
16875 errmsg ("Interface required but not specified");
16881 errmsg ("VRF ID required but not specified");
16885 if (tcp_out_vrf_id == 0
16886 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
16889 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
16893 /* Construct the API message */
16894 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL,
16895 ip_source_and_port_range_check_interface_add_del);
16897 mp->sw_if_index = ntohl (sw_if_index);
16898 mp->is_add = is_add;
16899 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
16900 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
16901 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
16902 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
16907 /* Wait for a reply... */
16912 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
16914 unformat_input_t *i = vam->input;
16915 vl_api_ipsec_gre_add_del_tunnel_t *mp;
16917 u32 local_sa_id = 0;
16918 u32 remote_sa_id = 0;
16919 ip4_address_t src_address;
16920 ip4_address_t dst_address;
16923 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16925 if (unformat (i, "local_sa %d", &local_sa_id))
16927 else if (unformat (i, "remote_sa %d", &remote_sa_id))
16929 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
16931 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
16933 else if (unformat (i, "del"))
16937 clib_warning ("parse error '%U'", format_unformat_error, i);
16942 M (IPSEC_GRE_ADD_DEL_TUNNEL, ipsec_gre_add_del_tunnel);
16944 mp->local_sa_id = ntohl (local_sa_id);
16945 mp->remote_sa_id = ntohl (remote_sa_id);
16946 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
16947 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
16948 mp->is_add = is_add;
16957 api_punt (vat_main_t * vam)
16959 unformat_input_t *i = vam->input;
16967 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16969 if (unformat (i, "ip %d", &ipv))
16971 else if (unformat (i, "protocol %d", &protocol))
16973 else if (unformat (i, "port %d", &port))
16975 else if (unformat (i, "del"))
16979 clib_warning ("parse error '%U'", format_unformat_error, i);
16986 mp->is_add = (u8) is_add;
16987 mp->ipv = (u8) ipv;
16988 mp->l4_protocol = (u8) protocol;
16989 mp->l4_port = htons ((u16) port);
16997 static void vl_api_ipsec_gre_tunnel_details_t_handler
16998 (vl_api_ipsec_gre_tunnel_details_t * mp)
17000 vat_main_t *vam = &vat_main;
17002 print (vam->ofp, "%11d%15U%15U%14d%14d",
17003 ntohl (mp->sw_if_index),
17004 format_ip4_address, &mp->src_address,
17005 format_ip4_address, &mp->dst_address,
17006 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
17009 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
17010 (vl_api_ipsec_gre_tunnel_details_t * mp)
17012 vat_main_t *vam = &vat_main;
17013 vat_json_node_t *node = NULL;
17014 struct in_addr ip4;
17016 if (VAT_JSON_ARRAY != vam->json_tree.type)
17018 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17019 vat_json_init_array (&vam->json_tree);
17021 node = vat_json_array_add (&vam->json_tree);
17023 vat_json_init_object (node);
17024 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
17025 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
17026 vat_json_object_add_ip4 (node, "src_address", ip4);
17027 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
17028 vat_json_object_add_ip4 (node, "dst_address", ip4);
17029 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
17030 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
17034 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
17036 unformat_input_t *i = vam->input;
17037 vl_api_ipsec_gre_tunnel_dump_t *mp;
17040 u8 sw_if_index_set = 0;
17042 /* Parse args required to build the message */
17043 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17045 if (unformat (i, "sw_if_index %d", &sw_if_index))
17046 sw_if_index_set = 1;
17051 if (sw_if_index_set == 0)
17056 if (!vam->json_output)
17058 print (vam->ofp, "%11s%15s%15s%14s%14s",
17059 "sw_if_index", "src_address", "dst_address",
17060 "local_sa_id", "remote_sa_id");
17063 /* Get list of gre-tunnel interfaces */
17064 M (IPSEC_GRE_TUNNEL_DUMP, ipsec_gre_tunnel_dump);
17066 mp->sw_if_index = htonl (sw_if_index);
17070 /* Use a control ping for synchronization */
17072 vl_api_control_ping_t *mp;
17073 M (CONTROL_PING, control_ping);
17080 api_delete_subif (vat_main_t * vam)
17082 unformat_input_t *i = vam->input;
17083 vl_api_delete_subif_t *mp;
17085 u32 sw_if_index = ~0;
17087 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17089 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17091 if (unformat (i, "sw_if_index %d", &sw_if_index))
17097 if (sw_if_index == ~0)
17099 errmsg ("missing sw_if_index");
17103 /* Construct the API message */
17104 M (DELETE_SUBIF, delete_subif);
17105 mp->sw_if_index = ntohl (sw_if_index);
17111 #define foreach_pbb_vtr_op \
17112 _("disable", L2_VTR_DISABLED) \
17113 _("pop", L2_VTR_POP_2) \
17114 _("push", L2_VTR_PUSH_2)
17117 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
17119 unformat_input_t *i = vam->input;
17120 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
17122 u32 sw_if_index = ~0, vtr_op = ~0;
17123 u16 outer_tag = ~0;
17124 u8 dmac[6], smac[6];
17125 u8 dmac_set = 0, smac_set = 0;
17130 /* Shut up coverity */
17131 memset (dmac, 0, sizeof (dmac));
17132 memset (smac, 0, sizeof (smac));
17134 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17136 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17138 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17140 else if (unformat (i, "vtr_op %d", &vtr_op))
17142 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
17145 else if (unformat (i, "translate_pbb_stag"))
17147 if (unformat (i, "%d", &tmp))
17149 vtr_op = L2_VTR_TRANSLATE_2_1;
17155 ("translate_pbb_stag operation requires outer tag definition");
17159 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
17161 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
17163 else if (unformat (i, "sid %d", &sid))
17165 else if (unformat (i, "vlanid %d", &tmp))
17169 clib_warning ("parse error '%U'", format_unformat_error, i);
17174 if ((sw_if_index == ~0) || (vtr_op == ~0))
17176 errmsg ("missing sw_if_index or vtr operation");
17179 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
17180 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
17183 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
17187 M (L2_INTERFACE_PBB_TAG_REWRITE, l2_interface_pbb_tag_rewrite);
17188 mp->sw_if_index = ntohl (sw_if_index);
17189 mp->vtr_op = ntohl (vtr_op);
17190 mp->outer_tag = ntohs (outer_tag);
17191 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
17192 clib_memcpy (mp->b_smac, smac, sizeof (smac));
17193 mp->b_vlanid = ntohs (vlanid);
17194 mp->i_sid = ntohl (sid);
17203 api_flow_classify_set_interface (vat_main_t * vam)
17205 unformat_input_t *i = vam->input;
17206 vl_api_flow_classify_set_interface_t *mp;
17209 int sw_if_index_set;
17210 u32 ip4_table_index = ~0;
17211 u32 ip6_table_index = ~0;
17214 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17216 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17217 sw_if_index_set = 1;
17218 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17219 sw_if_index_set = 1;
17220 else if (unformat (i, "del"))
17222 else if (unformat (i, "ip4-table %d", &ip4_table_index))
17224 else if (unformat (i, "ip6-table %d", &ip6_table_index))
17228 clib_warning ("parse error '%U'", format_unformat_error, i);
17233 if (sw_if_index_set == 0)
17235 errmsg ("missing interface name or sw_if_index");
17239 M (FLOW_CLASSIFY_SET_INTERFACE, flow_classify_set_interface);
17241 mp->sw_if_index = ntohl (sw_if_index);
17242 mp->ip4_table_index = ntohl (ip4_table_index);
17243 mp->ip6_table_index = ntohl (ip6_table_index);
17244 mp->is_add = is_add;
17253 api_flow_classify_dump (vat_main_t * vam)
17255 unformat_input_t *i = vam->input;
17256 vl_api_flow_classify_dump_t *mp;
17258 u8 type = FLOW_CLASSIFY_N_TABLES;
17260 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
17264 errmsg ("classify table type must be specified");
17268 if (!vam->json_output)
17270 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
17273 M (FLOW_CLASSIFY_DUMP, flow_classify_dump);
17278 /* Use a control ping for synchronization */
17280 vl_api_control_ping_t *mp;
17281 M (CONTROL_PING, control_ping);
17284 /* Wait for a reply... */
17292 api_feature_enable_disable (vat_main_t * vam)
17294 unformat_input_t *i = vam->input;
17295 vl_api_feature_enable_disable_t *mp;
17298 u8 *feature_name = 0;
17299 u32 sw_if_index = ~0;
17302 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17304 if (unformat (i, "arc_name %s", &arc_name))
17306 else if (unformat (i, "feature_name %s", &feature_name))
17309 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17311 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17313 else if (unformat (i, "disable"))
17321 errmsg ("missing arc name");
17324 if (vec_len (arc_name) > 63)
17326 errmsg ("arc name too long");
17329 if (feature_name == 0)
17331 errmsg ("missing feature name");
17334 if (vec_len (feature_name) > 63)
17336 errmsg ("feature name too long");
17339 if (sw_if_index == ~0)
17341 errmsg ("missing interface name or sw_if_index");
17345 /* Construct the API message */
17346 M (FEATURE_ENABLE_DISABLE, feature_enable_disable);
17347 mp->sw_if_index = ntohl (sw_if_index);
17348 mp->enable = enable;
17349 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
17350 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
17351 vec_free (arc_name);
17352 vec_free (feature_name);
17359 api_sw_interface_tag_add_del (vat_main_t * vam)
17361 unformat_input_t *i = vam->input;
17362 vl_api_sw_interface_tag_add_del_t *mp;
17364 u32 sw_if_index = ~0;
17368 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17370 if (unformat (i, "tag %s", &tag))
17372 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17374 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17376 else if (unformat (i, "del"))
17382 if (sw_if_index == ~0)
17384 errmsg ("missing interface name or sw_if_index");
17388 if (enable && (tag == 0))
17390 errmsg ("no tag specified");
17394 /* Construct the API message */
17395 M (SW_INTERFACE_TAG_ADD_DEL, sw_interface_tag_add_del);
17396 mp->sw_if_index = ntohl (sw_if_index);
17397 mp->is_add = enable;
17399 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
17406 static void vl_api_l2_xconnect_details_t_handler
17407 (vl_api_l2_xconnect_details_t * mp)
17409 vat_main_t *vam = &vat_main;
17411 print (vam->ofp, "%15d%15d",
17412 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
17415 static void vl_api_l2_xconnect_details_t_handler_json
17416 (vl_api_l2_xconnect_details_t * mp)
17418 vat_main_t *vam = &vat_main;
17419 vat_json_node_t *node = NULL;
17421 if (VAT_JSON_ARRAY != vam->json_tree.type)
17423 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17424 vat_json_init_array (&vam->json_tree);
17426 node = vat_json_array_add (&vam->json_tree);
17428 vat_json_init_object (node);
17429 vat_json_object_add_uint (node, "rx_sw_if_index",
17430 ntohl (mp->rx_sw_if_index));
17431 vat_json_object_add_uint (node, "tx_sw_if_index",
17432 ntohl (mp->tx_sw_if_index));
17436 api_l2_xconnect_dump (vat_main_t * vam)
17438 vl_api_l2_xconnect_dump_t *mp;
17441 if (!vam->json_output)
17443 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
17446 M (L2_XCONNECT_DUMP, l2_xconnect_dump);
17450 /* Use a control ping for synchronization */
17452 vl_api_control_ping_t *mp;
17453 M (CONTROL_PING, control_ping);
17460 api_sw_interface_set_mtu (vat_main_t * vam)
17462 unformat_input_t *i = vam->input;
17463 vl_api_sw_interface_set_mtu_t *mp;
17465 u32 sw_if_index = ~0;
17468 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17470 if (unformat (i, "mtu %d", &mtu))
17472 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17474 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17480 if (sw_if_index == ~0)
17482 errmsg ("missing interface name or sw_if_index");
17488 errmsg ("no mtu specified");
17492 /* Construct the API message */
17493 M (SW_INTERFACE_SET_MTU, sw_interface_set_mtu);
17494 mp->sw_if_index = ntohl (sw_if_index);
17495 mp->mtu = ntohs ((u16) mtu);
17503 q_or_quit (vat_main_t * vam)
17505 longjmp (vam->jump_buf, 1);
17506 return 0; /* not so much */
17510 q (vat_main_t * vam)
17512 return q_or_quit (vam);
17516 quit (vat_main_t * vam)
17518 return q_or_quit (vam);
17522 comment (vat_main_t * vam)
17528 cmd_cmp (void *a1, void *a2)
17533 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
17537 help (vat_main_t * vam)
17542 unformat_input_t *i = vam->input;
17545 if (unformat (i, "%s", &name))
17549 vec_add1 (name, 0);
17551 hs = hash_get_mem (vam->help_by_name, name);
17553 print (vam->ofp, "usage: %s %s", name, hs[0]);
17555 print (vam->ofp, "No such msg / command '%s'", name);
17560 print (vam->ofp, "Help is available for the following:");
17563 hash_foreach_pair (p, vam->function_by_name,
17565 vec_add1 (cmds, (u8 *)(p->key));
17569 vec_sort_with_function (cmds, cmd_cmp);
17571 for (j = 0; j < vec_len (cmds); j++)
17572 print (vam->ofp, "%s", cmds[j]);
17579 set (vat_main_t * vam)
17581 u8 *name = 0, *value = 0;
17582 unformat_input_t *i = vam->input;
17584 if (unformat (i, "%s", &name))
17586 /* The input buffer is a vector, not a string. */
17587 value = vec_dup (i->buffer);
17588 vec_delete (value, i->index, 0);
17589 /* Almost certainly has a trailing newline */
17590 if (value[vec_len (value) - 1] == '\n')
17591 value[vec_len (value) - 1] = 0;
17592 /* Make sure it's a proper string, one way or the other */
17593 vec_add1 (value, 0);
17594 (void) clib_macro_set_value (&vam->macro_main,
17595 (char *) name, (char *) value);
17598 errmsg ("usage: set <name> <value>");
17606 unset (vat_main_t * vam)
17610 if (unformat (vam->input, "%s", &name))
17611 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
17612 errmsg ("unset: %s wasn't set", name);
17625 macro_sort_cmp (void *a1, void *a2)
17627 macro_sort_t *s1 = a1;
17628 macro_sort_t *s2 = a2;
17630 return strcmp ((char *) (s1->name), (char *) (s2->name));
17634 dump_macro_table (vat_main_t * vam)
17636 macro_sort_t *sort_me = 0, *sm;
17641 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
17643 vec_add2 (sort_me, sm, 1);
17644 sm->name = (u8 *)(p->key);
17645 sm->value = (u8 *) (p->value[0]);
17649 vec_sort_with_function (sort_me, macro_sort_cmp);
17651 if (vec_len (sort_me))
17652 print (vam->ofp, "%-15s%s", "Name", "Value");
17654 print (vam->ofp, "The macro table is empty...");
17656 for (i = 0; i < vec_len (sort_me); i++)
17657 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
17662 dump_node_table (vat_main_t * vam)
17665 vlib_node_t *node, *next_node;
17667 if (vec_len (vam->graph_nodes) == 0)
17669 print (vam->ofp, "Node table empty, issue get_node_graph...");
17673 for (i = 0; i < vec_len (vam->graph_nodes); i++)
17675 node = vam->graph_nodes[i];
17676 print (vam->ofp, "[%d] %s", i, node->name);
17677 for (j = 0; j < vec_len (node->next_nodes); j++)
17679 if (node->next_nodes[j] != ~0)
17681 next_node = vam->graph_nodes[node->next_nodes[j]];
17682 print (vam->ofp, " [%d] %s", j, next_node->name);
17690 value_sort_cmp (void *a1, void *a2)
17692 name_sort_t *n1 = a1;
17693 name_sort_t *n2 = a2;
17695 if (n1->value < n2->value)
17697 if (n1->value > n2->value)
17704 dump_msg_api_table (vat_main_t * vam)
17706 api_main_t *am = &api_main;
17707 name_sort_t *nses = 0, *ns;
17712 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
17714 vec_add2 (nses, ns, 1);
17715 ns->name = (u8 *)(hp->key);
17716 ns->value = (u32) hp->value[0];
17720 vec_sort_with_function (nses, value_sort_cmp);
17722 for (i = 0; i < vec_len (nses); i++)
17723 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
17729 get_msg_id (vat_main_t * vam)
17734 if (unformat (vam->input, "%s", &name_and_crc))
17736 message_index = vl_api_get_msg_index (name_and_crc);
17737 if (message_index == ~0)
17739 print (vam->ofp, " '%s' not found", name_and_crc);
17742 print (vam->ofp, " '%s' has message index %d",
17743 name_and_crc, message_index);
17746 errmsg ("name_and_crc required...");
17751 search_node_table (vat_main_t * vam)
17753 unformat_input_t *line_input = vam->input;
17756 vlib_node_t *node, *next_node;
17759 if (vam->graph_node_index_by_name == 0)
17761 print (vam->ofp, "Node table empty, issue get_node_graph...");
17765 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
17767 if (unformat (line_input, "%s", &node_to_find))
17769 vec_add1 (node_to_find, 0);
17770 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
17773 print (vam->ofp, "%s not found...", node_to_find);
17776 node = vam->graph_nodes[p[0]];
17777 print (vam->ofp, "[%d] %s", p[0], node->name);
17778 for (j = 0; j < vec_len (node->next_nodes); j++)
17780 if (node->next_nodes[j] != ~0)
17782 next_node = vam->graph_nodes[node->next_nodes[j]];
17783 print (vam->ofp, " [%d] %s", j, next_node->name);
17790 clib_warning ("parse error '%U'", format_unformat_error,
17796 vec_free (node_to_find);
17805 script (vat_main_t * vam)
17807 #if (VPP_API_TEST_BUILTIN==0)
17809 char *save_current_file;
17810 unformat_input_t save_input;
17811 jmp_buf save_jump_buf;
17812 u32 save_line_number;
17814 FILE *new_fp, *save_ifp;
17816 if (unformat (vam->input, "%s", &s))
17818 new_fp = fopen ((char *) s, "r");
17821 errmsg ("Couldn't open script file %s", s);
17828 errmsg ("Missing script name");
17832 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
17833 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
17834 save_ifp = vam->ifp;
17835 save_line_number = vam->input_line_number;
17836 save_current_file = (char *) vam->current_file;
17838 vam->input_line_number = 0;
17840 vam->current_file = s;
17843 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
17844 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
17845 vam->ifp = save_ifp;
17846 vam->input_line_number = save_line_number;
17847 vam->current_file = (u8 *) save_current_file;
17852 clib_warning ("use the exec command...");
17858 echo (vat_main_t * vam)
17860 print (vam->ofp, "%v", vam->input->buffer);
17864 /* List of API message constructors, CLI names map to api_xxx */
17865 #define foreach_vpe_api_msg \
17866 _(create_loopback,"[mac <mac-addr>]") \
17867 _(sw_interface_dump,"") \
17868 _(sw_interface_set_flags, \
17869 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
17870 _(sw_interface_add_del_address, \
17871 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
17872 _(sw_interface_set_table, \
17873 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
17874 _(sw_interface_set_mpls_enable, \
17875 "<intfc> | sw_if_index [disable | dis]") \
17876 _(sw_interface_set_vpath, \
17877 "<intfc> | sw_if_index <id> enable | disable") \
17878 _(sw_interface_set_vxlan_bypass, \
17879 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
17880 _(sw_interface_set_l2_xconnect, \
17881 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
17882 "enable | disable") \
17883 _(sw_interface_set_l2_bridge, \
17884 "<intfc> | sw_if_index <id> bd_id <bridge-domain-id>\n" \
17885 "[shg <split-horizon-group>] [bvi]\n" \
17886 "enable | disable") \
17887 _(bridge_domain_add_del, \
17888 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n") \
17889 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
17891 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
17893 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
17895 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
17897 "tapname <name> mac <mac-addr> | random-mac [tag <string>]") \
17899 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
17901 "<vpp-if-name> | sw_if_index <id>") \
17902 _(sw_interface_tap_dump, "") \
17903 _(ip_add_del_route, \
17904 "<addr>/<mask> via <addr> [table-id <n>]\n" \
17905 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
17906 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
17907 "[multipath] [count <n>]") \
17908 _(ip_mroute_add_del, \
17909 "<src> <grp>/<mask> [table-id <n>]\n" \
17910 "[<intfc> | sw_if_index <id>] [local] [del]") \
17911 _(mpls_route_add_del, \
17912 "<label> <eos> via <addr> [table-id <n>]\n" \
17913 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
17914 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
17915 "[multipath] [count <n>]") \
17916 _(mpls_ip_bind_unbind, \
17917 "<label> <addr/len>") \
17918 _(mpls_tunnel_add_del, \
17919 " via <addr> [table-id <n>]\n" \
17920 "sw_if_index <id>] [l2] [del]") \
17921 _(proxy_arp_add_del, \
17922 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
17923 _(proxy_arp_intfc_enable_disable, \
17924 "<intfc> | sw_if_index <id> enable | disable") \
17925 _(sw_interface_set_unnumbered, \
17926 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
17927 _(ip_neighbor_add_del, \
17928 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
17929 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
17930 _(reset_vrf, "vrf <id> [ipv6]") \
17931 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
17932 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
17933 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
17934 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
17935 "[outer_vlan_id_any][inner_vlan_id_any]") \
17936 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
17937 _(reset_fib, "vrf <n> [ipv6]") \
17938 _(dhcp_proxy_config, \
17939 "svr <v46-address> src <v46-address>\n" \
17940 "insert-cid <n> [del]") \
17941 _(dhcp_proxy_config_2, \
17942 "svr <v46-address> src <v46-address>\n" \
17943 "rx_vrf_id <nn> server_vrf_id <nn> insert-cid <n> [del]") \
17944 _(dhcp_proxy_set_vss, \
17945 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
17946 _(dhcp_client_config, \
17947 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
17948 _(set_ip_flow_hash, \
17949 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
17950 _(sw_interface_ip6_enable_disable, \
17951 "<intfc> | sw_if_index <id> enable | disable") \
17952 _(sw_interface_ip6_set_link_local_address, \
17953 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
17954 _(sw_interface_ip6nd_ra_prefix, \
17955 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
17956 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
17957 "[nolink] [isno]") \
17958 _(sw_interface_ip6nd_ra_config, \
17959 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
17960 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
17961 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
17962 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
17963 _(l2_patch_add_del, \
17964 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
17965 "enable | disable") \
17966 _(sr_tunnel_add_del, \
17967 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
17968 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
17969 "[policy <policy_name>]") \
17970 _(sr_policy_add_del, \
17971 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
17972 _(sr_multicast_map_add_del, \
17973 "address [ip6 multicast address] sr-policy [policy name] [del]") \
17974 _(classify_add_del_table, \
17975 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
17976 " [del] [del-chain] mask <mask-value>\n" \
17977 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
17978 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
17979 _(classify_add_del_session, \
17980 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
17981 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
17982 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
17983 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
17984 _(classify_set_interface_ip_table, \
17985 "<intfc> | sw_if_index <nn> table <nn>") \
17986 _(classify_set_interface_l2_tables, \
17987 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
17988 " [other-table <nn>]") \
17989 _(get_node_index, "node <node-name") \
17990 _(add_node_next, "node <node-name> next <next-node-name>") \
17991 _(l2tpv3_create_tunnel, \
17992 "client_address <ip6-addr> our_address <ip6-addr>\n" \
17993 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
17994 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
17995 _(l2tpv3_set_tunnel_cookies, \
17996 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
17997 "[new_remote_cookie <nn>]\n") \
17998 _(l2tpv3_interface_enable_disable, \
17999 "<intfc> | sw_if_index <nn> enable | disable") \
18000 _(l2tpv3_set_lookup_key, \
18001 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
18002 _(sw_if_l2tpv3_tunnel_dump, "") \
18003 _(vxlan_add_del_tunnel, \
18004 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
18005 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
18006 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
18007 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
18008 _(gre_add_del_tunnel, \
18009 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [teb] [del]\n") \
18010 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
18011 _(l2_fib_clear_table, "") \
18012 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
18013 _(l2_interface_vlan_tag_rewrite, \
18014 "<intfc> | sw_if_index <nn> \n" \
18015 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
18016 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
18017 _(create_vhost_user_if, \
18018 "socket <filename> [server] [renumber <dev_instance>] " \
18019 "[mac <mac_address>]") \
18020 _(modify_vhost_user_if, \
18021 "<intfc> | sw_if_index <nn> socket <filename>\n" \
18022 "[server] [renumber <dev_instance>]") \
18023 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
18024 _(sw_interface_vhost_user_dump, "") \
18025 _(show_version, "") \
18026 _(vxlan_gpe_add_del_tunnel, \
18027 "local <addr> remote <addr> vni <nn>\n" \
18028 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
18029 "[next-ethernet] [next-nsh]\n") \
18030 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
18031 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
18032 _(interface_name_renumber, \
18033 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
18034 _(input_acl_set_interface, \
18035 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
18036 " [l2-table <nn>] [del]") \
18037 _(want_ip4_arp_events, "address <ip4-address> [del]") \
18038 _(want_ip6_nd_events, "address <ip6-address> [del]") \
18039 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
18040 _(ip_dump, "ipv4 | ipv6") \
18041 _(ipsec_spd_add_del, "spd_id <n> [del]") \
18042 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
18044 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
18045 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
18046 " integ_alg <alg> integ_key <hex>") \
18047 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
18048 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
18049 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
18050 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
18051 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
18052 _(ikev2_profile_add_del, "name <profile_name> [del]") \
18053 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
18054 "(auth_data 0x<data> | auth_data <data>)") \
18055 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
18056 "(id_data 0x<data> | id_data <data>) (local|remote)") \
18057 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
18058 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
18059 "(local|remote)") \
18060 _(ikev2_set_local_key, "file <absolute_file_path>") \
18061 _(delete_loopback,"sw_if_index <nn>") \
18062 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
18063 _(map_add_domain, \
18064 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
18065 "ip6-src <ip6addr> " \
18066 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
18067 _(map_del_domain, "index <n>") \
18068 _(map_add_del_rule, \
18069 "index <n> psid <n> dst <ip6addr> [del]") \
18070 _(map_domain_dump, "") \
18071 _(map_rule_dump, "index <map-domain>") \
18072 _(want_interface_events, "enable|disable") \
18073 _(want_stats,"enable|disable") \
18074 _(get_first_msg_id, "client <name>") \
18075 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
18076 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
18077 "fib-id <nn> [ip4][ip6][default]") \
18078 _(get_node_graph, " ") \
18079 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
18080 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
18081 _(ioam_disable, "") \
18082 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
18083 " sw_if_index <sw_if_index> p <priority> " \
18084 "w <weight>] [del]") \
18085 _(lisp_add_del_locator, "locator-set <locator_name> " \
18086 "iface <intf> | sw_if_index <sw_if_index> " \
18087 "p <priority> w <weight> [del]") \
18088 _(lisp_add_del_local_eid,"vni <vni> eid " \
18089 "<ipv4|ipv6>/<prefix> | <L2 address> " \
18090 "locator-set <locator_name> [del]" \
18091 "[key-id sha1|sha256 secret-key <secret-key>]") \
18092 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
18093 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
18094 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
18095 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
18096 _(lisp_gpe_enable_disable, "enable|disable") \
18097 _(lisp_enable_disable, "enable|disable") \
18098 _(lisp_map_register_enable_disable, "enable|disable") \
18099 _(lisp_rloc_probe_enable_disable, "enable|disable") \
18100 _(lisp_gpe_add_del_iface, "up|down") \
18101 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
18103 "rloc <locator> p <prio> " \
18104 "w <weight> [rloc <loc> ... ] " \
18105 "action <action> [del-all]") \
18106 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
18108 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
18109 _(lisp_map_request_mode, "src-dst|dst-only") \
18110 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
18111 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
18112 _(lisp_locator_set_dump, "[local | remote]") \
18113 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
18114 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
18115 "[local] | [remote]") \
18116 _(lisp_eid_table_vni_dump, "") \
18117 _(lisp_eid_table_map_dump, "l2|l3") \
18118 _(lisp_map_resolver_dump, "") \
18119 _(lisp_map_server_dump, "") \
18120 _(lisp_adjacencies_get, "vni <vni>") \
18121 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
18122 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
18123 _(show_lisp_rloc_probe_state, "") \
18124 _(show_lisp_map_register_state, "") \
18125 _(show_lisp_status, "") \
18126 _(lisp_get_map_request_itr_rlocs, "") \
18127 _(show_lisp_pitr, "") \
18128 _(show_lisp_map_request_mode, "") \
18129 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
18130 _(af_packet_delete, "name <host interface name>") \
18131 _(policer_add_del, "name <policer name> <params> [del]") \
18132 _(policer_dump, "[name <policer name>]") \
18133 _(policer_classify_set_interface, \
18134 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
18135 " [l2-table <nn>] [del]") \
18136 _(policer_classify_dump, "type [ip4|ip6|l2]") \
18137 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
18138 "[master|slave]") \
18139 _(netmap_delete, "name <interface name>") \
18140 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
18141 _(mpls_fib_dump, "") \
18142 _(classify_table_ids, "") \
18143 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
18144 _(classify_table_info, "table_id <nn>") \
18145 _(classify_session_dump, "table_id <nn>") \
18146 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
18147 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
18148 "[template_interval <nn>] [udp_checksum]") \
18149 _(ipfix_exporter_dump, "") \
18150 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
18151 _(ipfix_classify_stream_dump, "") \
18152 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
18153 _(ipfix_classify_table_dump, "") \
18154 _(sw_interface_span_enable_disable, "[src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
18155 _(sw_interface_span_dump, "") \
18156 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
18157 _(pg_create_interface, "if_id <nn>") \
18158 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
18159 _(pg_enable_disable, "[stream <id>] disable") \
18160 _(ip_source_and_port_range_check_add_del, \
18161 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
18162 _(ip_source_and_port_range_check_interface_add_del, \
18163 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
18164 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
18165 _(ipsec_gre_add_del_tunnel, \
18166 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
18167 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
18168 _(delete_subif,"<intfc> | sw_if_index <nn>") \
18169 _(l2_interface_pbb_tag_rewrite, \
18170 "<intfc> | sw_if_index <nn> \n" \
18171 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
18172 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
18173 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
18174 _(flow_classify_set_interface, \
18175 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
18176 _(flow_classify_dump, "type [ip4|ip6]") \
18177 _(ip_fib_dump, "") \
18178 _(ip6_fib_dump, "") \
18179 _(feature_enable_disable, "arc_name <arc_name> " \
18180 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
18181 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
18183 _(l2_xconnect_dump, "") \
18184 _(sw_interface_set_mtu, "<intfc> | sw_if_index <nn> mtu <nn>") \
18185 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
18186 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]")
18189 #define foreach_vpe_dpdk_api_msg \
18190 _(sw_interface_set_dpdk_hqos_pipe, \
18191 "rx <intfc> | sw_if_index <id> subport <subport-id> pipe <pipe-id>\n" \
18192 "profile <profile-id>\n") \
18193 _(sw_interface_set_dpdk_hqos_subport, \
18194 "rx <intfc> | sw_if_index <id> subport <subport-id> [rate <n>]\n" \
18195 "[bktsize <n>] [tc0 <n>] [tc1 <n>] [tc2 <n>] [tc3 <n>] [period <n>]\n") \
18196 _(sw_interface_set_dpdk_hqos_tctbl, \
18197 "rx <intfc> | sw_if_index <id> entry <n> tc <n> queue <n>\n")
18200 /* List of command functions, CLI names map directly to functions */
18201 #define foreach_cli_function \
18202 _(comment, "usage: comment <ignore-rest-of-line>") \
18203 _(dump_interface_table, "usage: dump_interface_table") \
18204 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
18205 _(dump_ipv4_table, "usage: dump_ipv4_table") \
18206 _(dump_ipv6_table, "usage: dump_ipv6_table") \
18207 _(dump_stats_table, "usage: dump_stats_table") \
18208 _(dump_macro_table, "usage: dump_macro_table ") \
18209 _(dump_node_table, "usage: dump_node_table") \
18210 _(dump_msg_api_table, "usage: dump_msg_api_table") \
18211 _(get_msg_id, "usage: get_msg_id name_and_crc") \
18212 _(echo, "usage: echo <message>") \
18213 _(exec, "usage: exec <vpe-debug-CLI-command>") \
18214 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
18215 _(help, "usage: help") \
18216 _(q, "usage: quit") \
18217 _(quit, "usage: quit") \
18218 _(search_node_table, "usage: search_node_table <name>...") \
18219 _(set, "usage: set <variable-name> <value>") \
18220 _(script, "usage: script <file-name>") \
18221 _(unset, "usage: unset <variable-name>")
18224 static void vl_api_##n##_t_handler_uni \
18225 (vl_api_##n##_t * mp) \
18227 vat_main_t * vam = &vat_main; \
18228 if (vam->json_output) { \
18229 vl_api_##n##_t_handler_json(mp); \
18231 vl_api_##n##_t_handler(mp); \
18234 foreach_vpe_api_reply_msg;
18239 static void vl_api_##n##_t_handler_uni \
18240 (vl_api_##n##_t * mp) \
18242 vat_main_t * vam = &vat_main; \
18243 if (vam->json_output) { \
18244 vl_api_##n##_t_handler_json(mp); \
18246 vl_api_##n##_t_handler(mp); \
18249 foreach_vpe_dpdk_api_reply_msg;
18254 vat_api_hookup (vat_main_t * vam)
18257 vl_msg_api_set_handlers(VL_API_##N, #n, \
18258 vl_api_##n##_t_handler_uni, \
18260 vl_api_##n##_t_endian, \
18261 vl_api_##n##_t_print, \
18262 sizeof(vl_api_##n##_t), 1);
18263 foreach_vpe_api_reply_msg;
18268 vl_msg_api_set_handlers(VL_API_##N, #n, \
18269 vl_api_##n##_t_handler_uni, \
18271 vl_api_##n##_t_endian, \
18272 vl_api_##n##_t_print, \
18273 sizeof(vl_api_##n##_t), 1);
18274 foreach_vpe_dpdk_api_reply_msg;
18278 #if (VPP_API_TEST_BUILTIN==0)
18279 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
18282 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
18284 vam->function_by_name = hash_create_string (0, sizeof (uword));
18286 vam->help_by_name = hash_create_string (0, sizeof (uword));
18288 /* API messages we can send */
18289 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
18290 foreach_vpe_api_msg;
18293 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
18294 foreach_vpe_dpdk_api_msg;
18299 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
18300 foreach_vpe_api_msg;
18303 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
18304 foreach_vpe_dpdk_api_msg;
18308 /* CLI functions */
18309 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
18310 foreach_cli_function;
18314 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
18315 foreach_cli_function;
18320 * fd.io coding-style-patch-verification: ON
18323 * eval: (c-set-style "gnu")