2 *------------------------------------------------------------------
5 * Copyright (c) 2014 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/mpls/mpls.h>
40 #include <vnet/ipsec/ipsec.h>
41 #include <vnet/ipsec/ikev2.h>
45 #include <vnet/map/map.h>
46 #include <vnet/cop/cop.h>
47 #include <vnet/ip/ip6_hop_by_hop.h>
48 #include <vnet/ip/ip_source_and_port_range_check.h>
49 #include <vnet/policer/xlate.h>
50 #include <vnet/policer/policer.h>
51 #include <vnet/policer/police.h>
53 #include "vat/json_format.h"
57 #define vl_typedefs /* define message structures */
58 #include <vpp-api/vpe_all_api_h.h>
61 /* declare message handlers for each api */
63 #define vl_endianfun /* define message structures */
64 #include <vpp-api/vpe_all_api_h.h>
67 /* instantiate all the print functions we know about */
68 #define vl_print(handle, ...)
70 #include <vpp-api/vpe_all_api_h.h>
74 unformat_sw_if_index (unformat_input_t * input, va_list * args)
76 vat_main_t *vam = va_arg (*args, vat_main_t *);
77 u32 *result = va_arg (*args, u32 *);
81 if (!unformat (input, "%s", &if_name))
84 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
91 /* Parse an IP4 address %d.%d.%d.%d. */
93 unformat_ip4_address (unformat_input_t * input, va_list * args)
95 u8 *result = va_arg (*args, u8 *);
98 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
101 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
114 unformat_ethernet_address (unformat_input_t * input, va_list * args)
116 u8 *result = va_arg (*args, u8 *);
119 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
120 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
124 for (i = 0; i < 6; i++)
125 if (a[i] >= (1 << 8))
128 for (i = 0; i < 6; i++)
134 /* Returns ethernet type as an int in host byte order. */
136 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
139 u16 *result = va_arg (*args, u16 *);
143 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
145 if (type >= (1 << 16))
153 /* Parse an IP6 address. */
155 unformat_ip6_address (unformat_input_t * input, va_list * args)
157 ip6_address_t *result = va_arg (*args, ip6_address_t *);
159 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
160 uword c, n_colon, double_colon_index;
162 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
163 double_colon_index = ARRAY_LEN (hex_quads);
164 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
167 if (c >= '0' && c <= '9')
169 else if (c >= 'a' && c <= 'f')
170 hex_digit = c + 10 - 'a';
171 else if (c >= 'A' && c <= 'F')
172 hex_digit = c + 10 - 'A';
173 else if (c == ':' && n_colon < 2)
177 unformat_put_input (input);
181 /* Too many hex quads. */
182 if (n_hex_quads >= ARRAY_LEN (hex_quads))
187 hex_quad = (hex_quad << 4) | hex_digit;
189 /* Hex quad must fit in 16 bits. */
190 if (n_hex_digits >= 4)
197 /* Save position of :: */
200 /* More than one :: ? */
201 if (double_colon_index < ARRAY_LEN (hex_quads))
203 double_colon_index = n_hex_quads;
206 if (n_colon > 0 && n_hex_digits > 0)
208 hex_quads[n_hex_quads++] = hex_quad;
214 if (n_hex_digits > 0)
215 hex_quads[n_hex_quads++] = hex_quad;
220 /* Expand :: to appropriate number of zero hex quads. */
221 if (double_colon_index < ARRAY_LEN (hex_quads))
223 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
225 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
226 hex_quads[n_zero + i] = hex_quads[i];
228 for (i = 0; i < n_zero; i++)
229 hex_quads[double_colon_index + i] = 0;
231 n_hex_quads = ARRAY_LEN (hex_quads);
234 /* Too few hex quads given. */
235 if (n_hex_quads < ARRAY_LEN (hex_quads))
238 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
239 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
246 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
249 u32 *r = va_arg (*args, u32 *);
252 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
253 foreach_ipsec_policy_action
264 unformat_ipsec_crypto_alg (unformat_input_t * input, va_list * args)
267 u32 *r = va_arg (*args, u32 *);
270 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_CRYPTO_ALG_##f;
271 foreach_ipsec_crypto_alg
282 format_ipsec_crypto_alg (u8 * s, va_list * args)
285 u32 i = va_arg (*args, u32);
290 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
291 foreach_ipsec_crypto_alg
294 return format (s, "unknown");
296 return format (s, "%s", t);
298 return format (s, "Unimplemented");
303 unformat_ipsec_integ_alg (unformat_input_t * input, va_list * args)
306 u32 *r = va_arg (*args, u32 *);
309 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_INTEG_ALG_##f;
310 foreach_ipsec_integ_alg
321 format_ipsec_integ_alg (u8 * s, va_list * args)
324 u32 i = va_arg (*args, u32);
329 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
330 foreach_ipsec_integ_alg
333 return format (s, "unknown");
335 return format (s, "%s", t);
337 return format (s, "Unsupported");
342 unformat_ikev2_auth_method (unformat_input_t * input, va_list * args)
345 u32 *r = va_arg (*args, u32 *);
348 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_AUTH_METHOD_##f;
349 foreach_ikev2_auth_method
360 unformat_ikev2_id_type (unformat_input_t * input, va_list * args)
363 u32 *r = va_arg (*args, u32 *);
366 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_ID_TYPE_##f;
367 foreach_ikev2_id_type
378 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
380 u8 *r = va_arg (*args, u8 *);
382 if (unformat (input, "kbps"))
383 *r = SSE2_QOS_RATE_KBPS;
384 else if (unformat (input, "pps"))
385 *r = SSE2_QOS_RATE_PPS;
392 unformat_policer_round_type (unformat_input_t * input, va_list * args)
394 u8 *r = va_arg (*args, u8 *);
396 if (unformat (input, "closest"))
397 *r = SSE2_QOS_ROUND_TO_CLOSEST;
398 else if (unformat (input, "up"))
399 *r = SSE2_QOS_ROUND_TO_UP;
400 else if (unformat (input, "down"))
401 *r = SSE2_QOS_ROUND_TO_DOWN;
408 unformat_policer_type (unformat_input_t * input, va_list * args)
410 u8 *r = va_arg (*args, u8 *);
412 if (unformat (input, "1r2c"))
413 *r = SSE2_QOS_POLICER_TYPE_1R2C;
414 else if (unformat (input, "1r3c"))
415 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
416 else if (unformat (input, "2r3c-2698"))
417 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
418 else if (unformat (input, "2r3c-4115"))
419 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
420 else if (unformat (input, "2r3c-mef5cf1"))
421 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
428 unformat_dscp (unformat_input_t * input, va_list * va)
430 u8 *r = va_arg (*va, u8 *);
433 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
442 unformat_policer_action_type (unformat_input_t * input, va_list * va)
444 sse2_qos_pol_action_params_st *a
445 = va_arg (*va, sse2_qos_pol_action_params_st *);
447 if (unformat (input, "drop"))
448 a->action_type = SSE2_QOS_ACTION_DROP;
449 else if (unformat (input, "transmit"))
450 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
451 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
452 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
459 unformat_classify_table_type (unformat_input_t * input, va_list * va)
461 u32 *r = va_arg (*va, u32 *);
464 if (unformat (input, "ip4"))
465 tid = POLICER_CLASSIFY_TABLE_IP4;
466 else if (unformat (input, "ip6"))
467 tid = POLICER_CLASSIFY_TABLE_IP6;
468 else if (unformat (input, "l2"))
469 tid = POLICER_CLASSIFY_TABLE_L2;
478 format_ip4_address (u8 * s, va_list * args)
480 u8 *a = va_arg (*args, u8 *);
481 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
485 format_ip6_address (u8 * s, va_list * args)
487 ip6_address_t *a = va_arg (*args, ip6_address_t *);
488 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
490 i_max_n_zero = ARRAY_LEN (a->as_u16);
492 i_first_zero = i_max_n_zero;
494 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
496 u32 is_zero = a->as_u16[i] == 0;
497 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
503 if ((!is_zero && n_zeros > max_n_zeros)
504 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
506 i_max_n_zero = i_first_zero;
507 max_n_zeros = n_zeros;
508 i_first_zero = ARRAY_LEN (a->as_u16);
513 last_double_colon = 0;
514 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
516 if (i == i_max_n_zero && max_n_zeros > 1)
518 s = format (s, "::");
519 i += max_n_zeros - 1;
520 last_double_colon = 1;
524 s = format (s, "%s%x",
525 (last_double_colon || i == 0) ? "" : ":",
526 clib_net_to_host_u16 (a->as_u16[i]));
527 last_double_colon = 0;
534 /* Format an IP46 address. */
536 format_ip46_address (u8 * s, va_list * args)
538 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
539 ip46_type_t type = va_arg (*args, ip46_type_t);
545 is_ip4 = ip46_address_is_ip4 (ip46);
556 format (s, "%U", format_ip4_address, &ip46->ip4) :
557 format (s, "%U", format_ip6_address, &ip46->ip6);
561 format_ethernet_address (u8 * s, va_list * args)
563 u8 *a = va_arg (*args, u8 *);
565 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
566 a[0], a[1], a[2], a[3], a[4], a[5]);
570 increment_v4_address (ip4_address_t * a)
574 v = ntohl (a->as_u32) + 1;
575 a->as_u32 = ntohl (v);
579 increment_v6_address (ip6_address_t * a)
583 v0 = clib_net_to_host_u64 (a->as_u64[0]);
584 v1 = clib_net_to_host_u64 (a->as_u64[1]);
589 a->as_u64[0] = clib_net_to_host_u64 (v0);
590 a->as_u64[1] = clib_net_to_host_u64 (v1);
594 increment_mac_address (u64 * mac)
598 tmp = clib_net_to_host_u64 (tmp);
599 tmp += 1 << 16; /* skip unused (least significant) octets */
600 tmp = clib_host_to_net_u64 (tmp);
604 static void vl_api_create_loopback_reply_t_handler
605 (vl_api_create_loopback_reply_t * mp)
607 vat_main_t *vam = &vat_main;
608 i32 retval = ntohl (mp->retval);
610 vam->retval = retval;
611 vam->regenerate_interface_table = 1;
612 vam->sw_if_index = ntohl (mp->sw_if_index);
613 vam->result_ready = 1;
616 static void vl_api_create_loopback_reply_t_handler_json
617 (vl_api_create_loopback_reply_t * mp)
619 vat_main_t *vam = &vat_main;
620 vat_json_node_t node;
622 vat_json_init_object (&node);
623 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
624 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
626 vat_json_print (vam->ofp, &node);
627 vat_json_free (&node);
628 vam->retval = ntohl (mp->retval);
629 vam->result_ready = 1;
632 static void vl_api_af_packet_create_reply_t_handler
633 (vl_api_af_packet_create_reply_t * mp)
635 vat_main_t *vam = &vat_main;
636 i32 retval = ntohl (mp->retval);
638 vam->retval = retval;
639 vam->regenerate_interface_table = 1;
640 vam->sw_if_index = ntohl (mp->sw_if_index);
641 vam->result_ready = 1;
644 static void vl_api_af_packet_create_reply_t_handler_json
645 (vl_api_af_packet_create_reply_t * mp)
647 vat_main_t *vam = &vat_main;
648 vat_json_node_t node;
650 vat_json_init_object (&node);
651 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
652 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
654 vat_json_print (vam->ofp, &node);
655 vat_json_free (&node);
657 vam->retval = ntohl (mp->retval);
658 vam->result_ready = 1;
661 static void vl_api_create_vlan_subif_reply_t_handler
662 (vl_api_create_vlan_subif_reply_t * mp)
664 vat_main_t *vam = &vat_main;
665 i32 retval = ntohl (mp->retval);
667 vam->retval = retval;
668 vam->regenerate_interface_table = 1;
669 vam->sw_if_index = ntohl (mp->sw_if_index);
670 vam->result_ready = 1;
673 static void vl_api_create_vlan_subif_reply_t_handler_json
674 (vl_api_create_vlan_subif_reply_t * mp)
676 vat_main_t *vam = &vat_main;
677 vat_json_node_t node;
679 vat_json_init_object (&node);
680 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
681 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
683 vat_json_print (vam->ofp, &node);
684 vat_json_free (&node);
686 vam->retval = ntohl (mp->retval);
687 vam->result_ready = 1;
690 static void vl_api_create_subif_reply_t_handler
691 (vl_api_create_subif_reply_t * mp)
693 vat_main_t *vam = &vat_main;
694 i32 retval = ntohl (mp->retval);
696 vam->retval = retval;
697 vam->regenerate_interface_table = 1;
698 vam->sw_if_index = ntohl (mp->sw_if_index);
699 vam->result_ready = 1;
702 static void vl_api_create_subif_reply_t_handler_json
703 (vl_api_create_subif_reply_t * mp)
705 vat_main_t *vam = &vat_main;
706 vat_json_node_t node;
708 vat_json_init_object (&node);
709 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
710 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
712 vat_json_print (vam->ofp, &node);
713 vat_json_free (&node);
715 vam->retval = ntohl (mp->retval);
716 vam->result_ready = 1;
719 static void vl_api_interface_name_renumber_reply_t_handler
720 (vl_api_interface_name_renumber_reply_t * mp)
722 vat_main_t *vam = &vat_main;
723 i32 retval = ntohl (mp->retval);
725 vam->retval = retval;
726 vam->regenerate_interface_table = 1;
727 vam->result_ready = 1;
730 static void vl_api_interface_name_renumber_reply_t_handler_json
731 (vl_api_interface_name_renumber_reply_t * mp)
733 vat_main_t *vam = &vat_main;
734 vat_json_node_t node;
736 vat_json_init_object (&node);
737 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
739 vat_json_print (vam->ofp, &node);
740 vat_json_free (&node);
742 vam->retval = ntohl (mp->retval);
743 vam->result_ready = 1;
747 * Special-case: build the interface table, maintain
748 * the next loopback sw_if_index vbl.
750 static void vl_api_sw_interface_details_t_handler
751 (vl_api_sw_interface_details_t * mp)
753 vat_main_t *vam = &vat_main;
754 u8 *s = format (0, "%s%c", mp->interface_name, 0);
756 hash_set_mem (vam->sw_if_index_by_interface_name, s,
757 ntohl (mp->sw_if_index));
759 /* In sub interface case, fill the sub interface table entry */
760 if (mp->sw_if_index != mp->sup_sw_if_index)
762 sw_interface_subif_t *sub = NULL;
764 vec_add2 (vam->sw_if_subif_table, sub, 1);
766 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
767 strncpy ((char *) sub->interface_name, (char *) s,
768 vec_len (sub->interface_name));
769 sub->sw_if_index = ntohl (mp->sw_if_index);
770 sub->sub_id = ntohl (mp->sub_id);
772 sub->sub_dot1ad = mp->sub_dot1ad;
773 sub->sub_number_of_tags = mp->sub_number_of_tags;
774 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
775 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
776 sub->sub_exact_match = mp->sub_exact_match;
777 sub->sub_default = mp->sub_default;
778 sub->sub_outer_vlan_id_any = mp->sub_outer_vlan_id_any;
779 sub->sub_inner_vlan_id_any = mp->sub_inner_vlan_id_any;
781 /* vlan tag rewrite */
782 sub->vtr_op = ntohl (mp->vtr_op);
783 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
784 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
785 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
789 static void vl_api_sw_interface_details_t_handler_json
790 (vl_api_sw_interface_details_t * mp)
792 vat_main_t *vam = &vat_main;
793 vat_json_node_t *node = NULL;
795 if (VAT_JSON_ARRAY != vam->json_tree.type)
797 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
798 vat_json_init_array (&vam->json_tree);
800 node = vat_json_array_add (&vam->json_tree);
802 vat_json_init_object (node);
803 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
804 vat_json_object_add_uint (node, "sup_sw_if_index",
805 ntohl (mp->sup_sw_if_index));
806 vat_json_object_add_uint (node, "l2_address_length",
807 ntohl (mp->l2_address_length));
808 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
809 sizeof (mp->l2_address));
810 vat_json_object_add_string_copy (node, "interface_name",
812 vat_json_object_add_uint (node, "admin_up_down", mp->admin_up_down);
813 vat_json_object_add_uint (node, "link_up_down", mp->link_up_down);
814 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
815 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
816 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
817 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
818 vat_json_object_add_uint (node, "sub_dot1ad", mp->sub_dot1ad);
819 vat_json_object_add_uint (node, "sub_number_of_tags",
820 mp->sub_number_of_tags);
821 vat_json_object_add_uint (node, "sub_outer_vlan_id",
822 ntohs (mp->sub_outer_vlan_id));
823 vat_json_object_add_uint (node, "sub_inner_vlan_id",
824 ntohs (mp->sub_inner_vlan_id));
825 vat_json_object_add_uint (node, "sub_exact_match", mp->sub_exact_match);
826 vat_json_object_add_uint (node, "sub_default", mp->sub_default);
827 vat_json_object_add_uint (node, "sub_outer_vlan_id_any",
828 mp->sub_outer_vlan_id_any);
829 vat_json_object_add_uint (node, "sub_inner_vlan_id_any",
830 mp->sub_inner_vlan_id_any);
831 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
832 vat_json_object_add_uint (node, "vtr_push_dot1q",
833 ntohl (mp->vtr_push_dot1q));
834 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
835 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
838 static void vl_api_sw_interface_set_flags_t_handler
839 (vl_api_sw_interface_set_flags_t * mp)
841 vat_main_t *vam = &vat_main;
842 if (vam->interface_event_display)
843 errmsg ("interface flags: sw_if_index %d %s %s\n",
844 ntohl (mp->sw_if_index),
845 mp->admin_up_down ? "admin-up" : "admin-down",
846 mp->link_up_down ? "link-up" : "link-down");
849 static void vl_api_sw_interface_set_flags_t_handler_json
850 (vl_api_sw_interface_set_flags_t * mp)
852 /* JSON output not supported */
856 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
858 vat_main_t *vam = &vat_main;
859 i32 retval = ntohl (mp->retval);
861 vam->retval = retval;
862 vam->shmem_result = (u8 *) mp->reply_in_shmem;
863 vam->result_ready = 1;
867 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
869 vat_main_t *vam = &vat_main;
870 vat_json_node_t node;
871 api_main_t *am = &api_main;
875 vat_json_init_object (&node);
876 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
877 vat_json_object_add_uint (&node, "reply_in_shmem",
878 ntohl (mp->reply_in_shmem));
879 /* Toss the shared-memory original... */
880 pthread_mutex_lock (&am->vlib_rp->mutex);
881 oldheap = svm_push_data_heap (am->vlib_rp);
883 reply = (u8 *) (mp->reply_in_shmem);
886 svm_pop_heap (oldheap);
887 pthread_mutex_unlock (&am->vlib_rp->mutex);
889 vat_json_print (vam->ofp, &node);
890 vat_json_free (&node);
892 vam->retval = ntohl (mp->retval);
893 vam->result_ready = 1;
897 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
899 vat_main_t *vam = &vat_main;
900 i32 retval = ntohl (mp->retval);
902 vam->retval = retval;
903 vam->cmd_reply = mp->reply;
904 vam->result_ready = 1;
908 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
910 vat_main_t *vam = &vat_main;
911 vat_json_node_t node;
913 vat_json_init_object (&node);
914 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
915 vat_json_object_add_string_copy (&node, "reply", mp->reply);
917 vat_json_print (vam->ofp, &node);
918 vat_json_free (&node);
920 vam->retval = ntohl (mp->retval);
921 vam->result_ready = 1;
924 static void vl_api_classify_add_del_table_reply_t_handler
925 (vl_api_classify_add_del_table_reply_t * mp)
927 vat_main_t *vam = &vat_main;
928 i32 retval = ntohl (mp->retval);
931 vam->async_errors += (retval < 0);
935 vam->retval = retval;
937 ((mp->new_table_index != 0xFFFFFFFF) ||
938 (mp->skip_n_vectors != 0xFFFFFFFF) ||
939 (mp->match_n_vectors != 0xFFFFFFFF)))
941 * Note: this is just barely thread-safe, depends on
942 * the main thread spinning waiting for an answer...
944 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d\n",
945 ntohl (mp->new_table_index),
946 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
947 vam->result_ready = 1;
951 static void vl_api_classify_add_del_table_reply_t_handler_json
952 (vl_api_classify_add_del_table_reply_t * mp)
954 vat_main_t *vam = &vat_main;
955 vat_json_node_t node;
957 vat_json_init_object (&node);
958 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
959 vat_json_object_add_uint (&node, "new_table_index",
960 ntohl (mp->new_table_index));
961 vat_json_object_add_uint (&node, "skip_n_vectors",
962 ntohl (mp->skip_n_vectors));
963 vat_json_object_add_uint (&node, "match_n_vectors",
964 ntohl (mp->match_n_vectors));
966 vat_json_print (vam->ofp, &node);
967 vat_json_free (&node);
969 vam->retval = ntohl (mp->retval);
970 vam->result_ready = 1;
973 static void vl_api_get_node_index_reply_t_handler
974 (vl_api_get_node_index_reply_t * mp)
976 vat_main_t *vam = &vat_main;
977 i32 retval = ntohl (mp->retval);
980 vam->async_errors += (retval < 0);
984 vam->retval = retval;
986 errmsg ("node index %d\n", ntohl (mp->node_index));
987 vam->result_ready = 1;
991 static void vl_api_get_node_index_reply_t_handler_json
992 (vl_api_get_node_index_reply_t * mp)
994 vat_main_t *vam = &vat_main;
995 vat_json_node_t node;
997 vat_json_init_object (&node);
998 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
999 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1001 vat_json_print (vam->ofp, &node);
1002 vat_json_free (&node);
1004 vam->retval = ntohl (mp->retval);
1005 vam->result_ready = 1;
1008 static void vl_api_get_next_index_reply_t_handler
1009 (vl_api_get_next_index_reply_t * mp)
1011 vat_main_t *vam = &vat_main;
1012 i32 retval = ntohl (mp->retval);
1013 if (vam->async_mode)
1015 vam->async_errors += (retval < 0);
1019 vam->retval = retval;
1021 errmsg ("next node index %d\n", ntohl (mp->next_index));
1022 vam->result_ready = 1;
1026 static void vl_api_get_next_index_reply_t_handler_json
1027 (vl_api_get_next_index_reply_t * mp)
1029 vat_main_t *vam = &vat_main;
1030 vat_json_node_t node;
1032 vat_json_init_object (&node);
1033 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1034 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1036 vat_json_print (vam->ofp, &node);
1037 vat_json_free (&node);
1039 vam->retval = ntohl (mp->retval);
1040 vam->result_ready = 1;
1043 static void vl_api_add_node_next_reply_t_handler
1044 (vl_api_add_node_next_reply_t * mp)
1046 vat_main_t *vam = &vat_main;
1047 i32 retval = ntohl (mp->retval);
1048 if (vam->async_mode)
1050 vam->async_errors += (retval < 0);
1054 vam->retval = retval;
1056 errmsg ("next index %d\n", ntohl (mp->next_index));
1057 vam->result_ready = 1;
1061 static void vl_api_add_node_next_reply_t_handler_json
1062 (vl_api_add_node_next_reply_t * mp)
1064 vat_main_t *vam = &vat_main;
1065 vat_json_node_t node;
1067 vat_json_init_object (&node);
1068 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1069 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1071 vat_json_print (vam->ofp, &node);
1072 vat_json_free (&node);
1074 vam->retval = ntohl (mp->retval);
1075 vam->result_ready = 1;
1078 static void vl_api_mpls_gre_add_del_tunnel_reply_t_handler
1079 (vl_api_mpls_gre_add_del_tunnel_reply_t * mp)
1081 vat_main_t *vam = &vat_main;
1082 i32 retval = ntohl (mp->retval);
1083 u32 sw_if_index = ntohl (mp->tunnel_sw_if_index);
1085 if (retval >= 0 && sw_if_index != (u32) ~ 0)
1087 errmsg ("tunnel_sw_if_index %d\n", sw_if_index);
1089 vam->retval = retval;
1090 vam->result_ready = 1;
1093 static void vl_api_mpls_gre_add_del_tunnel_reply_t_handler_json
1094 (vl_api_mpls_gre_add_del_tunnel_reply_t * mp)
1096 vat_main_t *vam = &vat_main;
1097 vat_json_node_t node;
1099 vat_json_init_object (&node);
1100 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1101 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
1102 ntohl (mp->tunnel_sw_if_index));
1104 vat_json_print (vam->ofp, &node);
1105 vat_json_free (&node);
1107 vam->retval = ntohl (mp->retval);
1108 vam->result_ready = 1;
1112 static void vl_api_show_version_reply_t_handler
1113 (vl_api_show_version_reply_t * mp)
1115 vat_main_t *vam = &vat_main;
1116 i32 retval = ntohl (mp->retval);
1120 errmsg (" program: %s\n", mp->program);
1121 errmsg (" version: %s\n", mp->version);
1122 errmsg (" build date: %s\n", mp->build_date);
1123 errmsg ("build directory: %s\n", mp->build_directory);
1125 vam->retval = retval;
1126 vam->result_ready = 1;
1129 static void vl_api_show_version_reply_t_handler_json
1130 (vl_api_show_version_reply_t * mp)
1132 vat_main_t *vam = &vat_main;
1133 vat_json_node_t node;
1135 vat_json_init_object (&node);
1136 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1137 vat_json_object_add_string_copy (&node, "program", mp->program);
1138 vat_json_object_add_string_copy (&node, "version", mp->version);
1139 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1140 vat_json_object_add_string_copy (&node, "build_directory",
1141 mp->build_directory);
1143 vat_json_print (vam->ofp, &node);
1144 vat_json_free (&node);
1146 vam->retval = ntohl (mp->retval);
1147 vam->result_ready = 1;
1151 vl_api_ip4_arp_event_t_handler (vl_api_ip4_arp_event_t * mp)
1153 vat_main_t *vam = &vat_main;
1154 errmsg ("arp %s event: address %U new mac %U sw_if_index %d\n",
1155 mp->mac_ip ? "mac/ip binding" : "address resolution",
1156 format_ip4_address, &mp->address,
1157 format_ethernet_address, mp->new_mac, mp->sw_if_index);
1161 vl_api_ip4_arp_event_t_handler_json (vl_api_ip4_arp_event_t * mp)
1163 /* JSON output not supported */
1167 vl_api_ip6_nd_event_t_handler (vl_api_ip6_nd_event_t * mp)
1169 vat_main_t *vam = &vat_main;
1170 errmsg ("ip6 nd %s event: address %U new mac %U sw_if_index %d\n",
1171 mp->mac_ip ? "mac/ip binding" : "address resolution",
1172 format_ip6_address, mp->address,
1173 format_ethernet_address, mp->new_mac, mp->sw_if_index);
1177 vl_api_ip6_nd_event_t_handler_json (vl_api_ip6_nd_event_t * mp)
1179 /* JSON output not supported */
1183 * Special-case: build the bridge domain table, maintain
1184 * the next bd id vbl.
1186 static void vl_api_bridge_domain_details_t_handler
1187 (vl_api_bridge_domain_details_t * mp)
1189 vat_main_t *vam = &vat_main;
1190 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1192 fformat (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-3s\n",
1193 " ID", "LRN", "FWD", "FLD", "BVI", "#IF");
1195 fformat (vam->ofp, "%3d %3d %3d %3d %3d %3d\n",
1196 ntohl (mp->bd_id), mp->learn, mp->forward,
1197 mp->flood, ntohl (mp->bvi_sw_if_index), n_sw_ifs);
1200 fformat (vam->ofp, "\n\n%s %s %s\n", "sw_if_index", "SHG",
1204 static void vl_api_bridge_domain_details_t_handler_json
1205 (vl_api_bridge_domain_details_t * mp)
1207 vat_main_t *vam = &vat_main;
1208 vat_json_node_t *node, *array = NULL;
1210 if (VAT_JSON_ARRAY != vam->json_tree.type)
1212 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1213 vat_json_init_array (&vam->json_tree);
1215 node = vat_json_array_add (&vam->json_tree);
1217 vat_json_init_object (node);
1218 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1219 vat_json_object_add_uint (node, "flood", mp->flood);
1220 vat_json_object_add_uint (node, "forward", mp->forward);
1221 vat_json_object_add_uint (node, "learn", mp->learn);
1222 vat_json_object_add_uint (node, "bvi_sw_if_index",
1223 ntohl (mp->bvi_sw_if_index));
1224 vat_json_object_add_uint (node, "n_sw_ifs", ntohl (mp->n_sw_ifs));
1225 array = vat_json_object_add (node, "sw_if");
1226 vat_json_init_array (array);
1230 * Special-case: build the bridge domain sw if table.
1232 static void vl_api_bridge_domain_sw_if_details_t_handler
1233 (vl_api_bridge_domain_sw_if_details_t * mp)
1235 vat_main_t *vam = &vat_main;
1240 sw_if_index = ntohl (mp->sw_if_index);
1242 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1244 if ((u32) p->value[0] == sw_if_index)
1246 sw_if_name = (u8 *)(p->key);
1252 fformat (vam->ofp, "%7d %3d %s", sw_if_index,
1253 mp->shg, sw_if_name ? (char *) sw_if_name :
1254 "sw_if_index not found!");
1257 static void vl_api_bridge_domain_sw_if_details_t_handler_json
1258 (vl_api_bridge_domain_sw_if_details_t * mp)
1260 vat_main_t *vam = &vat_main;
1261 vat_json_node_t *node = NULL;
1262 uword last_index = 0;
1264 ASSERT (VAT_JSON_ARRAY == vam->json_tree.type);
1265 ASSERT (vec_len (vam->json_tree.array) >= 1);
1266 last_index = vec_len (vam->json_tree.array) - 1;
1267 node = &vam->json_tree.array[last_index];
1268 node = vat_json_object_get_element (node, "sw_if");
1269 ASSERT (NULL != node);
1270 node = vat_json_array_add (node);
1272 vat_json_init_object (node);
1273 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1274 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
1275 vat_json_object_add_uint (node, "shg", mp->shg);
1278 static void vl_api_control_ping_reply_t_handler
1279 (vl_api_control_ping_reply_t * mp)
1281 vat_main_t *vam = &vat_main;
1282 i32 retval = ntohl (mp->retval);
1283 if (vam->async_mode)
1285 vam->async_errors += (retval < 0);
1289 vam->retval = retval;
1290 vam->result_ready = 1;
1294 static void vl_api_control_ping_reply_t_handler_json
1295 (vl_api_control_ping_reply_t * mp)
1297 vat_main_t *vam = &vat_main;
1298 i32 retval = ntohl (mp->retval);
1300 if (VAT_JSON_NONE != vam->json_tree.type)
1302 vat_json_print (vam->ofp, &vam->json_tree);
1303 vat_json_free (&vam->json_tree);
1304 vam->json_tree.type = VAT_JSON_NONE;
1309 vat_json_init_array (&vam->json_tree);
1310 vat_json_print (vam->ofp, &vam->json_tree);
1311 vam->json_tree.type = VAT_JSON_NONE;
1314 vam->retval = retval;
1315 vam->result_ready = 1;
1319 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1321 vat_main_t *vam = &vat_main;
1322 i32 retval = ntohl (mp->retval);
1323 if (vam->async_mode)
1325 vam->async_errors += (retval < 0);
1329 vam->retval = retval;
1330 vam->result_ready = 1;
1334 static void vl_api_l2_flags_reply_t_handler_json
1335 (vl_api_l2_flags_reply_t * mp)
1337 vat_main_t *vam = &vat_main;
1338 vat_json_node_t node;
1340 vat_json_init_object (&node);
1341 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1342 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1343 ntohl (mp->resulting_feature_bitmap));
1345 vat_json_print (vam->ofp, &node);
1346 vat_json_free (&node);
1348 vam->retval = ntohl (mp->retval);
1349 vam->result_ready = 1;
1352 static void vl_api_bridge_flags_reply_t_handler
1353 (vl_api_bridge_flags_reply_t * mp)
1355 vat_main_t *vam = &vat_main;
1356 i32 retval = ntohl (mp->retval);
1357 if (vam->async_mode)
1359 vam->async_errors += (retval < 0);
1363 vam->retval = retval;
1364 vam->result_ready = 1;
1368 static void vl_api_bridge_flags_reply_t_handler_json
1369 (vl_api_bridge_flags_reply_t * mp)
1371 vat_main_t *vam = &vat_main;
1372 vat_json_node_t node;
1374 vat_json_init_object (&node);
1375 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1376 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1377 ntohl (mp->resulting_feature_bitmap));
1379 vat_json_print (vam->ofp, &node);
1380 vat_json_free (&node);
1382 vam->retval = ntohl (mp->retval);
1383 vam->result_ready = 1;
1386 static void vl_api_tap_connect_reply_t_handler
1387 (vl_api_tap_connect_reply_t * mp)
1389 vat_main_t *vam = &vat_main;
1390 i32 retval = ntohl (mp->retval);
1391 if (vam->async_mode)
1393 vam->async_errors += (retval < 0);
1397 vam->retval = retval;
1398 vam->sw_if_index = ntohl (mp->sw_if_index);
1399 vam->result_ready = 1;
1404 static void vl_api_tap_connect_reply_t_handler_json
1405 (vl_api_tap_connect_reply_t * mp)
1407 vat_main_t *vam = &vat_main;
1408 vat_json_node_t node;
1410 vat_json_init_object (&node);
1411 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1412 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1414 vat_json_print (vam->ofp, &node);
1415 vat_json_free (&node);
1417 vam->retval = ntohl (mp->retval);
1418 vam->result_ready = 1;
1423 vl_api_tap_modify_reply_t_handler (vl_api_tap_modify_reply_t * mp)
1425 vat_main_t *vam = &vat_main;
1426 i32 retval = ntohl (mp->retval);
1427 if (vam->async_mode)
1429 vam->async_errors += (retval < 0);
1433 vam->retval = retval;
1434 vam->sw_if_index = ntohl (mp->sw_if_index);
1435 vam->result_ready = 1;
1439 static void vl_api_tap_modify_reply_t_handler_json
1440 (vl_api_tap_modify_reply_t * mp)
1442 vat_main_t *vam = &vat_main;
1443 vat_json_node_t node;
1445 vat_json_init_object (&node);
1446 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1447 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1449 vat_json_print (vam->ofp, &node);
1450 vat_json_free (&node);
1452 vam->retval = ntohl (mp->retval);
1453 vam->result_ready = 1;
1457 vl_api_tap_delete_reply_t_handler (vl_api_tap_delete_reply_t * mp)
1459 vat_main_t *vam = &vat_main;
1460 i32 retval = ntohl (mp->retval);
1461 if (vam->async_mode)
1463 vam->async_errors += (retval < 0);
1467 vam->retval = retval;
1468 vam->result_ready = 1;
1472 static void vl_api_tap_delete_reply_t_handler_json
1473 (vl_api_tap_delete_reply_t * mp)
1475 vat_main_t *vam = &vat_main;
1476 vat_json_node_t node;
1478 vat_json_init_object (&node);
1479 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1481 vat_json_print (vam->ofp, &node);
1482 vat_json_free (&node);
1484 vam->retval = ntohl (mp->retval);
1485 vam->result_ready = 1;
1488 static void vl_api_mpls_ethernet_add_del_tunnel_reply_t_handler
1489 (vl_api_mpls_ethernet_add_del_tunnel_reply_t * mp)
1491 vat_main_t *vam = &vat_main;
1492 i32 retval = ntohl (mp->retval);
1493 if (vam->async_mode)
1495 vam->async_errors += (retval < 0);
1499 vam->retval = retval;
1500 vam->result_ready = 1;
1504 static void vl_api_mpls_ethernet_add_del_tunnel_reply_t_handler_json
1505 (vl_api_mpls_ethernet_add_del_tunnel_reply_t * mp)
1507 vat_main_t *vam = &vat_main;
1508 vat_json_node_t node;
1510 vat_json_init_object (&node);
1511 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1512 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
1513 ntohl (mp->tunnel_sw_if_index));
1515 vat_json_print (vam->ofp, &node);
1516 vat_json_free (&node);
1518 vam->retval = ntohl (mp->retval);
1519 vam->result_ready = 1;
1522 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
1523 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1525 vat_main_t *vam = &vat_main;
1526 i32 retval = ntohl (mp->retval);
1527 if (vam->async_mode)
1529 vam->async_errors += (retval < 0);
1533 vam->retval = retval;
1534 vam->sw_if_index = ntohl (mp->sw_if_index);
1535 vam->result_ready = 1;
1539 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
1540 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1542 vat_main_t *vam = &vat_main;
1543 vat_json_node_t node;
1545 vat_json_init_object (&node);
1546 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1547 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1549 vat_json_print (vam->ofp, &node);
1550 vat_json_free (&node);
1552 vam->retval = ntohl (mp->retval);
1553 vam->result_ready = 1;
1557 static void vl_api_lisp_add_del_locator_set_reply_t_handler
1558 (vl_api_lisp_add_del_locator_set_reply_t * mp)
1560 vat_main_t *vam = &vat_main;
1561 i32 retval = ntohl (mp->retval);
1562 if (vam->async_mode)
1564 vam->async_errors += (retval < 0);
1568 vam->retval = retval;
1569 vam->result_ready = 1;
1573 static void vl_api_lisp_add_del_locator_set_reply_t_handler_json
1574 (vl_api_lisp_add_del_locator_set_reply_t * mp)
1576 vat_main_t *vam = &vat_main;
1577 vat_json_node_t node;
1579 vat_json_init_object (&node);
1580 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1581 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
1583 vat_json_print (vam->ofp, &node);
1584 vat_json_free (&node);
1586 vam->retval = ntohl (mp->retval);
1587 vam->result_ready = 1;
1590 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
1591 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1593 vat_main_t *vam = &vat_main;
1594 i32 retval = ntohl (mp->retval);
1595 if (vam->async_mode)
1597 vam->async_errors += (retval < 0);
1601 vam->retval = retval;
1602 vam->sw_if_index = ntohl (mp->sw_if_index);
1603 vam->result_ready = 1;
1607 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
1608 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1610 vat_main_t *vam = &vat_main;
1611 vat_json_node_t node;
1613 vat_json_init_object (&node);
1614 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1615 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1617 vat_json_print (vam->ofp, &node);
1618 vat_json_free (&node);
1620 vam->retval = ntohl (mp->retval);
1621 vam->result_ready = 1;
1624 static void vl_api_gre_add_del_tunnel_reply_t_handler
1625 (vl_api_gre_add_del_tunnel_reply_t * mp)
1627 vat_main_t *vam = &vat_main;
1628 i32 retval = ntohl (mp->retval);
1629 if (vam->async_mode)
1631 vam->async_errors += (retval < 0);
1635 vam->retval = retval;
1636 vam->sw_if_index = ntohl (mp->sw_if_index);
1637 vam->result_ready = 1;
1641 static void vl_api_gre_add_del_tunnel_reply_t_handler_json
1642 (vl_api_gre_add_del_tunnel_reply_t * mp)
1644 vat_main_t *vam = &vat_main;
1645 vat_json_node_t node;
1647 vat_json_init_object (&node);
1648 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1649 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1651 vat_json_print (vam->ofp, &node);
1652 vat_json_free (&node);
1654 vam->retval = ntohl (mp->retval);
1655 vam->result_ready = 1;
1658 static void vl_api_create_vhost_user_if_reply_t_handler
1659 (vl_api_create_vhost_user_if_reply_t * mp)
1661 vat_main_t *vam = &vat_main;
1662 i32 retval = ntohl (mp->retval);
1663 if (vam->async_mode)
1665 vam->async_errors += (retval < 0);
1669 vam->retval = retval;
1670 vam->sw_if_index = ntohl (mp->sw_if_index);
1671 vam->result_ready = 1;
1675 static void vl_api_create_vhost_user_if_reply_t_handler_json
1676 (vl_api_create_vhost_user_if_reply_t * mp)
1678 vat_main_t *vam = &vat_main;
1679 vat_json_node_t node;
1681 vat_json_init_object (&node);
1682 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1683 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1685 vat_json_print (vam->ofp, &node);
1686 vat_json_free (&node);
1688 vam->retval = ntohl (mp->retval);
1689 vam->result_ready = 1;
1692 static void vl_api_ip_address_details_t_handler
1693 (vl_api_ip_address_details_t * mp)
1695 vat_main_t *vam = &vat_main;
1696 static ip_address_details_t empty_ip_address_details = { {0} };
1697 ip_address_details_t *address = NULL;
1698 ip_details_t *current_ip_details = NULL;
1699 ip_details_t *details = NULL;
1701 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
1703 if (!details || vam->current_sw_if_index >= vec_len (details)
1704 || !details[vam->current_sw_if_index].present)
1706 errmsg ("ip address details arrived but not stored\n");
1707 errmsg ("ip_dump should be called first\n");
1711 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
1713 #define addresses (current_ip_details->addr)
1715 vec_validate_init_empty (addresses, vec_len (addresses),
1716 empty_ip_address_details);
1718 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
1720 clib_memcpy (&address->ip, &mp->ip, sizeof (address->ip));
1721 address->prefix_length = mp->prefix_length;
1725 static void vl_api_ip_address_details_t_handler_json
1726 (vl_api_ip_address_details_t * mp)
1728 vat_main_t *vam = &vat_main;
1729 vat_json_node_t *node = NULL;
1730 struct in6_addr ip6;
1733 if (VAT_JSON_ARRAY != vam->json_tree.type)
1735 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1736 vat_json_init_array (&vam->json_tree);
1738 node = vat_json_array_add (&vam->json_tree);
1740 vat_json_init_object (node);
1743 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
1744 vat_json_object_add_ip6 (node, "ip", ip6);
1748 clib_memcpy (&ip4, mp->ip, sizeof (ip4));
1749 vat_json_object_add_ip4 (node, "ip", ip4);
1751 vat_json_object_add_uint (node, "prefix_length", mp->prefix_length);
1755 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
1757 vat_main_t *vam = &vat_main;
1758 static ip_details_t empty_ip_details = { 0 };
1759 ip_details_t *ip = NULL;
1760 u32 sw_if_index = ~0;
1762 sw_if_index = ntohl (mp->sw_if_index);
1764 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1765 sw_if_index, empty_ip_details);
1767 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1774 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
1776 vat_main_t *vam = &vat_main;
1778 if (VAT_JSON_ARRAY != vam->json_tree.type)
1780 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1781 vat_json_init_array (&vam->json_tree);
1783 vat_json_array_add_uint (&vam->json_tree,
1784 clib_net_to_host_u32 (mp->sw_if_index));
1787 static void vl_api_map_domain_details_t_handler_json
1788 (vl_api_map_domain_details_t * mp)
1790 vat_json_node_t *node = NULL;
1791 vat_main_t *vam = &vat_main;
1792 struct in6_addr ip6;
1795 if (VAT_JSON_ARRAY != vam->json_tree.type)
1797 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1798 vat_json_init_array (&vam->json_tree);
1801 node = vat_json_array_add (&vam->json_tree);
1802 vat_json_init_object (node);
1804 vat_json_object_add_uint (node, "domain_index",
1805 clib_net_to_host_u32 (mp->domain_index));
1806 clib_memcpy (&ip6, mp->ip6_prefix, sizeof (ip6));
1807 vat_json_object_add_ip6 (node, "ip6_prefix", ip6);
1808 clib_memcpy (&ip4, mp->ip4_prefix, sizeof (ip4));
1809 vat_json_object_add_ip4 (node, "ip4_prefix", ip4);
1810 clib_memcpy (&ip6, mp->ip6_src, sizeof (ip6));
1811 vat_json_object_add_ip6 (node, "ip6_src", ip6);
1812 vat_json_object_add_int (node, "ip6_prefix_len", mp->ip6_prefix_len);
1813 vat_json_object_add_int (node, "ip4_prefix_len", mp->ip4_prefix_len);
1814 vat_json_object_add_int (node, "ip6_src_len", mp->ip6_src_len);
1815 vat_json_object_add_int (node, "ea_bits_len", mp->ea_bits_len);
1816 vat_json_object_add_int (node, "psid_offset", mp->psid_offset);
1817 vat_json_object_add_int (node, "psid_length", mp->psid_length);
1818 vat_json_object_add_uint (node, "flags", mp->flags);
1819 vat_json_object_add_uint (node, "mtu", clib_net_to_host_u16 (mp->mtu));
1820 vat_json_object_add_int (node, "is_translation", mp->is_translation);
1823 static void vl_api_map_domain_details_t_handler
1824 (vl_api_map_domain_details_t * mp)
1826 vat_main_t *vam = &vat_main;
1828 if (mp->is_translation)
1831 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U/%d (ip6-src) index: %u\n",
1832 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1833 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1834 format_ip6_address, mp->ip6_src, mp->ip6_src_len,
1835 clib_net_to_host_u32 (mp->domain_index));
1840 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U (ip6-src) index: %u\n",
1841 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1842 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1843 format_ip6_address, mp->ip6_src,
1844 clib_net_to_host_u32 (mp->domain_index));
1846 fformat (vam->ofp, " ea-len %d psid-offset %d psid-len %d mtu %d %s\n",
1847 mp->ea_bits_len, mp->psid_offset, mp->psid_length, mp->mtu,
1848 mp->is_translation ? "map-t" : "");
1851 static void vl_api_map_rule_details_t_handler_json
1852 (vl_api_map_rule_details_t * mp)
1854 struct in6_addr ip6;
1855 vat_json_node_t *node = NULL;
1856 vat_main_t *vam = &vat_main;
1858 if (VAT_JSON_ARRAY != vam->json_tree.type)
1860 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1861 vat_json_init_array (&vam->json_tree);
1864 node = vat_json_array_add (&vam->json_tree);
1865 vat_json_init_object (node);
1867 vat_json_object_add_uint (node, "psid", clib_net_to_host_u16 (mp->psid));
1868 clib_memcpy (&ip6, mp->ip6_dst, sizeof (ip6));
1869 vat_json_object_add_ip6 (node, "ip6_dst", ip6);
1873 vl_api_map_rule_details_t_handler (vl_api_map_rule_details_t * mp)
1875 vat_main_t *vam = &vat_main;
1876 fformat (vam->ofp, " %d (psid) %U (ip6-dst)\n",
1877 clib_net_to_host_u16 (mp->psid), format_ip6_address, mp->ip6_dst);
1881 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
1883 vat_main_t *vam = &vat_main;
1884 errmsg ("DHCP compl event: pid %d %s hostname %s host_addr %U "
1885 "router_addr %U host_mac %U\n",
1886 mp->pid, mp->is_ipv6 ? "ipv6" : "ipv4", mp->hostname,
1887 format_ip4_address, &mp->host_address,
1888 format_ip4_address, &mp->router_address,
1889 format_ethernet_address, mp->host_mac);
1892 static void vl_api_dhcp_compl_event_t_handler_json
1893 (vl_api_dhcp_compl_event_t * mp)
1895 /* JSON output not supported */
1899 set_simple_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1902 vat_main_t *vam = &vat_main;
1903 static u64 default_counter = 0;
1905 vec_validate_init_empty (vam->simple_interface_counters, vnet_counter_type,
1907 vec_validate_init_empty (vam->simple_interface_counters[vnet_counter_type],
1908 sw_if_index, default_counter);
1909 vam->simple_interface_counters[vnet_counter_type][sw_if_index] = counter;
1913 set_combined_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1914 interface_counter_t counter)
1916 vat_main_t *vam = &vat_main;
1917 static interface_counter_t default_counter = { 0, };
1919 vec_validate_init_empty (vam->combined_interface_counters,
1920 vnet_counter_type, NULL);
1921 vec_validate_init_empty (vam->combined_interface_counters
1922 [vnet_counter_type], sw_if_index, default_counter);
1923 vam->combined_interface_counters[vnet_counter_type][sw_if_index] = counter;
1926 static void vl_api_vnet_interface_counters_t_handler
1927 (vl_api_vnet_interface_counters_t * mp)
1932 static void vl_api_vnet_interface_counters_t_handler_json
1933 (vl_api_vnet_interface_counters_t * mp)
1935 interface_counter_t counter;
1940 u32 first_sw_if_index;
1943 count = ntohl (mp->count);
1944 first_sw_if_index = ntohl (mp->first_sw_if_index);
1946 if (!mp->is_combined)
1948 v_packets = (u64 *) & mp->data;
1949 for (i = 0; i < count; i++)
1952 clib_net_to_host_u64 (clib_mem_unaligned (v_packets, u64));
1953 set_simple_interface_counter (mp->vnet_counter_type,
1954 first_sw_if_index + i, packets);
1960 v = (vlib_counter_t *) & mp->data;
1961 for (i = 0; i < count; i++)
1964 clib_net_to_host_u64 (clib_mem_unaligned (&v->packets, u64));
1966 clib_net_to_host_u64 (clib_mem_unaligned (&v->bytes, u64));
1967 set_combined_interface_counter (mp->vnet_counter_type,
1968 first_sw_if_index + i, counter);
1975 ip4_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
1977 vat_main_t *vam = &vat_main;
1980 for (i = 0; i < vec_len (vam->ip4_fib_counters_vrf_id_by_index); i++)
1982 if (vam->ip4_fib_counters_vrf_id_by_index[i] == vrf_id)
1991 ip6_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
1993 vat_main_t *vam = &vat_main;
1996 for (i = 0; i < vec_len (vam->ip6_fib_counters_vrf_id_by_index); i++)
1998 if (vam->ip6_fib_counters_vrf_id_by_index[i] == vrf_id)
2006 static void vl_api_vnet_ip4_fib_counters_t_handler
2007 (vl_api_vnet_ip4_fib_counters_t * mp)
2012 static void vl_api_vnet_ip4_fib_counters_t_handler_json
2013 (vl_api_vnet_ip4_fib_counters_t * mp)
2015 vat_main_t *vam = &vat_main;
2016 vl_api_ip4_fib_counter_t *v;
2017 ip4_fib_counter_t *counter;
2024 vrf_id = ntohl (mp->vrf_id);
2025 vrf_index = ip4_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2026 if (~0 == vrf_index)
2028 vrf_index = vec_len (vam->ip4_fib_counters_vrf_id_by_index);
2029 vec_validate (vam->ip4_fib_counters_vrf_id_by_index, vrf_index);
2030 vam->ip4_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2031 vec_validate (vam->ip4_fib_counters, vrf_index);
2032 vam->ip4_fib_counters[vrf_index] = NULL;
2035 vec_free (vam->ip4_fib_counters[vrf_index]);
2036 v = (vl_api_ip4_fib_counter_t *) & mp->c;
2037 count = ntohl (mp->count);
2038 for (i = 0; i < count; i++)
2040 vec_validate (vam->ip4_fib_counters[vrf_index], i);
2041 counter = &vam->ip4_fib_counters[vrf_index][i];
2042 clib_memcpy (&ip4, &v->address, sizeof (ip4));
2043 counter->address = ip4;
2044 counter->address_length = v->address_length;
2045 counter->packets = clib_net_to_host_u64 (v->packets);
2046 counter->bytes = clib_net_to_host_u64 (v->bytes);
2051 static void vl_api_vnet_ip6_fib_counters_t_handler
2052 (vl_api_vnet_ip6_fib_counters_t * mp)
2057 static void vl_api_vnet_ip6_fib_counters_t_handler_json
2058 (vl_api_vnet_ip6_fib_counters_t * mp)
2060 vat_main_t *vam = &vat_main;
2061 vl_api_ip6_fib_counter_t *v;
2062 ip6_fib_counter_t *counter;
2063 struct in6_addr ip6;
2069 vrf_id = ntohl (mp->vrf_id);
2070 vrf_index = ip6_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2071 if (~0 == vrf_index)
2073 vrf_index = vec_len (vam->ip6_fib_counters_vrf_id_by_index);
2074 vec_validate (vam->ip6_fib_counters_vrf_id_by_index, vrf_index);
2075 vam->ip6_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2076 vec_validate (vam->ip6_fib_counters, vrf_index);
2077 vam->ip6_fib_counters[vrf_index] = NULL;
2080 vec_free (vam->ip6_fib_counters[vrf_index]);
2081 v = (vl_api_ip6_fib_counter_t *) & mp->c;
2082 count = ntohl (mp->count);
2083 for (i = 0; i < count; i++)
2085 vec_validate (vam->ip6_fib_counters[vrf_index], i);
2086 counter = &vam->ip6_fib_counters[vrf_index][i];
2087 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2088 counter->address = ip6;
2089 counter->address_length = v->address_length;
2090 counter->packets = clib_net_to_host_u64 (v->packets);
2091 counter->bytes = clib_net_to_host_u64 (v->bytes);
2096 static void vl_api_get_first_msg_id_reply_t_handler
2097 (vl_api_get_first_msg_id_reply_t * mp)
2099 vat_main_t *vam = &vat_main;
2100 i32 retval = ntohl (mp->retval);
2102 if (vam->async_mode)
2104 vam->async_errors += (retval < 0);
2108 vam->retval = retval;
2109 vam->result_ready = 1;
2113 errmsg ("first message id %d\n", ntohs (mp->first_msg_id));
2117 static void vl_api_get_first_msg_id_reply_t_handler_json
2118 (vl_api_get_first_msg_id_reply_t * mp)
2120 vat_main_t *vam = &vat_main;
2121 vat_json_node_t node;
2123 vat_json_init_object (&node);
2124 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2125 vat_json_object_add_uint (&node, "first_msg_id",
2126 (uint) ntohs (mp->first_msg_id));
2128 vat_json_print (vam->ofp, &node);
2129 vat_json_free (&node);
2131 vam->retval = ntohl (mp->retval);
2132 vam->result_ready = 1;
2135 static void vl_api_get_node_graph_reply_t_handler
2136 (vl_api_get_node_graph_reply_t * mp)
2138 vat_main_t *vam = &vat_main;
2139 api_main_t *am = &api_main;
2140 i32 retval = ntohl (mp->retval);
2141 u8 *pvt_copy, *reply;
2146 if (vam->async_mode)
2148 vam->async_errors += (retval < 0);
2152 vam->retval = retval;
2153 vam->result_ready = 1;
2156 /* "Should never happen..." */
2160 reply = (u8 *) (mp->reply_in_shmem);
2161 pvt_copy = vec_dup (reply);
2163 /* Toss the shared-memory original... */
2164 pthread_mutex_lock (&am->vlib_rp->mutex);
2165 oldheap = svm_push_data_heap (am->vlib_rp);
2169 svm_pop_heap (oldheap);
2170 pthread_mutex_unlock (&am->vlib_rp->mutex);
2172 if (vam->graph_nodes)
2174 hash_free (vam->graph_node_index_by_name);
2176 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2178 node = vam->graph_nodes[i];
2179 vec_free (node->name);
2180 vec_free (node->next_nodes);
2183 vec_free (vam->graph_nodes);
2186 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2187 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2188 vec_free (pvt_copy);
2190 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2192 node = vam->graph_nodes[i];
2193 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2197 static void vl_api_get_node_graph_reply_t_handler_json
2198 (vl_api_get_node_graph_reply_t * mp)
2200 vat_main_t *vam = &vat_main;
2201 api_main_t *am = &api_main;
2203 vat_json_node_t node;
2206 /* $$$$ make this real? */
2207 vat_json_init_object (&node);
2208 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2209 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2211 reply = (u8 *) (mp->reply_in_shmem);
2213 /* Toss the shared-memory original... */
2214 pthread_mutex_lock (&am->vlib_rp->mutex);
2215 oldheap = svm_push_data_heap (am->vlib_rp);
2219 svm_pop_heap (oldheap);
2220 pthread_mutex_unlock (&am->vlib_rp->mutex);
2222 vat_json_print (vam->ofp, &node);
2223 vat_json_free (&node);
2225 vam->retval = ntohl (mp->retval);
2226 vam->result_ready = 1;
2230 vl_api_lisp_locator_details_t_handler (vl_api_lisp_locator_details_t * mp)
2232 vat_main_t *vam = &vat_main;
2237 s = format (s, "%=16d%=16d%=16d\n",
2238 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2242 s = format (s, "%=16U%=16d%=16d\n",
2243 mp->is_ipv6 ? format_ip6_address :
2245 mp->ip_address, mp->priority, mp->weight);
2248 fformat (vam->ofp, "%v", s);
2253 vl_api_lisp_locator_details_t_handler_json (vl_api_lisp_locator_details_t *
2256 vat_main_t *vam = &vat_main;
2257 vat_json_node_t *node = NULL;
2258 struct in6_addr ip6;
2261 if (VAT_JSON_ARRAY != vam->json_tree.type)
2263 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2264 vat_json_init_array (&vam->json_tree);
2266 node = vat_json_array_add (&vam->json_tree);
2267 vat_json_init_object (node);
2269 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2270 vat_json_object_add_uint (node, "priority", mp->priority);
2271 vat_json_object_add_uint (node, "weight", mp->weight);
2274 vat_json_object_add_uint (node, "sw_if_index",
2275 clib_net_to_host_u32 (mp->sw_if_index));
2280 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2281 vat_json_object_add_ip6 (node, "address", ip6);
2285 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2286 vat_json_object_add_ip4 (node, "address", ip4);
2292 vl_api_lisp_locator_set_details_t_handler (vl_api_lisp_locator_set_details_t *
2295 vat_main_t *vam = &vat_main;
2298 ls_name = format (0, "%s", mp->ls_name);
2300 fformat (vam->ofp, "%=10d%=15v\n", clib_net_to_host_u32 (mp->ls_index),
2306 vl_api_lisp_locator_set_details_t_handler_json
2307 (vl_api_lisp_locator_set_details_t * mp)
2309 vat_main_t *vam = &vat_main;
2310 vat_json_node_t *node = 0;
2313 ls_name = format (0, "%s", mp->ls_name);
2314 vec_add1 (ls_name, 0);
2316 if (VAT_JSON_ARRAY != vam->json_tree.type)
2318 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2319 vat_json_init_array (&vam->json_tree);
2321 node = vat_json_array_add (&vam->json_tree);
2323 vat_json_init_object (node);
2324 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2325 vat_json_object_add_uint (node, "ls_index",
2326 clib_net_to_host_u32 (mp->ls_index));
2331 format_lisp_flat_eid (u8 * s, va_list * args)
2333 u32 type = va_arg (*args, u32);
2334 u8 *eid = va_arg (*args, u8 *);
2335 u32 eid_len = va_arg (*args, u32);
2340 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
2342 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
2344 return format (s, "%U", format_ethernet_address, eid);
2350 format_lisp_eid_vat (u8 * s, va_list * args)
2352 u32 type = va_arg (*args, u32);
2353 u8 *eid = va_arg (*args, u8 *);
2354 u32 eid_len = va_arg (*args, u32);
2355 u8 *seid = va_arg (*args, u8 *);
2356 u32 seid_len = va_arg (*args, u32);
2357 u32 is_src_dst = va_arg (*args, u32);
2360 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
2362 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
2368 vl_api_lisp_eid_table_details_t_handler (vl_api_lisp_eid_table_details_t * mp)
2370 vat_main_t *vam = &vat_main;
2371 u8 *s = 0, *eid = 0;
2373 if (~0 == mp->locator_set_index)
2374 s = format (0, "action: %d", mp->action);
2376 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
2378 eid = format (0, "%U", format_lisp_eid_vat,
2382 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2385 fformat (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-d\n",
2386 clib_net_to_host_u32 (mp->vni),
2388 mp->is_local ? "local" : "remote",
2389 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative);
2395 vl_api_lisp_eid_table_details_t_handler_json (vl_api_lisp_eid_table_details_t
2398 vat_main_t *vam = &vat_main;
2399 vat_json_node_t *node = 0;
2402 if (VAT_JSON_ARRAY != vam->json_tree.type)
2404 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2405 vat_json_init_array (&vam->json_tree);
2407 node = vat_json_array_add (&vam->json_tree);
2409 vat_json_init_object (node);
2410 if (~0 == mp->locator_set_index)
2411 vat_json_object_add_uint (node, "action", mp->action);
2413 vat_json_object_add_uint (node, "locator_set_index",
2414 clib_net_to_host_u32 (mp->locator_set_index));
2416 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
2417 eid = format (0, "%U", format_lisp_eid_vat,
2421 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2423 vat_json_object_add_string_copy (node, "eid", eid);
2424 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2425 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
2426 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
2431 vl_api_lisp_eid_table_map_details_t_handler
2432 (vl_api_lisp_eid_table_map_details_t * mp)
2434 vat_main_t *vam = &vat_main;
2436 u8 *line = format (0, "%=10d%=10d",
2437 clib_net_to_host_u32 (mp->vni),
2438 clib_net_to_host_u32 (mp->dp_table));
2439 fformat (vam->ofp, "%v\n", line);
2444 vl_api_lisp_eid_table_map_details_t_handler_json
2445 (vl_api_lisp_eid_table_map_details_t * mp)
2447 vat_main_t *vam = &vat_main;
2448 vat_json_node_t *node = NULL;
2450 if (VAT_JSON_ARRAY != vam->json_tree.type)
2452 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2453 vat_json_init_array (&vam->json_tree);
2455 node = vat_json_array_add (&vam->json_tree);
2456 vat_json_init_object (node);
2457 vat_json_object_add_uint (node, "dp_table",
2458 clib_net_to_host_u32 (mp->dp_table));
2459 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2463 vl_api_lisp_eid_table_vni_details_t_handler
2464 (vl_api_lisp_eid_table_vni_details_t * mp)
2466 vat_main_t *vam = &vat_main;
2468 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
2469 fformat (vam->ofp, "%v\n", line);
2474 vl_api_lisp_eid_table_vni_details_t_handler_json
2475 (vl_api_lisp_eid_table_vni_details_t * mp)
2477 vat_main_t *vam = &vat_main;
2478 vat_json_node_t *node = NULL;
2480 if (VAT_JSON_ARRAY != vam->json_tree.type)
2482 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2483 vat_json_init_array (&vam->json_tree);
2485 node = vat_json_array_add (&vam->json_tree);
2486 vat_json_init_object (node);
2487 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2491 format_decap_next (u8 * s, va_list * args)
2493 u32 next_index = va_arg (*args, u32);
2497 case LISP_GPE_INPUT_NEXT_DROP:
2498 return format (s, "drop");
2499 case LISP_GPE_INPUT_NEXT_IP4_INPUT:
2500 return format (s, "ip4");
2501 case LISP_GPE_INPUT_NEXT_IP6_INPUT:
2502 return format (s, "ip6");
2504 return format (s, "unknown %d", next_index);
2510 vl_api_lisp_gpe_tunnel_details_t_handler (vl_api_lisp_gpe_tunnel_details_t *
2513 vat_main_t *vam = &vat_main;
2515 u8 *flag_str = NULL;
2517 iid_str = format (0, "%d (0x%x)", ntohl (mp->iid), ntohl (mp->iid));
2519 #define _(n,v) if (mp->flags & v) flag_str = format (flag_str, "%s-bit ", #n);
2520 foreach_lisp_gpe_flag_bit;
2523 fformat (vam->ofp, "%=20d%=30U%=16U%=16d%=16d%=16U"
2524 "%=16d%=16d%=16sd=16d%=16s%=16s\n",
2526 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2528 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2530 ntohl (mp->encap_fib_id),
2531 ntohl (mp->decap_fib_id),
2532 format_decap_next, ntohl (mp->dcap_next),
2534 flag_str, mp->next_protocol, mp->ver_res, mp->res, iid_str);
2540 vl_api_lisp_gpe_tunnel_details_t_handler_json
2541 (vl_api_lisp_gpe_tunnel_details_t * mp)
2543 vat_main_t *vam = &vat_main;
2544 vat_json_node_t *node = NULL;
2545 struct in6_addr ip6;
2549 next_decap_str = format (0, "%U", format_decap_next, htonl (mp->dcap_next));
2551 if (VAT_JSON_ARRAY != vam->json_tree.type)
2553 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2554 vat_json_init_array (&vam->json_tree);
2556 node = vat_json_array_add (&vam->json_tree);
2558 vat_json_init_object (node);
2559 vat_json_object_add_uint (node, "tunel", mp->tunnels);
2562 clib_memcpy (&ip6, mp->source_ip, sizeof (ip6));
2563 vat_json_object_add_ip6 (node, "source address", ip6);
2564 clib_memcpy (&ip6, mp->destination_ip, sizeof (ip6));
2565 vat_json_object_add_ip6 (node, "destination address", ip6);
2569 clib_memcpy (&ip4, mp->source_ip, sizeof (ip4));
2570 vat_json_object_add_ip4 (node, "source address", ip4);
2571 clib_memcpy (&ip4, mp->destination_ip, sizeof (ip4));
2572 vat_json_object_add_ip4 (node, "destination address", ip4);
2574 vat_json_object_add_uint (node, "fib encap", ntohl (mp->encap_fib_id));
2575 vat_json_object_add_uint (node, "fib decap", ntohl (mp->decap_fib_id));
2576 vat_json_object_add_string_copy (node, "decap next", next_decap_str);
2577 vat_json_object_add_uint (node, "lisp version", mp->ver_res >> 6);
2578 vat_json_object_add_uint (node, "flags", mp->flags);
2579 vat_json_object_add_uint (node, "next protocol", mp->next_protocol);
2580 vat_json_object_add_uint (node, "ver_res", mp->ver_res);
2581 vat_json_object_add_uint (node, "res", mp->res);
2582 vat_json_object_add_uint (node, "iid", ntohl (mp->iid));
2584 vec_free (next_decap_str);
2588 vl_api_lisp_map_resolver_details_t_handler (vl_api_lisp_map_resolver_details_t
2591 vat_main_t *vam = &vat_main;
2593 fformat (vam->ofp, "%=20U\n",
2594 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2599 vl_api_lisp_map_resolver_details_t_handler_json
2600 (vl_api_lisp_map_resolver_details_t * mp)
2602 vat_main_t *vam = &vat_main;
2603 vat_json_node_t *node = NULL;
2604 struct in6_addr ip6;
2607 if (VAT_JSON_ARRAY != vam->json_tree.type)
2609 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2610 vat_json_init_array (&vam->json_tree);
2612 node = vat_json_array_add (&vam->json_tree);
2614 vat_json_init_object (node);
2617 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2618 vat_json_object_add_ip6 (node, "map resolver", ip6);
2622 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2623 vat_json_object_add_ip4 (node, "map resolver", ip4);
2628 vl_api_show_lisp_status_reply_t_handler
2629 (vl_api_show_lisp_status_reply_t * mp)
2631 vat_main_t *vam = &vat_main;
2632 i32 retval = ntohl (mp->retval);
2636 fformat (vam->ofp, "feature: %s\ngpe: %s\n",
2637 mp->feature_status ? "enabled" : "disabled",
2638 mp->gpe_status ? "enabled" : "disabled");
2641 vam->retval = retval;
2642 vam->result_ready = 1;
2646 vl_api_show_lisp_status_reply_t_handler_json
2647 (vl_api_show_lisp_status_reply_t * mp)
2649 vat_main_t *vam = &vat_main;
2650 vat_json_node_t node;
2651 u8 *gpe_status = NULL;
2652 u8 *feature_status = NULL;
2654 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
2655 feature_status = format (0, "%s",
2656 mp->feature_status ? "enabled" : "disabled");
2657 vec_add1 (gpe_status, 0);
2658 vec_add1 (feature_status, 0);
2660 vat_json_init_object (&node);
2661 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
2662 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
2664 vec_free (gpe_status);
2665 vec_free (feature_status);
2667 vat_json_print (vam->ofp, &node);
2668 vat_json_free (&node);
2670 vam->retval = ntohl (mp->retval);
2671 vam->result_ready = 1;
2675 vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler
2676 (vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
2678 vat_main_t *vam = &vat_main;
2679 i32 retval = ntohl (mp->retval);
2683 fformat (vam->ofp, "%=20s\n", mp->locator_set_name);
2686 vam->retval = retval;
2687 vam->result_ready = 1;
2691 vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler_json
2692 (vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
2694 vat_main_t *vam = &vat_main;
2695 vat_json_node_t *node = NULL;
2697 if (VAT_JSON_ARRAY != vam->json_tree.type)
2699 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2700 vat_json_init_array (&vam->json_tree);
2702 node = vat_json_array_add (&vam->json_tree);
2704 vat_json_init_object (node);
2705 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
2707 vat_json_print (vam->ofp, node);
2708 vat_json_free (node);
2710 vam->retval = ntohl (mp->retval);
2711 vam->result_ready = 1;
2715 format_lisp_map_request_mode (u8 * s, va_list * args)
2717 u32 mode = va_arg (*args, u32);
2722 return format (0, "dst-only");
2724 return format (0, "src-dst");
2730 vl_api_show_lisp_map_request_mode_reply_t_handler
2731 (vl_api_show_lisp_map_request_mode_reply_t * mp)
2733 vat_main_t *vam = &vat_main;
2734 i32 retval = ntohl (mp->retval);
2738 u32 mode = mp->mode;
2739 fformat (vam->ofp, "map_request_mode: %U\n",
2740 format_lisp_map_request_mode, mode);
2743 vam->retval = retval;
2744 vam->result_ready = 1;
2748 vl_api_show_lisp_map_request_mode_reply_t_handler_json
2749 (vl_api_show_lisp_map_request_mode_reply_t * mp)
2751 vat_main_t *vam = &vat_main;
2752 vat_json_node_t node;
2757 s = format (0, "%U", format_lisp_map_request_mode, mode);
2760 vat_json_init_object (&node);
2761 vat_json_object_add_string_copy (&node, "map_request_mode", s);
2762 vat_json_print (vam->ofp, &node);
2763 vat_json_free (&node);
2766 vam->retval = ntohl (mp->retval);
2767 vam->result_ready = 1;
2771 vl_api_show_lisp_pitr_reply_t_handler (vl_api_show_lisp_pitr_reply_t * mp)
2773 vat_main_t *vam = &vat_main;
2774 i32 retval = ntohl (mp->retval);
2778 fformat (vam->ofp, "%-20s%-16s\n",
2779 mp->status ? "enabled" : "disabled",
2780 mp->status ? (char *) mp->locator_set_name : "");
2783 vam->retval = retval;
2784 vam->result_ready = 1;
2788 vl_api_show_lisp_pitr_reply_t_handler_json (vl_api_show_lisp_pitr_reply_t *
2791 vat_main_t *vam = &vat_main;
2792 vat_json_node_t node;
2795 status = format (0, "%s", mp->status ? "enabled" : "disabled");
2796 vec_add1 (status, 0);
2798 vat_json_init_object (&node);
2799 vat_json_object_add_string_copy (&node, "status", status);
2802 vat_json_object_add_string_copy (&node, "locator_set",
2803 mp->locator_set_name);
2808 vat_json_print (vam->ofp, &node);
2809 vat_json_free (&node);
2811 vam->retval = ntohl (mp->retval);
2812 vam->result_ready = 1;
2816 format_policer_type (u8 * s, va_list * va)
2818 u32 i = va_arg (*va, u32);
2820 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
2821 s = format (s, "1r2c");
2822 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
2823 s = format (s, "1r3c");
2824 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
2825 s = format (s, "2r3c-2698");
2826 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
2827 s = format (s, "2r3c-4115");
2828 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
2829 s = format (s, "2r3c-mef5cf1");
2831 s = format (s, "ILLEGAL");
2836 format_policer_rate_type (u8 * s, va_list * va)
2838 u32 i = va_arg (*va, u32);
2840 if (i == SSE2_QOS_RATE_KBPS)
2841 s = format (s, "kbps");
2842 else if (i == SSE2_QOS_RATE_PPS)
2843 s = format (s, "pps");
2845 s = format (s, "ILLEGAL");
2850 format_policer_round_type (u8 * s, va_list * va)
2852 u32 i = va_arg (*va, u32);
2854 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
2855 s = format (s, "closest");
2856 else if (i == SSE2_QOS_ROUND_TO_UP)
2857 s = format (s, "up");
2858 else if (i == SSE2_QOS_ROUND_TO_DOWN)
2859 s = format (s, "down");
2861 s = format (s, "ILLEGAL");
2866 format_policer_action_type (u8 * s, va_list * va)
2868 u32 i = va_arg (*va, u32);
2870 if (i == SSE2_QOS_ACTION_DROP)
2871 s = format (s, "drop");
2872 else if (i == SSE2_QOS_ACTION_TRANSMIT)
2873 s = format (s, "transmit");
2874 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2875 s = format (s, "mark-and-transmit");
2877 s = format (s, "ILLEGAL");
2882 format_dscp (u8 * s, va_list * va)
2884 u32 i = va_arg (*va, u32);
2889 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
2893 return format (s, "ILLEGAL");
2895 s = format (s, "%s", t);
2900 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
2902 vat_main_t *vam = &vat_main;
2903 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
2905 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2906 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
2908 conform_dscp_str = format (0, "");
2910 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2911 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
2913 exceed_dscp_str = format (0, "");
2915 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2916 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
2918 violate_dscp_str = format (0, "");
2920 fformat (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
2921 "rate type %U, round type %U, %s rate, %s color-aware, "
2922 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
2923 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
2924 "conform action %U%s, exceed action %U%s, violate action %U%s\n",
2926 format_policer_type, mp->type,
2929 clib_net_to_host_u64 (mp->cb),
2930 clib_net_to_host_u64 (mp->eb),
2931 format_policer_rate_type, mp->rate_type,
2932 format_policer_round_type, mp->round_type,
2933 mp->single_rate ? "single" : "dual",
2934 mp->color_aware ? "is" : "not",
2935 ntohl (mp->cir_tokens_per_period),
2936 ntohl (mp->pir_tokens_per_period),
2938 ntohl (mp->current_limit),
2939 ntohl (mp->current_bucket),
2940 ntohl (mp->extended_limit),
2941 ntohl (mp->extended_bucket),
2942 clib_net_to_host_u64 (mp->last_update_time),
2943 format_policer_action_type, mp->conform_action_type,
2945 format_policer_action_type, mp->exceed_action_type,
2947 format_policer_action_type, mp->violate_action_type,
2950 vec_free (conform_dscp_str);
2951 vec_free (exceed_dscp_str);
2952 vec_free (violate_dscp_str);
2955 static void vl_api_policer_details_t_handler_json
2956 (vl_api_policer_details_t * mp)
2958 vat_main_t *vam = &vat_main;
2959 vat_json_node_t *node;
2960 u8 *rate_type_str, *round_type_str, *type_str;
2961 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
2963 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
2965 format (0, "%U", format_policer_round_type, mp->round_type);
2966 type_str = format (0, "%U", format_policer_type, mp->type);
2967 conform_action_str = format (0, "%U", format_policer_action_type,
2968 mp->conform_action_type);
2969 exceed_action_str = format (0, "%U", format_policer_action_type,
2970 mp->exceed_action_type);
2971 violate_action_str = format (0, "%U", format_policer_action_type,
2972 mp->violate_action_type);
2974 if (VAT_JSON_ARRAY != vam->json_tree.type)
2976 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2977 vat_json_init_array (&vam->json_tree);
2979 node = vat_json_array_add (&vam->json_tree);
2981 vat_json_init_object (node);
2982 vat_json_object_add_string_copy (node, "name", mp->name);
2983 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
2984 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
2985 vat_json_object_add_uint (node, "cb", ntohl (mp->cb));
2986 vat_json_object_add_uint (node, "eb", ntohl (mp->eb));
2987 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
2988 vat_json_object_add_string_copy (node, "round_type", round_type_str);
2989 vat_json_object_add_string_copy (node, "type", type_str);
2990 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
2991 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
2992 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
2993 vat_json_object_add_uint (node, "cir_tokens_per_period",
2994 ntohl (mp->cir_tokens_per_period));
2995 vat_json_object_add_uint (node, "eir_tokens_per_period",
2996 ntohl (mp->pir_tokens_per_period));
2997 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
2998 vat_json_object_add_uint (node, "current_bucket",
2999 ntohl (mp->current_bucket));
3000 vat_json_object_add_uint (node, "extended_limit",
3001 ntohl (mp->extended_limit));
3002 vat_json_object_add_uint (node, "extended_bucket",
3003 ntohl (mp->extended_bucket));
3004 vat_json_object_add_uint (node, "last_update_time",
3005 ntohl (mp->last_update_time));
3006 vat_json_object_add_string_copy (node, "conform_action",
3007 conform_action_str);
3008 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3010 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
3011 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
3012 vec_free (dscp_str);
3014 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
3015 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3017 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
3018 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
3019 vec_free (dscp_str);
3021 vat_json_object_add_string_copy (node, "violate_action",
3022 violate_action_str);
3023 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3025 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
3026 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
3027 vec_free (dscp_str);
3030 vec_free (rate_type_str);
3031 vec_free (round_type_str);
3032 vec_free (type_str);
3033 vec_free (conform_action_str);
3034 vec_free (exceed_action_str);
3035 vec_free (violate_action_str);
3039 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
3042 vat_main_t *vam = &vat_main;
3043 int i, count = ntohl (mp->count);
3046 fformat (vam->ofp, "classify table ids (%d) : ", count);
3047 for (i = 0; i < count; i++)
3049 fformat (vam->ofp, "%d", ntohl (mp->ids[i]));
3050 fformat (vam->ofp, (i < count - 1) ? "," : "\n");
3052 vam->retval = ntohl (mp->retval);
3053 vam->result_ready = 1;
3057 vl_api_classify_table_ids_reply_t_handler_json
3058 (vl_api_classify_table_ids_reply_t * mp)
3060 vat_main_t *vam = &vat_main;
3061 int i, count = ntohl (mp->count);
3065 vat_json_node_t node;
3067 vat_json_init_object (&node);
3068 for (i = 0; i < count; i++)
3070 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
3072 vat_json_print (vam->ofp, &node);
3073 vat_json_free (&node);
3075 vam->retval = ntohl (mp->retval);
3076 vam->result_ready = 1;
3080 vl_api_classify_table_by_interface_reply_t_handler
3081 (vl_api_classify_table_by_interface_reply_t * mp)
3083 vat_main_t *vam = &vat_main;
3086 table_id = ntohl (mp->l2_table_id);
3088 fformat (vam->ofp, "l2 table id : %d\n", table_id);
3090 fformat (vam->ofp, "l2 table id : No input ACL tables configured\n");
3091 table_id = ntohl (mp->ip4_table_id);
3093 fformat (vam->ofp, "ip4 table id : %d\n", table_id);
3095 fformat (vam->ofp, "ip4 table id : No input ACL tables configured\n");
3096 table_id = ntohl (mp->ip6_table_id);
3098 fformat (vam->ofp, "ip6 table id : %d\n", table_id);
3100 fformat (vam->ofp, "ip6 table id : No input ACL tables configured\n");
3101 vam->retval = ntohl (mp->retval);
3102 vam->result_ready = 1;
3106 vl_api_classify_table_by_interface_reply_t_handler_json
3107 (vl_api_classify_table_by_interface_reply_t * mp)
3109 vat_main_t *vam = &vat_main;
3110 vat_json_node_t node;
3112 vat_json_init_object (&node);
3114 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
3115 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
3116 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
3118 vat_json_print (vam->ofp, &node);
3119 vat_json_free (&node);
3121 vam->retval = ntohl (mp->retval);
3122 vam->result_ready = 1;
3125 static void vl_api_policer_add_del_reply_t_handler
3126 (vl_api_policer_add_del_reply_t * mp)
3128 vat_main_t *vam = &vat_main;
3129 i32 retval = ntohl (mp->retval);
3130 if (vam->async_mode)
3132 vam->async_errors += (retval < 0);
3136 vam->retval = retval;
3137 vam->result_ready = 1;
3138 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
3140 * Note: this is just barely thread-safe, depends on
3141 * the main thread spinning waiting for an answer...
3143 errmsg ("policer index %d\n", ntohl (mp->policer_index));
3147 static void vl_api_policer_add_del_reply_t_handler_json
3148 (vl_api_policer_add_del_reply_t * mp)
3150 vat_main_t *vam = &vat_main;
3151 vat_json_node_t node;
3153 vat_json_init_object (&node);
3154 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3155 vat_json_object_add_uint (&node, "policer_index",
3156 ntohl (mp->policer_index));
3158 vat_json_print (vam->ofp, &node);
3159 vat_json_free (&node);
3161 vam->retval = ntohl (mp->retval);
3162 vam->result_ready = 1;
3165 /* Format hex dump. */
3167 format_hex_bytes (u8 * s, va_list * va)
3169 u8 *bytes = va_arg (*va, u8 *);
3170 int n_bytes = va_arg (*va, int);
3173 /* Print short or long form depending on byte count. */
3174 uword short_form = n_bytes <= 32;
3175 uword indent = format_get_indent (s);
3180 for (i = 0; i < n_bytes; i++)
3182 if (!short_form && (i % 32) == 0)
3183 s = format (s, "%08x: ", i);
3184 s = format (s, "%02x", bytes[i]);
3185 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
3186 s = format (s, "\n%U", format_white_space, indent);
3193 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
3196 vat_main_t *vam = &vat_main;
3197 i32 retval = ntohl (mp->retval);
3200 fformat (vam->ofp, "classify table info :\n");
3201 fformat (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d\n",
3202 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
3203 ntohl (mp->miss_next_index));
3204 fformat (vam->ofp, "nbuckets: %d skip: %d match: %d\n",
3205 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
3206 ntohl (mp->match_n_vectors));
3207 fformat (vam->ofp, "mask: %U\n", format_hex_bytes, mp->mask,
3208 ntohl (mp->mask_length));
3210 vam->retval = retval;
3211 vam->result_ready = 1;
3215 vl_api_classify_table_info_reply_t_handler_json
3216 (vl_api_classify_table_info_reply_t * mp)
3218 vat_main_t *vam = &vat_main;
3219 vat_json_node_t node;
3221 i32 retval = ntohl (mp->retval);
3224 vat_json_init_object (&node);
3226 vat_json_object_add_int (&node, "sessions",
3227 ntohl (mp->active_sessions));
3228 vat_json_object_add_int (&node, "nexttbl",
3229 ntohl (mp->next_table_index));
3230 vat_json_object_add_int (&node, "nextnode",
3231 ntohl (mp->miss_next_index));
3232 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
3233 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
3234 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
3235 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
3236 ntohl (mp->mask_length), 0);
3237 vat_json_object_add_string_copy (&node, "mask", s);
3239 vat_json_print (vam->ofp, &node);
3240 vat_json_free (&node);
3242 vam->retval = ntohl (mp->retval);
3243 vam->result_ready = 1;
3247 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
3250 vat_main_t *vam = &vat_main;
3252 fformat (vam->ofp, "next_index: %d advance: %d opaque: %d ",
3253 ntohl (mp->hit_next_index), ntohl (mp->advance),
3254 ntohl (mp->opaque_index));
3255 fformat (vam->ofp, "mask: %U\n", format_hex_bytes, mp->match,
3256 ntohl (mp->match_length));
3260 vl_api_classify_session_details_t_handler_json
3261 (vl_api_classify_session_details_t * mp)
3263 vat_main_t *vam = &vat_main;
3264 vat_json_node_t *node = NULL;
3266 if (VAT_JSON_ARRAY != vam->json_tree.type)
3268 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3269 vat_json_init_array (&vam->json_tree);
3271 node = vat_json_array_add (&vam->json_tree);
3273 vat_json_init_object (node);
3274 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
3275 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
3276 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
3278 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
3280 vat_json_object_add_string_copy (node, "match", s);
3283 static void vl_api_pg_create_interface_reply_t_handler
3284 (vl_api_pg_create_interface_reply_t * mp)
3286 vat_main_t *vam = &vat_main;
3288 vam->retval = ntohl (mp->retval);
3289 vam->result_ready = 1;
3292 static void vl_api_pg_create_interface_reply_t_handler_json
3293 (vl_api_pg_create_interface_reply_t * mp)
3295 vat_main_t *vam = &vat_main;
3296 vat_json_node_t node;
3298 i32 retval = ntohl (mp->retval);
3301 vat_json_init_object (&node);
3303 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
3305 vat_json_print (vam->ofp, &node);
3306 vat_json_free (&node);
3308 vam->retval = ntohl (mp->retval);
3309 vam->result_ready = 1;
3312 static void vl_api_policer_classify_details_t_handler
3313 (vl_api_policer_classify_details_t * mp)
3315 vat_main_t *vam = &vat_main;
3317 fformat (vam->ofp, "%10d%20d\n", ntohl (mp->sw_if_index),
3318 ntohl (mp->table_index));
3321 static void vl_api_policer_classify_details_t_handler_json
3322 (vl_api_policer_classify_details_t * mp)
3324 vat_main_t *vam = &vat_main;
3325 vat_json_node_t *node;
3327 if (VAT_JSON_ARRAY != vam->json_tree.type)
3329 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3330 vat_json_init_array (&vam->json_tree);
3332 node = vat_json_array_add (&vam->json_tree);
3334 vat_json_init_object (node);
3335 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
3336 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
3339 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler
3340 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3342 vat_main_t *vam = &vat_main;
3343 i32 retval = ntohl (mp->retval);
3344 if (vam->async_mode)
3346 vam->async_errors += (retval < 0);
3350 vam->retval = retval;
3351 vam->sw_if_index = ntohl (mp->sw_if_index);
3352 vam->result_ready = 1;
3356 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler_json
3357 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3359 vat_main_t *vam = &vat_main;
3360 vat_json_node_t node;
3362 vat_json_init_object (&node);
3363 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3364 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
3366 vat_json_print (vam->ofp, &node);
3367 vat_json_free (&node);
3369 vam->retval = ntohl (mp->retval);
3370 vam->result_ready = 1;
3373 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
3374 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
3375 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
3376 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
3379 * Generate boilerplate reply handlers, which
3380 * dig the return value out of the xxx_reply_t API message,
3381 * stick it into vam->retval, and set vam->result_ready
3383 * Could also do this by pointing N message decode slots at
3384 * a single function, but that could break in subtle ways.
3387 #define foreach_standard_reply_retval_handler \
3388 _(sw_interface_set_flags_reply) \
3389 _(sw_interface_add_del_address_reply) \
3390 _(sw_interface_set_table_reply) \
3391 _(sw_interface_set_vpath_reply) \
3392 _(sw_interface_set_l2_bridge_reply) \
3393 _(sw_interface_set_dpdk_hqos_pipe_reply) \
3394 _(sw_interface_set_dpdk_hqos_subport_reply) \
3395 _(sw_interface_set_dpdk_hqos_tctbl_reply) \
3396 _(bridge_domain_add_del_reply) \
3397 _(sw_interface_set_l2_xconnect_reply) \
3398 _(l2fib_add_del_reply) \
3399 _(ip_add_del_route_reply) \
3400 _(proxy_arp_add_del_reply) \
3401 _(proxy_arp_intfc_enable_disable_reply) \
3402 _(mpls_add_del_encap_reply) \
3403 _(mpls_add_del_decap_reply) \
3404 _(mpls_ethernet_add_del_tunnel_2_reply) \
3405 _(sw_interface_set_unnumbered_reply) \
3406 _(ip_neighbor_add_del_reply) \
3407 _(reset_vrf_reply) \
3408 _(oam_add_del_reply) \
3409 _(reset_fib_reply) \
3410 _(dhcp_proxy_config_reply) \
3411 _(dhcp_proxy_config_2_reply) \
3412 _(dhcp_proxy_set_vss_reply) \
3413 _(dhcp_client_config_reply) \
3414 _(set_ip_flow_hash_reply) \
3415 _(sw_interface_ip6_enable_disable_reply) \
3416 _(sw_interface_ip6_set_link_local_address_reply) \
3417 _(sw_interface_ip6nd_ra_prefix_reply) \
3418 _(sw_interface_ip6nd_ra_config_reply) \
3419 _(set_arp_neighbor_limit_reply) \
3420 _(l2_patch_add_del_reply) \
3421 _(sr_tunnel_add_del_reply) \
3422 _(sr_policy_add_del_reply) \
3423 _(sr_multicast_map_add_del_reply) \
3424 _(classify_add_del_session_reply) \
3425 _(classify_set_interface_ip_table_reply) \
3426 _(classify_set_interface_l2_tables_reply) \
3427 _(l2tpv3_set_tunnel_cookies_reply) \
3428 _(l2tpv3_interface_enable_disable_reply) \
3429 _(l2tpv3_set_lookup_key_reply) \
3430 _(l2_fib_clear_table_reply) \
3431 _(l2_interface_efp_filter_reply) \
3432 _(l2_interface_vlan_tag_rewrite_reply) \
3433 _(modify_vhost_user_if_reply) \
3434 _(delete_vhost_user_if_reply) \
3435 _(want_ip4_arp_events_reply) \
3436 _(want_ip6_nd_events_reply) \
3437 _(input_acl_set_interface_reply) \
3438 _(ipsec_spd_add_del_reply) \
3439 _(ipsec_interface_add_del_spd_reply) \
3440 _(ipsec_spd_add_del_entry_reply) \
3441 _(ipsec_sad_add_del_entry_reply) \
3442 _(ipsec_sa_set_key_reply) \
3443 _(ikev2_profile_add_del_reply) \
3444 _(ikev2_profile_set_auth_reply) \
3445 _(ikev2_profile_set_id_reply) \
3446 _(ikev2_profile_set_ts_reply) \
3447 _(ikev2_set_local_key_reply) \
3448 _(delete_loopback_reply) \
3449 _(bd_ip_mac_add_del_reply) \
3450 _(map_del_domain_reply) \
3451 _(map_add_del_rule_reply) \
3452 _(want_interface_events_reply) \
3453 _(want_stats_reply) \
3454 _(cop_interface_enable_disable_reply) \
3455 _(cop_whitelist_enable_disable_reply) \
3456 _(sw_interface_clear_stats_reply) \
3457 _(ioam_enable_reply) \
3458 _(ioam_disable_reply) \
3459 _(lisp_add_del_locator_reply) \
3460 _(lisp_add_del_local_eid_reply) \
3461 _(lisp_add_del_remote_mapping_reply) \
3462 _(lisp_add_del_adjacency_reply) \
3463 _(lisp_gpe_add_del_fwd_entry_reply) \
3464 _(lisp_add_del_map_resolver_reply) \
3465 _(lisp_gpe_enable_disable_reply) \
3466 _(lisp_gpe_add_del_iface_reply) \
3467 _(lisp_enable_disable_reply) \
3468 _(lisp_pitr_set_locator_set_reply) \
3469 _(lisp_map_request_mode_reply) \
3470 _(lisp_add_del_map_request_itr_rlocs_reply) \
3471 _(lisp_eid_table_add_del_map_reply) \
3472 _(vxlan_gpe_add_del_tunnel_reply) \
3473 _(af_packet_delete_reply) \
3474 _(policer_classify_set_interface_reply) \
3475 _(netmap_create_reply) \
3476 _(netmap_delete_reply) \
3477 _(set_ipfix_exporter_reply) \
3478 _(set_ipfix_classify_stream_reply) \
3479 _(ipfix_classify_table_add_del_reply) \
3480 _(pg_capture_reply) \
3481 _(pg_enable_disable_reply) \
3482 _(ip_source_and_port_range_check_add_del_reply) \
3483 _(ip_source_and_port_range_check_interface_add_del_reply)\
3484 _(delete_subif_reply)
3487 static void vl_api_##n##_t_handler \
3488 (vl_api_##n##_t * mp) \
3490 vat_main_t * vam = &vat_main; \
3491 i32 retval = ntohl(mp->retval); \
3492 if (vam->async_mode) { \
3493 vam->async_errors += (retval < 0); \
3495 vam->retval = retval; \
3496 vam->result_ready = 1; \
3499 foreach_standard_reply_retval_handler;
3503 static void vl_api_##n##_t_handler_json \
3504 (vl_api_##n##_t * mp) \
3506 vat_main_t * vam = &vat_main; \
3507 vat_json_node_t node; \
3508 vat_json_init_object(&node); \
3509 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
3510 vat_json_print(vam->ofp, &node); \
3511 vam->retval = ntohl(mp->retval); \
3512 vam->result_ready = 1; \
3514 foreach_standard_reply_retval_handler;
3518 * Table of message reply handlers, must include boilerplate handlers
3522 #define foreach_vpe_api_reply_msg \
3523 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
3524 _(SW_INTERFACE_DETAILS, sw_interface_details) \
3525 _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
3526 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
3527 _(CONTROL_PING_REPLY, control_ping_reply) \
3528 _(CLI_REPLY, cli_reply) \
3529 _(CLI_INBAND_REPLY, cli_inband_reply) \
3530 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
3531 sw_interface_add_del_address_reply) \
3532 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
3533 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
3534 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
3535 sw_interface_set_l2_xconnect_reply) \
3536 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
3537 sw_interface_set_l2_bridge_reply) \
3538 _(SW_INTERFACE_SET_DPDK_HQOS_PIPE_REPLY, \
3539 sw_interface_set_dpdk_hqos_pipe_reply) \
3540 _(SW_INTERFACE_SET_DPDK_HQOS_SUBPORT_REPLY, \
3541 sw_interface_set_dpdk_hqos_subport_reply) \
3542 _(SW_INTERFACE_SET_DPDK_HQOS_TCTBL_REPLY, \
3543 sw_interface_set_dpdk_hqos_tctbl_reply) \
3544 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
3545 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
3546 _(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
3547 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
3548 _(L2_FLAGS_REPLY, l2_flags_reply) \
3549 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
3550 _(TAP_CONNECT_REPLY, tap_connect_reply) \
3551 _(TAP_MODIFY_REPLY, tap_modify_reply) \
3552 _(TAP_DELETE_REPLY, tap_delete_reply) \
3553 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
3554 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
3555 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
3556 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
3557 proxy_arp_intfc_enable_disable_reply) \
3558 _(MPLS_ADD_DEL_ENCAP_REPLY, mpls_add_del_encap_reply) \
3559 _(MPLS_ADD_DEL_DECAP_REPLY, mpls_add_del_decap_reply) \
3560 _(MPLS_GRE_ADD_DEL_TUNNEL_REPLY, mpls_gre_add_del_tunnel_reply) \
3561 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_REPLY, \
3562 mpls_ethernet_add_del_tunnel_reply) \
3563 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_2_REPLY, \
3564 mpls_ethernet_add_del_tunnel_2_reply) \
3565 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
3566 sw_interface_set_unnumbered_reply) \
3567 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
3568 _(RESET_VRF_REPLY, reset_vrf_reply) \
3569 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
3570 _(CREATE_SUBIF_REPLY, create_subif_reply) \
3571 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
3572 _(RESET_FIB_REPLY, reset_fib_reply) \
3573 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
3574 _(DHCP_PROXY_CONFIG_2_REPLY, dhcp_proxy_config_2_reply) \
3575 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
3576 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
3577 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
3578 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
3579 sw_interface_ip6_enable_disable_reply) \
3580 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
3581 sw_interface_ip6_set_link_local_address_reply) \
3582 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
3583 sw_interface_ip6nd_ra_prefix_reply) \
3584 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
3585 sw_interface_ip6nd_ra_config_reply) \
3586 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
3587 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
3588 _(SR_TUNNEL_ADD_DEL_REPLY, sr_tunnel_add_del_reply) \
3589 _(SR_POLICY_ADD_DEL_REPLY, sr_policy_add_del_reply) \
3590 _(SR_MULTICAST_MAP_ADD_DEL_REPLY, sr_multicast_map_add_del_reply) \
3591 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
3592 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
3593 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
3594 classify_set_interface_ip_table_reply) \
3595 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
3596 classify_set_interface_l2_tables_reply) \
3597 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
3598 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
3599 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
3600 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
3601 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
3602 l2tpv3_interface_enable_disable_reply) \
3603 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
3604 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
3605 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
3606 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
3607 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
3608 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
3609 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
3610 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
3611 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
3612 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
3613 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
3614 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
3615 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
3616 _(SHOW_VERSION_REPLY, show_version_reply) \
3617 _(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
3618 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
3619 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
3620 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
3621 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
3622 _(IP4_ARP_EVENT, ip4_arp_event) \
3623 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
3624 _(IP6_ND_EVENT, ip6_nd_event) \
3625 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
3626 _(IP_ADDRESS_DETAILS, ip_address_details) \
3627 _(IP_DETAILS, ip_details) \
3628 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
3629 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
3630 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
3631 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
3632 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
3633 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
3634 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
3635 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
3636 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
3637 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
3638 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
3639 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
3640 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
3641 _(VNET_INTERFACE_COUNTERS, vnet_interface_counters) \
3642 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
3643 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
3644 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
3645 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
3646 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
3647 _(MAP_DOMAIN_DETAILS, map_domain_details) \
3648 _(MAP_RULE_DETAILS, map_rule_details) \
3649 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
3650 _(WANT_STATS_REPLY, want_stats_reply) \
3651 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
3652 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
3653 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
3654 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
3655 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
3656 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
3657 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
3658 _(LISP_ADD_DEL_LOCATOR_SET_REPLY, lisp_add_del_locator_set_reply) \
3659 _(LISP_ADD_DEL_LOCATOR_REPLY, lisp_add_del_locator_reply) \
3660 _(LISP_ADD_DEL_LOCAL_EID_REPLY, lisp_add_del_local_eid_reply) \
3661 _(LISP_ADD_DEL_REMOTE_MAPPING_REPLY, lisp_add_del_remote_mapping_reply) \
3662 _(LISP_ADD_DEL_ADJACENCY_REPLY, lisp_add_del_adjacency_reply) \
3663 _(LISP_GPE_ADD_DEL_FWD_ENTRY_REPLY, lisp_gpe_add_del_fwd_entry_reply) \
3664 _(LISP_ADD_DEL_MAP_RESOLVER_REPLY, lisp_add_del_map_resolver_reply) \
3665 _(LISP_GPE_ENABLE_DISABLE_REPLY, lisp_gpe_enable_disable_reply) \
3666 _(LISP_ENABLE_DISABLE_REPLY, lisp_enable_disable_reply) \
3667 _(LISP_PITR_SET_LOCATOR_SET_REPLY, lisp_pitr_set_locator_set_reply) \
3668 _(LISP_MAP_REQUEST_MODE_REPLY, lisp_map_request_mode_reply) \
3669 _(LISP_EID_TABLE_ADD_DEL_MAP_REPLY, lisp_eid_table_add_del_map_reply) \
3670 _(LISP_GPE_ADD_DEL_IFACE_REPLY, lisp_gpe_add_del_iface_reply) \
3671 _(LISP_LOCATOR_SET_DETAILS, lisp_locator_set_details) \
3672 _(LISP_LOCATOR_DETAILS, lisp_locator_details) \
3673 _(LISP_EID_TABLE_DETAILS, lisp_eid_table_details) \
3674 _(LISP_EID_TABLE_MAP_DETAILS, lisp_eid_table_map_details) \
3675 _(LISP_EID_TABLE_VNI_DETAILS, lisp_eid_table_vni_details) \
3676 _(LISP_GPE_TUNNEL_DETAILS, lisp_gpe_tunnel_details) \
3677 _(LISP_MAP_RESOLVER_DETAILS, lisp_map_resolver_details) \
3678 _(SHOW_LISP_STATUS_REPLY, show_lisp_status_reply) \
3679 _(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
3680 lisp_add_del_map_request_itr_rlocs_reply) \
3681 _(LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
3682 lisp_get_map_request_itr_rlocs_reply) \
3683 _(SHOW_LISP_PITR_REPLY, show_lisp_pitr_reply) \
3684 _(SHOW_LISP_MAP_REQUEST_MODE_REPLY, show_lisp_map_request_mode_reply) \
3685 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
3686 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
3687 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
3688 _(POLICER_DETAILS, policer_details) \
3689 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
3690 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
3691 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
3692 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
3693 _(MPLS_GRE_TUNNEL_DETAILS, mpls_gre_tunnel_details) \
3694 _(MPLS_ETH_TUNNEL_DETAILS, mpls_eth_tunnel_details) \
3695 _(MPLS_FIB_ENCAP_DETAILS, mpls_fib_encap_details) \
3696 _(MPLS_FIB_DECAP_DETAILS, mpls_fib_decap_details) \
3697 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
3698 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
3699 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
3700 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
3701 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
3702 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
3703 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
3704 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
3705 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
3706 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
3707 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
3708 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
3709 _(PG_CAPTURE_REPLY, pg_capture_reply) \
3710 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
3711 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
3712 ip_source_and_port_range_check_add_del_reply) \
3713 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
3714 ip_source_and_port_range_check_interface_add_del_reply) \
3715 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
3716 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
3717 _(DELETE_SUBIF_REPLY, delete_subif_reply)
3719 /* M: construct, but don't yet send a message */
3723 vam->result_ready = 0; \
3724 mp = vl_msg_api_alloc(sizeof(*mp)); \
3725 memset (mp, 0, sizeof (*mp)); \
3726 mp->_vl_msg_id = ntohs (VL_API_##T); \
3727 mp->client_index = vam->my_client_index; \
3732 vam->result_ready = 0; \
3733 mp = vl_msg_api_alloc(sizeof(*mp)+(n)); \
3734 memset (mp, 0, sizeof (*mp)); \
3735 mp->_vl_msg_id = ntohs (VL_API_##T); \
3736 mp->client_index = vam->my_client_index; \
3740 /* S: send a message */
3741 #define S (vl_msg_api_send_shmem (vam->vl_input_queue, (u8 *)&mp))
3743 /* W: wait for results, with timeout */
3746 timeout = vat_time_now (vam) + 1.0; \
3748 while (vat_time_now (vam) < timeout) { \
3749 if (vam->result_ready == 1) { \
3750 return (vam->retval); \
3756 /* W2: wait for results, with timeout */
3759 timeout = vat_time_now (vam) + 1.0; \
3761 while (vat_time_now (vam) < timeout) { \
3762 if (vam->result_ready == 1) { \
3764 return (vam->retval); \
3777 #define STR_VTR_OP_CASE(op) \
3778 case L2_VTR_ ## op: \
3782 str_vtr_op (u32 vtr_op)
3786 STR_VTR_OP_CASE (DISABLED);
3787 STR_VTR_OP_CASE (PUSH_1);
3788 STR_VTR_OP_CASE (PUSH_2);
3789 STR_VTR_OP_CASE (POP_1);
3790 STR_VTR_OP_CASE (POP_2);
3791 STR_VTR_OP_CASE (TRANSLATE_1_1);
3792 STR_VTR_OP_CASE (TRANSLATE_1_2);
3793 STR_VTR_OP_CASE (TRANSLATE_2_1);
3794 STR_VTR_OP_CASE (TRANSLATE_2_2);
3801 dump_sub_interface_table (vat_main_t * vam)
3803 const sw_interface_subif_t *sub = NULL;
3805 if (vam->json_output)
3808 ("JSON output supported only for VPE API calls and dump_stats_table");
3813 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s\n",
3814 "Interface", "sw_if_index",
3815 "sub id", "dot1ad", "tags", "outer id",
3816 "inner id", "exact", "default", "outer any", "inner any");
3818 vec_foreach (sub, vam->sw_if_subif_table)
3821 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d\n",
3822 sub->interface_name,
3824 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
3825 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
3826 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
3827 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
3828 if (sub->vtr_op != L2_VTR_DISABLED)
3831 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
3832 "tag1: %d tag2: %d ]\n",
3833 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
3834 sub->vtr_tag1, sub->vtr_tag2);
3842 name_sort_cmp (void *a1, void *a2)
3844 name_sort_t *n1 = a1;
3845 name_sort_t *n2 = a2;
3847 return strcmp ((char *) n1->name, (char *) n2->name);
3851 dump_interface_table (vat_main_t * vam)
3854 name_sort_t *nses = 0, *ns;
3856 if (vam->json_output)
3859 ("JSON output supported only for VPE API calls and dump_stats_table");
3864 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
3866 vec_add2 (nses, ns, 1);
3867 ns->name = (u8 *)(p->key);
3868 ns->value = (u32) p->value[0];
3872 vec_sort_with_function (nses, name_sort_cmp);
3874 fformat (vam->ofp, "%-25s%-15s\n", "Interface", "sw_if_index");
3875 vec_foreach (ns, nses)
3877 fformat (vam->ofp, "%-25s%-15d\n", ns->name, ns->value);
3884 dump_ip_table (vat_main_t * vam, int is_ipv6)
3886 const ip_details_t *det = NULL;
3887 const ip_address_details_t *address = NULL;
3890 fformat (vam->ofp, "%-12s\n", "sw_if_index");
3892 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
3899 fformat (vam->ofp, "%-12d\n", i);
3901 " %-30s%-13s\n", "Address", "Prefix length");
3906 vec_foreach (address, det->addr)
3910 is_ipv6 ? format_ip6_address : format_ip4_address,
3911 address->ip, address->prefix_length);
3919 dump_ipv4_table (vat_main_t * vam)
3921 if (vam->json_output)
3924 ("JSON output supported only for VPE API calls and dump_stats_table");
3928 return dump_ip_table (vam, 0);
3932 dump_ipv6_table (vat_main_t * vam)
3934 if (vam->json_output)
3937 ("JSON output supported only for VPE API calls and dump_stats_table");
3941 return dump_ip_table (vam, 1);
3945 counter_type_to_str (u8 counter_type, u8 is_combined)
3949 switch (counter_type)
3951 case VNET_INTERFACE_COUNTER_DROP:
3953 case VNET_INTERFACE_COUNTER_PUNT:
3955 case VNET_INTERFACE_COUNTER_IP4:
3957 case VNET_INTERFACE_COUNTER_IP6:
3959 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
3961 case VNET_INTERFACE_COUNTER_RX_MISS:
3963 case VNET_INTERFACE_COUNTER_RX_ERROR:
3965 case VNET_INTERFACE_COUNTER_TX_ERROR:
3968 return "INVALID-COUNTER-TYPE";
3973 switch (counter_type)
3975 case VNET_INTERFACE_COUNTER_RX:
3977 case VNET_INTERFACE_COUNTER_TX:
3980 return "INVALID-COUNTER-TYPE";
3986 dump_stats_table (vat_main_t * vam)
3988 vat_json_node_t node;
3989 vat_json_node_t *msg_array;
3990 vat_json_node_t *msg;
3991 vat_json_node_t *counter_array;
3992 vat_json_node_t *counter;
3993 interface_counter_t c;
3995 ip4_fib_counter_t *c4;
3996 ip6_fib_counter_t *c6;
3999 if (!vam->json_output)
4001 clib_warning ("dump_stats_table supported only in JSON format");
4005 vat_json_init_object (&node);
4007 /* interface counters */
4008 msg_array = vat_json_object_add (&node, "interface_counters");
4009 vat_json_init_array (msg_array);
4010 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
4012 msg = vat_json_array_add (msg_array);
4013 vat_json_init_object (msg);
4014 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4015 (u8 *) counter_type_to_str (i, 0));
4016 vat_json_object_add_int (msg, "is_combined", 0);
4017 counter_array = vat_json_object_add (msg, "data");
4018 vat_json_init_array (counter_array);
4019 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
4021 packets = vam->simple_interface_counters[i][j];
4022 vat_json_array_add_uint (counter_array, packets);
4025 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
4027 msg = vat_json_array_add (msg_array);
4028 vat_json_init_object (msg);
4029 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4030 (u8 *) counter_type_to_str (i, 1));
4031 vat_json_object_add_int (msg, "is_combined", 1);
4032 counter_array = vat_json_object_add (msg, "data");
4033 vat_json_init_array (counter_array);
4034 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
4036 c = vam->combined_interface_counters[i][j];
4037 counter = vat_json_array_add (counter_array);
4038 vat_json_init_object (counter);
4039 vat_json_object_add_uint (counter, "packets", c.packets);
4040 vat_json_object_add_uint (counter, "bytes", c.bytes);
4044 /* ip4 fib counters */
4045 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
4046 vat_json_init_array (msg_array);
4047 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
4049 msg = vat_json_array_add (msg_array);
4050 vat_json_init_object (msg);
4051 vat_json_object_add_uint (msg, "vrf_id",
4052 vam->ip4_fib_counters_vrf_id_by_index[i]);
4053 counter_array = vat_json_object_add (msg, "c");
4054 vat_json_init_array (counter_array);
4055 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
4057 counter = vat_json_array_add (counter_array);
4058 vat_json_init_object (counter);
4059 c4 = &vam->ip4_fib_counters[i][j];
4060 vat_json_object_add_ip4 (counter, "address", c4->address);
4061 vat_json_object_add_uint (counter, "address_length",
4062 c4->address_length);
4063 vat_json_object_add_uint (counter, "packets", c4->packets);
4064 vat_json_object_add_uint (counter, "bytes", c4->bytes);
4068 /* ip6 fib counters */
4069 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
4070 vat_json_init_array (msg_array);
4071 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
4073 msg = vat_json_array_add (msg_array);
4074 vat_json_init_object (msg);
4075 vat_json_object_add_uint (msg, "vrf_id",
4076 vam->ip6_fib_counters_vrf_id_by_index[i]);
4077 counter_array = vat_json_object_add (msg, "c");
4078 vat_json_init_array (counter_array);
4079 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
4081 counter = vat_json_array_add (counter_array);
4082 vat_json_init_object (counter);
4083 c6 = &vam->ip6_fib_counters[i][j];
4084 vat_json_object_add_ip6 (counter, "address", c6->address);
4085 vat_json_object_add_uint (counter, "address_length",
4086 c6->address_length);
4087 vat_json_object_add_uint (counter, "packets", c6->packets);
4088 vat_json_object_add_uint (counter, "bytes", c6->bytes);
4092 vat_json_print (vam->ofp, &node);
4093 vat_json_free (&node);
4099 exec (vat_main_t * vam)
4101 api_main_t *am = &api_main;
4102 vl_api_cli_request_t *mp;
4106 unformat_input_t *i = vam->input;
4108 if (vec_len (i->buffer) == 0)
4111 if (vam->exec_mode == 0 && unformat (i, "mode"))
4116 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4123 M (CLI_REQUEST, cli_request);
4126 * Copy cmd into shared memory.
4127 * In order for the CLI command to work, it
4128 * must be a vector ending in \n, not a C-string ending
4131 pthread_mutex_lock (&am->vlib_rp->mutex);
4132 oldheap = svm_push_data_heap (am->vlib_rp);
4134 vec_validate (cmd, vec_len (vam->input->buffer) - 1);
4135 clib_memcpy (cmd, vam->input->buffer, vec_len (vam->input->buffer));
4137 svm_pop_heap (oldheap);
4138 pthread_mutex_unlock (&am->vlib_rp->mutex);
4140 mp->cmd_in_shmem = (u64) cmd;
4142 timeout = vat_time_now (vam) + 10.0;
4144 while (vat_time_now (vam) < timeout)
4146 if (vam->result_ready == 1)
4149 if (vam->shmem_result != NULL)
4150 fformat (vam->ofp, "%s", vam->shmem_result);
4151 pthread_mutex_lock (&am->vlib_rp->mutex);
4152 oldheap = svm_push_data_heap (am->vlib_rp);
4154 free_me = (u8 *) vam->shmem_result;
4157 svm_pop_heap (oldheap);
4158 pthread_mutex_unlock (&am->vlib_rp->mutex);
4166 * Future replacement of exec() that passes CLI buffers directly in
4167 * the API messages instead of an additional shared memory area.
4170 exec_inband (vat_main_t * vam)
4172 vl_api_cli_inband_t *mp;
4174 unformat_input_t *i = vam->input;
4176 if (vec_len (i->buffer) == 0)
4179 if (vam->exec_mode == 0 && unformat (i, "mode"))
4184 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4191 * In order for the CLI command to work, it
4192 * must be a vector ending in \n, not a C-string ending
4195 u32 len = vec_len (vam->input->buffer);
4196 M2 (CLI_INBAND, cli_inband, len);
4197 clib_memcpy (mp->cmd, vam->input->buffer, len);
4198 mp->length = htonl (len);
4201 W2 (fformat (vam->ofp, "%s", vam->cmd_reply));
4205 api_create_loopback (vat_main_t * vam)
4207 unformat_input_t *i = vam->input;
4208 vl_api_create_loopback_t *mp;
4213 memset (mac_address, 0, sizeof (mac_address));
4215 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4217 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
4223 /* Construct the API message */
4224 M (CREATE_LOOPBACK, create_loopback);
4226 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
4233 api_delete_loopback (vat_main_t * vam)
4235 unformat_input_t *i = vam->input;
4236 vl_api_delete_loopback_t *mp;
4238 u32 sw_if_index = ~0;
4240 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4242 if (unformat (i, "sw_if_index %d", &sw_if_index))
4248 if (sw_if_index == ~0)
4250 errmsg ("missing sw_if_index\n");
4254 /* Construct the API message */
4255 M (DELETE_LOOPBACK, delete_loopback);
4256 mp->sw_if_index = ntohl (sw_if_index);
4263 api_want_stats (vat_main_t * vam)
4265 unformat_input_t *i = vam->input;
4266 vl_api_want_stats_t *mp;
4270 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4272 if (unformat (i, "enable"))
4274 else if (unformat (i, "disable"))
4282 errmsg ("missing enable|disable\n");
4286 M (WANT_STATS, want_stats);
4287 mp->enable_disable = enable;
4294 api_want_interface_events (vat_main_t * vam)
4296 unformat_input_t *i = vam->input;
4297 vl_api_want_interface_events_t *mp;
4301 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4303 if (unformat (i, "enable"))
4305 else if (unformat (i, "disable"))
4313 errmsg ("missing enable|disable\n");
4317 M (WANT_INTERFACE_EVENTS, want_interface_events);
4318 mp->enable_disable = enable;
4320 vam->interface_event_display = enable;
4327 /* Note: non-static, called once to set up the initial intfc table */
4329 api_sw_interface_dump (vat_main_t * vam)
4331 vl_api_sw_interface_dump_t *mp;
4334 name_sort_t *nses = 0, *ns;
4335 sw_interface_subif_t *sub = NULL;
4337 /* Toss the old name table */
4339 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4341 vec_add2 (nses, ns, 1);
4342 ns->name = (u8 *)(p->key);
4343 ns->value = (u32) p->value[0];
4347 hash_free (vam->sw_if_index_by_interface_name);
4349 vec_foreach (ns, nses) vec_free (ns->name);
4353 vec_foreach (sub, vam->sw_if_subif_table)
4355 vec_free (sub->interface_name);
4357 vec_free (vam->sw_if_subif_table);
4359 /* recreate the interface name hash table */
4360 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
4362 /* Get list of ethernets */
4363 M (SW_INTERFACE_DUMP, sw_interface_dump);
4364 mp->name_filter_valid = 1;
4365 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
4368 /* and local / loopback interfaces */
4369 M (SW_INTERFACE_DUMP, sw_interface_dump);
4370 mp->name_filter_valid = 1;
4371 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
4375 /* and vxlan-gpe tunnel interfaces */
4376 M (SW_INTERFACE_DUMP, sw_interface_dump);
4377 mp->name_filter_valid = 1;
4378 strncpy ((char *) mp->name_filter, "vxlan_gpe",
4379 sizeof (mp->name_filter) - 1);
4382 /* and vxlan tunnel interfaces */
4383 M (SW_INTERFACE_DUMP, sw_interface_dump);
4384 mp->name_filter_valid = 1;
4385 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
4388 /* and host (af_packet) interfaces */
4389 M (SW_INTERFACE_DUMP, sw_interface_dump);
4390 mp->name_filter_valid = 1;
4391 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
4394 /* and l2tpv3 tunnel interfaces */
4395 M (SW_INTERFACE_DUMP, sw_interface_dump);
4396 mp->name_filter_valid = 1;
4397 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
4398 sizeof (mp->name_filter) - 1);
4401 /* and GRE tunnel interfaces */
4402 M (SW_INTERFACE_DUMP, sw_interface_dump);
4403 mp->name_filter_valid = 1;
4404 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
4407 /* and LISP-GPE interfaces */
4408 M (SW_INTERFACE_DUMP, sw_interface_dump);
4409 mp->name_filter_valid = 1;
4410 strncpy ((char *) mp->name_filter, "lisp_gpe",
4411 sizeof (mp->name_filter) - 1);
4414 /* and IPSEC tunnel interfaces */
4415 M (SW_INTERFACE_DUMP, sw_interface_dump);
4416 mp->name_filter_valid = 1;
4417 strncpy ((char *) mp->name_filter, "ipsec", sizeof (mp->name_filter) - 1);
4420 /* Use a control ping for synchronization */
4422 vl_api_control_ping_t *mp;
4423 M (CONTROL_PING, control_ping);
4430 api_sw_interface_set_flags (vat_main_t * vam)
4432 unformat_input_t *i = vam->input;
4433 vl_api_sw_interface_set_flags_t *mp;
4436 u8 sw_if_index_set = 0;
4437 u8 admin_up = 0, link_up = 0;
4439 /* Parse args required to build the message */
4440 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4442 if (unformat (i, "admin-up"))
4444 else if (unformat (i, "admin-down"))
4446 else if (unformat (i, "link-up"))
4448 else if (unformat (i, "link-down"))
4450 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4451 sw_if_index_set = 1;
4452 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4453 sw_if_index_set = 1;
4458 if (sw_if_index_set == 0)
4460 errmsg ("missing interface name or sw_if_index\n");
4464 /* Construct the API message */
4465 M (SW_INTERFACE_SET_FLAGS, sw_interface_set_flags);
4466 mp->sw_if_index = ntohl (sw_if_index);
4467 mp->admin_up_down = admin_up;
4468 mp->link_up_down = link_up;
4473 /* Wait for a reply, return the good/bad news... */
4478 api_sw_interface_clear_stats (vat_main_t * vam)
4480 unformat_input_t *i = vam->input;
4481 vl_api_sw_interface_clear_stats_t *mp;
4484 u8 sw_if_index_set = 0;
4486 /* Parse args required to build the message */
4487 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4489 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4490 sw_if_index_set = 1;
4491 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4492 sw_if_index_set = 1;
4497 /* Construct the API message */
4498 M (SW_INTERFACE_CLEAR_STATS, sw_interface_clear_stats);
4500 if (sw_if_index_set == 1)
4501 mp->sw_if_index = ntohl (sw_if_index);
4503 mp->sw_if_index = ~0;
4508 /* Wait for a reply, return the good/bad news... */
4513 api_sw_interface_set_dpdk_hqos_pipe (vat_main_t * vam)
4515 unformat_input_t *i = vam->input;
4516 vl_api_sw_interface_set_dpdk_hqos_pipe_t *mp;
4519 u8 sw_if_index_set = 0;
4527 /* Parse args required to build the message */
4528 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4530 if (unformat (i, "rx %U", unformat_sw_if_index, vam, &sw_if_index))
4531 sw_if_index_set = 1;
4532 else if (unformat (i, "sw_if_index %u", &sw_if_index))
4533 sw_if_index_set = 1;
4534 else if (unformat (i, "subport %u", &subport))
4536 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4537 sw_if_index_set = 1;
4538 else if (unformat (i, "pipe %u", &pipe))
4540 else if (unformat (i, "profile %u", &profile))
4546 if (sw_if_index_set == 0)
4548 errmsg ("missing interface name or sw_if_index\n");
4552 if (subport_set == 0)
4554 errmsg ("missing subport \n");
4560 errmsg ("missing pipe\n");
4564 if (profile_set == 0)
4566 errmsg ("missing profile\n");
4570 M (SW_INTERFACE_SET_DPDK_HQOS_PIPE, sw_interface_set_dpdk_hqos_pipe);
4572 mp->sw_if_index = ntohl (sw_if_index);
4573 mp->subport = ntohl (subport);
4574 mp->pipe = ntohl (pipe);
4575 mp->profile = ntohl (profile);
4585 api_sw_interface_set_dpdk_hqos_subport (vat_main_t * vam)
4587 unformat_input_t *i = vam->input;
4588 vl_api_sw_interface_set_dpdk_hqos_subport_t *mp;
4591 u8 sw_if_index_set = 0;
4594 u32 tb_rate = 1250000000; /* 10GbE */
4595 u32 tb_size = 1000000;
4596 u32 tc_rate[] = { 1250000000, 1250000000, 1250000000, 1250000000 };
4599 /* Parse args required to build the message */
4600 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4602 if (unformat (i, "rx %U", unformat_sw_if_index, vam, &sw_if_index))
4603 sw_if_index_set = 1;
4604 else if (unformat (i, "sw_if_index %u", &sw_if_index))
4605 sw_if_index_set = 1;
4606 else if (unformat (i, "subport %u", &subport))
4608 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4609 sw_if_index_set = 1;
4610 else if (unformat (i, "rate %u", &tb_rate))
4614 for (tc_id = 0; tc_id < (sizeof (tc_rate) / sizeof (tc_rate[0]));
4616 tc_rate[tc_id] = tb_rate;
4618 else if (unformat (i, "bktsize %u", &tb_size))
4620 else if (unformat (i, "tc0 %u", &tc_rate[0]))
4622 else if (unformat (i, "tc1 %u", &tc_rate[1]))
4624 else if (unformat (i, "tc2 %u", &tc_rate[2]))
4626 else if (unformat (i, "tc3 %u", &tc_rate[3]))
4628 else if (unformat (i, "period %u", &tc_period))
4634 if (sw_if_index_set == 0)
4636 errmsg ("missing interface name or sw_if_index\n");
4640 if (subport_set == 0)
4642 errmsg ("missing subport \n");
4646 M (SW_INTERFACE_SET_DPDK_HQOS_SUBPORT, sw_interface_set_dpdk_hqos_subport);
4648 mp->sw_if_index = ntohl (sw_if_index);
4649 mp->subport = ntohl (subport);
4650 mp->tb_rate = ntohl (tb_rate);
4651 mp->tb_size = ntohl (tb_size);
4652 mp->tc_rate[0] = ntohl (tc_rate[0]);
4653 mp->tc_rate[1] = ntohl (tc_rate[1]);
4654 mp->tc_rate[2] = ntohl (tc_rate[2]);
4655 mp->tc_rate[3] = ntohl (tc_rate[3]);
4656 mp->tc_period = ntohl (tc_period);
4665 api_sw_interface_set_dpdk_hqos_tctbl (vat_main_t * vam)
4667 unformat_input_t *i = vam->input;
4668 vl_api_sw_interface_set_dpdk_hqos_tctbl_t *mp;
4671 u8 sw_if_index_set = 0;
4675 u32 entry, tc, queue;
4677 /* Parse args required to build the message */
4678 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4680 if (unformat (i, "rx %U", unformat_sw_if_index, vam, &sw_if_index))
4681 sw_if_index_set = 1;
4682 else if (unformat (i, "sw_if_index %u", &sw_if_index))
4683 sw_if_index_set = 1;
4684 else if (unformat (i, "entry %d", &entry))
4686 else if (unformat (i, "tc %d", &tc))
4688 else if (unformat (i, "queue %d", &queue))
4694 if (sw_if_index_set == 0)
4696 errmsg ("missing interface name or sw_if_index\n");
4702 errmsg ("missing entry \n");
4708 errmsg ("missing traffic class \n");
4714 errmsg ("missing queue \n");
4718 M (SW_INTERFACE_SET_DPDK_HQOS_TCTBL, sw_interface_set_dpdk_hqos_tctbl);
4720 mp->sw_if_index = ntohl (sw_if_index);
4721 mp->entry = ntohl (entry);
4722 mp->tc = ntohl (tc);
4723 mp->queue = ntohl (queue);
4732 api_sw_interface_add_del_address (vat_main_t * vam)
4734 unformat_input_t *i = vam->input;
4735 vl_api_sw_interface_add_del_address_t *mp;
4738 u8 sw_if_index_set = 0;
4739 u8 is_add = 1, del_all = 0;
4740 u32 address_length = 0;
4741 u8 v4_address_set = 0;
4742 u8 v6_address_set = 0;
4743 ip4_address_t v4address;
4744 ip6_address_t v6address;
4746 /* Parse args required to build the message */
4747 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4749 if (unformat (i, "del-all"))
4751 else if (unformat (i, "del"))
4753 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4754 sw_if_index_set = 1;
4755 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4756 sw_if_index_set = 1;
4757 else if (unformat (i, "%U/%d",
4758 unformat_ip4_address, &v4address, &address_length))
4760 else if (unformat (i, "%U/%d",
4761 unformat_ip6_address, &v6address, &address_length))
4767 if (sw_if_index_set == 0)
4769 errmsg ("missing interface name or sw_if_index\n");
4772 if (v4_address_set && v6_address_set)
4774 errmsg ("both v4 and v6 addresses set\n");
4777 if (!v4_address_set && !v6_address_set && !del_all)
4779 errmsg ("no addresses set\n");
4783 /* Construct the API message */
4784 M (SW_INTERFACE_ADD_DEL_ADDRESS, sw_interface_add_del_address);
4786 mp->sw_if_index = ntohl (sw_if_index);
4787 mp->is_add = is_add;
4788 mp->del_all = del_all;
4792 clib_memcpy (mp->address, &v6address, sizeof (v6address));
4796 clib_memcpy (mp->address, &v4address, sizeof (v4address));
4798 mp->address_length = address_length;
4803 /* Wait for a reply, return good/bad news */
4808 api_sw_interface_set_table (vat_main_t * vam)
4810 unformat_input_t *i = vam->input;
4811 vl_api_sw_interface_set_table_t *mp;
4813 u32 sw_if_index, vrf_id = 0;
4814 u8 sw_if_index_set = 0;
4817 /* Parse args required to build the message */
4818 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4820 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4821 sw_if_index_set = 1;
4822 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4823 sw_if_index_set = 1;
4824 else if (unformat (i, "vrf %d", &vrf_id))
4826 else if (unformat (i, "ipv6"))
4832 if (sw_if_index_set == 0)
4834 errmsg ("missing interface name or sw_if_index\n");
4838 /* Construct the API message */
4839 M (SW_INTERFACE_SET_TABLE, sw_interface_set_table);
4841 mp->sw_if_index = ntohl (sw_if_index);
4842 mp->is_ipv6 = is_ipv6;
4843 mp->vrf_id = ntohl (vrf_id);
4848 /* Wait for a reply... */
4853 api_sw_interface_set_vpath (vat_main_t * vam)
4855 unformat_input_t *i = vam->input;
4856 vl_api_sw_interface_set_vpath_t *mp;
4858 u32 sw_if_index = 0;
4859 u8 sw_if_index_set = 0;
4862 /* Parse args required to build the message */
4863 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4865 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4866 sw_if_index_set = 1;
4867 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4868 sw_if_index_set = 1;
4869 else if (unformat (i, "enable"))
4871 else if (unformat (i, "disable"))
4877 if (sw_if_index_set == 0)
4879 errmsg ("missing interface name or sw_if_index\n");
4883 /* Construct the API message */
4884 M (SW_INTERFACE_SET_VPATH, sw_interface_set_vpath);
4886 mp->sw_if_index = ntohl (sw_if_index);
4887 mp->enable = is_enable;
4892 /* Wait for a reply... */
4897 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
4899 unformat_input_t *i = vam->input;
4900 vl_api_sw_interface_set_l2_xconnect_t *mp;
4903 u8 rx_sw_if_index_set = 0;
4905 u8 tx_sw_if_index_set = 0;
4908 /* Parse args required to build the message */
4909 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4911 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
4912 rx_sw_if_index_set = 1;
4913 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
4914 tx_sw_if_index_set = 1;
4915 else if (unformat (i, "rx"))
4917 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4919 if (unformat (i, "%U", unformat_sw_if_index, vam,
4921 rx_sw_if_index_set = 1;
4926 else if (unformat (i, "tx"))
4928 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4930 if (unformat (i, "%U", unformat_sw_if_index, vam,
4932 tx_sw_if_index_set = 1;
4937 else if (unformat (i, "enable"))
4939 else if (unformat (i, "disable"))
4945 if (rx_sw_if_index_set == 0)
4947 errmsg ("missing rx interface name or rx_sw_if_index\n");
4951 if (enable && (tx_sw_if_index_set == 0))
4953 errmsg ("missing tx interface name or tx_sw_if_index\n");
4957 M (SW_INTERFACE_SET_L2_XCONNECT, sw_interface_set_l2_xconnect);
4959 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
4960 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
4961 mp->enable = enable;
4970 api_sw_interface_set_l2_bridge (vat_main_t * vam)
4972 unformat_input_t *i = vam->input;
4973 vl_api_sw_interface_set_l2_bridge_t *mp;
4976 u8 rx_sw_if_index_set = 0;
4983 /* Parse args required to build the message */
4984 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4986 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
4987 rx_sw_if_index_set = 1;
4988 else if (unformat (i, "bd_id %d", &bd_id))
4990 else if (unformat (i, "%U", unformat_sw_if_index, vam, &rx_sw_if_index))
4991 rx_sw_if_index_set = 1;
4992 else if (unformat (i, "shg %d", &shg))
4994 else if (unformat (i, "bvi"))
4996 else if (unformat (i, "enable"))
4998 else if (unformat (i, "disable"))
5004 if (rx_sw_if_index_set == 0)
5006 errmsg ("missing rx interface name or sw_if_index\n");
5010 if (enable && (bd_id_set == 0))
5012 errmsg ("missing bridge domain\n");
5016 M (SW_INTERFACE_SET_L2_BRIDGE, sw_interface_set_l2_bridge);
5018 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5019 mp->bd_id = ntohl (bd_id);
5022 mp->enable = enable;
5031 api_bridge_domain_dump (vat_main_t * vam)
5033 unformat_input_t *i = vam->input;
5034 vl_api_bridge_domain_dump_t *mp;
5038 /* Parse args required to build the message */
5039 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5041 if (unformat (i, "bd_id %d", &bd_id))
5047 M (BRIDGE_DOMAIN_DUMP, bridge_domain_dump);
5048 mp->bd_id = ntohl (bd_id);
5051 /* Use a control ping for synchronization */
5053 vl_api_control_ping_t *mp;
5054 M (CONTROL_PING, control_ping);
5064 api_bridge_domain_add_del (vat_main_t * vam)
5066 unformat_input_t *i = vam->input;
5067 vl_api_bridge_domain_add_del_t *mp;
5071 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
5073 /* Parse args required to build the message */
5074 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5076 if (unformat (i, "bd_id %d", &bd_id))
5078 else if (unformat (i, "flood %d", &flood))
5080 else if (unformat (i, "uu-flood %d", &uu_flood))
5082 else if (unformat (i, "forward %d", &forward))
5084 else if (unformat (i, "learn %d", &learn))
5086 else if (unformat (i, "arp-term %d", &arp_term))
5088 else if (unformat (i, "del"))
5091 flood = uu_flood = forward = learn = 0;
5099 errmsg ("missing bridge domain\n");
5103 M (BRIDGE_DOMAIN_ADD_DEL, bridge_domain_add_del);
5105 mp->bd_id = ntohl (bd_id);
5107 mp->uu_flood = uu_flood;
5108 mp->forward = forward;
5110 mp->arp_term = arp_term;
5111 mp->is_add = is_add;
5120 api_l2fib_add_del (vat_main_t * vam)
5122 unformat_input_t *i = vam->input;
5123 vl_api_l2fib_add_del_t *mp;
5130 u8 sw_if_index_set = 0;
5139 /* Parse args required to build the message */
5140 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5142 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
5144 else if (unformat (i, "bd_id %d", &bd_id))
5146 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5147 sw_if_index_set = 1;
5148 else if (unformat (i, "sw_if"))
5150 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5152 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5153 sw_if_index_set = 1;
5158 else if (unformat (i, "static"))
5160 else if (unformat (i, "filter"))
5165 else if (unformat (i, "bvi"))
5170 else if (unformat (i, "del"))
5172 else if (unformat (i, "count %d", &count))
5180 errmsg ("missing mac address\n");
5186 errmsg ("missing bridge domain\n");
5190 if (is_add && (sw_if_index_set == 0))
5192 errmsg ("missing interface name or sw_if_index\n");
5198 /* Turn on async mode */
5199 vam->async_mode = 1;
5200 vam->async_errors = 0;
5201 before = vat_time_now (vam);
5204 for (j = 0; j < count; j++)
5206 M (L2FIB_ADD_DEL, l2fib_add_del);
5209 mp->bd_id = ntohl (bd_id);
5210 mp->is_add = is_add;
5214 mp->sw_if_index = ntohl (sw_if_index);
5215 mp->static_mac = static_mac;
5216 mp->filter_mac = filter_mac;
5217 mp->bvi_mac = bvi_mac;
5219 increment_mac_address (&mac);
5226 vl_api_control_ping_t *mp;
5229 /* Shut off async mode */
5230 vam->async_mode = 0;
5232 M (CONTROL_PING, control_ping);
5235 timeout = vat_time_now (vam) + 1.0;
5236 while (vat_time_now (vam) < timeout)
5237 if (vam->result_ready == 1)
5242 if (vam->retval == -99)
5243 errmsg ("timeout\n");
5245 if (vam->async_errors > 0)
5247 errmsg ("%d asynchronous errors\n", vam->async_errors);
5250 vam->async_errors = 0;
5251 after = vat_time_now (vam);
5253 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
5254 count, after - before, count / (after - before));
5258 /* Wait for a reply... */
5261 /* Return the good/bad news */
5262 return (vam->retval);
5266 api_l2_flags (vat_main_t * vam)
5268 unformat_input_t *i = vam->input;
5269 vl_api_l2_flags_t *mp;
5272 u32 feature_bitmap = 0;
5273 u8 sw_if_index_set = 0;
5275 /* Parse args required to build the message */
5276 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5278 if (unformat (i, "sw_if_index %d", &sw_if_index))
5279 sw_if_index_set = 1;
5280 else if (unformat (i, "sw_if"))
5282 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5284 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5285 sw_if_index_set = 1;
5290 else if (unformat (i, "learn"))
5291 feature_bitmap |= L2INPUT_FEAT_LEARN;
5292 else if (unformat (i, "forward"))
5293 feature_bitmap |= L2INPUT_FEAT_FWD;
5294 else if (unformat (i, "flood"))
5295 feature_bitmap |= L2INPUT_FEAT_FLOOD;
5296 else if (unformat (i, "uu-flood"))
5297 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
5302 if (sw_if_index_set == 0)
5304 errmsg ("missing interface name or sw_if_index\n");
5308 M (L2_FLAGS, l2_flags);
5310 mp->sw_if_index = ntohl (sw_if_index);
5311 mp->feature_bitmap = ntohl (feature_bitmap);
5320 api_bridge_flags (vat_main_t * vam)
5322 unformat_input_t *i = vam->input;
5323 vl_api_bridge_flags_t *mp;
5330 /* Parse args required to build the message */
5331 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5333 if (unformat (i, "bd_id %d", &bd_id))
5335 else if (unformat (i, "learn"))
5337 else if (unformat (i, "forward"))
5339 else if (unformat (i, "flood"))
5341 else if (unformat (i, "uu-flood"))
5342 flags |= L2_UU_FLOOD;
5343 else if (unformat (i, "arp-term"))
5344 flags |= L2_ARP_TERM;
5345 else if (unformat (i, "off"))
5347 else if (unformat (i, "disable"))
5355 errmsg ("missing bridge domain\n");
5359 M (BRIDGE_FLAGS, bridge_flags);
5361 mp->bd_id = ntohl (bd_id);
5362 mp->feature_bitmap = ntohl (flags);
5363 mp->is_set = is_set;
5372 api_bd_ip_mac_add_del (vat_main_t * vam)
5374 unformat_input_t *i = vam->input;
5375 vl_api_bd_ip_mac_add_del_t *mp;
5383 ip4_address_t v4addr;
5384 ip6_address_t v6addr;
5388 /* Parse args required to build the message */
5389 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5391 if (unformat (i, "bd_id %d", &bd_id))
5395 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
5399 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
5404 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
5408 else if (unformat (i, "del"))
5416 errmsg ("missing bridge domain\n");
5419 else if (ip_set == 0)
5421 errmsg ("missing IP address\n");
5424 else if (mac_set == 0)
5426 errmsg ("missing MAC address\n");
5430 M (BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del);
5432 mp->bd_id = ntohl (bd_id);
5433 mp->is_ipv6 = is_ipv6;
5434 mp->is_add = is_add;
5436 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
5438 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
5439 clib_memcpy (mp->mac_address, macaddr, 6);
5447 api_tap_connect (vat_main_t * vam)
5449 unformat_input_t *i = vam->input;
5450 vl_api_tap_connect_t *mp;
5457 memset (mac_address, 0, sizeof (mac_address));
5459 /* Parse args required to build the message */
5460 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5462 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5466 else if (unformat (i, "random-mac"))
5468 else if (unformat (i, "tapname %s", &tap_name))
5476 errmsg ("missing tap name\n");
5479 if (vec_len (tap_name) > 63)
5481 errmsg ("tap name too long\n");
5483 vec_add1 (tap_name, 0);
5485 /* Construct the API message */
5486 M (TAP_CONNECT, tap_connect);
5488 mp->use_random_mac = random_mac;
5489 clib_memcpy (mp->mac_address, mac_address, 6);
5490 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5491 vec_free (tap_name);
5496 /* Wait for a reply... */
5501 api_tap_modify (vat_main_t * vam)
5503 unformat_input_t *i = vam->input;
5504 vl_api_tap_modify_t *mp;
5510 u32 sw_if_index = ~0;
5511 u8 sw_if_index_set = 0;
5513 memset (mac_address, 0, sizeof (mac_address));
5515 /* Parse args required to build the message */
5516 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5518 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5519 sw_if_index_set = 1;
5520 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5521 sw_if_index_set = 1;
5522 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5526 else if (unformat (i, "random-mac"))
5528 else if (unformat (i, "tapname %s", &tap_name))
5534 if (sw_if_index_set == 0)
5536 errmsg ("missing vpp interface name");
5541 errmsg ("missing tap name\n");
5544 if (vec_len (tap_name) > 63)
5546 errmsg ("tap name too long\n");
5548 vec_add1 (tap_name, 0);
5550 /* Construct the API message */
5551 M (TAP_MODIFY, tap_modify);
5553 mp->use_random_mac = random_mac;
5554 mp->sw_if_index = ntohl (sw_if_index);
5555 clib_memcpy (mp->mac_address, mac_address, 6);
5556 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5557 vec_free (tap_name);
5562 /* Wait for a reply... */
5567 api_tap_delete (vat_main_t * vam)
5569 unformat_input_t *i = vam->input;
5570 vl_api_tap_delete_t *mp;
5572 u32 sw_if_index = ~0;
5573 u8 sw_if_index_set = 0;
5575 /* Parse args required to build the message */
5576 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5578 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5579 sw_if_index_set = 1;
5580 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5581 sw_if_index_set = 1;
5586 if (sw_if_index_set == 0)
5588 errmsg ("missing vpp interface name");
5592 /* Construct the API message */
5593 M (TAP_DELETE, tap_delete);
5595 mp->sw_if_index = ntohl (sw_if_index);
5600 /* Wait for a reply... */
5605 api_ip_add_del_route (vat_main_t * vam)
5607 unformat_input_t *i = vam->input;
5608 vl_api_ip_add_del_route_t *mp;
5610 u32 sw_if_index = ~0, vrf_id = 0;
5611 u8 sw_if_index_set = 0;
5613 u8 is_local = 0, is_drop = 0;
5614 u8 create_vrf_if_needed = 0;
5616 u8 next_hop_weight = 1;
5618 u8 is_multipath = 0;
5620 u8 address_length_set = 0;
5621 u32 lookup_in_vrf = 0;
5622 u32 resolve_attempts = 0;
5623 u32 dst_address_length = 0;
5624 u8 next_hop_set = 0;
5625 ip4_address_t v4_dst_address, v4_next_hop_address;
5626 ip6_address_t v6_dst_address, v6_next_hop_address;
5630 u32 random_add_del = 0;
5631 u32 *random_vector = 0;
5633 u32 random_seed = 0xdeaddabe;
5634 u32 classify_table_index = ~0;
5636 u8 resolve_host, resolve_attached;
5638 /* Parse args required to build the message */
5639 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5641 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5642 sw_if_index_set = 1;
5643 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5644 sw_if_index_set = 1;
5645 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
5650 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
5655 else if (unformat (i, "/%d", &dst_address_length))
5657 address_length_set = 1;
5660 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
5661 &v4_next_hop_address))
5665 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
5666 &v6_next_hop_address))
5670 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
5672 else if (unformat (i, "weight %d", &next_hop_weight))
5674 else if (unformat (i, "drop"))
5678 else if (unformat (i, "local"))
5682 else if (unformat (i, "classify %d", &classify_table_index))
5686 else if (unformat (i, "del"))
5688 else if (unformat (i, "add"))
5690 else if (unformat (i, "not-last"))
5692 else if (unformat (i, "resolve-via-host"))
5694 else if (unformat (i, "resolve-via-attached"))
5695 resolve_attached = 1;
5696 else if (unformat (i, "multipath"))
5698 else if (unformat (i, "vrf %d", &vrf_id))
5700 else if (unformat (i, "create-vrf"))
5701 create_vrf_if_needed = 1;
5702 else if (unformat (i, "count %d", &count))
5704 else if (unformat (i, "lookup-in-vrf %d", &lookup_in_vrf))
5706 else if (unformat (i, "random"))
5708 else if (unformat (i, "seed %d", &random_seed))
5712 clib_warning ("parse error '%U'", format_unformat_error, i);
5717 if (resolve_attempts > 0 && sw_if_index_set == 0)
5719 errmsg ("ARP resolution needs explicit interface or sw_if_index\n");
5723 if (!next_hop_set && !is_drop && !is_local && !is_classify)
5725 errmsg ("next hop / local / drop / classify not set\n");
5729 if (address_set == 0)
5731 errmsg ("missing addresses\n");
5735 if (address_length_set == 0)
5737 errmsg ("missing address length\n");
5741 /* Generate a pile of unique, random routes */
5744 u32 this_random_address;
5745 random_hash = hash_create (count, sizeof (uword));
5747 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
5748 for (j = 0; j <= count; j++)
5752 this_random_address = random_u32 (&random_seed);
5753 this_random_address =
5754 clib_host_to_net_u32 (this_random_address);
5756 while (hash_get (random_hash, this_random_address));
5757 vec_add1 (random_vector, this_random_address);
5758 hash_set (random_hash, this_random_address, 1);
5760 hash_free (random_hash);
5761 v4_dst_address.as_u32 = random_vector[0];
5766 /* Turn on async mode */
5767 vam->async_mode = 1;
5768 vam->async_errors = 0;
5769 before = vat_time_now (vam);
5772 for (j = 0; j < count; j++)
5774 /* Construct the API message */
5775 M (IP_ADD_DEL_ROUTE, ip_add_del_route);
5777 mp->next_hop_sw_if_index = ntohl (sw_if_index);
5778 mp->vrf_id = ntohl (vrf_id);
5779 if (resolve_attempts > 0)
5781 mp->resolve_attempts = ntohl (resolve_attempts);
5782 mp->resolve_if_needed = 1;
5784 mp->create_vrf_if_needed = create_vrf_if_needed;
5786 mp->is_add = is_add;
5787 mp->is_drop = is_drop;
5788 mp->is_ipv6 = is_ipv6;
5789 mp->is_local = is_local;
5790 mp->is_classify = is_classify;
5791 mp->is_multipath = is_multipath;
5792 mp->is_resolve_host = resolve_host;
5793 mp->is_resolve_attached = resolve_attached;
5794 mp->not_last = not_last;
5795 mp->next_hop_weight = next_hop_weight;
5796 mp->dst_address_length = dst_address_length;
5797 mp->lookup_in_vrf = ntohl (lookup_in_vrf);
5798 mp->classify_table_index = ntohl (classify_table_index);
5802 clib_memcpy (mp->dst_address, &v6_dst_address,
5803 sizeof (v6_dst_address));
5805 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
5806 sizeof (v6_next_hop_address));
5807 increment_v6_address (&v6_dst_address);
5811 clib_memcpy (mp->dst_address, &v4_dst_address,
5812 sizeof (v4_dst_address));
5814 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
5815 sizeof (v4_next_hop_address));
5817 v4_dst_address.as_u32 = random_vector[j + 1];
5819 increment_v4_address (&v4_dst_address);
5825 /* When testing multiple add/del ops, use a control-ping to sync */
5828 vl_api_control_ping_t *mp;
5831 /* Shut off async mode */
5832 vam->async_mode = 0;
5834 M (CONTROL_PING, control_ping);
5837 timeout = vat_time_now (vam) + 1.0;
5838 while (vat_time_now (vam) < timeout)
5839 if (vam->result_ready == 1)
5844 if (vam->retval == -99)
5845 errmsg ("timeout\n");
5847 if (vam->async_errors > 0)
5849 errmsg ("%d asynchronous errors\n", vam->async_errors);
5852 vam->async_errors = 0;
5853 after = vat_time_now (vam);
5855 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
5856 count, after - before, count / (after - before));
5860 /* Wait for a reply... */
5864 /* Return the good/bad news */
5865 return (vam->retval);
5869 api_proxy_arp_add_del (vat_main_t * vam)
5871 unformat_input_t *i = vam->input;
5872 vl_api_proxy_arp_add_del_t *mp;
5876 ip4_address_t lo, hi;
5879 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5881 if (unformat (i, "vrf %d", &vrf_id))
5883 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
5884 unformat_ip4_address, &hi))
5886 else if (unformat (i, "del"))
5890 clib_warning ("parse error '%U'", format_unformat_error, i);
5897 errmsg ("address range not set\n");
5901 M (PROXY_ARP_ADD_DEL, proxy_arp_add_del);
5903 mp->vrf_id = ntohl (vrf_id);
5904 mp->is_add = is_add;
5905 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
5906 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
5915 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
5917 unformat_input_t *i = vam->input;
5918 vl_api_proxy_arp_intfc_enable_disable_t *mp;
5922 u8 sw_if_index_set = 0;
5924 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5926 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5927 sw_if_index_set = 1;
5928 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5929 sw_if_index_set = 1;
5930 else if (unformat (i, "enable"))
5932 else if (unformat (i, "disable"))
5936 clib_warning ("parse error '%U'", format_unformat_error, i);
5941 if (sw_if_index_set == 0)
5943 errmsg ("missing interface name or sw_if_index\n");
5947 M (PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable);
5949 mp->sw_if_index = ntohl (sw_if_index);
5950 mp->enable_disable = enable;
5959 api_mpls_add_del_decap (vat_main_t * vam)
5961 unformat_input_t *i = vam->input;
5962 vl_api_mpls_add_del_decap_t *mp;
5971 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5973 if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
5975 else if (unformat (i, "tx_vrf_id %d", &tx_vrf_id))
5977 else if (unformat (i, "label %d", &label))
5979 else if (unformat (i, "next-index %d", &next_index))
5981 else if (unformat (i, "del"))
5983 else if (unformat (i, "s-bit-clear"))
5987 clib_warning ("parse error '%U'", format_unformat_error, i);
5992 M (MPLS_ADD_DEL_DECAP, mpls_add_del_decap);
5994 mp->rx_vrf_id = ntohl (rx_vrf_id);
5995 mp->tx_vrf_id = ntohl (tx_vrf_id);
5996 mp->label = ntohl (label);
5997 mp->next_index = ntohl (next_index);
5999 mp->is_add = is_add;
6008 api_mpls_add_del_encap (vat_main_t * vam)
6010 unformat_input_t *i = vam->input;
6011 vl_api_mpls_add_del_encap_t *mp;
6016 ip4_address_t dst_address;
6019 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6021 if (unformat (i, "vrf %d", &vrf_id))
6023 else if (unformat (i, "label %d", &label))
6024 vec_add1 (labels, ntohl (label));
6025 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
6027 else if (unformat (i, "del"))
6031 clib_warning ("parse error '%U'", format_unformat_error, i);
6036 if (vec_len (labels) == 0)
6038 errmsg ("missing encap label stack\n");
6042 M2 (MPLS_ADD_DEL_ENCAP, mpls_add_del_encap,
6043 sizeof (u32) * vec_len (labels));
6045 mp->vrf_id = ntohl (vrf_id);
6046 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
6047 mp->is_add = is_add;
6048 mp->nlabels = vec_len (labels);
6049 clib_memcpy (mp->labels, labels, sizeof (u32) * mp->nlabels);
6060 api_mpls_gre_add_del_tunnel (vat_main_t * vam)
6062 unformat_input_t *i = vam->input;
6063 vl_api_mpls_gre_add_del_tunnel_t *mp;
6065 u32 inner_vrf_id = 0;
6066 u32 outer_vrf_id = 0;
6067 ip4_address_t src_address;
6068 ip4_address_t dst_address;
6069 ip4_address_t intfc_address;
6071 u8 intfc_address_length = 0;
6075 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6077 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
6079 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
6081 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
6083 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
6085 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
6086 &intfc_address, &tmp))
6087 intfc_address_length = tmp;
6088 else if (unformat (i, "l2-only"))
6090 else if (unformat (i, "del"))
6094 clib_warning ("parse error '%U'", format_unformat_error, i);
6099 M (MPLS_GRE_ADD_DEL_TUNNEL, mpls_gre_add_del_tunnel);
6101 mp->inner_vrf_id = ntohl (inner_vrf_id);
6102 mp->outer_vrf_id = ntohl (outer_vrf_id);
6103 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
6104 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
6105 clib_memcpy (mp->intfc_address, &intfc_address, sizeof (intfc_address));
6106 mp->intfc_address_length = intfc_address_length;
6107 mp->l2_only = l2_only;
6108 mp->is_add = is_add;
6117 api_mpls_ethernet_add_del_tunnel (vat_main_t * vam)
6119 unformat_input_t *i = vam->input;
6120 vl_api_mpls_ethernet_add_del_tunnel_t *mp;
6122 u32 inner_vrf_id = 0;
6123 ip4_address_t intfc_address;
6124 u8 dst_mac_address[6];
6127 u8 intfc_address_length = 0;
6131 int tx_sw_if_index_set = 0;
6133 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6135 if (unformat (i, "vrf %d", &inner_vrf_id))
6137 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
6138 &intfc_address, &tmp))
6139 intfc_address_length = tmp;
6140 else if (unformat (i, "%U", unformat_sw_if_index, vam, &tx_sw_if_index))
6141 tx_sw_if_index_set = 1;
6142 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6143 tx_sw_if_index_set = 1;
6144 else if (unformat (i, "dst %U", unformat_ethernet_address,
6147 else if (unformat (i, "l2-only"))
6149 else if (unformat (i, "del"))
6153 clib_warning ("parse error '%U'", format_unformat_error, i);
6160 errmsg ("dst (mac address) not set\n");
6163 if (!tx_sw_if_index_set)
6165 errmsg ("tx-intfc not set\n");
6169 M (MPLS_ETHERNET_ADD_DEL_TUNNEL, mpls_ethernet_add_del_tunnel);
6171 mp->vrf_id = ntohl (inner_vrf_id);
6172 clib_memcpy (mp->adj_address, &intfc_address, sizeof (intfc_address));
6173 mp->adj_address_length = intfc_address_length;
6174 clib_memcpy (mp->dst_mac_address, dst_mac_address,
6175 sizeof (dst_mac_address));
6176 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6177 mp->l2_only = l2_only;
6178 mp->is_add = is_add;
6187 api_mpls_ethernet_add_del_tunnel_2 (vat_main_t * vam)
6189 unformat_input_t *i = vam->input;
6190 vl_api_mpls_ethernet_add_del_tunnel_2_t *mp;
6192 u32 inner_vrf_id = 0;
6193 u32 outer_vrf_id = 0;
6194 ip4_address_t adj_address;
6195 int adj_address_set = 0;
6196 ip4_address_t next_hop_address;
6197 int next_hop_address_set = 0;
6199 u8 adj_address_length = 0;
6202 u32 resolve_attempts = 5;
6203 u8 resolve_if_needed = 1;
6205 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6207 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
6209 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
6211 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
6212 &adj_address, &tmp))
6214 adj_address_length = tmp;
6215 adj_address_set = 1;
6217 else if (unformat (i, "next-hop %U", unformat_ip4_address,
6219 next_hop_address_set = 1;
6220 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
6222 else if (unformat (i, "resolve-if-needed %d", &tmp))
6223 resolve_if_needed = tmp;
6224 else if (unformat (i, "l2-only"))
6226 else if (unformat (i, "del"))
6230 clib_warning ("parse error '%U'", format_unformat_error, i);
6235 if (!adj_address_set)
6237 errmsg ("adjacency address/mask not set\n");
6240 if (!next_hop_address_set)
6242 errmsg ("ip4 next hop address (in outer fib) not set\n");
6246 M (MPLS_ETHERNET_ADD_DEL_TUNNEL_2, mpls_ethernet_add_del_tunnel_2);
6248 mp->inner_vrf_id = ntohl (inner_vrf_id);
6249 mp->outer_vrf_id = ntohl (outer_vrf_id);
6250 mp->resolve_attempts = ntohl (resolve_attempts);
6251 mp->resolve_if_needed = resolve_if_needed;
6252 mp->is_add = is_add;
6253 mp->l2_only = l2_only;
6254 clib_memcpy (mp->adj_address, &adj_address, sizeof (adj_address));
6255 mp->adj_address_length = adj_address_length;
6256 clib_memcpy (mp->next_hop_ip4_address_in_outer_vrf, &next_hop_address,
6257 sizeof (next_hop_address));
6266 api_sw_interface_set_unnumbered (vat_main_t * vam)
6268 unformat_input_t *i = vam->input;
6269 vl_api_sw_interface_set_unnumbered_t *mp;
6272 u32 unnum_sw_index = ~0;
6274 u8 sw_if_index_set = 0;
6276 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6278 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6279 sw_if_index_set = 1;
6280 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6281 sw_if_index_set = 1;
6282 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
6284 else if (unformat (i, "del"))
6288 clib_warning ("parse error '%U'", format_unformat_error, i);
6293 if (sw_if_index_set == 0)
6295 errmsg ("missing interface name or sw_if_index\n");
6299 M (SW_INTERFACE_SET_UNNUMBERED, sw_interface_set_unnumbered);
6301 mp->sw_if_index = ntohl (sw_if_index);
6302 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
6303 mp->is_add = is_add;
6312 api_ip_neighbor_add_del (vat_main_t * vam)
6314 unformat_input_t *i = vam->input;
6315 vl_api_ip_neighbor_add_del_t *mp;
6318 u8 sw_if_index_set = 0;
6324 u8 v4_address_set = 0;
6325 u8 v6_address_set = 0;
6326 ip4_address_t v4address;
6327 ip6_address_t v6address;
6329 memset (mac_address, 0, sizeof (mac_address));
6331 /* Parse args required to build the message */
6332 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6334 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6338 else if (unformat (i, "del"))
6340 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6341 sw_if_index_set = 1;
6342 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6343 sw_if_index_set = 1;
6344 else if (unformat (i, "is_static"))
6346 else if (unformat (i, "vrf %d", &vrf_id))
6348 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
6350 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
6354 clib_warning ("parse error '%U'", format_unformat_error, i);
6359 if (sw_if_index_set == 0)
6361 errmsg ("missing interface name or sw_if_index\n");
6364 if (v4_address_set && v6_address_set)
6366 errmsg ("both v4 and v6 addresses set\n");
6369 if (!v4_address_set && !v6_address_set)
6371 errmsg ("no address set\n");
6375 /* Construct the API message */
6376 M (IP_NEIGHBOR_ADD_DEL, ip_neighbor_add_del);
6378 mp->sw_if_index = ntohl (sw_if_index);
6379 mp->is_add = is_add;
6380 mp->vrf_id = ntohl (vrf_id);
6381 mp->is_static = is_static;
6383 clib_memcpy (mp->mac_address, mac_address, 6);
6387 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
6391 /* mp->is_ipv6 = 0; via memset in M macro above */
6392 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
6398 /* Wait for a reply, return good/bad news */
6406 api_reset_vrf (vat_main_t * vam)
6408 unformat_input_t *i = vam->input;
6409 vl_api_reset_vrf_t *mp;
6415 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6417 if (unformat (i, "vrf %d", &vrf_id))
6419 else if (unformat (i, "ipv6"))
6423 clib_warning ("parse error '%U'", format_unformat_error, i);
6428 if (vrf_id_set == 0)
6430 errmsg ("missing vrf id\n");
6434 M (RESET_VRF, reset_vrf);
6436 mp->vrf_id = ntohl (vrf_id);
6437 mp->is_ipv6 = is_ipv6;
6446 api_create_vlan_subif (vat_main_t * vam)
6448 unformat_input_t *i = vam->input;
6449 vl_api_create_vlan_subif_t *mp;
6452 u8 sw_if_index_set = 0;
6456 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6458 if (unformat (i, "sw_if_index %d", &sw_if_index))
6459 sw_if_index_set = 1;
6460 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6461 sw_if_index_set = 1;
6462 else if (unformat (i, "vlan %d", &vlan_id))
6466 clib_warning ("parse error '%U'", format_unformat_error, i);
6471 if (sw_if_index_set == 0)
6473 errmsg ("missing interface name or sw_if_index\n");
6477 if (vlan_id_set == 0)
6479 errmsg ("missing vlan_id\n");
6482 M (CREATE_VLAN_SUBIF, create_vlan_subif);
6484 mp->sw_if_index = ntohl (sw_if_index);
6485 mp->vlan_id = ntohl (vlan_id);
6493 #define foreach_create_subif_bit \
6500 _(outer_vlan_id_any) \
6501 _(inner_vlan_id_any)
6504 api_create_subif (vat_main_t * vam)
6506 unformat_input_t *i = vam->input;
6507 vl_api_create_subif_t *mp;
6510 u8 sw_if_index_set = 0;
6517 u32 exact_match = 0;
6518 u32 default_sub = 0;
6519 u32 outer_vlan_id_any = 0;
6520 u32 inner_vlan_id_any = 0;
6522 u16 outer_vlan_id = 0;
6523 u16 inner_vlan_id = 0;
6525 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6527 if (unformat (i, "sw_if_index %d", &sw_if_index))
6528 sw_if_index_set = 1;
6529 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6530 sw_if_index_set = 1;
6531 else if (unformat (i, "sub_id %d", &sub_id))
6533 else if (unformat (i, "outer_vlan_id %d", &tmp))
6534 outer_vlan_id = tmp;
6535 else if (unformat (i, "inner_vlan_id %d", &tmp))
6536 inner_vlan_id = tmp;
6538 #define _(a) else if (unformat (i, #a)) a = 1 ;
6539 foreach_create_subif_bit
6543 clib_warning ("parse error '%U'", format_unformat_error, i);
6548 if (sw_if_index_set == 0)
6550 errmsg ("missing interface name or sw_if_index\n");
6554 if (sub_id_set == 0)
6556 errmsg ("missing sub_id\n");
6559 M (CREATE_SUBIF, create_subif);
6561 mp->sw_if_index = ntohl (sw_if_index);
6562 mp->sub_id = ntohl (sub_id);
6564 #define _(a) mp->a = a;
6565 foreach_create_subif_bit;
6568 mp->outer_vlan_id = ntohs (outer_vlan_id);
6569 mp->inner_vlan_id = ntohs (inner_vlan_id);
6578 api_oam_add_del (vat_main_t * vam)
6580 unformat_input_t *i = vam->input;
6581 vl_api_oam_add_del_t *mp;
6585 ip4_address_t src, dst;
6589 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6591 if (unformat (i, "vrf %d", &vrf_id))
6593 else if (unformat (i, "src %U", unformat_ip4_address, &src))
6595 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
6597 else if (unformat (i, "del"))
6601 clib_warning ("parse error '%U'", format_unformat_error, i);
6608 errmsg ("missing src addr\n");
6614 errmsg ("missing dst addr\n");
6618 M (OAM_ADD_DEL, oam_add_del);
6620 mp->vrf_id = ntohl (vrf_id);
6621 mp->is_add = is_add;
6622 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
6623 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
6632 api_reset_fib (vat_main_t * vam)
6634 unformat_input_t *i = vam->input;
6635 vl_api_reset_fib_t *mp;
6641 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6643 if (unformat (i, "vrf %d", &vrf_id))
6645 else if (unformat (i, "ipv6"))
6649 clib_warning ("parse error '%U'", format_unformat_error, i);
6654 if (vrf_id_set == 0)
6656 errmsg ("missing vrf id\n");
6660 M (RESET_FIB, reset_fib);
6662 mp->vrf_id = ntohl (vrf_id);
6663 mp->is_ipv6 = is_ipv6;
6672 api_dhcp_proxy_config (vat_main_t * vam)
6674 unformat_input_t *i = vam->input;
6675 vl_api_dhcp_proxy_config_t *mp;
6680 u8 v4_address_set = 0;
6681 u8 v6_address_set = 0;
6682 ip4_address_t v4address;
6683 ip6_address_t v6address;
6684 u8 v4_src_address_set = 0;
6685 u8 v6_src_address_set = 0;
6686 ip4_address_t v4srcaddress;
6687 ip6_address_t v6srcaddress;
6689 /* Parse args required to build the message */
6690 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6692 if (unformat (i, "del"))
6694 else if (unformat (i, "vrf %d", &vrf_id))
6696 else if (unformat (i, "insert-cid %d", &insert_cid))
6698 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
6700 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
6702 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
6703 v4_src_address_set = 1;
6704 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
6705 v6_src_address_set = 1;
6710 if (v4_address_set && v6_address_set)
6712 errmsg ("both v4 and v6 server addresses set\n");
6715 if (!v4_address_set && !v6_address_set)
6717 errmsg ("no server addresses set\n");
6721 if (v4_src_address_set && v6_src_address_set)
6723 errmsg ("both v4 and v6 src addresses set\n");
6726 if (!v4_src_address_set && !v6_src_address_set)
6728 errmsg ("no src addresses set\n");
6732 if (!(v4_src_address_set && v4_address_set) &&
6733 !(v6_src_address_set && v6_address_set))
6735 errmsg ("no matching server and src addresses set\n");
6739 /* Construct the API message */
6740 M (DHCP_PROXY_CONFIG, dhcp_proxy_config);
6742 mp->insert_circuit_id = insert_cid;
6743 mp->is_add = is_add;
6744 mp->vrf_id = ntohl (vrf_id);
6748 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
6749 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
6753 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
6754 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
6760 /* Wait for a reply, return good/bad news */
6767 api_dhcp_proxy_config_2 (vat_main_t * vam)
6769 unformat_input_t *i = vam->input;
6770 vl_api_dhcp_proxy_config_2_t *mp;
6773 u32 server_vrf_id = 0;
6776 u8 v4_address_set = 0;
6777 u8 v6_address_set = 0;
6778 ip4_address_t v4address;
6779 ip6_address_t v6address;
6780 u8 v4_src_address_set = 0;
6781 u8 v6_src_address_set = 0;
6782 ip4_address_t v4srcaddress;
6783 ip6_address_t v6srcaddress;
6785 /* Parse args required to build the message */
6786 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6788 if (unformat (i, "del"))
6790 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
6792 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
6794 else if (unformat (i, "insert-cid %d", &insert_cid))
6796 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
6798 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
6800 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
6801 v4_src_address_set = 1;
6802 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
6803 v6_src_address_set = 1;
6808 if (v4_address_set && v6_address_set)
6810 errmsg ("both v4 and v6 server addresses set\n");
6813 if (!v4_address_set && !v6_address_set)
6815 errmsg ("no server addresses set\n");
6819 if (v4_src_address_set && v6_src_address_set)
6821 errmsg ("both v4 and v6 src addresses set\n");
6824 if (!v4_src_address_set && !v6_src_address_set)
6826 errmsg ("no src addresses set\n");
6830 if (!(v4_src_address_set && v4_address_set) &&
6831 !(v6_src_address_set && v6_address_set))
6833 errmsg ("no matching server and src addresses set\n");
6837 /* Construct the API message */
6838 M (DHCP_PROXY_CONFIG_2, dhcp_proxy_config_2);
6840 mp->insert_circuit_id = insert_cid;
6841 mp->is_add = is_add;
6842 mp->rx_vrf_id = ntohl (rx_vrf_id);
6843 mp->server_vrf_id = ntohl (server_vrf_id);
6847 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
6848 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
6852 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
6853 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
6859 /* Wait for a reply, return good/bad news */
6866 api_dhcp_proxy_set_vss (vat_main_t * vam)
6868 unformat_input_t *i = vam->input;
6869 vl_api_dhcp_proxy_set_vss_t *mp;
6880 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6882 if (unformat (i, "tbl_id %d", &tbl_id))
6884 if (unformat (i, "fib_id %d", &fib_id))
6886 if (unformat (i, "oui %d", &oui))
6888 else if (unformat (i, "ipv6"))
6890 else if (unformat (i, "del"))
6894 clib_warning ("parse error '%U'", format_unformat_error, i);
6899 if (tbl_id_set == 0)
6901 errmsg ("missing tbl id\n");
6905 if (fib_id_set == 0)
6907 errmsg ("missing fib id\n");
6912 errmsg ("missing oui\n");
6916 M (DHCP_PROXY_SET_VSS, dhcp_proxy_set_vss);
6917 mp->tbl_id = ntohl (tbl_id);
6918 mp->fib_id = ntohl (fib_id);
6919 mp->oui = ntohl (oui);
6920 mp->is_ipv6 = is_ipv6;
6921 mp->is_add = is_add;
6930 api_dhcp_client_config (vat_main_t * vam)
6932 unformat_input_t *i = vam->input;
6933 vl_api_dhcp_client_config_t *mp;
6936 u8 sw_if_index_set = 0;
6939 u8 disable_event = 0;
6941 /* Parse args required to build the message */
6942 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6944 if (unformat (i, "del"))
6946 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6947 sw_if_index_set = 1;
6948 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6949 sw_if_index_set = 1;
6950 else if (unformat (i, "hostname %s", &hostname))
6952 else if (unformat (i, "disable_event"))
6958 if (sw_if_index_set == 0)
6960 errmsg ("missing interface name or sw_if_index\n");
6964 if (vec_len (hostname) > 63)
6966 errmsg ("hostname too long\n");
6968 vec_add1 (hostname, 0);
6970 /* Construct the API message */
6971 M (DHCP_CLIENT_CONFIG, dhcp_client_config);
6973 mp->sw_if_index = ntohl (sw_if_index);
6974 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
6975 vec_free (hostname);
6976 mp->is_add = is_add;
6977 mp->want_dhcp_event = disable_event ? 0 : 1;
6978 mp->pid = getpid ();
6983 /* Wait for a reply, return good/bad news */
6990 api_set_ip_flow_hash (vat_main_t * vam)
6992 unformat_input_t *i = vam->input;
6993 vl_api_set_ip_flow_hash_t *mp;
7005 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7007 if (unformat (i, "vrf %d", &vrf_id))
7009 else if (unformat (i, "ipv6"))
7011 else if (unformat (i, "src"))
7013 else if (unformat (i, "dst"))
7015 else if (unformat (i, "sport"))
7017 else if (unformat (i, "dport"))
7019 else if (unformat (i, "proto"))
7021 else if (unformat (i, "reverse"))
7026 clib_warning ("parse error '%U'", format_unformat_error, i);
7031 if (vrf_id_set == 0)
7033 errmsg ("missing vrf id\n");
7037 M (SET_IP_FLOW_HASH, set_ip_flow_hash);
7043 mp->reverse = reverse;
7044 mp->vrf_id = ntohl (vrf_id);
7045 mp->is_ipv6 = is_ipv6;
7054 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
7056 unformat_input_t *i = vam->input;
7057 vl_api_sw_interface_ip6_enable_disable_t *mp;
7060 u8 sw_if_index_set = 0;
7063 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7065 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7066 sw_if_index_set = 1;
7067 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7068 sw_if_index_set = 1;
7069 else if (unformat (i, "enable"))
7071 else if (unformat (i, "disable"))
7075 clib_warning ("parse error '%U'", format_unformat_error, i);
7080 if (sw_if_index_set == 0)
7082 errmsg ("missing interface name or sw_if_index\n");
7086 M (SW_INTERFACE_IP6_ENABLE_DISABLE, sw_interface_ip6_enable_disable);
7088 mp->sw_if_index = ntohl (sw_if_index);
7089 mp->enable = enable;
7098 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
7100 unformat_input_t *i = vam->input;
7101 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
7104 u8 sw_if_index_set = 0;
7105 u32 address_length = 0;
7106 u8 v6_address_set = 0;
7107 ip6_address_t v6address;
7109 /* Parse args required to build the message */
7110 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7112 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7113 sw_if_index_set = 1;
7114 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7115 sw_if_index_set = 1;
7116 else if (unformat (i, "%U/%d",
7117 unformat_ip6_address, &v6address, &address_length))
7123 if (sw_if_index_set == 0)
7125 errmsg ("missing interface name or sw_if_index\n");
7128 if (!v6_address_set)
7130 errmsg ("no address set\n");
7134 /* Construct the API message */
7135 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS,
7136 sw_interface_ip6_set_link_local_address);
7138 mp->sw_if_index = ntohl (sw_if_index);
7139 clib_memcpy (mp->address, &v6address, sizeof (v6address));
7140 mp->address_length = address_length;
7145 /* Wait for a reply, return good/bad news */
7154 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
7156 unformat_input_t *i = vam->input;
7157 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
7160 u8 sw_if_index_set = 0;
7161 u32 address_length = 0;
7162 u8 v6_address_set = 0;
7163 ip6_address_t v6address;
7165 u8 no_advertise = 0;
7167 u8 no_autoconfig = 0;
7170 u32 val_lifetime = 0;
7171 u32 pref_lifetime = 0;
7173 /* Parse args required to build the message */
7174 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7176 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7177 sw_if_index_set = 1;
7178 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7179 sw_if_index_set = 1;
7180 else if (unformat (i, "%U/%d",
7181 unformat_ip6_address, &v6address, &address_length))
7183 else if (unformat (i, "val_life %d", &val_lifetime))
7185 else if (unformat (i, "pref_life %d", &pref_lifetime))
7187 else if (unformat (i, "def"))
7189 else if (unformat (i, "noadv"))
7191 else if (unformat (i, "offl"))
7193 else if (unformat (i, "noauto"))
7195 else if (unformat (i, "nolink"))
7197 else if (unformat (i, "isno"))
7201 clib_warning ("parse error '%U'", format_unformat_error, i);
7206 if (sw_if_index_set == 0)
7208 errmsg ("missing interface name or sw_if_index\n");
7211 if (!v6_address_set)
7213 errmsg ("no address set\n");
7217 /* Construct the API message */
7218 M (SW_INTERFACE_IP6ND_RA_PREFIX, sw_interface_ip6nd_ra_prefix);
7220 mp->sw_if_index = ntohl (sw_if_index);
7221 clib_memcpy (mp->address, &v6address, sizeof (v6address));
7222 mp->address_length = address_length;
7223 mp->use_default = use_default;
7224 mp->no_advertise = no_advertise;
7225 mp->off_link = off_link;
7226 mp->no_autoconfig = no_autoconfig;
7227 mp->no_onlink = no_onlink;
7229 mp->val_lifetime = ntohl (val_lifetime);
7230 mp->pref_lifetime = ntohl (pref_lifetime);
7235 /* Wait for a reply, return good/bad news */
7243 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
7245 unformat_input_t *i = vam->input;
7246 vl_api_sw_interface_ip6nd_ra_config_t *mp;
7249 u8 sw_if_index_set = 0;
7254 u8 send_unicast = 0;
7257 u8 default_router = 0;
7258 u32 max_interval = 0;
7259 u32 min_interval = 0;
7261 u32 initial_count = 0;
7262 u32 initial_interval = 0;
7265 /* Parse args required to build the message */
7266 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7268 if (unformat (i, "%U", 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, "maxint %d", &max_interval))
7274 else if (unformat (i, "minint %d", &min_interval))
7276 else if (unformat (i, "life %d", &lifetime))
7278 else if (unformat (i, "count %d", &initial_count))
7280 else if (unformat (i, "interval %d", &initial_interval))
7282 else if (unformat (i, "suppress") || unformat (i, "surpress"))
7284 else if (unformat (i, "managed"))
7286 else if (unformat (i, "other"))
7288 else if (unformat (i, "ll"))
7290 else if (unformat (i, "send"))
7292 else if (unformat (i, "cease"))
7294 else if (unformat (i, "isno"))
7296 else if (unformat (i, "def"))
7300 clib_warning ("parse error '%U'", format_unformat_error, i);
7305 if (sw_if_index_set == 0)
7307 errmsg ("missing interface name or sw_if_index\n");
7311 /* Construct the API message */
7312 M (SW_INTERFACE_IP6ND_RA_CONFIG, sw_interface_ip6nd_ra_config);
7314 mp->sw_if_index = ntohl (sw_if_index);
7315 mp->max_interval = ntohl (max_interval);
7316 mp->min_interval = ntohl (min_interval);
7317 mp->lifetime = ntohl (lifetime);
7318 mp->initial_count = ntohl (initial_count);
7319 mp->initial_interval = ntohl (initial_interval);
7320 mp->suppress = suppress;
7321 mp->managed = managed;
7323 mp->ll_option = ll_option;
7324 mp->send_unicast = send_unicast;
7327 mp->default_router = default_router;
7332 /* Wait for a reply, return good/bad news */
7340 api_set_arp_neighbor_limit (vat_main_t * vam)
7342 unformat_input_t *i = vam->input;
7343 vl_api_set_arp_neighbor_limit_t *mp;
7349 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7351 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
7353 else if (unformat (i, "ipv6"))
7357 clib_warning ("parse error '%U'", format_unformat_error, i);
7364 errmsg ("missing limit value\n");
7368 M (SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit);
7370 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
7371 mp->is_ipv6 = is_ipv6;
7380 api_l2_patch_add_del (vat_main_t * vam)
7382 unformat_input_t *i = vam->input;
7383 vl_api_l2_patch_add_del_t *mp;
7386 u8 rx_sw_if_index_set = 0;
7388 u8 tx_sw_if_index_set = 0;
7391 /* Parse args required to build the message */
7392 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7394 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
7395 rx_sw_if_index_set = 1;
7396 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
7397 tx_sw_if_index_set = 1;
7398 else if (unformat (i, "rx"))
7400 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7402 if (unformat (i, "%U", unformat_sw_if_index, vam,
7404 rx_sw_if_index_set = 1;
7409 else if (unformat (i, "tx"))
7411 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7413 if (unformat (i, "%U", unformat_sw_if_index, vam,
7415 tx_sw_if_index_set = 1;
7420 else if (unformat (i, "del"))
7426 if (rx_sw_if_index_set == 0)
7428 errmsg ("missing rx interface name or rx_sw_if_index\n");
7432 if (tx_sw_if_index_set == 0)
7434 errmsg ("missing tx interface name or tx_sw_if_index\n");
7438 M (L2_PATCH_ADD_DEL, l2_patch_add_del);
7440 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
7441 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
7442 mp->is_add = is_add;
7451 api_ioam_enable (vat_main_t * vam)
7453 unformat_input_t *input = vam->input;
7454 vl_api_ioam_enable_t *mp;
7457 int has_trace_option = 0;
7458 int has_pow_option = 0;
7459 int has_ppc_option = 0;
7461 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7463 if (unformat (input, "trace"))
7464 has_trace_option = 1;
7465 else if (unformat (input, "pow"))
7467 else if (unformat (input, "ppc encap"))
7468 has_ppc_option = PPC_ENCAP;
7469 else if (unformat (input, "ppc decap"))
7470 has_ppc_option = PPC_DECAP;
7471 else if (unformat (input, "ppc none"))
7472 has_ppc_option = PPC_NONE;
7476 M (IOAM_ENABLE, ioam_enable);
7477 mp->id = htons (id);
7478 mp->trace_ppc = has_ppc_option;
7479 mp->pow_enable = has_pow_option;
7480 mp->trace_enable = has_trace_option;
7491 api_ioam_disable (vat_main_t * vam)
7493 vl_api_ioam_disable_t *mp;
7496 M (IOAM_DISABLE, ioam_disable);
7503 api_sr_tunnel_add_del (vat_main_t * vam)
7505 unformat_input_t *i = vam->input;
7506 vl_api_sr_tunnel_add_del_t *mp;
7510 ip6_address_t src_address;
7511 int src_address_set = 0;
7512 ip6_address_t dst_address;
7514 int dst_address_set = 0;
7516 u32 rx_table_id = 0;
7517 u32 tx_table_id = 0;
7518 ip6_address_t *segments = 0;
7519 ip6_address_t *this_seg;
7520 ip6_address_t *tags = 0;
7521 ip6_address_t *this_tag;
7522 ip6_address_t next_address, tag;
7524 u8 *policy_name = 0;
7526 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7528 if (unformat (i, "del"))
7530 else if (unformat (i, "name %s", &name))
7532 else if (unformat (i, "policy %s", &policy_name))
7534 else if (unformat (i, "rx_fib_id %d", &rx_table_id))
7536 else if (unformat (i, "tx_fib_id %d", &tx_table_id))
7538 else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
7539 src_address_set = 1;
7540 else if (unformat (i, "dst %U/%d",
7541 unformat_ip6_address, &dst_address, &dst_mask_width))
7542 dst_address_set = 1;
7543 else if (unformat (i, "next %U", unformat_ip6_address, &next_address))
7545 vec_add2 (segments, this_seg, 1);
7546 clib_memcpy (this_seg->as_u8, next_address.as_u8,
7547 sizeof (*this_seg));
7549 else if (unformat (i, "tag %U", unformat_ip6_address, &tag))
7551 vec_add2 (tags, this_tag, 1);
7552 clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
7554 else if (unformat (i, "clean"))
7555 flags |= IP6_SR_HEADER_FLAG_CLEANUP;
7556 else if (unformat (i, "protected"))
7557 flags |= IP6_SR_HEADER_FLAG_PROTECTED;
7558 else if (unformat (i, "InPE %d", &pl_index))
7560 if (pl_index <= 0 || pl_index > 4)
7562 pl_index_range_error:
7563 errmsg ("pl index %d out of range\n", pl_index);
7567 IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE << (3 * (pl_index - 1));
7569 else if (unformat (i, "EgPE %d", &pl_index))
7571 if (pl_index <= 0 || pl_index > 4)
7572 goto pl_index_range_error;
7574 IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE << (3 * (pl_index - 1));
7576 else if (unformat (i, "OrgSrc %d", &pl_index))
7578 if (pl_index <= 0 || pl_index > 4)
7579 goto pl_index_range_error;
7581 IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3 * (pl_index - 1));
7587 if (!src_address_set)
7589 errmsg ("src address required\n");
7593 if (!dst_address_set)
7595 errmsg ("dst address required\n");
7601 errmsg ("at least one sr segment required\n");
7605 M2 (SR_TUNNEL_ADD_DEL, sr_tunnel_add_del,
7606 vec_len (segments) * sizeof (ip6_address_t)
7607 + vec_len (tags) * sizeof (ip6_address_t));
7609 clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
7610 clib_memcpy (mp->dst_address, &dst_address, sizeof (mp->dst_address));
7611 mp->dst_mask_width = dst_mask_width;
7612 mp->flags_net_byte_order = clib_host_to_net_u16 (flags);
7613 mp->n_segments = vec_len (segments);
7614 mp->n_tags = vec_len (tags);
7615 mp->is_add = is_del == 0;
7616 clib_memcpy (mp->segs_and_tags, segments,
7617 vec_len (segments) * sizeof (ip6_address_t));
7618 clib_memcpy (mp->segs_and_tags +
7619 vec_len (segments) * sizeof (ip6_address_t), tags,
7620 vec_len (tags) * sizeof (ip6_address_t));
7622 mp->outer_vrf_id = ntohl (rx_table_id);
7623 mp->inner_vrf_id = ntohl (tx_table_id);
7624 memcpy (mp->name, name, vec_len (name));
7625 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
7627 vec_free (segments);
7636 api_sr_policy_add_del (vat_main_t * vam)
7638 unformat_input_t *input = vam->input;
7639 vl_api_sr_policy_add_del_t *mp;
7643 u8 *tunnel_name = 0;
7644 u8 **tunnel_names = 0;
7649 int tunnel_names_length = 1; // Init to 1 to offset the #tunnel_names counter byte
7650 int tun_name_len = 0; // Different naming convention used as confusing these would be "bad" (TM)
7652 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7654 if (unformat (input, "del"))
7656 else if (unformat (input, "name %s", &name))
7658 else if (unformat (input, "tunnel %s", &tunnel_name))
7662 vec_add1 (tunnel_names, tunnel_name);
7664 - length = #bytes to store in serial vector
7665 - +1 = byte to store that length
7667 tunnel_names_length += (vec_len (tunnel_name) + 1);
7678 errmsg ("policy name required\n");
7682 if ((!tunnel_set) && (!is_del))
7684 errmsg ("tunnel name required\n");
7688 M2 (SR_POLICY_ADD_DEL, sr_policy_add_del, tunnel_names_length);
7692 mp->is_add = !is_del;
7694 memcpy (mp->name, name, vec_len (name));
7695 // Since mp->tunnel_names is of type u8[0] and not a u8 *, u8 ** needs to be serialized
7696 u8 *serial_orig = 0;
7697 vec_validate (serial_orig, tunnel_names_length);
7698 *serial_orig = vec_len (tunnel_names); // Store the number of tunnels as length in first byte of serialized vector
7699 serial_orig += 1; // Move along one byte to store the length of first tunnel_name
7701 for (j = 0; j < vec_len (tunnel_names); j++)
7703 tun_name_len = vec_len (tunnel_names[j]);
7704 *serial_orig = tun_name_len; // Store length of tunnel name in first byte of Length/Value pair
7705 serial_orig += 1; // Move along one byte to store the actual tunnel name
7706 memcpy (serial_orig, tunnel_names[j], tun_name_len);
7707 serial_orig += tun_name_len; // Advance past the copy
7709 memcpy (mp->tunnel_names, serial_orig - tunnel_names_length, tunnel_names_length); // Regress serial_orig to head then copy fwd
7711 vec_free (tunnel_names);
7712 vec_free (tunnel_name);
7720 api_sr_multicast_map_add_del (vat_main_t * vam)
7722 unformat_input_t *input = vam->input;
7723 vl_api_sr_multicast_map_add_del_t *mp;
7726 ip6_address_t multicast_address;
7727 u8 *policy_name = 0;
7728 int multicast_address_set = 0;
7730 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7732 if (unformat (input, "del"))
7736 (input, "address %U", unformat_ip6_address, &multicast_address))
7737 multicast_address_set = 1;
7738 else if (unformat (input, "sr-policy %s", &policy_name))
7744 if (!is_del && !policy_name)
7746 errmsg ("sr-policy name required\n");
7751 if (!multicast_address_set)
7753 errmsg ("address required\n");
7757 M (SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del);
7759 mp->is_add = !is_del;
7760 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
7761 clib_memcpy (mp->multicast_address, &multicast_address,
7762 sizeof (mp->multicast_address));
7765 vec_free (policy_name);
7773 #define foreach_ip4_proto_field \
7784 unformat_ip4_mask (unformat_input_t * input, va_list * args)
7786 u8 **maskp = va_arg (*args, u8 **);
7788 u8 found_something = 0;
7791 #define _(a) u8 a=0;
7792 foreach_ip4_proto_field;
7798 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7800 if (unformat (input, "version"))
7802 else if (unformat (input, "hdr_length"))
7804 else if (unformat (input, "src"))
7806 else if (unformat (input, "dst"))
7808 else if (unformat (input, "proto"))
7811 #define _(a) else if (unformat (input, #a)) a=1;
7812 foreach_ip4_proto_field
7818 #define _(a) found_something += a;
7819 foreach_ip4_proto_field;
7822 if (found_something == 0)
7825 vec_validate (mask, sizeof (*ip) - 1);
7827 ip = (ip4_header_t *) mask;
7829 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
7830 foreach_ip4_proto_field;
7833 ip->ip_version_and_header_length = 0;
7836 ip->ip_version_and_header_length |= 0xF0;
7839 ip->ip_version_and_header_length |= 0x0F;
7845 #define foreach_ip6_proto_field \
7853 unformat_ip6_mask (unformat_input_t * input, va_list * args)
7855 u8 **maskp = va_arg (*args, u8 **);
7857 u8 found_something = 0;
7859 u32 ip_version_traffic_class_and_flow_label;
7861 #define _(a) u8 a=0;
7862 foreach_ip6_proto_field;
7865 u8 traffic_class = 0;
7868 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7870 if (unformat (input, "version"))
7872 else if (unformat (input, "traffic-class"))
7874 else if (unformat (input, "flow-label"))
7876 else if (unformat (input, "src"))
7878 else if (unformat (input, "dst"))
7880 else if (unformat (input, "proto"))
7883 #define _(a) else if (unformat (input, #a)) a=1;
7884 foreach_ip6_proto_field
7890 #define _(a) found_something += a;
7891 foreach_ip6_proto_field;
7894 if (found_something == 0)
7897 vec_validate (mask, sizeof (*ip) - 1);
7899 ip = (ip6_header_t *) mask;
7901 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
7902 foreach_ip6_proto_field;
7905 ip_version_traffic_class_and_flow_label = 0;
7908 ip_version_traffic_class_and_flow_label |= 0xF0000000;
7911 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
7914 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
7916 ip->ip_version_traffic_class_and_flow_label =
7917 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
7924 unformat_l3_mask (unformat_input_t * input, va_list * args)
7926 u8 **maskp = va_arg (*args, u8 **);
7928 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7930 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
7932 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
7941 unformat_l2_mask (unformat_input_t * input, va_list * args)
7943 u8 **maskp = va_arg (*args, u8 **);
7958 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7960 if (unformat (input, "src"))
7962 else if (unformat (input, "dst"))
7964 else if (unformat (input, "proto"))
7966 else if (unformat (input, "tag1"))
7968 else if (unformat (input, "tag2"))
7970 else if (unformat (input, "ignore-tag1"))
7972 else if (unformat (input, "ignore-tag2"))
7974 else if (unformat (input, "cos1"))
7976 else if (unformat (input, "cos2"))
7978 else if (unformat (input, "dot1q"))
7980 else if (unformat (input, "dot1ad"))
7985 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
7986 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
7989 if (tag1 || ignore_tag1 || cos1 || dot1q)
7991 if (tag2 || ignore_tag2 || cos2 || dot1ad)
7994 vec_validate (mask, len - 1);
7997 memset (mask, 0xff, 6);
8000 memset (mask + 6, 0xff, 6);
8004 /* inner vlan tag */
8013 mask[21] = mask[20] = 0xff;
8034 mask[16] = mask[17] = 0xff;
8044 mask[12] = mask[13] = 0xff;
8051 unformat_classify_mask (unformat_input_t * input, va_list * args)
8053 u8 **maskp = va_arg (*args, u8 **);
8054 u32 *skipp = va_arg (*args, u32 *);
8055 u32 *matchp = va_arg (*args, u32 *);
8062 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8064 if (unformat (input, "hex %U", unformat_hex_string, &mask))
8066 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
8068 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
8074 if (mask || l2 || l3)
8078 /* "With a free Ethernet header in every package" */
8080 vec_validate (l2, 13);
8084 vec_append (mask, l3);
8089 /* Scan forward looking for the first significant mask octet */
8090 for (i = 0; i < vec_len (mask); i++)
8094 /* compute (skip, match) params */
8095 *skipp = i / sizeof (u32x4);
8096 vec_delete (mask, *skipp * sizeof (u32x4), 0);
8098 /* Pad mask to an even multiple of the vector size */
8099 while (vec_len (mask) % sizeof (u32x4))
8102 match = vec_len (mask) / sizeof (u32x4);
8104 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
8106 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
8107 if (*tmp || *(tmp + 1))
8112 clib_warning ("BUG: match 0");
8114 _vec_len (mask) = match * sizeof (u32x4);
8125 #define foreach_l2_next \
8127 _(ethernet, ETHERNET_INPUT) \
8132 unformat_l2_next_index (unformat_input_t * input, va_list * args)
8134 u32 *miss_next_indexp = va_arg (*args, u32 *);
8139 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
8143 if (unformat (input, "%d", &tmp))
8152 *miss_next_indexp = next_index;
8156 #define foreach_ip_next \
8162 unformat_ip_next_index (unformat_input_t * input, va_list * args)
8164 u32 *miss_next_indexp = va_arg (*args, u32 *);
8169 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
8173 if (unformat (input, "%d", &tmp))
8182 *miss_next_indexp = next_index;
8186 #define foreach_acl_next \
8190 unformat_acl_next_index (unformat_input_t * input, va_list * args)
8192 u32 *miss_next_indexp = va_arg (*args, u32 *);
8197 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
8201 if (unformat (input, "permit"))
8206 else if (unformat (input, "%d", &tmp))
8215 *miss_next_indexp = next_index;
8220 unformat_policer_precolor (unformat_input_t * input, va_list * args)
8222 u32 *r = va_arg (*args, u32 *);
8224 if (unformat (input, "conform-color"))
8225 *r = POLICE_CONFORM;
8226 else if (unformat (input, "exceed-color"))
8235 api_classify_add_del_table (vat_main_t * vam)
8237 unformat_input_t *i = vam->input;
8238 vl_api_classify_add_del_table_t *mp;
8244 u32 table_index = ~0;
8245 u32 next_table_index = ~0;
8246 u32 miss_next_index = ~0;
8247 u32 memory_size = 32 << 20;
8251 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8253 if (unformat (i, "del"))
8255 else if (unformat (i, "buckets %d", &nbuckets))
8257 else if (unformat (i, "memory_size %d", &memory_size))
8259 else if (unformat (i, "skip %d", &skip))
8261 else if (unformat (i, "match %d", &match))
8263 else if (unformat (i, "table %d", &table_index))
8265 else if (unformat (i, "mask %U", unformat_classify_mask,
8266 &mask, &skip, &match))
8268 else if (unformat (i, "next-table %d", &next_table_index))
8270 else if (unformat (i, "miss-next %U", unformat_ip_next_index,
8273 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
8276 else if (unformat (i, "acl-miss-next %U", unformat_acl_next_index,
8283 if (is_add && mask == 0)
8285 errmsg ("Mask required\n");
8289 if (is_add && skip == ~0)
8291 errmsg ("skip count required\n");
8295 if (is_add && match == ~0)
8297 errmsg ("match count required\n");
8301 if (!is_add && table_index == ~0)
8303 errmsg ("table index required for delete\n");
8307 M2 (CLASSIFY_ADD_DEL_TABLE, classify_add_del_table, vec_len (mask));
8309 mp->is_add = is_add;
8310 mp->table_index = ntohl (table_index);
8311 mp->nbuckets = ntohl (nbuckets);
8312 mp->memory_size = ntohl (memory_size);
8313 mp->skip_n_vectors = ntohl (skip);
8314 mp->match_n_vectors = ntohl (match);
8315 mp->next_table_index = ntohl (next_table_index);
8316 mp->miss_next_index = ntohl (miss_next_index);
8317 clib_memcpy (mp->mask, mask, vec_len (mask));
8327 unformat_ip4_match (unformat_input_t * input, va_list * args)
8329 u8 **matchp = va_arg (*args, u8 **);
8336 int src = 0, dst = 0;
8337 ip4_address_t src_val, dst_val;
8344 int fragment_id = 0;
8345 u32 fragment_id_val;
8351 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8353 if (unformat (input, "version %d", &version_val))
8355 else if (unformat (input, "hdr_length %d", &hdr_length_val))
8357 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
8359 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
8361 else if (unformat (input, "proto %d", &proto_val))
8363 else if (unformat (input, "tos %d", &tos_val))
8365 else if (unformat (input, "length %d", &length_val))
8367 else if (unformat (input, "fragment_id %d", &fragment_id_val))
8369 else if (unformat (input, "ttl %d", &ttl_val))
8371 else if (unformat (input, "checksum %d", &checksum_val))
8377 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
8378 + ttl + checksum == 0)
8382 * Aligned because we use the real comparison functions
8384 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
8386 ip = (ip4_header_t *) match;
8388 /* These are realistically matched in practice */
8390 ip->src_address.as_u32 = src_val.as_u32;
8393 ip->dst_address.as_u32 = dst_val.as_u32;
8396 ip->protocol = proto_val;
8399 /* These are not, but they're included for completeness */
8401 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
8404 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
8410 ip->length = length_val;
8416 ip->checksum = checksum_val;
8423 unformat_ip6_match (unformat_input_t * input, va_list * args)
8425 u8 **matchp = va_arg (*args, u8 **);
8430 u8 traffic_class = 0;
8431 u32 traffic_class_val = 0;
8434 int src = 0, dst = 0;
8435 ip6_address_t src_val, dst_val;
8438 int payload_length = 0;
8439 u32 payload_length_val;
8442 u32 ip_version_traffic_class_and_flow_label;
8444 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8446 if (unformat (input, "version %d", &version_val))
8448 else if (unformat (input, "traffic_class %d", &traffic_class_val))
8450 else if (unformat (input, "flow_label %d", &flow_label_val))
8452 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
8454 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
8456 else if (unformat (input, "proto %d", &proto_val))
8458 else if (unformat (input, "payload_length %d", &payload_length_val))
8460 else if (unformat (input, "hop_limit %d", &hop_limit_val))
8466 if (version + traffic_class + flow_label + src + dst + proto +
8467 payload_length + hop_limit == 0)
8471 * Aligned because we use the real comparison functions
8473 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
8475 ip = (ip6_header_t *) match;
8478 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
8481 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
8484 ip->protocol = proto_val;
8486 ip_version_traffic_class_and_flow_label = 0;
8489 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
8492 ip_version_traffic_class_and_flow_label |=
8493 (traffic_class_val & 0xFF) << 20;
8496 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
8498 ip->ip_version_traffic_class_and_flow_label =
8499 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
8502 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
8505 ip->hop_limit = hop_limit_val;
8512 unformat_l3_match (unformat_input_t * input, va_list * args)
8514 u8 **matchp = va_arg (*args, u8 **);
8516 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8518 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
8520 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
8529 unformat_vlan_tag (unformat_input_t * input, va_list * args)
8531 u8 *tagp = va_arg (*args, u8 *);
8534 if (unformat (input, "%d", &tag))
8536 tagp[0] = (tag >> 8) & 0x0F;
8537 tagp[1] = tag & 0xFF;
8545 unformat_l2_match (unformat_input_t * input, va_list * args)
8547 u8 **matchp = va_arg (*args, u8 **);
8567 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8569 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
8572 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
8574 else if (unformat (input, "proto %U",
8575 unformat_ethernet_type_host_byte_order, &proto_val))
8577 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
8579 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
8581 else if (unformat (input, "ignore-tag1"))
8583 else if (unformat (input, "ignore-tag2"))
8585 else if (unformat (input, "cos1 %d", &cos1_val))
8587 else if (unformat (input, "cos2 %d", &cos2_val))
8592 if ((src + dst + proto + tag1 + tag2 +
8593 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
8596 if (tag1 || ignore_tag1 || cos1)
8598 if (tag2 || ignore_tag2 || cos2)
8601 vec_validate_aligned (match, len - 1, sizeof (u32x4));
8604 clib_memcpy (match, dst_val, 6);
8607 clib_memcpy (match + 6, src_val, 6);
8611 /* inner vlan tag */
8612 match[19] = tag2_val[1];
8613 match[18] = tag2_val[0];
8615 match[18] |= (cos2_val & 0x7) << 5;
8618 match[21] = proto_val & 0xff;
8619 match[20] = proto_val >> 8;
8623 match[15] = tag1_val[1];
8624 match[14] = tag1_val[0];
8627 match[14] |= (cos1_val & 0x7) << 5;
8633 match[15] = tag1_val[1];
8634 match[14] = tag1_val[0];
8637 match[17] = proto_val & 0xff;
8638 match[16] = proto_val >> 8;
8641 match[14] |= (cos1_val & 0x7) << 5;
8647 match[18] |= (cos2_val & 0x7) << 5;
8649 match[14] |= (cos1_val & 0x7) << 5;
8652 match[13] = proto_val & 0xff;
8653 match[12] = proto_val >> 8;
8662 unformat_classify_match (unformat_input_t * input, va_list * args)
8664 u8 **matchp = va_arg (*args, u8 **);
8665 u32 skip_n_vectors = va_arg (*args, u32);
8666 u32 match_n_vectors = va_arg (*args, u32);
8672 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8674 if (unformat (input, "hex %U", unformat_hex_string, &match))
8676 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
8678 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
8684 if (match || l2 || l3)
8688 /* "Win a free Ethernet header in every packet" */
8690 vec_validate_aligned (l2, 13, sizeof (u32x4));
8694 vec_append_aligned (match, l3, sizeof (u32x4));
8699 /* Make sure the vector is big enough even if key is all 0's */
8700 vec_validate_aligned
8701 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
8704 /* Set size, include skipped vectors */
8705 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
8716 api_classify_add_del_session (vat_main_t * vam)
8718 unformat_input_t *i = vam->input;
8719 vl_api_classify_add_del_session_t *mp;
8721 u32 table_index = ~0;
8722 u32 hit_next_index = ~0;
8723 u32 opaque_index = ~0;
8727 u32 skip_n_vectors = 0;
8728 u32 match_n_vectors = 0;
8731 * Warning: you have to supply skip_n and match_n
8732 * because the API client cant simply look at the classify
8736 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8738 if (unformat (i, "del"))
8740 else if (unformat (i, "hit-next %U", unformat_ip_next_index,
8743 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
8746 else if (unformat (i, "acl-hit-next %U", unformat_acl_next_index,
8749 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
8751 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
8753 else if (unformat (i, "opaque-index %d", &opaque_index))
8755 else if (unformat (i, "skip_n %d", &skip_n_vectors))
8757 else if (unformat (i, "match_n %d", &match_n_vectors))
8759 else if (unformat (i, "match %U", unformat_classify_match,
8760 &match, skip_n_vectors, match_n_vectors))
8762 else if (unformat (i, "advance %d", &advance))
8764 else if (unformat (i, "table-index %d", &table_index))
8770 if (table_index == ~0)
8772 errmsg ("Table index required\n");
8776 if (is_add && match == 0)
8778 errmsg ("Match value required\n");
8782 M2 (CLASSIFY_ADD_DEL_SESSION, classify_add_del_session, vec_len (match));
8784 mp->is_add = is_add;
8785 mp->table_index = ntohl (table_index);
8786 mp->hit_next_index = ntohl (hit_next_index);
8787 mp->opaque_index = ntohl (opaque_index);
8788 mp->advance = ntohl (advance);
8789 clib_memcpy (mp->match, match, vec_len (match));
8798 api_classify_set_interface_ip_table (vat_main_t * vam)
8800 unformat_input_t *i = vam->input;
8801 vl_api_classify_set_interface_ip_table_t *mp;
8804 int sw_if_index_set;
8805 u32 table_index = ~0;
8808 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8810 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8811 sw_if_index_set = 1;
8812 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8813 sw_if_index_set = 1;
8814 else if (unformat (i, "table %d", &table_index))
8818 clib_warning ("parse error '%U'", format_unformat_error, i);
8823 if (sw_if_index_set == 0)
8825 errmsg ("missing interface name or sw_if_index\n");
8830 M (CLASSIFY_SET_INTERFACE_IP_TABLE, classify_set_interface_ip_table);
8832 mp->sw_if_index = ntohl (sw_if_index);
8833 mp->table_index = ntohl (table_index);
8834 mp->is_ipv6 = is_ipv6;
8843 api_classify_set_interface_l2_tables (vat_main_t * vam)
8845 unformat_input_t *i = vam->input;
8846 vl_api_classify_set_interface_l2_tables_t *mp;
8849 int sw_if_index_set;
8850 u32 ip4_table_index = ~0;
8851 u32 ip6_table_index = ~0;
8852 u32 other_table_index = ~0;
8855 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8857 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8858 sw_if_index_set = 1;
8859 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8860 sw_if_index_set = 1;
8861 else if (unformat (i, "ip4-table %d", &ip4_table_index))
8863 else if (unformat (i, "ip6-table %d", &ip6_table_index))
8865 else if (unformat (i, "other-table %d", &other_table_index))
8867 else if (unformat (i, "is-input %d", &is_input))
8871 clib_warning ("parse error '%U'", format_unformat_error, i);
8876 if (sw_if_index_set == 0)
8878 errmsg ("missing interface name or sw_if_index\n");
8883 M (CLASSIFY_SET_INTERFACE_L2_TABLES, classify_set_interface_l2_tables);
8885 mp->sw_if_index = ntohl (sw_if_index);
8886 mp->ip4_table_index = ntohl (ip4_table_index);
8887 mp->ip6_table_index = ntohl (ip6_table_index);
8888 mp->other_table_index = ntohl (other_table_index);
8889 mp->is_input = (u8) is_input;
8898 api_set_ipfix_exporter (vat_main_t * vam)
8900 unformat_input_t *i = vam->input;
8901 vl_api_set_ipfix_exporter_t *mp;
8902 ip4_address_t collector_address;
8903 u8 collector_address_set = 0;
8904 u32 collector_port = ~0;
8905 ip4_address_t src_address;
8906 u8 src_address_set = 0;
8909 u32 template_interval = ~0;
8910 u8 udp_checksum = 0;
8913 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8915 if (unformat (i, "collector_address %U", unformat_ip4_address,
8916 &collector_address))
8917 collector_address_set = 1;
8918 else if (unformat (i, "collector_port %d", &collector_port))
8920 else if (unformat (i, "src_address %U", unformat_ip4_address,
8922 src_address_set = 1;
8923 else if (unformat (i, "vrf_id %d", &vrf_id))
8925 else if (unformat (i, "path_mtu %d", &path_mtu))
8927 else if (unformat (i, "template_interval %d", &template_interval))
8929 else if (unformat (i, "udp_checksum"))
8935 if (collector_address_set == 0)
8937 errmsg ("collector_address required\n");
8941 if (src_address_set == 0)
8943 errmsg ("src_address required\n");
8947 M (SET_IPFIX_EXPORTER, set_ipfix_exporter);
8949 memcpy (mp->collector_address, collector_address.data,
8950 sizeof (collector_address.data));
8951 mp->collector_port = htons ((u16) collector_port);
8952 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
8953 mp->vrf_id = htonl (vrf_id);
8954 mp->path_mtu = htonl (path_mtu);
8955 mp->template_interval = htonl (template_interval);
8956 mp->udp_checksum = udp_checksum;
8964 api_set_ipfix_classify_stream (vat_main_t * vam)
8966 unformat_input_t *i = vam->input;
8967 vl_api_set_ipfix_classify_stream_t *mp;
8969 u32 src_port = UDP_DST_PORT_ipfix;
8972 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8974 if (unformat (i, "domain %d", &domain_id))
8976 else if (unformat (i, "src_port %d", &src_port))
8980 errmsg ("unknown input `%U'", format_unformat_error, i);
8985 M (SET_IPFIX_CLASSIFY_STREAM, set_ipfix_classify_stream);
8987 mp->domain_id = htonl (domain_id);
8988 mp->src_port = htons ((u16) src_port);
8996 api_ipfix_classify_table_add_del (vat_main_t * vam)
8998 unformat_input_t *i = vam->input;
8999 vl_api_ipfix_classify_table_add_del_t *mp;
9001 u32 classify_table_index = ~0;
9003 u8 transport_protocol = 255;
9006 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9008 if (unformat (i, "add"))
9010 else if (unformat (i, "del"))
9012 else if (unformat (i, "table %d", &classify_table_index))
9014 else if (unformat (i, "ip4"))
9016 else if (unformat (i, "ip6"))
9018 else if (unformat (i, "tcp"))
9019 transport_protocol = 6;
9020 else if (unformat (i, "udp"))
9021 transport_protocol = 17;
9024 errmsg ("unknown input `%U'", format_unformat_error, i);
9031 errmsg ("expecting: add|del");
9034 if (classify_table_index == ~0)
9036 errmsg ("classifier table not specified");
9039 if (ip_version == 0)
9041 errmsg ("IP version not specified");
9045 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, ipfix_classify_table_add_del);
9047 mp->is_add = is_add;
9048 mp->table_id = htonl (classify_table_index);
9049 mp->ip_version = ip_version;
9050 mp->transport_protocol = transport_protocol;
9058 api_get_node_index (vat_main_t * vam)
9060 unformat_input_t *i = vam->input;
9061 vl_api_get_node_index_t *mp;
9065 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9067 if (unformat (i, "node %s", &name))
9074 errmsg ("node name required\n");
9077 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
9079 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
9083 M (GET_NODE_INDEX, get_node_index);
9084 clib_memcpy (mp->node_name, name, vec_len (name));
9094 api_get_next_index (vat_main_t * vam)
9096 unformat_input_t *i = vam->input;
9097 vl_api_get_next_index_t *mp;
9099 u8 *node_name = 0, *next_node_name = 0;
9101 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9103 if (unformat (i, "node-name %s", &node_name))
9105 else if (unformat (i, "next-node-name %s", &next_node_name))
9111 errmsg ("node name required\n");
9114 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
9116 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
9120 if (next_node_name == 0)
9122 errmsg ("next node name required\n");
9125 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
9127 errmsg ("next node name too long, max %d\n", ARRAY_LEN (mp->next_name));
9131 M (GET_NEXT_INDEX, get_next_index);
9132 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
9133 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
9134 vec_free (node_name);
9135 vec_free (next_node_name);
9144 api_add_node_next (vat_main_t * vam)
9146 unformat_input_t *i = vam->input;
9147 vl_api_add_node_next_t *mp;
9152 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9154 if (unformat (i, "node %s", &name))
9156 else if (unformat (i, "next %s", &next))
9163 errmsg ("node name required\n");
9166 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
9168 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
9173 errmsg ("next node required\n");
9176 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
9178 errmsg ("next name too long, max %d\n", ARRAY_LEN (mp->next_name));
9182 M (ADD_NODE_NEXT, add_node_next);
9183 clib_memcpy (mp->node_name, name, vec_len (name));
9184 clib_memcpy (mp->next_name, next, vec_len (next));
9195 api_l2tpv3_create_tunnel (vat_main_t * vam)
9197 unformat_input_t *i = vam->input;
9198 ip6_address_t client_address, our_address;
9199 int client_address_set = 0;
9200 int our_address_set = 0;
9201 u32 local_session_id = 0;
9202 u32 remote_session_id = 0;
9203 u64 local_cookie = 0;
9204 u64 remote_cookie = 0;
9205 u8 l2_sublayer_present = 0;
9206 vl_api_l2tpv3_create_tunnel_t *mp;
9209 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9211 if (unformat (i, "client_address %U", unformat_ip6_address,
9213 client_address_set = 1;
9214 else if (unformat (i, "our_address %U", unformat_ip6_address,
9216 our_address_set = 1;
9217 else if (unformat (i, "local_session_id %d", &local_session_id))
9219 else if (unformat (i, "remote_session_id %d", &remote_session_id))
9221 else if (unformat (i, "local_cookie %lld", &local_cookie))
9223 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
9225 else if (unformat (i, "l2-sublayer-present"))
9226 l2_sublayer_present = 1;
9231 if (client_address_set == 0)
9233 errmsg ("client_address required\n");
9237 if (our_address_set == 0)
9239 errmsg ("our_address required\n");
9243 M (L2TPV3_CREATE_TUNNEL, l2tpv3_create_tunnel);
9245 clib_memcpy (mp->client_address, client_address.as_u8,
9246 sizeof (mp->client_address));
9248 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
9250 mp->local_session_id = ntohl (local_session_id);
9251 mp->remote_session_id = ntohl (remote_session_id);
9252 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
9253 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
9254 mp->l2_sublayer_present = l2_sublayer_present;
9264 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
9266 unformat_input_t *i = vam->input;
9268 u8 sw_if_index_set = 0;
9269 u64 new_local_cookie = 0;
9270 u64 new_remote_cookie = 0;
9271 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
9274 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9276 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9277 sw_if_index_set = 1;
9278 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9279 sw_if_index_set = 1;
9280 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
9282 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
9288 if (sw_if_index_set == 0)
9290 errmsg ("missing interface name or sw_if_index\n");
9294 M (L2TPV3_SET_TUNNEL_COOKIES, l2tpv3_set_tunnel_cookies);
9296 mp->sw_if_index = ntohl (sw_if_index);
9297 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
9298 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
9307 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
9309 unformat_input_t *i = vam->input;
9310 vl_api_l2tpv3_interface_enable_disable_t *mp;
9313 u8 sw_if_index_set = 0;
9314 u8 enable_disable = 1;
9316 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9318 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9319 sw_if_index_set = 1;
9320 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9321 sw_if_index_set = 1;
9322 else if (unformat (i, "enable"))
9324 else if (unformat (i, "disable"))
9330 if (sw_if_index_set == 0)
9332 errmsg ("missing interface name or sw_if_index\n");
9336 M (L2TPV3_INTERFACE_ENABLE_DISABLE, l2tpv3_interface_enable_disable);
9338 mp->sw_if_index = ntohl (sw_if_index);
9339 mp->enable_disable = enable_disable;
9348 api_l2tpv3_set_lookup_key (vat_main_t * vam)
9350 unformat_input_t *i = vam->input;
9351 vl_api_l2tpv3_set_lookup_key_t *mp;
9355 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9357 if (unformat (i, "lookup_v6_src"))
9358 key = L2T_LOOKUP_SRC_ADDRESS;
9359 else if (unformat (i, "lookup_v6_dst"))
9360 key = L2T_LOOKUP_DST_ADDRESS;
9361 else if (unformat (i, "lookup_session_id"))
9362 key = L2T_LOOKUP_SESSION_ID;
9367 if (key == (u8) ~ 0)
9369 errmsg ("l2tp session lookup key unset\n");
9373 M (L2TPV3_SET_LOOKUP_KEY, l2tpv3_set_lookup_key);
9383 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
9384 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
9386 vat_main_t *vam = &vat_main;
9388 fformat (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)\n",
9389 format_ip6_address, mp->our_address,
9390 format_ip6_address, mp->client_address,
9391 clib_net_to_host_u32 (mp->sw_if_index));
9394 " local cookies %016llx %016llx remote cookie %016llx\n",
9395 clib_net_to_host_u64 (mp->local_cookie[0]),
9396 clib_net_to_host_u64 (mp->local_cookie[1]),
9397 clib_net_to_host_u64 (mp->remote_cookie));
9399 fformat (vam->ofp, " local session-id %d remote session-id %d\n",
9400 clib_net_to_host_u32 (mp->local_session_id),
9401 clib_net_to_host_u32 (mp->remote_session_id));
9403 fformat (vam->ofp, " l2 specific sublayer %s\n\n",
9404 mp->l2_sublayer_present ? "preset" : "absent");
9408 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
9409 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
9411 vat_main_t *vam = &vat_main;
9412 vat_json_node_t *node = NULL;
9413 struct in6_addr addr;
9415 if (VAT_JSON_ARRAY != vam->json_tree.type)
9417 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9418 vat_json_init_array (&vam->json_tree);
9420 node = vat_json_array_add (&vam->json_tree);
9422 vat_json_init_object (node);
9424 clib_memcpy (&addr, mp->our_address, sizeof (addr));
9425 vat_json_object_add_ip6 (node, "our_address", addr);
9426 clib_memcpy (&addr, mp->client_address, sizeof (addr));
9427 vat_json_object_add_ip6 (node, "client_address", addr);
9429 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
9430 vat_json_init_array (lc);
9431 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
9432 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
9433 vat_json_object_add_uint (node, "remote_cookie",
9434 clib_net_to_host_u64 (mp->remote_cookie));
9436 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
9437 vat_json_object_add_uint (node, "local_session_id",
9438 clib_net_to_host_u32 (mp->local_session_id));
9439 vat_json_object_add_uint (node, "remote_session_id",
9440 clib_net_to_host_u32 (mp->remote_session_id));
9441 vat_json_object_add_string_copy (node, "l2_sublayer",
9442 mp->l2_sublayer_present ? (u8 *) "present"
9447 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
9449 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
9452 /* Get list of l2tpv3-tunnel interfaces */
9453 M (SW_IF_L2TPV3_TUNNEL_DUMP, sw_if_l2tpv3_tunnel_dump);
9456 /* Use a control ping for synchronization */
9458 vl_api_control_ping_t *mp;
9459 M (CONTROL_PING, control_ping);
9466 static void vl_api_sw_interface_tap_details_t_handler
9467 (vl_api_sw_interface_tap_details_t * mp)
9469 vat_main_t *vam = &vat_main;
9471 fformat (vam->ofp, "%-16s %d\n",
9472 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
9475 static void vl_api_sw_interface_tap_details_t_handler_json
9476 (vl_api_sw_interface_tap_details_t * mp)
9478 vat_main_t *vam = &vat_main;
9479 vat_json_node_t *node = NULL;
9481 if (VAT_JSON_ARRAY != vam->json_tree.type)
9483 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9484 vat_json_init_array (&vam->json_tree);
9486 node = vat_json_array_add (&vam->json_tree);
9488 vat_json_init_object (node);
9489 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9490 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
9494 api_sw_interface_tap_dump (vat_main_t * vam)
9496 vl_api_sw_interface_tap_dump_t *mp;
9499 fformat (vam->ofp, "\n%-16s %s\n", "dev_name", "sw_if_index");
9500 /* Get list of tap interfaces */
9501 M (SW_INTERFACE_TAP_DUMP, sw_interface_tap_dump);
9504 /* Use a control ping for synchronization */
9506 vl_api_control_ping_t *mp;
9507 M (CONTROL_PING, control_ping);
9513 static uword unformat_vxlan_decap_next
9514 (unformat_input_t * input, va_list * args)
9516 u32 *result = va_arg (*args, u32 *);
9519 if (unformat (input, "drop"))
9520 *result = VXLAN_INPUT_NEXT_DROP;
9521 else if (unformat (input, "ip4"))
9522 *result = VXLAN_INPUT_NEXT_IP4_INPUT;
9523 else if (unformat (input, "ip6"))
9524 *result = VXLAN_INPUT_NEXT_IP6_INPUT;
9525 else if (unformat (input, "l2"))
9526 *result = VXLAN_INPUT_NEXT_L2_INPUT;
9527 else if (unformat (input, "%d", &tmp))
9535 api_vxlan_add_del_tunnel (vat_main_t * vam)
9537 unformat_input_t *line_input = vam->input;
9538 vl_api_vxlan_add_del_tunnel_t *mp;
9540 ip4_address_t src4, dst4;
9541 ip6_address_t src6, dst6;
9543 u8 ipv4_set = 0, ipv6_set = 0;
9546 u32 encap_vrf_id = 0;
9547 u32 decap_next_index = ~0;
9550 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9552 if (unformat (line_input, "del"))
9554 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
9559 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
9564 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
9569 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
9574 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
9576 else if (unformat (line_input, "decap-next %U",
9577 unformat_vxlan_decap_next, &decap_next_index))
9579 else if (unformat (line_input, "vni %d", &vni))
9583 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
9590 errmsg ("tunnel src address not specified\n");
9595 errmsg ("tunnel dst address not specified\n");
9599 if (ipv4_set && ipv6_set)
9601 errmsg ("both IPv4 and IPv6 addresses specified");
9605 if ((vni == 0) || (vni >> 24))
9607 errmsg ("vni not specified or out of range\n");
9611 M (VXLAN_ADD_DEL_TUNNEL, vxlan_add_del_tunnel);
9615 clib_memcpy (&mp->src_address, &src6, sizeof (src6));
9616 clib_memcpy (&mp->dst_address, &dst6, sizeof (dst6));
9620 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
9621 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
9623 mp->encap_vrf_id = ntohl (encap_vrf_id);
9624 mp->decap_next_index = ntohl (decap_next_index);
9625 mp->vni = ntohl (vni);
9626 mp->is_add = is_add;
9627 mp->is_ipv6 = ipv6_set;
9635 static void vl_api_vxlan_tunnel_details_t_handler
9636 (vl_api_vxlan_tunnel_details_t * mp)
9638 vat_main_t *vam = &vat_main;
9640 fformat (vam->ofp, "%11d%24U%24U%14d%18d%13d\n",
9641 ntohl (mp->sw_if_index),
9642 format_ip46_address, &(mp->src_address[0]),
9644 format_ip46_address, &(mp->dst_address[0]),
9646 ntohl (mp->encap_vrf_id),
9647 ntohl (mp->decap_next_index), ntohl (mp->vni));
9650 static void vl_api_vxlan_tunnel_details_t_handler_json
9651 (vl_api_vxlan_tunnel_details_t * mp)
9653 vat_main_t *vam = &vat_main;
9654 vat_json_node_t *node = NULL;
9656 struct in6_addr ip6;
9658 if (VAT_JSON_ARRAY != vam->json_tree.type)
9660 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9661 vat_json_init_array (&vam->json_tree);
9663 node = vat_json_array_add (&vam->json_tree);
9665 vat_json_init_object (node);
9666 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9669 clib_memcpy (&ip6, &(mp->src_address[0]), sizeof (ip6));
9670 vat_json_object_add_ip6 (node, "src_address", ip6);
9671 clib_memcpy (&ip6, &(mp->dst_address[0]), sizeof (ip6));
9672 vat_json_object_add_ip6 (node, "dst_address", ip6);
9676 clib_memcpy (&ip4, &(mp->src_address[0]), sizeof (ip4));
9677 vat_json_object_add_ip4 (node, "src_address", ip4);
9678 clib_memcpy (&ip4, &(mp->dst_address[0]), sizeof (ip4));
9679 vat_json_object_add_ip4 (node, "dst_address", ip4);
9681 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
9682 vat_json_object_add_uint (node, "decap_next_index",
9683 ntohl (mp->decap_next_index));
9684 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
9685 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
9689 api_vxlan_tunnel_dump (vat_main_t * vam)
9691 unformat_input_t *i = vam->input;
9692 vl_api_vxlan_tunnel_dump_t *mp;
9695 u8 sw_if_index_set = 0;
9697 /* Parse args required to build the message */
9698 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9700 if (unformat (i, "sw_if_index %d", &sw_if_index))
9701 sw_if_index_set = 1;
9706 if (sw_if_index_set == 0)
9711 if (!vam->json_output)
9713 fformat (vam->ofp, "%11s%24s%24s%14s%18s%13s\n",
9714 "sw_if_index", "src_address", "dst_address",
9715 "encap_vrf_id", "decap_next_index", "vni");
9718 /* Get list of vxlan-tunnel interfaces */
9719 M (VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump);
9721 mp->sw_if_index = htonl (sw_if_index);
9725 /* Use a control ping for synchronization */
9727 vl_api_control_ping_t *mp;
9728 M (CONTROL_PING, control_ping);
9735 api_gre_add_del_tunnel (vat_main_t * vam)
9737 unformat_input_t *line_input = vam->input;
9738 vl_api_gre_add_del_tunnel_t *mp;
9740 ip4_address_t src4, dst4;
9745 u32 outer_fib_id = 0;
9747 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9749 if (unformat (line_input, "del"))
9751 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
9753 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
9755 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
9757 else if (unformat (line_input, "teb"))
9761 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
9768 errmsg ("tunnel src address not specified\n");
9773 errmsg ("tunnel dst address not specified\n");
9778 M (GRE_ADD_DEL_TUNNEL, gre_add_del_tunnel);
9780 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
9781 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
9782 mp->outer_fib_id = ntohl (outer_fib_id);
9783 mp->is_add = is_add;
9792 static void vl_api_gre_tunnel_details_t_handler
9793 (vl_api_gre_tunnel_details_t * mp)
9795 vat_main_t *vam = &vat_main;
9797 fformat (vam->ofp, "%11d%15U%15U%6d%14d\n",
9798 ntohl (mp->sw_if_index),
9799 format_ip4_address, &mp->src_address,
9800 format_ip4_address, &mp->dst_address,
9801 mp->teb, ntohl (mp->outer_fib_id));
9804 static void vl_api_gre_tunnel_details_t_handler_json
9805 (vl_api_gre_tunnel_details_t * mp)
9807 vat_main_t *vam = &vat_main;
9808 vat_json_node_t *node = NULL;
9811 if (VAT_JSON_ARRAY != vam->json_tree.type)
9813 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9814 vat_json_init_array (&vam->json_tree);
9816 node = vat_json_array_add (&vam->json_tree);
9818 vat_json_init_object (node);
9819 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9820 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
9821 vat_json_object_add_ip4 (node, "src_address", ip4);
9822 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
9823 vat_json_object_add_ip4 (node, "dst_address", ip4);
9824 vat_json_object_add_uint (node, "teb", mp->teb);
9825 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
9829 api_gre_tunnel_dump (vat_main_t * vam)
9831 unformat_input_t *i = vam->input;
9832 vl_api_gre_tunnel_dump_t *mp;
9835 u8 sw_if_index_set = 0;
9837 /* Parse args required to build the message */
9838 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9840 if (unformat (i, "sw_if_index %d", &sw_if_index))
9841 sw_if_index_set = 1;
9846 if (sw_if_index_set == 0)
9851 if (!vam->json_output)
9853 fformat (vam->ofp, "%11s%15s%15s%6s%14s\n",
9854 "sw_if_index", "src_address", "dst_address", "teb",
9858 /* Get list of gre-tunnel interfaces */
9859 M (GRE_TUNNEL_DUMP, gre_tunnel_dump);
9861 mp->sw_if_index = htonl (sw_if_index);
9865 /* Use a control ping for synchronization */
9867 vl_api_control_ping_t *mp;
9868 M (CONTROL_PING, control_ping);
9875 api_l2_fib_clear_table (vat_main_t * vam)
9877 // unformat_input_t * i = vam->input;
9878 vl_api_l2_fib_clear_table_t *mp;
9881 M (L2_FIB_CLEAR_TABLE, l2_fib_clear_table);
9890 api_l2_interface_efp_filter (vat_main_t * vam)
9892 unformat_input_t *i = vam->input;
9893 vl_api_l2_interface_efp_filter_t *mp;
9897 u8 sw_if_index_set = 0;
9899 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9901 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9902 sw_if_index_set = 1;
9903 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9904 sw_if_index_set = 1;
9905 else if (unformat (i, "enable"))
9907 else if (unformat (i, "disable"))
9911 clib_warning ("parse error '%U'", format_unformat_error, i);
9916 if (sw_if_index_set == 0)
9918 errmsg ("missing sw_if_index\n");
9922 M (L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter);
9924 mp->sw_if_index = ntohl (sw_if_index);
9925 mp->enable_disable = enable;
9933 #define foreach_vtr_op \
9934 _("disable", L2_VTR_DISABLED) \
9935 _("push-1", L2_VTR_PUSH_1) \
9936 _("push-2", L2_VTR_PUSH_2) \
9937 _("pop-1", L2_VTR_POP_1) \
9938 _("pop-2", L2_VTR_POP_2) \
9939 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
9940 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
9941 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
9942 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
9945 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
9947 unformat_input_t *i = vam->input;
9948 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
9951 u8 sw_if_index_set = 0;
9958 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9960 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9961 sw_if_index_set = 1;
9962 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9963 sw_if_index_set = 1;
9964 else if (unformat (i, "vtr_op %d", &vtr_op))
9966 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
9969 else if (unformat (i, "push_dot1q %d", &push_dot1q))
9971 else if (unformat (i, "tag1 %d", &tag1))
9973 else if (unformat (i, "tag2 %d", &tag2))
9977 clib_warning ("parse error '%U'", format_unformat_error, i);
9982 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
9984 errmsg ("missing vtr operation or sw_if_index\n");
9988 M (L2_INTERFACE_VLAN_TAG_REWRITE, l2_interface_vlan_tag_rewrite)
9989 mp->sw_if_index = ntohl (sw_if_index);
9990 mp->vtr_op = ntohl (vtr_op);
9991 mp->push_dot1q = ntohl (push_dot1q);
9992 mp->tag1 = ntohl (tag1);
9993 mp->tag2 = ntohl (tag2);
10002 api_create_vhost_user_if (vat_main_t * vam)
10004 unformat_input_t *i = vam->input;
10005 vl_api_create_vhost_user_if_t *mp;
10009 u8 file_name_set = 0;
10010 u32 custom_dev_instance = ~0;
10012 u8 use_custom_mac = 0;
10014 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10016 if (unformat (i, "socket %s", &file_name))
10020 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
10022 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
10023 use_custom_mac = 1;
10024 else if (unformat (i, "server"))
10030 if (file_name_set == 0)
10032 errmsg ("missing socket file name\n");
10036 if (vec_len (file_name) > 255)
10038 errmsg ("socket file name too long\n");
10041 vec_add1 (file_name, 0);
10043 M (CREATE_VHOST_USER_IF, create_vhost_user_if);
10045 mp->is_server = is_server;
10046 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
10047 vec_free (file_name);
10048 if (custom_dev_instance != ~0)
10051 mp->custom_dev_instance = ntohl (custom_dev_instance);
10053 mp->use_custom_mac = use_custom_mac;
10054 clib_memcpy (mp->mac_address, hwaddr, 6);
10063 api_modify_vhost_user_if (vat_main_t * vam)
10065 unformat_input_t *i = vam->input;
10066 vl_api_modify_vhost_user_if_t *mp;
10070 u8 file_name_set = 0;
10071 u32 custom_dev_instance = ~0;
10072 u8 sw_if_index_set = 0;
10073 u32 sw_if_index = (u32) ~ 0;
10075 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10077 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10078 sw_if_index_set = 1;
10079 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10080 sw_if_index_set = 1;
10081 else if (unformat (i, "socket %s", &file_name))
10085 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
10087 else if (unformat (i, "server"))
10093 if (sw_if_index_set == 0)
10095 errmsg ("missing sw_if_index or interface name\n");
10099 if (file_name_set == 0)
10101 errmsg ("missing socket file name\n");
10105 if (vec_len (file_name) > 255)
10107 errmsg ("socket file name too long\n");
10110 vec_add1 (file_name, 0);
10112 M (MODIFY_VHOST_USER_IF, modify_vhost_user_if);
10114 mp->sw_if_index = ntohl (sw_if_index);
10115 mp->is_server = is_server;
10116 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
10117 vec_free (file_name);
10118 if (custom_dev_instance != ~0)
10121 mp->custom_dev_instance = ntohl (custom_dev_instance);
10131 api_delete_vhost_user_if (vat_main_t * vam)
10133 unformat_input_t *i = vam->input;
10134 vl_api_delete_vhost_user_if_t *mp;
10136 u32 sw_if_index = ~0;
10137 u8 sw_if_index_set = 0;
10139 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10141 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10142 sw_if_index_set = 1;
10143 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10144 sw_if_index_set = 1;
10149 if (sw_if_index_set == 0)
10151 errmsg ("missing sw_if_index or interface name\n");
10156 M (DELETE_VHOST_USER_IF, delete_vhost_user_if);
10158 mp->sw_if_index = ntohl (sw_if_index);
10166 static void vl_api_sw_interface_vhost_user_details_t_handler
10167 (vl_api_sw_interface_vhost_user_details_t * mp)
10169 vat_main_t *vam = &vat_main;
10171 fformat (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s\n",
10172 (char *) mp->interface_name,
10173 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
10174 clib_net_to_host_u64 (mp->features), mp->is_server,
10175 ntohl (mp->num_regions), (char *) mp->sock_filename);
10176 fformat (vam->ofp, " Status: '%s'\n", strerror (ntohl (mp->sock_errno)));
10179 static void vl_api_sw_interface_vhost_user_details_t_handler_json
10180 (vl_api_sw_interface_vhost_user_details_t * mp)
10182 vat_main_t *vam = &vat_main;
10183 vat_json_node_t *node = NULL;
10185 if (VAT_JSON_ARRAY != vam->json_tree.type)
10187 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10188 vat_json_init_array (&vam->json_tree);
10190 node = vat_json_array_add (&vam->json_tree);
10192 vat_json_init_object (node);
10193 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10194 vat_json_object_add_string_copy (node, "interface_name",
10195 mp->interface_name);
10196 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
10197 ntohl (mp->virtio_net_hdr_sz));
10198 vat_json_object_add_uint (node, "features",
10199 clib_net_to_host_u64 (mp->features));
10200 vat_json_object_add_uint (node, "is_server", mp->is_server);
10201 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
10202 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
10203 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
10207 api_sw_interface_vhost_user_dump (vat_main_t * vam)
10209 vl_api_sw_interface_vhost_user_dump_t *mp;
10212 "Interface name idx hdr_sz features server regions filename\n");
10214 /* Get list of vhost-user interfaces */
10215 M (SW_INTERFACE_VHOST_USER_DUMP, sw_interface_vhost_user_dump);
10218 /* Use a control ping for synchronization */
10220 vl_api_control_ping_t *mp;
10221 M (CONTROL_PING, control_ping);
10228 api_show_version (vat_main_t * vam)
10230 vl_api_show_version_t *mp;
10233 M (SHOW_VERSION, show_version);
10243 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
10245 unformat_input_t *line_input = vam->input;
10246 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
10248 ip4_address_t local4, remote4;
10249 ip6_address_t local6, remote6;
10251 u8 ipv4_set = 0, ipv6_set = 0;
10254 u32 encap_vrf_id = 0;
10255 u32 decap_vrf_id = 0;
10260 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10262 if (unformat (line_input, "del"))
10264 else if (unformat (line_input, "local %U",
10265 unformat_ip4_address, &local4))
10270 else if (unformat (line_input, "remote %U",
10271 unformat_ip4_address, &remote4))
10276 else if (unformat (line_input, "local %U",
10277 unformat_ip6_address, &local6))
10282 else if (unformat (line_input, "remote %U",
10283 unformat_ip6_address, &remote6))
10288 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
10290 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
10292 else if (unformat (line_input, "vni %d", &vni))
10294 else if (unformat (line_input, "next-ip4"))
10296 else if (unformat (line_input, "next-ip6"))
10298 else if (unformat (line_input, "next-ethernet"))
10300 else if (unformat (line_input, "next-nsh"))
10304 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
10309 if (local_set == 0)
10311 errmsg ("tunnel local address not specified\n");
10314 if (remote_set == 0)
10316 errmsg ("tunnel remote address not specified\n");
10319 if (ipv4_set && ipv6_set)
10321 errmsg ("both IPv4 and IPv6 addresses specified");
10327 errmsg ("vni not specified\n");
10331 M (VXLAN_GPE_ADD_DEL_TUNNEL, vxlan_gpe_add_del_tunnel);
10336 clib_memcpy (&mp->local, &local6, sizeof (local6));
10337 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
10341 clib_memcpy (&mp->local, &local4, sizeof (local4));
10342 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
10345 mp->encap_vrf_id = ntohl (encap_vrf_id);
10346 mp->decap_vrf_id = ntohl (decap_vrf_id);
10347 mp->protocol = ntohl (protocol);
10348 mp->vni = ntohl (vni);
10349 mp->is_add = is_add;
10350 mp->is_ipv6 = ipv6_set;
10358 static void vl_api_vxlan_gpe_tunnel_details_t_handler
10359 (vl_api_vxlan_gpe_tunnel_details_t * mp)
10361 vat_main_t *vam = &vat_main;
10363 fformat (vam->ofp, "%11d%24U%24U%13d%12d%14d%14d\n",
10364 ntohl (mp->sw_if_index),
10365 format_ip46_address, &(mp->local[0]),
10366 format_ip46_address, &(mp->remote[0]),
10368 ntohl (mp->protocol),
10369 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
10372 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
10373 (vl_api_vxlan_gpe_tunnel_details_t * mp)
10375 vat_main_t *vam = &vat_main;
10376 vat_json_node_t *node = NULL;
10377 struct in_addr ip4;
10378 struct in6_addr ip6;
10380 if (VAT_JSON_ARRAY != vam->json_tree.type)
10382 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10383 vat_json_init_array (&vam->json_tree);
10385 node = vat_json_array_add (&vam->json_tree);
10387 vat_json_init_object (node);
10388 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10391 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
10392 vat_json_object_add_ip6 (node, "local", ip6);
10393 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
10394 vat_json_object_add_ip6 (node, "remote", ip6);
10398 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
10399 vat_json_object_add_ip4 (node, "local", ip4);
10400 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
10401 vat_json_object_add_ip4 (node, "remote", ip4);
10403 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
10404 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
10405 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
10406 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
10407 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
10411 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
10413 unformat_input_t *i = vam->input;
10414 vl_api_vxlan_gpe_tunnel_dump_t *mp;
10417 u8 sw_if_index_set = 0;
10419 /* Parse args required to build the message */
10420 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10422 if (unformat (i, "sw_if_index %d", &sw_if_index))
10423 sw_if_index_set = 1;
10428 if (sw_if_index_set == 0)
10433 if (!vam->json_output)
10435 fformat (vam->ofp, "%11s%24s%24s%13s%15s%14s%14s\n",
10436 "sw_if_index", "local", "remote", "vni",
10437 "protocol", "encap_vrf_id", "decap_vrf_id");
10440 /* Get list of vxlan-tunnel interfaces */
10441 M (VXLAN_GPE_TUNNEL_DUMP, vxlan_gpe_tunnel_dump);
10443 mp->sw_if_index = htonl (sw_if_index);
10447 /* Use a control ping for synchronization */
10449 vl_api_control_ping_t *mp;
10450 M (CONTROL_PING, control_ping);
10457 format_l2_fib_mac_address (u8 * s, va_list * args)
10459 u8 *a = va_arg (*args, u8 *);
10461 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
10462 a[2], a[3], a[4], a[5], a[6], a[7]);
10465 static void vl_api_l2_fib_table_entry_t_handler
10466 (vl_api_l2_fib_table_entry_t * mp)
10468 vat_main_t *vam = &vat_main;
10470 fformat (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
10472 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
10473 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
10477 static void vl_api_l2_fib_table_entry_t_handler_json
10478 (vl_api_l2_fib_table_entry_t * mp)
10480 vat_main_t *vam = &vat_main;
10481 vat_json_node_t *node = NULL;
10483 if (VAT_JSON_ARRAY != vam->json_tree.type)
10485 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10486 vat_json_init_array (&vam->json_tree);
10488 node = vat_json_array_add (&vam->json_tree);
10490 vat_json_init_object (node);
10491 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
10492 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
10493 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10494 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
10495 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
10496 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
10500 api_l2_fib_table_dump (vat_main_t * vam)
10502 unformat_input_t *i = vam->input;
10503 vl_api_l2_fib_table_dump_t *mp;
10508 /* Parse args required to build the message */
10509 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10511 if (unformat (i, "bd_id %d", &bd_id))
10517 if (bd_id_set == 0)
10519 errmsg ("missing bridge domain\n");
10524 "BD-ID Mac Address sw-ndx Static Filter BVI\n");
10526 /* Get list of l2 fib entries */
10527 M (L2_FIB_TABLE_DUMP, l2_fib_table_dump);
10529 mp->bd_id = ntohl (bd_id);
10532 /* Use a control ping for synchronization */
10534 vl_api_control_ping_t *mp;
10535 M (CONTROL_PING, control_ping);
10543 api_interface_name_renumber (vat_main_t * vam)
10545 unformat_input_t *line_input = vam->input;
10546 vl_api_interface_name_renumber_t *mp;
10547 u32 sw_if_index = ~0;
10549 u32 new_show_dev_instance = ~0;
10551 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10553 if (unformat (line_input, "%U", unformat_sw_if_index, vam,
10556 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
10558 else if (unformat (line_input, "new_show_dev_instance %d",
10559 &new_show_dev_instance))
10565 if (sw_if_index == ~0)
10567 errmsg ("missing interface name or sw_if_index\n");
10571 if (new_show_dev_instance == ~0)
10573 errmsg ("missing new_show_dev_instance\n");
10577 M (INTERFACE_NAME_RENUMBER, interface_name_renumber);
10579 mp->sw_if_index = ntohl (sw_if_index);
10580 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
10587 api_want_ip4_arp_events (vat_main_t * vam)
10589 unformat_input_t *line_input = vam->input;
10590 vl_api_want_ip4_arp_events_t *mp;
10592 ip4_address_t address;
10593 int address_set = 0;
10594 u32 enable_disable = 1;
10596 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10598 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
10600 else if (unformat (line_input, "del"))
10601 enable_disable = 0;
10606 if (address_set == 0)
10608 errmsg ("missing addresses\n");
10612 M (WANT_IP4_ARP_EVENTS, want_ip4_arp_events);
10613 mp->enable_disable = enable_disable;
10614 mp->pid = getpid ();
10615 mp->address = address.as_u32;
10622 api_want_ip6_nd_events (vat_main_t * vam)
10624 unformat_input_t *line_input = vam->input;
10625 vl_api_want_ip6_nd_events_t *mp;
10627 ip6_address_t address;
10628 int address_set = 0;
10629 u32 enable_disable = 1;
10631 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10633 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
10635 else if (unformat (line_input, "del"))
10636 enable_disable = 0;
10641 if (address_set == 0)
10643 errmsg ("missing addresses\n");
10647 M (WANT_IP6_ND_EVENTS, want_ip6_nd_events);
10648 mp->enable_disable = enable_disable;
10649 mp->pid = getpid ();
10650 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
10657 api_input_acl_set_interface (vat_main_t * vam)
10659 unformat_input_t *i = vam->input;
10660 vl_api_input_acl_set_interface_t *mp;
10663 int sw_if_index_set;
10664 u32 ip4_table_index = ~0;
10665 u32 ip6_table_index = ~0;
10666 u32 l2_table_index = ~0;
10669 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10671 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10672 sw_if_index_set = 1;
10673 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10674 sw_if_index_set = 1;
10675 else if (unformat (i, "del"))
10677 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10679 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10681 else if (unformat (i, "l2-table %d", &l2_table_index))
10685 clib_warning ("parse error '%U'", format_unformat_error, i);
10690 if (sw_if_index_set == 0)
10692 errmsg ("missing interface name or sw_if_index\n");
10696 M (INPUT_ACL_SET_INTERFACE, input_acl_set_interface);
10698 mp->sw_if_index = ntohl (sw_if_index);
10699 mp->ip4_table_index = ntohl (ip4_table_index);
10700 mp->ip6_table_index = ntohl (ip6_table_index);
10701 mp->l2_table_index = ntohl (l2_table_index);
10702 mp->is_add = is_add;
10711 api_ip_address_dump (vat_main_t * vam)
10713 unformat_input_t *i = vam->input;
10714 vl_api_ip_address_dump_t *mp;
10715 u32 sw_if_index = ~0;
10716 u8 sw_if_index_set = 0;
10721 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10723 if (unformat (i, "sw_if_index %d", &sw_if_index))
10724 sw_if_index_set = 1;
10725 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10726 sw_if_index_set = 1;
10727 else if (unformat (i, "ipv4"))
10729 else if (unformat (i, "ipv6"))
10735 if (ipv4_set && ipv6_set)
10737 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
10741 if ((!ipv4_set) && (!ipv6_set))
10743 errmsg ("no ipv4 nor ipv6 flag set\n");
10747 if (sw_if_index_set == 0)
10749 errmsg ("missing interface name or sw_if_index\n");
10753 vam->current_sw_if_index = sw_if_index;
10754 vam->is_ipv6 = ipv6_set;
10756 M (IP_ADDRESS_DUMP, ip_address_dump);
10757 mp->sw_if_index = ntohl (sw_if_index);
10758 mp->is_ipv6 = ipv6_set;
10761 /* Use a control ping for synchronization */
10763 vl_api_control_ping_t *mp;
10764 M (CONTROL_PING, control_ping);
10771 api_ip_dump (vat_main_t * vam)
10773 vl_api_ip_dump_t *mp;
10774 unformat_input_t *in = vam->input;
10781 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
10783 if (unformat (in, "ipv4"))
10785 else if (unformat (in, "ipv6"))
10791 if (ipv4_set && ipv6_set)
10793 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
10797 if ((!ipv4_set) && (!ipv6_set))
10799 errmsg ("no ipv4 nor ipv6 flag set\n");
10803 is_ipv6 = ipv6_set;
10804 vam->is_ipv6 = is_ipv6;
10806 /* free old data */
10807 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
10809 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
10811 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
10813 M (IP_DUMP, ip_dump);
10814 mp->is_ipv6 = ipv6_set;
10817 /* Use a control ping for synchronization */
10819 vl_api_control_ping_t *mp;
10820 M (CONTROL_PING, control_ping);
10827 api_ipsec_spd_add_del (vat_main_t * vam)
10830 unformat_input_t *i = vam->input;
10831 vl_api_ipsec_spd_add_del_t *mp;
10836 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10838 if (unformat (i, "spd_id %d", &spd_id))
10840 else if (unformat (i, "del"))
10844 clib_warning ("parse error '%U'", format_unformat_error, i);
10850 errmsg ("spd_id must be set\n");
10854 M (IPSEC_SPD_ADD_DEL, ipsec_spd_add_del);
10856 mp->spd_id = ntohl (spd_id);
10857 mp->is_add = is_add;
10864 clib_warning ("unsupported (no dpdk)");
10870 api_ipsec_interface_add_del_spd (vat_main_t * vam)
10873 unformat_input_t *i = vam->input;
10874 vl_api_ipsec_interface_add_del_spd_t *mp;
10877 u8 sw_if_index_set = 0;
10878 u32 spd_id = (u32) ~ 0;
10881 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10883 if (unformat (i, "del"))
10885 else if (unformat (i, "spd_id %d", &spd_id))
10887 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10888 sw_if_index_set = 1;
10889 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10890 sw_if_index_set = 1;
10893 clib_warning ("parse error '%U'", format_unformat_error, i);
10899 if (spd_id == (u32) ~ 0)
10901 errmsg ("spd_id must be set\n");
10905 if (sw_if_index_set == 0)
10907 errmsg ("missing interface name or sw_if_index\n");
10911 M (IPSEC_INTERFACE_ADD_DEL_SPD, ipsec_interface_add_del_spd);
10913 mp->spd_id = ntohl (spd_id);
10914 mp->sw_if_index = ntohl (sw_if_index);
10915 mp->is_add = is_add;
10922 clib_warning ("unsupported (no dpdk)");
10928 api_ipsec_spd_add_del_entry (vat_main_t * vam)
10931 unformat_input_t *i = vam->input;
10932 vl_api_ipsec_spd_add_del_entry_t *mp;
10934 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
10935 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
10937 u32 rport_start = 0, rport_stop = (u32) ~ 0;
10938 u32 lport_start = 0, lport_stop = (u32) ~ 0;
10939 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
10940 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
10942 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
10943 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
10944 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
10945 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
10946 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
10947 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
10949 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10951 if (unformat (i, "del"))
10953 if (unformat (i, "outbound"))
10955 if (unformat (i, "inbound"))
10957 else if (unformat (i, "spd_id %d", &spd_id))
10959 else if (unformat (i, "sa_id %d", &sa_id))
10961 else if (unformat (i, "priority %d", &priority))
10963 else if (unformat (i, "protocol %d", &protocol))
10965 else if (unformat (i, "lport_start %d", &lport_start))
10967 else if (unformat (i, "lport_stop %d", &lport_stop))
10969 else if (unformat (i, "rport_start %d", &rport_start))
10971 else if (unformat (i, "rport_stop %d", &rport_stop))
10975 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
10981 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
10988 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
10994 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
11001 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
11007 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
11014 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
11020 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
11026 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
11028 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
11030 clib_warning ("unsupported action: 'resolve'");
11036 clib_warning ("parse error '%U'", format_unformat_error, i);
11042 M (IPSEC_SPD_ADD_DEL_ENTRY, ipsec_spd_add_del_entry);
11044 mp->spd_id = ntohl (spd_id);
11045 mp->priority = ntohl (priority);
11046 mp->is_outbound = is_outbound;
11048 mp->is_ipv6 = is_ipv6;
11049 if (is_ipv6 || is_ip_any)
11051 clib_memcpy (mp->remote_address_start, &raddr6_start,
11052 sizeof (ip6_address_t));
11053 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
11054 sizeof (ip6_address_t));
11055 clib_memcpy (mp->local_address_start, &laddr6_start,
11056 sizeof (ip6_address_t));
11057 clib_memcpy (mp->local_address_stop, &laddr6_stop,
11058 sizeof (ip6_address_t));
11062 clib_memcpy (mp->remote_address_start, &raddr4_start,
11063 sizeof (ip4_address_t));
11064 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
11065 sizeof (ip4_address_t));
11066 clib_memcpy (mp->local_address_start, &laddr4_start,
11067 sizeof (ip4_address_t));
11068 clib_memcpy (mp->local_address_stop, &laddr4_stop,
11069 sizeof (ip4_address_t));
11071 mp->protocol = (u8) protocol;
11072 mp->local_port_start = ntohs ((u16) lport_start);
11073 mp->local_port_stop = ntohs ((u16) lport_stop);
11074 mp->remote_port_start = ntohs ((u16) rport_start);
11075 mp->remote_port_stop = ntohs ((u16) rport_stop);
11076 mp->policy = (u8) policy;
11077 mp->sa_id = ntohl (sa_id);
11078 mp->is_add = is_add;
11079 mp->is_ip_any = is_ip_any;
11085 clib_warning ("unsupported (no dpdk)");
11091 api_ipsec_sad_add_del_entry (vat_main_t * vam)
11094 unformat_input_t *i = vam->input;
11095 vl_api_ipsec_sad_add_del_entry_t *mp;
11097 u32 sad_id = 0, spi = 0;
11098 u8 *ck = 0, *ik = 0;
11101 u8 protocol = IPSEC_PROTOCOL_AH;
11102 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
11103 u32 crypto_alg = 0, integ_alg = 0;
11104 ip4_address_t tun_src4;
11105 ip4_address_t tun_dst4;
11106 ip6_address_t tun_src6;
11107 ip6_address_t tun_dst6;
11109 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11111 if (unformat (i, "del"))
11113 else if (unformat (i, "sad_id %d", &sad_id))
11115 else if (unformat (i, "spi %d", &spi))
11117 else if (unformat (i, "esp"))
11118 protocol = IPSEC_PROTOCOL_ESP;
11119 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
11122 is_tunnel_ipv6 = 0;
11124 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
11127 is_tunnel_ipv6 = 0;
11129 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
11132 is_tunnel_ipv6 = 1;
11134 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
11137 is_tunnel_ipv6 = 1;
11141 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
11143 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
11144 crypto_alg > IPSEC_INTEG_ALG_SHA_512_256)
11146 clib_warning ("unsupported crypto-alg: '%U'",
11147 format_ipsec_crypto_alg, crypto_alg);
11151 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
11155 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
11157 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
11158 integ_alg > IPSEC_INTEG_ALG_SHA_512_256)
11160 clib_warning ("unsupported integ-alg: '%U'",
11161 format_ipsec_integ_alg, integ_alg);
11165 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
11169 clib_warning ("parse error '%U'", format_unformat_error, i);
11175 M (IPSEC_SAD_ADD_DEL_ENTRY, ipsec_sad_add_del_entry);
11177 mp->sad_id = ntohl (sad_id);
11178 mp->is_add = is_add;
11179 mp->protocol = protocol;
11180 mp->spi = ntohl (spi);
11181 mp->is_tunnel = is_tunnel;
11182 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
11183 mp->crypto_algorithm = crypto_alg;
11184 mp->integrity_algorithm = integ_alg;
11185 mp->crypto_key_length = vec_len (ck);
11186 mp->integrity_key_length = vec_len (ik);
11188 if (mp->crypto_key_length > sizeof (mp->crypto_key))
11189 mp->crypto_key_length = sizeof (mp->crypto_key);
11191 if (mp->integrity_key_length > sizeof (mp->integrity_key))
11192 mp->integrity_key_length = sizeof (mp->integrity_key);
11195 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
11197 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
11201 if (is_tunnel_ipv6)
11203 clib_memcpy (mp->tunnel_src_address, &tun_src6,
11204 sizeof (ip6_address_t));
11205 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
11206 sizeof (ip6_address_t));
11210 clib_memcpy (mp->tunnel_src_address, &tun_src4,
11211 sizeof (ip4_address_t));
11212 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
11213 sizeof (ip4_address_t));
11222 clib_warning ("unsupported (no dpdk)");
11228 api_ipsec_sa_set_key (vat_main_t * vam)
11231 unformat_input_t *i = vam->input;
11232 vl_api_ipsec_sa_set_key_t *mp;
11235 u8 *ck = 0, *ik = 0;
11237 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11239 if (unformat (i, "sa_id %d", &sa_id))
11241 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
11243 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
11247 clib_warning ("parse error '%U'", format_unformat_error, i);
11252 M (IPSEC_SA_SET_KEY, ipsec_set_sa_key);
11254 mp->sa_id = ntohl (sa_id);
11255 mp->crypto_key_length = vec_len (ck);
11256 mp->integrity_key_length = vec_len (ik);
11258 if (mp->crypto_key_length > sizeof (mp->crypto_key))
11259 mp->crypto_key_length = sizeof (mp->crypto_key);
11261 if (mp->integrity_key_length > sizeof (mp->integrity_key))
11262 mp->integrity_key_length = sizeof (mp->integrity_key);
11265 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
11267 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
11274 clib_warning ("unsupported (no dpdk)");
11280 api_ikev2_profile_add_del (vat_main_t * vam)
11283 unformat_input_t *i = vam->input;
11284 vl_api_ikev2_profile_add_del_t *mp;
11289 const char *valid_chars = "a-zA-Z0-9_";
11291 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11293 if (unformat (i, "del"))
11295 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11296 vec_add1 (name, 0);
11299 errmsg ("parse error '%U'", format_unformat_error, i);
11304 if (!vec_len (name))
11306 errmsg ("profile name must be specified");
11310 if (vec_len (name) > 64)
11312 errmsg ("profile name too long");
11316 M (IKEV2_PROFILE_ADD_DEL, ikev2_profile_add_del);
11318 clib_memcpy (mp->name, name, vec_len (name));
11319 mp->is_add = is_add;
11327 clib_warning ("unsupported (no dpdk)");
11333 api_ikev2_profile_set_auth (vat_main_t * vam)
11336 unformat_input_t *i = vam->input;
11337 vl_api_ikev2_profile_set_auth_t *mp;
11341 u32 auth_method = 0;
11344 const char *valid_chars = "a-zA-Z0-9_";
11346 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11348 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11349 vec_add1 (name, 0);
11350 else if (unformat (i, "auth_method %U",
11351 unformat_ikev2_auth_method, &auth_method))
11353 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
11355 else if (unformat (i, "auth_data %v", &data))
11359 errmsg ("parse error '%U'", format_unformat_error, i);
11364 if (!vec_len (name))
11366 errmsg ("profile name must be specified");
11370 if (vec_len (name) > 64)
11372 errmsg ("profile name too long");
11376 if (!vec_len (data))
11378 errmsg ("auth_data must be specified");
11384 errmsg ("auth_method must be specified");
11388 M (IKEV2_PROFILE_SET_AUTH, ikev2_profile_set_auth);
11390 mp->is_hex = is_hex;
11391 mp->auth_method = (u8) auth_method;
11392 mp->data_len = vec_len (data);
11393 clib_memcpy (mp->name, name, vec_len (name));
11394 clib_memcpy (mp->data, data, vec_len (data));
11403 clib_warning ("unsupported (no dpdk)");
11409 api_ikev2_profile_set_id (vat_main_t * vam)
11412 unformat_input_t *i = vam->input;
11413 vl_api_ikev2_profile_set_id_t *mp;
11421 const char *valid_chars = "a-zA-Z0-9_";
11423 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11425 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11426 vec_add1 (name, 0);
11427 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
11429 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
11431 data = vec_new (u8, 4);
11432 clib_memcpy (data, ip4.as_u8, 4);
11434 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
11436 else if (unformat (i, "id_data %v", &data))
11438 else if (unformat (i, "local"))
11440 else if (unformat (i, "remote"))
11444 errmsg ("parse error '%U'", format_unformat_error, i);
11449 if (!vec_len (name))
11451 errmsg ("profile name must be specified");
11455 if (vec_len (name) > 64)
11457 errmsg ("profile name too long");
11461 if (!vec_len (data))
11463 errmsg ("id_data must be specified");
11469 errmsg ("id_type must be specified");
11473 M (IKEV2_PROFILE_SET_ID, ikev2_profile_set_id);
11475 mp->is_local = is_local;
11476 mp->id_type = (u8) id_type;
11477 mp->data_len = vec_len (data);
11478 clib_memcpy (mp->name, name, vec_len (name));
11479 clib_memcpy (mp->data, data, vec_len (data));
11488 clib_warning ("unsupported (no dpdk)");
11494 api_ikev2_profile_set_ts (vat_main_t * vam)
11497 unformat_input_t *i = vam->input;
11498 vl_api_ikev2_profile_set_ts_t *mp;
11502 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
11503 ip4_address_t start_addr, end_addr;
11505 const char *valid_chars = "a-zA-Z0-9_";
11507 start_addr.as_u32 = 0;
11508 end_addr.as_u32 = (u32) ~ 0;
11510 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11512 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11513 vec_add1 (name, 0);
11514 else if (unformat (i, "protocol %d", &proto))
11516 else if (unformat (i, "start_port %d", &start_port))
11518 else if (unformat (i, "end_port %d", &end_port))
11521 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
11523 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
11525 else if (unformat (i, "local"))
11527 else if (unformat (i, "remote"))
11531 errmsg ("parse error '%U'", format_unformat_error, i);
11536 if (!vec_len (name))
11538 errmsg ("profile name must be specified");
11542 if (vec_len (name) > 64)
11544 errmsg ("profile name too long");
11548 M (IKEV2_PROFILE_SET_TS, ikev2_profile_set_ts);
11550 mp->is_local = is_local;
11551 mp->proto = (u8) proto;
11552 mp->start_port = (u16) start_port;
11553 mp->end_port = (u16) end_port;
11554 mp->start_addr = start_addr.as_u32;
11555 mp->end_addr = end_addr.as_u32;
11556 clib_memcpy (mp->name, name, vec_len (name));
11564 clib_warning ("unsupported (no dpdk)");
11570 api_ikev2_set_local_key (vat_main_t * vam)
11573 unformat_input_t *i = vam->input;
11574 vl_api_ikev2_set_local_key_t *mp;
11578 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11580 if (unformat (i, "file %v", &file))
11581 vec_add1 (file, 0);
11584 errmsg ("parse error '%U'", format_unformat_error, i);
11589 if (!vec_len (file))
11591 errmsg ("RSA key file must be specified");
11595 if (vec_len (file) > 256)
11597 errmsg ("file name too long");
11601 M (IKEV2_SET_LOCAL_KEY, ikev2_set_local_key);
11603 clib_memcpy (mp->key_file, file, vec_len (file));
11611 clib_warning ("unsupported (no dpdk)");
11620 api_map_add_domain (vat_main_t * vam)
11622 unformat_input_t *i = vam->input;
11623 vl_api_map_add_domain_t *mp;
11626 ip4_address_t ip4_prefix;
11627 ip6_address_t ip6_prefix;
11628 ip6_address_t ip6_src;
11629 u32 num_m_args = 0;
11630 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
11631 0, psid_length = 0;
11632 u8 is_translation = 0;
11634 u32 ip6_src_len = 128;
11636 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11638 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
11639 &ip4_prefix, &ip4_prefix_len))
11641 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
11642 &ip6_prefix, &ip6_prefix_len))
11646 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
11649 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
11651 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
11653 else if (unformat (i, "psid-offset %d", &psid_offset))
11655 else if (unformat (i, "psid-len %d", &psid_length))
11657 else if (unformat (i, "mtu %d", &mtu))
11659 else if (unformat (i, "map-t"))
11660 is_translation = 1;
11663 clib_warning ("parse error '%U'", format_unformat_error, i);
11668 if (num_m_args < 3)
11670 errmsg ("mandatory argument(s) missing\n");
11674 /* Construct the API message */
11675 M (MAP_ADD_DOMAIN, map_add_domain);
11677 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
11678 mp->ip4_prefix_len = ip4_prefix_len;
11680 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
11681 mp->ip6_prefix_len = ip6_prefix_len;
11683 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
11684 mp->ip6_src_prefix_len = ip6_src_len;
11686 mp->ea_bits_len = ea_bits_len;
11687 mp->psid_offset = psid_offset;
11688 mp->psid_length = psid_length;
11689 mp->is_translation = is_translation;
11690 mp->mtu = htons (mtu);
11695 /* Wait for a reply, return good/bad news */
11700 api_map_del_domain (vat_main_t * vam)
11702 unformat_input_t *i = vam->input;
11703 vl_api_map_del_domain_t *mp;
11706 u32 num_m_args = 0;
11709 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11711 if (unformat (i, "index %d", &index))
11715 clib_warning ("parse error '%U'", format_unformat_error, i);
11720 if (num_m_args != 1)
11722 errmsg ("mandatory argument(s) missing\n");
11726 /* Construct the API message */
11727 M (MAP_DEL_DOMAIN, map_del_domain);
11729 mp->index = ntohl (index);
11734 /* Wait for a reply, return good/bad news */
11739 api_map_add_del_rule (vat_main_t * vam)
11741 unformat_input_t *i = vam->input;
11742 vl_api_map_add_del_rule_t *mp;
11745 ip6_address_t ip6_dst;
11746 u32 num_m_args = 0, index, psid = 0;
11748 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11750 if (unformat (i, "index %d", &index))
11752 else if (unformat (i, "psid %d", &psid))
11754 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
11756 else if (unformat (i, "del"))
11762 clib_warning ("parse error '%U'", format_unformat_error, i);
11767 /* Construct the API message */
11768 M (MAP_ADD_DEL_RULE, map_add_del_rule);
11770 mp->index = ntohl (index);
11771 mp->is_add = is_add;
11772 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
11773 mp->psid = ntohs (psid);
11778 /* Wait for a reply, return good/bad news */
11783 api_map_domain_dump (vat_main_t * vam)
11785 vl_api_map_domain_dump_t *mp;
11788 /* Construct the API message */
11789 M (MAP_DOMAIN_DUMP, map_domain_dump);
11794 /* Use a control ping for synchronization */
11796 vl_api_control_ping_t *mp;
11797 M (CONTROL_PING, control_ping);
11804 api_map_rule_dump (vat_main_t * vam)
11806 unformat_input_t *i = vam->input;
11807 vl_api_map_rule_dump_t *mp;
11809 u32 domain_index = ~0;
11811 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11813 if (unformat (i, "index %u", &domain_index))
11819 if (domain_index == ~0)
11821 clib_warning ("parse error: domain index expected");
11825 /* Construct the API message */
11826 M (MAP_RULE_DUMP, map_rule_dump);
11828 mp->domain_index = htonl (domain_index);
11833 /* Use a control ping for synchronization */
11835 vl_api_control_ping_t *mp;
11836 M (CONTROL_PING, control_ping);
11842 static void vl_api_map_add_domain_reply_t_handler
11843 (vl_api_map_add_domain_reply_t * mp)
11845 vat_main_t *vam = &vat_main;
11846 i32 retval = ntohl (mp->retval);
11848 if (vam->async_mode)
11850 vam->async_errors += (retval < 0);
11854 vam->retval = retval;
11855 vam->result_ready = 1;
11859 static void vl_api_map_add_domain_reply_t_handler_json
11860 (vl_api_map_add_domain_reply_t * mp)
11862 vat_main_t *vam = &vat_main;
11863 vat_json_node_t node;
11865 vat_json_init_object (&node);
11866 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
11867 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
11869 vat_json_print (vam->ofp, &node);
11870 vat_json_free (&node);
11872 vam->retval = ntohl (mp->retval);
11873 vam->result_ready = 1;
11877 api_get_first_msg_id (vat_main_t * vam)
11879 vl_api_get_first_msg_id_t *mp;
11881 unformat_input_t *i = vam->input;
11885 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11887 if (unformat (i, "client %s", &name))
11895 errmsg ("missing client name\n");
11898 vec_add1 (name, 0);
11900 if (vec_len (name) > 63)
11902 errmsg ("client name too long\n");
11906 M (GET_FIRST_MSG_ID, get_first_msg_id);
11907 clib_memcpy (mp->name, name, vec_len (name));
11915 api_cop_interface_enable_disable (vat_main_t * vam)
11917 unformat_input_t *line_input = vam->input;
11918 vl_api_cop_interface_enable_disable_t *mp;
11920 u32 sw_if_index = ~0;
11921 u8 enable_disable = 1;
11923 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11925 if (unformat (line_input, "disable"))
11926 enable_disable = 0;
11927 if (unformat (line_input, "enable"))
11928 enable_disable = 1;
11929 else if (unformat (line_input, "%U", unformat_sw_if_index,
11930 vam, &sw_if_index))
11932 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11938 if (sw_if_index == ~0)
11940 errmsg ("missing interface name or sw_if_index\n");
11944 /* Construct the API message */
11945 M (COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable);
11946 mp->sw_if_index = ntohl (sw_if_index);
11947 mp->enable_disable = enable_disable;
11951 /* Wait for the reply */
11956 api_cop_whitelist_enable_disable (vat_main_t * vam)
11958 unformat_input_t *line_input = vam->input;
11959 vl_api_cop_whitelist_enable_disable_t *mp;
11961 u32 sw_if_index = ~0;
11962 u8 ip4 = 0, ip6 = 0, default_cop = 0;
11965 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11967 if (unformat (line_input, "ip4"))
11969 else if (unformat (line_input, "ip6"))
11971 else if (unformat (line_input, "default"))
11973 else if (unformat (line_input, "%U", unformat_sw_if_index,
11974 vam, &sw_if_index))
11976 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11978 else if (unformat (line_input, "fib-id %d", &fib_id))
11984 if (sw_if_index == ~0)
11986 errmsg ("missing interface name or sw_if_index\n");
11990 /* Construct the API message */
11991 M (COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable);
11992 mp->sw_if_index = ntohl (sw_if_index);
11993 mp->fib_id = ntohl (fib_id);
11996 mp->default_cop = default_cop;
12000 /* Wait for the reply */
12005 api_get_node_graph (vat_main_t * vam)
12007 vl_api_get_node_graph_t *mp;
12010 M (GET_NODE_GRAPH, get_node_graph);
12014 /* Wait for the reply */
12019 /** Used for parsing LISP eids */
12020 typedef CLIB_PACKED(struct{
12021 u8 addr[16]; /**< eid address */
12022 u32 len; /**< prefix length if IP */
12023 u8 type; /**< type of eid */
12028 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
12030 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
12032 memset (a, 0, sizeof (a[0]));
12034 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
12036 a->type = 0; /* ipv4 type */
12038 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
12040 a->type = 1; /* ipv6 type */
12042 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
12044 a->type = 2; /* mac type */
12051 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
12060 lisp_eid_size_vat (u8 type)
12075 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
12077 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
12081 /** Used for transferring locators via VPP API */
12082 typedef CLIB_PACKED(struct
12084 u32 sw_if_index; /**< locator sw_if_index */
12085 u8 priority; /**< locator priority */
12086 u8 weight; /**< locator weight */
12091 api_lisp_add_del_locator_set (vat_main_t * vam)
12093 unformat_input_t *input = vam->input;
12094 vl_api_lisp_add_del_locator_set_t *mp;
12097 u8 *locator_set_name = NULL;
12098 u8 locator_set_name_set = 0;
12099 ls_locator_t locator, *locators = 0;
12100 u32 sw_if_index, priority, weight;
12103 /* Parse args required to build the message */
12104 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12106 if (unformat (input, "del"))
12110 else if (unformat (input, "locator-set %s", &locator_set_name))
12112 locator_set_name_set = 1;
12114 else if (unformat (input, "sw_if_index %u p %u w %u",
12115 &sw_if_index, &priority, &weight))
12117 locator.sw_if_index = htonl (sw_if_index);
12118 locator.priority = priority;
12119 locator.weight = weight;
12120 vec_add1 (locators, locator);
12122 else if (unformat (input, "iface %U p %u w %u", unformat_sw_if_index,
12123 vam, &sw_if_index, &priority, &weight))
12125 locator.sw_if_index = htonl (sw_if_index);
12126 locator.priority = priority;
12127 locator.weight = weight;
12128 vec_add1 (locators, locator);
12134 if (locator_set_name_set == 0)
12136 errmsg ("missing locator-set name");
12137 vec_free (locators);
12141 if (vec_len (locator_set_name) > 64)
12143 errmsg ("locator-set name too long\n");
12144 vec_free (locator_set_name);
12145 vec_free (locators);
12148 vec_add1 (locator_set_name, 0);
12150 data_len = sizeof (ls_locator_t) * vec_len (locators);
12152 /* Construct the API message */
12153 M2 (LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set, data_len);
12155 mp->is_add = is_add;
12156 clib_memcpy (mp->locator_set_name, locator_set_name,
12157 vec_len (locator_set_name));
12158 vec_free (locator_set_name);
12160 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
12162 clib_memcpy (mp->locators, locators, data_len);
12163 vec_free (locators);
12168 /* Wait for a reply... */
12176 api_lisp_add_del_locator (vat_main_t * vam)
12178 unformat_input_t *input = vam->input;
12179 vl_api_lisp_add_del_locator_t *mp;
12181 u32 tmp_if_index = ~0;
12182 u32 sw_if_index = ~0;
12183 u8 sw_if_index_set = 0;
12184 u8 sw_if_index_if_name_set = 0;
12186 u8 priority_set = 0;
12190 u8 *locator_set_name = NULL;
12191 u8 locator_set_name_set = 0;
12193 /* Parse args required to build the message */
12194 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12196 if (unformat (input, "del"))
12200 else if (unformat (input, "locator-set %s", &locator_set_name))
12202 locator_set_name_set = 1;
12204 else if (unformat (input, "iface %U", unformat_sw_if_index, vam,
12207 sw_if_index_if_name_set = 1;
12208 sw_if_index = tmp_if_index;
12210 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
12212 sw_if_index_set = 1;
12213 sw_if_index = tmp_if_index;
12215 else if (unformat (input, "p %d", &priority))
12219 else if (unformat (input, "w %d", &weight))
12227 if (locator_set_name_set == 0)
12229 errmsg ("missing locator-set name");
12233 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
12235 errmsg ("missing sw_if_index");
12236 vec_free (locator_set_name);
12240 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
12242 errmsg ("cannot use both params interface name and sw_if_index");
12243 vec_free (locator_set_name);
12247 if (priority_set == 0)
12249 errmsg ("missing locator-set priority\n");
12250 vec_free (locator_set_name);
12254 if (weight_set == 0)
12256 errmsg ("missing locator-set weight\n");
12257 vec_free (locator_set_name);
12261 if (vec_len (locator_set_name) > 64)
12263 errmsg ("locator-set name too long\n");
12264 vec_free (locator_set_name);
12267 vec_add1 (locator_set_name, 0);
12269 /* Construct the API message */
12270 M (LISP_ADD_DEL_LOCATOR, lisp_add_del_locator);
12272 mp->is_add = is_add;
12273 mp->sw_if_index = ntohl (sw_if_index);
12274 mp->priority = priority;
12275 mp->weight = weight;
12276 clib_memcpy (mp->locator_set_name, locator_set_name,
12277 vec_len (locator_set_name));
12278 vec_free (locator_set_name);
12283 /* Wait for a reply... */
12291 api_lisp_add_del_local_eid (vat_main_t * vam)
12293 unformat_input_t *input = vam->input;
12294 vl_api_lisp_add_del_local_eid_t *mp;
12298 lisp_eid_vat_t _eid, *eid = &_eid;
12299 u8 *locator_set_name = 0;
12300 u8 locator_set_name_set = 0;
12303 /* Parse args required to build the message */
12304 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12306 if (unformat (input, "del"))
12310 else if (unformat (input, "vni %d", &vni))
12314 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
12318 else if (unformat (input, "locator-set %s", &locator_set_name))
12320 locator_set_name_set = 1;
12326 if (locator_set_name_set == 0)
12328 errmsg ("missing locator-set name\n");
12334 errmsg ("EID address not set!");
12335 vec_free (locator_set_name);
12339 if (vec_len (locator_set_name) > 64)
12341 errmsg ("locator-set name too long\n");
12342 vec_free (locator_set_name);
12345 vec_add1 (locator_set_name, 0);
12347 /* Construct the API message */
12348 M (LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid);
12350 mp->is_add = is_add;
12351 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
12352 mp->eid_type = eid->type;
12353 mp->prefix_len = eid->len;
12354 mp->vni = clib_host_to_net_u32 (vni);
12355 clib_memcpy (mp->locator_set_name, locator_set_name,
12356 vec_len (locator_set_name));
12358 vec_free (locator_set_name);
12363 /* Wait for a reply... */
12371 /** Used for transferring locators via VPP API */
12372 typedef CLIB_PACKED(struct
12374 u8 is_ip4; /**< is locator an IPv4 address? */
12375 u8 priority; /**< locator priority */
12376 u8 weight; /**< locator weight */
12377 u8 addr[16]; /**< IPv4/IPv6 address */
12382 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
12384 unformat_input_t *input = vam->input;
12385 vl_api_lisp_gpe_add_del_fwd_entry_t *mp;
12388 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
12389 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
12390 u8 rmt_eid_set = 0, lcl_eid_set = 0;
12391 u32 action = ~0, p, w;
12392 ip4_address_t rmt_rloc4, lcl_rloc4;
12393 ip6_address_t rmt_rloc6, lcl_rloc6;
12394 rloc_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
12396 memset (&rloc, 0, sizeof (rloc));
12398 /* Parse args required to build the message */
12399 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12401 if (unformat (input, "del"))
12405 else if (unformat (input, "rmt_eid %U", unformat_lisp_eid_vat, rmt_eid))
12409 else if (unformat (input, "lcl_eid %U", unformat_lisp_eid_vat, lcl_eid))
12413 else if (unformat (input, "p %d w %d", &p, &w))
12417 errmsg ("No RLOC configured for setting priority/weight!");
12420 curr_rloc->priority = p;
12421 curr_rloc->weight = w;
12423 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
12424 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
12428 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
12429 rloc.priority = rloc.weight = 0;
12430 vec_add1 (lcl_locs, rloc);
12432 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
12433 vec_add1 (rmt_locs, rloc);
12434 /* priority and weight saved in rmt loc */
12435 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
12437 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
12438 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
12441 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
12442 rloc.priority = rloc.weight = 0;
12443 vec_add1 (lcl_locs, rloc);
12445 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
12446 vec_add1 (rmt_locs, rloc);
12447 /* priority and weight saved in rmt loc */
12448 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
12450 else if (unformat (input, "action %d", &action))
12456 clib_warning ("parse error '%U'", format_unformat_error, input);
12463 errmsg ("remote eid addresses not set\n");
12467 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
12469 errmsg ("eid types don't match\n");
12473 if (0 == rmt_locs && (u32) ~ 0 == action)
12475 errmsg ("action not set for negative mapping\n");
12479 /* Construct the API message */
12480 M (LISP_GPE_ADD_DEL_FWD_ENTRY, lisp_gpe_add_del_fwd_entry);
12482 mp->is_add = is_add;
12483 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
12484 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
12485 mp->eid_type = rmt_eid->type;
12486 mp->rmt_len = rmt_eid->len;
12487 mp->lcl_len = lcl_eid->len;
12488 mp->action = action;
12490 if (0 != rmt_locs && 0 != lcl_locs)
12492 mp->loc_num = vec_len (rmt_locs);
12493 clib_memcpy (mp->lcl_locs, lcl_locs,
12494 (sizeof (rloc_t) * vec_len (lcl_locs)));
12495 clib_memcpy (mp->rmt_locs, rmt_locs,
12496 (sizeof (rloc_t) * vec_len (rmt_locs)));
12498 vec_free (lcl_locs);
12499 vec_free (rmt_locs);
12504 /* Wait for a reply... */
12512 api_lisp_add_del_map_resolver (vat_main_t * vam)
12514 unformat_input_t *input = vam->input;
12515 vl_api_lisp_add_del_map_resolver_t *mp;
12520 ip4_address_t ipv4;
12521 ip6_address_t ipv6;
12523 /* Parse args required to build the message */
12524 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12526 if (unformat (input, "del"))
12530 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
12534 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
12542 if (ipv4_set && ipv6_set)
12544 errmsg ("both eid v4 and v6 addresses set\n");
12548 if (!ipv4_set && !ipv6_set)
12550 errmsg ("eid addresses not set\n");
12554 /* Construct the API message */
12555 M (LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver);
12557 mp->is_add = is_add;
12561 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
12566 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
12572 /* Wait for a reply... */
12580 api_lisp_gpe_enable_disable (vat_main_t * vam)
12582 unformat_input_t *input = vam->input;
12583 vl_api_lisp_gpe_enable_disable_t *mp;
12588 /* Parse args required to build the message */
12589 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12591 if (unformat (input, "enable"))
12596 else if (unformat (input, "disable"))
12607 errmsg ("Value not set\n");
12611 /* Construct the API message */
12612 M (LISP_GPE_ENABLE_DISABLE, lisp_gpe_enable_disable);
12619 /* Wait for a reply... */
12627 api_lisp_enable_disable (vat_main_t * vam)
12629 unformat_input_t *input = vam->input;
12630 vl_api_lisp_enable_disable_t *mp;
12635 /* Parse args required to build the message */
12636 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12638 if (unformat (input, "enable"))
12643 else if (unformat (input, "disable"))
12653 errmsg ("Value not set\n");
12657 /* Construct the API message */
12658 M (LISP_ENABLE_DISABLE, lisp_enable_disable);
12665 /* Wait for a reply... */
12673 api_show_lisp_map_request_mode (vat_main_t * vam)
12676 vl_api_show_lisp_map_request_mode_t *mp;
12678 M (SHOW_LISP_MAP_REQUEST_MODE, show_lisp_map_request_mode);
12683 /* wait for reply */
12690 api_lisp_map_request_mode (vat_main_t * vam)
12693 unformat_input_t *input = vam->input;
12694 vl_api_lisp_map_request_mode_t *mp;
12697 /* Parse args required to build the message */
12698 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12700 if (unformat (input, "dst-only"))
12702 else if (unformat (input, "src-dst"))
12706 errmsg ("parse error '%U'", format_unformat_error, input);
12711 M (LISP_MAP_REQUEST_MODE, lisp_map_request_mode);
12718 /* wait for reply */
12726 * Enable/disable LISP proxy ITR.
12728 * @param vam vpp API test context
12729 * @return return code
12732 api_lisp_pitr_set_locator_set (vat_main_t * vam)
12735 u8 ls_name_set = 0;
12736 unformat_input_t *input = vam->input;
12737 vl_api_lisp_pitr_set_locator_set_t *mp;
12741 /* Parse args required to build the message */
12742 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12744 if (unformat (input, "del"))
12746 else if (unformat (input, "locator-set %s", &ls_name))
12750 errmsg ("parse error '%U'", format_unformat_error, input);
12757 errmsg ("locator-set name not set!");
12761 M (LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set);
12763 mp->is_add = is_add;
12764 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
12765 vec_free (ls_name);
12770 /* wait for reply */
12778 api_show_lisp_pitr (vat_main_t * vam)
12780 vl_api_show_lisp_pitr_t *mp;
12783 if (!vam->json_output)
12785 fformat (vam->ofp, "%=20s\n", "lisp status:");
12788 M (SHOW_LISP_PITR, show_lisp_pitr);
12792 /* Wait for a reply... */
12800 * Add/delete mapping between vni and vrf
12803 api_lisp_eid_table_add_del_map (vat_main_t * vam)
12806 unformat_input_t *input = vam->input;
12807 vl_api_lisp_eid_table_add_del_map_t *mp;
12808 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
12809 u32 vni, vrf, bd_index;
12811 /* Parse args required to build the message */
12812 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12814 if (unformat (input, "del"))
12816 else if (unformat (input, "vrf %d", &vrf))
12818 else if (unformat (input, "bd_index %d", &bd_index))
12820 else if (unformat (input, "vni %d", &vni))
12826 if (!vni_set || (!vrf_set && !bd_index_set))
12828 errmsg ("missing arguments!");
12832 if (vrf_set && bd_index_set)
12834 errmsg ("error: both vrf and bd entered!");
12838 M (LISP_EID_TABLE_ADD_DEL_MAP, lisp_eid_table_add_del_map);
12840 mp->is_add = is_add;
12841 mp->vni = htonl (vni);
12842 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
12843 mp->is_l2 = bd_index_set;
12848 /* wait for reply */
12856 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
12858 u32 *action = va_arg (*args, u32 *);
12861 if (unformat (input, "%s", &s))
12863 if (!strcmp ((char *) s, "no-action"))
12865 else if (!strcmp ((char *) s, "natively-forward"))
12867 else if (!strcmp ((char *) s, "send-map-request"))
12869 else if (!strcmp ((char *) s, "drop"))
12873 clib_warning ("invalid action: '%s'", s);
12885 * Add/del remote mapping to/from LISP control plane
12887 * @param vam vpp API test context
12888 * @return return code
12891 api_lisp_add_del_remote_mapping (vat_main_t * vam)
12893 unformat_input_t *input = vam->input;
12894 vl_api_lisp_add_del_remote_mapping_t *mp;
12897 lisp_eid_vat_t _eid, *eid = &_eid;
12898 lisp_eid_vat_t _seid, *seid = &_seid;
12899 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
12900 u32 action = ~0, p, w, data_len;
12901 ip4_address_t rloc4;
12902 ip6_address_t rloc6;
12903 rloc_t *rlocs = 0, rloc, *curr_rloc = 0;
12905 memset (&rloc, 0, sizeof (rloc));
12907 /* Parse args required to build the message */
12908 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12910 if (unformat (input, "del-all"))
12914 else if (unformat (input, "del"))
12918 else if (unformat (input, "add"))
12922 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
12926 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
12930 else if (unformat (input, "vni %d", &vni))
12934 else if (unformat (input, "p %d w %d", &p, &w))
12938 errmsg ("No RLOC configured for setting priority/weight!");
12941 curr_rloc->priority = p;
12942 curr_rloc->weight = w;
12944 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
12947 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
12948 vec_add1 (rlocs, rloc);
12949 curr_rloc = &rlocs[vec_len (rlocs) - 1];
12951 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
12954 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
12955 vec_add1 (rlocs, rloc);
12956 curr_rloc = &rlocs[vec_len (rlocs) - 1];
12958 else if (unformat (input, "action %U",
12959 unformat_negative_mapping_action, &action))
12965 clib_warning ("parse error '%U'", format_unformat_error, input);
12972 errmsg ("missing params!");
12976 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
12978 errmsg ("no action set for negative map-reply!");
12982 data_len = vec_len (rlocs) * sizeof (rloc_t);
12984 M2 (LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping, data_len);
12985 mp->is_add = is_add;
12986 mp->vni = htonl (vni);
12987 mp->action = (u8) action;
12988 mp->is_src_dst = seid_set;
12989 mp->eid_len = eid->len;
12990 mp->seid_len = seid->len;
12991 mp->del_all = del_all;
12992 mp->eid_type = eid->type;
12993 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
12994 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
12996 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
12997 clib_memcpy (mp->rlocs, rlocs, data_len);
13003 /* Wait for a reply... */
13011 * Add/del LISP adjacency. Saves mapping in LISP control plane and updates
13012 * forwarding entries in data-plane accordingly.
13014 * @param vam vpp API test context
13015 * @return return code
13018 api_lisp_add_del_adjacency (vat_main_t * vam)
13020 unformat_input_t *input = vam->input;
13021 vl_api_lisp_add_del_adjacency_t *mp;
13024 ip4_address_t leid4, reid4;
13025 ip6_address_t leid6, reid6;
13026 u8 reid_mac[6] = { 0 };
13027 u8 leid_mac[6] = { 0 };
13028 u8 reid_type, leid_type;
13029 u32 leid_len = 0, reid_len = 0, len;
13032 leid_type = reid_type = (u8) ~ 0;
13034 /* Parse args required to build the message */
13035 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13037 if (unformat (input, "del"))
13041 else if (unformat (input, "add"))
13045 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
13048 reid_type = 0; /* ipv4 */
13051 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
13054 reid_type = 1; /* ipv6 */
13057 else if (unformat (input, "reid %U", unformat_ethernet_address,
13060 reid_type = 2; /* mac */
13062 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
13065 leid_type = 0; /* ipv4 */
13068 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
13071 leid_type = 1; /* ipv6 */
13074 else if (unformat (input, "leid %U", unformat_ethernet_address,
13077 leid_type = 2; /* mac */
13079 else if (unformat (input, "vni %d", &vni))
13085 errmsg ("parse error '%U'", format_unformat_error, input);
13090 if ((u8) ~ 0 == reid_type)
13092 errmsg ("missing params!");
13096 if (leid_type != reid_type)
13098 errmsg ("remote and local EIDs are of different types!");
13102 M (LISP_ADD_DEL_ADJACENCY, lisp_add_del_adjacency);
13103 mp->is_add = is_add;
13104 mp->vni = htonl (vni);
13105 mp->leid_len = leid_len;
13106 mp->reid_len = reid_len;
13107 mp->eid_type = reid_type;
13109 switch (mp->eid_type)
13112 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
13113 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
13116 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
13117 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
13120 clib_memcpy (mp->leid, leid_mac, 6);
13121 clib_memcpy (mp->reid, reid_mac, 6);
13124 errmsg ("unknown EID type %d!", mp->eid_type);
13131 /* Wait for a reply... */
13139 api_lisp_gpe_add_del_iface (vat_main_t * vam)
13141 unformat_input_t *input = vam->input;
13142 vl_api_lisp_gpe_add_del_iface_t *mp;
13144 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
13145 u32 dp_table = 0, vni = 0;
13147 /* Parse args required to build the message */
13148 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13150 if (unformat (input, "up"))
13155 else if (unformat (input, "down"))
13160 else if (unformat (input, "table_id %d", &dp_table))
13164 else if (unformat (input, "bd_id %d", &dp_table))
13169 else if (unformat (input, "vni %d", &vni))
13177 if (action_set == 0)
13179 errmsg ("Action not set\n");
13182 if (dp_table_set == 0 || vni_set == 0)
13184 errmsg ("vni and dp_table must be set\n");
13188 /* Construct the API message */
13189 M (LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface);
13191 mp->is_add = is_add;
13192 mp->dp_table = dp_table;
13199 /* Wait for a reply... */
13207 * Add/del map request itr rlocs from LISP control plane and updates
13209 * @param vam vpp API test context
13210 * @return return code
13213 api_lisp_add_del_map_request_itr_rlocs (vat_main_t * vam)
13215 unformat_input_t *input = vam->input;
13216 vl_api_lisp_add_del_map_request_itr_rlocs_t *mp;
13218 u8 *locator_set_name = 0;
13219 u8 locator_set_name_set = 0;
13222 /* Parse args required to build the message */
13223 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13225 if (unformat (input, "del"))
13229 else if (unformat (input, "%_%v%_", &locator_set_name))
13231 locator_set_name_set = 1;
13235 clib_warning ("parse error '%U'", format_unformat_error, input);
13240 if (is_add && !locator_set_name_set)
13242 errmsg ("itr-rloc is not set!");
13246 if (is_add && vec_len (locator_set_name) > 64)
13248 errmsg ("itr-rloc locator-set name too long\n");
13249 vec_free (locator_set_name);
13253 M (LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, lisp_add_del_map_request_itr_rlocs);
13254 mp->is_add = is_add;
13257 clib_memcpy (mp->locator_set_name, locator_set_name,
13258 vec_len (locator_set_name));
13262 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
13264 vec_free (locator_set_name);
13269 /* Wait for a reply... */
13277 api_lisp_locator_dump (vat_main_t * vam)
13279 unformat_input_t *input = vam->input;
13280 vl_api_lisp_locator_dump_t *mp;
13282 u8 is_index_set = 0, is_name_set = 0;
13286 /* Parse args required to build the message */
13287 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13289 if (unformat (input, "ls_name %_%v%_", &ls_name))
13293 else if (unformat (input, "ls_index %d", &ls_index))
13299 errmsg ("parse error '%U'", format_unformat_error, input);
13304 if (!is_index_set && !is_name_set)
13306 errmsg ("error: expected one of index or name!\n");
13310 if (is_index_set && is_name_set)
13312 errmsg ("error: only one param expected!\n");
13316 if (vec_len (ls_name) > 62)
13318 errmsg ("error: locator set name too long!");
13322 if (!vam->json_output)
13324 fformat (vam->ofp, "%=16s%=16s%=16s\n", "locator", "priority",
13328 M (LISP_LOCATOR_DUMP, lisp_locator_dump);
13329 mp->is_index_set = is_index_set;
13332 mp->ls_index = clib_host_to_net_u32 (ls_index);
13335 vec_add1 (ls_name, 0);
13336 strncpy ((char *) mp->ls_name, (char *) ls_name,
13337 sizeof (mp->ls_name) - 1);
13343 /* Use a control ping for synchronization */
13345 vl_api_control_ping_t *mp;
13346 M (CONTROL_PING, control_ping);
13349 /* Wait for a reply... */
13357 api_lisp_locator_set_dump (vat_main_t * vam)
13359 vl_api_lisp_locator_set_dump_t *mp;
13360 unformat_input_t *input = vam->input;
13364 /* Parse args required to build the message */
13365 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13367 if (unformat (input, "local"))
13371 else if (unformat (input, "remote"))
13377 errmsg ("parse error '%U'", format_unformat_error, input);
13382 if (!vam->json_output)
13384 fformat (vam->ofp, "%=10s%=15s\n", "ls_index", "ls_name");
13387 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
13389 mp->filter = filter;
13394 /* Use a control ping for synchronization */
13396 vl_api_control_ping_t *mp;
13397 M (CONTROL_PING, control_ping);
13400 /* Wait for a reply... */
13408 api_lisp_eid_table_map_dump (vat_main_t * vam)
13412 unformat_input_t *input = vam->input;
13413 vl_api_lisp_eid_table_map_dump_t *mp;
13416 /* Parse args required to build the message */
13417 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13419 if (unformat (input, "l2"))
13424 else if (unformat (input, "l3"))
13431 errmsg ("parse error '%U'", format_unformat_error, input);
13438 errmsg ("expected one of 'l2' or 'l3' parameter!\n");
13442 if (!vam->json_output)
13444 fformat (vam->ofp, "%=10s%=10s\n", "VNI", is_l2 ? "BD" : "VRF");
13447 M (LISP_EID_TABLE_MAP_DUMP, lisp_eid_table_map_dump);
13453 /* Use a control ping for synchronization */
13455 vl_api_control_ping_t *mp;
13456 M (CONTROL_PING, control_ping);
13459 /* Wait for a reply... */
13467 api_lisp_eid_table_vni_dump (vat_main_t * vam)
13469 vl_api_lisp_eid_table_vni_dump_t *mp;
13472 if (!vam->json_output)
13474 fformat (vam->ofp, "VNI\n");
13477 M (LISP_EID_TABLE_VNI_DUMP, lisp_eid_table_vni_dump);
13482 /* Use a control ping for synchronization */
13484 vl_api_control_ping_t *mp;
13485 M (CONTROL_PING, control_ping);
13488 /* Wait for a reply... */
13496 api_lisp_eid_table_dump (vat_main_t * vam)
13498 unformat_input_t *i = vam->input;
13499 vl_api_lisp_eid_table_dump_t *mp;
13501 struct in_addr ip4;
13502 struct in6_addr ip6;
13504 u8 eid_type = ~0, eid_set = 0;
13505 u32 prefix_length = ~0, t, vni = 0;
13508 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13510 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
13516 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
13522 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
13527 else if (unformat (i, "vni %d", &t))
13531 else if (unformat (i, "local"))
13535 else if (unformat (i, "remote"))
13541 errmsg ("parse error '%U'", format_unformat_error, i);
13546 if (!vam->json_output)
13548 fformat (vam->ofp, "%-35s%-20s%-30s%-20s%-s\n", "EID", "type",
13549 "ls_index", "ttl", "authoritative");
13552 M (LISP_EID_TABLE_DUMP, lisp_eid_table_dump);
13554 mp->filter = filter;
13558 mp->vni = htonl (vni);
13559 mp->eid_type = eid_type;
13563 mp->prefix_length = prefix_length;
13564 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
13567 mp->prefix_length = prefix_length;
13568 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
13571 clib_memcpy (mp->eid, mac, sizeof (mac));
13574 errmsg ("unknown EID type %d!", eid_type);
13582 /* Use a control ping for synchronization */
13584 vl_api_control_ping_t *mp;
13585 M (CONTROL_PING, control_ping);
13589 /* Wait for a reply... */
13597 api_lisp_gpe_tunnel_dump (vat_main_t * vam)
13599 vl_api_lisp_gpe_tunnel_dump_t *mp;
13602 if (!vam->json_output)
13604 fformat (vam->ofp, "%=20s%=30s%=16s%=16s%=16s%=16s"
13605 "%=16s%=16s%=16s%=16s%=16s\n",
13606 "Tunel", "Source", "Destination", "Fib encap", "Fib decap",
13607 "Decap next", "Lisp version", "Flags", "Next protocol",
13608 "ver_res", "res", "iid");
13611 M (LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump);
13615 /* Use a control ping for synchronization */
13617 vl_api_control_ping_t *mp;
13618 M (CONTROL_PING, control_ping);
13621 /* Wait for a reply... */
13629 api_lisp_map_resolver_dump (vat_main_t * vam)
13631 vl_api_lisp_map_resolver_dump_t *mp;
13634 if (!vam->json_output)
13636 fformat (vam->ofp, "%=20s\n", "Map resolver");
13639 M (LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump);
13643 /* Use a control ping for synchronization */
13645 vl_api_control_ping_t *mp;
13646 M (CONTROL_PING, control_ping);
13649 /* Wait for a reply... */
13657 api_show_lisp_status (vat_main_t * vam)
13659 vl_api_show_lisp_status_t *mp;
13662 if (!vam->json_output)
13664 fformat (vam->ofp, "%-20s%-16s\n", "lisp status", "locator-set");
13667 M (SHOW_LISP_STATUS, show_lisp_status);
13670 /* Wait for a reply... */
13678 api_lisp_get_map_request_itr_rlocs (vat_main_t * vam)
13680 vl_api_lisp_get_map_request_itr_rlocs_t *mp;
13683 if (!vam->json_output)
13685 fformat (vam->ofp, "%=20s\n", "itr-rlocs:");
13688 M (LISP_GET_MAP_REQUEST_ITR_RLOCS, lisp_get_map_request_itr_rlocs);
13691 /* Wait for a reply... */
13699 api_af_packet_create (vat_main_t * vam)
13701 unformat_input_t *i = vam->input;
13702 vl_api_af_packet_create_t *mp;
13704 u8 *host_if_name = 0;
13706 u8 random_hw_addr = 1;
13708 memset (hw_addr, 0, sizeof (hw_addr));
13710 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13712 if (unformat (i, "name %s", &host_if_name))
13713 vec_add1 (host_if_name, 0);
13714 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
13715 random_hw_addr = 0;
13720 if (!vec_len (host_if_name))
13722 errmsg ("host-interface name must be specified");
13726 if (vec_len (host_if_name) > 64)
13728 errmsg ("host-interface name too long");
13732 M (AF_PACKET_CREATE, af_packet_create);
13734 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
13735 clib_memcpy (mp->hw_addr, hw_addr, 6);
13736 mp->use_random_hw_addr = random_hw_addr;
13737 vec_free (host_if_name);
13740 W2 (fprintf (vam->ofp, " new sw_if_index = %d ", vam->sw_if_index));
13746 api_af_packet_delete (vat_main_t * vam)
13748 unformat_input_t *i = vam->input;
13749 vl_api_af_packet_delete_t *mp;
13751 u8 *host_if_name = 0;
13753 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13755 if (unformat (i, "name %s", &host_if_name))
13756 vec_add1 (host_if_name, 0);
13761 if (!vec_len (host_if_name))
13763 errmsg ("host-interface name must be specified");
13767 if (vec_len (host_if_name) > 64)
13769 errmsg ("host-interface name too long");
13773 M (AF_PACKET_DELETE, af_packet_delete);
13775 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
13776 vec_free (host_if_name);
13785 api_policer_add_del (vat_main_t * vam)
13787 unformat_input_t *i = vam->input;
13788 vl_api_policer_add_del_t *mp;
13799 u8 color_aware = 0;
13800 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
13802 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
13803 conform_action.dscp = 0;
13804 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
13805 exceed_action.dscp = 0;
13806 violate_action.action_type = SSE2_QOS_ACTION_DROP;
13807 violate_action.dscp = 0;
13809 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13811 if (unformat (i, "del"))
13813 else if (unformat (i, "name %s", &name))
13814 vec_add1 (name, 0);
13815 else if (unformat (i, "cir %u", &cir))
13817 else if (unformat (i, "eir %u", &eir))
13819 else if (unformat (i, "cb %u", &cb))
13821 else if (unformat (i, "eb %u", &eb))
13823 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
13826 else if (unformat (i, "round_type %U", unformat_policer_round_type,
13829 else if (unformat (i, "type %U", unformat_policer_type, &type))
13831 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
13834 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
13837 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
13840 else if (unformat (i, "color-aware"))
13846 if (!vec_len (name))
13848 errmsg ("policer name must be specified");
13852 if (vec_len (name) > 64)
13854 errmsg ("policer name too long");
13858 M (POLICER_ADD_DEL, policer_add_del);
13860 clib_memcpy (mp->name, name, vec_len (name));
13862 mp->is_add = is_add;
13867 mp->rate_type = rate_type;
13868 mp->round_type = round_type;
13870 mp->conform_action_type = conform_action.action_type;
13871 mp->conform_dscp = conform_action.dscp;
13872 mp->exceed_action_type = exceed_action.action_type;
13873 mp->exceed_dscp = exceed_action.dscp;
13874 mp->violate_action_type = violate_action.action_type;
13875 mp->violate_dscp = violate_action.dscp;
13876 mp->color_aware = color_aware;
13885 api_policer_dump (vat_main_t * vam)
13887 unformat_input_t *i = vam->input;
13888 vl_api_policer_dump_t *mp;
13890 u8 *match_name = 0;
13891 u8 match_name_valid = 0;
13893 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13895 if (unformat (i, "name %s", &match_name))
13897 vec_add1 (match_name, 0);
13898 match_name_valid = 1;
13904 M (POLICER_DUMP, policer_dump);
13905 mp->match_name_valid = match_name_valid;
13906 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
13907 vec_free (match_name);
13911 /* Use a control ping for synchronization */
13913 vl_api_control_ping_t *mp;
13914 M (CONTROL_PING, control_ping);
13917 /* Wait for a reply... */
13925 api_policer_classify_set_interface (vat_main_t * vam)
13927 unformat_input_t *i = vam->input;
13928 vl_api_policer_classify_set_interface_t *mp;
13931 int sw_if_index_set;
13932 u32 ip4_table_index = ~0;
13933 u32 ip6_table_index = ~0;
13934 u32 l2_table_index = ~0;
13937 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13939 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
13940 sw_if_index_set = 1;
13941 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13942 sw_if_index_set = 1;
13943 else if (unformat (i, "del"))
13945 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13947 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13949 else if (unformat (i, "l2-table %d", &l2_table_index))
13953 clib_warning ("parse error '%U'", format_unformat_error, i);
13958 if (sw_if_index_set == 0)
13960 errmsg ("missing interface name or sw_if_index\n");
13964 M (POLICER_CLASSIFY_SET_INTERFACE, policer_classify_set_interface);
13966 mp->sw_if_index = ntohl (sw_if_index);
13967 mp->ip4_table_index = ntohl (ip4_table_index);
13968 mp->ip6_table_index = ntohl (ip6_table_index);
13969 mp->l2_table_index = ntohl (l2_table_index);
13970 mp->is_add = is_add;
13979 api_policer_classify_dump (vat_main_t * vam)
13981 unformat_input_t *i = vam->input;
13982 vl_api_policer_classify_dump_t *mp;
13984 u8 type = POLICER_CLASSIFY_N_TABLES;
13986 if (unformat (i, "type %U", unformat_classify_table_type, &type))
13990 errmsg ("classify table type must be specified\n");
13994 if (!vam->json_output)
13996 fformat (vam->ofp, "%10s%20s\n", "Intfc idx", "Classify table");
13999 M (POLICER_CLASSIFY_DUMP, policer_classify_dump);
14004 /* Use a control ping for synchronization */
14006 vl_api_control_ping_t *mp;
14007 M (CONTROL_PING, control_ping);
14010 /* Wait for a reply... */
14018 api_netmap_create (vat_main_t * vam)
14020 unformat_input_t *i = vam->input;
14021 vl_api_netmap_create_t *mp;
14025 u8 random_hw_addr = 1;
14029 memset (hw_addr, 0, sizeof (hw_addr));
14031 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14033 if (unformat (i, "name %s", &if_name))
14034 vec_add1 (if_name, 0);
14035 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
14036 random_hw_addr = 0;
14037 else if (unformat (i, "pipe"))
14039 else if (unformat (i, "master"))
14041 else if (unformat (i, "slave"))
14047 if (!vec_len (if_name))
14049 errmsg ("interface name must be specified");
14053 if (vec_len (if_name) > 64)
14055 errmsg ("interface name too long");
14059 M (NETMAP_CREATE, netmap_create);
14061 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
14062 clib_memcpy (mp->hw_addr, hw_addr, 6);
14063 mp->use_random_hw_addr = random_hw_addr;
14064 mp->is_pipe = is_pipe;
14065 mp->is_master = is_master;
14066 vec_free (if_name);
14075 api_netmap_delete (vat_main_t * vam)
14077 unformat_input_t *i = vam->input;
14078 vl_api_netmap_delete_t *mp;
14082 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14084 if (unformat (i, "name %s", &if_name))
14085 vec_add1 (if_name, 0);
14090 if (!vec_len (if_name))
14092 errmsg ("interface name must be specified");
14096 if (vec_len (if_name) > 64)
14098 errmsg ("interface name too long");
14102 M (NETMAP_DELETE, netmap_delete);
14104 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
14105 vec_free (if_name);
14113 static void vl_api_mpls_gre_tunnel_details_t_handler
14114 (vl_api_mpls_gre_tunnel_details_t * mp)
14116 vat_main_t *vam = &vat_main;
14118 i32 len = ntohl (mp->nlabels);
14120 if (mp->l2_only == 0)
14122 fformat (vam->ofp, "[%d]: src %U, dst %U, adj %U/%d, labels ",
14123 ntohl (mp->tunnel_index),
14124 format_ip4_address, &mp->tunnel_src,
14125 format_ip4_address, &mp->tunnel_dst,
14126 format_ip4_address, &mp->intfc_address,
14127 ntohl (mp->mask_width));
14128 for (i = 0; i < len; i++)
14130 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14132 fformat (vam->ofp, "\n");
14133 fformat (vam->ofp, " inner fib index %d, outer fib index %d\n",
14134 ntohl (mp->inner_fib_index), ntohl (mp->outer_fib_index));
14138 fformat (vam->ofp, "[%d]: src %U, dst %U, key %U, labels ",
14139 ntohl (mp->tunnel_index),
14140 format_ip4_address, &mp->tunnel_src,
14141 format_ip4_address, &mp->tunnel_dst,
14142 format_ip4_address, &mp->intfc_address);
14143 for (i = 0; i < len; i++)
14145 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14147 fformat (vam->ofp, "\n");
14148 fformat (vam->ofp, " l2 interface %d, outer fib index %d\n",
14149 ntohl (mp->hw_if_index), ntohl (mp->outer_fib_index));
14153 static void vl_api_mpls_gre_tunnel_details_t_handler_json
14154 (vl_api_mpls_gre_tunnel_details_t * mp)
14156 vat_main_t *vam = &vat_main;
14157 vat_json_node_t *node = NULL;
14158 struct in_addr ip4;
14160 i32 len = ntohl (mp->nlabels);
14162 if (VAT_JSON_ARRAY != vam->json_tree.type)
14164 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14165 vat_json_init_array (&vam->json_tree);
14167 node = vat_json_array_add (&vam->json_tree);
14169 vat_json_init_object (node);
14170 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
14171 clib_memcpy (&ip4, &(mp->intfc_address), sizeof (ip4));
14172 vat_json_object_add_ip4 (node, "intfc_address", ip4);
14173 vat_json_object_add_uint (node, "inner_fib_index",
14174 ntohl (mp->inner_fib_index));
14175 vat_json_object_add_uint (node, "mask_width", ntohl (mp->mask_width));
14176 vat_json_object_add_uint (node, "encap_index", ntohl (mp->encap_index));
14177 vat_json_object_add_uint (node, "hw_if_index", ntohl (mp->hw_if_index));
14178 vat_json_object_add_uint (node, "l2_only", ntohl (mp->l2_only));
14179 clib_memcpy (&ip4, &(mp->tunnel_src), sizeof (ip4));
14180 vat_json_object_add_ip4 (node, "tunnel_src", ip4);
14181 clib_memcpy (&ip4, &(mp->tunnel_dst), sizeof (ip4));
14182 vat_json_object_add_ip4 (node, "tunnel_dst", ip4);
14183 vat_json_object_add_uint (node, "outer_fib_index",
14184 ntohl (mp->outer_fib_index));
14185 vat_json_object_add_uint (node, "label_count", len);
14186 for (i = 0; i < len; i++)
14188 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14193 api_mpls_gre_tunnel_dump (vat_main_t * vam)
14195 vl_api_mpls_gre_tunnel_dump_t *mp;
14199 /* Parse args required to build the message */
14200 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
14202 if (!unformat (vam->input, "tunnel_index %d", &index))
14209 fformat (vam->ofp, " tunnel_index %d\n", index);
14211 M (MPLS_GRE_TUNNEL_DUMP, mpls_gre_tunnel_dump);
14212 mp->tunnel_index = htonl (index);
14215 /* Use a control ping for synchronization */
14217 vl_api_control_ping_t *mp;
14218 M (CONTROL_PING, control_ping);
14224 static void vl_api_mpls_eth_tunnel_details_t_handler
14225 (vl_api_mpls_eth_tunnel_details_t * mp)
14227 vat_main_t *vam = &vat_main;
14229 i32 len = ntohl (mp->nlabels);
14231 fformat (vam->ofp, "[%d]: dst %U, adj %U/%d, labels ",
14232 ntohl (mp->tunnel_index),
14233 format_ethernet_address, &mp->tunnel_dst_mac,
14234 format_ip4_address, &mp->intfc_address, ntohl (mp->mask_width));
14235 for (i = 0; i < len; i++)
14237 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14239 fformat (vam->ofp, "\n");
14240 fformat (vam->ofp, " tx on %d, rx fib index %d\n",
14241 ntohl (mp->tx_sw_if_index), ntohl (mp->inner_fib_index));
14244 static void vl_api_mpls_eth_tunnel_details_t_handler_json
14245 (vl_api_mpls_eth_tunnel_details_t * mp)
14247 vat_main_t *vam = &vat_main;
14248 vat_json_node_t *node = NULL;
14249 struct in_addr ip4;
14251 i32 len = ntohl (mp->nlabels);
14253 if (VAT_JSON_ARRAY != vam->json_tree.type)
14255 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14256 vat_json_init_array (&vam->json_tree);
14258 node = vat_json_array_add (&vam->json_tree);
14260 vat_json_init_object (node);
14261 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
14262 clib_memcpy (&ip4, &(mp->intfc_address), sizeof (ip4));
14263 vat_json_object_add_ip4 (node, "intfc_address", ip4);
14264 vat_json_object_add_uint (node, "inner_fib_index",
14265 ntohl (mp->inner_fib_index));
14266 vat_json_object_add_uint (node, "mask_width", ntohl (mp->mask_width));
14267 vat_json_object_add_uint (node, "encap_index", ntohl (mp->encap_index));
14268 vat_json_object_add_uint (node, "hw_if_index", ntohl (mp->hw_if_index));
14269 vat_json_object_add_uint (node, "l2_only", ntohl (mp->l2_only));
14270 vat_json_object_add_string_copy (node, "tunnel_dst_mac",
14271 format (0, "%U", format_ethernet_address,
14272 &mp->tunnel_dst_mac));
14273 vat_json_object_add_uint (node, "tx_sw_if_index",
14274 ntohl (mp->tx_sw_if_index));
14275 vat_json_object_add_uint (node, "label_count", len);
14276 for (i = 0; i < len; i++)
14278 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14283 api_mpls_eth_tunnel_dump (vat_main_t * vam)
14285 vl_api_mpls_eth_tunnel_dump_t *mp;
14289 /* Parse args required to build the message */
14290 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
14292 if (!unformat (vam->input, "tunnel_index %d", &index))
14299 fformat (vam->ofp, " tunnel_index %d\n", index);
14301 M (MPLS_ETH_TUNNEL_DUMP, mpls_eth_tunnel_dump);
14302 mp->tunnel_index = htonl (index);
14305 /* Use a control ping for synchronization */
14307 vl_api_control_ping_t *mp;
14308 M (CONTROL_PING, control_ping);
14314 static void vl_api_mpls_fib_encap_details_t_handler
14315 (vl_api_mpls_fib_encap_details_t * mp)
14317 vat_main_t *vam = &vat_main;
14319 i32 len = ntohl (mp->nlabels);
14321 fformat (vam->ofp, "table %d, dest %U, label ",
14322 ntohl (mp->fib_index), format_ip4_address, &mp->dest, len);
14323 for (i = 0; i < len; i++)
14325 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14327 fformat (vam->ofp, "\n");
14330 static void vl_api_mpls_fib_encap_details_t_handler_json
14331 (vl_api_mpls_fib_encap_details_t * mp)
14333 vat_main_t *vam = &vat_main;
14334 vat_json_node_t *node = NULL;
14336 i32 len = ntohl (mp->nlabels);
14337 struct in_addr ip4;
14339 if (VAT_JSON_ARRAY != vam->json_tree.type)
14341 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14342 vat_json_init_array (&vam->json_tree);
14344 node = vat_json_array_add (&vam->json_tree);
14346 vat_json_init_object (node);
14347 vat_json_object_add_uint (node, "table", ntohl (mp->fib_index));
14348 vat_json_object_add_uint (node, "entry_index", ntohl (mp->entry_index));
14349 clib_memcpy (&ip4, &(mp->dest), sizeof (ip4));
14350 vat_json_object_add_ip4 (node, "dest", ip4);
14351 vat_json_object_add_uint (node, "s_bit", ntohl (mp->s_bit));
14352 vat_json_object_add_uint (node, "label_count", len);
14353 for (i = 0; i < len; i++)
14355 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14360 api_mpls_fib_encap_dump (vat_main_t * vam)
14362 vl_api_mpls_fib_encap_dump_t *mp;
14365 M (MPLS_FIB_ENCAP_DUMP, mpls_fib_encap_dump);
14368 /* Use a control ping for synchronization */
14370 vl_api_control_ping_t *mp;
14371 M (CONTROL_PING, control_ping);
14377 static void vl_api_mpls_fib_decap_details_t_handler
14378 (vl_api_mpls_fib_decap_details_t * mp)
14380 vat_main_t *vam = &vat_main;
14383 "RX table %d, TX table/intfc %u, swif_tag '%s', label %u, s_bit %u\n",
14384 ntohl (mp->rx_table_id), ntohl (mp->tx_table_id), mp->swif_tag,
14385 ntohl (mp->label), ntohl (mp->s_bit));
14388 static void vl_api_mpls_fib_decap_details_t_handler_json
14389 (vl_api_mpls_fib_decap_details_t * mp)
14391 vat_main_t *vam = &vat_main;
14392 vat_json_node_t *node = NULL;
14393 struct in_addr ip4;
14395 if (VAT_JSON_ARRAY != vam->json_tree.type)
14397 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14398 vat_json_init_array (&vam->json_tree);
14400 node = vat_json_array_add (&vam->json_tree);
14402 vat_json_init_object (node);
14403 vat_json_object_add_uint (node, "table", ntohl (mp->fib_index));
14404 vat_json_object_add_uint (node, "entry_index", ntohl (mp->entry_index));
14405 clib_memcpy (&ip4, &(mp->dest), sizeof (ip4));
14406 vat_json_object_add_ip4 (node, "dest", ip4);
14407 vat_json_object_add_uint (node, "s_bit", ntohl (mp->s_bit));
14408 vat_json_object_add_uint (node, "label", ntohl (mp->label));
14409 vat_json_object_add_uint (node, "rx_table_id", ntohl (mp->rx_table_id));
14410 vat_json_object_add_uint (node, "tx_table_id", ntohl (mp->tx_table_id));
14411 vat_json_object_add_string_copy (node, "swif_tag", mp->swif_tag);
14415 api_mpls_fib_decap_dump (vat_main_t * vam)
14417 vl_api_mpls_fib_decap_dump_t *mp;
14420 M (MPLS_FIB_DECAP_DUMP, mpls_fib_decap_dump);
14423 /* Use a control ping for synchronization */
14425 vl_api_control_ping_t *mp;
14426 M (CONTROL_PING, control_ping);
14433 api_classify_table_ids (vat_main_t * vam)
14435 vl_api_classify_table_ids_t *mp;
14438 /* Construct the API message */
14439 M (CLASSIFY_TABLE_IDS, classify_table_ids);
14449 api_classify_table_by_interface (vat_main_t * vam)
14451 unformat_input_t *input = vam->input;
14452 vl_api_classify_table_by_interface_t *mp;
14455 u32 sw_if_index = ~0;
14456 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14458 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
14460 else if (unformat (input, "sw_if_index %d", &sw_if_index))
14465 if (sw_if_index == ~0)
14467 errmsg ("missing interface name or sw_if_index\n");
14471 /* Construct the API message */
14472 M (CLASSIFY_TABLE_BY_INTERFACE, classify_table_by_interface);
14474 mp->sw_if_index = ntohl (sw_if_index);
14483 api_classify_table_info (vat_main_t * vam)
14485 unformat_input_t *input = vam->input;
14486 vl_api_classify_table_info_t *mp;
14490 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14492 if (unformat (input, "table_id %d", &table_id))
14497 if (table_id == ~0)
14499 errmsg ("missing table id\n");
14503 /* Construct the API message */
14504 M (CLASSIFY_TABLE_INFO, classify_table_info);
14506 mp->table_id = ntohl (table_id);
14515 api_classify_session_dump (vat_main_t * vam)
14517 unformat_input_t *input = vam->input;
14518 vl_api_classify_session_dump_t *mp;
14522 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14524 if (unformat (input, "table_id %d", &table_id))
14529 if (table_id == ~0)
14531 errmsg ("missing table id\n");
14535 /* Construct the API message */
14536 M (CLASSIFY_SESSION_DUMP, classify_session_dump);
14538 mp->table_id = ntohl (table_id);
14541 /* Use a control ping for synchronization */
14543 vl_api_control_ping_t *mp;
14544 M (CONTROL_PING, control_ping);
14553 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
14555 vat_main_t *vam = &vat_main;
14557 fformat (vam->ofp, "collector_address %U, collector_port %d, "
14558 "src_address %U, vrf_id %d, path_mtu %u, "
14559 "template_interval %u, udp_checksum %d\n",
14560 format_ip4_address, mp->collector_address,
14561 ntohs (mp->collector_port),
14562 format_ip4_address, mp->src_address,
14563 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
14564 ntohl (mp->template_interval), mp->udp_checksum);
14567 vam->result_ready = 1;
14571 vl_api_ipfix_exporter_details_t_handler_json
14572 (vl_api_ipfix_exporter_details_t * mp)
14574 vat_main_t *vam = &vat_main;
14575 vat_json_node_t node;
14576 struct in_addr collector_address;
14577 struct in_addr src_address;
14579 vat_json_init_object (&node);
14580 clib_memcpy (&collector_address, &mp->collector_address,
14581 sizeof (collector_address));
14582 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
14583 vat_json_object_add_uint (&node, "collector_port",
14584 ntohs (mp->collector_port));
14585 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
14586 vat_json_object_add_ip4 (&node, "src_address", src_address);
14587 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
14588 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
14589 vat_json_object_add_uint (&node, "template_interval",
14590 ntohl (mp->template_interval));
14591 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
14593 vat_json_print (vam->ofp, &node);
14594 vat_json_free (&node);
14596 vam->result_ready = 1;
14600 api_ipfix_exporter_dump (vat_main_t * vam)
14602 vl_api_ipfix_exporter_dump_t *mp;
14605 /* Construct the API message */
14606 M (IPFIX_EXPORTER_DUMP, ipfix_exporter_dump);
14616 api_ipfix_classify_stream_dump (vat_main_t * vam)
14618 vl_api_ipfix_classify_stream_dump_t *mp;
14621 /* Construct the API message */
14622 M (IPFIX_CLASSIFY_STREAM_DUMP, ipfix_classify_stream_dump);
14632 vl_api_ipfix_classify_stream_details_t_handler
14633 (vl_api_ipfix_classify_stream_details_t * mp)
14635 vat_main_t *vam = &vat_main;
14636 fformat (vam->ofp, "domain_id %d, src_port %d\n",
14637 ntohl (mp->domain_id), ntohs (mp->src_port));
14639 vam->result_ready = 1;
14643 vl_api_ipfix_classify_stream_details_t_handler_json
14644 (vl_api_ipfix_classify_stream_details_t * mp)
14646 vat_main_t *vam = &vat_main;
14647 vat_json_node_t node;
14649 vat_json_init_object (&node);
14650 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
14651 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
14653 vat_json_print (vam->ofp, &node);
14654 vat_json_free (&node);
14656 vam->result_ready = 1;
14660 api_ipfix_classify_table_dump (vat_main_t * vam)
14662 vl_api_ipfix_classify_table_dump_t *mp;
14665 if (!vam->json_output)
14667 fformat (vam->ofp, "%15s%15s%20s\n", "table_id", "ip_version",
14668 "transport_protocol");
14671 /* Construct the API message */
14672 M (IPFIX_CLASSIFY_TABLE_DUMP, ipfix_classify_table_dump);
14677 /* Use a control ping for synchronization */
14679 vl_api_control_ping_t *mp;
14680 M (CONTROL_PING, control_ping);
14687 vl_api_ipfix_classify_table_details_t_handler
14688 (vl_api_ipfix_classify_table_details_t * mp)
14690 vat_main_t *vam = &vat_main;
14691 fformat (vam->ofp, "%15d%15d%20d\n", ntohl (mp->table_id), mp->ip_version,
14692 mp->transport_protocol);
14696 vl_api_ipfix_classify_table_details_t_handler_json
14697 (vl_api_ipfix_classify_table_details_t * mp)
14699 vat_json_node_t *node = NULL;
14700 vat_main_t *vam = &vat_main;
14702 if (VAT_JSON_ARRAY != vam->json_tree.type)
14704 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14705 vat_json_init_array (&vam->json_tree);
14708 node = vat_json_array_add (&vam->json_tree);
14709 vat_json_init_object (node);
14711 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
14712 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
14713 vat_json_object_add_uint (node, "transport_protocol",
14714 mp->transport_protocol);
14718 api_pg_create_interface (vat_main_t * vam)
14720 unformat_input_t *input = vam->input;
14721 vl_api_pg_create_interface_t *mp;
14725 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14727 if (unformat (input, "if_id %d", &if_id))
14734 errmsg ("missing pg interface index\n");
14738 /* Construct the API message */
14739 M (PG_CREATE_INTERFACE, pg_create_interface);
14741 mp->interface_id = ntohl (if_id);
14750 api_pg_capture (vat_main_t * vam)
14752 unformat_input_t *input = vam->input;
14753 vl_api_pg_capture_t *mp;
14759 u8 pcap_file_set = 0;
14761 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14763 if (unformat (input, "if_id %d", &if_id))
14765 else if (unformat (input, "pcap %s", &pcap_file))
14767 else if (unformat (input, "count %d", &count))
14769 else if (unformat (input, "disable"))
14776 errmsg ("missing pg interface index\n");
14779 if (pcap_file_set > 0)
14781 if (vec_len (pcap_file) > 255)
14783 errmsg ("pcap file name is too long\n");
14788 u32 name_len = vec_len (pcap_file);
14789 /* Construct the API message */
14790 M (PG_CAPTURE, pg_capture);
14792 mp->interface_id = ntohl (if_id);
14793 mp->is_enabled = enable;
14794 mp->count = ntohl (count);
14795 mp->pcap_name_length = ntohl (name_len);
14796 if (pcap_file_set != 0)
14798 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
14800 vec_free (pcap_file);
14809 api_pg_enable_disable (vat_main_t * vam)
14811 unformat_input_t *input = vam->input;
14812 vl_api_pg_enable_disable_t *mp;
14816 u8 stream_name_set = 0;
14817 u8 *stream_name = 0;
14818 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14820 if (unformat (input, "stream %s", &stream_name))
14821 stream_name_set = 1;
14822 else if (unformat (input, "disable"))
14828 if (stream_name_set > 0)
14830 if (vec_len (stream_name) > 255)
14832 errmsg ("stream name too long\n");
14837 u32 name_len = vec_len (stream_name);
14838 /* Construct the API message */
14839 M (PG_ENABLE_DISABLE, pg_enable_disable);
14841 mp->is_enabled = enable;
14842 if (stream_name_set != 0)
14844 mp->stream_name_length = ntohl (name_len);
14845 clib_memcpy (mp->stream_name, stream_name, name_len);
14847 vec_free (stream_name);
14856 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
14858 unformat_input_t *input = vam->input;
14859 vl_api_ip_source_and_port_range_check_add_del_t *mp;
14862 u16 *low_ports = 0;
14863 u16 *high_ports = 0;
14866 ip4_address_t ip4_addr;
14867 ip6_address_t ip6_addr;
14875 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14877 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
14883 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
14888 else if (unformat (input, "vrf %d", &vrf_id))
14890 else if (unformat (input, "del"))
14892 else if (unformat (input, "port %d", &tmp))
14894 if (tmp == 0 || tmp > 65535)
14896 errmsg ("port %d out of range", tmp);
14900 this_hi = this_low + 1;
14901 vec_add1 (low_ports, this_low);
14902 vec_add1 (high_ports, this_hi);
14904 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
14906 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
14908 errmsg ("incorrect range parameters\n");
14912 /* Note: in debug CLI +1 is added to high before
14913 passing to real fn that does "the work"
14914 (ip_source_and_port_range_check_add_del).
14915 This fn is a wrapper around the binary API fn a
14916 control plane will call, which expects this increment
14917 to have occurred. Hence letting the binary API control
14918 plane fn do the increment for consistency between VAT
14919 and other control planes.
14922 vec_add1 (low_ports, this_low);
14923 vec_add1 (high_ports, this_hi);
14929 if (prefix_set == 0)
14931 errmsg ("<address>/<mask> not specified\n");
14937 errmsg ("VRF ID required, not specified\n");
14944 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
14948 if (vec_len (low_ports) == 0)
14950 errmsg ("At least one port or port range required\n");
14954 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL,
14955 ip_source_and_port_range_check_add_del);
14957 mp->is_add = is_add;
14962 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
14967 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
14970 mp->mask_length = length;
14971 mp->number_of_ranges = vec_len (low_ports);
14973 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
14974 vec_free (low_ports);
14976 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
14977 vec_free (high_ports);
14979 mp->vrf_id = ntohl (vrf_id);
14988 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
14990 unformat_input_t *input = vam->input;
14991 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
14993 u32 sw_if_index = ~0;
14995 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
14996 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
14999 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15001 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
15003 else if (unformat (input, "sw_if_index %d", &sw_if_index))
15005 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
15007 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
15009 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
15011 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
15013 else if (unformat (input, "del"))
15019 if (sw_if_index == ~0)
15021 errmsg ("Interface required but not specified\n");
15027 errmsg ("VRF ID required but not specified\n");
15031 if (tcp_out_vrf_id == 0
15032 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
15035 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
15039 /* Construct the API message */
15040 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL,
15041 ip_source_and_port_range_check_interface_add_del);
15043 mp->sw_if_index = ntohl (sw_if_index);
15044 mp->is_add = is_add;
15045 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
15046 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
15047 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
15048 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
15053 /* Wait for a reply... */
15058 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
15060 unformat_input_t *i = vam->input;
15061 vl_api_ipsec_gre_add_del_tunnel_t *mp;
15063 u32 local_sa_id = 0;
15064 u32 remote_sa_id = 0;
15065 ip4_address_t src_address;
15066 ip4_address_t dst_address;
15069 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15071 if (unformat (i, "local_sa %d", &local_sa_id))
15073 else if (unformat (i, "remote_sa %d", &remote_sa_id))
15075 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
15077 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
15079 else if (unformat (i, "del"))
15083 clib_warning ("parse error '%U'", format_unformat_error, i);
15088 M (IPSEC_GRE_ADD_DEL_TUNNEL, ipsec_gre_add_del_tunnel);
15090 mp->local_sa_id = ntohl (local_sa_id);
15091 mp->remote_sa_id = ntohl (remote_sa_id);
15092 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
15093 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
15094 mp->is_add = is_add;
15102 static void vl_api_ipsec_gre_tunnel_details_t_handler
15103 (vl_api_ipsec_gre_tunnel_details_t * mp)
15105 vat_main_t *vam = &vat_main;
15107 fformat (vam->ofp, "%11d%15U%15U%14d%14d\n",
15108 ntohl (mp->sw_if_index),
15109 format_ip4_address, &mp->src_address,
15110 format_ip4_address, &mp->dst_address,
15111 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
15114 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
15115 (vl_api_ipsec_gre_tunnel_details_t * mp)
15117 vat_main_t *vam = &vat_main;
15118 vat_json_node_t *node = NULL;
15119 struct in_addr ip4;
15121 if (VAT_JSON_ARRAY != vam->json_tree.type)
15123 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15124 vat_json_init_array (&vam->json_tree);
15126 node = vat_json_array_add (&vam->json_tree);
15128 vat_json_init_object (node);
15129 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
15130 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
15131 vat_json_object_add_ip4 (node, "src_address", ip4);
15132 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
15133 vat_json_object_add_ip4 (node, "dst_address", ip4);
15134 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
15135 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
15139 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
15141 unformat_input_t *i = vam->input;
15142 vl_api_ipsec_gre_tunnel_dump_t *mp;
15145 u8 sw_if_index_set = 0;
15147 /* Parse args required to build the message */
15148 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15150 if (unformat (i, "sw_if_index %d", &sw_if_index))
15151 sw_if_index_set = 1;
15156 if (sw_if_index_set == 0)
15161 if (!vam->json_output)
15163 fformat (vam->ofp, "%11s%15s%15s%14s%14s\n",
15164 "sw_if_index", "src_address", "dst_address",
15165 "local_sa_id", "remote_sa_id");
15168 /* Get list of gre-tunnel interfaces */
15169 M (IPSEC_GRE_TUNNEL_DUMP, ipsec_gre_tunnel_dump);
15171 mp->sw_if_index = htonl (sw_if_index);
15175 /* Use a control ping for synchronization */
15177 vl_api_control_ping_t *mp;
15178 M (CONTROL_PING, control_ping);
15185 api_delete_subif (vat_main_t * vam)
15187 unformat_input_t *i = vam->input;
15188 vl_api_delete_subif_t *mp;
15190 u32 sw_if_index = ~0;
15192 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15194 if (unformat (i, "sw_if_index %d", &sw_if_index))
15200 if (sw_if_index == ~0)
15202 errmsg ("missing sw_if_index\n");
15206 /* Construct the API message */
15207 M (DELETE_SUBIF, delete_subif);
15208 mp->sw_if_index = ntohl (sw_if_index);
15215 q_or_quit (vat_main_t * vam)
15217 longjmp (vam->jump_buf, 1);
15218 return 0; /* not so much */
15222 q (vat_main_t * vam)
15224 return q_or_quit (vam);
15228 quit (vat_main_t * vam)
15230 return q_or_quit (vam);
15234 comment (vat_main_t * vam)
15240 cmd_cmp (void *a1, void *a2)
15245 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
15249 help (vat_main_t * vam)
15254 unformat_input_t *i = vam->input;
15257 if (unformat (i, "%s", &name))
15261 vec_add1 (name, 0);
15263 hs = hash_get_mem (vam->help_by_name, name);
15265 fformat (vam->ofp, "usage: %s %s\n", name, hs[0]);
15267 fformat (vam->ofp, "No such msg / command '%s'\n", name);
15272 fformat (vam->ofp, "Help is available for the following:\n");
15275 hash_foreach_pair (p, vam->function_by_name,
15277 vec_add1 (cmds, (u8 *)(p->key));
15281 vec_sort_with_function (cmds, cmd_cmp);
15283 for (j = 0; j < vec_len (cmds); j++)
15284 fformat (vam->ofp, "%s\n", cmds[j]);
15291 set (vat_main_t * vam)
15293 u8 *name = 0, *value = 0;
15294 unformat_input_t *i = vam->input;
15296 if (unformat (i, "%s", &name))
15298 /* The input buffer is a vector, not a string. */
15299 value = vec_dup (i->buffer);
15300 vec_delete (value, i->index, 0);
15301 /* Almost certainly has a trailing newline */
15302 if (value[vec_len (value) - 1] == '\n')
15303 value[vec_len (value) - 1] = 0;
15304 /* Make sure it's a proper string, one way or the other */
15305 vec_add1 (value, 0);
15306 (void) clib_macro_set_value (&vam->macro_main,
15307 (char *) name, (char *) value);
15310 errmsg ("usage: set <name> <value>\n");
15318 unset (vat_main_t * vam)
15322 if (unformat (vam->input, "%s", &name))
15323 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
15324 errmsg ("unset: %s wasn't set\n", name);
15337 macro_sort_cmp (void *a1, void *a2)
15339 macro_sort_t *s1 = a1;
15340 macro_sort_t *s2 = a2;
15342 return strcmp ((char *) (s1->name), (char *) (s2->name));
15346 dump_macro_table (vat_main_t * vam)
15348 macro_sort_t *sort_me = 0, *sm;
15353 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
15355 vec_add2 (sort_me, sm, 1);
15356 sm->name = (u8 *)(p->key);
15357 sm->value = (u8 *) (p->value[0]);
15361 vec_sort_with_function (sort_me, macro_sort_cmp);
15363 if (vec_len (sort_me))
15364 fformat (vam->ofp, "%-15s%s\n", "Name", "Value");
15366 fformat (vam->ofp, "The macro table is empty...\n");
15368 for (i = 0; i < vec_len (sort_me); i++)
15369 fformat (vam->ofp, "%-15s%s\n", sort_me[i].name, sort_me[i].value);
15374 dump_node_table (vat_main_t * vam)
15377 vlib_node_t *node, *next_node;
15379 if (vec_len (vam->graph_nodes) == 0)
15381 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
15385 for (i = 0; i < vec_len (vam->graph_nodes); i++)
15387 node = vam->graph_nodes[i];
15388 fformat (vam->ofp, "[%d] %s\n", i, node->name);
15389 for (j = 0; j < vec_len (node->next_nodes); j++)
15391 if (node->next_nodes[j] != ~0)
15393 next_node = vam->graph_nodes[node->next_nodes[j]];
15394 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
15402 search_node_table (vat_main_t * vam)
15404 unformat_input_t *line_input = vam->input;
15407 vlib_node_t *node, *next_node;
15410 if (vam->graph_node_index_by_name == 0)
15412 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
15416 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15418 if (unformat (line_input, "%s", &node_to_find))
15420 vec_add1 (node_to_find, 0);
15421 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
15424 fformat (vam->ofp, "%s not found...\n", node_to_find);
15427 node = vam->graph_nodes[p[0]];
15428 fformat (vam->ofp, "[%d] %s\n", p[0], node->name);
15429 for (j = 0; j < vec_len (node->next_nodes); j++)
15431 if (node->next_nodes[j] != ~0)
15433 next_node = vam->graph_nodes[node->next_nodes[j]];
15434 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
15441 clib_warning ("parse error '%U'", format_unformat_error,
15447 vec_free (node_to_find);
15456 script (vat_main_t * vam)
15459 char *save_current_file;
15460 unformat_input_t save_input;
15461 jmp_buf save_jump_buf;
15462 u32 save_line_number;
15464 FILE *new_fp, *save_ifp;
15466 if (unformat (vam->input, "%s", &s))
15468 new_fp = fopen ((char *) s, "r");
15471 errmsg ("Couldn't open script file %s\n", s);
15478 errmsg ("Missing script name\n");
15482 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
15483 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
15484 save_ifp = vam->ifp;
15485 save_line_number = vam->input_line_number;
15486 save_current_file = (char *) vam->current_file;
15488 vam->input_line_number = 0;
15490 vam->current_file = s;
15493 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
15494 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
15495 vam->ifp = save_ifp;
15496 vam->input_line_number = save_line_number;
15497 vam->current_file = (u8 *) save_current_file;
15504 echo (vat_main_t * vam)
15506 fformat (vam->ofp, "%v", vam->input->buffer);
15510 /* List of API message constructors, CLI names map to api_xxx */
15511 #define foreach_vpe_api_msg \
15512 _(create_loopback,"[mac <mac-addr>]") \
15513 _(sw_interface_dump,"") \
15514 _(sw_interface_set_flags, \
15515 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
15516 _(sw_interface_add_del_address, \
15517 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
15518 _(sw_interface_set_table, \
15519 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
15520 _(sw_interface_set_vpath, \
15521 "<intfc> | sw_if_index <id> enable | disable") \
15522 _(sw_interface_set_l2_xconnect, \
15523 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
15524 "enable | disable") \
15525 _(sw_interface_set_l2_bridge, \
15526 "<intfc> | sw_if_index <id> bd_id <bridge-domain-id>\n" \
15527 "[shg <split-horizon-group>] [bvi]\n" \
15528 "enable | disable") \
15529 _(sw_interface_set_dpdk_hqos_pipe, \
15530 "rx <intfc> | sw_if_index <id> subport <subport-id> pipe <pipe-id>\n" \
15531 "profile <profile-id>\n") \
15532 _(sw_interface_set_dpdk_hqos_subport, \
15533 "rx <intfc> | sw_if_index <id> subport <subport-id> [rate <n>]\n" \
15534 "[bktsize <n>] [tc0 <n>] [tc1 <n>] [tc2 <n>] [tc3 <n>] [period <n>]\n") \
15535 _(sw_interface_set_dpdk_hqos_tctbl, \
15536 "rx <intfc> | sw_if_index <id> entry <n> tc <n> queue <n>\n") \
15537 _(bridge_domain_add_del, \
15538 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n")\
15539 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
15541 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
15543 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
15545 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
15547 "tapname <name> mac <mac-addr> | random-mac") \
15549 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
15551 "<vpp-if-name> | sw_if_index <id>") \
15552 _(sw_interface_tap_dump, "") \
15553 _(ip_add_del_route, \
15554 "<addr>/<mask> via <addr> [vrf <n>]\n" \
15555 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
15556 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
15557 "[multipath] [count <n>]") \
15558 _(proxy_arp_add_del, \
15559 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
15560 _(proxy_arp_intfc_enable_disable, \
15561 "<intfc> | sw_if_index <id> enable | disable") \
15562 _(mpls_add_del_encap, \
15563 "label <n> dst <ip4-addr> [vrf <n>] [del]") \
15564 _(mpls_add_del_decap, \
15565 "label <n> [rx_vrf_id <n>] [tx_vrf_id] [s-bit-clear][del]") \
15566 _(mpls_gre_add_del_tunnel, \
15567 "inner_vrf_id <n> outer_vrf_id <n> src <ip4-address> dst <ip4-address>\n" \
15568 "adj <ip4-address>/<mask-width> [del]") \
15569 _(sw_interface_set_unnumbered, \
15570 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
15571 _(ip_neighbor_add_del, \
15572 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
15573 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
15574 _(reset_vrf, "vrf <id> [ipv6]") \
15575 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
15576 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
15577 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
15578 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
15579 "[outer_vlan_id_any][inner_vlan_id_any]") \
15580 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
15581 _(reset_fib, "vrf <n> [ipv6]") \
15582 _(dhcp_proxy_config, \
15583 "svr <v46-address> src <v46-address>\n" \
15584 "insert-cid <n> [del]") \
15585 _(dhcp_proxy_config_2, \
15586 "svr <v46-address> src <v46-address>\n" \
15587 "rx_vrf_id <nn> server_vrf_id <nn> insert-cid <n> [del]") \
15588 _(dhcp_proxy_set_vss, \
15589 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
15590 _(dhcp_client_config, \
15591 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
15592 _(set_ip_flow_hash, \
15593 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
15594 _(sw_interface_ip6_enable_disable, \
15595 "<intfc> | sw_if_index <id> enable | disable") \
15596 _(sw_interface_ip6_set_link_local_address, \
15597 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
15598 _(sw_interface_ip6nd_ra_prefix, \
15599 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
15600 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
15601 "[nolink] [isno]") \
15602 _(sw_interface_ip6nd_ra_config, \
15603 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
15604 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
15605 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
15606 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
15607 _(l2_patch_add_del, \
15608 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
15609 "enable | disable") \
15610 _(mpls_ethernet_add_del_tunnel, \
15611 "tx <intfc> | tx_sw_if_index <n> dst <mac-addr>\n" \
15612 "adj <ip4-addr>/<mw> dst <mac-addr> [del]") \
15613 _(mpls_ethernet_add_del_tunnel_2, \
15614 "inner_vrf_id <n> outer_vrf_id <n> next-hop <ip4-addr>\n" \
15615 "resolve-attempts <n> resolve-if-needed 0 | 1 [del]") \
15616 _(sr_tunnel_add_del, \
15617 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
15618 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
15619 "[policy <policy_name>]") \
15620 _(sr_policy_add_del, \
15621 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
15622 _(sr_multicast_map_add_del, \
15623 "address [ip6 multicast address] sr-policy [policy name] [del]") \
15624 _(classify_add_del_table, \
15625 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
15626 "[del] mask <mask-value>\n" \
15627 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>") \
15628 _(classify_add_del_session, \
15629 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
15630 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
15631 " [l3 [ip4|ip6]]") \
15632 _(classify_set_interface_ip_table, \
15633 "<intfc> | sw_if_index <nn> table <nn>") \
15634 _(classify_set_interface_l2_tables, \
15635 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15636 " [other-table <nn>]") \
15637 _(get_node_index, "node <node-name") \
15638 _(add_node_next, "node <node-name> next <next-node-name>") \
15639 _(l2tpv3_create_tunnel, \
15640 "client_address <ip6-addr> our_address <ip6-addr>\n" \
15641 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n"\
15642 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
15643 _(l2tpv3_set_tunnel_cookies, \
15644 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
15645 "[new_remote_cookie <nn>]\n") \
15646 _(l2tpv3_interface_enable_disable, \
15647 "<intfc> | sw_if_index <nn> enable | disable") \
15648 _(l2tpv3_set_lookup_key, \
15649 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
15650 _(sw_if_l2tpv3_tunnel_dump, "") \
15651 _(vxlan_add_del_tunnel, \
15652 "src <ip-addr> dst <ip-addr> vni <vni> [encap-vrf-id <nn>]\n" \
15653 " [decap-next l2|ip4|ip6] [del]") \
15654 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15655 _(gre_add_del_tunnel, \
15656 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [teb] [del]\n") \
15657 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15658 _(l2_fib_clear_table, "") \
15659 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
15660 _(l2_interface_vlan_tag_rewrite, \
15661 "<intfc> | sw_if_index <nn> \n" \
15662 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
15663 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
15664 _(create_vhost_user_if, \
15665 "socket <filename> [server] [renumber <dev_instance>] " \
15666 "[mac <mac_address>]") \
15667 _(modify_vhost_user_if, \
15668 "<intfc> | sw_if_index <nn> socket <filename>\n" \
15669 "[server] [renumber <dev_instance>]") \
15670 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
15671 _(sw_interface_vhost_user_dump, "") \
15672 _(show_version, "") \
15673 _(vxlan_gpe_add_del_tunnel, \
15674 "local <addr> remote <addr> vni <nn>\n" \
15675 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
15676 "[next-ethernet] [next-nsh]\n") \
15677 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15678 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
15679 _(interface_name_renumber, \
15680 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
15681 _(input_acl_set_interface, \
15682 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15683 " [l2-table <nn>] [del]") \
15684 _(want_ip4_arp_events, "address <ip4-address> [del]") \
15685 _(want_ip6_nd_events, "address <ip6-address> [del]") \
15686 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
15687 _(ip_dump, "ipv4 | ipv6") \
15688 _(ipsec_spd_add_del, "spd_id <n> [del]") \
15689 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
15691 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
15692 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
15693 " integ_alg <alg> integ_key <hex>") \
15694 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
15695 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
15696 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
15697 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" )\
15698 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
15699 _(ikev2_profile_add_del, "name <profile_name> [del]") \
15700 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
15701 "(auth_data 0x<data> | auth_data <data>)") \
15702 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
15703 "(id_data 0x<data> | id_data <data>) (local|remote)") \
15704 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
15705 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
15706 "(local|remote)") \
15707 _(ikev2_set_local_key, "file <absolute_file_path>") \
15708 _(delete_loopback,"sw_if_index <nn>") \
15709 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
15710 _(map_add_domain, \
15711 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
15712 "ip6-src <ip6addr> " \
15713 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
15714 _(map_del_domain, "index <n>") \
15715 _(map_add_del_rule, \
15716 "index <n> psid <n> dst <ip6addr> [del]") \
15717 _(map_domain_dump, "") \
15718 _(map_rule_dump, "index <map-domain>") \
15719 _(want_interface_events, "enable|disable") \
15720 _(want_stats,"enable|disable") \
15721 _(get_first_msg_id, "client <name>") \
15722 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
15723 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
15724 "fib-id <nn> [ip4][ip6][default]") \
15725 _(get_node_graph, " ") \
15726 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
15727 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
15728 _(ioam_disable, "") \
15729 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
15730 " sw_if_index <sw_if_index> p <priority> " \
15731 "w <weight>] [del]") \
15732 _(lisp_add_del_locator, "locator-set <locator_name> " \
15733 "iface <intf> | sw_if_index <sw_if_index> " \
15734 "p <priority> w <weight> [del]") \
15735 _(lisp_add_del_local_eid,"vni <vni> eid " \
15736 "<ipv4|ipv6>/<prefix> | <L2 address> " \
15737 "locator-set <locator_name> [del]") \
15738 _(lisp_gpe_add_del_fwd_entry, "rmt_eid <eid> [lcl_eid <eid>] vni <vni>" \
15739 "dp_table <table> loc-pair <lcl_loc> <rmt_loc> ... [del]") \
15740 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
15741 _(lisp_gpe_enable_disable, "enable|disable") \
15742 _(lisp_enable_disable, "enable|disable") \
15743 _(lisp_gpe_add_del_iface, "up|down") \
15744 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
15746 "rloc <locator> p <prio> " \
15747 "w <weight> [rloc <loc> ... ] " \
15748 "action <action> [del-all]") \
15749 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
15751 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
15752 _(lisp_map_request_mode, "src-dst|dst-only") \
15753 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
15754 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
15755 _(lisp_locator_set_dump, "[local | remote]") \
15756 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
15757 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
15758 "[local] | [remote]") \
15759 _(lisp_eid_table_vni_dump, "") \
15760 _(lisp_eid_table_map_dump, "l2|l3") \
15761 _(lisp_gpe_tunnel_dump, "") \
15762 _(lisp_map_resolver_dump, "") \
15763 _(show_lisp_status, "") \
15764 _(lisp_get_map_request_itr_rlocs, "") \
15765 _(show_lisp_pitr, "") \
15766 _(show_lisp_map_request_mode, "") \
15767 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
15768 _(af_packet_delete, "name <host interface name>") \
15769 _(policer_add_del, "name <policer name> <params> [del]") \
15770 _(policer_dump, "[name <policer name>]") \
15771 _(policer_classify_set_interface, \
15772 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15773 " [l2-table <nn>] [del]") \
15774 _(policer_classify_dump, "type [ip4|ip6|l2]") \
15775 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
15776 "[master|slave]") \
15777 _(netmap_delete, "name <interface name>") \
15778 _(mpls_gre_tunnel_dump, "tunnel_index <tunnel-id>") \
15779 _(mpls_eth_tunnel_dump, "tunnel_index <tunnel-id>") \
15780 _(mpls_fib_encap_dump, "") \
15781 _(mpls_fib_decap_dump, "") \
15782 _(classify_table_ids, "") \
15783 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
15784 _(classify_table_info, "table_id <nn>") \
15785 _(classify_session_dump, "table_id <nn>") \
15786 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
15787 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
15788 "[template_interval <nn>] [udp_checksum]") \
15789 _(ipfix_exporter_dump, "") \
15790 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
15791 _(ipfix_classify_stream_dump, "") \
15792 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]")\
15793 _(ipfix_classify_table_dump, "") \
15794 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
15795 _(pg_create_interface, "if_id <nn>") \
15796 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
15797 _(pg_enable_disable, "[stream <id>] disable") \
15798 _(ip_source_and_port_range_check_add_del, \
15799 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
15800 _(ip_source_and_port_range_check_interface_add_del, \
15801 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
15802 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
15803 _(ipsec_gre_add_del_tunnel, \
15804 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
15805 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
15806 _(delete_subif,"sub_sw_if_index <nn> sub_if_id <nn>")
15808 /* List of command functions, CLI names map directly to functions */
15809 #define foreach_cli_function \
15810 _(comment, "usage: comment <ignore-rest-of-line>") \
15811 _(dump_interface_table, "usage: dump_interface_table") \
15812 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
15813 _(dump_ipv4_table, "usage: dump_ipv4_table") \
15814 _(dump_ipv6_table, "usage: dump_ipv6_table") \
15815 _(dump_stats_table, "usage: dump_stats_table") \
15816 _(dump_macro_table, "usage: dump_macro_table ") \
15817 _(dump_node_table, "usage: dump_node_table") \
15818 _(echo, "usage: echo <message>") \
15819 _(exec, "usage: exec <vpe-debug-CLI-command>") \
15820 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
15821 _(help, "usage: help") \
15822 _(q, "usage: quit") \
15823 _(quit, "usage: quit") \
15824 _(search_node_table, "usage: search_node_table <name>...") \
15825 _(set, "usage: set <variable-name> <value>") \
15826 _(script, "usage: script <file-name>") \
15827 _(unset, "usage: unset <variable-name>")
15830 static void vl_api_##n##_t_handler_uni \
15831 (vl_api_##n##_t * mp) \
15833 vat_main_t * vam = &vat_main; \
15834 if (vam->json_output) { \
15835 vl_api_##n##_t_handler_json(mp); \
15837 vl_api_##n##_t_handler(mp); \
15840 foreach_vpe_api_reply_msg;
15844 vat_api_hookup (vat_main_t * vam)
15847 vl_msg_api_set_handlers(VL_API_##N, #n, \
15848 vl_api_##n##_t_handler_uni, \
15850 vl_api_##n##_t_endian, \
15851 vl_api_##n##_t_print, \
15852 sizeof(vl_api_##n##_t), 1);
15853 foreach_vpe_api_reply_msg;
15856 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
15858 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
15860 vam->function_by_name = hash_create_string (0, sizeof (uword));
15862 vam->help_by_name = hash_create_string (0, sizeof (uword));
15864 /* API messages we can send */
15865 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
15866 foreach_vpe_api_msg;
15870 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
15871 foreach_vpe_api_msg;
15874 /* CLI functions */
15875 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
15876 foreach_cli_function;
15880 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
15881 foreach_cli_function;
15885 #undef vl_api_version
15886 #define vl_api_version(n,v) static u32 vpe_api_version = v;
15887 #include <vpp-api/vpe.api.h>
15888 #undef vl_api_version
15891 vl_client_add_api_signatures (vl_api_memclnt_create_t * mp)
15894 * Send the main API signature in slot 0. This bit of code must
15895 * match the checks in ../vpe/api/api.c: vl_msg_api_version_check().
15897 mp->api_versions[0] = clib_host_to_net_u32 (vpe_api_version);
15901 * fd.io coding-style-patch-verification: ON
15904 * eval: (c-set-style "gnu")