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... */
6712 api_mpls_route_add_del (vat_main_t * vam)
6714 unformat_input_t *i = vam->input;
6715 vl_api_mpls_route_add_del_t *mp;
6717 u32 sw_if_index = ~0, table_id = 0;
6718 u8 create_table_if_needed = 0;
6720 u32 next_hop_weight = 1;
6721 u8 is_multipath = 0;
6722 u32 next_hop_table_id = 0;
6723 u8 next_hop_set = 0;
6724 ip4_address_t v4_next_hop_address = {
6727 ip6_address_t v6_next_hop_address = { {0} };
6731 u32 classify_table_index = ~0;
6733 u8 resolve_host = 0, resolve_attached = 0;
6734 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
6735 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6736 mpls_label_t *next_hop_out_label_stack = NULL;
6737 mpls_label_t local_label = MPLS_LABEL_INVALID;
6739 u8 next_hop_proto_is_ip4 = 1;
6741 /* Parse args required to build the message */
6742 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6744 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
6746 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6748 else if (unformat (i, "%d", &local_label))
6750 else if (unformat (i, "eos"))
6752 else if (unformat (i, "non-eos"))
6754 else if (unformat (i, "via %U", unformat_ip4_address,
6755 &v4_next_hop_address))
6758 next_hop_proto_is_ip4 = 1;
6760 else if (unformat (i, "via %U", unformat_ip6_address,
6761 &v6_next_hop_address))
6764 next_hop_proto_is_ip4 = 0;
6766 else if (unformat (i, "weight %d", &next_hop_weight))
6768 else if (unformat (i, "create-table"))
6769 create_table_if_needed = 1;
6770 else if (unformat (i, "classify %d", &classify_table_index))
6774 else if (unformat (i, "del"))
6776 else if (unformat (i, "add"))
6778 else if (unformat (i, "resolve-via-host"))
6780 else if (unformat (i, "resolve-via-attached"))
6781 resolve_attached = 1;
6782 else if (unformat (i, "multipath"))
6784 else if (unformat (i, "count %d", &count))
6786 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
6789 next_hop_proto_is_ip4 = 1;
6791 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
6794 next_hop_proto_is_ip4 = 0;
6796 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6798 else if (unformat (i, "via-label %d", &next_hop_via_label))
6800 else if (unformat (i, "out-label %d", &next_hop_out_label))
6801 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
6804 clib_warning ("parse error '%U'", format_unformat_error, i);
6809 if (!next_hop_set && !is_classify)
6811 errmsg ("next hop / classify not set");
6815 if (MPLS_LABEL_INVALID == local_label)
6817 errmsg ("missing label");
6823 /* Turn on async mode */
6824 vam->async_mode = 1;
6825 vam->async_errors = 0;
6826 before = vat_time_now (vam);
6829 for (j = 0; j < count; j++)
6831 /* Construct the API message */
6832 M2 (MPLS_ROUTE_ADD_DEL, mpls_route_add_del,
6833 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
6835 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
6836 mp->mr_table_id = ntohl (table_id);
6837 mp->mr_create_table_if_needed = create_table_if_needed;
6839 mp->mr_is_add = is_add;
6840 mp->mr_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
6841 mp->mr_is_classify = is_classify;
6842 mp->mr_is_multipath = is_multipath;
6843 mp->mr_is_resolve_host = resolve_host;
6844 mp->mr_is_resolve_attached = resolve_attached;
6845 mp->mr_next_hop_weight = next_hop_weight;
6846 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
6847 mp->mr_classify_table_index = ntohl (classify_table_index);
6848 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
6849 mp->mr_label = ntohl (local_label);
6850 mp->mr_eos = is_eos;
6852 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
6853 if (0 != mp->mr_next_hop_n_out_labels)
6855 memcpy (mp->mr_next_hop_out_label_stack,
6856 next_hop_out_label_stack,
6857 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
6858 vec_free (next_hop_out_label_stack);
6863 if (next_hop_proto_is_ip4)
6865 clib_memcpy (mp->mr_next_hop,
6866 &v4_next_hop_address,
6867 sizeof (v4_next_hop_address));
6871 clib_memcpy (mp->mr_next_hop,
6872 &v6_next_hop_address,
6873 sizeof (v6_next_hop_address));
6880 /* If we receive SIGTERM, stop now... */
6885 /* When testing multiple add/del ops, use a control-ping to sync */
6888 vl_api_control_ping_t *mp;
6891 /* Shut off async mode */
6892 vam->async_mode = 0;
6894 M (CONTROL_PING, control_ping);
6897 timeout = vat_time_now (vam) + 1.0;
6898 while (vat_time_now (vam) < timeout)
6899 if (vam->result_ready == 1)
6904 if (vam->retval == -99)
6907 if (vam->async_errors > 0)
6909 errmsg ("%d asynchronous errors", vam->async_errors);
6912 vam->async_errors = 0;
6913 after = vat_time_now (vam);
6915 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6919 print (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec",
6920 count, after - before, count / (after - before));
6924 /* Wait for a reply... */
6928 /* Return the good/bad news */
6929 return (vam->retval);
6933 api_mpls_ip_bind_unbind (vat_main_t * vam)
6935 unformat_input_t *i = vam->input;
6936 vl_api_mpls_ip_bind_unbind_t *mp;
6938 u32 ip_table_id = 0;
6939 u8 create_table_if_needed = 0;
6942 ip4_address_t v4_address;
6943 ip6_address_t v6_address;
6946 mpls_label_t local_label = MPLS_LABEL_INVALID;
6948 /* Parse args required to build the message */
6949 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6951 if (unformat (i, "%U/%d", unformat_ip4_address,
6952 &v4_address, &address_length))
6957 else if (unformat (i, "%U/%d", unformat_ip6_address,
6958 &v6_address, &address_length))
6963 else if (unformat (i, "%d", &local_label))
6965 else if (unformat (i, "create-table"))
6966 create_table_if_needed = 1;
6967 else if (unformat (i, "table-id %d", &ip_table_id))
6969 else if (unformat (i, "unbind"))
6971 else if (unformat (i, "bind"))
6975 clib_warning ("parse error '%U'", format_unformat_error, i);
6982 errmsg ("IP addres not set");
6986 if (MPLS_LABEL_INVALID == local_label)
6988 errmsg ("missing label");
6992 /* Construct the API message */
6993 M (MPLS_IP_BIND_UNBIND, mpls_ip_bind_unbind);
6995 mp->mb_create_table_if_needed = create_table_if_needed;
6996 mp->mb_is_bind = is_bind;
6997 mp->mb_is_ip4 = is_ip4;
6998 mp->mb_ip_table_id = ntohl (ip_table_id);
6999 mp->mb_mpls_table_id = 0;
7000 mp->mb_label = ntohl (local_label);
7001 mp->mb_address_length = address_length;
7004 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
7006 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
7011 /* Wait for a reply... */
7016 api_proxy_arp_add_del (vat_main_t * vam)
7018 unformat_input_t *i = vam->input;
7019 vl_api_proxy_arp_add_del_t *mp;
7023 ip4_address_t lo, hi;
7026 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7028 if (unformat (i, "vrf %d", &vrf_id))
7030 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
7031 unformat_ip4_address, &hi))
7033 else if (unformat (i, "del"))
7037 clib_warning ("parse error '%U'", format_unformat_error, i);
7044 errmsg ("address range not set");
7048 M (PROXY_ARP_ADD_DEL, proxy_arp_add_del);
7050 mp->vrf_id = ntohl (vrf_id);
7051 mp->is_add = is_add;
7052 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
7053 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
7062 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
7064 unformat_input_t *i = vam->input;
7065 vl_api_proxy_arp_intfc_enable_disable_t *mp;
7069 u8 sw_if_index_set = 0;
7071 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7073 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7074 sw_if_index_set = 1;
7075 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7076 sw_if_index_set = 1;
7077 else if (unformat (i, "enable"))
7079 else if (unformat (i, "disable"))
7083 clib_warning ("parse error '%U'", format_unformat_error, i);
7088 if (sw_if_index_set == 0)
7090 errmsg ("missing interface name or sw_if_index");
7094 M (PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable);
7096 mp->sw_if_index = ntohl (sw_if_index);
7097 mp->enable_disable = enable;
7106 api_mpls_tunnel_add_del (vat_main_t * vam)
7108 unformat_input_t *i = vam->input;
7109 vl_api_mpls_tunnel_add_del_t *mp;
7114 u32 sw_if_index = ~0;
7115 u32 next_hop_sw_if_index = ~0;
7116 u32 next_hop_proto_is_ip4 = 1;
7118 u32 next_hop_table_id = 0;
7119 ip4_address_t v4_next_hop_address = {
7122 ip6_address_t v6_next_hop_address = { {0} };
7123 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID, *labels = NULL;
7125 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7127 if (unformat (i, "add"))
7129 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
7131 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
7133 else if (unformat (i, "via %U",
7134 unformat_ip4_address, &v4_next_hop_address))
7136 next_hop_proto_is_ip4 = 1;
7138 else if (unformat (i, "via %U",
7139 unformat_ip6_address, &v6_next_hop_address))
7141 next_hop_proto_is_ip4 = 0;
7143 else if (unformat (i, "l2-only"))
7145 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
7147 else if (unformat (i, "out-label %d", &next_hop_out_label))
7148 vec_add1 (labels, ntohl (next_hop_out_label));
7151 clib_warning ("parse error '%U'", format_unformat_error, i);
7156 M2 (MPLS_TUNNEL_ADD_DEL, mpls_tunnel_add_del,
7157 sizeof (mpls_label_t) * vec_len (labels));
7159 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
7160 mp->mt_sw_if_index = ntohl (sw_if_index);
7161 mp->mt_is_add = is_add;
7162 mp->mt_l2_only = l2_only;
7163 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
7164 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
7166 mp->mt_next_hop_n_out_labels = vec_len (labels);
7168 if (0 != mp->mt_next_hop_n_out_labels)
7170 clib_memcpy (mp->mt_next_hop_out_label_stack, labels,
7171 sizeof (mpls_label_t) * mp->mt_next_hop_n_out_labels);
7175 if (next_hop_proto_is_ip4)
7177 clib_memcpy (mp->mt_next_hop,
7178 &v4_next_hop_address, sizeof (v4_next_hop_address));
7182 clib_memcpy (mp->mt_next_hop,
7183 &v6_next_hop_address, sizeof (v6_next_hop_address));
7193 api_sw_interface_set_unnumbered (vat_main_t * vam)
7195 unformat_input_t *i = vam->input;
7196 vl_api_sw_interface_set_unnumbered_t *mp;
7199 u32 unnum_sw_index = ~0;
7201 u8 sw_if_index_set = 0;
7203 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7205 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7206 sw_if_index_set = 1;
7207 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7208 sw_if_index_set = 1;
7209 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
7211 else if (unformat (i, "del"))
7215 clib_warning ("parse error '%U'", format_unformat_error, i);
7220 if (sw_if_index_set == 0)
7222 errmsg ("missing interface name or sw_if_index");
7226 M (SW_INTERFACE_SET_UNNUMBERED, sw_interface_set_unnumbered);
7228 mp->sw_if_index = ntohl (sw_if_index);
7229 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
7230 mp->is_add = is_add;
7239 api_ip_neighbor_add_del (vat_main_t * vam)
7241 unformat_input_t *i = vam->input;
7242 vl_api_ip_neighbor_add_del_t *mp;
7245 u8 sw_if_index_set = 0;
7251 u8 v4_address_set = 0;
7252 u8 v6_address_set = 0;
7253 ip4_address_t v4address;
7254 ip6_address_t v6address;
7256 memset (mac_address, 0, sizeof (mac_address));
7258 /* Parse args required to build the message */
7259 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7261 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
7265 else if (unformat (i, "del"))
7268 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7269 sw_if_index_set = 1;
7270 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7271 sw_if_index_set = 1;
7272 else if (unformat (i, "is_static"))
7274 else if (unformat (i, "vrf %d", &vrf_id))
7276 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
7278 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
7282 clib_warning ("parse error '%U'", format_unformat_error, i);
7287 if (sw_if_index_set == 0)
7289 errmsg ("missing interface name or sw_if_index");
7292 if (v4_address_set && v6_address_set)
7294 errmsg ("both v4 and v6 addresses set");
7297 if (!v4_address_set && !v6_address_set)
7299 errmsg ("no address set");
7303 /* Construct the API message */
7304 M (IP_NEIGHBOR_ADD_DEL, ip_neighbor_add_del);
7306 mp->sw_if_index = ntohl (sw_if_index);
7307 mp->is_add = is_add;
7308 mp->vrf_id = ntohl (vrf_id);
7309 mp->is_static = is_static;
7311 clib_memcpy (mp->mac_address, mac_address, 6);
7315 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
7319 /* mp->is_ipv6 = 0; via memset in M macro above */
7320 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
7326 /* Wait for a reply, return good/bad news */
7334 api_reset_vrf (vat_main_t * vam)
7336 unformat_input_t *i = vam->input;
7337 vl_api_reset_vrf_t *mp;
7343 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7345 if (unformat (i, "vrf %d", &vrf_id))
7347 else if (unformat (i, "ipv6"))
7351 clib_warning ("parse error '%U'", format_unformat_error, i);
7356 if (vrf_id_set == 0)
7358 errmsg ("missing vrf id");
7362 M (RESET_VRF, reset_vrf);
7364 mp->vrf_id = ntohl (vrf_id);
7365 mp->is_ipv6 = is_ipv6;
7374 api_create_vlan_subif (vat_main_t * vam)
7376 unformat_input_t *i = vam->input;
7377 vl_api_create_vlan_subif_t *mp;
7380 u8 sw_if_index_set = 0;
7384 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7386 if (unformat (i, "sw_if_index %d", &sw_if_index))
7387 sw_if_index_set = 1;
7389 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7390 sw_if_index_set = 1;
7391 else if (unformat (i, "vlan %d", &vlan_id))
7395 clib_warning ("parse error '%U'", format_unformat_error, i);
7400 if (sw_if_index_set == 0)
7402 errmsg ("missing interface name or sw_if_index");
7406 if (vlan_id_set == 0)
7408 errmsg ("missing vlan_id");
7411 M (CREATE_VLAN_SUBIF, create_vlan_subif);
7413 mp->sw_if_index = ntohl (sw_if_index);
7414 mp->vlan_id = ntohl (vlan_id);
7422 #define foreach_create_subif_bit \
7429 _(outer_vlan_id_any) \
7430 _(inner_vlan_id_any)
7433 api_create_subif (vat_main_t * vam)
7435 unformat_input_t *i = vam->input;
7436 vl_api_create_subif_t *mp;
7439 u8 sw_if_index_set = 0;
7446 u32 exact_match = 0;
7447 u32 default_sub = 0;
7448 u32 outer_vlan_id_any = 0;
7449 u32 inner_vlan_id_any = 0;
7451 u16 outer_vlan_id = 0;
7452 u16 inner_vlan_id = 0;
7454 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7456 if (unformat (i, "sw_if_index %d", &sw_if_index))
7457 sw_if_index_set = 1;
7459 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7460 sw_if_index_set = 1;
7461 else if (unformat (i, "sub_id %d", &sub_id))
7463 else if (unformat (i, "outer_vlan_id %d", &tmp))
7464 outer_vlan_id = tmp;
7465 else if (unformat (i, "inner_vlan_id %d", &tmp))
7466 inner_vlan_id = tmp;
7468 #define _(a) else if (unformat (i, #a)) a = 1 ;
7469 foreach_create_subif_bit
7473 clib_warning ("parse error '%U'", format_unformat_error, i);
7478 if (sw_if_index_set == 0)
7480 errmsg ("missing interface name or sw_if_index");
7484 if (sub_id_set == 0)
7486 errmsg ("missing sub_id");
7489 M (CREATE_SUBIF, create_subif);
7491 mp->sw_if_index = ntohl (sw_if_index);
7492 mp->sub_id = ntohl (sub_id);
7494 #define _(a) mp->a = a;
7495 foreach_create_subif_bit;
7498 mp->outer_vlan_id = ntohs (outer_vlan_id);
7499 mp->inner_vlan_id = ntohs (inner_vlan_id);
7508 api_oam_add_del (vat_main_t * vam)
7510 unformat_input_t *i = vam->input;
7511 vl_api_oam_add_del_t *mp;
7515 ip4_address_t src, dst;
7519 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7521 if (unformat (i, "vrf %d", &vrf_id))
7523 else if (unformat (i, "src %U", unformat_ip4_address, &src))
7525 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
7527 else if (unformat (i, "del"))
7531 clib_warning ("parse error '%U'", format_unformat_error, i);
7538 errmsg ("missing src addr");
7544 errmsg ("missing dst addr");
7548 M (OAM_ADD_DEL, oam_add_del);
7550 mp->vrf_id = ntohl (vrf_id);
7551 mp->is_add = is_add;
7552 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
7553 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
7562 api_reset_fib (vat_main_t * vam)
7564 unformat_input_t *i = vam->input;
7565 vl_api_reset_fib_t *mp;
7571 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7573 if (unformat (i, "vrf %d", &vrf_id))
7575 else if (unformat (i, "ipv6"))
7579 clib_warning ("parse error '%U'", format_unformat_error, i);
7584 if (vrf_id_set == 0)
7586 errmsg ("missing vrf id");
7590 M (RESET_FIB, reset_fib);
7592 mp->vrf_id = ntohl (vrf_id);
7593 mp->is_ipv6 = is_ipv6;
7602 api_dhcp_proxy_config (vat_main_t * vam)
7604 unformat_input_t *i = vam->input;
7605 vl_api_dhcp_proxy_config_t *mp;
7610 u8 v4_address_set = 0;
7611 u8 v6_address_set = 0;
7612 ip4_address_t v4address;
7613 ip6_address_t v6address;
7614 u8 v4_src_address_set = 0;
7615 u8 v6_src_address_set = 0;
7616 ip4_address_t v4srcaddress;
7617 ip6_address_t v6srcaddress;
7619 /* Parse args required to build the message */
7620 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7622 if (unformat (i, "del"))
7624 else if (unformat (i, "vrf %d", &vrf_id))
7626 else if (unformat (i, "insert-cid %d", &insert_cid))
7628 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
7630 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
7632 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
7633 v4_src_address_set = 1;
7634 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
7635 v6_src_address_set = 1;
7640 if (v4_address_set && v6_address_set)
7642 errmsg ("both v4 and v6 server addresses set");
7645 if (!v4_address_set && !v6_address_set)
7647 errmsg ("no server addresses set");
7651 if (v4_src_address_set && v6_src_address_set)
7653 errmsg ("both v4 and v6 src addresses set");
7656 if (!v4_src_address_set && !v6_src_address_set)
7658 errmsg ("no src addresses set");
7662 if (!(v4_src_address_set && v4_address_set) &&
7663 !(v6_src_address_set && v6_address_set))
7665 errmsg ("no matching server and src addresses set");
7669 /* Construct the API message */
7670 M (DHCP_PROXY_CONFIG, dhcp_proxy_config);
7672 mp->insert_circuit_id = insert_cid;
7673 mp->is_add = is_add;
7674 mp->vrf_id = ntohl (vrf_id);
7678 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
7679 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
7683 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
7684 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
7690 /* Wait for a reply, return good/bad news */
7697 api_dhcp_proxy_config_2 (vat_main_t * vam)
7699 unformat_input_t *i = vam->input;
7700 vl_api_dhcp_proxy_config_2_t *mp;
7703 u32 server_vrf_id = 0;
7706 u8 v4_address_set = 0;
7707 u8 v6_address_set = 0;
7708 ip4_address_t v4address;
7709 ip6_address_t v6address;
7710 u8 v4_src_address_set = 0;
7711 u8 v6_src_address_set = 0;
7712 ip4_address_t v4srcaddress;
7713 ip6_address_t v6srcaddress;
7715 /* Parse args required to build the message */
7716 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7718 if (unformat (i, "del"))
7720 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
7722 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
7724 else if (unformat (i, "insert-cid %d", &insert_cid))
7726 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
7728 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
7730 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
7731 v4_src_address_set = 1;
7732 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
7733 v6_src_address_set = 1;
7738 if (v4_address_set && v6_address_set)
7740 errmsg ("both v4 and v6 server addresses set");
7743 if (!v4_address_set && !v6_address_set)
7745 errmsg ("no server addresses set");
7749 if (v4_src_address_set && v6_src_address_set)
7751 errmsg ("both v4 and v6 src addresses set");
7754 if (!v4_src_address_set && !v6_src_address_set)
7756 errmsg ("no src addresses set");
7760 if (!(v4_src_address_set && v4_address_set) &&
7761 !(v6_src_address_set && v6_address_set))
7763 errmsg ("no matching server and src addresses set");
7767 /* Construct the API message */
7768 M (DHCP_PROXY_CONFIG_2, dhcp_proxy_config_2);
7770 mp->insert_circuit_id = insert_cid;
7771 mp->is_add = is_add;
7772 mp->rx_vrf_id = ntohl (rx_vrf_id);
7773 mp->server_vrf_id = ntohl (server_vrf_id);
7777 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
7778 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
7782 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
7783 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
7789 /* Wait for a reply, return good/bad news */
7796 api_dhcp_proxy_set_vss (vat_main_t * vam)
7798 unformat_input_t *i = vam->input;
7799 vl_api_dhcp_proxy_set_vss_t *mp;
7810 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7812 if (unformat (i, "tbl_id %d", &tbl_id))
7814 if (unformat (i, "fib_id %d", &fib_id))
7816 if (unformat (i, "oui %d", &oui))
7818 else if (unformat (i, "ipv6"))
7820 else if (unformat (i, "del"))
7824 clib_warning ("parse error '%U'", format_unformat_error, i);
7829 if (tbl_id_set == 0)
7831 errmsg ("missing tbl id");
7835 if (fib_id_set == 0)
7837 errmsg ("missing fib id");
7842 errmsg ("missing oui");
7846 M (DHCP_PROXY_SET_VSS, dhcp_proxy_set_vss);
7847 mp->tbl_id = ntohl (tbl_id);
7848 mp->fib_id = ntohl (fib_id);
7849 mp->oui = ntohl (oui);
7850 mp->is_ipv6 = is_ipv6;
7851 mp->is_add = is_add;
7860 api_dhcp_client_config (vat_main_t * vam)
7862 unformat_input_t *i = vam->input;
7863 vl_api_dhcp_client_config_t *mp;
7866 u8 sw_if_index_set = 0;
7869 u8 disable_event = 0;
7871 /* Parse args required to build the message */
7872 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7874 if (unformat (i, "del"))
7877 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7878 sw_if_index_set = 1;
7879 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7880 sw_if_index_set = 1;
7881 else if (unformat (i, "hostname %s", &hostname))
7883 else if (unformat (i, "disable_event"))
7889 if (sw_if_index_set == 0)
7891 errmsg ("missing interface name or sw_if_index");
7895 if (vec_len (hostname) > 63)
7897 errmsg ("hostname too long");
7899 vec_add1 (hostname, 0);
7901 /* Construct the API message */
7902 M (DHCP_CLIENT_CONFIG, dhcp_client_config);
7904 mp->sw_if_index = ntohl (sw_if_index);
7905 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
7906 vec_free (hostname);
7907 mp->is_add = is_add;
7908 mp->want_dhcp_event = disable_event ? 0 : 1;
7909 mp->pid = getpid ();
7914 /* Wait for a reply, return good/bad news */
7921 api_set_ip_flow_hash (vat_main_t * vam)
7923 unformat_input_t *i = vam->input;
7924 vl_api_set_ip_flow_hash_t *mp;
7936 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7938 if (unformat (i, "vrf %d", &vrf_id))
7940 else if (unformat (i, "ipv6"))
7942 else if (unformat (i, "src"))
7944 else if (unformat (i, "dst"))
7946 else if (unformat (i, "sport"))
7948 else if (unformat (i, "dport"))
7950 else if (unformat (i, "proto"))
7952 else if (unformat (i, "reverse"))
7957 clib_warning ("parse error '%U'", format_unformat_error, i);
7962 if (vrf_id_set == 0)
7964 errmsg ("missing vrf id");
7968 M (SET_IP_FLOW_HASH, set_ip_flow_hash);
7974 mp->reverse = reverse;
7975 mp->vrf_id = ntohl (vrf_id);
7976 mp->is_ipv6 = is_ipv6;
7985 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
7987 unformat_input_t *i = vam->input;
7988 vl_api_sw_interface_ip6_enable_disable_t *mp;
7991 u8 sw_if_index_set = 0;
7994 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7996 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
7997 sw_if_index_set = 1;
7998 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7999 sw_if_index_set = 1;
8000 else if (unformat (i, "enable"))
8002 else if (unformat (i, "disable"))
8006 clib_warning ("parse error '%U'", format_unformat_error, i);
8011 if (sw_if_index_set == 0)
8013 errmsg ("missing interface name or sw_if_index");
8017 M (SW_INTERFACE_IP6_ENABLE_DISABLE, sw_interface_ip6_enable_disable);
8019 mp->sw_if_index = ntohl (sw_if_index);
8020 mp->enable = enable;
8029 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
8031 unformat_input_t *i = vam->input;
8032 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
8035 u8 sw_if_index_set = 0;
8036 u8 v6_address_set = 0;
8037 ip6_address_t v6address;
8039 /* Parse args required to build the message */
8040 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8042 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8043 sw_if_index_set = 1;
8044 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8045 sw_if_index_set = 1;
8046 else if (unformat (i, "%U", unformat_ip6_address, &v6address))
8052 if (sw_if_index_set == 0)
8054 errmsg ("missing interface name or sw_if_index");
8057 if (!v6_address_set)
8059 errmsg ("no address set");
8063 /* Construct the API message */
8064 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS,
8065 sw_interface_ip6_set_link_local_address);
8067 mp->sw_if_index = ntohl (sw_if_index);
8068 clib_memcpy (mp->address, &v6address, sizeof (v6address));
8073 /* Wait for a reply, return good/bad news */
8082 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
8084 unformat_input_t *i = vam->input;
8085 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
8088 u8 sw_if_index_set = 0;
8089 u32 address_length = 0;
8090 u8 v6_address_set = 0;
8091 ip6_address_t v6address;
8093 u8 no_advertise = 0;
8095 u8 no_autoconfig = 0;
8098 u32 val_lifetime = 0;
8099 u32 pref_lifetime = 0;
8101 /* Parse args required to build the message */
8102 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8104 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8105 sw_if_index_set = 1;
8106 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8107 sw_if_index_set = 1;
8108 else if (unformat (i, "%U/%d",
8109 unformat_ip6_address, &v6address, &address_length))
8111 else if (unformat (i, "val_life %d", &val_lifetime))
8113 else if (unformat (i, "pref_life %d", &pref_lifetime))
8115 else if (unformat (i, "def"))
8117 else if (unformat (i, "noadv"))
8119 else if (unformat (i, "offl"))
8121 else if (unformat (i, "noauto"))
8123 else if (unformat (i, "nolink"))
8125 else if (unformat (i, "isno"))
8129 clib_warning ("parse error '%U'", format_unformat_error, i);
8134 if (sw_if_index_set == 0)
8136 errmsg ("missing interface name or sw_if_index");
8139 if (!v6_address_set)
8141 errmsg ("no address set");
8145 /* Construct the API message */
8146 M (SW_INTERFACE_IP6ND_RA_PREFIX, sw_interface_ip6nd_ra_prefix);
8148 mp->sw_if_index = ntohl (sw_if_index);
8149 clib_memcpy (mp->address, &v6address, sizeof (v6address));
8150 mp->address_length = address_length;
8151 mp->use_default = use_default;
8152 mp->no_advertise = no_advertise;
8153 mp->off_link = off_link;
8154 mp->no_autoconfig = no_autoconfig;
8155 mp->no_onlink = no_onlink;
8157 mp->val_lifetime = ntohl (val_lifetime);
8158 mp->pref_lifetime = ntohl (pref_lifetime);
8163 /* Wait for a reply, return good/bad news */
8171 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
8173 unformat_input_t *i = vam->input;
8174 vl_api_sw_interface_ip6nd_ra_config_t *mp;
8177 u8 sw_if_index_set = 0;
8182 u8 send_unicast = 0;
8185 u8 default_router = 0;
8186 u32 max_interval = 0;
8187 u32 min_interval = 0;
8189 u32 initial_count = 0;
8190 u32 initial_interval = 0;
8193 /* Parse args required to build the message */
8194 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8196 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
8197 sw_if_index_set = 1;
8198 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8199 sw_if_index_set = 1;
8200 else if (unformat (i, "maxint %d", &max_interval))
8202 else if (unformat (i, "minint %d", &min_interval))
8204 else if (unformat (i, "life %d", &lifetime))
8206 else if (unformat (i, "count %d", &initial_count))
8208 else if (unformat (i, "interval %d", &initial_interval))
8210 else if (unformat (i, "suppress") || unformat (i, "surpress"))
8212 else if (unformat (i, "managed"))
8214 else if (unformat (i, "other"))
8216 else if (unformat (i, "ll"))
8218 else if (unformat (i, "send"))
8220 else if (unformat (i, "cease"))
8222 else if (unformat (i, "isno"))
8224 else if (unformat (i, "def"))
8228 clib_warning ("parse error '%U'", format_unformat_error, i);
8233 if (sw_if_index_set == 0)
8235 errmsg ("missing interface name or sw_if_index");
8239 /* Construct the API message */
8240 M (SW_INTERFACE_IP6ND_RA_CONFIG, sw_interface_ip6nd_ra_config);
8242 mp->sw_if_index = ntohl (sw_if_index);
8243 mp->max_interval = ntohl (max_interval);
8244 mp->min_interval = ntohl (min_interval);
8245 mp->lifetime = ntohl (lifetime);
8246 mp->initial_count = ntohl (initial_count);
8247 mp->initial_interval = ntohl (initial_interval);
8248 mp->suppress = suppress;
8249 mp->managed = managed;
8251 mp->ll_option = ll_option;
8252 mp->send_unicast = send_unicast;
8255 mp->default_router = default_router;
8260 /* Wait for a reply, return good/bad news */
8268 api_set_arp_neighbor_limit (vat_main_t * vam)
8270 unformat_input_t *i = vam->input;
8271 vl_api_set_arp_neighbor_limit_t *mp;
8277 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8279 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
8281 else if (unformat (i, "ipv6"))
8285 clib_warning ("parse error '%U'", format_unformat_error, i);
8292 errmsg ("missing limit value");
8296 M (SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit);
8298 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
8299 mp->is_ipv6 = is_ipv6;
8308 api_l2_patch_add_del (vat_main_t * vam)
8310 unformat_input_t *i = vam->input;
8311 vl_api_l2_patch_add_del_t *mp;
8314 u8 rx_sw_if_index_set = 0;
8316 u8 tx_sw_if_index_set = 0;
8319 /* Parse args required to build the message */
8320 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8322 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
8323 rx_sw_if_index_set = 1;
8324 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
8325 tx_sw_if_index_set = 1;
8326 else if (unformat (i, "rx"))
8328 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8330 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
8332 rx_sw_if_index_set = 1;
8337 else if (unformat (i, "tx"))
8339 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8341 if (unformat (i, "%U", api_unformat_sw_if_index, vam,
8343 tx_sw_if_index_set = 1;
8348 else if (unformat (i, "del"))
8354 if (rx_sw_if_index_set == 0)
8356 errmsg ("missing rx interface name or rx_sw_if_index");
8360 if (tx_sw_if_index_set == 0)
8362 errmsg ("missing tx interface name or tx_sw_if_index");
8366 M (L2_PATCH_ADD_DEL, l2_patch_add_del);
8368 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
8369 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
8370 mp->is_add = is_add;
8379 api_ioam_enable (vat_main_t * vam)
8381 unformat_input_t *input = vam->input;
8382 vl_api_ioam_enable_t *mp;
8385 int has_trace_option = 0;
8386 int has_pot_option = 0;
8387 int has_seqno_option = 0;
8388 int has_analyse_option = 0;
8390 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8392 if (unformat (input, "trace"))
8393 has_trace_option = 1;
8394 else if (unformat (input, "pot"))
8396 else if (unformat (input, "seqno"))
8397 has_seqno_option = 1;
8398 else if (unformat (input, "analyse"))
8399 has_analyse_option = 1;
8403 M (IOAM_ENABLE, ioam_enable);
8404 mp->id = htons (id);
8405 mp->seqno = has_seqno_option;
8406 mp->analyse = has_analyse_option;
8407 mp->pot_enable = has_pot_option;
8408 mp->trace_enable = has_trace_option;
8419 api_ioam_disable (vat_main_t * vam)
8421 vl_api_ioam_disable_t *mp;
8424 M (IOAM_DISABLE, ioam_disable);
8431 api_sr_tunnel_add_del (vat_main_t * vam)
8433 unformat_input_t *i = vam->input;
8434 vl_api_sr_tunnel_add_del_t *mp;
8438 ip6_address_t src_address;
8439 int src_address_set = 0;
8440 ip6_address_t dst_address;
8442 int dst_address_set = 0;
8444 u32 rx_table_id = 0;
8445 u32 tx_table_id = 0;
8446 ip6_address_t *segments = 0;
8447 ip6_address_t *this_seg;
8448 ip6_address_t *tags = 0;
8449 ip6_address_t *this_tag;
8450 ip6_address_t next_address, tag;
8452 u8 *policy_name = 0;
8454 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8456 if (unformat (i, "del"))
8458 else if (unformat (i, "name %s", &name))
8460 else if (unformat (i, "policy %s", &policy_name))
8462 else if (unformat (i, "rx_fib_id %d", &rx_table_id))
8464 else if (unformat (i, "tx_fib_id %d", &tx_table_id))
8466 else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
8467 src_address_set = 1;
8468 else if (unformat (i, "dst %U/%d",
8469 unformat_ip6_address, &dst_address, &dst_mask_width))
8470 dst_address_set = 1;
8471 else if (unformat (i, "next %U", unformat_ip6_address, &next_address))
8473 vec_add2 (segments, this_seg, 1);
8474 clib_memcpy (this_seg->as_u8, next_address.as_u8,
8475 sizeof (*this_seg));
8477 else if (unformat (i, "tag %U", unformat_ip6_address, &tag))
8479 vec_add2 (tags, this_tag, 1);
8480 clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
8482 else if (unformat (i, "clean"))
8483 flags |= IP6_SR_HEADER_FLAG_CLEANUP;
8484 else if (unformat (i, "protected"))
8485 flags |= IP6_SR_HEADER_FLAG_PROTECTED;
8486 else if (unformat (i, "InPE %d", &pl_index))
8488 if (pl_index <= 0 || pl_index > 4)
8490 pl_index_range_error:
8491 errmsg ("pl index %d out of range", pl_index);
8495 IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE << (3 * (pl_index - 1));
8497 else if (unformat (i, "EgPE %d", &pl_index))
8499 if (pl_index <= 0 || pl_index > 4)
8500 goto pl_index_range_error;
8502 IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE << (3 * (pl_index - 1));
8504 else if (unformat (i, "OrgSrc %d", &pl_index))
8506 if (pl_index <= 0 || pl_index > 4)
8507 goto pl_index_range_error;
8509 IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3 * (pl_index - 1));
8515 if (!src_address_set)
8517 errmsg ("src address required");
8521 if (!dst_address_set)
8523 errmsg ("dst address required");
8529 errmsg ("at least one sr segment required");
8533 M2 (SR_TUNNEL_ADD_DEL, sr_tunnel_add_del,
8534 vec_len (segments) * sizeof (ip6_address_t)
8535 + vec_len (tags) * sizeof (ip6_address_t));
8537 clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
8538 clib_memcpy (mp->dst_address, &dst_address, sizeof (mp->dst_address));
8539 mp->dst_mask_width = dst_mask_width;
8540 mp->flags_net_byte_order = clib_host_to_net_u16 (flags);
8541 mp->n_segments = vec_len (segments);
8542 mp->n_tags = vec_len (tags);
8543 mp->is_add = is_del == 0;
8544 clib_memcpy (mp->segs_and_tags, segments,
8545 vec_len (segments) * sizeof (ip6_address_t));
8546 clib_memcpy (mp->segs_and_tags +
8547 vec_len (segments) * sizeof (ip6_address_t), tags,
8548 vec_len (tags) * sizeof (ip6_address_t));
8550 mp->outer_vrf_id = ntohl (rx_table_id);
8551 mp->inner_vrf_id = ntohl (tx_table_id);
8552 memcpy (mp->name, name, vec_len (name));
8553 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
8555 vec_free (segments);
8564 api_sr_policy_add_del (vat_main_t * vam)
8566 unformat_input_t *input = vam->input;
8567 vl_api_sr_policy_add_del_t *mp;
8571 u8 *tunnel_name = 0;
8572 u8 **tunnel_names = 0;
8577 int tunnel_names_length = 1; // Init to 1 to offset the #tunnel_names counter byte
8578 int tun_name_len = 0; // Different naming convention used as confusing these would be "bad" (TM)
8580 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8582 if (unformat (input, "del"))
8584 else if (unformat (input, "name %s", &name))
8586 else if (unformat (input, "tunnel %s", &tunnel_name))
8590 vec_add1 (tunnel_names, tunnel_name);
8592 - length = #bytes to store in serial vector
8593 - +1 = byte to store that length
8595 tunnel_names_length += (vec_len (tunnel_name) + 1);
8606 errmsg ("policy name required");
8610 if ((!tunnel_set) && (!is_del))
8612 errmsg ("tunnel name required");
8616 M2 (SR_POLICY_ADD_DEL, sr_policy_add_del, tunnel_names_length);
8620 mp->is_add = !is_del;
8622 memcpy (mp->name, name, vec_len (name));
8623 // Since mp->tunnel_names is of type u8[0] and not a u8 *, u8 ** needs to be serialized
8624 u8 *serial_orig = 0;
8625 vec_validate (serial_orig, tunnel_names_length);
8626 *serial_orig = vec_len (tunnel_names); // Store the number of tunnels as length in first byte of serialized vector
8627 serial_orig += 1; // Move along one byte to store the length of first tunnel_name
8629 for (j = 0; j < vec_len (tunnel_names); j++)
8631 tun_name_len = vec_len (tunnel_names[j]);
8632 *serial_orig = tun_name_len; // Store length of tunnel name in first byte of Length/Value pair
8633 serial_orig += 1; // Move along one byte to store the actual tunnel name
8634 memcpy (serial_orig, tunnel_names[j], tun_name_len);
8635 serial_orig += tun_name_len; // Advance past the copy
8637 memcpy (mp->tunnel_names, serial_orig - tunnel_names_length, tunnel_names_length); // Regress serial_orig to head then copy fwd
8639 vec_free (tunnel_names);
8640 vec_free (tunnel_name);
8648 api_sr_multicast_map_add_del (vat_main_t * vam)
8650 unformat_input_t *input = vam->input;
8651 vl_api_sr_multicast_map_add_del_t *mp;
8654 ip6_address_t multicast_address;
8655 u8 *policy_name = 0;
8656 int multicast_address_set = 0;
8658 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8660 if (unformat (input, "del"))
8664 (input, "address %U", unformat_ip6_address, &multicast_address))
8665 multicast_address_set = 1;
8666 else if (unformat (input, "sr-policy %s", &policy_name))
8672 if (!is_del && !policy_name)
8674 errmsg ("sr-policy name required");
8679 if (!multicast_address_set)
8681 errmsg ("address required");
8685 M (SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del);
8687 mp->is_add = !is_del;
8688 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
8689 clib_memcpy (mp->multicast_address, &multicast_address,
8690 sizeof (mp->multicast_address));
8693 vec_free (policy_name);
8701 #define foreach_tcp_proto_field \
8705 #define foreach_udp_proto_field \
8709 #define foreach_ip4_proto_field \
8720 unformat_tcp_mask (unformat_input_t * input, va_list * args)
8722 u8 **maskp = va_arg (*args, u8 **);
8724 u8 found_something = 0;
8727 #define _(a) u8 a=0;
8728 foreach_tcp_proto_field;
8731 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8734 #define _(a) else if (unformat (input, #a)) a=1;
8735 foreach_tcp_proto_field
8741 #define _(a) found_something += a;
8742 foreach_tcp_proto_field;
8745 if (found_something == 0)
8748 vec_validate (mask, sizeof (*tcp) - 1);
8750 tcp = (tcp_header_t *) mask;
8752 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
8753 foreach_tcp_proto_field;
8761 unformat_udp_mask (unformat_input_t * input, va_list * args)
8763 u8 **maskp = va_arg (*args, u8 **);
8765 u8 found_something = 0;
8768 #define _(a) u8 a=0;
8769 foreach_udp_proto_field;
8772 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8775 #define _(a) else if (unformat (input, #a)) a=1;
8776 foreach_udp_proto_field
8782 #define _(a) found_something += a;
8783 foreach_udp_proto_field;
8786 if (found_something == 0)
8789 vec_validate (mask, sizeof (*udp) - 1);
8791 udp = (udp_header_t *) mask;
8793 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
8794 foreach_udp_proto_field;
8803 u16 src_port, dst_port;
8807 unformat_l4_mask (unformat_input_t * input, va_list * args)
8809 u8 **maskp = va_arg (*args, u8 **);
8810 u16 src_port = 0, dst_port = 0;
8811 tcpudp_header_t *tcpudp;
8813 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8815 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
8817 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
8819 else if (unformat (input, "src_port"))
8821 else if (unformat (input, "dst_port"))
8827 if (!src_port && !dst_port)
8831 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
8833 tcpudp = (tcpudp_header_t *) mask;
8834 tcpudp->src_port = src_port;
8835 tcpudp->dst_port = dst_port;
8843 unformat_ip4_mask (unformat_input_t * input, va_list * args)
8845 u8 **maskp = va_arg (*args, u8 **);
8847 u8 found_something = 0;
8850 #define _(a) u8 a=0;
8851 foreach_ip4_proto_field;
8857 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8859 if (unformat (input, "version"))
8861 else if (unformat (input, "hdr_length"))
8863 else if (unformat (input, "src"))
8865 else if (unformat (input, "dst"))
8867 else if (unformat (input, "proto"))
8870 #define _(a) else if (unformat (input, #a)) a=1;
8871 foreach_ip4_proto_field
8877 #define _(a) found_something += a;
8878 foreach_ip4_proto_field;
8881 if (found_something == 0)
8884 vec_validate (mask, sizeof (*ip) - 1);
8886 ip = (ip4_header_t *) mask;
8888 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
8889 foreach_ip4_proto_field;
8892 ip->ip_version_and_header_length = 0;
8895 ip->ip_version_and_header_length |= 0xF0;
8898 ip->ip_version_and_header_length |= 0x0F;
8904 #define foreach_ip6_proto_field \
8912 unformat_ip6_mask (unformat_input_t * input, va_list * args)
8914 u8 **maskp = va_arg (*args, u8 **);
8916 u8 found_something = 0;
8918 u32 ip_version_traffic_class_and_flow_label;
8920 #define _(a) u8 a=0;
8921 foreach_ip6_proto_field;
8924 u8 traffic_class = 0;
8927 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8929 if (unformat (input, "version"))
8931 else if (unformat (input, "traffic-class"))
8933 else if (unformat (input, "flow-label"))
8935 else if (unformat (input, "src"))
8937 else if (unformat (input, "dst"))
8939 else if (unformat (input, "proto"))
8942 #define _(a) else if (unformat (input, #a)) a=1;
8943 foreach_ip6_proto_field
8949 #define _(a) found_something += a;
8950 foreach_ip6_proto_field;
8953 if (found_something == 0)
8956 vec_validate (mask, sizeof (*ip) - 1);
8958 ip = (ip6_header_t *) mask;
8960 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
8961 foreach_ip6_proto_field;
8964 ip_version_traffic_class_and_flow_label = 0;
8967 ip_version_traffic_class_and_flow_label |= 0xF0000000;
8970 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
8973 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
8975 ip->ip_version_traffic_class_and_flow_label =
8976 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
8983 unformat_l3_mask (unformat_input_t * input, va_list * args)
8985 u8 **maskp = va_arg (*args, u8 **);
8987 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8989 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
8991 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
9000 unformat_l2_mask (unformat_input_t * input, va_list * args)
9002 u8 **maskp = va_arg (*args, u8 **);
9017 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9019 if (unformat (input, "src"))
9021 else if (unformat (input, "dst"))
9023 else if (unformat (input, "proto"))
9025 else if (unformat (input, "tag1"))
9027 else if (unformat (input, "tag2"))
9029 else if (unformat (input, "ignore-tag1"))
9031 else if (unformat (input, "ignore-tag2"))
9033 else if (unformat (input, "cos1"))
9035 else if (unformat (input, "cos2"))
9037 else if (unformat (input, "dot1q"))
9039 else if (unformat (input, "dot1ad"))
9044 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
9045 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9048 if (tag1 || ignore_tag1 || cos1 || dot1q)
9050 if (tag2 || ignore_tag2 || cos2 || dot1ad)
9053 vec_validate (mask, len - 1);
9056 memset (mask, 0xff, 6);
9059 memset (mask + 6, 0xff, 6);
9063 /* inner vlan tag */
9072 mask[21] = mask[20] = 0xff;
9093 mask[16] = mask[17] = 0xff;
9103 mask[12] = mask[13] = 0xff;
9110 unformat_classify_mask (unformat_input_t * input, va_list * args)
9112 u8 **maskp = va_arg (*args, u8 **);
9113 u32 *skipp = va_arg (*args, u32 *);
9114 u32 *matchp = va_arg (*args, u32 *);
9122 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9124 if (unformat (input, "hex %U", unformat_hex_string, &mask))
9126 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
9128 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
9130 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
9144 if (mask || l2 || l3 || l4)
9148 /* "With a free Ethernet header in every package" */
9150 vec_validate (l2, 13);
9154 vec_append (mask, l3);
9159 vec_append (mask, l4);
9164 /* Scan forward looking for the first significant mask octet */
9165 for (i = 0; i < vec_len (mask); i++)
9169 /* compute (skip, match) params */
9170 *skipp = i / sizeof (u32x4);
9171 vec_delete (mask, *skipp * sizeof (u32x4), 0);
9173 /* Pad mask to an even multiple of the vector size */
9174 while (vec_len (mask) % sizeof (u32x4))
9177 match = vec_len (mask) / sizeof (u32x4);
9179 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
9181 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
9182 if (*tmp || *(tmp + 1))
9187 clib_warning ("BUG: match 0");
9189 _vec_len (mask) = match * sizeof (u32x4);
9200 #define foreach_l2_next \
9202 _(ethernet, ETHERNET_INPUT) \
9207 unformat_l2_next_index (unformat_input_t * input, va_list * args)
9209 u32 *miss_next_indexp = va_arg (*args, u32 *);
9214 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
9218 if (unformat (input, "%d", &tmp))
9227 *miss_next_indexp = next_index;
9231 #define foreach_ip_next \
9237 unformat_ip_next_index (unformat_input_t * input, va_list * args)
9239 u32 *miss_next_indexp = va_arg (*args, u32 *);
9244 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
9248 if (unformat (input, "%d", &tmp))
9257 *miss_next_indexp = next_index;
9261 #define foreach_acl_next \
9265 unformat_acl_next_index (unformat_input_t * input, va_list * args)
9267 u32 *miss_next_indexp = va_arg (*args, u32 *);
9272 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
9276 if (unformat (input, "permit"))
9281 else if (unformat (input, "%d", &tmp))
9290 *miss_next_indexp = next_index;
9295 unformat_policer_precolor (unformat_input_t * input, va_list * args)
9297 u32 *r = va_arg (*args, u32 *);
9299 if (unformat (input, "conform-color"))
9300 *r = POLICE_CONFORM;
9301 else if (unformat (input, "exceed-color"))
9310 api_classify_add_del_table (vat_main_t * vam)
9312 unformat_input_t *i = vam->input;
9313 vl_api_classify_add_del_table_t *mp;
9320 u32 table_index = ~0;
9321 u32 next_table_index = ~0;
9322 u32 miss_next_index = ~0;
9323 u32 memory_size = 32 << 20;
9326 u32 current_data_flag = 0;
9327 int current_data_offset = 0;
9329 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9331 if (unformat (i, "del"))
9333 else if (unformat (i, "del-chain"))
9338 else if (unformat (i, "buckets %d", &nbuckets))
9340 else if (unformat (i, "memory_size %d", &memory_size))
9342 else if (unformat (i, "skip %d", &skip))
9344 else if (unformat (i, "match %d", &match))
9346 else if (unformat (i, "table %d", &table_index))
9348 else if (unformat (i, "mask %U", unformat_classify_mask,
9349 &mask, &skip, &match))
9351 else if (unformat (i, "next-table %d", &next_table_index))
9353 else if (unformat (i, "miss-next %U", unformat_ip_next_index,
9356 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
9359 else if (unformat (i, "acl-miss-next %U", unformat_acl_next_index,
9362 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
9364 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
9370 if (is_add && mask == 0)
9372 errmsg ("Mask required");
9376 if (is_add && skip == ~0)
9378 errmsg ("skip count required");
9382 if (is_add && match == ~0)
9384 errmsg ("match count required");
9388 if (!is_add && table_index == ~0)
9390 errmsg ("table index required for delete");
9394 M2 (CLASSIFY_ADD_DEL_TABLE, classify_add_del_table, vec_len (mask));
9396 mp->is_add = is_add;
9397 mp->del_chain = del_chain;
9398 mp->table_index = ntohl (table_index);
9399 mp->nbuckets = ntohl (nbuckets);
9400 mp->memory_size = ntohl (memory_size);
9401 mp->skip_n_vectors = ntohl (skip);
9402 mp->match_n_vectors = ntohl (match);
9403 mp->next_table_index = ntohl (next_table_index);
9404 mp->miss_next_index = ntohl (miss_next_index);
9405 mp->current_data_flag = ntohl (current_data_flag);
9406 mp->current_data_offset = ntohl (current_data_offset);
9407 clib_memcpy (mp->mask, mask, vec_len (mask));
9417 unformat_l4_match (unformat_input_t * input, va_list * args)
9419 u8 **matchp = va_arg (*args, u8 **);
9421 u8 *proto_header = 0;
9427 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9429 if (unformat (input, "src_port %d", &src_port))
9431 else if (unformat (input, "dst_port %d", &dst_port))
9437 h.src_port = clib_host_to_net_u16 (src_port);
9438 h.dst_port = clib_host_to_net_u16 (dst_port);
9439 vec_validate (proto_header, sizeof (h) - 1);
9440 memcpy (proto_header, &h, sizeof (h));
9442 *matchp = proto_header;
9448 unformat_ip4_match (unformat_input_t * input, va_list * args)
9450 u8 **matchp = va_arg (*args, u8 **);
9457 int src = 0, dst = 0;
9458 ip4_address_t src_val, dst_val;
9465 int fragment_id = 0;
9466 u32 fragment_id_val;
9472 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9474 if (unformat (input, "version %d", &version_val))
9476 else if (unformat (input, "hdr_length %d", &hdr_length_val))
9478 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
9480 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
9482 else if (unformat (input, "proto %d", &proto_val))
9484 else if (unformat (input, "tos %d", &tos_val))
9486 else if (unformat (input, "length %d", &length_val))
9488 else if (unformat (input, "fragment_id %d", &fragment_id_val))
9490 else if (unformat (input, "ttl %d", &ttl_val))
9492 else if (unformat (input, "checksum %d", &checksum_val))
9498 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
9499 + ttl + checksum == 0)
9503 * Aligned because we use the real comparison functions
9505 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
9507 ip = (ip4_header_t *) match;
9509 /* These are realistically matched in practice */
9511 ip->src_address.as_u32 = src_val.as_u32;
9514 ip->dst_address.as_u32 = dst_val.as_u32;
9517 ip->protocol = proto_val;
9520 /* These are not, but they're included for completeness */
9522 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
9525 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
9531 ip->length = clib_host_to_net_u16 (length_val);
9537 ip->checksum = clib_host_to_net_u16 (checksum_val);
9544 unformat_ip6_match (unformat_input_t * input, va_list * args)
9546 u8 **matchp = va_arg (*args, u8 **);
9551 u8 traffic_class = 0;
9552 u32 traffic_class_val = 0;
9555 int src = 0, dst = 0;
9556 ip6_address_t src_val, dst_val;
9559 int payload_length = 0;
9560 u32 payload_length_val;
9563 u32 ip_version_traffic_class_and_flow_label;
9565 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9567 if (unformat (input, "version %d", &version_val))
9569 else if (unformat (input, "traffic_class %d", &traffic_class_val))
9571 else if (unformat (input, "flow_label %d", &flow_label_val))
9573 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
9575 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
9577 else if (unformat (input, "proto %d", &proto_val))
9579 else if (unformat (input, "payload_length %d", &payload_length_val))
9581 else if (unformat (input, "hop_limit %d", &hop_limit_val))
9587 if (version + traffic_class + flow_label + src + dst + proto +
9588 payload_length + hop_limit == 0)
9592 * Aligned because we use the real comparison functions
9594 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
9596 ip = (ip6_header_t *) match;
9599 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
9602 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
9605 ip->protocol = proto_val;
9607 ip_version_traffic_class_and_flow_label = 0;
9610 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
9613 ip_version_traffic_class_and_flow_label |=
9614 (traffic_class_val & 0xFF) << 20;
9617 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
9619 ip->ip_version_traffic_class_and_flow_label =
9620 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9623 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
9626 ip->hop_limit = hop_limit_val;
9633 unformat_l3_match (unformat_input_t * input, va_list * args)
9635 u8 **matchp = va_arg (*args, u8 **);
9637 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9639 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
9641 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
9650 unformat_vlan_tag (unformat_input_t * input, va_list * args)
9652 u8 *tagp = va_arg (*args, u8 *);
9655 if (unformat (input, "%d", &tag))
9657 tagp[0] = (tag >> 8) & 0x0F;
9658 tagp[1] = tag & 0xFF;
9666 unformat_l2_match (unformat_input_t * input, va_list * args)
9668 u8 **matchp = va_arg (*args, u8 **);
9688 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9690 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
9693 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
9695 else if (unformat (input, "proto %U",
9696 unformat_ethernet_type_host_byte_order, &proto_val))
9698 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
9700 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
9702 else if (unformat (input, "ignore-tag1"))
9704 else if (unformat (input, "ignore-tag2"))
9706 else if (unformat (input, "cos1 %d", &cos1_val))
9708 else if (unformat (input, "cos2 %d", &cos2_val))
9713 if ((src + dst + proto + tag1 + tag2 +
9714 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9717 if (tag1 || ignore_tag1 || cos1)
9719 if (tag2 || ignore_tag2 || cos2)
9722 vec_validate_aligned (match, len - 1, sizeof (u32x4));
9725 clib_memcpy (match, dst_val, 6);
9728 clib_memcpy (match + 6, src_val, 6);
9732 /* inner vlan tag */
9733 match[19] = tag2_val[1];
9734 match[18] = tag2_val[0];
9736 match[18] |= (cos2_val & 0x7) << 5;
9739 match[21] = proto_val & 0xff;
9740 match[20] = proto_val >> 8;
9744 match[15] = tag1_val[1];
9745 match[14] = tag1_val[0];
9748 match[14] |= (cos1_val & 0x7) << 5;
9754 match[15] = tag1_val[1];
9755 match[14] = tag1_val[0];
9758 match[17] = proto_val & 0xff;
9759 match[16] = proto_val >> 8;
9762 match[14] |= (cos1_val & 0x7) << 5;
9768 match[18] |= (cos2_val & 0x7) << 5;
9770 match[14] |= (cos1_val & 0x7) << 5;
9773 match[13] = proto_val & 0xff;
9774 match[12] = proto_val >> 8;
9783 unformat_classify_match (unformat_input_t * input, va_list * args)
9785 u8 **matchp = va_arg (*args, u8 **);
9786 u32 skip_n_vectors = va_arg (*args, u32);
9787 u32 match_n_vectors = va_arg (*args, u32);
9794 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9796 if (unformat (input, "hex %U", unformat_hex_string, &match))
9798 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
9800 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
9802 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
9816 if (match || l2 || l3 || l4)
9820 /* "Win a free Ethernet header in every packet" */
9822 vec_validate_aligned (l2, 13, sizeof (u32x4));
9826 vec_append_aligned (match, l3, sizeof (u32x4));
9831 vec_append_aligned (match, l4, sizeof (u32x4));
9836 /* Make sure the vector is big enough even if key is all 0's */
9837 vec_validate_aligned
9838 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
9841 /* Set size, include skipped vectors */
9842 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
9853 api_classify_add_del_session (vat_main_t * vam)
9855 unformat_input_t *i = vam->input;
9856 vl_api_classify_add_del_session_t *mp;
9858 u32 table_index = ~0;
9859 u32 hit_next_index = ~0;
9860 u32 opaque_index = ~0;
9864 u32 skip_n_vectors = 0;
9865 u32 match_n_vectors = 0;
9870 * Warning: you have to supply skip_n and match_n
9871 * because the API client cant simply look at the classify
9875 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9877 if (unformat (i, "del"))
9879 else if (unformat (i, "hit-next %U", unformat_ip_next_index,
9882 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
9885 else if (unformat (i, "acl-hit-next %U", unformat_acl_next_index,
9888 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
9890 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
9892 else if (unformat (i, "opaque-index %d", &opaque_index))
9894 else if (unformat (i, "skip_n %d", &skip_n_vectors))
9896 else if (unformat (i, "match_n %d", &match_n_vectors))
9898 else if (unformat (i, "match %U", unformat_classify_match,
9899 &match, skip_n_vectors, match_n_vectors))
9901 else if (unformat (i, "advance %d", &advance))
9903 else if (unformat (i, "table-index %d", &table_index))
9905 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
9907 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
9909 else if (unformat (i, "action %d", &action))
9911 else if (unformat (i, "metadata %d", &metadata))
9917 if (table_index == ~0)
9919 errmsg ("Table index required");
9923 if (is_add && match == 0)
9925 errmsg ("Match value required");
9929 M2 (CLASSIFY_ADD_DEL_SESSION, classify_add_del_session, vec_len (match));
9931 mp->is_add = is_add;
9932 mp->table_index = ntohl (table_index);
9933 mp->hit_next_index = ntohl (hit_next_index);
9934 mp->opaque_index = ntohl (opaque_index);
9935 mp->advance = ntohl (advance);
9936 mp->action = action;
9937 mp->metadata = ntohl (metadata);
9938 clib_memcpy (mp->match, match, vec_len (match));
9947 api_classify_set_interface_ip_table (vat_main_t * vam)
9949 unformat_input_t *i = vam->input;
9950 vl_api_classify_set_interface_ip_table_t *mp;
9953 int sw_if_index_set;
9954 u32 table_index = ~0;
9957 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9959 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
9960 sw_if_index_set = 1;
9961 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9962 sw_if_index_set = 1;
9963 else if (unformat (i, "table %d", &table_index))
9967 clib_warning ("parse error '%U'", format_unformat_error, i);
9972 if (sw_if_index_set == 0)
9974 errmsg ("missing interface name or sw_if_index");
9979 M (CLASSIFY_SET_INTERFACE_IP_TABLE, classify_set_interface_ip_table);
9981 mp->sw_if_index = ntohl (sw_if_index);
9982 mp->table_index = ntohl (table_index);
9983 mp->is_ipv6 = is_ipv6;
9992 api_classify_set_interface_l2_tables (vat_main_t * vam)
9994 unformat_input_t *i = vam->input;
9995 vl_api_classify_set_interface_l2_tables_t *mp;
9998 int sw_if_index_set;
9999 u32 ip4_table_index = ~0;
10000 u32 ip6_table_index = ~0;
10001 u32 other_table_index = ~0;
10004 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10006 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10007 sw_if_index_set = 1;
10008 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10009 sw_if_index_set = 1;
10010 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10012 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10014 else if (unformat (i, "other-table %d", &other_table_index))
10016 else if (unformat (i, "is-input %d", &is_input))
10020 clib_warning ("parse error '%U'", format_unformat_error, i);
10025 if (sw_if_index_set == 0)
10027 errmsg ("missing interface name or sw_if_index");
10032 M (CLASSIFY_SET_INTERFACE_L2_TABLES, classify_set_interface_l2_tables);
10034 mp->sw_if_index = ntohl (sw_if_index);
10035 mp->ip4_table_index = ntohl (ip4_table_index);
10036 mp->ip6_table_index = ntohl (ip6_table_index);
10037 mp->other_table_index = ntohl (other_table_index);
10038 mp->is_input = (u8) is_input;
10047 api_set_ipfix_exporter (vat_main_t * vam)
10049 unformat_input_t *i = vam->input;
10050 vl_api_set_ipfix_exporter_t *mp;
10051 ip4_address_t collector_address;
10052 u8 collector_address_set = 0;
10053 u32 collector_port = ~0;
10054 ip4_address_t src_address;
10055 u8 src_address_set = 0;
10058 u32 template_interval = ~0;
10059 u8 udp_checksum = 0;
10062 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10064 if (unformat (i, "collector_address %U", unformat_ip4_address,
10065 &collector_address))
10066 collector_address_set = 1;
10067 else if (unformat (i, "collector_port %d", &collector_port))
10069 else if (unformat (i, "src_address %U", unformat_ip4_address,
10071 src_address_set = 1;
10072 else if (unformat (i, "vrf_id %d", &vrf_id))
10074 else if (unformat (i, "path_mtu %d", &path_mtu))
10076 else if (unformat (i, "template_interval %d", &template_interval))
10078 else if (unformat (i, "udp_checksum"))
10084 if (collector_address_set == 0)
10086 errmsg ("collector_address required");
10090 if (src_address_set == 0)
10092 errmsg ("src_address required");
10096 M (SET_IPFIX_EXPORTER, set_ipfix_exporter);
10098 memcpy (mp->collector_address, collector_address.data,
10099 sizeof (collector_address.data));
10100 mp->collector_port = htons ((u16) collector_port);
10101 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
10102 mp->vrf_id = htonl (vrf_id);
10103 mp->path_mtu = htonl (path_mtu);
10104 mp->template_interval = htonl (template_interval);
10105 mp->udp_checksum = udp_checksum;
10113 api_set_ipfix_classify_stream (vat_main_t * vam)
10115 unformat_input_t *i = vam->input;
10116 vl_api_set_ipfix_classify_stream_t *mp;
10118 u32 src_port = UDP_DST_PORT_ipfix;
10121 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10123 if (unformat (i, "domain %d", &domain_id))
10125 else if (unformat (i, "src_port %d", &src_port))
10129 errmsg ("unknown input `%U'", format_unformat_error, i);
10134 M (SET_IPFIX_CLASSIFY_STREAM, set_ipfix_classify_stream);
10136 mp->domain_id = htonl (domain_id);
10137 mp->src_port = htons ((u16) src_port);
10145 api_ipfix_classify_table_add_del (vat_main_t * vam)
10147 unformat_input_t *i = vam->input;
10148 vl_api_ipfix_classify_table_add_del_t *mp;
10150 u32 classify_table_index = ~0;
10152 u8 transport_protocol = 255;
10155 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10157 if (unformat (i, "add"))
10159 else if (unformat (i, "del"))
10161 else if (unformat (i, "table %d", &classify_table_index))
10163 else if (unformat (i, "ip4"))
10165 else if (unformat (i, "ip6"))
10167 else if (unformat (i, "tcp"))
10168 transport_protocol = 6;
10169 else if (unformat (i, "udp"))
10170 transport_protocol = 17;
10173 errmsg ("unknown input `%U'", format_unformat_error, i);
10180 errmsg ("expecting: add|del");
10183 if (classify_table_index == ~0)
10185 errmsg ("classifier table not specified");
10188 if (ip_version == 0)
10190 errmsg ("IP version not specified");
10194 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, ipfix_classify_table_add_del);
10196 mp->is_add = is_add;
10197 mp->table_id = htonl (classify_table_index);
10198 mp->ip_version = ip_version;
10199 mp->transport_protocol = transport_protocol;
10207 api_get_node_index (vat_main_t * vam)
10209 unformat_input_t *i = vam->input;
10210 vl_api_get_node_index_t *mp;
10214 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10216 if (unformat (i, "node %s", &name))
10223 errmsg ("node name required");
10226 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10228 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10232 M (GET_NODE_INDEX, get_node_index);
10233 clib_memcpy (mp->node_name, name, vec_len (name));
10243 api_get_next_index (vat_main_t * vam)
10245 unformat_input_t *i = vam->input;
10246 vl_api_get_next_index_t *mp;
10248 u8 *node_name = 0, *next_node_name = 0;
10250 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10252 if (unformat (i, "node-name %s", &node_name))
10254 else if (unformat (i, "next-node-name %s", &next_node_name))
10258 if (node_name == 0)
10260 errmsg ("node name required");
10263 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
10265 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10269 if (next_node_name == 0)
10271 errmsg ("next node name required");
10274 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
10276 errmsg ("next node name too long, max %d", ARRAY_LEN (mp->next_name));
10280 M (GET_NEXT_INDEX, get_next_index);
10281 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
10282 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
10283 vec_free (node_name);
10284 vec_free (next_node_name);
10293 api_add_node_next (vat_main_t * vam)
10295 unformat_input_t *i = vam->input;
10296 vl_api_add_node_next_t *mp;
10301 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10303 if (unformat (i, "node %s", &name))
10305 else if (unformat (i, "next %s", &next))
10312 errmsg ("node name required");
10315 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
10317 errmsg ("node name too long, max %d", ARRAY_LEN (mp->node_name));
10322 errmsg ("next node required");
10325 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
10327 errmsg ("next name too long, max %d", ARRAY_LEN (mp->next_name));
10331 M (ADD_NODE_NEXT, add_node_next);
10332 clib_memcpy (mp->node_name, name, vec_len (name));
10333 clib_memcpy (mp->next_name, next, vec_len (next));
10344 api_l2tpv3_create_tunnel (vat_main_t * vam)
10346 unformat_input_t *i = vam->input;
10347 ip6_address_t client_address, our_address;
10348 int client_address_set = 0;
10349 int our_address_set = 0;
10350 u32 local_session_id = 0;
10351 u32 remote_session_id = 0;
10352 u64 local_cookie = 0;
10353 u64 remote_cookie = 0;
10354 u8 l2_sublayer_present = 0;
10355 vl_api_l2tpv3_create_tunnel_t *mp;
10358 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10360 if (unformat (i, "client_address %U", unformat_ip6_address,
10362 client_address_set = 1;
10363 else if (unformat (i, "our_address %U", unformat_ip6_address,
10365 our_address_set = 1;
10366 else if (unformat (i, "local_session_id %d", &local_session_id))
10368 else if (unformat (i, "remote_session_id %d", &remote_session_id))
10370 else if (unformat (i, "local_cookie %lld", &local_cookie))
10372 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
10374 else if (unformat (i, "l2-sublayer-present"))
10375 l2_sublayer_present = 1;
10380 if (client_address_set == 0)
10382 errmsg ("client_address required");
10386 if (our_address_set == 0)
10388 errmsg ("our_address required");
10392 M (L2TPV3_CREATE_TUNNEL, l2tpv3_create_tunnel);
10394 clib_memcpy (mp->client_address, client_address.as_u8,
10395 sizeof (mp->client_address));
10397 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
10399 mp->local_session_id = ntohl (local_session_id);
10400 mp->remote_session_id = ntohl (remote_session_id);
10401 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
10402 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
10403 mp->l2_sublayer_present = l2_sublayer_present;
10413 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
10415 unformat_input_t *i = vam->input;
10417 u8 sw_if_index_set = 0;
10418 u64 new_local_cookie = 0;
10419 u64 new_remote_cookie = 0;
10420 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
10423 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10425 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10426 sw_if_index_set = 1;
10427 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10428 sw_if_index_set = 1;
10429 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
10431 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
10437 if (sw_if_index_set == 0)
10439 errmsg ("missing interface name or sw_if_index");
10443 M (L2TPV3_SET_TUNNEL_COOKIES, l2tpv3_set_tunnel_cookies);
10445 mp->sw_if_index = ntohl (sw_if_index);
10446 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
10447 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
10456 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
10458 unformat_input_t *i = vam->input;
10459 vl_api_l2tpv3_interface_enable_disable_t *mp;
10462 u8 sw_if_index_set = 0;
10463 u8 enable_disable = 1;
10465 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10467 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
10468 sw_if_index_set = 1;
10469 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10470 sw_if_index_set = 1;
10471 else if (unformat (i, "enable"))
10472 enable_disable = 1;
10473 else if (unformat (i, "disable"))
10474 enable_disable = 0;
10479 if (sw_if_index_set == 0)
10481 errmsg ("missing interface name or sw_if_index");
10485 M (L2TPV3_INTERFACE_ENABLE_DISABLE, l2tpv3_interface_enable_disable);
10487 mp->sw_if_index = ntohl (sw_if_index);
10488 mp->enable_disable = enable_disable;
10497 api_l2tpv3_set_lookup_key (vat_main_t * vam)
10499 unformat_input_t *i = vam->input;
10500 vl_api_l2tpv3_set_lookup_key_t *mp;
10504 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10506 if (unformat (i, "lookup_v6_src"))
10507 key = L2T_LOOKUP_SRC_ADDRESS;
10508 else if (unformat (i, "lookup_v6_dst"))
10509 key = L2T_LOOKUP_DST_ADDRESS;
10510 else if (unformat (i, "lookup_session_id"))
10511 key = L2T_LOOKUP_SESSION_ID;
10516 if (key == (u8) ~ 0)
10518 errmsg ("l2tp session lookup key unset");
10522 M (L2TPV3_SET_LOOKUP_KEY, l2tpv3_set_lookup_key);
10532 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
10533 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
10535 vat_main_t *vam = &vat_main;
10537 print (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)",
10538 format_ip6_address, mp->our_address,
10539 format_ip6_address, mp->client_address,
10540 clib_net_to_host_u32 (mp->sw_if_index));
10543 " local cookies %016llx %016llx remote cookie %016llx",
10544 clib_net_to_host_u64 (mp->local_cookie[0]),
10545 clib_net_to_host_u64 (mp->local_cookie[1]),
10546 clib_net_to_host_u64 (mp->remote_cookie));
10548 print (vam->ofp, " local session-id %d remote session-id %d",
10549 clib_net_to_host_u32 (mp->local_session_id),
10550 clib_net_to_host_u32 (mp->remote_session_id));
10552 print (vam->ofp, " l2 specific sublayer %s\n",
10553 mp->l2_sublayer_present ? "preset" : "absent");
10557 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
10558 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
10560 vat_main_t *vam = &vat_main;
10561 vat_json_node_t *node = NULL;
10562 struct in6_addr addr;
10564 if (VAT_JSON_ARRAY != vam->json_tree.type)
10566 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10567 vat_json_init_array (&vam->json_tree);
10569 node = vat_json_array_add (&vam->json_tree);
10571 vat_json_init_object (node);
10573 clib_memcpy (&addr, mp->our_address, sizeof (addr));
10574 vat_json_object_add_ip6 (node, "our_address", addr);
10575 clib_memcpy (&addr, mp->client_address, sizeof (addr));
10576 vat_json_object_add_ip6 (node, "client_address", addr);
10578 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
10579 vat_json_init_array (lc);
10580 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
10581 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
10582 vat_json_object_add_uint (node, "remote_cookie",
10583 clib_net_to_host_u64 (mp->remote_cookie));
10585 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
10586 vat_json_object_add_uint (node, "local_session_id",
10587 clib_net_to_host_u32 (mp->local_session_id));
10588 vat_json_object_add_uint (node, "remote_session_id",
10589 clib_net_to_host_u32 (mp->remote_session_id));
10590 vat_json_object_add_string_copy (node, "l2_sublayer",
10591 mp->l2_sublayer_present ? (u8 *) "present"
10592 : (u8 *) "absent");
10596 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
10598 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
10601 /* Get list of l2tpv3-tunnel interfaces */
10602 M (SW_IF_L2TPV3_TUNNEL_DUMP, sw_if_l2tpv3_tunnel_dump);
10605 /* Use a control ping for synchronization */
10607 vl_api_control_ping_t *mp;
10608 M (CONTROL_PING, control_ping);
10615 static void vl_api_sw_interface_tap_details_t_handler
10616 (vl_api_sw_interface_tap_details_t * mp)
10618 vat_main_t *vam = &vat_main;
10620 print (vam->ofp, "%-16s %d",
10621 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
10624 static void vl_api_sw_interface_tap_details_t_handler_json
10625 (vl_api_sw_interface_tap_details_t * mp)
10627 vat_main_t *vam = &vat_main;
10628 vat_json_node_t *node = NULL;
10630 if (VAT_JSON_ARRAY != vam->json_tree.type)
10632 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10633 vat_json_init_array (&vam->json_tree);
10635 node = vat_json_array_add (&vam->json_tree);
10637 vat_json_init_object (node);
10638 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10639 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
10643 api_sw_interface_tap_dump (vat_main_t * vam)
10645 vl_api_sw_interface_tap_dump_t *mp;
10648 print (vam->ofp, "\n%-16s %s", "dev_name", "sw_if_index");
10649 /* Get list of tap interfaces */
10650 M (SW_INTERFACE_TAP_DUMP, sw_interface_tap_dump);
10653 /* Use a control ping for synchronization */
10655 vl_api_control_ping_t *mp;
10656 M (CONTROL_PING, control_ping);
10662 static uword unformat_vxlan_decap_next
10663 (unformat_input_t * input, va_list * args)
10665 u32 *result = va_arg (*args, u32 *);
10668 if (unformat (input, "l2"))
10669 *result = VXLAN_INPUT_NEXT_L2_INPUT;
10670 else if (unformat (input, "%d", &tmp))
10678 api_vxlan_add_del_tunnel (vat_main_t * vam)
10680 unformat_input_t *line_input = vam->input;
10681 vl_api_vxlan_add_del_tunnel_t *mp;
10683 ip46_address_t src, dst;
10685 u8 ipv4_set = 0, ipv6_set = 0;
10689 u32 mcast_sw_if_index = ~0;
10690 u32 encap_vrf_id = 0;
10691 u32 decap_next_index = ~0;
10694 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
10695 memset (&src, 0, sizeof src);
10696 memset (&dst, 0, sizeof dst);
10698 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10700 if (unformat (line_input, "del"))
10703 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
10709 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
10715 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
10721 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
10726 else if (unformat (line_input, "group %U %U",
10727 unformat_ip4_address, &dst.ip4,
10728 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
10730 grp_set = dst_set = 1;
10733 else if (unformat (line_input, "group %U",
10734 unformat_ip4_address, &dst.ip4))
10736 grp_set = dst_set = 1;
10739 else if (unformat (line_input, "group %U %U",
10740 unformat_ip6_address, &dst.ip6,
10741 api_unformat_sw_if_index, vam, &mcast_sw_if_index))
10743 grp_set = dst_set = 1;
10746 else if (unformat (line_input, "group %U",
10747 unformat_ip6_address, &dst.ip6))
10749 grp_set = dst_set = 1;
10753 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
10755 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
10757 else if (unformat (line_input, "decap-next %U",
10758 unformat_vxlan_decap_next, &decap_next_index))
10760 else if (unformat (line_input, "vni %d", &vni))
10764 errmsg ("parse error '%U'", format_unformat_error, line_input);
10771 errmsg ("tunnel src address not specified");
10776 errmsg ("tunnel dst address not specified");
10780 if (grp_set && !ip46_address_is_multicast (&dst))
10782 errmsg ("tunnel group address not multicast");
10785 if (grp_set && mcast_sw_if_index == ~0)
10787 errmsg ("tunnel nonexistent multicast device");
10790 if (grp_set == 0 && ip46_address_is_multicast (&dst))
10792 errmsg ("tunnel dst address must be unicast");
10797 if (ipv4_set && ipv6_set)
10799 errmsg ("both IPv4 and IPv6 addresses specified");
10803 if ((vni == 0) || (vni >> 24))
10805 errmsg ("vni not specified or out of range");
10809 M (VXLAN_ADD_DEL_TUNNEL, vxlan_add_del_tunnel);
10813 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
10814 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
10818 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
10819 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
10821 mp->encap_vrf_id = ntohl (encap_vrf_id);
10822 mp->decap_next_index = ntohl (decap_next_index);
10823 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
10824 mp->vni = ntohl (vni);
10825 mp->is_add = is_add;
10826 mp->is_ipv6 = ipv6_set;
10834 static void vl_api_vxlan_tunnel_details_t_handler
10835 (vl_api_vxlan_tunnel_details_t * mp)
10837 vat_main_t *vam = &vat_main;
10838 ip46_address_t src, dst;
10840 ip46_from_addr_buf (mp->is_ipv6, mp->src_address, &src);
10841 ip46_from_addr_buf (mp->is_ipv6, mp->dst_address, &dst);
10843 print (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d",
10844 ntohl (mp->sw_if_index),
10845 format_ip46_address, &src, IP46_TYPE_ANY,
10846 format_ip46_address, &dst, IP46_TYPE_ANY,
10847 ntohl (mp->encap_vrf_id),
10848 ntohl (mp->decap_next_index), ntohl (mp->vni),
10849 ntohl (mp->mcast_sw_if_index));
10852 static void vl_api_vxlan_tunnel_details_t_handler_json
10853 (vl_api_vxlan_tunnel_details_t * mp)
10855 vat_main_t *vam = &vat_main;
10856 vat_json_node_t *node = NULL;
10858 if (VAT_JSON_ARRAY != vam->json_tree.type)
10860 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10861 vat_json_init_array (&vam->json_tree);
10863 node = vat_json_array_add (&vam->json_tree);
10865 vat_json_init_object (node);
10866 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10869 struct in6_addr ip6;
10871 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
10872 vat_json_object_add_ip6 (node, "src_address", ip6);
10873 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
10874 vat_json_object_add_ip6 (node, "dst_address", ip6);
10878 struct in_addr ip4;
10880 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
10881 vat_json_object_add_ip4 (node, "src_address", ip4);
10882 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
10883 vat_json_object_add_ip4 (node, "dst_address", ip4);
10885 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
10886 vat_json_object_add_uint (node, "decap_next_index",
10887 ntohl (mp->decap_next_index));
10888 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
10889 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
10890 vat_json_object_add_uint (node, "mcast_sw_if_index",
10891 ntohl (mp->mcast_sw_if_index));
10895 api_vxlan_tunnel_dump (vat_main_t * vam)
10897 unformat_input_t *i = vam->input;
10898 vl_api_vxlan_tunnel_dump_t *mp;
10901 u8 sw_if_index_set = 0;
10903 /* Parse args required to build the message */
10904 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10906 if (unformat (i, "sw_if_index %d", &sw_if_index))
10907 sw_if_index_set = 1;
10912 if (sw_if_index_set == 0)
10917 if (!vam->json_output)
10919 print (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s",
10920 "sw_if_index", "src_address", "dst_address",
10921 "encap_vrf_id", "decap_next_index", "vni", "mcast_sw_if_index");
10924 /* Get list of vxlan-tunnel interfaces */
10925 M (VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump);
10927 mp->sw_if_index = htonl (sw_if_index);
10931 /* Use a control ping for synchronization */
10933 vl_api_control_ping_t *mp;
10934 M (CONTROL_PING, control_ping);
10941 api_gre_add_del_tunnel (vat_main_t * vam)
10943 unformat_input_t *line_input = vam->input;
10944 vl_api_gre_add_del_tunnel_t *mp;
10946 ip4_address_t src4, dst4;
10951 u32 outer_fib_id = 0;
10953 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10955 if (unformat (line_input, "del"))
10957 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
10959 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
10961 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
10963 else if (unformat (line_input, "teb"))
10967 errmsg ("parse error '%U'", format_unformat_error, line_input);
10974 errmsg ("tunnel src address not specified");
10979 errmsg ("tunnel dst address not specified");
10984 M (GRE_ADD_DEL_TUNNEL, gre_add_del_tunnel);
10986 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
10987 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
10988 mp->outer_fib_id = ntohl (outer_fib_id);
10989 mp->is_add = is_add;
10998 static void vl_api_gre_tunnel_details_t_handler
10999 (vl_api_gre_tunnel_details_t * mp)
11001 vat_main_t *vam = &vat_main;
11003 print (vam->ofp, "%11d%15U%15U%6d%14d",
11004 ntohl (mp->sw_if_index),
11005 format_ip4_address, &mp->src_address,
11006 format_ip4_address, &mp->dst_address,
11007 mp->teb, ntohl (mp->outer_fib_id));
11010 static void vl_api_gre_tunnel_details_t_handler_json
11011 (vl_api_gre_tunnel_details_t * mp)
11013 vat_main_t *vam = &vat_main;
11014 vat_json_node_t *node = NULL;
11015 struct in_addr ip4;
11017 if (VAT_JSON_ARRAY != vam->json_tree.type)
11019 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11020 vat_json_init_array (&vam->json_tree);
11022 node = vat_json_array_add (&vam->json_tree);
11024 vat_json_init_object (node);
11025 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11026 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
11027 vat_json_object_add_ip4 (node, "src_address", ip4);
11028 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
11029 vat_json_object_add_ip4 (node, "dst_address", ip4);
11030 vat_json_object_add_uint (node, "teb", mp->teb);
11031 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
11035 api_gre_tunnel_dump (vat_main_t * vam)
11037 unformat_input_t *i = vam->input;
11038 vl_api_gre_tunnel_dump_t *mp;
11041 u8 sw_if_index_set = 0;
11043 /* Parse args required to build the message */
11044 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11046 if (unformat (i, "sw_if_index %d", &sw_if_index))
11047 sw_if_index_set = 1;
11052 if (sw_if_index_set == 0)
11057 if (!vam->json_output)
11059 print (vam->ofp, "%11s%15s%15s%6s%14s",
11060 "sw_if_index", "src_address", "dst_address", "teb",
11064 /* Get list of gre-tunnel interfaces */
11065 M (GRE_TUNNEL_DUMP, gre_tunnel_dump);
11067 mp->sw_if_index = htonl (sw_if_index);
11071 /* Use a control ping for synchronization */
11073 vl_api_control_ping_t *mp;
11074 M (CONTROL_PING, control_ping);
11081 api_l2_fib_clear_table (vat_main_t * vam)
11083 // unformat_input_t * i = vam->input;
11084 vl_api_l2_fib_clear_table_t *mp;
11087 M (L2_FIB_CLEAR_TABLE, l2_fib_clear_table);
11096 api_l2_interface_efp_filter (vat_main_t * vam)
11098 unformat_input_t *i = vam->input;
11099 vl_api_l2_interface_efp_filter_t *mp;
11103 u8 sw_if_index_set = 0;
11105 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11107 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11108 sw_if_index_set = 1;
11109 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11110 sw_if_index_set = 1;
11111 else if (unformat (i, "enable"))
11113 else if (unformat (i, "disable"))
11117 clib_warning ("parse error '%U'", format_unformat_error, i);
11122 if (sw_if_index_set == 0)
11124 errmsg ("missing sw_if_index");
11128 M (L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter);
11130 mp->sw_if_index = ntohl (sw_if_index);
11131 mp->enable_disable = enable;
11139 #define foreach_vtr_op \
11140 _("disable", L2_VTR_DISABLED) \
11141 _("push-1", L2_VTR_PUSH_1) \
11142 _("push-2", L2_VTR_PUSH_2) \
11143 _("pop-1", L2_VTR_POP_1) \
11144 _("pop-2", L2_VTR_POP_2) \
11145 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
11146 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
11147 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
11148 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
11151 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
11153 unformat_input_t *i = vam->input;
11154 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
11157 u8 sw_if_index_set = 0;
11160 u32 push_dot1q = 1;
11164 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11166 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11167 sw_if_index_set = 1;
11168 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11169 sw_if_index_set = 1;
11170 else if (unformat (i, "vtr_op %d", &vtr_op))
11172 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
11175 else if (unformat (i, "push_dot1q %d", &push_dot1q))
11177 else if (unformat (i, "tag1 %d", &tag1))
11179 else if (unformat (i, "tag2 %d", &tag2))
11183 clib_warning ("parse error '%U'", format_unformat_error, i);
11188 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
11190 errmsg ("missing vtr operation or sw_if_index");
11194 M (L2_INTERFACE_VLAN_TAG_REWRITE, l2_interface_vlan_tag_rewrite)
11195 mp->sw_if_index = ntohl (sw_if_index);
11196 mp->vtr_op = ntohl (vtr_op);
11197 mp->push_dot1q = ntohl (push_dot1q);
11198 mp->tag1 = ntohl (tag1);
11199 mp->tag2 = ntohl (tag2);
11208 api_create_vhost_user_if (vat_main_t * vam)
11210 unformat_input_t *i = vam->input;
11211 vl_api_create_vhost_user_if_t *mp;
11215 u8 file_name_set = 0;
11216 u32 custom_dev_instance = ~0;
11218 u8 use_custom_mac = 0;
11221 /* Shut up coverity */
11222 memset (hwaddr, 0, sizeof (hwaddr));
11224 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11226 if (unformat (i, "socket %s", &file_name))
11230 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
11232 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
11233 use_custom_mac = 1;
11234 else if (unformat (i, "server"))
11236 else if (unformat (i, "tag %s", &tag))
11242 if (file_name_set == 0)
11244 errmsg ("missing socket file name");
11248 if (vec_len (file_name) > 255)
11250 errmsg ("socket file name too long");
11253 vec_add1 (file_name, 0);
11255 M (CREATE_VHOST_USER_IF, create_vhost_user_if);
11257 mp->is_server = is_server;
11258 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
11259 vec_free (file_name);
11260 if (custom_dev_instance != ~0)
11263 mp->custom_dev_instance = ntohl (custom_dev_instance);
11265 mp->use_custom_mac = use_custom_mac;
11266 clib_memcpy (mp->mac_address, hwaddr, 6);
11268 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
11278 api_modify_vhost_user_if (vat_main_t * vam)
11280 unformat_input_t *i = vam->input;
11281 vl_api_modify_vhost_user_if_t *mp;
11285 u8 file_name_set = 0;
11286 u32 custom_dev_instance = ~0;
11287 u8 sw_if_index_set = 0;
11288 u32 sw_if_index = (u32) ~ 0;
11290 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11292 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11293 sw_if_index_set = 1;
11294 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11295 sw_if_index_set = 1;
11296 else if (unformat (i, "socket %s", &file_name))
11300 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
11302 else if (unformat (i, "server"))
11308 if (sw_if_index_set == 0)
11310 errmsg ("missing sw_if_index or interface name");
11314 if (file_name_set == 0)
11316 errmsg ("missing socket file name");
11320 if (vec_len (file_name) > 255)
11322 errmsg ("socket file name too long");
11325 vec_add1 (file_name, 0);
11327 M (MODIFY_VHOST_USER_IF, modify_vhost_user_if);
11329 mp->sw_if_index = ntohl (sw_if_index);
11330 mp->is_server = is_server;
11331 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
11332 vec_free (file_name);
11333 if (custom_dev_instance != ~0)
11336 mp->custom_dev_instance = ntohl (custom_dev_instance);
11346 api_delete_vhost_user_if (vat_main_t * vam)
11348 unformat_input_t *i = vam->input;
11349 vl_api_delete_vhost_user_if_t *mp;
11351 u32 sw_if_index = ~0;
11352 u8 sw_if_index_set = 0;
11354 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11356 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11357 sw_if_index_set = 1;
11358 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11359 sw_if_index_set = 1;
11364 if (sw_if_index_set == 0)
11366 errmsg ("missing sw_if_index or interface name");
11371 M (DELETE_VHOST_USER_IF, delete_vhost_user_if);
11373 mp->sw_if_index = ntohl (sw_if_index);
11381 static void vl_api_sw_interface_vhost_user_details_t_handler
11382 (vl_api_sw_interface_vhost_user_details_t * mp)
11384 vat_main_t *vam = &vat_main;
11386 print (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s",
11387 (char *) mp->interface_name,
11388 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
11389 clib_net_to_host_u64 (mp->features), mp->is_server,
11390 ntohl (mp->num_regions), (char *) mp->sock_filename);
11391 print (vam->ofp, " Status: '%s'", strerror (ntohl (mp->sock_errno)));
11394 static void vl_api_sw_interface_vhost_user_details_t_handler_json
11395 (vl_api_sw_interface_vhost_user_details_t * mp)
11397 vat_main_t *vam = &vat_main;
11398 vat_json_node_t *node = NULL;
11400 if (VAT_JSON_ARRAY != vam->json_tree.type)
11402 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11403 vat_json_init_array (&vam->json_tree);
11405 node = vat_json_array_add (&vam->json_tree);
11407 vat_json_init_object (node);
11408 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11409 vat_json_object_add_string_copy (node, "interface_name",
11410 mp->interface_name);
11411 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
11412 ntohl (mp->virtio_net_hdr_sz));
11413 vat_json_object_add_uint (node, "features",
11414 clib_net_to_host_u64 (mp->features));
11415 vat_json_object_add_uint (node, "is_server", mp->is_server);
11416 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
11417 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
11418 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
11422 api_sw_interface_vhost_user_dump (vat_main_t * vam)
11424 vl_api_sw_interface_vhost_user_dump_t *mp;
11427 "Interface name idx hdr_sz features server regions filename");
11429 /* Get list of vhost-user interfaces */
11430 M (SW_INTERFACE_VHOST_USER_DUMP, sw_interface_vhost_user_dump);
11433 /* Use a control ping for synchronization */
11435 vl_api_control_ping_t *mp;
11436 M (CONTROL_PING, control_ping);
11443 api_show_version (vat_main_t * vam)
11445 vl_api_show_version_t *mp;
11448 M (SHOW_VERSION, show_version);
11458 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
11460 unformat_input_t *line_input = vam->input;
11461 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
11463 ip4_address_t local4, remote4;
11464 ip6_address_t local6, remote6;
11466 u8 ipv4_set = 0, ipv6_set = 0;
11469 u32 encap_vrf_id = 0;
11470 u32 decap_vrf_id = 0;
11475 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11477 if (unformat (line_input, "del"))
11479 else if (unformat (line_input, "local %U",
11480 unformat_ip4_address, &local4))
11485 else if (unformat (line_input, "remote %U",
11486 unformat_ip4_address, &remote4))
11491 else if (unformat (line_input, "local %U",
11492 unformat_ip6_address, &local6))
11497 else if (unformat (line_input, "remote %U",
11498 unformat_ip6_address, &remote6))
11503 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11505 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
11507 else if (unformat (line_input, "vni %d", &vni))
11509 else if (unformat (line_input, "next-ip4"))
11511 else if (unformat (line_input, "next-ip6"))
11513 else if (unformat (line_input, "next-ethernet"))
11515 else if (unformat (line_input, "next-nsh"))
11519 errmsg ("parse error '%U'", format_unformat_error, line_input);
11524 if (local_set == 0)
11526 errmsg ("tunnel local address not specified");
11529 if (remote_set == 0)
11531 errmsg ("tunnel remote address not specified");
11534 if (ipv4_set && ipv6_set)
11536 errmsg ("both IPv4 and IPv6 addresses specified");
11542 errmsg ("vni not specified");
11546 M (VXLAN_GPE_ADD_DEL_TUNNEL, vxlan_gpe_add_del_tunnel);
11551 clib_memcpy (&mp->local, &local6, sizeof (local6));
11552 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
11556 clib_memcpy (&mp->local, &local4, sizeof (local4));
11557 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
11560 mp->encap_vrf_id = ntohl (encap_vrf_id);
11561 mp->decap_vrf_id = ntohl (decap_vrf_id);
11562 mp->protocol = protocol;
11563 mp->vni = ntohl (vni);
11564 mp->is_add = is_add;
11565 mp->is_ipv6 = ipv6_set;
11573 static void vl_api_vxlan_gpe_tunnel_details_t_handler
11574 (vl_api_vxlan_gpe_tunnel_details_t * mp)
11576 vat_main_t *vam = &vat_main;
11578 print (vam->ofp, "%11d%24U%24U%13d%12d%14d%14d",
11579 ntohl (mp->sw_if_index),
11580 format_ip46_address, &(mp->local[0]),
11581 format_ip46_address, &(mp->remote[0]),
11583 ntohl (mp->protocol),
11584 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
11587 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
11588 (vl_api_vxlan_gpe_tunnel_details_t * mp)
11590 vat_main_t *vam = &vat_main;
11591 vat_json_node_t *node = NULL;
11592 struct in_addr ip4;
11593 struct in6_addr ip6;
11595 if (VAT_JSON_ARRAY != vam->json_tree.type)
11597 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11598 vat_json_init_array (&vam->json_tree);
11600 node = vat_json_array_add (&vam->json_tree);
11602 vat_json_init_object (node);
11603 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11606 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
11607 vat_json_object_add_ip6 (node, "local", ip6);
11608 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
11609 vat_json_object_add_ip6 (node, "remote", ip6);
11613 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
11614 vat_json_object_add_ip4 (node, "local", ip4);
11615 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
11616 vat_json_object_add_ip4 (node, "remote", ip4);
11618 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
11619 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
11620 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
11621 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
11622 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
11626 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
11628 unformat_input_t *i = vam->input;
11629 vl_api_vxlan_gpe_tunnel_dump_t *mp;
11632 u8 sw_if_index_set = 0;
11634 /* Parse args required to build the message */
11635 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11637 if (unformat (i, "sw_if_index %d", &sw_if_index))
11638 sw_if_index_set = 1;
11643 if (sw_if_index_set == 0)
11648 if (!vam->json_output)
11650 print (vam->ofp, "%11s%24s%24s%13s%15s%14s%14s",
11651 "sw_if_index", "local", "remote", "vni",
11652 "protocol", "encap_vrf_id", "decap_vrf_id");
11655 /* Get list of vxlan-tunnel interfaces */
11656 M (VXLAN_GPE_TUNNEL_DUMP, vxlan_gpe_tunnel_dump);
11658 mp->sw_if_index = htonl (sw_if_index);
11662 /* Use a control ping for synchronization */
11664 vl_api_control_ping_t *mp;
11665 M (CONTROL_PING, control_ping);
11672 format_l2_fib_mac_address (u8 * s, va_list * args)
11674 u8 *a = va_arg (*args, u8 *);
11676 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
11677 a[2], a[3], a[4], a[5], a[6], a[7]);
11680 static void vl_api_l2_fib_table_entry_t_handler
11681 (vl_api_l2_fib_table_entry_t * mp)
11683 vat_main_t *vam = &vat_main;
11685 print (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
11687 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
11688 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
11692 static void vl_api_l2_fib_table_entry_t_handler_json
11693 (vl_api_l2_fib_table_entry_t * mp)
11695 vat_main_t *vam = &vat_main;
11696 vat_json_node_t *node = NULL;
11698 if (VAT_JSON_ARRAY != vam->json_tree.type)
11700 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11701 vat_json_init_array (&vam->json_tree);
11703 node = vat_json_array_add (&vam->json_tree);
11705 vat_json_init_object (node);
11706 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
11707 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
11708 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11709 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
11710 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
11711 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
11715 api_l2_fib_table_dump (vat_main_t * vam)
11717 unformat_input_t *i = vam->input;
11718 vl_api_l2_fib_table_dump_t *mp;
11723 /* Parse args required to build the message */
11724 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11726 if (unformat (i, "bd_id %d", &bd_id))
11732 if (bd_id_set == 0)
11734 errmsg ("missing bridge domain");
11738 print (vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI");
11740 /* Get list of l2 fib entries */
11741 M (L2_FIB_TABLE_DUMP, l2_fib_table_dump);
11743 mp->bd_id = ntohl (bd_id);
11746 /* Use a control ping for synchronization */
11748 vl_api_control_ping_t *mp;
11749 M (CONTROL_PING, control_ping);
11757 api_interface_name_renumber (vat_main_t * vam)
11759 unformat_input_t *line_input = vam->input;
11760 vl_api_interface_name_renumber_t *mp;
11761 u32 sw_if_index = ~0;
11763 u32 new_show_dev_instance = ~0;
11765 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11767 if (unformat (line_input, "%U", api_unformat_sw_if_index, vam,
11770 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11772 else if (unformat (line_input, "new_show_dev_instance %d",
11773 &new_show_dev_instance))
11779 if (sw_if_index == ~0)
11781 errmsg ("missing interface name or sw_if_index");
11785 if (new_show_dev_instance == ~0)
11787 errmsg ("missing new_show_dev_instance");
11791 M (INTERFACE_NAME_RENUMBER, interface_name_renumber);
11793 mp->sw_if_index = ntohl (sw_if_index);
11794 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
11801 api_want_ip4_arp_events (vat_main_t * vam)
11803 unformat_input_t *line_input = vam->input;
11804 vl_api_want_ip4_arp_events_t *mp;
11806 ip4_address_t address;
11807 int address_set = 0;
11808 u32 enable_disable = 1;
11810 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11812 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
11814 else if (unformat (line_input, "del"))
11815 enable_disable = 0;
11820 if (address_set == 0)
11822 errmsg ("missing addresses");
11826 M (WANT_IP4_ARP_EVENTS, want_ip4_arp_events);
11827 mp->enable_disable = enable_disable;
11828 mp->pid = getpid ();
11829 mp->address = address.as_u32;
11836 api_want_ip6_nd_events (vat_main_t * vam)
11838 unformat_input_t *line_input = vam->input;
11839 vl_api_want_ip6_nd_events_t *mp;
11841 ip6_address_t address;
11842 int address_set = 0;
11843 u32 enable_disable = 1;
11845 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11847 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
11849 else if (unformat (line_input, "del"))
11850 enable_disable = 0;
11855 if (address_set == 0)
11857 errmsg ("missing addresses");
11861 M (WANT_IP6_ND_EVENTS, want_ip6_nd_events);
11862 mp->enable_disable = enable_disable;
11863 mp->pid = getpid ();
11864 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
11871 api_input_acl_set_interface (vat_main_t * vam)
11873 unformat_input_t *i = vam->input;
11874 vl_api_input_acl_set_interface_t *mp;
11877 int sw_if_index_set;
11878 u32 ip4_table_index = ~0;
11879 u32 ip6_table_index = ~0;
11880 u32 l2_table_index = ~0;
11883 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11885 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11886 sw_if_index_set = 1;
11887 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11888 sw_if_index_set = 1;
11889 else if (unformat (i, "del"))
11891 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11893 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11895 else if (unformat (i, "l2-table %d", &l2_table_index))
11899 clib_warning ("parse error '%U'", format_unformat_error, i);
11904 if (sw_if_index_set == 0)
11906 errmsg ("missing interface name or sw_if_index");
11910 M (INPUT_ACL_SET_INTERFACE, input_acl_set_interface);
11912 mp->sw_if_index = ntohl (sw_if_index);
11913 mp->ip4_table_index = ntohl (ip4_table_index);
11914 mp->ip6_table_index = ntohl (ip6_table_index);
11915 mp->l2_table_index = ntohl (l2_table_index);
11916 mp->is_add = is_add;
11925 api_ip_address_dump (vat_main_t * vam)
11927 unformat_input_t *i = vam->input;
11928 vl_api_ip_address_dump_t *mp;
11929 u32 sw_if_index = ~0;
11930 u8 sw_if_index_set = 0;
11935 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11937 if (unformat (i, "sw_if_index %d", &sw_if_index))
11938 sw_if_index_set = 1;
11940 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
11941 sw_if_index_set = 1;
11942 else if (unformat (i, "ipv4"))
11944 else if (unformat (i, "ipv6"))
11950 if (ipv4_set && ipv6_set)
11952 errmsg ("ipv4 and ipv6 flags cannot be both set");
11956 if ((!ipv4_set) && (!ipv6_set))
11958 errmsg ("no ipv4 nor ipv6 flag set");
11962 if (sw_if_index_set == 0)
11964 errmsg ("missing interface name or sw_if_index");
11968 vam->current_sw_if_index = sw_if_index;
11969 vam->is_ipv6 = ipv6_set;
11971 M (IP_ADDRESS_DUMP, ip_address_dump);
11972 mp->sw_if_index = ntohl (sw_if_index);
11973 mp->is_ipv6 = ipv6_set;
11976 /* Use a control ping for synchronization */
11978 vl_api_control_ping_t *mp;
11979 M (CONTROL_PING, control_ping);
11986 api_ip_dump (vat_main_t * vam)
11988 vl_api_ip_dump_t *mp;
11989 unformat_input_t *in = vam->input;
11996 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
11998 if (unformat (in, "ipv4"))
12000 else if (unformat (in, "ipv6"))
12006 if (ipv4_set && ipv6_set)
12008 errmsg ("ipv4 and ipv6 flags cannot be both set");
12012 if ((!ipv4_set) && (!ipv6_set))
12014 errmsg ("no ipv4 nor ipv6 flag set");
12018 is_ipv6 = ipv6_set;
12019 vam->is_ipv6 = is_ipv6;
12021 /* free old data */
12022 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
12024 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
12026 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
12028 M (IP_DUMP, ip_dump);
12029 mp->is_ipv6 = ipv6_set;
12032 /* Use a control ping for synchronization */
12034 vl_api_control_ping_t *mp;
12035 M (CONTROL_PING, control_ping);
12042 api_ipsec_spd_add_del (vat_main_t * vam)
12044 unformat_input_t *i = vam->input;
12045 vl_api_ipsec_spd_add_del_t *mp;
12050 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12052 if (unformat (i, "spd_id %d", &spd_id))
12054 else if (unformat (i, "del"))
12058 clib_warning ("parse error '%U'", format_unformat_error, i);
12064 errmsg ("spd_id must be set");
12068 M (IPSEC_SPD_ADD_DEL, ipsec_spd_add_del);
12070 mp->spd_id = ntohl (spd_id);
12071 mp->is_add = is_add;
12080 api_ipsec_interface_add_del_spd (vat_main_t * vam)
12082 unformat_input_t *i = vam->input;
12083 vl_api_ipsec_interface_add_del_spd_t *mp;
12086 u8 sw_if_index_set = 0;
12087 u32 spd_id = (u32) ~ 0;
12090 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12092 if (unformat (i, "del"))
12094 else if (unformat (i, "spd_id %d", &spd_id))
12097 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
12098 sw_if_index_set = 1;
12099 else if (unformat (i, "sw_if_index %d", &sw_if_index))
12100 sw_if_index_set = 1;
12103 clib_warning ("parse error '%U'", format_unformat_error, i);
12109 if (spd_id == (u32) ~ 0)
12111 errmsg ("spd_id must be set");
12115 if (sw_if_index_set == 0)
12117 errmsg ("missing interface name or sw_if_index");
12121 M (IPSEC_INTERFACE_ADD_DEL_SPD, ipsec_interface_add_del_spd);
12123 mp->spd_id = ntohl (spd_id);
12124 mp->sw_if_index = ntohl (sw_if_index);
12125 mp->is_add = is_add;
12134 api_ipsec_spd_add_del_entry (vat_main_t * vam)
12136 unformat_input_t *i = vam->input;
12137 vl_api_ipsec_spd_add_del_entry_t *mp;
12139 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
12140 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
12142 u32 rport_start = 0, rport_stop = (u32) ~ 0;
12143 u32 lport_start = 0, lport_stop = (u32) ~ 0;
12144 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
12145 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
12147 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
12148 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
12149 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
12150 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
12151 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
12152 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
12154 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12156 if (unformat (i, "del"))
12158 if (unformat (i, "outbound"))
12160 if (unformat (i, "inbound"))
12162 else if (unformat (i, "spd_id %d", &spd_id))
12164 else if (unformat (i, "sa_id %d", &sa_id))
12166 else if (unformat (i, "priority %d", &priority))
12168 else if (unformat (i, "protocol %d", &protocol))
12170 else if (unformat (i, "lport_start %d", &lport_start))
12172 else if (unformat (i, "lport_stop %d", &lport_stop))
12174 else if (unformat (i, "rport_start %d", &rport_start))
12176 else if (unformat (i, "rport_stop %d", &rport_stop))
12180 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
12186 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
12193 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
12199 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
12206 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
12212 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
12219 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
12225 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
12231 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
12233 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
12235 clib_warning ("unsupported action: 'resolve'");
12241 clib_warning ("parse error '%U'", format_unformat_error, i);
12247 M (IPSEC_SPD_ADD_DEL_ENTRY, ipsec_spd_add_del_entry);
12249 mp->spd_id = ntohl (spd_id);
12250 mp->priority = ntohl (priority);
12251 mp->is_outbound = is_outbound;
12253 mp->is_ipv6 = is_ipv6;
12254 if (is_ipv6 || is_ip_any)
12256 clib_memcpy (mp->remote_address_start, &raddr6_start,
12257 sizeof (ip6_address_t));
12258 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
12259 sizeof (ip6_address_t));
12260 clib_memcpy (mp->local_address_start, &laddr6_start,
12261 sizeof (ip6_address_t));
12262 clib_memcpy (mp->local_address_stop, &laddr6_stop,
12263 sizeof (ip6_address_t));
12267 clib_memcpy (mp->remote_address_start, &raddr4_start,
12268 sizeof (ip4_address_t));
12269 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
12270 sizeof (ip4_address_t));
12271 clib_memcpy (mp->local_address_start, &laddr4_start,
12272 sizeof (ip4_address_t));
12273 clib_memcpy (mp->local_address_stop, &laddr4_stop,
12274 sizeof (ip4_address_t));
12276 mp->protocol = (u8) protocol;
12277 mp->local_port_start = ntohs ((u16) lport_start);
12278 mp->local_port_stop = ntohs ((u16) lport_stop);
12279 mp->remote_port_start = ntohs ((u16) rport_start);
12280 mp->remote_port_stop = ntohs ((u16) rport_stop);
12281 mp->policy = (u8) policy;
12282 mp->sa_id = ntohl (sa_id);
12283 mp->is_add = is_add;
12284 mp->is_ip_any = is_ip_any;
12292 api_ipsec_sad_add_del_entry (vat_main_t * vam)
12294 unformat_input_t *i = vam->input;
12295 vl_api_ipsec_sad_add_del_entry_t *mp;
12297 u32 sad_id = 0, spi = 0;
12298 u8 *ck = 0, *ik = 0;
12301 u8 protocol = IPSEC_PROTOCOL_AH;
12302 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
12303 u32 crypto_alg = 0, integ_alg = 0;
12304 ip4_address_t tun_src4;
12305 ip4_address_t tun_dst4;
12306 ip6_address_t tun_src6;
12307 ip6_address_t tun_dst6;
12309 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12311 if (unformat (i, "del"))
12313 else if (unformat (i, "sad_id %d", &sad_id))
12315 else if (unformat (i, "spi %d", &spi))
12317 else if (unformat (i, "esp"))
12318 protocol = IPSEC_PROTOCOL_ESP;
12319 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
12322 is_tunnel_ipv6 = 0;
12324 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
12327 is_tunnel_ipv6 = 0;
12329 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
12332 is_tunnel_ipv6 = 1;
12334 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
12337 is_tunnel_ipv6 = 1;
12341 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
12343 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
12344 crypto_alg >= IPSEC_CRYPTO_N_ALG)
12346 clib_warning ("unsupported crypto-alg: '%U'",
12347 format_ipsec_crypto_alg, crypto_alg);
12351 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
12355 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
12357 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
12358 integ_alg >= IPSEC_INTEG_N_ALG)
12360 clib_warning ("unsupported integ-alg: '%U'",
12361 format_ipsec_integ_alg, integ_alg);
12365 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
12369 clib_warning ("parse error '%U'", format_unformat_error, i);
12375 M (IPSEC_SAD_ADD_DEL_ENTRY, ipsec_sad_add_del_entry);
12377 mp->sad_id = ntohl (sad_id);
12378 mp->is_add = is_add;
12379 mp->protocol = protocol;
12380 mp->spi = ntohl (spi);
12381 mp->is_tunnel = is_tunnel;
12382 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
12383 mp->crypto_algorithm = crypto_alg;
12384 mp->integrity_algorithm = integ_alg;
12385 mp->crypto_key_length = vec_len (ck);
12386 mp->integrity_key_length = vec_len (ik);
12388 if (mp->crypto_key_length > sizeof (mp->crypto_key))
12389 mp->crypto_key_length = sizeof (mp->crypto_key);
12391 if (mp->integrity_key_length > sizeof (mp->integrity_key))
12392 mp->integrity_key_length = sizeof (mp->integrity_key);
12395 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
12397 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
12401 if (is_tunnel_ipv6)
12403 clib_memcpy (mp->tunnel_src_address, &tun_src6,
12404 sizeof (ip6_address_t));
12405 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
12406 sizeof (ip6_address_t));
12410 clib_memcpy (mp->tunnel_src_address, &tun_src4,
12411 sizeof (ip4_address_t));
12412 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
12413 sizeof (ip4_address_t));
12424 api_ipsec_sa_set_key (vat_main_t * vam)
12426 unformat_input_t *i = vam->input;
12427 vl_api_ipsec_sa_set_key_t *mp;
12430 u8 *ck = 0, *ik = 0;
12432 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12434 if (unformat (i, "sa_id %d", &sa_id))
12436 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
12438 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
12442 clib_warning ("parse error '%U'", format_unformat_error, i);
12447 M (IPSEC_SA_SET_KEY, ipsec_set_sa_key);
12449 mp->sa_id = ntohl (sa_id);
12450 mp->crypto_key_length = vec_len (ck);
12451 mp->integrity_key_length = vec_len (ik);
12453 if (mp->crypto_key_length > sizeof (mp->crypto_key))
12454 mp->crypto_key_length = sizeof (mp->crypto_key);
12456 if (mp->integrity_key_length > sizeof (mp->integrity_key))
12457 mp->integrity_key_length = sizeof (mp->integrity_key);
12460 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
12462 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
12471 api_ikev2_profile_add_del (vat_main_t * vam)
12473 unformat_input_t *i = vam->input;
12474 vl_api_ikev2_profile_add_del_t *mp;
12479 const char *valid_chars = "a-zA-Z0-9_";
12481 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12483 if (unformat (i, "del"))
12485 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12486 vec_add1 (name, 0);
12489 errmsg ("parse error '%U'", format_unformat_error, i);
12494 if (!vec_len (name))
12496 errmsg ("profile name must be specified");
12500 if (vec_len (name) > 64)
12502 errmsg ("profile name too long");
12506 M (IKEV2_PROFILE_ADD_DEL, ikev2_profile_add_del);
12508 clib_memcpy (mp->name, name, vec_len (name));
12509 mp->is_add = is_add;
12519 api_ikev2_profile_set_auth (vat_main_t * vam)
12521 unformat_input_t *i = vam->input;
12522 vl_api_ikev2_profile_set_auth_t *mp;
12526 u32 auth_method = 0;
12529 const char *valid_chars = "a-zA-Z0-9_";
12531 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12533 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12534 vec_add1 (name, 0);
12535 else if (unformat (i, "auth_method %U",
12536 unformat_ikev2_auth_method, &auth_method))
12538 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
12540 else if (unformat (i, "auth_data %v", &data))
12544 errmsg ("parse error '%U'", format_unformat_error, i);
12549 if (!vec_len (name))
12551 errmsg ("profile name must be specified");
12555 if (vec_len (name) > 64)
12557 errmsg ("profile name too long");
12561 if (!vec_len (data))
12563 errmsg ("auth_data must be specified");
12569 errmsg ("auth_method must be specified");
12573 M (IKEV2_PROFILE_SET_AUTH, ikev2_profile_set_auth);
12575 mp->is_hex = is_hex;
12576 mp->auth_method = (u8) auth_method;
12577 mp->data_len = vec_len (data);
12578 clib_memcpy (mp->name, name, vec_len (name));
12579 clib_memcpy (mp->data, data, vec_len (data));
12590 api_ikev2_profile_set_id (vat_main_t * vam)
12592 unformat_input_t *i = vam->input;
12593 vl_api_ikev2_profile_set_id_t *mp;
12601 const char *valid_chars = "a-zA-Z0-9_";
12603 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12605 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12606 vec_add1 (name, 0);
12607 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
12609 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
12611 data = vec_new (u8, 4);
12612 clib_memcpy (data, ip4.as_u8, 4);
12614 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
12616 else if (unformat (i, "id_data %v", &data))
12618 else if (unformat (i, "local"))
12620 else if (unformat (i, "remote"))
12624 errmsg ("parse error '%U'", format_unformat_error, i);
12629 if (!vec_len (name))
12631 errmsg ("profile name must be specified");
12635 if (vec_len (name) > 64)
12637 errmsg ("profile name too long");
12641 if (!vec_len (data))
12643 errmsg ("id_data must be specified");
12649 errmsg ("id_type must be specified");
12653 M (IKEV2_PROFILE_SET_ID, ikev2_profile_set_id);
12655 mp->is_local = is_local;
12656 mp->id_type = (u8) id_type;
12657 mp->data_len = vec_len (data);
12658 clib_memcpy (mp->name, name, vec_len (name));
12659 clib_memcpy (mp->data, data, vec_len (data));
12670 api_ikev2_profile_set_ts (vat_main_t * vam)
12672 unformat_input_t *i = vam->input;
12673 vl_api_ikev2_profile_set_ts_t *mp;
12677 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
12678 ip4_address_t start_addr, end_addr;
12680 const char *valid_chars = "a-zA-Z0-9_";
12682 start_addr.as_u32 = 0;
12683 end_addr.as_u32 = (u32) ~ 0;
12685 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12687 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12688 vec_add1 (name, 0);
12689 else if (unformat (i, "protocol %d", &proto))
12691 else if (unformat (i, "start_port %d", &start_port))
12693 else if (unformat (i, "end_port %d", &end_port))
12696 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
12698 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
12700 else if (unformat (i, "local"))
12702 else if (unformat (i, "remote"))
12706 errmsg ("parse error '%U'", format_unformat_error, i);
12711 if (!vec_len (name))
12713 errmsg ("profile name must be specified");
12717 if (vec_len (name) > 64)
12719 errmsg ("profile name too long");
12723 M (IKEV2_PROFILE_SET_TS, ikev2_profile_set_ts);
12725 mp->is_local = is_local;
12726 mp->proto = (u8) proto;
12727 mp->start_port = (u16) start_port;
12728 mp->end_port = (u16) end_port;
12729 mp->start_addr = start_addr.as_u32;
12730 mp->end_addr = end_addr.as_u32;
12731 clib_memcpy (mp->name, name, vec_len (name));
12741 api_ikev2_set_local_key (vat_main_t * vam)
12743 unformat_input_t *i = vam->input;
12744 vl_api_ikev2_set_local_key_t *mp;
12748 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12750 if (unformat (i, "file %v", &file))
12751 vec_add1 (file, 0);
12754 errmsg ("parse error '%U'", format_unformat_error, i);
12759 if (!vec_len (file))
12761 errmsg ("RSA key file must be specified");
12765 if (vec_len (file) > 256)
12767 errmsg ("file name too long");
12771 M (IKEV2_SET_LOCAL_KEY, ikev2_set_local_key);
12773 clib_memcpy (mp->key_file, file, vec_len (file));
12786 api_map_add_domain (vat_main_t * vam)
12788 unformat_input_t *i = vam->input;
12789 vl_api_map_add_domain_t *mp;
12792 ip4_address_t ip4_prefix;
12793 ip6_address_t ip6_prefix;
12794 ip6_address_t ip6_src;
12795 u32 num_m_args = 0;
12796 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
12797 0, psid_length = 0;
12798 u8 is_translation = 0;
12800 u32 ip6_src_len = 128;
12802 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12804 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
12805 &ip4_prefix, &ip4_prefix_len))
12807 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
12808 &ip6_prefix, &ip6_prefix_len))
12812 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
12815 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
12817 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
12819 else if (unformat (i, "psid-offset %d", &psid_offset))
12821 else if (unformat (i, "psid-len %d", &psid_length))
12823 else if (unformat (i, "mtu %d", &mtu))
12825 else if (unformat (i, "map-t"))
12826 is_translation = 1;
12829 clib_warning ("parse error '%U'", format_unformat_error, i);
12834 if (num_m_args < 3)
12836 errmsg ("mandatory argument(s) missing");
12840 /* Construct the API message */
12841 M (MAP_ADD_DOMAIN, map_add_domain);
12843 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
12844 mp->ip4_prefix_len = ip4_prefix_len;
12846 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
12847 mp->ip6_prefix_len = ip6_prefix_len;
12849 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
12850 mp->ip6_src_prefix_len = ip6_src_len;
12852 mp->ea_bits_len = ea_bits_len;
12853 mp->psid_offset = psid_offset;
12854 mp->psid_length = psid_length;
12855 mp->is_translation = is_translation;
12856 mp->mtu = htons (mtu);
12861 /* Wait for a reply, return good/bad news */
12866 api_map_del_domain (vat_main_t * vam)
12868 unformat_input_t *i = vam->input;
12869 vl_api_map_del_domain_t *mp;
12872 u32 num_m_args = 0;
12875 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12877 if (unformat (i, "index %d", &index))
12881 clib_warning ("parse error '%U'", format_unformat_error, i);
12886 if (num_m_args != 1)
12888 errmsg ("mandatory argument(s) missing");
12892 /* Construct the API message */
12893 M (MAP_DEL_DOMAIN, map_del_domain);
12895 mp->index = ntohl (index);
12900 /* Wait for a reply, return good/bad news */
12905 api_map_add_del_rule (vat_main_t * vam)
12907 unformat_input_t *i = vam->input;
12908 vl_api_map_add_del_rule_t *mp;
12911 ip6_address_t ip6_dst;
12912 u32 num_m_args = 0, index, psid = 0;
12914 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12916 if (unformat (i, "index %d", &index))
12918 else if (unformat (i, "psid %d", &psid))
12920 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
12922 else if (unformat (i, "del"))
12928 clib_warning ("parse error '%U'", format_unformat_error, i);
12933 /* Construct the API message */
12934 M (MAP_ADD_DEL_RULE, map_add_del_rule);
12936 mp->index = ntohl (index);
12937 mp->is_add = is_add;
12938 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
12939 mp->psid = ntohs (psid);
12944 /* Wait for a reply, return good/bad news */
12949 api_map_domain_dump (vat_main_t * vam)
12951 vl_api_map_domain_dump_t *mp;
12954 /* Construct the API message */
12955 M (MAP_DOMAIN_DUMP, map_domain_dump);
12960 /* Use a control ping for synchronization */
12962 vl_api_control_ping_t *mp;
12963 M (CONTROL_PING, control_ping);
12970 api_map_rule_dump (vat_main_t * vam)
12972 unformat_input_t *i = vam->input;
12973 vl_api_map_rule_dump_t *mp;
12975 u32 domain_index = ~0;
12977 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12979 if (unformat (i, "index %u", &domain_index))
12985 if (domain_index == ~0)
12987 clib_warning ("parse error: domain index expected");
12991 /* Construct the API message */
12992 M (MAP_RULE_DUMP, map_rule_dump);
12994 mp->domain_index = htonl (domain_index);
12999 /* Use a control ping for synchronization */
13001 vl_api_control_ping_t *mp;
13002 M (CONTROL_PING, control_ping);
13008 static void vl_api_map_add_domain_reply_t_handler
13009 (vl_api_map_add_domain_reply_t * mp)
13011 vat_main_t *vam = &vat_main;
13012 i32 retval = ntohl (mp->retval);
13014 if (vam->async_mode)
13016 vam->async_errors += (retval < 0);
13020 vam->retval = retval;
13021 vam->result_ready = 1;
13025 static void vl_api_map_add_domain_reply_t_handler_json
13026 (vl_api_map_add_domain_reply_t * mp)
13028 vat_main_t *vam = &vat_main;
13029 vat_json_node_t node;
13031 vat_json_init_object (&node);
13032 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
13033 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
13035 vat_json_print (vam->ofp, &node);
13036 vat_json_free (&node);
13038 vam->retval = ntohl (mp->retval);
13039 vam->result_ready = 1;
13043 api_get_first_msg_id (vat_main_t * vam)
13045 vl_api_get_first_msg_id_t *mp;
13047 unformat_input_t *i = vam->input;
13051 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13053 if (unformat (i, "client %s", &name))
13061 errmsg ("missing client name");
13064 vec_add1 (name, 0);
13066 if (vec_len (name) > 63)
13068 errmsg ("client name too long");
13072 M (GET_FIRST_MSG_ID, get_first_msg_id);
13073 clib_memcpy (mp->name, name, vec_len (name));
13081 api_cop_interface_enable_disable (vat_main_t * vam)
13083 unformat_input_t *line_input = vam->input;
13084 vl_api_cop_interface_enable_disable_t *mp;
13086 u32 sw_if_index = ~0;
13087 u8 enable_disable = 1;
13089 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13091 if (unformat (line_input, "disable"))
13092 enable_disable = 0;
13093 if (unformat (line_input, "enable"))
13094 enable_disable = 1;
13095 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
13096 vam, &sw_if_index))
13098 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13104 if (sw_if_index == ~0)
13106 errmsg ("missing interface name or sw_if_index");
13110 /* Construct the API message */
13111 M (COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable);
13112 mp->sw_if_index = ntohl (sw_if_index);
13113 mp->enable_disable = enable_disable;
13117 /* Wait for the reply */
13122 api_cop_whitelist_enable_disable (vat_main_t * vam)
13124 unformat_input_t *line_input = vam->input;
13125 vl_api_cop_whitelist_enable_disable_t *mp;
13127 u32 sw_if_index = ~0;
13128 u8 ip4 = 0, ip6 = 0, default_cop = 0;
13131 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
13133 if (unformat (line_input, "ip4"))
13135 else if (unformat (line_input, "ip6"))
13137 else if (unformat (line_input, "default"))
13139 else if (unformat (line_input, "%U", api_unformat_sw_if_index,
13140 vam, &sw_if_index))
13142 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
13144 else if (unformat (line_input, "fib-id %d", &fib_id))
13150 if (sw_if_index == ~0)
13152 errmsg ("missing interface name or sw_if_index");
13156 /* Construct the API message */
13157 M (COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable);
13158 mp->sw_if_index = ntohl (sw_if_index);
13159 mp->fib_id = ntohl (fib_id);
13162 mp->default_cop = default_cop;
13166 /* Wait for the reply */
13171 api_get_node_graph (vat_main_t * vam)
13173 vl_api_get_node_graph_t *mp;
13176 M (GET_NODE_GRAPH, get_node_graph);
13180 /* Wait for the reply */
13185 /** Used for parsing LISP eids */
13186 typedef CLIB_PACKED(struct{
13187 u8 addr[16]; /**< eid address */
13188 u32 len; /**< prefix length if IP */
13189 u8 type; /**< type of eid */
13194 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
13196 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
13198 memset (a, 0, sizeof (a[0]));
13200 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
13202 a->type = 0; /* ipv4 type */
13204 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
13206 a->type = 1; /* ipv6 type */
13208 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
13210 a->type = 2; /* mac type */
13217 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
13226 lisp_eid_size_vat (u8 type)
13241 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
13243 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
13247 api_lisp_add_del_locator_set (vat_main_t * vam)
13249 unformat_input_t *input = vam->input;
13250 vl_api_lisp_add_del_locator_set_t *mp;
13253 u8 *locator_set_name = NULL;
13254 u8 locator_set_name_set = 0;
13255 vl_api_local_locator_t locator, *locators = 0;
13256 u32 sw_if_index, priority, weight;
13259 /* Parse args required to build the message */
13260 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13262 if (unformat (input, "del"))
13266 else if (unformat (input, "locator-set %s", &locator_set_name))
13268 locator_set_name_set = 1;
13270 else if (unformat (input, "sw_if_index %u p %u w %u",
13271 &sw_if_index, &priority, &weight))
13273 locator.sw_if_index = htonl (sw_if_index);
13274 locator.priority = priority;
13275 locator.weight = weight;
13276 vec_add1 (locators, locator);
13280 (input, "iface %U p %u w %u", api_unformat_sw_if_index, vam,
13281 &sw_if_index, &priority, &weight))
13283 locator.sw_if_index = htonl (sw_if_index);
13284 locator.priority = priority;
13285 locator.weight = weight;
13286 vec_add1 (locators, locator);
13292 if (locator_set_name_set == 0)
13294 errmsg ("missing locator-set name");
13295 vec_free (locators);
13299 if (vec_len (locator_set_name) > 64)
13301 errmsg ("locator-set name too long");
13302 vec_free (locator_set_name);
13303 vec_free (locators);
13306 vec_add1 (locator_set_name, 0);
13308 data_len = sizeof (vl_api_local_locator_t) * vec_len (locators);
13310 /* Construct the API message */
13311 M2 (LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set, data_len);
13313 mp->is_add = is_add;
13314 clib_memcpy (mp->locator_set_name, locator_set_name,
13315 vec_len (locator_set_name));
13316 vec_free (locator_set_name);
13318 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
13320 clib_memcpy (mp->locators, locators, data_len);
13321 vec_free (locators);
13326 /* Wait for a reply... */
13334 api_lisp_add_del_locator (vat_main_t * vam)
13336 unformat_input_t *input = vam->input;
13337 vl_api_lisp_add_del_locator_t *mp;
13339 u32 tmp_if_index = ~0;
13340 u32 sw_if_index = ~0;
13341 u8 sw_if_index_set = 0;
13342 u8 sw_if_index_if_name_set = 0;
13344 u8 priority_set = 0;
13348 u8 *locator_set_name = NULL;
13349 u8 locator_set_name_set = 0;
13351 /* Parse args required to build the message */
13352 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13354 if (unformat (input, "del"))
13358 else if (unformat (input, "locator-set %s", &locator_set_name))
13360 locator_set_name_set = 1;
13362 else if (unformat (input, "iface %U", api_unformat_sw_if_index, vam,
13365 sw_if_index_if_name_set = 1;
13366 sw_if_index = tmp_if_index;
13368 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
13370 sw_if_index_set = 1;
13371 sw_if_index = tmp_if_index;
13373 else if (unformat (input, "p %d", &priority))
13377 else if (unformat (input, "w %d", &weight))
13385 if (locator_set_name_set == 0)
13387 errmsg ("missing locator-set name");
13391 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
13393 errmsg ("missing sw_if_index");
13394 vec_free (locator_set_name);
13398 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
13400 errmsg ("cannot use both params interface name and sw_if_index");
13401 vec_free (locator_set_name);
13405 if (priority_set == 0)
13407 errmsg ("missing locator-set priority");
13408 vec_free (locator_set_name);
13412 if (weight_set == 0)
13414 errmsg ("missing locator-set weight");
13415 vec_free (locator_set_name);
13419 if (vec_len (locator_set_name) > 64)
13421 errmsg ("locator-set name too long");
13422 vec_free (locator_set_name);
13425 vec_add1 (locator_set_name, 0);
13427 /* Construct the API message */
13428 M (LISP_ADD_DEL_LOCATOR, lisp_add_del_locator);
13430 mp->is_add = is_add;
13431 mp->sw_if_index = ntohl (sw_if_index);
13432 mp->priority = priority;
13433 mp->weight = weight;
13434 clib_memcpy (mp->locator_set_name, locator_set_name,
13435 vec_len (locator_set_name));
13436 vec_free (locator_set_name);
13441 /* Wait for a reply... */
13449 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
13451 u32 *key_id = va_arg (*args, u32 *);
13454 if (unformat (input, "%s", &s))
13456 if (!strcmp ((char *) s, "sha1"))
13457 key_id[0] = HMAC_SHA_1_96;
13458 else if (!strcmp ((char *) s, "sha256"))
13459 key_id[0] = HMAC_SHA_256_128;
13462 clib_warning ("invalid key_id: '%s'", s);
13463 key_id[0] = HMAC_NO_KEY;
13474 api_lisp_add_del_local_eid (vat_main_t * vam)
13476 unformat_input_t *input = vam->input;
13477 vl_api_lisp_add_del_local_eid_t *mp;
13481 lisp_eid_vat_t _eid, *eid = &_eid;
13482 u8 *locator_set_name = 0;
13483 u8 locator_set_name_set = 0;
13488 /* Parse args required to build the message */
13489 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13491 if (unformat (input, "del"))
13495 else if (unformat (input, "vni %d", &vni))
13499 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
13503 else if (unformat (input, "locator-set %s", &locator_set_name))
13505 locator_set_name_set = 1;
13507 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
13509 else if (unformat (input, "secret-key %_%v%_", &key))
13515 if (locator_set_name_set == 0)
13517 errmsg ("missing locator-set name");
13523 errmsg ("EID address not set!");
13524 vec_free (locator_set_name);
13528 if (key && (0 == key_id))
13530 errmsg ("invalid key_id!");
13534 if (vec_len (key) > 64)
13536 errmsg ("key too long");
13541 if (vec_len (locator_set_name) > 64)
13543 errmsg ("locator-set name too long");
13544 vec_free (locator_set_name);
13547 vec_add1 (locator_set_name, 0);
13549 /* Construct the API message */
13550 M (LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid);
13552 mp->is_add = is_add;
13553 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
13554 mp->eid_type = eid->type;
13555 mp->prefix_len = eid->len;
13556 mp->vni = clib_host_to_net_u32 (vni);
13557 mp->key_id = clib_host_to_net_u16 (key_id);
13558 clib_memcpy (mp->locator_set_name, locator_set_name,
13559 vec_len (locator_set_name));
13560 clib_memcpy (mp->key, key, vec_len (key));
13562 vec_free (locator_set_name);
13568 /* Wait for a reply... */
13576 /** Used for transferring locators via VPP API */
13577 typedef CLIB_PACKED(struct
13579 u8 is_ip4; /**< is locator an IPv4 address? */
13580 u8 priority; /**< locator priority */
13581 u8 weight; /**< locator weight */
13582 u8 addr[16]; /**< IPv4/IPv6 address */
13587 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
13589 u32 dp_table = 0, vni = 0;;
13590 unformat_input_t *input = vam->input;
13591 vl_api_lisp_gpe_add_del_fwd_entry_t *mp;
13594 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
13595 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
13596 u8 rmt_eid_set = 0, lcl_eid_set = 0;
13597 u32 action = ~0, w;
13598 ip4_address_t rmt_rloc4, lcl_rloc4;
13599 ip6_address_t rmt_rloc6, lcl_rloc6;
13600 vl_api_lisp_gpe_locator_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc =
13603 memset (&rloc, 0, sizeof (rloc));
13605 /* Parse args required to build the message */
13606 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13608 if (unformat (input, "del"))
13610 else if (unformat (input, "add"))
13612 else if (unformat (input, "reid %U", unformat_lisp_eid_vat, rmt_eid))
13616 else if (unformat (input, "leid %U", unformat_lisp_eid_vat, lcl_eid))
13620 else if (unformat (input, "vrf %d", &dp_table))
13622 else if (unformat (input, "bd %d", &dp_table))
13624 else if (unformat (input, "vni %d", &vni))
13626 else if (unformat (input, "w %d", &w))
13630 errmsg ("No RLOC configured for setting priority/weight!");
13633 curr_rloc->weight = w;
13635 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
13636 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
13640 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
13642 vec_add1 (lcl_locs, rloc);
13644 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
13645 vec_add1 (rmt_locs, rloc);
13646 /* weight saved in rmt loc */
13647 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
13649 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
13650 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
13653 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
13655 vec_add1 (lcl_locs, rloc);
13657 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
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, "action %d", &action))
13668 clib_warning ("parse error '%U'", format_unformat_error, input);
13675 errmsg ("remote eid addresses not set");
13679 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
13681 errmsg ("eid types don't match");
13685 if (0 == rmt_locs && (u32) ~ 0 == action)
13687 errmsg ("action not set for negative mapping");
13691 /* Construct the API message */
13692 M2 (LISP_GPE_ADD_DEL_FWD_ENTRY, lisp_gpe_add_del_fwd_entry,
13693 sizeof (vl_api_lisp_gpe_locator_t) * vec_len (rmt_locs) * 2);
13695 mp->is_add = is_add;
13696 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
13697 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
13698 mp->eid_type = rmt_eid->type;
13699 mp->dp_table = clib_host_to_net_u32 (dp_table);
13700 mp->vni = clib_host_to_net_u32 (vni);
13701 mp->rmt_len = rmt_eid->len;
13702 mp->lcl_len = lcl_eid->len;
13703 mp->action = action;
13705 if (0 != rmt_locs && 0 != lcl_locs)
13707 mp->loc_num = clib_host_to_net_u32 (vec_len (rmt_locs) * 2);
13708 clib_memcpy (mp->locs, lcl_locs,
13709 (sizeof (vl_api_lisp_gpe_locator_t) * vec_len (lcl_locs)));
13711 u32 offset = sizeof (vl_api_lisp_gpe_locator_t) * vec_len (lcl_locs);
13712 clib_memcpy (((u8 *) mp->locs) + offset, rmt_locs,
13713 (sizeof (vl_api_lisp_gpe_locator_t) * vec_len (rmt_locs)));
13715 vec_free (lcl_locs);
13716 vec_free (rmt_locs);
13721 /* Wait for a reply... */
13729 api_lisp_add_del_map_server (vat_main_t * vam)
13731 unformat_input_t *input = vam->input;
13732 vl_api_lisp_add_del_map_server_t *mp;
13737 ip4_address_t ipv4;
13738 ip6_address_t ipv6;
13740 /* Parse args required to build the message */
13741 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13743 if (unformat (input, "del"))
13747 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
13751 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
13759 if (ipv4_set && ipv6_set)
13761 errmsg ("both eid v4 and v6 addresses set");
13765 if (!ipv4_set && !ipv6_set)
13767 errmsg ("eid addresses not set");
13771 /* Construct the API message */
13772 M (LISP_ADD_DEL_MAP_SERVER, lisp_add_del_map_server);
13774 mp->is_add = is_add;
13778 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
13783 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
13789 /* Wait for a reply... */
13797 api_lisp_add_del_map_resolver (vat_main_t * vam)
13799 unformat_input_t *input = vam->input;
13800 vl_api_lisp_add_del_map_resolver_t *mp;
13805 ip4_address_t ipv4;
13806 ip6_address_t ipv6;
13808 /* Parse args required to build the message */
13809 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13811 if (unformat (input, "del"))
13815 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
13819 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
13827 if (ipv4_set && ipv6_set)
13829 errmsg ("both eid v4 and v6 addresses set");
13833 if (!ipv4_set && !ipv6_set)
13835 errmsg ("eid addresses not set");
13839 /* Construct the API message */
13840 M (LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver);
13842 mp->is_add = is_add;
13846 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
13851 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
13857 /* Wait for a reply... */
13865 api_lisp_gpe_enable_disable (vat_main_t * vam)
13867 unformat_input_t *input = vam->input;
13868 vl_api_lisp_gpe_enable_disable_t *mp;
13873 /* Parse args required to build the message */
13874 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13876 if (unformat (input, "enable"))
13881 else if (unformat (input, "disable"))
13892 errmsg ("Value not set");
13896 /* Construct the API message */
13897 M (LISP_GPE_ENABLE_DISABLE, lisp_gpe_enable_disable);
13904 /* Wait for a reply... */
13912 api_lisp_rloc_probe_enable_disable (vat_main_t * vam)
13914 unformat_input_t *input = vam->input;
13915 vl_api_lisp_rloc_probe_enable_disable_t *mp;
13920 /* Parse args required to build the message */
13921 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13923 if (unformat (input, "enable"))
13928 else if (unformat (input, "disable"))
13936 errmsg ("Value not set");
13940 /* Construct the API message */
13941 M (LISP_RLOC_PROBE_ENABLE_DISABLE, lisp_rloc_probe_enable_disable);
13943 mp->is_enabled = is_en;
13948 /* Wait for a reply... */
13956 api_lisp_map_register_enable_disable (vat_main_t * vam)
13958 unformat_input_t *input = vam->input;
13959 vl_api_lisp_map_register_enable_disable_t *mp;
13964 /* Parse args required to build the message */
13965 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13967 if (unformat (input, "enable"))
13972 else if (unformat (input, "disable"))
13980 errmsg ("Value not set");
13984 /* Construct the API message */
13985 M (LISP_MAP_REGISTER_ENABLE_DISABLE, lisp_map_register_enable_disable);
13987 mp->is_enabled = is_en;
13992 /* Wait for a reply... */
14000 api_lisp_enable_disable (vat_main_t * vam)
14002 unformat_input_t *input = vam->input;
14003 vl_api_lisp_enable_disable_t *mp;
14008 /* Parse args required to build the message */
14009 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14011 if (unformat (input, "enable"))
14016 else if (unformat (input, "disable"))
14026 errmsg ("Value not set");
14030 /* Construct the API message */
14031 M (LISP_ENABLE_DISABLE, lisp_enable_disable);
14038 /* Wait for a reply... */
14046 api_show_lisp_map_register_state (vat_main_t * vam)
14049 vl_api_show_lisp_map_register_state_t *mp;
14051 M (SHOW_LISP_MAP_REGISTER_STATE, show_lisp_map_register_state);
14056 /* wait for reply */
14063 api_show_lisp_rloc_probe_state (vat_main_t * vam)
14066 vl_api_show_lisp_rloc_probe_state_t *mp;
14068 M (SHOW_LISP_RLOC_PROBE_STATE, show_lisp_rloc_probe_state);
14073 /* wait for reply */
14080 api_show_lisp_map_request_mode (vat_main_t * vam)
14083 vl_api_show_lisp_map_request_mode_t *mp;
14085 M (SHOW_LISP_MAP_REQUEST_MODE, show_lisp_map_request_mode);
14090 /* wait for reply */
14097 api_lisp_map_request_mode (vat_main_t * vam)
14100 unformat_input_t *input = vam->input;
14101 vl_api_lisp_map_request_mode_t *mp;
14104 /* Parse args required to build the message */
14105 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14107 if (unformat (input, "dst-only"))
14109 else if (unformat (input, "src-dst"))
14113 errmsg ("parse error '%U'", format_unformat_error, input);
14118 M (LISP_MAP_REQUEST_MODE, lisp_map_request_mode);
14125 /* wait for reply */
14133 * Enable/disable LISP proxy ITR.
14135 * @param vam vpp API test context
14136 * @return return code
14139 api_lisp_pitr_set_locator_set (vat_main_t * vam)
14142 u8 ls_name_set = 0;
14143 unformat_input_t *input = vam->input;
14144 vl_api_lisp_pitr_set_locator_set_t *mp;
14148 /* Parse args required to build the message */
14149 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14151 if (unformat (input, "del"))
14153 else if (unformat (input, "locator-set %s", &ls_name))
14157 errmsg ("parse error '%U'", format_unformat_error, input);
14164 errmsg ("locator-set name not set!");
14168 M (LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set);
14170 mp->is_add = is_add;
14171 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
14172 vec_free (ls_name);
14177 /* wait for reply */
14185 api_show_lisp_pitr (vat_main_t * vam)
14187 vl_api_show_lisp_pitr_t *mp;
14190 if (!vam->json_output)
14192 print (vam->ofp, "%=20s", "lisp status:");
14195 M (SHOW_LISP_PITR, show_lisp_pitr);
14199 /* Wait for a reply... */
14207 * Add/delete mapping between vni and vrf
14210 api_lisp_eid_table_add_del_map (vat_main_t * vam)
14213 unformat_input_t *input = vam->input;
14214 vl_api_lisp_eid_table_add_del_map_t *mp;
14215 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
14216 u32 vni, vrf, bd_index;
14218 /* Parse args required to build the message */
14219 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14221 if (unformat (input, "del"))
14223 else if (unformat (input, "vrf %d", &vrf))
14225 else if (unformat (input, "bd_index %d", &bd_index))
14227 else if (unformat (input, "vni %d", &vni))
14233 if (!vni_set || (!vrf_set && !bd_index_set))
14235 errmsg ("missing arguments!");
14239 if (vrf_set && bd_index_set)
14241 errmsg ("error: both vrf and bd entered!");
14245 M (LISP_EID_TABLE_ADD_DEL_MAP, lisp_eid_table_add_del_map);
14247 mp->is_add = is_add;
14248 mp->vni = htonl (vni);
14249 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
14250 mp->is_l2 = bd_index_set;
14255 /* wait for reply */
14263 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
14265 u32 *action = va_arg (*args, u32 *);
14268 if (unformat (input, "%s", &s))
14270 if (!strcmp ((char *) s, "no-action"))
14272 else if (!strcmp ((char *) s, "natively-forward"))
14274 else if (!strcmp ((char *) s, "send-map-request"))
14276 else if (!strcmp ((char *) s, "drop"))
14280 clib_warning ("invalid action: '%s'", s);
14292 * Add/del remote mapping to/from LISP control plane
14294 * @param vam vpp API test context
14295 * @return return code
14298 api_lisp_add_del_remote_mapping (vat_main_t * vam)
14300 unformat_input_t *input = vam->input;
14301 vl_api_lisp_add_del_remote_mapping_t *mp;
14304 lisp_eid_vat_t _eid, *eid = &_eid;
14305 lisp_eid_vat_t _seid, *seid = &_seid;
14306 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
14307 u32 action = ~0, p, w, data_len;
14308 ip4_address_t rloc4;
14309 ip6_address_t rloc6;
14310 vl_api_remote_locator_t *rlocs = 0, rloc, *curr_rloc = 0;
14312 memset (&rloc, 0, sizeof (rloc));
14314 /* Parse args required to build the message */
14315 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14317 if (unformat (input, "del-all"))
14321 else if (unformat (input, "del"))
14325 else if (unformat (input, "add"))
14329 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
14333 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
14337 else if (unformat (input, "vni %d", &vni))
14341 else if (unformat (input, "p %d w %d", &p, &w))
14345 errmsg ("No RLOC configured for setting priority/weight!");
14348 curr_rloc->priority = p;
14349 curr_rloc->weight = w;
14351 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
14354 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
14355 vec_add1 (rlocs, rloc);
14356 curr_rloc = &rlocs[vec_len (rlocs) - 1];
14358 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
14361 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
14362 vec_add1 (rlocs, rloc);
14363 curr_rloc = &rlocs[vec_len (rlocs) - 1];
14365 else if (unformat (input, "action %U",
14366 unformat_negative_mapping_action, &action))
14372 clib_warning ("parse error '%U'", format_unformat_error, input);
14379 errmsg ("missing params!");
14383 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
14385 errmsg ("no action set for negative map-reply!");
14389 data_len = vec_len (rlocs) * sizeof (vl_api_remote_locator_t);
14391 M2 (LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping, data_len);
14392 mp->is_add = is_add;
14393 mp->vni = htonl (vni);
14394 mp->action = (u8) action;
14395 mp->is_src_dst = seid_set;
14396 mp->eid_len = eid->len;
14397 mp->seid_len = seid->len;
14398 mp->del_all = del_all;
14399 mp->eid_type = eid->type;
14400 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
14401 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
14403 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
14404 clib_memcpy (mp->rlocs, rlocs, data_len);
14410 /* Wait for a reply... */
14418 * Add/del LISP adjacency. Saves mapping in LISP control plane and updates
14419 * forwarding entries in data-plane accordingly.
14421 * @param vam vpp API test context
14422 * @return return code
14425 api_lisp_add_del_adjacency (vat_main_t * vam)
14427 unformat_input_t *input = vam->input;
14428 vl_api_lisp_add_del_adjacency_t *mp;
14431 ip4_address_t leid4, reid4;
14432 ip6_address_t leid6, reid6;
14433 u8 reid_mac[6] = { 0 };
14434 u8 leid_mac[6] = { 0 };
14435 u8 reid_type, leid_type;
14436 u32 leid_len = 0, reid_len = 0, len;
14439 leid_type = reid_type = (u8) ~ 0;
14441 /* Parse args required to build the message */
14442 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14444 if (unformat (input, "del"))
14448 else if (unformat (input, "add"))
14452 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
14455 reid_type = 0; /* ipv4 */
14458 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
14461 reid_type = 1; /* ipv6 */
14464 else if (unformat (input, "reid %U", unformat_ethernet_address,
14467 reid_type = 2; /* mac */
14469 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
14472 leid_type = 0; /* ipv4 */
14475 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
14478 leid_type = 1; /* ipv6 */
14481 else if (unformat (input, "leid %U", unformat_ethernet_address,
14484 leid_type = 2; /* mac */
14486 else if (unformat (input, "vni %d", &vni))
14492 errmsg ("parse error '%U'", format_unformat_error, input);
14497 if ((u8) ~ 0 == reid_type)
14499 errmsg ("missing params!");
14503 if (leid_type != reid_type)
14505 errmsg ("remote and local EIDs are of different types!");
14509 M (LISP_ADD_DEL_ADJACENCY, lisp_add_del_adjacency);
14510 mp->is_add = is_add;
14511 mp->vni = htonl (vni);
14512 mp->leid_len = leid_len;
14513 mp->reid_len = reid_len;
14514 mp->eid_type = reid_type;
14516 switch (mp->eid_type)
14519 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
14520 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
14523 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
14524 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
14527 clib_memcpy (mp->leid, leid_mac, 6);
14528 clib_memcpy (mp->reid, reid_mac, 6);
14531 errmsg ("unknown EID type %d!", mp->eid_type);
14538 /* Wait for a reply... */
14546 api_lisp_gpe_add_del_iface (vat_main_t * vam)
14548 unformat_input_t *input = vam->input;
14549 vl_api_lisp_gpe_add_del_iface_t *mp;
14551 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
14552 u32 dp_table = 0, vni = 0;
14554 /* Parse args required to build the message */
14555 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14557 if (unformat (input, "up"))
14562 else if (unformat (input, "down"))
14567 else if (unformat (input, "table_id %d", &dp_table))
14571 else if (unformat (input, "bd_id %d", &dp_table))
14576 else if (unformat (input, "vni %d", &vni))
14584 if (action_set == 0)
14586 errmsg ("Action not set");
14589 if (dp_table_set == 0 || vni_set == 0)
14591 errmsg ("vni and dp_table must be set");
14595 /* Construct the API message */
14596 M (LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface);
14598 mp->is_add = is_add;
14599 mp->dp_table = dp_table;
14606 /* Wait for a reply... */
14614 * Add/del map request itr rlocs from LISP control plane and updates
14616 * @param vam vpp API test context
14617 * @return return code
14620 api_lisp_add_del_map_request_itr_rlocs (vat_main_t * vam)
14622 unformat_input_t *input = vam->input;
14623 vl_api_lisp_add_del_map_request_itr_rlocs_t *mp;
14625 u8 *locator_set_name = 0;
14626 u8 locator_set_name_set = 0;
14629 /* Parse args required to build the message */
14630 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14632 if (unformat (input, "del"))
14636 else if (unformat (input, "%_%v%_", &locator_set_name))
14638 locator_set_name_set = 1;
14642 clib_warning ("parse error '%U'", format_unformat_error, input);
14647 if (is_add && !locator_set_name_set)
14649 errmsg ("itr-rloc is not set!");
14653 if (is_add && vec_len (locator_set_name) > 64)
14655 errmsg ("itr-rloc locator-set name too long");
14656 vec_free (locator_set_name);
14660 M (LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, lisp_add_del_map_request_itr_rlocs);
14661 mp->is_add = is_add;
14664 clib_memcpy (mp->locator_set_name, locator_set_name,
14665 vec_len (locator_set_name));
14669 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
14671 vec_free (locator_set_name);
14676 /* Wait for a reply... */
14684 api_lisp_locator_dump (vat_main_t * vam)
14686 unformat_input_t *input = vam->input;
14687 vl_api_lisp_locator_dump_t *mp;
14689 u8 is_index_set = 0, is_name_set = 0;
14693 /* Parse args required to build the message */
14694 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14696 if (unformat (input, "ls_name %_%v%_", &ls_name))
14700 else if (unformat (input, "ls_index %d", &ls_index))
14706 errmsg ("parse error '%U'", format_unformat_error, input);
14711 if (!is_index_set && !is_name_set)
14713 errmsg ("error: expected one of index or name!");
14717 if (is_index_set && is_name_set)
14719 errmsg ("error: only one param expected!");
14723 if (vec_len (ls_name) > 62)
14725 errmsg ("error: locator set name too long!");
14729 if (!vam->json_output)
14731 print (vam->ofp, "%=16s%=16s%=16s", "locator", "priority", "weight");
14734 M (LISP_LOCATOR_DUMP, lisp_locator_dump);
14735 mp->is_index_set = is_index_set;
14738 mp->ls_index = clib_host_to_net_u32 (ls_index);
14741 vec_add1 (ls_name, 0);
14742 strncpy ((char *) mp->ls_name, (char *) ls_name,
14743 sizeof (mp->ls_name) - 1);
14749 /* Use a control ping for synchronization */
14751 vl_api_control_ping_t *mp;
14752 M (CONTROL_PING, control_ping);
14755 /* Wait for a reply... */
14763 api_lisp_locator_set_dump (vat_main_t * vam)
14765 vl_api_lisp_locator_set_dump_t *mp;
14766 unformat_input_t *input = vam->input;
14770 /* Parse args required to build the message */
14771 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14773 if (unformat (input, "local"))
14777 else if (unformat (input, "remote"))
14783 errmsg ("parse error '%U'", format_unformat_error, input);
14788 if (!vam->json_output)
14790 print (vam->ofp, "%=10s%=15s", "ls_index", "ls_name");
14793 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
14795 mp->filter = filter;
14800 /* Use a control ping for synchronization */
14802 vl_api_control_ping_t *mp;
14803 M (CONTROL_PING, control_ping);
14806 /* Wait for a reply... */
14814 api_lisp_eid_table_map_dump (vat_main_t * vam)
14818 unformat_input_t *input = vam->input;
14819 vl_api_lisp_eid_table_map_dump_t *mp;
14822 /* Parse args required to build the message */
14823 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14825 if (unformat (input, "l2"))
14830 else if (unformat (input, "l3"))
14837 errmsg ("parse error '%U'", format_unformat_error, input);
14844 errmsg ("expected one of 'l2' or 'l3' parameter!");
14848 if (!vam->json_output)
14850 print (vam->ofp, "%=10s%=10s", "VNI", is_l2 ? "BD" : "VRF");
14853 M (LISP_EID_TABLE_MAP_DUMP, lisp_eid_table_map_dump);
14859 /* Use a control ping for synchronization */
14861 vl_api_control_ping_t *mp;
14862 M (CONTROL_PING, control_ping);
14865 /* Wait for a reply... */
14873 api_lisp_eid_table_vni_dump (vat_main_t * vam)
14875 vl_api_lisp_eid_table_vni_dump_t *mp;
14878 if (!vam->json_output)
14880 print (vam->ofp, "VNI");
14883 M (LISP_EID_TABLE_VNI_DUMP, lisp_eid_table_vni_dump);
14888 /* Use a control ping for synchronization */
14890 vl_api_control_ping_t *mp;
14891 M (CONTROL_PING, control_ping);
14894 /* Wait for a reply... */
14902 api_lisp_eid_table_dump (vat_main_t * vam)
14904 unformat_input_t *i = vam->input;
14905 vl_api_lisp_eid_table_dump_t *mp;
14907 struct in_addr ip4;
14908 struct in6_addr ip6;
14910 u8 eid_type = ~0, eid_set = 0;
14911 u32 prefix_length = ~0, t, vni = 0;
14914 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14916 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
14922 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
14928 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
14933 else if (unformat (i, "vni %d", &t))
14937 else if (unformat (i, "local"))
14941 else if (unformat (i, "remote"))
14947 errmsg ("parse error '%U'", format_unformat_error, i);
14952 if (!vam->json_output)
14954 print (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s", "EID",
14955 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
14958 M (LISP_EID_TABLE_DUMP, lisp_eid_table_dump);
14960 mp->filter = filter;
14964 mp->vni = htonl (vni);
14965 mp->eid_type = eid_type;
14969 mp->prefix_length = prefix_length;
14970 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
14973 mp->prefix_length = prefix_length;
14974 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
14977 clib_memcpy (mp->eid, mac, sizeof (mac));
14980 errmsg ("unknown EID type %d!", eid_type);
14988 /* Use a control ping for synchronization */
14990 vl_api_control_ping_t *mp;
14991 M (CONTROL_PING, control_ping);
14995 /* Wait for a reply... */
15003 api_lisp_gpe_fwd_entries_get (vat_main_t * vam)
15005 unformat_input_t *i = vam->input;
15006 vl_api_lisp_gpe_fwd_entries_get_t *mp;
15011 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15013 if (unformat (i, "vni %d", &vni))
15019 errmsg ("parse error '%U'", format_unformat_error, i);
15026 errmsg ("vni not set!");
15030 if (!vam->json_output)
15032 print (vam->ofp, "%10s %10s %s %40s", "fwd_index", "dp_table",
15036 M (LISP_GPE_FWD_ENTRIES_GET, lisp_gpe_fwd_entries_get);
15037 mp->vni = clib_host_to_net_u32 (vni);
15042 /* Wait for a reply... */
15049 #define vl_api_lisp_gpe_fwd_entries_get_reply_t_endian vl_noop_handler
15050 #define vl_api_lisp_gpe_fwd_entries_get_reply_t_print vl_noop_handler
15051 #define vl_api_lisp_gpe_fwd_entry_path_details_t_endian vl_noop_handler
15052 #define vl_api_lisp_gpe_fwd_entry_path_details_t_print vl_noop_handler
15055 api_lisp_adjacencies_get (vat_main_t * vam)
15057 unformat_input_t *i = vam->input;
15058 vl_api_lisp_adjacencies_get_t *mp;
15063 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15065 if (unformat (i, "vni %d", &vni))
15071 errmsg ("parse error '%U'", format_unformat_error, i);
15078 errmsg ("vni not set!");
15082 if (!vam->json_output)
15084 print (vam->ofp, "%s %40s", "leid", "reid");
15087 M (LISP_ADJACENCIES_GET, lisp_adjacencies_get);
15088 mp->vni = clib_host_to_net_u32 (vni);
15093 /* Wait for a reply... */
15101 api_lisp_map_server_dump (vat_main_t * vam)
15103 vl_api_lisp_map_server_dump_t *mp;
15106 if (!vam->json_output)
15108 print (vam->ofp, "%=20s", "Map server");
15111 M (LISP_MAP_SERVER_DUMP, lisp_map_server_dump);
15115 /* Use a control ping for synchronization */
15117 vl_api_control_ping_t *mp;
15118 M (CONTROL_PING, control_ping);
15121 /* Wait for a reply... */
15129 api_lisp_map_resolver_dump (vat_main_t * vam)
15131 vl_api_lisp_map_resolver_dump_t *mp;
15134 if (!vam->json_output)
15136 print (vam->ofp, "%=20s", "Map resolver");
15139 M (LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump);
15143 /* Use a control ping for synchronization */
15145 vl_api_control_ping_t *mp;
15146 M (CONTROL_PING, control_ping);
15149 /* Wait for a reply... */
15157 api_show_lisp_status (vat_main_t * vam)
15159 vl_api_show_lisp_status_t *mp;
15162 if (!vam->json_output)
15164 print (vam->ofp, "%-20s%-16s", "lisp status", "locator-set");
15167 M (SHOW_LISP_STATUS, show_lisp_status);
15170 /* Wait for a reply... */
15178 api_lisp_gpe_fwd_entry_path_dump (vat_main_t * vam)
15180 vl_api_lisp_gpe_fwd_entry_path_dump_t *mp;
15182 unformat_input_t *i = vam->input;
15183 u32 fwd_entry_index = ~0;
15185 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15187 if (unformat (i, "index %d", &fwd_entry_index))
15193 if (~0 == fwd_entry_index)
15195 errmsg ("no index specified!");
15199 if (!vam->json_output)
15201 print (vam->ofp, "first line");
15204 M (LISP_GPE_FWD_ENTRY_PATH_DUMP, lisp_gpe_fwd_entry_path_dump);
15208 /* Use a control ping for synchronization */
15210 vl_api_control_ping_t *mp;
15211 M (CONTROL_PING, control_ping);
15214 /* Wait for a reply... */
15222 api_lisp_get_map_request_itr_rlocs (vat_main_t * vam)
15224 vl_api_lisp_get_map_request_itr_rlocs_t *mp;
15227 if (!vam->json_output)
15229 print (vam->ofp, "%=20s", "itr-rlocs:");
15232 M (LISP_GET_MAP_REQUEST_ITR_RLOCS, lisp_get_map_request_itr_rlocs);
15235 /* Wait for a reply... */
15243 api_af_packet_create (vat_main_t * vam)
15245 unformat_input_t *i = vam->input;
15246 vl_api_af_packet_create_t *mp;
15248 u8 *host_if_name = 0;
15250 u8 random_hw_addr = 1;
15252 memset (hw_addr, 0, sizeof (hw_addr));
15254 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15256 if (unformat (i, "name %s", &host_if_name))
15257 vec_add1 (host_if_name, 0);
15258 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
15259 random_hw_addr = 0;
15264 if (!vec_len (host_if_name))
15266 errmsg ("host-interface name must be specified");
15270 if (vec_len (host_if_name) > 64)
15272 errmsg ("host-interface name too long");
15276 M (AF_PACKET_CREATE, af_packet_create);
15278 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
15279 clib_memcpy (mp->hw_addr, hw_addr, 6);
15280 mp->use_random_hw_addr = random_hw_addr;
15281 vec_free (host_if_name);
15284 W2 (fprintf (vam->ofp, " new sw_if_index = %d ", vam->sw_if_index));
15290 api_af_packet_delete (vat_main_t * vam)
15292 unformat_input_t *i = vam->input;
15293 vl_api_af_packet_delete_t *mp;
15295 u8 *host_if_name = 0;
15297 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15299 if (unformat (i, "name %s", &host_if_name))
15300 vec_add1 (host_if_name, 0);
15305 if (!vec_len (host_if_name))
15307 errmsg ("host-interface name must be specified");
15311 if (vec_len (host_if_name) > 64)
15313 errmsg ("host-interface name too long");
15317 M (AF_PACKET_DELETE, af_packet_delete);
15319 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
15320 vec_free (host_if_name);
15329 api_policer_add_del (vat_main_t * vam)
15331 unformat_input_t *i = vam->input;
15332 vl_api_policer_add_del_t *mp;
15343 u8 color_aware = 0;
15344 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
15346 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
15347 conform_action.dscp = 0;
15348 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
15349 exceed_action.dscp = 0;
15350 violate_action.action_type = SSE2_QOS_ACTION_DROP;
15351 violate_action.dscp = 0;
15353 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15355 if (unformat (i, "del"))
15357 else if (unformat (i, "name %s", &name))
15358 vec_add1 (name, 0);
15359 else if (unformat (i, "cir %u", &cir))
15361 else if (unformat (i, "eir %u", &eir))
15363 else if (unformat (i, "cb %u", &cb))
15365 else if (unformat (i, "eb %u", &eb))
15367 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
15370 else if (unformat (i, "round_type %U", unformat_policer_round_type,
15373 else if (unformat (i, "type %U", unformat_policer_type, &type))
15375 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
15378 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
15381 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
15384 else if (unformat (i, "color-aware"))
15390 if (!vec_len (name))
15392 errmsg ("policer name must be specified");
15396 if (vec_len (name) > 64)
15398 errmsg ("policer name too long");
15402 M (POLICER_ADD_DEL, policer_add_del);
15404 clib_memcpy (mp->name, name, vec_len (name));
15406 mp->is_add = is_add;
15411 mp->rate_type = rate_type;
15412 mp->round_type = round_type;
15414 mp->conform_action_type = conform_action.action_type;
15415 mp->conform_dscp = conform_action.dscp;
15416 mp->exceed_action_type = exceed_action.action_type;
15417 mp->exceed_dscp = exceed_action.dscp;
15418 mp->violate_action_type = violate_action.action_type;
15419 mp->violate_dscp = violate_action.dscp;
15420 mp->color_aware = color_aware;
15429 api_policer_dump (vat_main_t * vam)
15431 unformat_input_t *i = vam->input;
15432 vl_api_policer_dump_t *mp;
15434 u8 *match_name = 0;
15435 u8 match_name_valid = 0;
15437 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15439 if (unformat (i, "name %s", &match_name))
15441 vec_add1 (match_name, 0);
15442 match_name_valid = 1;
15448 M (POLICER_DUMP, policer_dump);
15449 mp->match_name_valid = match_name_valid;
15450 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
15451 vec_free (match_name);
15455 /* Use a control ping for synchronization */
15457 vl_api_control_ping_t *mp;
15458 M (CONTROL_PING, control_ping);
15461 /* Wait for a reply... */
15469 api_policer_classify_set_interface (vat_main_t * vam)
15471 unformat_input_t *i = vam->input;
15472 vl_api_policer_classify_set_interface_t *mp;
15475 int sw_if_index_set;
15476 u32 ip4_table_index = ~0;
15477 u32 ip6_table_index = ~0;
15478 u32 l2_table_index = ~0;
15481 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15483 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
15484 sw_if_index_set = 1;
15485 else if (unformat (i, "sw_if_index %d", &sw_if_index))
15486 sw_if_index_set = 1;
15487 else if (unformat (i, "del"))
15489 else if (unformat (i, "ip4-table %d", &ip4_table_index))
15491 else if (unformat (i, "ip6-table %d", &ip6_table_index))
15493 else if (unformat (i, "l2-table %d", &l2_table_index))
15497 clib_warning ("parse error '%U'", format_unformat_error, i);
15502 if (sw_if_index_set == 0)
15504 errmsg ("missing interface name or sw_if_index");
15508 M (POLICER_CLASSIFY_SET_INTERFACE, policer_classify_set_interface);
15510 mp->sw_if_index = ntohl (sw_if_index);
15511 mp->ip4_table_index = ntohl (ip4_table_index);
15512 mp->ip6_table_index = ntohl (ip6_table_index);
15513 mp->l2_table_index = ntohl (l2_table_index);
15514 mp->is_add = is_add;
15523 api_policer_classify_dump (vat_main_t * vam)
15525 unformat_input_t *i = vam->input;
15526 vl_api_policer_classify_dump_t *mp;
15528 u8 type = POLICER_CLASSIFY_N_TABLES;
15530 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
15534 errmsg ("classify table type must be specified");
15538 if (!vam->json_output)
15540 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
15543 M (POLICER_CLASSIFY_DUMP, policer_classify_dump);
15548 /* Use a control ping for synchronization */
15550 vl_api_control_ping_t *mp;
15551 M (CONTROL_PING, control_ping);
15554 /* Wait for a reply... */
15562 api_netmap_create (vat_main_t * vam)
15564 unformat_input_t *i = vam->input;
15565 vl_api_netmap_create_t *mp;
15569 u8 random_hw_addr = 1;
15573 memset (hw_addr, 0, sizeof (hw_addr));
15575 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15577 if (unformat (i, "name %s", &if_name))
15578 vec_add1 (if_name, 0);
15579 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
15580 random_hw_addr = 0;
15581 else if (unformat (i, "pipe"))
15583 else if (unformat (i, "master"))
15585 else if (unformat (i, "slave"))
15591 if (!vec_len (if_name))
15593 errmsg ("interface name must be specified");
15597 if (vec_len (if_name) > 64)
15599 errmsg ("interface name too long");
15603 M (NETMAP_CREATE, netmap_create);
15605 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
15606 clib_memcpy (mp->hw_addr, hw_addr, 6);
15607 mp->use_random_hw_addr = random_hw_addr;
15608 mp->is_pipe = is_pipe;
15609 mp->is_master = is_master;
15610 vec_free (if_name);
15619 api_netmap_delete (vat_main_t * vam)
15621 unformat_input_t *i = vam->input;
15622 vl_api_netmap_delete_t *mp;
15626 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15628 if (unformat (i, "name %s", &if_name))
15629 vec_add1 (if_name, 0);
15634 if (!vec_len (if_name))
15636 errmsg ("interface name must be specified");
15640 if (vec_len (if_name) > 64)
15642 errmsg ("interface name too long");
15646 M (NETMAP_DELETE, netmap_delete);
15648 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
15649 vec_free (if_name);
15657 static void vl_api_mpls_tunnel_details_t_handler
15658 (vl_api_mpls_tunnel_details_t * mp)
15660 vat_main_t *vam = &vat_main;
15661 i32 len = mp->mt_next_hop_n_labels;
15664 print (vam->ofp, "[%d]: via %U %d labels ",
15666 format_ip4_address, mp->mt_next_hop,
15667 ntohl (mp->mt_next_hop_sw_if_index));
15668 for (i = 0; i < len; i++)
15670 print (vam->ofp, "%u ", ntohl (mp->mt_next_hop_out_labels[i]));
15672 print (vam->ofp, "");
15675 static void vl_api_mpls_tunnel_details_t_handler_json
15676 (vl_api_mpls_tunnel_details_t * mp)
15678 vat_main_t *vam = &vat_main;
15679 vat_json_node_t *node = NULL;
15680 struct in_addr ip4;
15682 i32 len = mp->mt_next_hop_n_labels;
15684 if (VAT_JSON_ARRAY != vam->json_tree.type)
15686 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15687 vat_json_init_array (&vam->json_tree);
15689 node = vat_json_array_add (&vam->json_tree);
15691 vat_json_init_object (node);
15692 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
15693 clib_memcpy (&ip4, &(mp->mt_next_hop), sizeof (ip4));
15694 vat_json_object_add_ip4 (node, "next_hop", ip4);
15695 vat_json_object_add_uint (node, "next_hop_sw_if_index",
15696 ntohl (mp->mt_next_hop_sw_if_index));
15697 vat_json_object_add_uint (node, "l2_only", ntohl (mp->mt_l2_only));
15698 vat_json_object_add_uint (node, "label_count", len);
15699 for (i = 0; i < len; i++)
15701 vat_json_object_add_uint (node, "label",
15702 ntohl (mp->mt_next_hop_out_labels[i]));
15707 api_mpls_tunnel_dump (vat_main_t * vam)
15709 vl_api_mpls_tunnel_dump_t *mp;
15713 /* Parse args required to build the message */
15714 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
15716 if (!unformat (vam->input, "tunnel_index %d", &index))
15723 print (vam->ofp, " tunnel_index %d", index);
15725 M (MPLS_TUNNEL_DUMP, mpls_tunnel_dump);
15726 mp->tunnel_index = htonl (index);
15729 /* Use a control ping for synchronization */
15731 vl_api_control_ping_t *mp;
15732 M (CONTROL_PING, control_ping);
15738 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
15739 #define vl_api_mpls_fib_details_t_print vl_noop_handler
15742 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
15744 vat_main_t *vam = &vat_main;
15745 int count = ntohl (mp->count);
15746 vl_api_fib_path2_t *fp;
15750 "table-id %d, label %u, ess_bit %u",
15751 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
15753 for (i = 0; i < count; i++)
15755 if (fp->afi == IP46_TYPE_IP6)
15757 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15758 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15759 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15760 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15761 format_ip6_address, fp->next_hop);
15762 else if (fp->afi == IP46_TYPE_IP4)
15764 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15765 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15766 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15767 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15768 format_ip4_address, fp->next_hop);
15773 static void vl_api_mpls_fib_details_t_handler_json
15774 (vl_api_mpls_fib_details_t * mp)
15776 vat_main_t *vam = &vat_main;
15777 int count = ntohl (mp->count);
15778 vat_json_node_t *node = NULL;
15779 struct in_addr ip4;
15780 struct in6_addr ip6;
15781 vl_api_fib_path2_t *fp;
15784 if (VAT_JSON_ARRAY != vam->json_tree.type)
15786 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15787 vat_json_init_array (&vam->json_tree);
15789 node = vat_json_array_add (&vam->json_tree);
15791 vat_json_init_object (node);
15792 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
15793 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
15794 vat_json_object_add_uint (node, "label", ntohl (mp->label));
15795 vat_json_object_add_uint (node, "path_count", count);
15797 for (i = 0; i < count; i++)
15799 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
15800 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
15801 vat_json_object_add_uint (node, "is_local", fp->is_local);
15802 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
15803 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
15804 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
15805 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
15806 if (fp->afi == IP46_TYPE_IP4)
15808 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
15809 vat_json_object_add_ip4 (node, "next_hop", ip4);
15811 else if (fp->afi == IP46_TYPE_IP6)
15813 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
15814 vat_json_object_add_ip6 (node, "next_hop", ip6);
15820 api_mpls_fib_dump (vat_main_t * vam)
15822 vl_api_mpls_fib_dump_t *mp;
15825 M (MPLS_FIB_DUMP, mpls_fib_dump);
15828 /* Use a control ping for synchronization */
15830 vl_api_control_ping_t *mp;
15831 M (CONTROL_PING, control_ping);
15837 #define vl_api_ip_fib_details_t_endian vl_noop_handler
15838 #define vl_api_ip_fib_details_t_print vl_noop_handler
15841 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
15843 vat_main_t *vam = &vat_main;
15844 int count = ntohl (mp->count);
15845 vl_api_fib_path_t *fp;
15849 "table-id %d, prefix %U/%d",
15850 ntohl (mp->table_id), format_ip4_address, mp->address,
15851 mp->address_length);
15853 for (i = 0; i < count; i++)
15855 if (fp->afi == IP46_TYPE_IP6)
15857 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15858 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15859 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15860 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15861 format_ip6_address, fp->next_hop);
15862 else if (fp->afi == IP46_TYPE_IP4)
15864 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15865 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
15866 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15867 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15868 format_ip4_address, fp->next_hop);
15873 static void vl_api_ip_fib_details_t_handler_json
15874 (vl_api_ip_fib_details_t * mp)
15876 vat_main_t *vam = &vat_main;
15877 int count = ntohl (mp->count);
15878 vat_json_node_t *node = NULL;
15879 struct in_addr ip4;
15880 struct in6_addr ip6;
15881 vl_api_fib_path_t *fp;
15884 if (VAT_JSON_ARRAY != vam->json_tree.type)
15886 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15887 vat_json_init_array (&vam->json_tree);
15889 node = vat_json_array_add (&vam->json_tree);
15891 vat_json_init_object (node);
15892 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
15893 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
15894 vat_json_object_add_ip4 (node, "prefix", ip4);
15895 vat_json_object_add_uint (node, "mask_length", mp->address_length);
15896 vat_json_object_add_uint (node, "path_count", count);
15898 for (i = 0; i < count; i++)
15900 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
15901 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
15902 vat_json_object_add_uint (node, "is_local", fp->is_local);
15903 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
15904 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
15905 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
15906 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
15907 if (fp->afi == IP46_TYPE_IP4)
15909 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
15910 vat_json_object_add_ip4 (node, "next_hop", ip4);
15912 else if (fp->afi == IP46_TYPE_IP6)
15914 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
15915 vat_json_object_add_ip6 (node, "next_hop", ip6);
15921 api_ip_fib_dump (vat_main_t * vam)
15923 vl_api_ip_fib_dump_t *mp;
15926 M (IP_FIB_DUMP, ip_fib_dump);
15929 /* Use a control ping for synchronization */
15931 vl_api_control_ping_t *mp;
15932 M (CONTROL_PING, control_ping);
15938 static void vl_api_ip_neighbor_details_t_handler
15939 (vl_api_ip_neighbor_details_t * mp)
15941 vat_main_t *vam = &vat_main;
15943 print (vam->ofp, "%c %U %U",
15944 (mp->is_static) ? 'S' : 'D',
15945 format_ethernet_address, &mp->mac_address,
15946 (mp->is_ipv6) ? format_ip6_address : format_ip4_address,
15950 static void vl_api_ip_neighbor_details_t_handler_json
15951 (vl_api_ip_neighbor_details_t * mp)
15954 vat_main_t *vam = &vat_main;
15955 vat_json_node_t *node;
15956 struct in_addr ip4;
15957 struct in6_addr ip6;
15959 if (VAT_JSON_ARRAY != vam->json_tree.type)
15961 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15962 vat_json_init_array (&vam->json_tree);
15964 node = vat_json_array_add (&vam->json_tree);
15966 vat_json_init_object (node);
15967 vat_json_object_add_string_copy (node, "flag",
15968 (mp->is_static) ? (u8 *) "static" : (u8 *)
15971 vat_json_object_add_string_copy (node, "link_layer",
15972 format (0, "%U", format_ethernet_address,
15973 &mp->mac_address));
15977 clib_memcpy (&ip6, &mp->ip_address, sizeof (ip6));
15978 vat_json_object_add_ip6 (node, "ip_address", ip6);
15982 clib_memcpy (&ip4, &mp->ip_address, sizeof (ip4));
15983 vat_json_object_add_ip4 (node, "ip_address", ip4);
15988 api_ip_neighbor_dump (vat_main_t * vam)
15990 unformat_input_t *i = vam->input;
15991 vl_api_ip_neighbor_dump_t *mp;
15994 u32 sw_if_index = ~0;
15996 /* Parse args required to build the message */
15997 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15999 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16001 else if (unformat (i, "sw_if_index %d", &sw_if_index))
16003 else if (unformat (i, "ip6"))
16009 if (sw_if_index == ~0)
16011 errmsg ("missing interface name or sw_if_index");
16015 M (IP_NEIGHBOR_DUMP, ip_neighbor_dump);
16016 mp->is_ipv6 = (u8) is_ipv6;
16017 mp->sw_if_index = ntohl (sw_if_index);
16020 /* Use a control ping for synchronization */
16022 vl_api_control_ping_t *mp;
16023 M (CONTROL_PING, control_ping);
16029 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
16030 #define vl_api_ip6_fib_details_t_print vl_noop_handler
16033 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
16035 vat_main_t *vam = &vat_main;
16036 int count = ntohl (mp->count);
16037 vl_api_fib_path_t *fp;
16041 "table-id %d, prefix %U/%d",
16042 ntohl (mp->table_id), format_ip6_address, mp->address,
16043 mp->address_length);
16045 for (i = 0; i < count; i++)
16047 if (fp->afi == IP46_TYPE_IP6)
16049 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16050 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16051 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16052 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16053 format_ip6_address, fp->next_hop);
16054 else if (fp->afi == IP46_TYPE_IP4)
16056 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
16057 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U",
16058 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
16059 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
16060 format_ip4_address, fp->next_hop);
16065 static void vl_api_ip6_fib_details_t_handler_json
16066 (vl_api_ip6_fib_details_t * mp)
16068 vat_main_t *vam = &vat_main;
16069 int count = ntohl (mp->count);
16070 vat_json_node_t *node = NULL;
16071 struct in_addr ip4;
16072 struct in6_addr ip6;
16073 vl_api_fib_path_t *fp;
16076 if (VAT_JSON_ARRAY != vam->json_tree.type)
16078 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16079 vat_json_init_array (&vam->json_tree);
16081 node = vat_json_array_add (&vam->json_tree);
16083 vat_json_init_object (node);
16084 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
16085 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
16086 vat_json_object_add_ip6 (node, "prefix", ip6);
16087 vat_json_object_add_uint (node, "mask_length", mp->address_length);
16088 vat_json_object_add_uint (node, "path_count", count);
16090 for (i = 0; i < count; i++)
16092 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
16093 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
16094 vat_json_object_add_uint (node, "is_local", fp->is_local);
16095 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
16096 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
16097 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
16098 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
16099 if (fp->afi == IP46_TYPE_IP4)
16101 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
16102 vat_json_object_add_ip4 (node, "next_hop", ip4);
16104 else if (fp->afi == IP46_TYPE_IP6)
16106 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
16107 vat_json_object_add_ip6 (node, "next_hop", ip6);
16113 api_ip6_fib_dump (vat_main_t * vam)
16115 vl_api_ip6_fib_dump_t *mp;
16118 M (IP6_FIB_DUMP, ip6_fib_dump);
16121 /* Use a control ping for synchronization */
16123 vl_api_control_ping_t *mp;
16124 M (CONTROL_PING, control_ping);
16131 api_classify_table_ids (vat_main_t * vam)
16133 vl_api_classify_table_ids_t *mp;
16136 /* Construct the API message */
16137 M (CLASSIFY_TABLE_IDS, classify_table_ids);
16147 api_classify_table_by_interface (vat_main_t * vam)
16149 unformat_input_t *input = vam->input;
16150 vl_api_classify_table_by_interface_t *mp;
16153 u32 sw_if_index = ~0;
16154 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16156 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16158 else if (unformat (input, "sw_if_index %d", &sw_if_index))
16163 if (sw_if_index == ~0)
16165 errmsg ("missing interface name or sw_if_index");
16169 /* Construct the API message */
16170 M (CLASSIFY_TABLE_BY_INTERFACE, classify_table_by_interface);
16172 mp->sw_if_index = ntohl (sw_if_index);
16181 api_classify_table_info (vat_main_t * vam)
16183 unformat_input_t *input = vam->input;
16184 vl_api_classify_table_info_t *mp;
16188 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16190 if (unformat (input, "table_id %d", &table_id))
16195 if (table_id == ~0)
16197 errmsg ("missing table id");
16201 /* Construct the API message */
16202 M (CLASSIFY_TABLE_INFO, classify_table_info);
16204 mp->table_id = ntohl (table_id);
16213 api_classify_session_dump (vat_main_t * vam)
16215 unformat_input_t *input = vam->input;
16216 vl_api_classify_session_dump_t *mp;
16220 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16222 if (unformat (input, "table_id %d", &table_id))
16227 if (table_id == ~0)
16229 errmsg ("missing table id");
16233 /* Construct the API message */
16234 M (CLASSIFY_SESSION_DUMP, classify_session_dump);
16236 mp->table_id = ntohl (table_id);
16239 /* Use a control ping for synchronization */
16241 vl_api_control_ping_t *mp;
16242 M (CONTROL_PING, control_ping);
16251 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
16253 vat_main_t *vam = &vat_main;
16255 print (vam->ofp, "collector_address %U, collector_port %d, "
16256 "src_address %U, vrf_id %d, path_mtu %u, "
16257 "template_interval %u, udp_checksum %d",
16258 format_ip4_address, mp->collector_address,
16259 ntohs (mp->collector_port),
16260 format_ip4_address, mp->src_address,
16261 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
16262 ntohl (mp->template_interval), mp->udp_checksum);
16265 vam->result_ready = 1;
16269 vl_api_ipfix_exporter_details_t_handler_json
16270 (vl_api_ipfix_exporter_details_t * mp)
16272 vat_main_t *vam = &vat_main;
16273 vat_json_node_t node;
16274 struct in_addr collector_address;
16275 struct in_addr src_address;
16277 vat_json_init_object (&node);
16278 clib_memcpy (&collector_address, &mp->collector_address,
16279 sizeof (collector_address));
16280 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
16281 vat_json_object_add_uint (&node, "collector_port",
16282 ntohs (mp->collector_port));
16283 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
16284 vat_json_object_add_ip4 (&node, "src_address", src_address);
16285 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
16286 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
16287 vat_json_object_add_uint (&node, "template_interval",
16288 ntohl (mp->template_interval));
16289 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
16291 vat_json_print (vam->ofp, &node);
16292 vat_json_free (&node);
16294 vam->result_ready = 1;
16298 api_ipfix_exporter_dump (vat_main_t * vam)
16300 vl_api_ipfix_exporter_dump_t *mp;
16303 /* Construct the API message */
16304 M (IPFIX_EXPORTER_DUMP, ipfix_exporter_dump);
16314 api_ipfix_classify_stream_dump (vat_main_t * vam)
16316 vl_api_ipfix_classify_stream_dump_t *mp;
16319 /* Construct the API message */
16320 M (IPFIX_CLASSIFY_STREAM_DUMP, ipfix_classify_stream_dump);
16330 vl_api_ipfix_classify_stream_details_t_handler
16331 (vl_api_ipfix_classify_stream_details_t * mp)
16333 vat_main_t *vam = &vat_main;
16334 print (vam->ofp, "domain_id %d, src_port %d",
16335 ntohl (mp->domain_id), ntohs (mp->src_port));
16337 vam->result_ready = 1;
16341 vl_api_ipfix_classify_stream_details_t_handler_json
16342 (vl_api_ipfix_classify_stream_details_t * mp)
16344 vat_main_t *vam = &vat_main;
16345 vat_json_node_t node;
16347 vat_json_init_object (&node);
16348 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
16349 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
16351 vat_json_print (vam->ofp, &node);
16352 vat_json_free (&node);
16354 vam->result_ready = 1;
16358 api_ipfix_classify_table_dump (vat_main_t * vam)
16360 vl_api_ipfix_classify_table_dump_t *mp;
16363 if (!vam->json_output)
16365 print (vam->ofp, "%15s%15s%20s", "table_id", "ip_version",
16366 "transport_protocol");
16369 /* Construct the API message */
16370 M (IPFIX_CLASSIFY_TABLE_DUMP, ipfix_classify_table_dump);
16375 /* Use a control ping for synchronization */
16377 vl_api_control_ping_t *mp;
16378 M (CONTROL_PING, control_ping);
16385 vl_api_ipfix_classify_table_details_t_handler
16386 (vl_api_ipfix_classify_table_details_t * mp)
16388 vat_main_t *vam = &vat_main;
16389 print (vam->ofp, "%15d%15d%20d", ntohl (mp->table_id), mp->ip_version,
16390 mp->transport_protocol);
16394 vl_api_ipfix_classify_table_details_t_handler_json
16395 (vl_api_ipfix_classify_table_details_t * mp)
16397 vat_json_node_t *node = NULL;
16398 vat_main_t *vam = &vat_main;
16400 if (VAT_JSON_ARRAY != vam->json_tree.type)
16402 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16403 vat_json_init_array (&vam->json_tree);
16406 node = vat_json_array_add (&vam->json_tree);
16407 vat_json_init_object (node);
16409 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
16410 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
16411 vat_json_object_add_uint (node, "transport_protocol",
16412 mp->transport_protocol);
16416 api_sw_interface_span_enable_disable (vat_main_t * vam)
16418 unformat_input_t *i = vam->input;
16419 vl_api_sw_interface_span_enable_disable_t *mp;
16421 u32 src_sw_if_index = ~0;
16422 u32 dst_sw_if_index = ~0;
16425 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16428 (i, "src %U", api_unformat_sw_if_index, vam, &src_sw_if_index))
16430 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
16434 (i, "dst %U", api_unformat_sw_if_index, vam, &dst_sw_if_index))
16436 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
16438 else if (unformat (i, "disable"))
16440 else if (unformat (i, "rx"))
16442 else if (unformat (i, "tx"))
16444 else if (unformat (i, "both"))
16450 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, sw_interface_span_enable_disable);
16452 mp->sw_if_index_from = htonl (src_sw_if_index);
16453 mp->sw_if_index_to = htonl (dst_sw_if_index);
16463 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
16466 vat_main_t *vam = &vat_main;
16467 u8 *sw_if_from_name = 0;
16468 u8 *sw_if_to_name = 0;
16469 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
16470 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
16471 char *states[] = { "none", "rx", "tx", "both" };
16475 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
16477 if ((u32) p->value[0] == sw_if_index_from)
16479 sw_if_from_name = (u8 *)(p->key);
16483 if ((u32) p->value[0] == sw_if_index_to)
16485 sw_if_to_name = (u8 *)(p->key);
16486 if (sw_if_from_name)
16491 print (vam->ofp, "%20s => %20s (%s)",
16492 sw_if_from_name, sw_if_to_name, states[mp->state]);
16496 vl_api_sw_interface_span_details_t_handler_json
16497 (vl_api_sw_interface_span_details_t * mp)
16499 vat_main_t *vam = &vat_main;
16500 vat_json_node_t *node = NULL;
16501 u8 *sw_if_from_name = 0;
16502 u8 *sw_if_to_name = 0;
16503 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
16504 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
16508 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
16510 if ((u32) p->value[0] == sw_if_index_from)
16512 sw_if_from_name = (u8 *)(p->key);
16516 if ((u32) p->value[0] == sw_if_index_to)
16518 sw_if_to_name = (u8 *)(p->key);
16519 if (sw_if_from_name)
16525 if (VAT_JSON_ARRAY != vam->json_tree.type)
16527 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16528 vat_json_init_array (&vam->json_tree);
16530 node = vat_json_array_add (&vam->json_tree);
16532 vat_json_init_object (node);
16533 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
16534 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
16535 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
16536 if (0 != sw_if_to_name)
16538 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
16540 vat_json_object_add_uint (node, "state", mp->state);
16544 api_sw_interface_span_dump (vat_main_t * vam)
16546 vl_api_sw_interface_span_dump_t *mp;
16549 M (SW_INTERFACE_SPAN_DUMP, sw_interface_span_dump);
16552 /* Use a control ping for synchronization */
16554 vl_api_control_ping_t *mp;
16555 M (CONTROL_PING, control_ping);
16562 api_pg_create_interface (vat_main_t * vam)
16564 unformat_input_t *input = vam->input;
16565 vl_api_pg_create_interface_t *mp;
16569 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16571 if (unformat (input, "if_id %d", &if_id))
16578 errmsg ("missing pg interface index");
16582 /* Construct the API message */
16583 M (PG_CREATE_INTERFACE, pg_create_interface);
16585 mp->interface_id = ntohl (if_id);
16594 api_pg_capture (vat_main_t * vam)
16596 unformat_input_t *input = vam->input;
16597 vl_api_pg_capture_t *mp;
16603 u8 pcap_file_set = 0;
16605 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16607 if (unformat (input, "if_id %d", &if_id))
16609 else if (unformat (input, "pcap %s", &pcap_file))
16611 else if (unformat (input, "count %d", &count))
16613 else if (unformat (input, "disable"))
16620 errmsg ("missing pg interface index");
16623 if (pcap_file_set > 0)
16625 if (vec_len (pcap_file) > 255)
16627 errmsg ("pcap file name is too long");
16632 u32 name_len = vec_len (pcap_file);
16633 /* Construct the API message */
16634 M (PG_CAPTURE, pg_capture);
16636 mp->interface_id = ntohl (if_id);
16637 mp->is_enabled = enable;
16638 mp->count = ntohl (count);
16639 mp->pcap_name_length = ntohl (name_len);
16640 if (pcap_file_set != 0)
16642 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
16644 vec_free (pcap_file);
16653 api_pg_enable_disable (vat_main_t * vam)
16655 unformat_input_t *input = vam->input;
16656 vl_api_pg_enable_disable_t *mp;
16660 u8 stream_name_set = 0;
16661 u8 *stream_name = 0;
16662 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16664 if (unformat (input, "stream %s", &stream_name))
16665 stream_name_set = 1;
16666 else if (unformat (input, "disable"))
16672 if (stream_name_set > 0)
16674 if (vec_len (stream_name) > 255)
16676 errmsg ("stream name too long");
16681 u32 name_len = vec_len (stream_name);
16682 /* Construct the API message */
16683 M (PG_ENABLE_DISABLE, pg_enable_disable);
16685 mp->is_enabled = enable;
16686 if (stream_name_set != 0)
16688 mp->stream_name_length = ntohl (name_len);
16689 clib_memcpy (mp->stream_name, stream_name, name_len);
16691 vec_free (stream_name);
16700 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
16702 unformat_input_t *input = vam->input;
16703 vl_api_ip_source_and_port_range_check_add_del_t *mp;
16706 u16 *low_ports = 0;
16707 u16 *high_ports = 0;
16710 ip4_address_t ip4_addr;
16711 ip6_address_t ip6_addr;
16719 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16721 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
16727 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
16732 else if (unformat (input, "vrf %d", &vrf_id))
16734 else if (unformat (input, "del"))
16736 else if (unformat (input, "port %d", &tmp))
16738 if (tmp == 0 || tmp > 65535)
16740 errmsg ("port %d out of range", tmp);
16744 this_hi = this_low + 1;
16745 vec_add1 (low_ports, this_low);
16746 vec_add1 (high_ports, this_hi);
16748 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
16750 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
16752 errmsg ("incorrect range parameters");
16756 /* Note: in debug CLI +1 is added to high before
16757 passing to real fn that does "the work"
16758 (ip_source_and_port_range_check_add_del).
16759 This fn is a wrapper around the binary API fn a
16760 control plane will call, which expects this increment
16761 to have occurred. Hence letting the binary API control
16762 plane fn do the increment for consistency between VAT
16763 and other control planes.
16766 vec_add1 (low_ports, this_low);
16767 vec_add1 (high_ports, this_hi);
16773 if (prefix_set == 0)
16775 errmsg ("<address>/<mask> not specified");
16781 errmsg ("VRF ID required, not specified");
16788 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
16792 if (vec_len (low_ports) == 0)
16794 errmsg ("At least one port or port range required");
16798 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL,
16799 ip_source_and_port_range_check_add_del);
16801 mp->is_add = is_add;
16806 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
16811 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
16814 mp->mask_length = length;
16815 mp->number_of_ranges = vec_len (low_ports);
16817 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
16818 vec_free (low_ports);
16820 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
16821 vec_free (high_ports);
16823 mp->vrf_id = ntohl (vrf_id);
16832 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
16834 unformat_input_t *input = vam->input;
16835 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
16837 u32 sw_if_index = ~0;
16839 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
16840 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
16843 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16845 if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
16847 else if (unformat (input, "sw_if_index %d", &sw_if_index))
16849 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
16851 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
16853 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
16855 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
16857 else if (unformat (input, "del"))
16863 if (sw_if_index == ~0)
16865 errmsg ("Interface required but not specified");
16871 errmsg ("VRF ID required but not specified");
16875 if (tcp_out_vrf_id == 0
16876 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
16879 ("VRF ID should not be default. Should be distinct VRF for this purpose.");
16883 /* Construct the API message */
16884 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL,
16885 ip_source_and_port_range_check_interface_add_del);
16887 mp->sw_if_index = ntohl (sw_if_index);
16888 mp->is_add = is_add;
16889 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
16890 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
16891 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
16892 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
16897 /* Wait for a reply... */
16902 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
16904 unformat_input_t *i = vam->input;
16905 vl_api_ipsec_gre_add_del_tunnel_t *mp;
16907 u32 local_sa_id = 0;
16908 u32 remote_sa_id = 0;
16909 ip4_address_t src_address;
16910 ip4_address_t dst_address;
16913 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16915 if (unformat (i, "local_sa %d", &local_sa_id))
16917 else if (unformat (i, "remote_sa %d", &remote_sa_id))
16919 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
16921 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
16923 else if (unformat (i, "del"))
16927 clib_warning ("parse error '%U'", format_unformat_error, i);
16932 M (IPSEC_GRE_ADD_DEL_TUNNEL, ipsec_gre_add_del_tunnel);
16934 mp->local_sa_id = ntohl (local_sa_id);
16935 mp->remote_sa_id = ntohl (remote_sa_id);
16936 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
16937 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
16938 mp->is_add = is_add;
16947 api_punt (vat_main_t * vam)
16949 unformat_input_t *i = vam->input;
16957 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16959 if (unformat (i, "ip %d", &ipv))
16961 else if (unformat (i, "protocol %d", &protocol))
16963 else if (unformat (i, "port %d", &port))
16965 else if (unformat (i, "del"))
16969 clib_warning ("parse error '%U'", format_unformat_error, i);
16976 mp->is_add = (u8) is_add;
16977 mp->ipv = (u8) ipv;
16978 mp->l4_protocol = (u8) protocol;
16979 mp->l4_port = htons ((u16) port);
16987 static void vl_api_ipsec_gre_tunnel_details_t_handler
16988 (vl_api_ipsec_gre_tunnel_details_t * mp)
16990 vat_main_t *vam = &vat_main;
16992 print (vam->ofp, "%11d%15U%15U%14d%14d",
16993 ntohl (mp->sw_if_index),
16994 format_ip4_address, &mp->src_address,
16995 format_ip4_address, &mp->dst_address,
16996 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
16999 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
17000 (vl_api_ipsec_gre_tunnel_details_t * mp)
17002 vat_main_t *vam = &vat_main;
17003 vat_json_node_t *node = NULL;
17004 struct in_addr ip4;
17006 if (VAT_JSON_ARRAY != vam->json_tree.type)
17008 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17009 vat_json_init_array (&vam->json_tree);
17011 node = vat_json_array_add (&vam->json_tree);
17013 vat_json_init_object (node);
17014 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
17015 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
17016 vat_json_object_add_ip4 (node, "src_address", ip4);
17017 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
17018 vat_json_object_add_ip4 (node, "dst_address", ip4);
17019 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
17020 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
17024 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
17026 unformat_input_t *i = vam->input;
17027 vl_api_ipsec_gre_tunnel_dump_t *mp;
17030 u8 sw_if_index_set = 0;
17032 /* Parse args required to build the message */
17033 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17035 if (unformat (i, "sw_if_index %d", &sw_if_index))
17036 sw_if_index_set = 1;
17041 if (sw_if_index_set == 0)
17046 if (!vam->json_output)
17048 print (vam->ofp, "%11s%15s%15s%14s%14s",
17049 "sw_if_index", "src_address", "dst_address",
17050 "local_sa_id", "remote_sa_id");
17053 /* Get list of gre-tunnel interfaces */
17054 M (IPSEC_GRE_TUNNEL_DUMP, ipsec_gre_tunnel_dump);
17056 mp->sw_if_index = htonl (sw_if_index);
17060 /* Use a control ping for synchronization */
17062 vl_api_control_ping_t *mp;
17063 M (CONTROL_PING, control_ping);
17070 api_delete_subif (vat_main_t * vam)
17072 unformat_input_t *i = vam->input;
17073 vl_api_delete_subif_t *mp;
17075 u32 sw_if_index = ~0;
17077 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17079 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17081 if (unformat (i, "sw_if_index %d", &sw_if_index))
17087 if (sw_if_index == ~0)
17089 errmsg ("missing sw_if_index");
17093 /* Construct the API message */
17094 M (DELETE_SUBIF, delete_subif);
17095 mp->sw_if_index = ntohl (sw_if_index);
17101 #define foreach_pbb_vtr_op \
17102 _("disable", L2_VTR_DISABLED) \
17103 _("pop", L2_VTR_POP_2) \
17104 _("push", L2_VTR_PUSH_2)
17107 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
17109 unformat_input_t *i = vam->input;
17110 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
17112 u32 sw_if_index = ~0, vtr_op = ~0;
17113 u16 outer_tag = ~0;
17114 u8 dmac[6], smac[6];
17115 u8 dmac_set = 0, smac_set = 0;
17120 /* Shut up coverity */
17121 memset (dmac, 0, sizeof (dmac));
17122 memset (smac, 0, sizeof (smac));
17124 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17126 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17128 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17130 else if (unformat (i, "vtr_op %d", &vtr_op))
17132 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
17135 else if (unformat (i, "translate_pbb_stag"))
17137 if (unformat (i, "%d", &tmp))
17139 vtr_op = L2_VTR_TRANSLATE_2_1;
17145 ("translate_pbb_stag operation requires outer tag definition");
17149 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
17151 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
17153 else if (unformat (i, "sid %d", &sid))
17155 else if (unformat (i, "vlanid %d", &tmp))
17159 clib_warning ("parse error '%U'", format_unformat_error, i);
17164 if ((sw_if_index == ~0) || (vtr_op == ~0))
17166 errmsg ("missing sw_if_index or vtr operation");
17169 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
17170 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
17173 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid");
17177 M (L2_INTERFACE_PBB_TAG_REWRITE, l2_interface_pbb_tag_rewrite);
17178 mp->sw_if_index = ntohl (sw_if_index);
17179 mp->vtr_op = ntohl (vtr_op);
17180 mp->outer_tag = ntohs (outer_tag);
17181 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
17182 clib_memcpy (mp->b_smac, smac, sizeof (smac));
17183 mp->b_vlanid = ntohs (vlanid);
17184 mp->i_sid = ntohl (sid);
17193 api_flow_classify_set_interface (vat_main_t * vam)
17195 unformat_input_t *i = vam->input;
17196 vl_api_flow_classify_set_interface_t *mp;
17199 int sw_if_index_set;
17200 u32 ip4_table_index = ~0;
17201 u32 ip6_table_index = ~0;
17204 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17206 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17207 sw_if_index_set = 1;
17208 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17209 sw_if_index_set = 1;
17210 else if (unformat (i, "del"))
17212 else if (unformat (i, "ip4-table %d", &ip4_table_index))
17214 else if (unformat (i, "ip6-table %d", &ip6_table_index))
17218 clib_warning ("parse error '%U'", format_unformat_error, i);
17223 if (sw_if_index_set == 0)
17225 errmsg ("missing interface name or sw_if_index");
17229 M (FLOW_CLASSIFY_SET_INTERFACE, flow_classify_set_interface);
17231 mp->sw_if_index = ntohl (sw_if_index);
17232 mp->ip4_table_index = ntohl (ip4_table_index);
17233 mp->ip6_table_index = ntohl (ip6_table_index);
17234 mp->is_add = is_add;
17243 api_flow_classify_dump (vat_main_t * vam)
17245 unformat_input_t *i = vam->input;
17246 vl_api_flow_classify_dump_t *mp;
17248 u8 type = FLOW_CLASSIFY_N_TABLES;
17250 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
17254 errmsg ("classify table type must be specified");
17258 if (!vam->json_output)
17260 print (vam->ofp, "%10s%20s", "Intfc idx", "Classify table");
17263 M (FLOW_CLASSIFY_DUMP, flow_classify_dump);
17268 /* Use a control ping for synchronization */
17270 vl_api_control_ping_t *mp;
17271 M (CONTROL_PING, control_ping);
17274 /* Wait for a reply... */
17282 api_feature_enable_disable (vat_main_t * vam)
17284 unformat_input_t *i = vam->input;
17285 vl_api_feature_enable_disable_t *mp;
17288 u8 *feature_name = 0;
17289 u32 sw_if_index = ~0;
17292 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17294 if (unformat (i, "arc_name %s", &arc_name))
17296 else if (unformat (i, "feature_name %s", &feature_name))
17299 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17301 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17303 else if (unformat (i, "disable"))
17311 errmsg ("missing arc name");
17314 if (vec_len (arc_name) > 63)
17316 errmsg ("arc name too long");
17319 if (feature_name == 0)
17321 errmsg ("missing feature name");
17324 if (vec_len (feature_name) > 63)
17326 errmsg ("feature name too long");
17329 if (sw_if_index == ~0)
17331 errmsg ("missing interface name or sw_if_index");
17335 /* Construct the API message */
17336 M (FEATURE_ENABLE_DISABLE, feature_enable_disable);
17337 mp->sw_if_index = ntohl (sw_if_index);
17338 mp->enable = enable;
17339 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
17340 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
17341 vec_free (arc_name);
17342 vec_free (feature_name);
17349 api_sw_interface_tag_add_del (vat_main_t * vam)
17351 unformat_input_t *i = vam->input;
17352 vl_api_sw_interface_tag_add_del_t *mp;
17354 u32 sw_if_index = ~0;
17358 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17360 if (unformat (i, "tag %s", &tag))
17362 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17364 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17366 else if (unformat (i, "del"))
17372 if (sw_if_index == ~0)
17374 errmsg ("missing interface name or sw_if_index");
17378 if (enable && (tag == 0))
17380 errmsg ("no tag specified");
17384 /* Construct the API message */
17385 M (SW_INTERFACE_TAG_ADD_DEL, sw_interface_tag_add_del);
17386 mp->sw_if_index = ntohl (sw_if_index);
17387 mp->is_add = enable;
17389 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
17396 static void vl_api_l2_xconnect_details_t_handler
17397 (vl_api_l2_xconnect_details_t * mp)
17399 vat_main_t *vam = &vat_main;
17401 print (vam->ofp, "%15d%15d",
17402 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
17405 static void vl_api_l2_xconnect_details_t_handler_json
17406 (vl_api_l2_xconnect_details_t * mp)
17408 vat_main_t *vam = &vat_main;
17409 vat_json_node_t *node = NULL;
17411 if (VAT_JSON_ARRAY != vam->json_tree.type)
17413 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
17414 vat_json_init_array (&vam->json_tree);
17416 node = vat_json_array_add (&vam->json_tree);
17418 vat_json_init_object (node);
17419 vat_json_object_add_uint (node, "rx_sw_if_index",
17420 ntohl (mp->rx_sw_if_index));
17421 vat_json_object_add_uint (node, "tx_sw_if_index",
17422 ntohl (mp->tx_sw_if_index));
17426 api_l2_xconnect_dump (vat_main_t * vam)
17428 vl_api_l2_xconnect_dump_t *mp;
17431 if (!vam->json_output)
17433 print (vam->ofp, "%15s%15s", "rx_sw_if_index", "tx_sw_if_index");
17436 M (L2_XCONNECT_DUMP, l2_xconnect_dump);
17440 /* Use a control ping for synchronization */
17442 vl_api_control_ping_t *mp;
17443 M (CONTROL_PING, control_ping);
17450 api_sw_interface_set_mtu (vat_main_t * vam)
17452 unformat_input_t *i = vam->input;
17453 vl_api_sw_interface_set_mtu_t *mp;
17455 u32 sw_if_index = ~0;
17458 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
17460 if (unformat (i, "mtu %d", &mtu))
17462 if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
17464 else if (unformat (i, "sw_if_index %d", &sw_if_index))
17470 if (sw_if_index == ~0)
17472 errmsg ("missing interface name or sw_if_index");
17478 errmsg ("no mtu specified");
17482 /* Construct the API message */
17483 M (SW_INTERFACE_SET_MTU, sw_interface_set_mtu);
17484 mp->sw_if_index = ntohl (sw_if_index);
17485 mp->mtu = ntohs ((u16) mtu);
17493 q_or_quit (vat_main_t * vam)
17495 longjmp (vam->jump_buf, 1);
17496 return 0; /* not so much */
17500 q (vat_main_t * vam)
17502 return q_or_quit (vam);
17506 quit (vat_main_t * vam)
17508 return q_or_quit (vam);
17512 comment (vat_main_t * vam)
17518 cmd_cmp (void *a1, void *a2)
17523 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
17527 help (vat_main_t * vam)
17532 unformat_input_t *i = vam->input;
17535 if (unformat (i, "%s", &name))
17539 vec_add1 (name, 0);
17541 hs = hash_get_mem (vam->help_by_name, name);
17543 print (vam->ofp, "usage: %s %s", name, hs[0]);
17545 print (vam->ofp, "No such msg / command '%s'", name);
17550 print (vam->ofp, "Help is available for the following:");
17553 hash_foreach_pair (p, vam->function_by_name,
17555 vec_add1 (cmds, (u8 *)(p->key));
17559 vec_sort_with_function (cmds, cmd_cmp);
17561 for (j = 0; j < vec_len (cmds); j++)
17562 print (vam->ofp, "%s", cmds[j]);
17569 set (vat_main_t * vam)
17571 u8 *name = 0, *value = 0;
17572 unformat_input_t *i = vam->input;
17574 if (unformat (i, "%s", &name))
17576 /* The input buffer is a vector, not a string. */
17577 value = vec_dup (i->buffer);
17578 vec_delete (value, i->index, 0);
17579 /* Almost certainly has a trailing newline */
17580 if (value[vec_len (value) - 1] == '\n')
17581 value[vec_len (value) - 1] = 0;
17582 /* Make sure it's a proper string, one way or the other */
17583 vec_add1 (value, 0);
17584 (void) clib_macro_set_value (&vam->macro_main,
17585 (char *) name, (char *) value);
17588 errmsg ("usage: set <name> <value>");
17596 unset (vat_main_t * vam)
17600 if (unformat (vam->input, "%s", &name))
17601 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
17602 errmsg ("unset: %s wasn't set", name);
17615 macro_sort_cmp (void *a1, void *a2)
17617 macro_sort_t *s1 = a1;
17618 macro_sort_t *s2 = a2;
17620 return strcmp ((char *) (s1->name), (char *) (s2->name));
17624 dump_macro_table (vat_main_t * vam)
17626 macro_sort_t *sort_me = 0, *sm;
17631 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
17633 vec_add2 (sort_me, sm, 1);
17634 sm->name = (u8 *)(p->key);
17635 sm->value = (u8 *) (p->value[0]);
17639 vec_sort_with_function (sort_me, macro_sort_cmp);
17641 if (vec_len (sort_me))
17642 print (vam->ofp, "%-15s%s", "Name", "Value");
17644 print (vam->ofp, "The macro table is empty...");
17646 for (i = 0; i < vec_len (sort_me); i++)
17647 print (vam->ofp, "%-15s%s", sort_me[i].name, sort_me[i].value);
17652 dump_node_table (vat_main_t * vam)
17655 vlib_node_t *node, *next_node;
17657 if (vec_len (vam->graph_nodes) == 0)
17659 print (vam->ofp, "Node table empty, issue get_node_graph...");
17663 for (i = 0; i < vec_len (vam->graph_nodes); i++)
17665 node = vam->graph_nodes[i];
17666 print (vam->ofp, "[%d] %s", i, node->name);
17667 for (j = 0; j < vec_len (node->next_nodes); j++)
17669 if (node->next_nodes[j] != ~0)
17671 next_node = vam->graph_nodes[node->next_nodes[j]];
17672 print (vam->ofp, " [%d] %s", j, next_node->name);
17680 value_sort_cmp (void *a1, void *a2)
17682 name_sort_t *n1 = a1;
17683 name_sort_t *n2 = a2;
17685 if (n1->value < n2->value)
17687 if (n1->value > n2->value)
17694 dump_msg_api_table (vat_main_t * vam)
17696 api_main_t *am = &api_main;
17697 name_sort_t *nses = 0, *ns;
17702 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
17704 vec_add2 (nses, ns, 1);
17705 ns->name = (u8 *)(hp->key);
17706 ns->value = (u32) hp->value[0];
17710 vec_sort_with_function (nses, value_sort_cmp);
17712 for (i = 0; i < vec_len (nses); i++)
17713 print (vam->ofp, " [%d]: %s", nses[i].value, nses[i].name);
17719 get_msg_id (vat_main_t * vam)
17724 if (unformat (vam->input, "%s", &name_and_crc))
17726 message_index = vl_api_get_msg_index (name_and_crc);
17727 if (message_index == ~0)
17729 print (vam->ofp, " '%s' not found", name_and_crc);
17732 print (vam->ofp, " '%s' has message index %d",
17733 name_and_crc, message_index);
17736 errmsg ("name_and_crc required...");
17741 search_node_table (vat_main_t * vam)
17743 unformat_input_t *line_input = vam->input;
17746 vlib_node_t *node, *next_node;
17749 if (vam->graph_node_index_by_name == 0)
17751 print (vam->ofp, "Node table empty, issue get_node_graph...");
17755 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
17757 if (unformat (line_input, "%s", &node_to_find))
17759 vec_add1 (node_to_find, 0);
17760 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
17763 print (vam->ofp, "%s not found...", node_to_find);
17766 node = vam->graph_nodes[p[0]];
17767 print (vam->ofp, "[%d] %s", p[0], node->name);
17768 for (j = 0; j < vec_len (node->next_nodes); j++)
17770 if (node->next_nodes[j] != ~0)
17772 next_node = vam->graph_nodes[node->next_nodes[j]];
17773 print (vam->ofp, " [%d] %s", j, next_node->name);
17780 clib_warning ("parse error '%U'", format_unformat_error,
17786 vec_free (node_to_find);
17795 script (vat_main_t * vam)
17797 #if (VPP_API_TEST_BUILTIN==0)
17799 char *save_current_file;
17800 unformat_input_t save_input;
17801 jmp_buf save_jump_buf;
17802 u32 save_line_number;
17804 FILE *new_fp, *save_ifp;
17806 if (unformat (vam->input, "%s", &s))
17808 new_fp = fopen ((char *) s, "r");
17811 errmsg ("Couldn't open script file %s", s);
17818 errmsg ("Missing script name");
17822 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
17823 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
17824 save_ifp = vam->ifp;
17825 save_line_number = vam->input_line_number;
17826 save_current_file = (char *) vam->current_file;
17828 vam->input_line_number = 0;
17830 vam->current_file = s;
17833 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
17834 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
17835 vam->ifp = save_ifp;
17836 vam->input_line_number = save_line_number;
17837 vam->current_file = (u8 *) save_current_file;
17842 clib_warning ("use the exec command...");
17848 echo (vat_main_t * vam)
17850 print (vam->ofp, "%v", vam->input->buffer);
17854 /* List of API message constructors, CLI names map to api_xxx */
17855 #define foreach_vpe_api_msg \
17856 _(create_loopback,"[mac <mac-addr>]") \
17857 _(sw_interface_dump,"") \
17858 _(sw_interface_set_flags, \
17859 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
17860 _(sw_interface_add_del_address, \
17861 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
17862 _(sw_interface_set_table, \
17863 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
17864 _(sw_interface_set_mpls_enable, \
17865 "<intfc> | sw_if_index [disable | dis]") \
17866 _(sw_interface_set_vpath, \
17867 "<intfc> | sw_if_index <id> enable | disable") \
17868 _(sw_interface_set_vxlan_bypass, \
17869 "<intfc> | sw_if_index <id> [ip4 | ip6] [enable | disable]") \
17870 _(sw_interface_set_l2_xconnect, \
17871 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
17872 "enable | disable") \
17873 _(sw_interface_set_l2_bridge, \
17874 "<intfc> | sw_if_index <id> bd_id <bridge-domain-id>\n" \
17875 "[shg <split-horizon-group>] [bvi]\n" \
17876 "enable | disable") \
17877 _(bridge_domain_add_del, \
17878 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n") \
17879 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
17881 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
17883 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
17885 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
17887 "tapname <name> mac <mac-addr> | random-mac [tag <string>]") \
17889 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
17891 "<vpp-if-name> | sw_if_index <id>") \
17892 _(sw_interface_tap_dump, "") \
17893 _(ip_add_del_route, \
17894 "<addr>/<mask> via <addr> [table-id <n>]\n" \
17895 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
17896 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
17897 "[multipath] [count <n>]") \
17898 _(ip_mroute_add_del, \
17899 "<src> <grp>/<mask> [table-id <n>]\n" \
17900 "[<intfc> | sw_if_index <id>] [local] [del]") \
17901 _(mpls_route_add_del, \
17902 "<label> <eos> via <addr> [table-id <n>]\n" \
17903 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
17904 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
17905 "[multipath] [count <n>]") \
17906 _(mpls_ip_bind_unbind, \
17907 "<label> <addr/len>") \
17908 _(mpls_tunnel_add_del, \
17909 " via <addr> [table-id <n>]\n" \
17910 "sw_if_index <id>] [l2] [del]") \
17911 _(proxy_arp_add_del, \
17912 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
17913 _(proxy_arp_intfc_enable_disable, \
17914 "<intfc> | sw_if_index <id> enable | disable") \
17915 _(sw_interface_set_unnumbered, \
17916 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
17917 _(ip_neighbor_add_del, \
17918 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
17919 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
17920 _(reset_vrf, "vrf <id> [ipv6]") \
17921 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
17922 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
17923 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
17924 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
17925 "[outer_vlan_id_any][inner_vlan_id_any]") \
17926 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
17927 _(reset_fib, "vrf <n> [ipv6]") \
17928 _(dhcp_proxy_config, \
17929 "svr <v46-address> src <v46-address>\n" \
17930 "insert-cid <n> [del]") \
17931 _(dhcp_proxy_config_2, \
17932 "svr <v46-address> src <v46-address>\n" \
17933 "rx_vrf_id <nn> server_vrf_id <nn> insert-cid <n> [del]") \
17934 _(dhcp_proxy_set_vss, \
17935 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
17936 _(dhcp_client_config, \
17937 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
17938 _(set_ip_flow_hash, \
17939 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
17940 _(sw_interface_ip6_enable_disable, \
17941 "<intfc> | sw_if_index <id> enable | disable") \
17942 _(sw_interface_ip6_set_link_local_address, \
17943 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
17944 _(sw_interface_ip6nd_ra_prefix, \
17945 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
17946 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
17947 "[nolink] [isno]") \
17948 _(sw_interface_ip6nd_ra_config, \
17949 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
17950 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
17951 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
17952 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
17953 _(l2_patch_add_del, \
17954 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
17955 "enable | disable") \
17956 _(sr_tunnel_add_del, \
17957 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
17958 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
17959 "[policy <policy_name>]") \
17960 _(sr_policy_add_del, \
17961 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
17962 _(sr_multicast_map_add_del, \
17963 "address [ip6 multicast address] sr-policy [policy name] [del]") \
17964 _(classify_add_del_table, \
17965 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
17966 " [del] [del-chain] mask <mask-value>\n" \
17967 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
17968 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
17969 _(classify_add_del_session, \
17970 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
17971 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
17972 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
17973 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
17974 _(classify_set_interface_ip_table, \
17975 "<intfc> | sw_if_index <nn> table <nn>") \
17976 _(classify_set_interface_l2_tables, \
17977 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
17978 " [other-table <nn>]") \
17979 _(get_node_index, "node <node-name") \
17980 _(add_node_next, "node <node-name> next <next-node-name>") \
17981 _(l2tpv3_create_tunnel, \
17982 "client_address <ip6-addr> our_address <ip6-addr>\n" \
17983 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n" \
17984 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
17985 _(l2tpv3_set_tunnel_cookies, \
17986 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
17987 "[new_remote_cookie <nn>]\n") \
17988 _(l2tpv3_interface_enable_disable, \
17989 "<intfc> | sw_if_index <nn> enable | disable") \
17990 _(l2tpv3_set_lookup_key, \
17991 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
17992 _(sw_if_l2tpv3_tunnel_dump, "") \
17993 _(vxlan_add_del_tunnel, \
17994 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
17995 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
17996 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
17997 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
17998 _(gre_add_del_tunnel, \
17999 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [teb] [del]\n") \
18000 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
18001 _(l2_fib_clear_table, "") \
18002 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
18003 _(l2_interface_vlan_tag_rewrite, \
18004 "<intfc> | sw_if_index <nn> \n" \
18005 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
18006 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
18007 _(create_vhost_user_if, \
18008 "socket <filename> [server] [renumber <dev_instance>] " \
18009 "[mac <mac_address>]") \
18010 _(modify_vhost_user_if, \
18011 "<intfc> | sw_if_index <nn> socket <filename>\n" \
18012 "[server] [renumber <dev_instance>]") \
18013 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
18014 _(sw_interface_vhost_user_dump, "") \
18015 _(show_version, "") \
18016 _(vxlan_gpe_add_del_tunnel, \
18017 "local <addr> remote <addr> vni <nn>\n" \
18018 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
18019 "[next-ethernet] [next-nsh]\n") \
18020 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
18021 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
18022 _(interface_name_renumber, \
18023 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
18024 _(input_acl_set_interface, \
18025 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
18026 " [l2-table <nn>] [del]") \
18027 _(want_ip4_arp_events, "address <ip4-address> [del]") \
18028 _(want_ip6_nd_events, "address <ip6-address> [del]") \
18029 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
18030 _(ip_dump, "ipv4 | ipv6") \
18031 _(ipsec_spd_add_del, "spd_id <n> [del]") \
18032 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
18034 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
18035 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
18036 " integ_alg <alg> integ_key <hex>") \
18037 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
18038 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
18039 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
18040 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" ) \
18041 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
18042 _(ikev2_profile_add_del, "name <profile_name> [del]") \
18043 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
18044 "(auth_data 0x<data> | auth_data <data>)") \
18045 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
18046 "(id_data 0x<data> | id_data <data>) (local|remote)") \
18047 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
18048 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
18049 "(local|remote)") \
18050 _(ikev2_set_local_key, "file <absolute_file_path>") \
18051 _(delete_loopback,"sw_if_index <nn>") \
18052 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
18053 _(map_add_domain, \
18054 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
18055 "ip6-src <ip6addr> " \
18056 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
18057 _(map_del_domain, "index <n>") \
18058 _(map_add_del_rule, \
18059 "index <n> psid <n> dst <ip6addr> [del]") \
18060 _(map_domain_dump, "") \
18061 _(map_rule_dump, "index <map-domain>") \
18062 _(want_interface_events, "enable|disable") \
18063 _(want_stats,"enable|disable") \
18064 _(get_first_msg_id, "client <name>") \
18065 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
18066 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
18067 "fib-id <nn> [ip4][ip6][default]") \
18068 _(get_node_graph, " ") \
18069 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
18070 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
18071 _(ioam_disable, "") \
18072 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |" \
18073 " sw_if_index <sw_if_index> p <priority> " \
18074 "w <weight>] [del]") \
18075 _(lisp_add_del_locator, "locator-set <locator_name> " \
18076 "iface <intf> | sw_if_index <sw_if_index> " \
18077 "p <priority> w <weight> [del]") \
18078 _(lisp_add_del_local_eid,"vni <vni> eid " \
18079 "<ipv4|ipv6>/<prefix> | <L2 address> " \
18080 "locator-set <locator_name> [del]" \
18081 "[key-id sha1|sha256 secret-key <secret-key>]") \
18082 _(lisp_gpe_add_del_fwd_entry, "reid <eid> [leid <eid>] vni <vni>" \
18083 "vrf/bd <dp_table> loc-pair <lcl_loc> <rmt_loc> w <weight>... [del]") \
18084 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
18085 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
18086 _(lisp_gpe_enable_disable, "enable|disable") \
18087 _(lisp_enable_disable, "enable|disable") \
18088 _(lisp_map_register_enable_disable, "enable|disable") \
18089 _(lisp_rloc_probe_enable_disable, "enable|disable") \
18090 _(lisp_gpe_add_del_iface, "up|down") \
18091 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
18093 "rloc <locator> p <prio> " \
18094 "w <weight> [rloc <loc> ... ] " \
18095 "action <action> [del-all]") \
18096 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
18098 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
18099 _(lisp_map_request_mode, "src-dst|dst-only") \
18100 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
18101 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
18102 _(lisp_locator_set_dump, "[local | remote]") \
18103 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
18104 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
18105 "[local] | [remote]") \
18106 _(lisp_eid_table_vni_dump, "") \
18107 _(lisp_eid_table_map_dump, "l2|l3") \
18108 _(lisp_map_resolver_dump, "") \
18109 _(lisp_map_server_dump, "") \
18110 _(lisp_adjacencies_get, "vni <vni>") \
18111 _(lisp_gpe_fwd_entries_get, "vni <vni>") \
18112 _(lisp_gpe_fwd_entry_path_dump, "index <fwd_entry_index>") \
18113 _(show_lisp_rloc_probe_state, "") \
18114 _(show_lisp_map_register_state, "") \
18115 _(show_lisp_status, "") \
18116 _(lisp_get_map_request_itr_rlocs, "") \
18117 _(show_lisp_pitr, "") \
18118 _(show_lisp_map_request_mode, "") \
18119 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
18120 _(af_packet_delete, "name <host interface name>") \
18121 _(policer_add_del, "name <policer name> <params> [del]") \
18122 _(policer_dump, "[name <policer name>]") \
18123 _(policer_classify_set_interface, \
18124 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
18125 " [l2-table <nn>] [del]") \
18126 _(policer_classify_dump, "type [ip4|ip6|l2]") \
18127 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
18128 "[master|slave]") \
18129 _(netmap_delete, "name <interface name>") \
18130 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
18131 _(mpls_fib_dump, "") \
18132 _(classify_table_ids, "") \
18133 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
18134 _(classify_table_info, "table_id <nn>") \
18135 _(classify_session_dump, "table_id <nn>") \
18136 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
18137 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
18138 "[template_interval <nn>] [udp_checksum]") \
18139 _(ipfix_exporter_dump, "") \
18140 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
18141 _(ipfix_classify_stream_dump, "") \
18142 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]") \
18143 _(ipfix_classify_table_dump, "") \
18144 _(sw_interface_span_enable_disable, "[src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
18145 _(sw_interface_span_dump, "") \
18146 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
18147 _(pg_create_interface, "if_id <nn>") \
18148 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
18149 _(pg_enable_disable, "[stream <id>] disable") \
18150 _(ip_source_and_port_range_check_add_del, \
18151 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
18152 _(ip_source_and_port_range_check_interface_add_del, \
18153 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
18154 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
18155 _(ipsec_gre_add_del_tunnel, \
18156 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
18157 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
18158 _(delete_subif,"<intfc> | sw_if_index <nn>") \
18159 _(l2_interface_pbb_tag_rewrite, \
18160 "<intfc> | sw_if_index <nn> \n" \
18161 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
18162 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
18163 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
18164 _(flow_classify_set_interface, \
18165 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
18166 _(flow_classify_dump, "type [ip4|ip6]") \
18167 _(ip_fib_dump, "") \
18168 _(ip6_fib_dump, "") \
18169 _(feature_enable_disable, "arc_name <arc_name> " \
18170 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
18171 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
18173 _(l2_xconnect_dump, "") \
18174 _(sw_interface_set_mtu, "<intfc> | sw_if_index <nn> mtu <nn>") \
18175 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
18176 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]")
18179 #define foreach_vpe_dpdk_api_msg \
18180 _(sw_interface_set_dpdk_hqos_pipe, \
18181 "rx <intfc> | sw_if_index <id> subport <subport-id> pipe <pipe-id>\n" \
18182 "profile <profile-id>\n") \
18183 _(sw_interface_set_dpdk_hqos_subport, \
18184 "rx <intfc> | sw_if_index <id> subport <subport-id> [rate <n>]\n" \
18185 "[bktsize <n>] [tc0 <n>] [tc1 <n>] [tc2 <n>] [tc3 <n>] [period <n>]\n") \
18186 _(sw_interface_set_dpdk_hqos_tctbl, \
18187 "rx <intfc> | sw_if_index <id> entry <n> tc <n> queue <n>\n")
18190 /* List of command functions, CLI names map directly to functions */
18191 #define foreach_cli_function \
18192 _(comment, "usage: comment <ignore-rest-of-line>") \
18193 _(dump_interface_table, "usage: dump_interface_table") \
18194 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
18195 _(dump_ipv4_table, "usage: dump_ipv4_table") \
18196 _(dump_ipv6_table, "usage: dump_ipv6_table") \
18197 _(dump_stats_table, "usage: dump_stats_table") \
18198 _(dump_macro_table, "usage: dump_macro_table ") \
18199 _(dump_node_table, "usage: dump_node_table") \
18200 _(dump_msg_api_table, "usage: dump_msg_api_table") \
18201 _(get_msg_id, "usage: get_msg_id name_and_crc") \
18202 _(echo, "usage: echo <message>") \
18203 _(exec, "usage: exec <vpe-debug-CLI-command>") \
18204 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
18205 _(help, "usage: help") \
18206 _(q, "usage: quit") \
18207 _(quit, "usage: quit") \
18208 _(search_node_table, "usage: search_node_table <name>...") \
18209 _(set, "usage: set <variable-name> <value>") \
18210 _(script, "usage: script <file-name>") \
18211 _(unset, "usage: unset <variable-name>")
18214 static void vl_api_##n##_t_handler_uni \
18215 (vl_api_##n##_t * mp) \
18217 vat_main_t * vam = &vat_main; \
18218 if (vam->json_output) { \
18219 vl_api_##n##_t_handler_json(mp); \
18221 vl_api_##n##_t_handler(mp); \
18224 foreach_vpe_api_reply_msg;
18229 static void vl_api_##n##_t_handler_uni \
18230 (vl_api_##n##_t * mp) \
18232 vat_main_t * vam = &vat_main; \
18233 if (vam->json_output) { \
18234 vl_api_##n##_t_handler_json(mp); \
18236 vl_api_##n##_t_handler(mp); \
18239 foreach_vpe_dpdk_api_reply_msg;
18244 vat_api_hookup (vat_main_t * vam)
18247 vl_msg_api_set_handlers(VL_API_##N, #n, \
18248 vl_api_##n##_t_handler_uni, \
18250 vl_api_##n##_t_endian, \
18251 vl_api_##n##_t_print, \
18252 sizeof(vl_api_##n##_t), 1);
18253 foreach_vpe_api_reply_msg;
18258 vl_msg_api_set_handlers(VL_API_##N, #n, \
18259 vl_api_##n##_t_handler_uni, \
18261 vl_api_##n##_t_endian, \
18262 vl_api_##n##_t_print, \
18263 sizeof(vl_api_##n##_t), 1);
18264 foreach_vpe_dpdk_api_reply_msg;
18268 #if (VPP_API_TEST_BUILTIN==0)
18269 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
18272 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
18274 vam->function_by_name = hash_create_string (0, sizeof (uword));
18276 vam->help_by_name = hash_create_string (0, sizeof (uword));
18278 /* API messages we can send */
18279 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
18280 foreach_vpe_api_msg;
18283 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
18284 foreach_vpe_dpdk_api_msg;
18289 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
18290 foreach_vpe_api_msg;
18293 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
18294 foreach_vpe_dpdk_api_msg;
18298 /* CLI functions */
18299 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
18300 foreach_cli_function;
18304 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
18305 foreach_cli_function;
18310 * fd.io coding-style-patch-verification: ON
18313 * eval: (c-set-style "gnu")