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 vl_api_show_lisp_pitr_reply_t_handler (vl_api_show_lisp_pitr_reply_t * mp)
2717 vat_main_t *vam = &vat_main;
2718 i32 retval = ntohl (mp->retval);
2722 fformat (vam->ofp, "%-20s%-16s\n",
2723 mp->status ? "enabled" : "disabled",
2724 mp->status ? (char *) mp->locator_set_name : "");
2727 vam->retval = retval;
2728 vam->result_ready = 1;
2732 vl_api_show_lisp_pitr_reply_t_handler_json (vl_api_show_lisp_pitr_reply_t *
2735 vat_main_t *vam = &vat_main;
2736 vat_json_node_t node;
2739 status = format (0, "%s", mp->status ? "enabled" : "disabled");
2740 vec_add1 (status, 0);
2742 vat_json_init_object (&node);
2743 vat_json_object_add_string_copy (&node, "status", status);
2746 vat_json_object_add_string_copy (&node, "locator_set",
2747 mp->locator_set_name);
2752 vat_json_print (vam->ofp, &node);
2753 vat_json_free (&node);
2755 vam->retval = ntohl (mp->retval);
2756 vam->result_ready = 1;
2760 format_policer_type (u8 * s, va_list * va)
2762 u32 i = va_arg (*va, u32);
2764 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
2765 s = format (s, "1r2c");
2766 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
2767 s = format (s, "1r3c");
2768 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
2769 s = format (s, "2r3c-2698");
2770 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
2771 s = format (s, "2r3c-4115");
2772 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
2773 s = format (s, "2r3c-mef5cf1");
2775 s = format (s, "ILLEGAL");
2780 format_policer_rate_type (u8 * s, va_list * va)
2782 u32 i = va_arg (*va, u32);
2784 if (i == SSE2_QOS_RATE_KBPS)
2785 s = format (s, "kbps");
2786 else if (i == SSE2_QOS_RATE_PPS)
2787 s = format (s, "pps");
2789 s = format (s, "ILLEGAL");
2794 format_policer_round_type (u8 * s, va_list * va)
2796 u32 i = va_arg (*va, u32);
2798 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
2799 s = format (s, "closest");
2800 else if (i == SSE2_QOS_ROUND_TO_UP)
2801 s = format (s, "up");
2802 else if (i == SSE2_QOS_ROUND_TO_DOWN)
2803 s = format (s, "down");
2805 s = format (s, "ILLEGAL");
2810 format_policer_action_type (u8 * s, va_list * va)
2812 u32 i = va_arg (*va, u32);
2814 if (i == SSE2_QOS_ACTION_DROP)
2815 s = format (s, "drop");
2816 else if (i == SSE2_QOS_ACTION_TRANSMIT)
2817 s = format (s, "transmit");
2818 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2819 s = format (s, "mark-and-transmit");
2821 s = format (s, "ILLEGAL");
2826 format_dscp (u8 * s, va_list * va)
2828 u32 i = va_arg (*va, u32);
2833 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
2837 return format (s, "ILLEGAL");
2839 s = format (s, "%s", t);
2844 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
2846 vat_main_t *vam = &vat_main;
2847 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
2849 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2850 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
2852 conform_dscp_str = format (0, "");
2854 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2855 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
2857 exceed_dscp_str = format (0, "");
2859 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2860 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
2862 violate_dscp_str = format (0, "");
2864 fformat (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
2865 "rate type %U, round type %U, %s rate, %s color-aware, "
2866 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
2867 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
2868 "conform action %U%s, exceed action %U%s, violate action %U%s\n",
2870 format_policer_type, mp->type,
2873 clib_net_to_host_u64 (mp->cb),
2874 clib_net_to_host_u64 (mp->eb),
2875 format_policer_rate_type, mp->rate_type,
2876 format_policer_round_type, mp->round_type,
2877 mp->single_rate ? "single" : "dual",
2878 mp->color_aware ? "is" : "not",
2879 ntohl (mp->cir_tokens_per_period),
2880 ntohl (mp->pir_tokens_per_period),
2882 ntohl (mp->current_limit),
2883 ntohl (mp->current_bucket),
2884 ntohl (mp->extended_limit),
2885 ntohl (mp->extended_bucket),
2886 clib_net_to_host_u64 (mp->last_update_time),
2887 format_policer_action_type, mp->conform_action_type,
2889 format_policer_action_type, mp->exceed_action_type,
2891 format_policer_action_type, mp->violate_action_type,
2894 vec_free (conform_dscp_str);
2895 vec_free (exceed_dscp_str);
2896 vec_free (violate_dscp_str);
2899 static void vl_api_policer_details_t_handler_json
2900 (vl_api_policer_details_t * mp)
2902 vat_main_t *vam = &vat_main;
2903 vat_json_node_t *node;
2904 u8 *rate_type_str, *round_type_str, *type_str;
2905 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
2907 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
2909 format (0, "%U", format_policer_round_type, mp->round_type);
2910 type_str = format (0, "%U", format_policer_type, mp->type);
2911 conform_action_str = format (0, "%U", format_policer_action_type,
2912 mp->conform_action_type);
2913 exceed_action_str = format (0, "%U", format_policer_action_type,
2914 mp->exceed_action_type);
2915 violate_action_str = format (0, "%U", format_policer_action_type,
2916 mp->violate_action_type);
2918 if (VAT_JSON_ARRAY != vam->json_tree.type)
2920 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2921 vat_json_init_array (&vam->json_tree);
2923 node = vat_json_array_add (&vam->json_tree);
2925 vat_json_init_object (node);
2926 vat_json_object_add_string_copy (node, "name", mp->name);
2927 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
2928 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
2929 vat_json_object_add_uint (node, "cb", ntohl (mp->cb));
2930 vat_json_object_add_uint (node, "eb", ntohl (mp->eb));
2931 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
2932 vat_json_object_add_string_copy (node, "round_type", round_type_str);
2933 vat_json_object_add_string_copy (node, "type", type_str);
2934 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
2935 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
2936 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
2937 vat_json_object_add_uint (node, "cir_tokens_per_period",
2938 ntohl (mp->cir_tokens_per_period));
2939 vat_json_object_add_uint (node, "eir_tokens_per_period",
2940 ntohl (mp->pir_tokens_per_period));
2941 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
2942 vat_json_object_add_uint (node, "current_bucket",
2943 ntohl (mp->current_bucket));
2944 vat_json_object_add_uint (node, "extended_limit",
2945 ntohl (mp->extended_limit));
2946 vat_json_object_add_uint (node, "extended_bucket",
2947 ntohl (mp->extended_bucket));
2948 vat_json_object_add_uint (node, "last_update_time",
2949 ntohl (mp->last_update_time));
2950 vat_json_object_add_string_copy (node, "conform_action",
2951 conform_action_str);
2952 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2954 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
2955 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
2956 vec_free (dscp_str);
2958 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
2959 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2961 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
2962 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
2963 vec_free (dscp_str);
2965 vat_json_object_add_string_copy (node, "violate_action",
2966 violate_action_str);
2967 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2969 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
2970 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
2971 vec_free (dscp_str);
2974 vec_free (rate_type_str);
2975 vec_free (round_type_str);
2976 vec_free (type_str);
2977 vec_free (conform_action_str);
2978 vec_free (exceed_action_str);
2979 vec_free (violate_action_str);
2983 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
2986 vat_main_t *vam = &vat_main;
2987 int i, count = ntohl (mp->count);
2990 fformat (vam->ofp, "classify table ids (%d) : ", count);
2991 for (i = 0; i < count; i++)
2993 fformat (vam->ofp, "%d", ntohl (mp->ids[i]));
2994 fformat (vam->ofp, (i < count - 1) ? "," : "\n");
2996 vam->retval = ntohl (mp->retval);
2997 vam->result_ready = 1;
3001 vl_api_classify_table_ids_reply_t_handler_json
3002 (vl_api_classify_table_ids_reply_t * mp)
3004 vat_main_t *vam = &vat_main;
3005 int i, count = ntohl (mp->count);
3009 vat_json_node_t node;
3011 vat_json_init_object (&node);
3012 for (i = 0; i < count; i++)
3014 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
3016 vat_json_print (vam->ofp, &node);
3017 vat_json_free (&node);
3019 vam->retval = ntohl (mp->retval);
3020 vam->result_ready = 1;
3024 vl_api_classify_table_by_interface_reply_t_handler
3025 (vl_api_classify_table_by_interface_reply_t * mp)
3027 vat_main_t *vam = &vat_main;
3030 table_id = ntohl (mp->l2_table_id);
3032 fformat (vam->ofp, "l2 table id : %d\n", table_id);
3034 fformat (vam->ofp, "l2 table id : No input ACL tables configured\n");
3035 table_id = ntohl (mp->ip4_table_id);
3037 fformat (vam->ofp, "ip4 table id : %d\n", table_id);
3039 fformat (vam->ofp, "ip4 table id : No input ACL tables configured\n");
3040 table_id = ntohl (mp->ip6_table_id);
3042 fformat (vam->ofp, "ip6 table id : %d\n", table_id);
3044 fformat (vam->ofp, "ip6 table id : No input ACL tables configured\n");
3045 vam->retval = ntohl (mp->retval);
3046 vam->result_ready = 1;
3050 vl_api_classify_table_by_interface_reply_t_handler_json
3051 (vl_api_classify_table_by_interface_reply_t * mp)
3053 vat_main_t *vam = &vat_main;
3054 vat_json_node_t node;
3056 vat_json_init_object (&node);
3058 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
3059 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
3060 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
3062 vat_json_print (vam->ofp, &node);
3063 vat_json_free (&node);
3065 vam->retval = ntohl (mp->retval);
3066 vam->result_ready = 1;
3069 static void vl_api_policer_add_del_reply_t_handler
3070 (vl_api_policer_add_del_reply_t * mp)
3072 vat_main_t *vam = &vat_main;
3073 i32 retval = ntohl (mp->retval);
3074 if (vam->async_mode)
3076 vam->async_errors += (retval < 0);
3080 vam->retval = retval;
3081 vam->result_ready = 1;
3082 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
3084 * Note: this is just barely thread-safe, depends on
3085 * the main thread spinning waiting for an answer...
3087 errmsg ("policer index %d\n", ntohl (mp->policer_index));
3091 static void vl_api_policer_add_del_reply_t_handler_json
3092 (vl_api_policer_add_del_reply_t * mp)
3094 vat_main_t *vam = &vat_main;
3095 vat_json_node_t node;
3097 vat_json_init_object (&node);
3098 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3099 vat_json_object_add_uint (&node, "policer_index",
3100 ntohl (mp->policer_index));
3102 vat_json_print (vam->ofp, &node);
3103 vat_json_free (&node);
3105 vam->retval = ntohl (mp->retval);
3106 vam->result_ready = 1;
3109 /* Format hex dump. */
3111 format_hex_bytes (u8 * s, va_list * va)
3113 u8 *bytes = va_arg (*va, u8 *);
3114 int n_bytes = va_arg (*va, int);
3117 /* Print short or long form depending on byte count. */
3118 uword short_form = n_bytes <= 32;
3119 uword indent = format_get_indent (s);
3124 for (i = 0; i < n_bytes; i++)
3126 if (!short_form && (i % 32) == 0)
3127 s = format (s, "%08x: ", i);
3128 s = format (s, "%02x", bytes[i]);
3129 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
3130 s = format (s, "\n%U", format_white_space, indent);
3137 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
3140 vat_main_t *vam = &vat_main;
3141 i32 retval = ntohl (mp->retval);
3144 fformat (vam->ofp, "classify table info :\n");
3145 fformat (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d\n",
3146 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
3147 ntohl (mp->miss_next_index));
3148 fformat (vam->ofp, "nbuckets: %d skip: %d match: %d\n",
3149 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
3150 ntohl (mp->match_n_vectors));
3151 fformat (vam->ofp, "mask: %U\n", format_hex_bytes, mp->mask,
3152 ntohl (mp->mask_length));
3154 vam->retval = retval;
3155 vam->result_ready = 1;
3159 vl_api_classify_table_info_reply_t_handler_json
3160 (vl_api_classify_table_info_reply_t * mp)
3162 vat_main_t *vam = &vat_main;
3163 vat_json_node_t node;
3165 i32 retval = ntohl (mp->retval);
3168 vat_json_init_object (&node);
3170 vat_json_object_add_int (&node, "sessions",
3171 ntohl (mp->active_sessions));
3172 vat_json_object_add_int (&node, "nexttbl",
3173 ntohl (mp->next_table_index));
3174 vat_json_object_add_int (&node, "nextnode",
3175 ntohl (mp->miss_next_index));
3176 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
3177 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
3178 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
3179 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
3180 ntohl (mp->mask_length), 0);
3181 vat_json_object_add_string_copy (&node, "mask", s);
3183 vat_json_print (vam->ofp, &node);
3184 vat_json_free (&node);
3186 vam->retval = ntohl (mp->retval);
3187 vam->result_ready = 1;
3191 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
3194 vat_main_t *vam = &vat_main;
3196 fformat (vam->ofp, "next_index: %d advance: %d opaque: %d ",
3197 ntohl (mp->hit_next_index), ntohl (mp->advance),
3198 ntohl (mp->opaque_index));
3199 fformat (vam->ofp, "mask: %U\n", format_hex_bytes, mp->match,
3200 ntohl (mp->match_length));
3204 vl_api_classify_session_details_t_handler_json
3205 (vl_api_classify_session_details_t * mp)
3207 vat_main_t *vam = &vat_main;
3208 vat_json_node_t *node = NULL;
3210 if (VAT_JSON_ARRAY != vam->json_tree.type)
3212 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3213 vat_json_init_array (&vam->json_tree);
3215 node = vat_json_array_add (&vam->json_tree);
3217 vat_json_init_object (node);
3218 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
3219 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
3220 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
3222 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
3224 vat_json_object_add_string_copy (node, "match", s);
3227 static void vl_api_pg_create_interface_reply_t_handler
3228 (vl_api_pg_create_interface_reply_t * mp)
3230 vat_main_t *vam = &vat_main;
3232 vam->retval = ntohl (mp->retval);
3233 vam->result_ready = 1;
3236 static void vl_api_pg_create_interface_reply_t_handler_json
3237 (vl_api_pg_create_interface_reply_t * mp)
3239 vat_main_t *vam = &vat_main;
3240 vat_json_node_t node;
3242 i32 retval = ntohl (mp->retval);
3245 vat_json_init_object (&node);
3247 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
3249 vat_json_print (vam->ofp, &node);
3250 vat_json_free (&node);
3252 vam->retval = ntohl (mp->retval);
3253 vam->result_ready = 1;
3256 static void vl_api_policer_classify_details_t_handler
3257 (vl_api_policer_classify_details_t * mp)
3259 vat_main_t *vam = &vat_main;
3261 fformat (vam->ofp, "%10d%20d\n", ntohl (mp->sw_if_index),
3262 ntohl (mp->table_index));
3265 static void vl_api_policer_classify_details_t_handler_json
3266 (vl_api_policer_classify_details_t * mp)
3268 vat_main_t *vam = &vat_main;
3269 vat_json_node_t *node;
3271 if (VAT_JSON_ARRAY != vam->json_tree.type)
3273 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3274 vat_json_init_array (&vam->json_tree);
3276 node = vat_json_array_add (&vam->json_tree);
3278 vat_json_init_object (node);
3279 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
3280 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
3283 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler
3284 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3286 vat_main_t *vam = &vat_main;
3287 i32 retval = ntohl (mp->retval);
3288 if (vam->async_mode)
3290 vam->async_errors += (retval < 0);
3294 vam->retval = retval;
3295 vam->sw_if_index = ntohl (mp->sw_if_index);
3296 vam->result_ready = 1;
3300 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler_json
3301 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3303 vat_main_t *vam = &vat_main;
3304 vat_json_node_t node;
3306 vat_json_init_object (&node);
3307 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3308 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
3310 vat_json_print (vam->ofp, &node);
3311 vat_json_free (&node);
3313 vam->retval = ntohl (mp->retval);
3314 vam->result_ready = 1;
3317 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
3318 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
3319 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
3320 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
3323 * Generate boilerplate reply handlers, which
3324 * dig the return value out of the xxx_reply_t API message,
3325 * stick it into vam->retval, and set vam->result_ready
3327 * Could also do this by pointing N message decode slots at
3328 * a single function, but that could break in subtle ways.
3331 #define foreach_standard_reply_retval_handler \
3332 _(sw_interface_set_flags_reply) \
3333 _(sw_interface_add_del_address_reply) \
3334 _(sw_interface_set_table_reply) \
3335 _(sw_interface_set_vpath_reply) \
3336 _(sw_interface_set_l2_bridge_reply) \
3337 _(bridge_domain_add_del_reply) \
3338 _(sw_interface_set_l2_xconnect_reply) \
3339 _(l2fib_add_del_reply) \
3340 _(ip_add_del_route_reply) \
3341 _(proxy_arp_add_del_reply) \
3342 _(proxy_arp_intfc_enable_disable_reply) \
3343 _(mpls_add_del_encap_reply) \
3344 _(mpls_add_del_decap_reply) \
3345 _(mpls_ethernet_add_del_tunnel_2_reply) \
3346 _(sw_interface_set_unnumbered_reply) \
3347 _(ip_neighbor_add_del_reply) \
3348 _(reset_vrf_reply) \
3349 _(oam_add_del_reply) \
3350 _(reset_fib_reply) \
3351 _(dhcp_proxy_config_reply) \
3352 _(dhcp_proxy_config_2_reply) \
3353 _(dhcp_proxy_set_vss_reply) \
3354 _(dhcp_client_config_reply) \
3355 _(set_ip_flow_hash_reply) \
3356 _(sw_interface_ip6_enable_disable_reply) \
3357 _(sw_interface_ip6_set_link_local_address_reply) \
3358 _(sw_interface_ip6nd_ra_prefix_reply) \
3359 _(sw_interface_ip6nd_ra_config_reply) \
3360 _(set_arp_neighbor_limit_reply) \
3361 _(l2_patch_add_del_reply) \
3362 _(sr_tunnel_add_del_reply) \
3363 _(sr_policy_add_del_reply) \
3364 _(sr_multicast_map_add_del_reply) \
3365 _(classify_add_del_session_reply) \
3366 _(classify_set_interface_ip_table_reply) \
3367 _(classify_set_interface_l2_tables_reply) \
3368 _(l2tpv3_set_tunnel_cookies_reply) \
3369 _(l2tpv3_interface_enable_disable_reply) \
3370 _(l2tpv3_set_lookup_key_reply) \
3371 _(l2_fib_clear_table_reply) \
3372 _(l2_interface_efp_filter_reply) \
3373 _(l2_interface_vlan_tag_rewrite_reply) \
3374 _(modify_vhost_user_if_reply) \
3375 _(delete_vhost_user_if_reply) \
3376 _(want_ip4_arp_events_reply) \
3377 _(want_ip6_nd_events_reply) \
3378 _(input_acl_set_interface_reply) \
3379 _(ipsec_spd_add_del_reply) \
3380 _(ipsec_interface_add_del_spd_reply) \
3381 _(ipsec_spd_add_del_entry_reply) \
3382 _(ipsec_sad_add_del_entry_reply) \
3383 _(ipsec_sa_set_key_reply) \
3384 _(ikev2_profile_add_del_reply) \
3385 _(ikev2_profile_set_auth_reply) \
3386 _(ikev2_profile_set_id_reply) \
3387 _(ikev2_profile_set_ts_reply) \
3388 _(ikev2_set_local_key_reply) \
3389 _(delete_loopback_reply) \
3390 _(bd_ip_mac_add_del_reply) \
3391 _(map_del_domain_reply) \
3392 _(map_add_del_rule_reply) \
3393 _(want_interface_events_reply) \
3394 _(want_stats_reply) \
3395 _(cop_interface_enable_disable_reply) \
3396 _(cop_whitelist_enable_disable_reply) \
3397 _(sw_interface_clear_stats_reply) \
3398 _(ioam_enable_reply) \
3399 _(ioam_disable_reply) \
3400 _(lisp_add_del_locator_reply) \
3401 _(lisp_add_del_local_eid_reply) \
3402 _(lisp_add_del_remote_mapping_reply) \
3403 _(lisp_add_del_adjacency_reply) \
3404 _(lisp_gpe_add_del_fwd_entry_reply) \
3405 _(lisp_add_del_map_resolver_reply) \
3406 _(lisp_gpe_enable_disable_reply) \
3407 _(lisp_gpe_add_del_iface_reply) \
3408 _(lisp_enable_disable_reply) \
3409 _(lisp_pitr_set_locator_set_reply) \
3410 _(lisp_add_del_map_request_itr_rlocs_reply) \
3411 _(lisp_eid_table_add_del_map_reply) \
3412 _(vxlan_gpe_add_del_tunnel_reply) \
3413 _(af_packet_delete_reply) \
3414 _(policer_classify_set_interface_reply) \
3415 _(netmap_create_reply) \
3416 _(netmap_delete_reply) \
3417 _(set_ipfix_exporter_reply) \
3418 _(set_ipfix_classify_stream_reply) \
3419 _(ipfix_classify_table_add_del_reply) \
3420 _(pg_capture_reply) \
3421 _(pg_enable_disable_reply) \
3422 _(ip_source_and_port_range_check_add_del_reply) \
3423 _(ip_source_and_port_range_check_interface_add_del_reply)\
3424 _(delete_subif_reply)
3427 static void vl_api_##n##_t_handler \
3428 (vl_api_##n##_t * mp) \
3430 vat_main_t * vam = &vat_main; \
3431 i32 retval = ntohl(mp->retval); \
3432 if (vam->async_mode) { \
3433 vam->async_errors += (retval < 0); \
3435 vam->retval = retval; \
3436 vam->result_ready = 1; \
3439 foreach_standard_reply_retval_handler;
3443 static void vl_api_##n##_t_handler_json \
3444 (vl_api_##n##_t * mp) \
3446 vat_main_t * vam = &vat_main; \
3447 vat_json_node_t node; \
3448 vat_json_init_object(&node); \
3449 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
3450 vat_json_print(vam->ofp, &node); \
3451 vam->retval = ntohl(mp->retval); \
3452 vam->result_ready = 1; \
3454 foreach_standard_reply_retval_handler;
3458 * Table of message reply handlers, must include boilerplate handlers
3462 #define foreach_vpe_api_reply_msg \
3463 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
3464 _(SW_INTERFACE_DETAILS, sw_interface_details) \
3465 _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
3466 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
3467 _(CONTROL_PING_REPLY, control_ping_reply) \
3468 _(CLI_REPLY, cli_reply) \
3469 _(CLI_INBAND_REPLY, cli_inband_reply) \
3470 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
3471 sw_interface_add_del_address_reply) \
3472 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
3473 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
3474 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
3475 sw_interface_set_l2_xconnect_reply) \
3476 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
3477 sw_interface_set_l2_bridge_reply) \
3478 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
3479 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
3480 _(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
3481 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
3482 _(L2_FLAGS_REPLY, l2_flags_reply) \
3483 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
3484 _(TAP_CONNECT_REPLY, tap_connect_reply) \
3485 _(TAP_MODIFY_REPLY, tap_modify_reply) \
3486 _(TAP_DELETE_REPLY, tap_delete_reply) \
3487 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
3488 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
3489 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
3490 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
3491 proxy_arp_intfc_enable_disable_reply) \
3492 _(MPLS_ADD_DEL_ENCAP_REPLY, mpls_add_del_encap_reply) \
3493 _(MPLS_ADD_DEL_DECAP_REPLY, mpls_add_del_decap_reply) \
3494 _(MPLS_GRE_ADD_DEL_TUNNEL_REPLY, mpls_gre_add_del_tunnel_reply) \
3495 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_REPLY, \
3496 mpls_ethernet_add_del_tunnel_reply) \
3497 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_2_REPLY, \
3498 mpls_ethernet_add_del_tunnel_2_reply) \
3499 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
3500 sw_interface_set_unnumbered_reply) \
3501 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
3502 _(RESET_VRF_REPLY, reset_vrf_reply) \
3503 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
3504 _(CREATE_SUBIF_REPLY, create_subif_reply) \
3505 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
3506 _(RESET_FIB_REPLY, reset_fib_reply) \
3507 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
3508 _(DHCP_PROXY_CONFIG_2_REPLY, dhcp_proxy_config_2_reply) \
3509 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
3510 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
3511 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
3512 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
3513 sw_interface_ip6_enable_disable_reply) \
3514 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
3515 sw_interface_ip6_set_link_local_address_reply) \
3516 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
3517 sw_interface_ip6nd_ra_prefix_reply) \
3518 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
3519 sw_interface_ip6nd_ra_config_reply) \
3520 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
3521 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
3522 _(SR_TUNNEL_ADD_DEL_REPLY, sr_tunnel_add_del_reply) \
3523 _(SR_POLICY_ADD_DEL_REPLY, sr_policy_add_del_reply) \
3524 _(SR_MULTICAST_MAP_ADD_DEL_REPLY, sr_multicast_map_add_del_reply) \
3525 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
3526 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
3527 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
3528 classify_set_interface_ip_table_reply) \
3529 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
3530 classify_set_interface_l2_tables_reply) \
3531 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
3532 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
3533 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
3534 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
3535 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
3536 l2tpv3_interface_enable_disable_reply) \
3537 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
3538 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
3539 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
3540 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
3541 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
3542 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
3543 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
3544 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
3545 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
3546 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
3547 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
3548 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
3549 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
3550 _(SHOW_VERSION_REPLY, show_version_reply) \
3551 _(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
3552 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
3553 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
3554 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
3555 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
3556 _(IP4_ARP_EVENT, ip4_arp_event) \
3557 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
3558 _(IP6_ND_EVENT, ip6_nd_event) \
3559 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
3560 _(IP_ADDRESS_DETAILS, ip_address_details) \
3561 _(IP_DETAILS, ip_details) \
3562 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
3563 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
3564 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
3565 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
3566 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
3567 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
3568 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
3569 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
3570 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
3571 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
3572 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
3573 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
3574 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
3575 _(VNET_INTERFACE_COUNTERS, vnet_interface_counters) \
3576 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
3577 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
3578 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
3579 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
3580 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
3581 _(MAP_DOMAIN_DETAILS, map_domain_details) \
3582 _(MAP_RULE_DETAILS, map_rule_details) \
3583 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
3584 _(WANT_STATS_REPLY, want_stats_reply) \
3585 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
3586 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
3587 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
3588 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
3589 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
3590 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
3591 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
3592 _(LISP_ADD_DEL_LOCATOR_SET_REPLY, lisp_add_del_locator_set_reply) \
3593 _(LISP_ADD_DEL_LOCATOR_REPLY, lisp_add_del_locator_reply) \
3594 _(LISP_ADD_DEL_LOCAL_EID_REPLY, lisp_add_del_local_eid_reply) \
3595 _(LISP_ADD_DEL_REMOTE_MAPPING_REPLY, lisp_add_del_remote_mapping_reply) \
3596 _(LISP_ADD_DEL_ADJACENCY_REPLY, lisp_add_del_adjacency_reply) \
3597 _(LISP_GPE_ADD_DEL_FWD_ENTRY_REPLY, lisp_gpe_add_del_fwd_entry_reply) \
3598 _(LISP_ADD_DEL_MAP_RESOLVER_REPLY, lisp_add_del_map_resolver_reply) \
3599 _(LISP_GPE_ENABLE_DISABLE_REPLY, lisp_gpe_enable_disable_reply) \
3600 _(LISP_ENABLE_DISABLE_REPLY, lisp_enable_disable_reply) \
3601 _(LISP_PITR_SET_LOCATOR_SET_REPLY, lisp_pitr_set_locator_set_reply) \
3602 _(LISP_EID_TABLE_ADD_DEL_MAP_REPLY, lisp_eid_table_add_del_map_reply) \
3603 _(LISP_GPE_ADD_DEL_IFACE_REPLY, lisp_gpe_add_del_iface_reply) \
3604 _(LISP_LOCATOR_SET_DETAILS, lisp_locator_set_details) \
3605 _(LISP_LOCATOR_DETAILS, lisp_locator_details) \
3606 _(LISP_EID_TABLE_DETAILS, lisp_eid_table_details) \
3607 _(LISP_EID_TABLE_MAP_DETAILS, lisp_eid_table_map_details) \
3608 _(LISP_EID_TABLE_VNI_DETAILS, lisp_eid_table_vni_details) \
3609 _(LISP_GPE_TUNNEL_DETAILS, lisp_gpe_tunnel_details) \
3610 _(LISP_MAP_RESOLVER_DETAILS, lisp_map_resolver_details) \
3611 _(SHOW_LISP_STATUS_REPLY, show_lisp_status_reply) \
3612 _(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
3613 lisp_add_del_map_request_itr_rlocs_reply) \
3614 _(LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
3615 lisp_get_map_request_itr_rlocs_reply) \
3616 _(SHOW_LISP_PITR_REPLY, show_lisp_pitr_reply) \
3617 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
3618 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
3619 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
3620 _(POLICER_DETAILS, policer_details) \
3621 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
3622 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
3623 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
3624 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
3625 _(MPLS_GRE_TUNNEL_DETAILS, mpls_gre_tunnel_details) \
3626 _(MPLS_ETH_TUNNEL_DETAILS, mpls_eth_tunnel_details) \
3627 _(MPLS_FIB_ENCAP_DETAILS, mpls_fib_encap_details) \
3628 _(MPLS_FIB_DECAP_DETAILS, mpls_fib_decap_details) \
3629 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
3630 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
3631 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
3632 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
3633 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
3634 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
3635 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
3636 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
3637 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
3638 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
3639 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
3640 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
3641 _(PG_CAPTURE_REPLY, pg_capture_reply) \
3642 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
3643 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
3644 ip_source_and_port_range_check_add_del_reply) \
3645 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
3646 ip_source_and_port_range_check_interface_add_del_reply) \
3647 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
3648 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
3649 _(DELETE_SUBIF_REPLY, delete_subif_reply)
3651 /* M: construct, but don't yet send a message */
3655 vam->result_ready = 0; \
3656 mp = vl_msg_api_alloc(sizeof(*mp)); \
3657 memset (mp, 0, sizeof (*mp)); \
3658 mp->_vl_msg_id = ntohs (VL_API_##T); \
3659 mp->client_index = vam->my_client_index; \
3664 vam->result_ready = 0; \
3665 mp = vl_msg_api_alloc(sizeof(*mp)+(n)); \
3666 memset (mp, 0, sizeof (*mp)); \
3667 mp->_vl_msg_id = ntohs (VL_API_##T); \
3668 mp->client_index = vam->my_client_index; \
3672 /* S: send a message */
3673 #define S (vl_msg_api_send_shmem (vam->vl_input_queue, (u8 *)&mp))
3675 /* W: wait for results, with timeout */
3678 timeout = vat_time_now (vam) + 1.0; \
3680 while (vat_time_now (vam) < timeout) { \
3681 if (vam->result_ready == 1) { \
3682 return (vam->retval); \
3688 /* W2: wait for results, with timeout */
3691 timeout = vat_time_now (vam) + 1.0; \
3693 while (vat_time_now (vam) < timeout) { \
3694 if (vam->result_ready == 1) { \
3696 return (vam->retval); \
3709 #define STR_VTR_OP_CASE(op) \
3710 case L2_VTR_ ## op: \
3714 str_vtr_op (u32 vtr_op)
3718 STR_VTR_OP_CASE (DISABLED);
3719 STR_VTR_OP_CASE (PUSH_1);
3720 STR_VTR_OP_CASE (PUSH_2);
3721 STR_VTR_OP_CASE (POP_1);
3722 STR_VTR_OP_CASE (POP_2);
3723 STR_VTR_OP_CASE (TRANSLATE_1_1);
3724 STR_VTR_OP_CASE (TRANSLATE_1_2);
3725 STR_VTR_OP_CASE (TRANSLATE_2_1);
3726 STR_VTR_OP_CASE (TRANSLATE_2_2);
3733 dump_sub_interface_table (vat_main_t * vam)
3735 const sw_interface_subif_t *sub = NULL;
3737 if (vam->json_output)
3740 ("JSON output supported only for VPE API calls and dump_stats_table");
3745 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s\n",
3746 "Interface", "sw_if_index",
3747 "sub id", "dot1ad", "tags", "outer id",
3748 "inner id", "exact", "default", "outer any", "inner any");
3750 vec_foreach (sub, vam->sw_if_subif_table)
3753 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d\n",
3754 sub->interface_name,
3756 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
3757 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
3758 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
3759 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
3760 if (sub->vtr_op != L2_VTR_DISABLED)
3763 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
3764 "tag1: %d tag2: %d ]\n",
3765 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
3766 sub->vtr_tag1, sub->vtr_tag2);
3774 name_sort_cmp (void *a1, void *a2)
3776 name_sort_t *n1 = a1;
3777 name_sort_t *n2 = a2;
3779 return strcmp ((char *) n1->name, (char *) n2->name);
3783 dump_interface_table (vat_main_t * vam)
3786 name_sort_t *nses = 0, *ns;
3788 if (vam->json_output)
3791 ("JSON output supported only for VPE API calls and dump_stats_table");
3796 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
3798 vec_add2 (nses, ns, 1);
3799 ns->name = (u8 *)(p->key);
3800 ns->value = (u32) p->value[0];
3804 vec_sort_with_function (nses, name_sort_cmp);
3806 fformat (vam->ofp, "%-25s%-15s\n", "Interface", "sw_if_index");
3807 vec_foreach (ns, nses)
3809 fformat (vam->ofp, "%-25s%-15d\n", ns->name, ns->value);
3816 dump_ip_table (vat_main_t * vam, int is_ipv6)
3818 const ip_details_t *det = NULL;
3819 const ip_address_details_t *address = NULL;
3822 fformat (vam->ofp, "%-12s\n", "sw_if_index");
3824 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
3831 fformat (vam->ofp, "%-12d\n", i);
3833 " %-30s%-13s\n", "Address", "Prefix length");
3838 vec_foreach (address, det->addr)
3842 is_ipv6 ? format_ip6_address : format_ip4_address,
3843 address->ip, address->prefix_length);
3851 dump_ipv4_table (vat_main_t * vam)
3853 if (vam->json_output)
3856 ("JSON output supported only for VPE API calls and dump_stats_table");
3860 return dump_ip_table (vam, 0);
3864 dump_ipv6_table (vat_main_t * vam)
3866 if (vam->json_output)
3869 ("JSON output supported only for VPE API calls and dump_stats_table");
3873 return dump_ip_table (vam, 1);
3877 counter_type_to_str (u8 counter_type, u8 is_combined)
3881 switch (counter_type)
3883 case VNET_INTERFACE_COUNTER_DROP:
3885 case VNET_INTERFACE_COUNTER_PUNT:
3887 case VNET_INTERFACE_COUNTER_IP4:
3889 case VNET_INTERFACE_COUNTER_IP6:
3891 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
3893 case VNET_INTERFACE_COUNTER_RX_MISS:
3895 case VNET_INTERFACE_COUNTER_RX_ERROR:
3897 case VNET_INTERFACE_COUNTER_TX_ERROR:
3900 return "INVALID-COUNTER-TYPE";
3905 switch (counter_type)
3907 case VNET_INTERFACE_COUNTER_RX:
3909 case VNET_INTERFACE_COUNTER_TX:
3912 return "INVALID-COUNTER-TYPE";
3918 dump_stats_table (vat_main_t * vam)
3920 vat_json_node_t node;
3921 vat_json_node_t *msg_array;
3922 vat_json_node_t *msg;
3923 vat_json_node_t *counter_array;
3924 vat_json_node_t *counter;
3925 interface_counter_t c;
3927 ip4_fib_counter_t *c4;
3928 ip6_fib_counter_t *c6;
3931 if (!vam->json_output)
3933 clib_warning ("dump_stats_table supported only in JSON format");
3937 vat_json_init_object (&node);
3939 /* interface counters */
3940 msg_array = vat_json_object_add (&node, "interface_counters");
3941 vat_json_init_array (msg_array);
3942 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
3944 msg = vat_json_array_add (msg_array);
3945 vat_json_init_object (msg);
3946 vat_json_object_add_string_copy (msg, "vnet_counter_type",
3947 (u8 *) counter_type_to_str (i, 0));
3948 vat_json_object_add_int (msg, "is_combined", 0);
3949 counter_array = vat_json_object_add (msg, "data");
3950 vat_json_init_array (counter_array);
3951 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
3953 packets = vam->simple_interface_counters[i][j];
3954 vat_json_array_add_uint (counter_array, packets);
3957 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
3959 msg = vat_json_array_add (msg_array);
3960 vat_json_init_object (msg);
3961 vat_json_object_add_string_copy (msg, "vnet_counter_type",
3962 (u8 *) counter_type_to_str (i, 1));
3963 vat_json_object_add_int (msg, "is_combined", 1);
3964 counter_array = vat_json_object_add (msg, "data");
3965 vat_json_init_array (counter_array);
3966 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
3968 c = vam->combined_interface_counters[i][j];
3969 counter = vat_json_array_add (counter_array);
3970 vat_json_init_object (counter);
3971 vat_json_object_add_uint (counter, "packets", c.packets);
3972 vat_json_object_add_uint (counter, "bytes", c.bytes);
3976 /* ip4 fib counters */
3977 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
3978 vat_json_init_array (msg_array);
3979 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
3981 msg = vat_json_array_add (msg_array);
3982 vat_json_init_object (msg);
3983 vat_json_object_add_uint (msg, "vrf_id",
3984 vam->ip4_fib_counters_vrf_id_by_index[i]);
3985 counter_array = vat_json_object_add (msg, "c");
3986 vat_json_init_array (counter_array);
3987 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
3989 counter = vat_json_array_add (counter_array);
3990 vat_json_init_object (counter);
3991 c4 = &vam->ip4_fib_counters[i][j];
3992 vat_json_object_add_ip4 (counter, "address", c4->address);
3993 vat_json_object_add_uint (counter, "address_length",
3994 c4->address_length);
3995 vat_json_object_add_uint (counter, "packets", c4->packets);
3996 vat_json_object_add_uint (counter, "bytes", c4->bytes);
4000 /* ip6 fib counters */
4001 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
4002 vat_json_init_array (msg_array);
4003 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
4005 msg = vat_json_array_add (msg_array);
4006 vat_json_init_object (msg);
4007 vat_json_object_add_uint (msg, "vrf_id",
4008 vam->ip6_fib_counters_vrf_id_by_index[i]);
4009 counter_array = vat_json_object_add (msg, "c");
4010 vat_json_init_array (counter_array);
4011 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
4013 counter = vat_json_array_add (counter_array);
4014 vat_json_init_object (counter);
4015 c6 = &vam->ip6_fib_counters[i][j];
4016 vat_json_object_add_ip6 (counter, "address", c6->address);
4017 vat_json_object_add_uint (counter, "address_length",
4018 c6->address_length);
4019 vat_json_object_add_uint (counter, "packets", c6->packets);
4020 vat_json_object_add_uint (counter, "bytes", c6->bytes);
4024 vat_json_print (vam->ofp, &node);
4025 vat_json_free (&node);
4031 exec (vat_main_t * vam)
4033 api_main_t *am = &api_main;
4034 vl_api_cli_request_t *mp;
4038 unformat_input_t *i = vam->input;
4040 if (vec_len (i->buffer) == 0)
4043 if (vam->exec_mode == 0 && unformat (i, "mode"))
4048 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4055 M (CLI_REQUEST, cli_request);
4058 * Copy cmd into shared memory.
4059 * In order for the CLI command to work, it
4060 * must be a vector ending in \n, not a C-string ending
4063 pthread_mutex_lock (&am->vlib_rp->mutex);
4064 oldheap = svm_push_data_heap (am->vlib_rp);
4066 vec_validate (cmd, vec_len (vam->input->buffer) - 1);
4067 clib_memcpy (cmd, vam->input->buffer, vec_len (vam->input->buffer));
4069 svm_pop_heap (oldheap);
4070 pthread_mutex_unlock (&am->vlib_rp->mutex);
4072 mp->cmd_in_shmem = (u64) cmd;
4074 timeout = vat_time_now (vam) + 10.0;
4076 while (vat_time_now (vam) < timeout)
4078 if (vam->result_ready == 1)
4081 if (vam->shmem_result != NULL)
4082 fformat (vam->ofp, "%s", vam->shmem_result);
4083 pthread_mutex_lock (&am->vlib_rp->mutex);
4084 oldheap = svm_push_data_heap (am->vlib_rp);
4086 free_me = (u8 *) vam->shmem_result;
4089 svm_pop_heap (oldheap);
4090 pthread_mutex_unlock (&am->vlib_rp->mutex);
4098 * Future replacement of exec() that passes CLI buffers directly in
4099 * the API messages instead of an additional shared memory area.
4102 exec_inband (vat_main_t * vam)
4104 vl_api_cli_inband_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 * In order for the CLI command to work, it
4124 * must be a vector ending in \n, not a C-string ending
4127 u32 len = vec_len (vam->input->buffer);
4128 M2 (CLI_INBAND, cli_inband, len);
4129 clib_memcpy (mp->cmd, vam->input->buffer, len);
4130 mp->length = htonl (len);
4133 W2 (fformat (vam->ofp, "%s", vam->cmd_reply));
4137 api_create_loopback (vat_main_t * vam)
4139 unformat_input_t *i = vam->input;
4140 vl_api_create_loopback_t *mp;
4145 memset (mac_address, 0, sizeof (mac_address));
4147 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4149 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
4155 /* Construct the API message */
4156 M (CREATE_LOOPBACK, create_loopback);
4158 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
4165 api_delete_loopback (vat_main_t * vam)
4167 unformat_input_t *i = vam->input;
4168 vl_api_delete_loopback_t *mp;
4170 u32 sw_if_index = ~0;
4172 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4174 if (unformat (i, "sw_if_index %d", &sw_if_index))
4180 if (sw_if_index == ~0)
4182 errmsg ("missing sw_if_index\n");
4186 /* Construct the API message */
4187 M (DELETE_LOOPBACK, delete_loopback);
4188 mp->sw_if_index = ntohl (sw_if_index);
4195 api_want_stats (vat_main_t * vam)
4197 unformat_input_t *i = vam->input;
4198 vl_api_want_stats_t *mp;
4202 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4204 if (unformat (i, "enable"))
4206 else if (unformat (i, "disable"))
4214 errmsg ("missing enable|disable\n");
4218 M (WANT_STATS, want_stats);
4219 mp->enable_disable = enable;
4226 api_want_interface_events (vat_main_t * vam)
4228 unformat_input_t *i = vam->input;
4229 vl_api_want_interface_events_t *mp;
4233 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4235 if (unformat (i, "enable"))
4237 else if (unformat (i, "disable"))
4245 errmsg ("missing enable|disable\n");
4249 M (WANT_INTERFACE_EVENTS, want_interface_events);
4250 mp->enable_disable = enable;
4252 vam->interface_event_display = enable;
4259 /* Note: non-static, called once to set up the initial intfc table */
4261 api_sw_interface_dump (vat_main_t * vam)
4263 vl_api_sw_interface_dump_t *mp;
4266 name_sort_t *nses = 0, *ns;
4267 sw_interface_subif_t *sub = NULL;
4269 /* Toss the old name table */
4271 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4273 vec_add2 (nses, ns, 1);
4274 ns->name = (u8 *)(p->key);
4275 ns->value = (u32) p->value[0];
4279 hash_free (vam->sw_if_index_by_interface_name);
4281 vec_foreach (ns, nses) vec_free (ns->name);
4285 vec_foreach (sub, vam->sw_if_subif_table)
4287 vec_free (sub->interface_name);
4289 vec_free (vam->sw_if_subif_table);
4291 /* recreate the interface name hash table */
4292 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
4294 /* Get list of ethernets */
4295 M (SW_INTERFACE_DUMP, sw_interface_dump);
4296 mp->name_filter_valid = 1;
4297 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
4300 /* and local / loopback interfaces */
4301 M (SW_INTERFACE_DUMP, sw_interface_dump);
4302 mp->name_filter_valid = 1;
4303 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
4307 /* and vxlan-gpe tunnel interfaces */
4308 M (SW_INTERFACE_DUMP, sw_interface_dump);
4309 mp->name_filter_valid = 1;
4310 strncpy ((char *) mp->name_filter, "vxlan_gpe",
4311 sizeof (mp->name_filter) - 1);
4314 /* and vxlan tunnel interfaces */
4315 M (SW_INTERFACE_DUMP, sw_interface_dump);
4316 mp->name_filter_valid = 1;
4317 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
4320 /* and host (af_packet) interfaces */
4321 M (SW_INTERFACE_DUMP, sw_interface_dump);
4322 mp->name_filter_valid = 1;
4323 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
4326 /* and l2tpv3 tunnel interfaces */
4327 M (SW_INTERFACE_DUMP, sw_interface_dump);
4328 mp->name_filter_valid = 1;
4329 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
4330 sizeof (mp->name_filter) - 1);
4333 /* and GRE tunnel interfaces */
4334 M (SW_INTERFACE_DUMP, sw_interface_dump);
4335 mp->name_filter_valid = 1;
4336 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
4339 /* and LISP-GPE interfaces */
4340 M (SW_INTERFACE_DUMP, sw_interface_dump);
4341 mp->name_filter_valid = 1;
4342 strncpy ((char *) mp->name_filter, "lisp_gpe",
4343 sizeof (mp->name_filter) - 1);
4346 /* and IPSEC tunnel interfaces */
4347 M (SW_INTERFACE_DUMP, sw_interface_dump);
4348 mp->name_filter_valid = 1;
4349 strncpy ((char *) mp->name_filter, "ipsec", sizeof (mp->name_filter) - 1);
4352 /* Use a control ping for synchronization */
4354 vl_api_control_ping_t *mp;
4355 M (CONTROL_PING, control_ping);
4362 api_sw_interface_set_flags (vat_main_t * vam)
4364 unformat_input_t *i = vam->input;
4365 vl_api_sw_interface_set_flags_t *mp;
4368 u8 sw_if_index_set = 0;
4369 u8 admin_up = 0, link_up = 0;
4371 /* Parse args required to build the message */
4372 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4374 if (unformat (i, "admin-up"))
4376 else if (unformat (i, "admin-down"))
4378 else if (unformat (i, "link-up"))
4380 else if (unformat (i, "link-down"))
4382 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4383 sw_if_index_set = 1;
4384 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4385 sw_if_index_set = 1;
4390 if (sw_if_index_set == 0)
4392 errmsg ("missing interface name or sw_if_index\n");
4396 /* Construct the API message */
4397 M (SW_INTERFACE_SET_FLAGS, sw_interface_set_flags);
4398 mp->sw_if_index = ntohl (sw_if_index);
4399 mp->admin_up_down = admin_up;
4400 mp->link_up_down = link_up;
4405 /* Wait for a reply, return the good/bad news... */
4410 api_sw_interface_clear_stats (vat_main_t * vam)
4412 unformat_input_t *i = vam->input;
4413 vl_api_sw_interface_clear_stats_t *mp;
4416 u8 sw_if_index_set = 0;
4418 /* Parse args required to build the message */
4419 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4421 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4422 sw_if_index_set = 1;
4423 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4424 sw_if_index_set = 1;
4429 /* Construct the API message */
4430 M (SW_INTERFACE_CLEAR_STATS, sw_interface_clear_stats);
4432 if (sw_if_index_set == 1)
4433 mp->sw_if_index = ntohl (sw_if_index);
4435 mp->sw_if_index = ~0;
4440 /* Wait for a reply, return the good/bad news... */
4445 api_sw_interface_add_del_address (vat_main_t * vam)
4447 unformat_input_t *i = vam->input;
4448 vl_api_sw_interface_add_del_address_t *mp;
4451 u8 sw_if_index_set = 0;
4452 u8 is_add = 1, del_all = 0;
4453 u32 address_length = 0;
4454 u8 v4_address_set = 0;
4455 u8 v6_address_set = 0;
4456 ip4_address_t v4address;
4457 ip6_address_t v6address;
4459 /* Parse args required to build the message */
4460 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4462 if (unformat (i, "del-all"))
4464 else if (unformat (i, "del"))
4466 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4467 sw_if_index_set = 1;
4468 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4469 sw_if_index_set = 1;
4470 else if (unformat (i, "%U/%d",
4471 unformat_ip4_address, &v4address, &address_length))
4473 else if (unformat (i, "%U/%d",
4474 unformat_ip6_address, &v6address, &address_length))
4480 if (sw_if_index_set == 0)
4482 errmsg ("missing interface name or sw_if_index\n");
4485 if (v4_address_set && v6_address_set)
4487 errmsg ("both v4 and v6 addresses set\n");
4490 if (!v4_address_set && !v6_address_set && !del_all)
4492 errmsg ("no addresses set\n");
4496 /* Construct the API message */
4497 M (SW_INTERFACE_ADD_DEL_ADDRESS, sw_interface_add_del_address);
4499 mp->sw_if_index = ntohl (sw_if_index);
4500 mp->is_add = is_add;
4501 mp->del_all = del_all;
4505 clib_memcpy (mp->address, &v6address, sizeof (v6address));
4509 clib_memcpy (mp->address, &v4address, sizeof (v4address));
4511 mp->address_length = address_length;
4516 /* Wait for a reply, return good/bad news */
4521 api_sw_interface_set_table (vat_main_t * vam)
4523 unformat_input_t *i = vam->input;
4524 vl_api_sw_interface_set_table_t *mp;
4526 u32 sw_if_index, vrf_id = 0;
4527 u8 sw_if_index_set = 0;
4530 /* Parse args required to build the message */
4531 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4533 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4534 sw_if_index_set = 1;
4535 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4536 sw_if_index_set = 1;
4537 else if (unformat (i, "vrf %d", &vrf_id))
4539 else if (unformat (i, "ipv6"))
4545 if (sw_if_index_set == 0)
4547 errmsg ("missing interface name or sw_if_index\n");
4551 /* Construct the API message */
4552 M (SW_INTERFACE_SET_TABLE, sw_interface_set_table);
4554 mp->sw_if_index = ntohl (sw_if_index);
4555 mp->is_ipv6 = is_ipv6;
4556 mp->vrf_id = ntohl (vrf_id);
4561 /* Wait for a reply... */
4566 api_sw_interface_set_vpath (vat_main_t * vam)
4568 unformat_input_t *i = vam->input;
4569 vl_api_sw_interface_set_vpath_t *mp;
4571 u32 sw_if_index = 0;
4572 u8 sw_if_index_set = 0;
4575 /* Parse args required to build the message */
4576 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4578 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4579 sw_if_index_set = 1;
4580 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4581 sw_if_index_set = 1;
4582 else if (unformat (i, "enable"))
4584 else if (unformat (i, "disable"))
4590 if (sw_if_index_set == 0)
4592 errmsg ("missing interface name or sw_if_index\n");
4596 /* Construct the API message */
4597 M (SW_INTERFACE_SET_VPATH, sw_interface_set_vpath);
4599 mp->sw_if_index = ntohl (sw_if_index);
4600 mp->enable = is_enable;
4605 /* Wait for a reply... */
4610 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
4612 unformat_input_t *i = vam->input;
4613 vl_api_sw_interface_set_l2_xconnect_t *mp;
4616 u8 rx_sw_if_index_set = 0;
4618 u8 tx_sw_if_index_set = 0;
4621 /* Parse args required to build the message */
4622 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4624 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
4625 rx_sw_if_index_set = 1;
4626 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
4627 tx_sw_if_index_set = 1;
4628 else if (unformat (i, "rx"))
4630 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4632 if (unformat (i, "%U", unformat_sw_if_index, vam,
4634 rx_sw_if_index_set = 1;
4639 else if (unformat (i, "tx"))
4641 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4643 if (unformat (i, "%U", unformat_sw_if_index, vam,
4645 tx_sw_if_index_set = 1;
4650 else if (unformat (i, "enable"))
4652 else if (unformat (i, "disable"))
4658 if (rx_sw_if_index_set == 0)
4660 errmsg ("missing rx interface name or rx_sw_if_index\n");
4664 if (enable && (tx_sw_if_index_set == 0))
4666 errmsg ("missing tx interface name or tx_sw_if_index\n");
4670 M (SW_INTERFACE_SET_L2_XCONNECT, sw_interface_set_l2_xconnect);
4672 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
4673 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
4674 mp->enable = enable;
4683 api_sw_interface_set_l2_bridge (vat_main_t * vam)
4685 unformat_input_t *i = vam->input;
4686 vl_api_sw_interface_set_l2_bridge_t *mp;
4689 u8 rx_sw_if_index_set = 0;
4696 /* Parse args required to build the message */
4697 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4699 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
4700 rx_sw_if_index_set = 1;
4701 else if (unformat (i, "bd_id %d", &bd_id))
4703 else if (unformat (i, "%U", unformat_sw_if_index, vam, &rx_sw_if_index))
4704 rx_sw_if_index_set = 1;
4705 else if (unformat (i, "shg %d", &shg))
4707 else if (unformat (i, "bvi"))
4709 else if (unformat (i, "enable"))
4711 else if (unformat (i, "disable"))
4717 if (rx_sw_if_index_set == 0)
4719 errmsg ("missing rx interface name or sw_if_index\n");
4723 if (enable && (bd_id_set == 0))
4725 errmsg ("missing bridge domain\n");
4729 M (SW_INTERFACE_SET_L2_BRIDGE, sw_interface_set_l2_bridge);
4731 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
4732 mp->bd_id = ntohl (bd_id);
4735 mp->enable = enable;
4744 api_bridge_domain_dump (vat_main_t * vam)
4746 unformat_input_t *i = vam->input;
4747 vl_api_bridge_domain_dump_t *mp;
4751 /* Parse args required to build the message */
4752 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4754 if (unformat (i, "bd_id %d", &bd_id))
4760 M (BRIDGE_DOMAIN_DUMP, bridge_domain_dump);
4761 mp->bd_id = ntohl (bd_id);
4764 /* Use a control ping for synchronization */
4766 vl_api_control_ping_t *mp;
4767 M (CONTROL_PING, control_ping);
4777 api_bridge_domain_add_del (vat_main_t * vam)
4779 unformat_input_t *i = vam->input;
4780 vl_api_bridge_domain_add_del_t *mp;
4784 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
4786 /* Parse args required to build the message */
4787 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4789 if (unformat (i, "bd_id %d", &bd_id))
4791 else if (unformat (i, "flood %d", &flood))
4793 else if (unformat (i, "uu-flood %d", &uu_flood))
4795 else if (unformat (i, "forward %d", &forward))
4797 else if (unformat (i, "learn %d", &learn))
4799 else if (unformat (i, "arp-term %d", &arp_term))
4801 else if (unformat (i, "del"))
4804 flood = uu_flood = forward = learn = 0;
4812 errmsg ("missing bridge domain\n");
4816 M (BRIDGE_DOMAIN_ADD_DEL, bridge_domain_add_del);
4818 mp->bd_id = ntohl (bd_id);
4820 mp->uu_flood = uu_flood;
4821 mp->forward = forward;
4823 mp->arp_term = arp_term;
4824 mp->is_add = is_add;
4833 api_l2fib_add_del (vat_main_t * vam)
4835 unformat_input_t *i = vam->input;
4836 vl_api_l2fib_add_del_t *mp;
4843 u8 sw_if_index_set = 0;
4852 /* Parse args required to build the message */
4853 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4855 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
4857 else if (unformat (i, "bd_id %d", &bd_id))
4859 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4860 sw_if_index_set = 1;
4861 else if (unformat (i, "sw_if"))
4863 if (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;
4871 else if (unformat (i, "static"))
4873 else if (unformat (i, "filter"))
4878 else if (unformat (i, "bvi"))
4883 else if (unformat (i, "del"))
4885 else if (unformat (i, "count %d", &count))
4893 errmsg ("missing mac address\n");
4899 errmsg ("missing bridge domain\n");
4903 if (is_add && (sw_if_index_set == 0))
4905 errmsg ("missing interface name or sw_if_index\n");
4911 /* Turn on async mode */
4912 vam->async_mode = 1;
4913 vam->async_errors = 0;
4914 before = vat_time_now (vam);
4917 for (j = 0; j < count; j++)
4919 M (L2FIB_ADD_DEL, l2fib_add_del);
4922 mp->bd_id = ntohl (bd_id);
4923 mp->is_add = is_add;
4927 mp->sw_if_index = ntohl (sw_if_index);
4928 mp->static_mac = static_mac;
4929 mp->filter_mac = filter_mac;
4930 mp->bvi_mac = bvi_mac;
4932 increment_mac_address (&mac);
4939 vl_api_control_ping_t *mp;
4942 /* Shut off async mode */
4943 vam->async_mode = 0;
4945 M (CONTROL_PING, control_ping);
4948 timeout = vat_time_now (vam) + 1.0;
4949 while (vat_time_now (vam) < timeout)
4950 if (vam->result_ready == 1)
4955 if (vam->retval == -99)
4956 errmsg ("timeout\n");
4958 if (vam->async_errors > 0)
4960 errmsg ("%d asynchronous errors\n", vam->async_errors);
4963 vam->async_errors = 0;
4964 after = vat_time_now (vam);
4966 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
4967 count, after - before, count / (after - before));
4971 /* Wait for a reply... */
4974 /* Return the good/bad news */
4975 return (vam->retval);
4979 api_l2_flags (vat_main_t * vam)
4981 unformat_input_t *i = vam->input;
4982 vl_api_l2_flags_t *mp;
4985 u32 feature_bitmap = 0;
4986 u8 sw_if_index_set = 0;
4988 /* Parse args required to build the message */
4989 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4991 if (unformat (i, "sw_if_index %d", &sw_if_index))
4992 sw_if_index_set = 1;
4993 else if (unformat (i, "sw_if"))
4995 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4997 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4998 sw_if_index_set = 1;
5003 else if (unformat (i, "learn"))
5004 feature_bitmap |= L2INPUT_FEAT_LEARN;
5005 else if (unformat (i, "forward"))
5006 feature_bitmap |= L2INPUT_FEAT_FWD;
5007 else if (unformat (i, "flood"))
5008 feature_bitmap |= L2INPUT_FEAT_FLOOD;
5009 else if (unformat (i, "uu-flood"))
5010 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
5015 if (sw_if_index_set == 0)
5017 errmsg ("missing interface name or sw_if_index\n");
5021 M (L2_FLAGS, l2_flags);
5023 mp->sw_if_index = ntohl (sw_if_index);
5024 mp->feature_bitmap = ntohl (feature_bitmap);
5033 api_bridge_flags (vat_main_t * vam)
5035 unformat_input_t *i = vam->input;
5036 vl_api_bridge_flags_t *mp;
5043 /* Parse args required to build the message */
5044 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5046 if (unformat (i, "bd_id %d", &bd_id))
5048 else if (unformat (i, "learn"))
5050 else if (unformat (i, "forward"))
5052 else if (unformat (i, "flood"))
5054 else if (unformat (i, "uu-flood"))
5055 flags |= L2_UU_FLOOD;
5056 else if (unformat (i, "arp-term"))
5057 flags |= L2_ARP_TERM;
5058 else if (unformat (i, "off"))
5060 else if (unformat (i, "disable"))
5068 errmsg ("missing bridge domain\n");
5072 M (BRIDGE_FLAGS, bridge_flags);
5074 mp->bd_id = ntohl (bd_id);
5075 mp->feature_bitmap = ntohl (flags);
5076 mp->is_set = is_set;
5085 api_bd_ip_mac_add_del (vat_main_t * vam)
5087 unformat_input_t *i = vam->input;
5088 vl_api_bd_ip_mac_add_del_t *mp;
5096 ip4_address_t v4addr;
5097 ip6_address_t v6addr;
5101 /* Parse args required to build the message */
5102 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5104 if (unformat (i, "bd_id %d", &bd_id))
5108 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
5112 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
5117 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
5121 else if (unformat (i, "del"))
5129 errmsg ("missing bridge domain\n");
5132 else if (ip_set == 0)
5134 errmsg ("missing IP address\n");
5137 else if (mac_set == 0)
5139 errmsg ("missing MAC address\n");
5143 M (BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del);
5145 mp->bd_id = ntohl (bd_id);
5146 mp->is_ipv6 = is_ipv6;
5147 mp->is_add = is_add;
5149 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
5151 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
5152 clib_memcpy (mp->mac_address, macaddr, 6);
5160 api_tap_connect (vat_main_t * vam)
5162 unformat_input_t *i = vam->input;
5163 vl_api_tap_connect_t *mp;
5170 memset (mac_address, 0, sizeof (mac_address));
5172 /* Parse args required to build the message */
5173 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5175 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5179 else if (unformat (i, "random-mac"))
5181 else if (unformat (i, "tapname %s", &tap_name))
5189 errmsg ("missing tap name\n");
5192 if (vec_len (tap_name) > 63)
5194 errmsg ("tap name too long\n");
5196 vec_add1 (tap_name, 0);
5198 /* Construct the API message */
5199 M (TAP_CONNECT, tap_connect);
5201 mp->use_random_mac = random_mac;
5202 clib_memcpy (mp->mac_address, mac_address, 6);
5203 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5204 vec_free (tap_name);
5209 /* Wait for a reply... */
5214 api_tap_modify (vat_main_t * vam)
5216 unformat_input_t *i = vam->input;
5217 vl_api_tap_modify_t *mp;
5223 u32 sw_if_index = ~0;
5224 u8 sw_if_index_set = 0;
5226 memset (mac_address, 0, sizeof (mac_address));
5228 /* Parse args required to build the message */
5229 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5231 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5232 sw_if_index_set = 1;
5233 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5234 sw_if_index_set = 1;
5235 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5239 else if (unformat (i, "random-mac"))
5241 else if (unformat (i, "tapname %s", &tap_name))
5247 if (sw_if_index_set == 0)
5249 errmsg ("missing vpp interface name");
5254 errmsg ("missing tap name\n");
5257 if (vec_len (tap_name) > 63)
5259 errmsg ("tap name too long\n");
5261 vec_add1 (tap_name, 0);
5263 /* Construct the API message */
5264 M (TAP_MODIFY, tap_modify);
5266 mp->use_random_mac = random_mac;
5267 mp->sw_if_index = ntohl (sw_if_index);
5268 clib_memcpy (mp->mac_address, mac_address, 6);
5269 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5270 vec_free (tap_name);
5275 /* Wait for a reply... */
5280 api_tap_delete (vat_main_t * vam)
5282 unformat_input_t *i = vam->input;
5283 vl_api_tap_delete_t *mp;
5285 u32 sw_if_index = ~0;
5286 u8 sw_if_index_set = 0;
5288 /* Parse args required to build the message */
5289 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5291 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5292 sw_if_index_set = 1;
5293 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5294 sw_if_index_set = 1;
5299 if (sw_if_index_set == 0)
5301 errmsg ("missing vpp interface name");
5305 /* Construct the API message */
5306 M (TAP_DELETE, tap_delete);
5308 mp->sw_if_index = ntohl (sw_if_index);
5313 /* Wait for a reply... */
5318 api_ip_add_del_route (vat_main_t * vam)
5320 unformat_input_t *i = vam->input;
5321 vl_api_ip_add_del_route_t *mp;
5323 u32 sw_if_index = ~0, vrf_id = 0;
5324 u8 sw_if_index_set = 0;
5326 u8 is_local = 0, is_drop = 0;
5327 u8 create_vrf_if_needed = 0;
5329 u8 next_hop_weight = 1;
5331 u8 is_multipath = 0;
5333 u8 address_length_set = 0;
5334 u32 lookup_in_vrf = 0;
5335 u32 resolve_attempts = 0;
5336 u32 dst_address_length = 0;
5337 u8 next_hop_set = 0;
5338 ip4_address_t v4_dst_address, v4_next_hop_address;
5339 ip6_address_t v6_dst_address, v6_next_hop_address;
5343 u32 random_add_del = 0;
5344 u32 *random_vector = 0;
5346 u32 random_seed = 0xdeaddabe;
5347 u32 classify_table_index = ~0;
5349 u8 resolve_host, resolve_attached;
5351 /* Parse args required to build the message */
5352 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5354 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5355 sw_if_index_set = 1;
5356 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5357 sw_if_index_set = 1;
5358 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
5363 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
5368 else if (unformat (i, "/%d", &dst_address_length))
5370 address_length_set = 1;
5373 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
5374 &v4_next_hop_address))
5378 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
5379 &v6_next_hop_address))
5383 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
5385 else if (unformat (i, "weight %d", &next_hop_weight))
5387 else if (unformat (i, "drop"))
5391 else if (unformat (i, "local"))
5395 else if (unformat (i, "classify %d", &classify_table_index))
5399 else if (unformat (i, "del"))
5401 else if (unformat (i, "add"))
5403 else if (unformat (i, "not-last"))
5405 else if (unformat (i, "resolve-via-host"))
5407 else if (unformat (i, "resolve-via-attached"))
5408 resolve_attached = 1;
5409 else if (unformat (i, "multipath"))
5411 else if (unformat (i, "vrf %d", &vrf_id))
5413 else if (unformat (i, "create-vrf"))
5414 create_vrf_if_needed = 1;
5415 else if (unformat (i, "count %d", &count))
5417 else if (unformat (i, "lookup-in-vrf %d", &lookup_in_vrf))
5419 else if (unformat (i, "random"))
5421 else if (unformat (i, "seed %d", &random_seed))
5425 clib_warning ("parse error '%U'", format_unformat_error, i);
5430 if (resolve_attempts > 0 && sw_if_index_set == 0)
5432 errmsg ("ARP resolution needs explicit interface or sw_if_index\n");
5436 if (!next_hop_set && !is_drop && !is_local && !is_classify)
5438 errmsg ("next hop / local / drop / classify not set\n");
5442 if (address_set == 0)
5444 errmsg ("missing addresses\n");
5448 if (address_length_set == 0)
5450 errmsg ("missing address length\n");
5454 /* Generate a pile of unique, random routes */
5457 u32 this_random_address;
5458 random_hash = hash_create (count, sizeof (uword));
5460 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
5461 for (j = 0; j <= count; j++)
5465 this_random_address = random_u32 (&random_seed);
5466 this_random_address =
5467 clib_host_to_net_u32 (this_random_address);
5469 while (hash_get (random_hash, this_random_address));
5470 vec_add1 (random_vector, this_random_address);
5471 hash_set (random_hash, this_random_address, 1);
5473 hash_free (random_hash);
5474 v4_dst_address.as_u32 = random_vector[0];
5479 /* Turn on async mode */
5480 vam->async_mode = 1;
5481 vam->async_errors = 0;
5482 before = vat_time_now (vam);
5485 for (j = 0; j < count; j++)
5487 /* Construct the API message */
5488 M (IP_ADD_DEL_ROUTE, ip_add_del_route);
5490 mp->next_hop_sw_if_index = ntohl (sw_if_index);
5491 mp->vrf_id = ntohl (vrf_id);
5492 if (resolve_attempts > 0)
5494 mp->resolve_attempts = ntohl (resolve_attempts);
5495 mp->resolve_if_needed = 1;
5497 mp->create_vrf_if_needed = create_vrf_if_needed;
5499 mp->is_add = is_add;
5500 mp->is_drop = is_drop;
5501 mp->is_ipv6 = is_ipv6;
5502 mp->is_local = is_local;
5503 mp->is_classify = is_classify;
5504 mp->is_multipath = is_multipath;
5505 mp->is_resolve_host = resolve_host;
5506 mp->is_resolve_attached = resolve_attached;
5507 mp->not_last = not_last;
5508 mp->next_hop_weight = next_hop_weight;
5509 mp->dst_address_length = dst_address_length;
5510 mp->lookup_in_vrf = ntohl (lookup_in_vrf);
5511 mp->classify_table_index = ntohl (classify_table_index);
5515 clib_memcpy (mp->dst_address, &v6_dst_address,
5516 sizeof (v6_dst_address));
5518 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
5519 sizeof (v6_next_hop_address));
5520 increment_v6_address (&v6_dst_address);
5524 clib_memcpy (mp->dst_address, &v4_dst_address,
5525 sizeof (v4_dst_address));
5527 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
5528 sizeof (v4_next_hop_address));
5530 v4_dst_address.as_u32 = random_vector[j + 1];
5532 increment_v4_address (&v4_dst_address);
5538 /* When testing multiple add/del ops, use a control-ping to sync */
5541 vl_api_control_ping_t *mp;
5544 /* Shut off async mode */
5545 vam->async_mode = 0;
5547 M (CONTROL_PING, control_ping);
5550 timeout = vat_time_now (vam) + 1.0;
5551 while (vat_time_now (vam) < timeout)
5552 if (vam->result_ready == 1)
5557 if (vam->retval == -99)
5558 errmsg ("timeout\n");
5560 if (vam->async_errors > 0)
5562 errmsg ("%d asynchronous errors\n", vam->async_errors);
5565 vam->async_errors = 0;
5566 after = vat_time_now (vam);
5568 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
5569 count, after - before, count / (after - before));
5573 /* Wait for a reply... */
5577 /* Return the good/bad news */
5578 return (vam->retval);
5582 api_proxy_arp_add_del (vat_main_t * vam)
5584 unformat_input_t *i = vam->input;
5585 vl_api_proxy_arp_add_del_t *mp;
5589 ip4_address_t lo, hi;
5592 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5594 if (unformat (i, "vrf %d", &vrf_id))
5596 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
5597 unformat_ip4_address, &hi))
5599 else if (unformat (i, "del"))
5603 clib_warning ("parse error '%U'", format_unformat_error, i);
5610 errmsg ("address range not set\n");
5614 M (PROXY_ARP_ADD_DEL, proxy_arp_add_del);
5616 mp->vrf_id = ntohl (vrf_id);
5617 mp->is_add = is_add;
5618 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
5619 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
5628 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
5630 unformat_input_t *i = vam->input;
5631 vl_api_proxy_arp_intfc_enable_disable_t *mp;
5635 u8 sw_if_index_set = 0;
5637 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5639 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5640 sw_if_index_set = 1;
5641 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5642 sw_if_index_set = 1;
5643 else if (unformat (i, "enable"))
5645 else if (unformat (i, "disable"))
5649 clib_warning ("parse error '%U'", format_unformat_error, i);
5654 if (sw_if_index_set == 0)
5656 errmsg ("missing interface name or sw_if_index\n");
5660 M (PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable);
5662 mp->sw_if_index = ntohl (sw_if_index);
5663 mp->enable_disable = enable;
5672 api_mpls_add_del_decap (vat_main_t * vam)
5674 unformat_input_t *i = vam->input;
5675 vl_api_mpls_add_del_decap_t *mp;
5684 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5686 if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
5688 else if (unformat (i, "tx_vrf_id %d", &tx_vrf_id))
5690 else if (unformat (i, "label %d", &label))
5692 else if (unformat (i, "next-index %d", &next_index))
5694 else if (unformat (i, "del"))
5696 else if (unformat (i, "s-bit-clear"))
5700 clib_warning ("parse error '%U'", format_unformat_error, i);
5705 M (MPLS_ADD_DEL_DECAP, mpls_add_del_decap);
5707 mp->rx_vrf_id = ntohl (rx_vrf_id);
5708 mp->tx_vrf_id = ntohl (tx_vrf_id);
5709 mp->label = ntohl (label);
5710 mp->next_index = ntohl (next_index);
5712 mp->is_add = is_add;
5721 api_mpls_add_del_encap (vat_main_t * vam)
5723 unformat_input_t *i = vam->input;
5724 vl_api_mpls_add_del_encap_t *mp;
5729 ip4_address_t dst_address;
5732 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5734 if (unformat (i, "vrf %d", &vrf_id))
5736 else if (unformat (i, "label %d", &label))
5737 vec_add1 (labels, ntohl (label));
5738 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
5740 else if (unformat (i, "del"))
5744 clib_warning ("parse error '%U'", format_unformat_error, i);
5749 if (vec_len (labels) == 0)
5751 errmsg ("missing encap label stack\n");
5755 M2 (MPLS_ADD_DEL_ENCAP, mpls_add_del_encap,
5756 sizeof (u32) * vec_len (labels));
5758 mp->vrf_id = ntohl (vrf_id);
5759 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
5760 mp->is_add = is_add;
5761 mp->nlabels = vec_len (labels);
5762 clib_memcpy (mp->labels, labels, sizeof (u32) * mp->nlabels);
5773 api_mpls_gre_add_del_tunnel (vat_main_t * vam)
5775 unformat_input_t *i = vam->input;
5776 vl_api_mpls_gre_add_del_tunnel_t *mp;
5778 u32 inner_vrf_id = 0;
5779 u32 outer_vrf_id = 0;
5780 ip4_address_t src_address;
5781 ip4_address_t dst_address;
5782 ip4_address_t intfc_address;
5784 u8 intfc_address_length = 0;
5788 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5790 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
5792 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
5794 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
5796 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
5798 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
5799 &intfc_address, &tmp))
5800 intfc_address_length = tmp;
5801 else if (unformat (i, "l2-only"))
5803 else if (unformat (i, "del"))
5807 clib_warning ("parse error '%U'", format_unformat_error, i);
5812 M (MPLS_GRE_ADD_DEL_TUNNEL, mpls_gre_add_del_tunnel);
5814 mp->inner_vrf_id = ntohl (inner_vrf_id);
5815 mp->outer_vrf_id = ntohl (outer_vrf_id);
5816 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
5817 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
5818 clib_memcpy (mp->intfc_address, &intfc_address, sizeof (intfc_address));
5819 mp->intfc_address_length = intfc_address_length;
5820 mp->l2_only = l2_only;
5821 mp->is_add = is_add;
5830 api_mpls_ethernet_add_del_tunnel (vat_main_t * vam)
5832 unformat_input_t *i = vam->input;
5833 vl_api_mpls_ethernet_add_del_tunnel_t *mp;
5835 u32 inner_vrf_id = 0;
5836 ip4_address_t intfc_address;
5837 u8 dst_mac_address[6];
5840 u8 intfc_address_length = 0;
5844 int tx_sw_if_index_set = 0;
5846 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5848 if (unformat (i, "vrf %d", &inner_vrf_id))
5850 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
5851 &intfc_address, &tmp))
5852 intfc_address_length = tmp;
5853 else if (unformat (i, "%U", unformat_sw_if_index, vam, &tx_sw_if_index))
5854 tx_sw_if_index_set = 1;
5855 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5856 tx_sw_if_index_set = 1;
5857 else if (unformat (i, "dst %U", unformat_ethernet_address,
5860 else if (unformat (i, "l2-only"))
5862 else if (unformat (i, "del"))
5866 clib_warning ("parse error '%U'", format_unformat_error, i);
5873 errmsg ("dst (mac address) not set\n");
5876 if (!tx_sw_if_index_set)
5878 errmsg ("tx-intfc not set\n");
5882 M (MPLS_ETHERNET_ADD_DEL_TUNNEL, mpls_ethernet_add_del_tunnel);
5884 mp->vrf_id = ntohl (inner_vrf_id);
5885 clib_memcpy (mp->adj_address, &intfc_address, sizeof (intfc_address));
5886 mp->adj_address_length = intfc_address_length;
5887 clib_memcpy (mp->dst_mac_address, dst_mac_address,
5888 sizeof (dst_mac_address));
5889 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
5890 mp->l2_only = l2_only;
5891 mp->is_add = is_add;
5900 api_mpls_ethernet_add_del_tunnel_2 (vat_main_t * vam)
5902 unformat_input_t *i = vam->input;
5903 vl_api_mpls_ethernet_add_del_tunnel_2_t *mp;
5905 u32 inner_vrf_id = 0;
5906 u32 outer_vrf_id = 0;
5907 ip4_address_t adj_address;
5908 int adj_address_set = 0;
5909 ip4_address_t next_hop_address;
5910 int next_hop_address_set = 0;
5912 u8 adj_address_length = 0;
5915 u32 resolve_attempts = 5;
5916 u8 resolve_if_needed = 1;
5918 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5920 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
5922 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
5924 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
5925 &adj_address, &tmp))
5927 adj_address_length = tmp;
5928 adj_address_set = 1;
5930 else if (unformat (i, "next-hop %U", unformat_ip4_address,
5932 next_hop_address_set = 1;
5933 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
5935 else if (unformat (i, "resolve-if-needed %d", &tmp))
5936 resolve_if_needed = tmp;
5937 else if (unformat (i, "l2-only"))
5939 else if (unformat (i, "del"))
5943 clib_warning ("parse error '%U'", format_unformat_error, i);
5948 if (!adj_address_set)
5950 errmsg ("adjacency address/mask not set\n");
5953 if (!next_hop_address_set)
5955 errmsg ("ip4 next hop address (in outer fib) not set\n");
5959 M (MPLS_ETHERNET_ADD_DEL_TUNNEL_2, mpls_ethernet_add_del_tunnel_2);
5961 mp->inner_vrf_id = ntohl (inner_vrf_id);
5962 mp->outer_vrf_id = ntohl (outer_vrf_id);
5963 mp->resolve_attempts = ntohl (resolve_attempts);
5964 mp->resolve_if_needed = resolve_if_needed;
5965 mp->is_add = is_add;
5966 mp->l2_only = l2_only;
5967 clib_memcpy (mp->adj_address, &adj_address, sizeof (adj_address));
5968 mp->adj_address_length = adj_address_length;
5969 clib_memcpy (mp->next_hop_ip4_address_in_outer_vrf, &next_hop_address,
5970 sizeof (next_hop_address));
5979 api_sw_interface_set_unnumbered (vat_main_t * vam)
5981 unformat_input_t *i = vam->input;
5982 vl_api_sw_interface_set_unnumbered_t *mp;
5985 u32 unnum_sw_index = ~0;
5987 u8 sw_if_index_set = 0;
5989 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5991 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5992 sw_if_index_set = 1;
5993 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5994 sw_if_index_set = 1;
5995 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
5997 else if (unformat (i, "del"))
6001 clib_warning ("parse error '%U'", format_unformat_error, i);
6006 if (sw_if_index_set == 0)
6008 errmsg ("missing interface name or sw_if_index\n");
6012 M (SW_INTERFACE_SET_UNNUMBERED, sw_interface_set_unnumbered);
6014 mp->sw_if_index = ntohl (sw_if_index);
6015 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
6016 mp->is_add = is_add;
6025 api_ip_neighbor_add_del (vat_main_t * vam)
6027 unformat_input_t *i = vam->input;
6028 vl_api_ip_neighbor_add_del_t *mp;
6031 u8 sw_if_index_set = 0;
6037 u8 v4_address_set = 0;
6038 u8 v6_address_set = 0;
6039 ip4_address_t v4address;
6040 ip6_address_t v6address;
6042 memset (mac_address, 0, sizeof (mac_address));
6044 /* Parse args required to build the message */
6045 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6047 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6051 else if (unformat (i, "del"))
6053 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6054 sw_if_index_set = 1;
6055 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6056 sw_if_index_set = 1;
6057 else if (unformat (i, "is_static"))
6059 else if (unformat (i, "vrf %d", &vrf_id))
6061 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
6063 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
6067 clib_warning ("parse error '%U'", format_unformat_error, i);
6072 if (sw_if_index_set == 0)
6074 errmsg ("missing interface name or sw_if_index\n");
6077 if (v4_address_set && v6_address_set)
6079 errmsg ("both v4 and v6 addresses set\n");
6082 if (!v4_address_set && !v6_address_set)
6084 errmsg ("no address set\n");
6088 /* Construct the API message */
6089 M (IP_NEIGHBOR_ADD_DEL, ip_neighbor_add_del);
6091 mp->sw_if_index = ntohl (sw_if_index);
6092 mp->is_add = is_add;
6093 mp->vrf_id = ntohl (vrf_id);
6094 mp->is_static = is_static;
6096 clib_memcpy (mp->mac_address, mac_address, 6);
6100 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
6104 /* mp->is_ipv6 = 0; via memset in M macro above */
6105 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
6111 /* Wait for a reply, return good/bad news */
6119 api_reset_vrf (vat_main_t * vam)
6121 unformat_input_t *i = vam->input;
6122 vl_api_reset_vrf_t *mp;
6128 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6130 if (unformat (i, "vrf %d", &vrf_id))
6132 else if (unformat (i, "ipv6"))
6136 clib_warning ("parse error '%U'", format_unformat_error, i);
6141 if (vrf_id_set == 0)
6143 errmsg ("missing vrf id\n");
6147 M (RESET_VRF, reset_vrf);
6149 mp->vrf_id = ntohl (vrf_id);
6150 mp->is_ipv6 = is_ipv6;
6159 api_create_vlan_subif (vat_main_t * vam)
6161 unformat_input_t *i = vam->input;
6162 vl_api_create_vlan_subif_t *mp;
6165 u8 sw_if_index_set = 0;
6169 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6171 if (unformat (i, "sw_if_index %d", &sw_if_index))
6172 sw_if_index_set = 1;
6173 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6174 sw_if_index_set = 1;
6175 else if (unformat (i, "vlan %d", &vlan_id))
6179 clib_warning ("parse error '%U'", format_unformat_error, i);
6184 if (sw_if_index_set == 0)
6186 errmsg ("missing interface name or sw_if_index\n");
6190 if (vlan_id_set == 0)
6192 errmsg ("missing vlan_id\n");
6195 M (CREATE_VLAN_SUBIF, create_vlan_subif);
6197 mp->sw_if_index = ntohl (sw_if_index);
6198 mp->vlan_id = ntohl (vlan_id);
6206 #define foreach_create_subif_bit \
6213 _(outer_vlan_id_any) \
6214 _(inner_vlan_id_any)
6217 api_create_subif (vat_main_t * vam)
6219 unformat_input_t *i = vam->input;
6220 vl_api_create_subif_t *mp;
6223 u8 sw_if_index_set = 0;
6230 u32 exact_match = 0;
6231 u32 default_sub = 0;
6232 u32 outer_vlan_id_any = 0;
6233 u32 inner_vlan_id_any = 0;
6235 u16 outer_vlan_id = 0;
6236 u16 inner_vlan_id = 0;
6238 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6240 if (unformat (i, "sw_if_index %d", &sw_if_index))
6241 sw_if_index_set = 1;
6242 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6243 sw_if_index_set = 1;
6244 else if (unformat (i, "sub_id %d", &sub_id))
6246 else if (unformat (i, "outer_vlan_id %d", &tmp))
6247 outer_vlan_id = tmp;
6248 else if (unformat (i, "inner_vlan_id %d", &tmp))
6249 inner_vlan_id = tmp;
6251 #define _(a) else if (unformat (i, #a)) a = 1 ;
6252 foreach_create_subif_bit
6256 clib_warning ("parse error '%U'", format_unformat_error, i);
6261 if (sw_if_index_set == 0)
6263 errmsg ("missing interface name or sw_if_index\n");
6267 if (sub_id_set == 0)
6269 errmsg ("missing sub_id\n");
6272 M (CREATE_SUBIF, create_subif);
6274 mp->sw_if_index = ntohl (sw_if_index);
6275 mp->sub_id = ntohl (sub_id);
6277 #define _(a) mp->a = a;
6278 foreach_create_subif_bit;
6281 mp->outer_vlan_id = ntohs (outer_vlan_id);
6282 mp->inner_vlan_id = ntohs (inner_vlan_id);
6291 api_oam_add_del (vat_main_t * vam)
6293 unformat_input_t *i = vam->input;
6294 vl_api_oam_add_del_t *mp;
6298 ip4_address_t src, dst;
6302 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6304 if (unformat (i, "vrf %d", &vrf_id))
6306 else if (unformat (i, "src %U", unformat_ip4_address, &src))
6308 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
6310 else if (unformat (i, "del"))
6314 clib_warning ("parse error '%U'", format_unformat_error, i);
6321 errmsg ("missing src addr\n");
6327 errmsg ("missing dst addr\n");
6331 M (OAM_ADD_DEL, oam_add_del);
6333 mp->vrf_id = ntohl (vrf_id);
6334 mp->is_add = is_add;
6335 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
6336 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
6345 api_reset_fib (vat_main_t * vam)
6347 unformat_input_t *i = vam->input;
6348 vl_api_reset_fib_t *mp;
6354 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6356 if (unformat (i, "vrf %d", &vrf_id))
6358 else if (unformat (i, "ipv6"))
6362 clib_warning ("parse error '%U'", format_unformat_error, i);
6367 if (vrf_id_set == 0)
6369 errmsg ("missing vrf id\n");
6373 M (RESET_FIB, reset_fib);
6375 mp->vrf_id = ntohl (vrf_id);
6376 mp->is_ipv6 = is_ipv6;
6385 api_dhcp_proxy_config (vat_main_t * vam)
6387 unformat_input_t *i = vam->input;
6388 vl_api_dhcp_proxy_config_t *mp;
6393 u8 v4_address_set = 0;
6394 u8 v6_address_set = 0;
6395 ip4_address_t v4address;
6396 ip6_address_t v6address;
6397 u8 v4_src_address_set = 0;
6398 u8 v6_src_address_set = 0;
6399 ip4_address_t v4srcaddress;
6400 ip6_address_t v6srcaddress;
6402 /* Parse args required to build the message */
6403 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6405 if (unformat (i, "del"))
6407 else if (unformat (i, "vrf %d", &vrf_id))
6409 else if (unformat (i, "insert-cid %d", &insert_cid))
6411 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
6413 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
6415 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
6416 v4_src_address_set = 1;
6417 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
6418 v6_src_address_set = 1;
6423 if (v4_address_set && v6_address_set)
6425 errmsg ("both v4 and v6 server addresses set\n");
6428 if (!v4_address_set && !v6_address_set)
6430 errmsg ("no server addresses set\n");
6434 if (v4_src_address_set && v6_src_address_set)
6436 errmsg ("both v4 and v6 src addresses set\n");
6439 if (!v4_src_address_set && !v6_src_address_set)
6441 errmsg ("no src addresses set\n");
6445 if (!(v4_src_address_set && v4_address_set) &&
6446 !(v6_src_address_set && v6_address_set))
6448 errmsg ("no matching server and src addresses set\n");
6452 /* Construct the API message */
6453 M (DHCP_PROXY_CONFIG, dhcp_proxy_config);
6455 mp->insert_circuit_id = insert_cid;
6456 mp->is_add = is_add;
6457 mp->vrf_id = ntohl (vrf_id);
6461 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
6462 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
6466 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
6467 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
6473 /* Wait for a reply, return good/bad news */
6480 api_dhcp_proxy_config_2 (vat_main_t * vam)
6482 unformat_input_t *i = vam->input;
6483 vl_api_dhcp_proxy_config_2_t *mp;
6486 u32 server_vrf_id = 0;
6489 u8 v4_address_set = 0;
6490 u8 v6_address_set = 0;
6491 ip4_address_t v4address;
6492 ip6_address_t v6address;
6493 u8 v4_src_address_set = 0;
6494 u8 v6_src_address_set = 0;
6495 ip4_address_t v4srcaddress;
6496 ip6_address_t v6srcaddress;
6498 /* Parse args required to build the message */
6499 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6501 if (unformat (i, "del"))
6503 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
6505 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
6507 else if (unformat (i, "insert-cid %d", &insert_cid))
6509 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
6511 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
6513 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
6514 v4_src_address_set = 1;
6515 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
6516 v6_src_address_set = 1;
6521 if (v4_address_set && v6_address_set)
6523 errmsg ("both v4 and v6 server addresses set\n");
6526 if (!v4_address_set && !v6_address_set)
6528 errmsg ("no server addresses set\n");
6532 if (v4_src_address_set && v6_src_address_set)
6534 errmsg ("both v4 and v6 src addresses set\n");
6537 if (!v4_src_address_set && !v6_src_address_set)
6539 errmsg ("no src addresses set\n");
6543 if (!(v4_src_address_set && v4_address_set) &&
6544 !(v6_src_address_set && v6_address_set))
6546 errmsg ("no matching server and src addresses set\n");
6550 /* Construct the API message */
6551 M (DHCP_PROXY_CONFIG_2, dhcp_proxy_config_2);
6553 mp->insert_circuit_id = insert_cid;
6554 mp->is_add = is_add;
6555 mp->rx_vrf_id = ntohl (rx_vrf_id);
6556 mp->server_vrf_id = ntohl (server_vrf_id);
6560 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
6561 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
6565 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
6566 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
6572 /* Wait for a reply, return good/bad news */
6579 api_dhcp_proxy_set_vss (vat_main_t * vam)
6581 unformat_input_t *i = vam->input;
6582 vl_api_dhcp_proxy_set_vss_t *mp;
6593 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6595 if (unformat (i, "tbl_id %d", &tbl_id))
6597 if (unformat (i, "fib_id %d", &fib_id))
6599 if (unformat (i, "oui %d", &oui))
6601 else if (unformat (i, "ipv6"))
6603 else if (unformat (i, "del"))
6607 clib_warning ("parse error '%U'", format_unformat_error, i);
6612 if (tbl_id_set == 0)
6614 errmsg ("missing tbl id\n");
6618 if (fib_id_set == 0)
6620 errmsg ("missing fib id\n");
6625 errmsg ("missing oui\n");
6629 M (DHCP_PROXY_SET_VSS, dhcp_proxy_set_vss);
6630 mp->tbl_id = ntohl (tbl_id);
6631 mp->fib_id = ntohl (fib_id);
6632 mp->oui = ntohl (oui);
6633 mp->is_ipv6 = is_ipv6;
6634 mp->is_add = is_add;
6643 api_dhcp_client_config (vat_main_t * vam)
6645 unformat_input_t *i = vam->input;
6646 vl_api_dhcp_client_config_t *mp;
6649 u8 sw_if_index_set = 0;
6652 u8 disable_event = 0;
6654 /* Parse args required to build the message */
6655 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6657 if (unformat (i, "del"))
6659 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6660 sw_if_index_set = 1;
6661 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6662 sw_if_index_set = 1;
6663 else if (unformat (i, "hostname %s", &hostname))
6665 else if (unformat (i, "disable_event"))
6671 if (sw_if_index_set == 0)
6673 errmsg ("missing interface name or sw_if_index\n");
6677 if (vec_len (hostname) > 63)
6679 errmsg ("hostname too long\n");
6681 vec_add1 (hostname, 0);
6683 /* Construct the API message */
6684 M (DHCP_CLIENT_CONFIG, dhcp_client_config);
6686 mp->sw_if_index = ntohl (sw_if_index);
6687 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
6688 vec_free (hostname);
6689 mp->is_add = is_add;
6690 mp->want_dhcp_event = disable_event ? 0 : 1;
6691 mp->pid = getpid ();
6696 /* Wait for a reply, return good/bad news */
6703 api_set_ip_flow_hash (vat_main_t * vam)
6705 unformat_input_t *i = vam->input;
6706 vl_api_set_ip_flow_hash_t *mp;
6718 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6720 if (unformat (i, "vrf %d", &vrf_id))
6722 else if (unformat (i, "ipv6"))
6724 else if (unformat (i, "src"))
6726 else if (unformat (i, "dst"))
6728 else if (unformat (i, "sport"))
6730 else if (unformat (i, "dport"))
6732 else if (unformat (i, "proto"))
6734 else if (unformat (i, "reverse"))
6739 clib_warning ("parse error '%U'", format_unformat_error, i);
6744 if (vrf_id_set == 0)
6746 errmsg ("missing vrf id\n");
6750 M (SET_IP_FLOW_HASH, set_ip_flow_hash);
6756 mp->reverse = reverse;
6757 mp->vrf_id = ntohl (vrf_id);
6758 mp->is_ipv6 = is_ipv6;
6767 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
6769 unformat_input_t *i = vam->input;
6770 vl_api_sw_interface_ip6_enable_disable_t *mp;
6773 u8 sw_if_index_set = 0;
6776 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6778 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6779 sw_if_index_set = 1;
6780 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6781 sw_if_index_set = 1;
6782 else if (unformat (i, "enable"))
6784 else if (unformat (i, "disable"))
6788 clib_warning ("parse error '%U'", format_unformat_error, i);
6793 if (sw_if_index_set == 0)
6795 errmsg ("missing interface name or sw_if_index\n");
6799 M (SW_INTERFACE_IP6_ENABLE_DISABLE, sw_interface_ip6_enable_disable);
6801 mp->sw_if_index = ntohl (sw_if_index);
6802 mp->enable = enable;
6811 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
6813 unformat_input_t *i = vam->input;
6814 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
6817 u8 sw_if_index_set = 0;
6818 u32 address_length = 0;
6819 u8 v6_address_set = 0;
6820 ip6_address_t v6address;
6822 /* Parse args required to build the message */
6823 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6825 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6826 sw_if_index_set = 1;
6827 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6828 sw_if_index_set = 1;
6829 else if (unformat (i, "%U/%d",
6830 unformat_ip6_address, &v6address, &address_length))
6836 if (sw_if_index_set == 0)
6838 errmsg ("missing interface name or sw_if_index\n");
6841 if (!v6_address_set)
6843 errmsg ("no address set\n");
6847 /* Construct the API message */
6848 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS,
6849 sw_interface_ip6_set_link_local_address);
6851 mp->sw_if_index = ntohl (sw_if_index);
6852 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6853 mp->address_length = address_length;
6858 /* Wait for a reply, return good/bad news */
6867 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
6869 unformat_input_t *i = vam->input;
6870 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
6873 u8 sw_if_index_set = 0;
6874 u32 address_length = 0;
6875 u8 v6_address_set = 0;
6876 ip6_address_t v6address;
6878 u8 no_advertise = 0;
6880 u8 no_autoconfig = 0;
6883 u32 val_lifetime = 0;
6884 u32 pref_lifetime = 0;
6886 /* Parse args required to build the message */
6887 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6889 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6890 sw_if_index_set = 1;
6891 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6892 sw_if_index_set = 1;
6893 else if (unformat (i, "%U/%d",
6894 unformat_ip6_address, &v6address, &address_length))
6896 else if (unformat (i, "val_life %d", &val_lifetime))
6898 else if (unformat (i, "pref_life %d", &pref_lifetime))
6900 else if (unformat (i, "def"))
6902 else if (unformat (i, "noadv"))
6904 else if (unformat (i, "offl"))
6906 else if (unformat (i, "noauto"))
6908 else if (unformat (i, "nolink"))
6910 else if (unformat (i, "isno"))
6914 clib_warning ("parse error '%U'", format_unformat_error, i);
6919 if (sw_if_index_set == 0)
6921 errmsg ("missing interface name or sw_if_index\n");
6924 if (!v6_address_set)
6926 errmsg ("no address set\n");
6930 /* Construct the API message */
6931 M (SW_INTERFACE_IP6ND_RA_PREFIX, sw_interface_ip6nd_ra_prefix);
6933 mp->sw_if_index = ntohl (sw_if_index);
6934 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6935 mp->address_length = address_length;
6936 mp->use_default = use_default;
6937 mp->no_advertise = no_advertise;
6938 mp->off_link = off_link;
6939 mp->no_autoconfig = no_autoconfig;
6940 mp->no_onlink = no_onlink;
6942 mp->val_lifetime = ntohl (val_lifetime);
6943 mp->pref_lifetime = ntohl (pref_lifetime);
6948 /* Wait for a reply, return good/bad news */
6956 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
6958 unformat_input_t *i = vam->input;
6959 vl_api_sw_interface_ip6nd_ra_config_t *mp;
6962 u8 sw_if_index_set = 0;
6967 u8 send_unicast = 0;
6970 u8 default_router = 0;
6971 u32 max_interval = 0;
6972 u32 min_interval = 0;
6974 u32 initial_count = 0;
6975 u32 initial_interval = 0;
6978 /* Parse args required to build the message */
6979 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6981 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6982 sw_if_index_set = 1;
6983 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6984 sw_if_index_set = 1;
6985 else if (unformat (i, "maxint %d", &max_interval))
6987 else if (unformat (i, "minint %d", &min_interval))
6989 else if (unformat (i, "life %d", &lifetime))
6991 else if (unformat (i, "count %d", &initial_count))
6993 else if (unformat (i, "interval %d", &initial_interval))
6995 else if (unformat (i, "suppress") || unformat (i, "surpress"))
6997 else if (unformat (i, "managed"))
6999 else if (unformat (i, "other"))
7001 else if (unformat (i, "ll"))
7003 else if (unformat (i, "send"))
7005 else if (unformat (i, "cease"))
7007 else if (unformat (i, "isno"))
7009 else if (unformat (i, "def"))
7013 clib_warning ("parse error '%U'", format_unformat_error, i);
7018 if (sw_if_index_set == 0)
7020 errmsg ("missing interface name or sw_if_index\n");
7024 /* Construct the API message */
7025 M (SW_INTERFACE_IP6ND_RA_CONFIG, sw_interface_ip6nd_ra_config);
7027 mp->sw_if_index = ntohl (sw_if_index);
7028 mp->max_interval = ntohl (max_interval);
7029 mp->min_interval = ntohl (min_interval);
7030 mp->lifetime = ntohl (lifetime);
7031 mp->initial_count = ntohl (initial_count);
7032 mp->initial_interval = ntohl (initial_interval);
7033 mp->suppress = suppress;
7034 mp->managed = managed;
7036 mp->ll_option = ll_option;
7037 mp->send_unicast = send_unicast;
7040 mp->default_router = default_router;
7045 /* Wait for a reply, return good/bad news */
7053 api_set_arp_neighbor_limit (vat_main_t * vam)
7055 unformat_input_t *i = vam->input;
7056 vl_api_set_arp_neighbor_limit_t *mp;
7062 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7064 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
7066 else if (unformat (i, "ipv6"))
7070 clib_warning ("parse error '%U'", format_unformat_error, i);
7077 errmsg ("missing limit value\n");
7081 M (SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit);
7083 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
7084 mp->is_ipv6 = is_ipv6;
7093 api_l2_patch_add_del (vat_main_t * vam)
7095 unformat_input_t *i = vam->input;
7096 vl_api_l2_patch_add_del_t *mp;
7099 u8 rx_sw_if_index_set = 0;
7101 u8 tx_sw_if_index_set = 0;
7104 /* Parse args required to build the message */
7105 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7107 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
7108 rx_sw_if_index_set = 1;
7109 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
7110 tx_sw_if_index_set = 1;
7111 else if (unformat (i, "rx"))
7113 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7115 if (unformat (i, "%U", unformat_sw_if_index, vam,
7117 rx_sw_if_index_set = 1;
7122 else if (unformat (i, "tx"))
7124 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7126 if (unformat (i, "%U", unformat_sw_if_index, vam,
7128 tx_sw_if_index_set = 1;
7133 else if (unformat (i, "del"))
7139 if (rx_sw_if_index_set == 0)
7141 errmsg ("missing rx interface name or rx_sw_if_index\n");
7145 if (tx_sw_if_index_set == 0)
7147 errmsg ("missing tx interface name or tx_sw_if_index\n");
7151 M (L2_PATCH_ADD_DEL, l2_patch_add_del);
7153 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
7154 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
7155 mp->is_add = is_add;
7164 api_ioam_enable (vat_main_t * vam)
7166 unformat_input_t *input = vam->input;
7167 vl_api_ioam_enable_t *mp;
7170 int has_trace_option = 0;
7171 int has_pow_option = 0;
7172 int has_ppc_option = 0;
7174 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7176 if (unformat (input, "trace"))
7177 has_trace_option = 1;
7178 else if (unformat (input, "pow"))
7180 else if (unformat (input, "ppc encap"))
7181 has_ppc_option = PPC_ENCAP;
7182 else if (unformat (input, "ppc decap"))
7183 has_ppc_option = PPC_DECAP;
7184 else if (unformat (input, "ppc none"))
7185 has_ppc_option = PPC_NONE;
7189 M (IOAM_ENABLE, ioam_enable);
7190 mp->id = htons (id);
7191 mp->trace_ppc = has_ppc_option;
7192 mp->pow_enable = has_pow_option;
7193 mp->trace_enable = has_trace_option;
7204 api_ioam_disable (vat_main_t * vam)
7206 vl_api_ioam_disable_t *mp;
7209 M (IOAM_DISABLE, ioam_disable);
7216 api_sr_tunnel_add_del (vat_main_t * vam)
7218 unformat_input_t *i = vam->input;
7219 vl_api_sr_tunnel_add_del_t *mp;
7223 ip6_address_t src_address;
7224 int src_address_set = 0;
7225 ip6_address_t dst_address;
7227 int dst_address_set = 0;
7229 u32 rx_table_id = 0;
7230 u32 tx_table_id = 0;
7231 ip6_address_t *segments = 0;
7232 ip6_address_t *this_seg;
7233 ip6_address_t *tags = 0;
7234 ip6_address_t *this_tag;
7235 ip6_address_t next_address, tag;
7237 u8 *policy_name = 0;
7239 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7241 if (unformat (i, "del"))
7243 else if (unformat (i, "name %s", &name))
7245 else if (unformat (i, "policy %s", &policy_name))
7247 else if (unformat (i, "rx_fib_id %d", &rx_table_id))
7249 else if (unformat (i, "tx_fib_id %d", &tx_table_id))
7251 else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
7252 src_address_set = 1;
7253 else if (unformat (i, "dst %U/%d",
7254 unformat_ip6_address, &dst_address, &dst_mask_width))
7255 dst_address_set = 1;
7256 else if (unformat (i, "next %U", unformat_ip6_address, &next_address))
7258 vec_add2 (segments, this_seg, 1);
7259 clib_memcpy (this_seg->as_u8, next_address.as_u8,
7260 sizeof (*this_seg));
7262 else if (unformat (i, "tag %U", unformat_ip6_address, &tag))
7264 vec_add2 (tags, this_tag, 1);
7265 clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
7267 else if (unformat (i, "clean"))
7268 flags |= IP6_SR_HEADER_FLAG_CLEANUP;
7269 else if (unformat (i, "protected"))
7270 flags |= IP6_SR_HEADER_FLAG_PROTECTED;
7271 else if (unformat (i, "InPE %d", &pl_index))
7273 if (pl_index <= 0 || pl_index > 4)
7275 pl_index_range_error:
7276 errmsg ("pl index %d out of range\n", pl_index);
7280 IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE << (3 * (pl_index - 1));
7282 else if (unformat (i, "EgPE %d", &pl_index))
7284 if (pl_index <= 0 || pl_index > 4)
7285 goto pl_index_range_error;
7287 IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE << (3 * (pl_index - 1));
7289 else if (unformat (i, "OrgSrc %d", &pl_index))
7291 if (pl_index <= 0 || pl_index > 4)
7292 goto pl_index_range_error;
7294 IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3 * (pl_index - 1));
7300 if (!src_address_set)
7302 errmsg ("src address required\n");
7306 if (!dst_address_set)
7308 errmsg ("dst address required\n");
7314 errmsg ("at least one sr segment required\n");
7318 M2 (SR_TUNNEL_ADD_DEL, sr_tunnel_add_del,
7319 vec_len (segments) * sizeof (ip6_address_t)
7320 + vec_len (tags) * sizeof (ip6_address_t));
7322 clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
7323 clib_memcpy (mp->dst_address, &dst_address, sizeof (mp->dst_address));
7324 mp->dst_mask_width = dst_mask_width;
7325 mp->flags_net_byte_order = clib_host_to_net_u16 (flags);
7326 mp->n_segments = vec_len (segments);
7327 mp->n_tags = vec_len (tags);
7328 mp->is_add = is_del == 0;
7329 clib_memcpy (mp->segs_and_tags, segments,
7330 vec_len (segments) * sizeof (ip6_address_t));
7331 clib_memcpy (mp->segs_and_tags +
7332 vec_len (segments) * sizeof (ip6_address_t), tags,
7333 vec_len (tags) * sizeof (ip6_address_t));
7335 mp->outer_vrf_id = ntohl (rx_table_id);
7336 mp->inner_vrf_id = ntohl (tx_table_id);
7337 memcpy (mp->name, name, vec_len (name));
7338 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
7340 vec_free (segments);
7349 api_sr_policy_add_del (vat_main_t * vam)
7351 unformat_input_t *input = vam->input;
7352 vl_api_sr_policy_add_del_t *mp;
7356 u8 *tunnel_name = 0;
7357 u8 **tunnel_names = 0;
7362 int tunnel_names_length = 1; // Init to 1 to offset the #tunnel_names counter byte
7363 int tun_name_len = 0; // Different naming convention used as confusing these would be "bad" (TM)
7365 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7367 if (unformat (input, "del"))
7369 else if (unformat (input, "name %s", &name))
7371 else if (unformat (input, "tunnel %s", &tunnel_name))
7375 vec_add1 (tunnel_names, tunnel_name);
7377 - length = #bytes to store in serial vector
7378 - +1 = byte to store that length
7380 tunnel_names_length += (vec_len (tunnel_name) + 1);
7391 errmsg ("policy name required\n");
7395 if ((!tunnel_set) && (!is_del))
7397 errmsg ("tunnel name required\n");
7401 M2 (SR_POLICY_ADD_DEL, sr_policy_add_del, tunnel_names_length);
7405 mp->is_add = !is_del;
7407 memcpy (mp->name, name, vec_len (name));
7408 // Since mp->tunnel_names is of type u8[0] and not a u8 *, u8 ** needs to be serialized
7409 u8 *serial_orig = 0;
7410 vec_validate (serial_orig, tunnel_names_length);
7411 *serial_orig = vec_len (tunnel_names); // Store the number of tunnels as length in first byte of serialized vector
7412 serial_orig += 1; // Move along one byte to store the length of first tunnel_name
7414 for (j = 0; j < vec_len (tunnel_names); j++)
7416 tun_name_len = vec_len (tunnel_names[j]);
7417 *serial_orig = tun_name_len; // Store length of tunnel name in first byte of Length/Value pair
7418 serial_orig += 1; // Move along one byte to store the actual tunnel name
7419 memcpy (serial_orig, tunnel_names[j], tun_name_len);
7420 serial_orig += tun_name_len; // Advance past the copy
7422 memcpy (mp->tunnel_names, serial_orig - tunnel_names_length, tunnel_names_length); // Regress serial_orig to head then copy fwd
7424 vec_free (tunnel_names);
7425 vec_free (tunnel_name);
7433 api_sr_multicast_map_add_del (vat_main_t * vam)
7435 unformat_input_t *input = vam->input;
7436 vl_api_sr_multicast_map_add_del_t *mp;
7439 ip6_address_t multicast_address;
7440 u8 *policy_name = 0;
7441 int multicast_address_set = 0;
7443 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7445 if (unformat (input, "del"))
7449 (input, "address %U", unformat_ip6_address, &multicast_address))
7450 multicast_address_set = 1;
7451 else if (unformat (input, "sr-policy %s", &policy_name))
7457 if (!is_del && !policy_name)
7459 errmsg ("sr-policy name required\n");
7464 if (!multicast_address_set)
7466 errmsg ("address required\n");
7470 M (SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del);
7472 mp->is_add = !is_del;
7473 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
7474 clib_memcpy (mp->multicast_address, &multicast_address,
7475 sizeof (mp->multicast_address));
7478 vec_free (policy_name);
7486 #define foreach_ip4_proto_field \
7497 unformat_ip4_mask (unformat_input_t * input, va_list * args)
7499 u8 **maskp = va_arg (*args, u8 **);
7501 u8 found_something = 0;
7504 #define _(a) u8 a=0;
7505 foreach_ip4_proto_field;
7511 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7513 if (unformat (input, "version"))
7515 else if (unformat (input, "hdr_length"))
7517 else if (unformat (input, "src"))
7519 else if (unformat (input, "dst"))
7521 else if (unformat (input, "proto"))
7524 #define _(a) else if (unformat (input, #a)) a=1;
7525 foreach_ip4_proto_field
7531 #define _(a) found_something += a;
7532 foreach_ip4_proto_field;
7535 if (found_something == 0)
7538 vec_validate (mask, sizeof (*ip) - 1);
7540 ip = (ip4_header_t *) mask;
7542 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
7543 foreach_ip4_proto_field;
7546 ip->ip_version_and_header_length = 0;
7549 ip->ip_version_and_header_length |= 0xF0;
7552 ip->ip_version_and_header_length |= 0x0F;
7558 #define foreach_ip6_proto_field \
7566 unformat_ip6_mask (unformat_input_t * input, va_list * args)
7568 u8 **maskp = va_arg (*args, u8 **);
7570 u8 found_something = 0;
7572 u32 ip_version_traffic_class_and_flow_label;
7574 #define _(a) u8 a=0;
7575 foreach_ip6_proto_field;
7578 u8 traffic_class = 0;
7581 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7583 if (unformat (input, "version"))
7585 else if (unformat (input, "traffic-class"))
7587 else if (unformat (input, "flow-label"))
7589 else if (unformat (input, "src"))
7591 else if (unformat (input, "dst"))
7593 else if (unformat (input, "proto"))
7596 #define _(a) else if (unformat (input, #a)) a=1;
7597 foreach_ip6_proto_field
7603 #define _(a) found_something += a;
7604 foreach_ip6_proto_field;
7607 if (found_something == 0)
7610 vec_validate (mask, sizeof (*ip) - 1);
7612 ip = (ip6_header_t *) mask;
7614 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
7615 foreach_ip6_proto_field;
7618 ip_version_traffic_class_and_flow_label = 0;
7621 ip_version_traffic_class_and_flow_label |= 0xF0000000;
7624 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
7627 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
7629 ip->ip_version_traffic_class_and_flow_label =
7630 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
7637 unformat_l3_mask (unformat_input_t * input, va_list * args)
7639 u8 **maskp = va_arg (*args, u8 **);
7641 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7643 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
7645 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
7654 unformat_l2_mask (unformat_input_t * input, va_list * args)
7656 u8 **maskp = va_arg (*args, u8 **);
7671 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7673 if (unformat (input, "src"))
7675 else if (unformat (input, "dst"))
7677 else if (unformat (input, "proto"))
7679 else if (unformat (input, "tag1"))
7681 else if (unformat (input, "tag2"))
7683 else if (unformat (input, "ignore-tag1"))
7685 else if (unformat (input, "ignore-tag2"))
7687 else if (unformat (input, "cos1"))
7689 else if (unformat (input, "cos2"))
7691 else if (unformat (input, "dot1q"))
7693 else if (unformat (input, "dot1ad"))
7698 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
7699 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
7702 if (tag1 || ignore_tag1 || cos1 || dot1q)
7704 if (tag2 || ignore_tag2 || cos2 || dot1ad)
7707 vec_validate (mask, len - 1);
7710 memset (mask, 0xff, 6);
7713 memset (mask + 6, 0xff, 6);
7717 /* inner vlan tag */
7726 mask[21] = mask[20] = 0xff;
7747 mask[16] = mask[17] = 0xff;
7757 mask[12] = mask[13] = 0xff;
7764 unformat_classify_mask (unformat_input_t * input, va_list * args)
7766 u8 **maskp = va_arg (*args, u8 **);
7767 u32 *skipp = va_arg (*args, u32 *);
7768 u32 *matchp = va_arg (*args, u32 *);
7775 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7777 if (unformat (input, "hex %U", unformat_hex_string, &mask))
7779 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
7781 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
7787 if (mask || l2 || l3)
7791 /* "With a free Ethernet header in every package" */
7793 vec_validate (l2, 13);
7797 vec_append (mask, l3);
7802 /* Scan forward looking for the first significant mask octet */
7803 for (i = 0; i < vec_len (mask); i++)
7807 /* compute (skip, match) params */
7808 *skipp = i / sizeof (u32x4);
7809 vec_delete (mask, *skipp * sizeof (u32x4), 0);
7811 /* Pad mask to an even multiple of the vector size */
7812 while (vec_len (mask) % sizeof (u32x4))
7815 match = vec_len (mask) / sizeof (u32x4);
7817 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
7819 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
7820 if (*tmp || *(tmp + 1))
7825 clib_warning ("BUG: match 0");
7827 _vec_len (mask) = match * sizeof (u32x4);
7838 #define foreach_l2_next \
7840 _(ethernet, ETHERNET_INPUT) \
7845 unformat_l2_next_index (unformat_input_t * input, va_list * args)
7847 u32 *miss_next_indexp = va_arg (*args, u32 *);
7852 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
7856 if (unformat (input, "%d", &tmp))
7865 *miss_next_indexp = next_index;
7869 #define foreach_ip_next \
7875 unformat_ip_next_index (unformat_input_t * input, va_list * args)
7877 u32 *miss_next_indexp = va_arg (*args, u32 *);
7882 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
7886 if (unformat (input, "%d", &tmp))
7895 *miss_next_indexp = next_index;
7899 #define foreach_acl_next \
7903 unformat_acl_next_index (unformat_input_t * input, va_list * args)
7905 u32 *miss_next_indexp = va_arg (*args, u32 *);
7910 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
7914 if (unformat (input, "permit"))
7919 else if (unformat (input, "%d", &tmp))
7928 *miss_next_indexp = next_index;
7933 unformat_policer_precolor (unformat_input_t * input, va_list * args)
7935 u32 *r = va_arg (*args, u32 *);
7937 if (unformat (input, "conform-color"))
7938 *r = POLICE_CONFORM;
7939 else if (unformat (input, "exceed-color"))
7948 api_classify_add_del_table (vat_main_t * vam)
7950 unformat_input_t *i = vam->input;
7951 vl_api_classify_add_del_table_t *mp;
7957 u32 table_index = ~0;
7958 u32 next_table_index = ~0;
7959 u32 miss_next_index = ~0;
7960 u32 memory_size = 32 << 20;
7964 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7966 if (unformat (i, "del"))
7968 else if (unformat (i, "buckets %d", &nbuckets))
7970 else if (unformat (i, "memory_size %d", &memory_size))
7972 else if (unformat (i, "skip %d", &skip))
7974 else if (unformat (i, "match %d", &match))
7976 else if (unformat (i, "table %d", &table_index))
7978 else if (unformat (i, "mask %U", unformat_classify_mask,
7979 &mask, &skip, &match))
7981 else if (unformat (i, "next-table %d", &next_table_index))
7983 else if (unformat (i, "miss-next %U", unformat_ip_next_index,
7986 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
7989 else if (unformat (i, "acl-miss-next %U", unformat_acl_next_index,
7996 if (is_add && mask == 0)
7998 errmsg ("Mask required\n");
8002 if (is_add && skip == ~0)
8004 errmsg ("skip count required\n");
8008 if (is_add && match == ~0)
8010 errmsg ("match count required\n");
8014 if (!is_add && table_index == ~0)
8016 errmsg ("table index required for delete\n");
8020 M2 (CLASSIFY_ADD_DEL_TABLE, classify_add_del_table, vec_len (mask));
8022 mp->is_add = is_add;
8023 mp->table_index = ntohl (table_index);
8024 mp->nbuckets = ntohl (nbuckets);
8025 mp->memory_size = ntohl (memory_size);
8026 mp->skip_n_vectors = ntohl (skip);
8027 mp->match_n_vectors = ntohl (match);
8028 mp->next_table_index = ntohl (next_table_index);
8029 mp->miss_next_index = ntohl (miss_next_index);
8030 clib_memcpy (mp->mask, mask, vec_len (mask));
8040 unformat_ip4_match (unformat_input_t * input, va_list * args)
8042 u8 **matchp = va_arg (*args, u8 **);
8049 int src = 0, dst = 0;
8050 ip4_address_t src_val, dst_val;
8057 int fragment_id = 0;
8058 u32 fragment_id_val;
8064 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8066 if (unformat (input, "version %d", &version_val))
8068 else if (unformat (input, "hdr_length %d", &hdr_length_val))
8070 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
8072 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
8074 else if (unformat (input, "proto %d", &proto_val))
8076 else if (unformat (input, "tos %d", &tos_val))
8078 else if (unformat (input, "length %d", &length_val))
8080 else if (unformat (input, "fragment_id %d", &fragment_id_val))
8082 else if (unformat (input, "ttl %d", &ttl_val))
8084 else if (unformat (input, "checksum %d", &checksum_val))
8090 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
8091 + ttl + checksum == 0)
8095 * Aligned because we use the real comparison functions
8097 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
8099 ip = (ip4_header_t *) match;
8101 /* These are realistically matched in practice */
8103 ip->src_address.as_u32 = src_val.as_u32;
8106 ip->dst_address.as_u32 = dst_val.as_u32;
8109 ip->protocol = proto_val;
8112 /* These are not, but they're included for completeness */
8114 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
8117 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
8123 ip->length = length_val;
8129 ip->checksum = checksum_val;
8136 unformat_ip6_match (unformat_input_t * input, va_list * args)
8138 u8 **matchp = va_arg (*args, u8 **);
8143 u8 traffic_class = 0;
8144 u32 traffic_class_val = 0;
8147 int src = 0, dst = 0;
8148 ip6_address_t src_val, dst_val;
8151 int payload_length = 0;
8152 u32 payload_length_val;
8155 u32 ip_version_traffic_class_and_flow_label;
8157 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8159 if (unformat (input, "version %d", &version_val))
8161 else if (unformat (input, "traffic_class %d", &traffic_class_val))
8163 else if (unformat (input, "flow_label %d", &flow_label_val))
8165 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
8167 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
8169 else if (unformat (input, "proto %d", &proto_val))
8171 else if (unformat (input, "payload_length %d", &payload_length_val))
8173 else if (unformat (input, "hop_limit %d", &hop_limit_val))
8179 if (version + traffic_class + flow_label + src + dst + proto +
8180 payload_length + hop_limit == 0)
8184 * Aligned because we use the real comparison functions
8186 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
8188 ip = (ip6_header_t *) match;
8191 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
8194 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
8197 ip->protocol = proto_val;
8199 ip_version_traffic_class_and_flow_label = 0;
8202 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
8205 ip_version_traffic_class_and_flow_label |=
8206 (traffic_class_val & 0xFF) << 20;
8209 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
8211 ip->ip_version_traffic_class_and_flow_label =
8212 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
8215 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
8218 ip->hop_limit = hop_limit_val;
8225 unformat_l3_match (unformat_input_t * input, va_list * args)
8227 u8 **matchp = va_arg (*args, u8 **);
8229 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8231 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
8233 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
8242 unformat_vlan_tag (unformat_input_t * input, va_list * args)
8244 u8 *tagp = va_arg (*args, u8 *);
8247 if (unformat (input, "%d", &tag))
8249 tagp[0] = (tag >> 8) & 0x0F;
8250 tagp[1] = tag & 0xFF;
8258 unformat_l2_match (unformat_input_t * input, va_list * args)
8260 u8 **matchp = va_arg (*args, u8 **);
8280 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8282 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
8285 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
8287 else if (unformat (input, "proto %U",
8288 unformat_ethernet_type_host_byte_order, &proto_val))
8290 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
8292 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
8294 else if (unformat (input, "ignore-tag1"))
8296 else if (unformat (input, "ignore-tag2"))
8298 else if (unformat (input, "cos1 %d", &cos1_val))
8300 else if (unformat (input, "cos2 %d", &cos2_val))
8305 if ((src + dst + proto + tag1 + tag2 +
8306 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
8309 if (tag1 || ignore_tag1 || cos1)
8311 if (tag2 || ignore_tag2 || cos2)
8314 vec_validate_aligned (match, len - 1, sizeof (u32x4));
8317 clib_memcpy (match, dst_val, 6);
8320 clib_memcpy (match + 6, src_val, 6);
8324 /* inner vlan tag */
8325 match[19] = tag2_val[1];
8326 match[18] = tag2_val[0];
8328 match[18] |= (cos2_val & 0x7) << 5;
8331 match[21] = proto_val & 0xff;
8332 match[20] = proto_val >> 8;
8336 match[15] = tag1_val[1];
8337 match[14] = tag1_val[0];
8340 match[14] |= (cos1_val & 0x7) << 5;
8346 match[15] = tag1_val[1];
8347 match[14] = tag1_val[0];
8350 match[17] = proto_val & 0xff;
8351 match[16] = proto_val >> 8;
8354 match[14] |= (cos1_val & 0x7) << 5;
8360 match[18] |= (cos2_val & 0x7) << 5;
8362 match[14] |= (cos1_val & 0x7) << 5;
8365 match[13] = proto_val & 0xff;
8366 match[12] = proto_val >> 8;
8375 unformat_classify_match (unformat_input_t * input, va_list * args)
8377 u8 **matchp = va_arg (*args, u8 **);
8378 u32 skip_n_vectors = va_arg (*args, u32);
8379 u32 match_n_vectors = va_arg (*args, u32);
8385 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8387 if (unformat (input, "hex %U", unformat_hex_string, &match))
8389 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
8391 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
8397 if (match || l2 || l3)
8401 /* "Win a free Ethernet header in every packet" */
8403 vec_validate_aligned (l2, 13, sizeof (u32x4));
8407 vec_append_aligned (match, l3, sizeof (u32x4));
8412 /* Make sure the vector is big enough even if key is all 0's */
8413 vec_validate_aligned
8414 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
8417 /* Set size, include skipped vectors */
8418 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
8429 api_classify_add_del_session (vat_main_t * vam)
8431 unformat_input_t *i = vam->input;
8432 vl_api_classify_add_del_session_t *mp;
8434 u32 table_index = ~0;
8435 u32 hit_next_index = ~0;
8436 u32 opaque_index = ~0;
8440 u32 skip_n_vectors = 0;
8441 u32 match_n_vectors = 0;
8444 * Warning: you have to supply skip_n and match_n
8445 * because the API client cant simply look at the classify
8449 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8451 if (unformat (i, "del"))
8453 else if (unformat (i, "hit-next %U", unformat_ip_next_index,
8456 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
8459 else if (unformat (i, "acl-hit-next %U", unformat_acl_next_index,
8462 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
8464 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
8466 else if (unformat (i, "opaque-index %d", &opaque_index))
8468 else if (unformat (i, "skip_n %d", &skip_n_vectors))
8470 else if (unformat (i, "match_n %d", &match_n_vectors))
8472 else if (unformat (i, "match %U", unformat_classify_match,
8473 &match, skip_n_vectors, match_n_vectors))
8475 else if (unformat (i, "advance %d", &advance))
8477 else if (unformat (i, "table-index %d", &table_index))
8483 if (table_index == ~0)
8485 errmsg ("Table index required\n");
8489 if (is_add && match == 0)
8491 errmsg ("Match value required\n");
8495 M2 (CLASSIFY_ADD_DEL_SESSION, classify_add_del_session, vec_len (match));
8497 mp->is_add = is_add;
8498 mp->table_index = ntohl (table_index);
8499 mp->hit_next_index = ntohl (hit_next_index);
8500 mp->opaque_index = ntohl (opaque_index);
8501 mp->advance = ntohl (advance);
8502 clib_memcpy (mp->match, match, vec_len (match));
8511 api_classify_set_interface_ip_table (vat_main_t * vam)
8513 unformat_input_t *i = vam->input;
8514 vl_api_classify_set_interface_ip_table_t *mp;
8517 int sw_if_index_set;
8518 u32 table_index = ~0;
8521 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8523 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8524 sw_if_index_set = 1;
8525 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8526 sw_if_index_set = 1;
8527 else if (unformat (i, "table %d", &table_index))
8531 clib_warning ("parse error '%U'", format_unformat_error, i);
8536 if (sw_if_index_set == 0)
8538 errmsg ("missing interface name or sw_if_index\n");
8543 M (CLASSIFY_SET_INTERFACE_IP_TABLE, classify_set_interface_ip_table);
8545 mp->sw_if_index = ntohl (sw_if_index);
8546 mp->table_index = ntohl (table_index);
8547 mp->is_ipv6 = is_ipv6;
8556 api_classify_set_interface_l2_tables (vat_main_t * vam)
8558 unformat_input_t *i = vam->input;
8559 vl_api_classify_set_interface_l2_tables_t *mp;
8562 int sw_if_index_set;
8563 u32 ip4_table_index = ~0;
8564 u32 ip6_table_index = ~0;
8565 u32 other_table_index = ~0;
8568 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8570 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8571 sw_if_index_set = 1;
8572 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8573 sw_if_index_set = 1;
8574 else if (unformat (i, "ip4-table %d", &ip4_table_index))
8576 else if (unformat (i, "ip6-table %d", &ip6_table_index))
8578 else if (unformat (i, "other-table %d", &other_table_index))
8580 else if (unformat (i, "is-input %d", &is_input))
8584 clib_warning ("parse error '%U'", format_unformat_error, i);
8589 if (sw_if_index_set == 0)
8591 errmsg ("missing interface name or sw_if_index\n");
8596 M (CLASSIFY_SET_INTERFACE_L2_TABLES, classify_set_interface_l2_tables);
8598 mp->sw_if_index = ntohl (sw_if_index);
8599 mp->ip4_table_index = ntohl (ip4_table_index);
8600 mp->ip6_table_index = ntohl (ip6_table_index);
8601 mp->other_table_index = ntohl (other_table_index);
8602 mp->is_input = (u8) is_input;
8611 api_set_ipfix_exporter (vat_main_t * vam)
8613 unformat_input_t *i = vam->input;
8614 vl_api_set_ipfix_exporter_t *mp;
8615 ip4_address_t collector_address;
8616 u8 collector_address_set = 0;
8617 u32 collector_port = ~0;
8618 ip4_address_t src_address;
8619 u8 src_address_set = 0;
8622 u32 template_interval = ~0;
8623 u8 udp_checksum = 0;
8626 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8628 if (unformat (i, "collector_address %U", unformat_ip4_address,
8629 &collector_address))
8630 collector_address_set = 1;
8631 else if (unformat (i, "collector_port %d", &collector_port))
8633 else if (unformat (i, "src_address %U", unformat_ip4_address,
8635 src_address_set = 1;
8636 else if (unformat (i, "vrf_id %d", &vrf_id))
8638 else if (unformat (i, "path_mtu %d", &path_mtu))
8640 else if (unformat (i, "template_interval %d", &template_interval))
8642 else if (unformat (i, "udp_checksum"))
8648 if (collector_address_set == 0)
8650 errmsg ("collector_address required\n");
8654 if (src_address_set == 0)
8656 errmsg ("src_address required\n");
8660 M (SET_IPFIX_EXPORTER, set_ipfix_exporter);
8662 memcpy (mp->collector_address, collector_address.data,
8663 sizeof (collector_address.data));
8664 mp->collector_port = htons ((u16) collector_port);
8665 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
8666 mp->vrf_id = htonl (vrf_id);
8667 mp->path_mtu = htonl (path_mtu);
8668 mp->template_interval = htonl (template_interval);
8669 mp->udp_checksum = udp_checksum;
8677 api_set_ipfix_classify_stream (vat_main_t * vam)
8679 unformat_input_t *i = vam->input;
8680 vl_api_set_ipfix_classify_stream_t *mp;
8682 u32 src_port = UDP_DST_PORT_ipfix;
8685 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8687 if (unformat (i, "domain %d", &domain_id))
8689 else if (unformat (i, "src_port %d", &src_port))
8693 errmsg ("unknown input `%U'", format_unformat_error, i);
8698 M (SET_IPFIX_CLASSIFY_STREAM, set_ipfix_classify_stream);
8700 mp->domain_id = htonl (domain_id);
8701 mp->src_port = htons ((u16) src_port);
8709 api_ipfix_classify_table_add_del (vat_main_t * vam)
8711 unformat_input_t *i = vam->input;
8712 vl_api_ipfix_classify_table_add_del_t *mp;
8714 u32 classify_table_index = ~0;
8716 u8 transport_protocol = 255;
8719 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8721 if (unformat (i, "add"))
8723 else if (unformat (i, "del"))
8725 else if (unformat (i, "table %d", &classify_table_index))
8727 else if (unformat (i, "ip4"))
8729 else if (unformat (i, "ip6"))
8731 else if (unformat (i, "tcp"))
8732 transport_protocol = 6;
8733 else if (unformat (i, "udp"))
8734 transport_protocol = 17;
8737 errmsg ("unknown input `%U'", format_unformat_error, i);
8744 errmsg ("expecting: add|del");
8747 if (classify_table_index == ~0)
8749 errmsg ("classifier table not specified");
8752 if (ip_version == 0)
8754 errmsg ("IP version not specified");
8758 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, ipfix_classify_table_add_del);
8760 mp->is_add = is_add;
8761 mp->table_id = htonl (classify_table_index);
8762 mp->ip_version = ip_version;
8763 mp->transport_protocol = transport_protocol;
8771 api_get_node_index (vat_main_t * vam)
8773 unformat_input_t *i = vam->input;
8774 vl_api_get_node_index_t *mp;
8778 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8780 if (unformat (i, "node %s", &name))
8787 errmsg ("node name required\n");
8790 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
8792 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
8796 M (GET_NODE_INDEX, get_node_index);
8797 clib_memcpy (mp->node_name, name, vec_len (name));
8807 api_get_next_index (vat_main_t * vam)
8809 unformat_input_t *i = vam->input;
8810 vl_api_get_next_index_t *mp;
8812 u8 *node_name = 0, *next_node_name = 0;
8814 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8816 if (unformat (i, "node-name %s", &node_name))
8818 else if (unformat (i, "next-node-name %s", &next_node_name))
8824 errmsg ("node name required\n");
8827 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
8829 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
8833 if (next_node_name == 0)
8835 errmsg ("next node name required\n");
8838 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
8840 errmsg ("next node name too long, max %d\n", ARRAY_LEN (mp->next_name));
8844 M (GET_NEXT_INDEX, get_next_index);
8845 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
8846 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
8847 vec_free (node_name);
8848 vec_free (next_node_name);
8857 api_add_node_next (vat_main_t * vam)
8859 unformat_input_t *i = vam->input;
8860 vl_api_add_node_next_t *mp;
8865 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8867 if (unformat (i, "node %s", &name))
8869 else if (unformat (i, "next %s", &next))
8876 errmsg ("node name required\n");
8879 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
8881 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
8886 errmsg ("next node required\n");
8889 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
8891 errmsg ("next name too long, max %d\n", ARRAY_LEN (mp->next_name));
8895 M (ADD_NODE_NEXT, add_node_next);
8896 clib_memcpy (mp->node_name, name, vec_len (name));
8897 clib_memcpy (mp->next_name, next, vec_len (next));
8908 api_l2tpv3_create_tunnel (vat_main_t * vam)
8910 unformat_input_t *i = vam->input;
8911 ip6_address_t client_address, our_address;
8912 int client_address_set = 0;
8913 int our_address_set = 0;
8914 u32 local_session_id = 0;
8915 u32 remote_session_id = 0;
8916 u64 local_cookie = 0;
8917 u64 remote_cookie = 0;
8918 u8 l2_sublayer_present = 0;
8919 vl_api_l2tpv3_create_tunnel_t *mp;
8922 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8924 if (unformat (i, "client_address %U", unformat_ip6_address,
8926 client_address_set = 1;
8927 else if (unformat (i, "our_address %U", unformat_ip6_address,
8929 our_address_set = 1;
8930 else if (unformat (i, "local_session_id %d", &local_session_id))
8932 else if (unformat (i, "remote_session_id %d", &remote_session_id))
8934 else if (unformat (i, "local_cookie %lld", &local_cookie))
8936 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
8938 else if (unformat (i, "l2-sublayer-present"))
8939 l2_sublayer_present = 1;
8944 if (client_address_set == 0)
8946 errmsg ("client_address required\n");
8950 if (our_address_set == 0)
8952 errmsg ("our_address required\n");
8956 M (L2TPV3_CREATE_TUNNEL, l2tpv3_create_tunnel);
8958 clib_memcpy (mp->client_address, client_address.as_u8,
8959 sizeof (mp->client_address));
8961 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
8963 mp->local_session_id = ntohl (local_session_id);
8964 mp->remote_session_id = ntohl (remote_session_id);
8965 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
8966 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
8967 mp->l2_sublayer_present = l2_sublayer_present;
8977 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
8979 unformat_input_t *i = vam->input;
8981 u8 sw_if_index_set = 0;
8982 u64 new_local_cookie = 0;
8983 u64 new_remote_cookie = 0;
8984 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
8987 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8989 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8990 sw_if_index_set = 1;
8991 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8992 sw_if_index_set = 1;
8993 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
8995 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
9001 if (sw_if_index_set == 0)
9003 errmsg ("missing interface name or sw_if_index\n");
9007 M (L2TPV3_SET_TUNNEL_COOKIES, l2tpv3_set_tunnel_cookies);
9009 mp->sw_if_index = ntohl (sw_if_index);
9010 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
9011 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
9020 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
9022 unformat_input_t *i = vam->input;
9023 vl_api_l2tpv3_interface_enable_disable_t *mp;
9026 u8 sw_if_index_set = 0;
9027 u8 enable_disable = 1;
9029 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9031 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9032 sw_if_index_set = 1;
9033 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9034 sw_if_index_set = 1;
9035 else if (unformat (i, "enable"))
9037 else if (unformat (i, "disable"))
9043 if (sw_if_index_set == 0)
9045 errmsg ("missing interface name or sw_if_index\n");
9049 M (L2TPV3_INTERFACE_ENABLE_DISABLE, l2tpv3_interface_enable_disable);
9051 mp->sw_if_index = ntohl (sw_if_index);
9052 mp->enable_disable = enable_disable;
9061 api_l2tpv3_set_lookup_key (vat_main_t * vam)
9063 unformat_input_t *i = vam->input;
9064 vl_api_l2tpv3_set_lookup_key_t *mp;
9068 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9070 if (unformat (i, "lookup_v6_src"))
9071 key = L2T_LOOKUP_SRC_ADDRESS;
9072 else if (unformat (i, "lookup_v6_dst"))
9073 key = L2T_LOOKUP_DST_ADDRESS;
9074 else if (unformat (i, "lookup_session_id"))
9075 key = L2T_LOOKUP_SESSION_ID;
9080 if (key == (u8) ~ 0)
9082 errmsg ("l2tp session lookup key unset\n");
9086 M (L2TPV3_SET_LOOKUP_KEY, l2tpv3_set_lookup_key);
9096 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
9097 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
9099 vat_main_t *vam = &vat_main;
9101 fformat (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)\n",
9102 format_ip6_address, mp->our_address,
9103 format_ip6_address, mp->client_address,
9104 clib_net_to_host_u32 (mp->sw_if_index));
9107 " local cookies %016llx %016llx remote cookie %016llx\n",
9108 clib_net_to_host_u64 (mp->local_cookie[0]),
9109 clib_net_to_host_u64 (mp->local_cookie[1]),
9110 clib_net_to_host_u64 (mp->remote_cookie));
9112 fformat (vam->ofp, " local session-id %d remote session-id %d\n",
9113 clib_net_to_host_u32 (mp->local_session_id),
9114 clib_net_to_host_u32 (mp->remote_session_id));
9116 fformat (vam->ofp, " l2 specific sublayer %s\n\n",
9117 mp->l2_sublayer_present ? "preset" : "absent");
9121 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
9122 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
9124 vat_main_t *vam = &vat_main;
9125 vat_json_node_t *node = NULL;
9126 struct in6_addr addr;
9128 if (VAT_JSON_ARRAY != vam->json_tree.type)
9130 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9131 vat_json_init_array (&vam->json_tree);
9133 node = vat_json_array_add (&vam->json_tree);
9135 vat_json_init_object (node);
9137 clib_memcpy (&addr, mp->our_address, sizeof (addr));
9138 vat_json_object_add_ip6 (node, "our_address", addr);
9139 clib_memcpy (&addr, mp->client_address, sizeof (addr));
9140 vat_json_object_add_ip6 (node, "client_address", addr);
9142 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
9143 vat_json_init_array (lc);
9144 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
9145 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
9146 vat_json_object_add_uint (node, "remote_cookie",
9147 clib_net_to_host_u64 (mp->remote_cookie));
9149 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
9150 vat_json_object_add_uint (node, "local_session_id",
9151 clib_net_to_host_u32 (mp->local_session_id));
9152 vat_json_object_add_uint (node, "remote_session_id",
9153 clib_net_to_host_u32 (mp->remote_session_id));
9154 vat_json_object_add_string_copy (node, "l2_sublayer",
9155 mp->l2_sublayer_present ? (u8 *) "present"
9160 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
9162 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
9165 /* Get list of l2tpv3-tunnel interfaces */
9166 M (SW_IF_L2TPV3_TUNNEL_DUMP, sw_if_l2tpv3_tunnel_dump);
9169 /* Use a control ping for synchronization */
9171 vl_api_control_ping_t *mp;
9172 M (CONTROL_PING, control_ping);
9179 static void vl_api_sw_interface_tap_details_t_handler
9180 (vl_api_sw_interface_tap_details_t * mp)
9182 vat_main_t *vam = &vat_main;
9184 fformat (vam->ofp, "%-16s %d\n",
9185 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
9188 static void vl_api_sw_interface_tap_details_t_handler_json
9189 (vl_api_sw_interface_tap_details_t * mp)
9191 vat_main_t *vam = &vat_main;
9192 vat_json_node_t *node = NULL;
9194 if (VAT_JSON_ARRAY != vam->json_tree.type)
9196 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9197 vat_json_init_array (&vam->json_tree);
9199 node = vat_json_array_add (&vam->json_tree);
9201 vat_json_init_object (node);
9202 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9203 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
9207 api_sw_interface_tap_dump (vat_main_t * vam)
9209 vl_api_sw_interface_tap_dump_t *mp;
9212 fformat (vam->ofp, "\n%-16s %s\n", "dev_name", "sw_if_index");
9213 /* Get list of tap interfaces */
9214 M (SW_INTERFACE_TAP_DUMP, sw_interface_tap_dump);
9217 /* Use a control ping for synchronization */
9219 vl_api_control_ping_t *mp;
9220 M (CONTROL_PING, control_ping);
9226 static uword unformat_vxlan_decap_next
9227 (unformat_input_t * input, va_list * args)
9229 u32 *result = va_arg (*args, u32 *);
9232 if (unformat (input, "drop"))
9233 *result = VXLAN_INPUT_NEXT_DROP;
9234 else if (unformat (input, "ip4"))
9235 *result = VXLAN_INPUT_NEXT_IP4_INPUT;
9236 else if (unformat (input, "ip6"))
9237 *result = VXLAN_INPUT_NEXT_IP6_INPUT;
9238 else if (unformat (input, "l2"))
9239 *result = VXLAN_INPUT_NEXT_L2_INPUT;
9240 else if (unformat (input, "%d", &tmp))
9248 api_vxlan_add_del_tunnel (vat_main_t * vam)
9250 unformat_input_t *line_input = vam->input;
9251 vl_api_vxlan_add_del_tunnel_t *mp;
9253 ip4_address_t src4, dst4;
9254 ip6_address_t src6, dst6;
9256 u8 ipv4_set = 0, ipv6_set = 0;
9259 u32 encap_vrf_id = 0;
9260 u32 decap_next_index = ~0;
9263 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9265 if (unformat (line_input, "del"))
9267 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
9272 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
9277 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
9282 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
9287 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
9289 else if (unformat (line_input, "decap-next %U",
9290 unformat_vxlan_decap_next, &decap_next_index))
9292 else if (unformat (line_input, "vni %d", &vni))
9296 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
9303 errmsg ("tunnel src address not specified\n");
9308 errmsg ("tunnel dst address not specified\n");
9312 if (ipv4_set && ipv6_set)
9314 errmsg ("both IPv4 and IPv6 addresses specified");
9318 if ((vni == 0) || (vni >> 24))
9320 errmsg ("vni not specified or out of range\n");
9324 M (VXLAN_ADD_DEL_TUNNEL, vxlan_add_del_tunnel);
9328 clib_memcpy (&mp->src_address, &src6, sizeof (src6));
9329 clib_memcpy (&mp->dst_address, &dst6, sizeof (dst6));
9333 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
9334 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
9336 mp->encap_vrf_id = ntohl (encap_vrf_id);
9337 mp->decap_next_index = ntohl (decap_next_index);
9338 mp->vni = ntohl (vni);
9339 mp->is_add = is_add;
9340 mp->is_ipv6 = ipv6_set;
9348 static void vl_api_vxlan_tunnel_details_t_handler
9349 (vl_api_vxlan_tunnel_details_t * mp)
9351 vat_main_t *vam = &vat_main;
9353 fformat (vam->ofp, "%11d%24U%24U%14d%18d%13d\n",
9354 ntohl (mp->sw_if_index),
9355 format_ip46_address, &(mp->src_address[0]),
9357 format_ip46_address, &(mp->dst_address[0]),
9359 ntohl (mp->encap_vrf_id),
9360 ntohl (mp->decap_next_index), ntohl (mp->vni));
9363 static void vl_api_vxlan_tunnel_details_t_handler_json
9364 (vl_api_vxlan_tunnel_details_t * mp)
9366 vat_main_t *vam = &vat_main;
9367 vat_json_node_t *node = NULL;
9369 struct in6_addr ip6;
9371 if (VAT_JSON_ARRAY != vam->json_tree.type)
9373 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9374 vat_json_init_array (&vam->json_tree);
9376 node = vat_json_array_add (&vam->json_tree);
9378 vat_json_init_object (node);
9379 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9382 clib_memcpy (&ip6, &(mp->src_address[0]), sizeof (ip6));
9383 vat_json_object_add_ip6 (node, "src_address", ip6);
9384 clib_memcpy (&ip6, &(mp->dst_address[0]), sizeof (ip6));
9385 vat_json_object_add_ip6 (node, "dst_address", ip6);
9389 clib_memcpy (&ip4, &(mp->src_address[0]), sizeof (ip4));
9390 vat_json_object_add_ip4 (node, "src_address", ip4);
9391 clib_memcpy (&ip4, &(mp->dst_address[0]), sizeof (ip4));
9392 vat_json_object_add_ip4 (node, "dst_address", ip4);
9394 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
9395 vat_json_object_add_uint (node, "decap_next_index",
9396 ntohl (mp->decap_next_index));
9397 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
9398 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
9402 api_vxlan_tunnel_dump (vat_main_t * vam)
9404 unformat_input_t *i = vam->input;
9405 vl_api_vxlan_tunnel_dump_t *mp;
9408 u8 sw_if_index_set = 0;
9410 /* Parse args required to build the message */
9411 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9413 if (unformat (i, "sw_if_index %d", &sw_if_index))
9414 sw_if_index_set = 1;
9419 if (sw_if_index_set == 0)
9424 if (!vam->json_output)
9426 fformat (vam->ofp, "%11s%24s%24s%14s%18s%13s\n",
9427 "sw_if_index", "src_address", "dst_address",
9428 "encap_vrf_id", "decap_next_index", "vni");
9431 /* Get list of vxlan-tunnel interfaces */
9432 M (VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump);
9434 mp->sw_if_index = htonl (sw_if_index);
9438 /* Use a control ping for synchronization */
9440 vl_api_control_ping_t *mp;
9441 M (CONTROL_PING, control_ping);
9448 api_gre_add_del_tunnel (vat_main_t * vam)
9450 unformat_input_t *line_input = vam->input;
9451 vl_api_gre_add_del_tunnel_t *mp;
9453 ip4_address_t src4, dst4;
9458 u32 outer_fib_id = 0;
9460 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9462 if (unformat (line_input, "del"))
9464 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
9466 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
9468 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
9470 else if (unformat (line_input, "teb"))
9474 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
9481 errmsg ("tunnel src address not specified\n");
9486 errmsg ("tunnel dst address not specified\n");
9491 M (GRE_ADD_DEL_TUNNEL, gre_add_del_tunnel);
9493 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
9494 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
9495 mp->outer_fib_id = ntohl (outer_fib_id);
9496 mp->is_add = is_add;
9505 static void vl_api_gre_tunnel_details_t_handler
9506 (vl_api_gre_tunnel_details_t * mp)
9508 vat_main_t *vam = &vat_main;
9510 fformat (vam->ofp, "%11d%15U%15U%6d%14d\n",
9511 ntohl (mp->sw_if_index),
9512 format_ip4_address, &mp->src_address,
9513 format_ip4_address, &mp->dst_address,
9514 mp->teb, ntohl (mp->outer_fib_id));
9517 static void vl_api_gre_tunnel_details_t_handler_json
9518 (vl_api_gre_tunnel_details_t * mp)
9520 vat_main_t *vam = &vat_main;
9521 vat_json_node_t *node = NULL;
9524 if (VAT_JSON_ARRAY != vam->json_tree.type)
9526 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9527 vat_json_init_array (&vam->json_tree);
9529 node = vat_json_array_add (&vam->json_tree);
9531 vat_json_init_object (node);
9532 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9533 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
9534 vat_json_object_add_ip4 (node, "src_address", ip4);
9535 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
9536 vat_json_object_add_ip4 (node, "dst_address", ip4);
9537 vat_json_object_add_uint (node, "teb", mp->teb);
9538 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
9542 api_gre_tunnel_dump (vat_main_t * vam)
9544 unformat_input_t *i = vam->input;
9545 vl_api_gre_tunnel_dump_t *mp;
9548 u8 sw_if_index_set = 0;
9550 /* Parse args required to build the message */
9551 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9553 if (unformat (i, "sw_if_index %d", &sw_if_index))
9554 sw_if_index_set = 1;
9559 if (sw_if_index_set == 0)
9564 if (!vam->json_output)
9566 fformat (vam->ofp, "%11s%15s%15s%6s%14s\n",
9567 "sw_if_index", "src_address", "dst_address", "teb",
9571 /* Get list of gre-tunnel interfaces */
9572 M (GRE_TUNNEL_DUMP, gre_tunnel_dump);
9574 mp->sw_if_index = htonl (sw_if_index);
9578 /* Use a control ping for synchronization */
9580 vl_api_control_ping_t *mp;
9581 M (CONTROL_PING, control_ping);
9588 api_l2_fib_clear_table (vat_main_t * vam)
9590 // unformat_input_t * i = vam->input;
9591 vl_api_l2_fib_clear_table_t *mp;
9594 M (L2_FIB_CLEAR_TABLE, l2_fib_clear_table);
9603 api_l2_interface_efp_filter (vat_main_t * vam)
9605 unformat_input_t *i = vam->input;
9606 vl_api_l2_interface_efp_filter_t *mp;
9610 u8 sw_if_index_set = 0;
9612 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9614 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9615 sw_if_index_set = 1;
9616 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9617 sw_if_index_set = 1;
9618 else if (unformat (i, "enable"))
9620 else if (unformat (i, "disable"))
9624 clib_warning ("parse error '%U'", format_unformat_error, i);
9629 if (sw_if_index_set == 0)
9631 errmsg ("missing sw_if_index\n");
9635 M (L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter);
9637 mp->sw_if_index = ntohl (sw_if_index);
9638 mp->enable_disable = enable;
9646 #define foreach_vtr_op \
9647 _("disable", L2_VTR_DISABLED) \
9648 _("push-1", L2_VTR_PUSH_1) \
9649 _("push-2", L2_VTR_PUSH_2) \
9650 _("pop-1", L2_VTR_POP_1) \
9651 _("pop-2", L2_VTR_POP_2) \
9652 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
9653 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
9654 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
9655 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
9658 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
9660 unformat_input_t *i = vam->input;
9661 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
9664 u8 sw_if_index_set = 0;
9671 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9673 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9674 sw_if_index_set = 1;
9675 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9676 sw_if_index_set = 1;
9677 else if (unformat (i, "vtr_op %d", &vtr_op))
9679 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
9682 else if (unformat (i, "push_dot1q %d", &push_dot1q))
9684 else if (unformat (i, "tag1 %d", &tag1))
9686 else if (unformat (i, "tag2 %d", &tag2))
9690 clib_warning ("parse error '%U'", format_unformat_error, i);
9695 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
9697 errmsg ("missing vtr operation or sw_if_index\n");
9701 M (L2_INTERFACE_VLAN_TAG_REWRITE, l2_interface_vlan_tag_rewrite)
9702 mp->sw_if_index = ntohl (sw_if_index);
9703 mp->vtr_op = ntohl (vtr_op);
9704 mp->push_dot1q = ntohl (push_dot1q);
9705 mp->tag1 = ntohl (tag1);
9706 mp->tag2 = ntohl (tag2);
9715 api_create_vhost_user_if (vat_main_t * vam)
9717 unformat_input_t *i = vam->input;
9718 vl_api_create_vhost_user_if_t *mp;
9722 u8 file_name_set = 0;
9723 u32 custom_dev_instance = ~0;
9725 u8 use_custom_mac = 0;
9727 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9729 if (unformat (i, "socket %s", &file_name))
9733 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
9735 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
9737 else if (unformat (i, "server"))
9743 if (file_name_set == 0)
9745 errmsg ("missing socket file name\n");
9749 if (vec_len (file_name) > 255)
9751 errmsg ("socket file name too long\n");
9754 vec_add1 (file_name, 0);
9756 M (CREATE_VHOST_USER_IF, create_vhost_user_if);
9758 mp->is_server = is_server;
9759 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
9760 vec_free (file_name);
9761 if (custom_dev_instance != ~0)
9764 mp->custom_dev_instance = ntohl (custom_dev_instance);
9766 mp->use_custom_mac = use_custom_mac;
9767 clib_memcpy (mp->mac_address, hwaddr, 6);
9776 api_modify_vhost_user_if (vat_main_t * vam)
9778 unformat_input_t *i = vam->input;
9779 vl_api_modify_vhost_user_if_t *mp;
9783 u8 file_name_set = 0;
9784 u32 custom_dev_instance = ~0;
9785 u8 sw_if_index_set = 0;
9786 u32 sw_if_index = (u32) ~ 0;
9788 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9790 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9791 sw_if_index_set = 1;
9792 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9793 sw_if_index_set = 1;
9794 else if (unformat (i, "socket %s", &file_name))
9798 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
9800 else if (unformat (i, "server"))
9806 if (sw_if_index_set == 0)
9808 errmsg ("missing sw_if_index or interface name\n");
9812 if (file_name_set == 0)
9814 errmsg ("missing socket file name\n");
9818 if (vec_len (file_name) > 255)
9820 errmsg ("socket file name too long\n");
9823 vec_add1 (file_name, 0);
9825 M (MODIFY_VHOST_USER_IF, modify_vhost_user_if);
9827 mp->sw_if_index = ntohl (sw_if_index);
9828 mp->is_server = is_server;
9829 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
9830 vec_free (file_name);
9831 if (custom_dev_instance != ~0)
9834 mp->custom_dev_instance = ntohl (custom_dev_instance);
9844 api_delete_vhost_user_if (vat_main_t * vam)
9846 unformat_input_t *i = vam->input;
9847 vl_api_delete_vhost_user_if_t *mp;
9849 u32 sw_if_index = ~0;
9850 u8 sw_if_index_set = 0;
9852 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9854 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9855 sw_if_index_set = 1;
9856 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9857 sw_if_index_set = 1;
9862 if (sw_if_index_set == 0)
9864 errmsg ("missing sw_if_index or interface name\n");
9869 M (DELETE_VHOST_USER_IF, delete_vhost_user_if);
9871 mp->sw_if_index = ntohl (sw_if_index);
9879 static void vl_api_sw_interface_vhost_user_details_t_handler
9880 (vl_api_sw_interface_vhost_user_details_t * mp)
9882 vat_main_t *vam = &vat_main;
9884 fformat (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s\n",
9885 (char *) mp->interface_name,
9886 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
9887 clib_net_to_host_u64 (mp->features), mp->is_server,
9888 ntohl (mp->num_regions), (char *) mp->sock_filename);
9889 fformat (vam->ofp, " Status: '%s'\n", strerror (ntohl (mp->sock_errno)));
9892 static void vl_api_sw_interface_vhost_user_details_t_handler_json
9893 (vl_api_sw_interface_vhost_user_details_t * mp)
9895 vat_main_t *vam = &vat_main;
9896 vat_json_node_t *node = NULL;
9898 if (VAT_JSON_ARRAY != vam->json_tree.type)
9900 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9901 vat_json_init_array (&vam->json_tree);
9903 node = vat_json_array_add (&vam->json_tree);
9905 vat_json_init_object (node);
9906 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9907 vat_json_object_add_string_copy (node, "interface_name",
9908 mp->interface_name);
9909 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
9910 ntohl (mp->virtio_net_hdr_sz));
9911 vat_json_object_add_uint (node, "features",
9912 clib_net_to_host_u64 (mp->features));
9913 vat_json_object_add_uint (node, "is_server", mp->is_server);
9914 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
9915 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
9916 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
9920 api_sw_interface_vhost_user_dump (vat_main_t * vam)
9922 vl_api_sw_interface_vhost_user_dump_t *mp;
9925 "Interface name idx hdr_sz features server regions filename\n");
9927 /* Get list of vhost-user interfaces */
9928 M (SW_INTERFACE_VHOST_USER_DUMP, sw_interface_vhost_user_dump);
9931 /* Use a control ping for synchronization */
9933 vl_api_control_ping_t *mp;
9934 M (CONTROL_PING, control_ping);
9941 api_show_version (vat_main_t * vam)
9943 vl_api_show_version_t *mp;
9946 M (SHOW_VERSION, show_version);
9956 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
9958 unformat_input_t *line_input = vam->input;
9959 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
9961 ip4_address_t local4, remote4;
9962 ip6_address_t local6, remote6;
9964 u8 ipv4_set = 0, ipv6_set = 0;
9967 u32 encap_vrf_id = 0;
9968 u32 decap_vrf_id = 0;
9973 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9975 if (unformat (line_input, "del"))
9977 else if (unformat (line_input, "local %U",
9978 unformat_ip4_address, &local4))
9983 else if (unformat (line_input, "remote %U",
9984 unformat_ip4_address, &remote4))
9989 else if (unformat (line_input, "local %U",
9990 unformat_ip6_address, &local6))
9995 else if (unformat (line_input, "remote %U",
9996 unformat_ip6_address, &remote6))
10001 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
10003 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
10005 else if (unformat (line_input, "vni %d", &vni))
10007 else if (unformat (line_input, "next-ip4"))
10009 else if (unformat (line_input, "next-ip6"))
10011 else if (unformat (line_input, "next-ethernet"))
10013 else if (unformat (line_input, "next-nsh"))
10017 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
10022 if (local_set == 0)
10024 errmsg ("tunnel local address not specified\n");
10027 if (remote_set == 0)
10029 errmsg ("tunnel remote address not specified\n");
10032 if (ipv4_set && ipv6_set)
10034 errmsg ("both IPv4 and IPv6 addresses specified");
10040 errmsg ("vni not specified\n");
10044 M (VXLAN_GPE_ADD_DEL_TUNNEL, vxlan_gpe_add_del_tunnel);
10049 clib_memcpy (&mp->local, &local6, sizeof (local6));
10050 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
10054 clib_memcpy (&mp->local, &local4, sizeof (local4));
10055 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
10058 mp->encap_vrf_id = ntohl (encap_vrf_id);
10059 mp->decap_vrf_id = ntohl (decap_vrf_id);
10060 mp->protocol = ntohl (protocol);
10061 mp->vni = ntohl (vni);
10062 mp->is_add = is_add;
10063 mp->is_ipv6 = ipv6_set;
10071 static void vl_api_vxlan_gpe_tunnel_details_t_handler
10072 (vl_api_vxlan_gpe_tunnel_details_t * mp)
10074 vat_main_t *vam = &vat_main;
10076 fformat (vam->ofp, "%11d%24U%24U%13d%12d%14d%14d\n",
10077 ntohl (mp->sw_if_index),
10078 format_ip46_address, &(mp->local[0]),
10079 format_ip46_address, &(mp->remote[0]),
10081 ntohl (mp->protocol),
10082 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
10085 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
10086 (vl_api_vxlan_gpe_tunnel_details_t * mp)
10088 vat_main_t *vam = &vat_main;
10089 vat_json_node_t *node = NULL;
10090 struct in_addr ip4;
10091 struct in6_addr ip6;
10093 if (VAT_JSON_ARRAY != vam->json_tree.type)
10095 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10096 vat_json_init_array (&vam->json_tree);
10098 node = vat_json_array_add (&vam->json_tree);
10100 vat_json_init_object (node);
10101 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10104 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
10105 vat_json_object_add_ip6 (node, "local", ip6);
10106 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
10107 vat_json_object_add_ip6 (node, "remote", ip6);
10111 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
10112 vat_json_object_add_ip4 (node, "local", ip4);
10113 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
10114 vat_json_object_add_ip4 (node, "remote", ip4);
10116 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
10117 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
10118 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
10119 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
10120 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
10124 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
10126 unformat_input_t *i = vam->input;
10127 vl_api_vxlan_gpe_tunnel_dump_t *mp;
10130 u8 sw_if_index_set = 0;
10132 /* Parse args required to build the message */
10133 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10135 if (unformat (i, "sw_if_index %d", &sw_if_index))
10136 sw_if_index_set = 1;
10141 if (sw_if_index_set == 0)
10146 if (!vam->json_output)
10148 fformat (vam->ofp, "%11s%24s%24s%13s%15s%14s%14s\n",
10149 "sw_if_index", "local", "remote", "vni",
10150 "protocol", "encap_vrf_id", "decap_vrf_id");
10153 /* Get list of vxlan-tunnel interfaces */
10154 M (VXLAN_GPE_TUNNEL_DUMP, vxlan_gpe_tunnel_dump);
10156 mp->sw_if_index = htonl (sw_if_index);
10160 /* Use a control ping for synchronization */
10162 vl_api_control_ping_t *mp;
10163 M (CONTROL_PING, control_ping);
10170 format_l2_fib_mac_address (u8 * s, va_list * args)
10172 u8 *a = va_arg (*args, u8 *);
10174 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
10175 a[2], a[3], a[4], a[5], a[6], a[7]);
10178 static void vl_api_l2_fib_table_entry_t_handler
10179 (vl_api_l2_fib_table_entry_t * mp)
10181 vat_main_t *vam = &vat_main;
10183 fformat (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
10185 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
10186 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
10190 static void vl_api_l2_fib_table_entry_t_handler_json
10191 (vl_api_l2_fib_table_entry_t * mp)
10193 vat_main_t *vam = &vat_main;
10194 vat_json_node_t *node = NULL;
10196 if (VAT_JSON_ARRAY != vam->json_tree.type)
10198 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10199 vat_json_init_array (&vam->json_tree);
10201 node = vat_json_array_add (&vam->json_tree);
10203 vat_json_init_object (node);
10204 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
10205 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
10206 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10207 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
10208 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
10209 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
10213 api_l2_fib_table_dump (vat_main_t * vam)
10215 unformat_input_t *i = vam->input;
10216 vl_api_l2_fib_table_dump_t *mp;
10221 /* Parse args required to build the message */
10222 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10224 if (unformat (i, "bd_id %d", &bd_id))
10230 if (bd_id_set == 0)
10232 errmsg ("missing bridge domain\n");
10237 "BD-ID Mac Address sw-ndx Static Filter BVI\n");
10239 /* Get list of l2 fib entries */
10240 M (L2_FIB_TABLE_DUMP, l2_fib_table_dump);
10242 mp->bd_id = ntohl (bd_id);
10245 /* Use a control ping for synchronization */
10247 vl_api_control_ping_t *mp;
10248 M (CONTROL_PING, control_ping);
10256 api_interface_name_renumber (vat_main_t * vam)
10258 unformat_input_t *line_input = vam->input;
10259 vl_api_interface_name_renumber_t *mp;
10260 u32 sw_if_index = ~0;
10262 u32 new_show_dev_instance = ~0;
10264 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10266 if (unformat (line_input, "%U", unformat_sw_if_index, vam,
10269 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
10271 else if (unformat (line_input, "new_show_dev_instance %d",
10272 &new_show_dev_instance))
10278 if (sw_if_index == ~0)
10280 errmsg ("missing interface name or sw_if_index\n");
10284 if (new_show_dev_instance == ~0)
10286 errmsg ("missing new_show_dev_instance\n");
10290 M (INTERFACE_NAME_RENUMBER, interface_name_renumber);
10292 mp->sw_if_index = ntohl (sw_if_index);
10293 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
10300 api_want_ip4_arp_events (vat_main_t * vam)
10302 unformat_input_t *line_input = vam->input;
10303 vl_api_want_ip4_arp_events_t *mp;
10305 ip4_address_t address;
10306 int address_set = 0;
10307 u32 enable_disable = 1;
10309 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10311 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
10313 else if (unformat (line_input, "del"))
10314 enable_disable = 0;
10319 if (address_set == 0)
10321 errmsg ("missing addresses\n");
10325 M (WANT_IP4_ARP_EVENTS, want_ip4_arp_events);
10326 mp->enable_disable = enable_disable;
10327 mp->pid = getpid ();
10328 mp->address = address.as_u32;
10335 api_want_ip6_nd_events (vat_main_t * vam)
10337 unformat_input_t *line_input = vam->input;
10338 vl_api_want_ip6_nd_events_t *mp;
10340 ip6_address_t address;
10341 int address_set = 0;
10342 u32 enable_disable = 1;
10344 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10346 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
10348 else if (unformat (line_input, "del"))
10349 enable_disable = 0;
10354 if (address_set == 0)
10356 errmsg ("missing addresses\n");
10360 M (WANT_IP6_ND_EVENTS, want_ip6_nd_events);
10361 mp->enable_disable = enable_disable;
10362 mp->pid = getpid ();
10363 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
10370 api_input_acl_set_interface (vat_main_t * vam)
10372 unformat_input_t *i = vam->input;
10373 vl_api_input_acl_set_interface_t *mp;
10376 int sw_if_index_set;
10377 u32 ip4_table_index = ~0;
10378 u32 ip6_table_index = ~0;
10379 u32 l2_table_index = ~0;
10382 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10384 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10385 sw_if_index_set = 1;
10386 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10387 sw_if_index_set = 1;
10388 else if (unformat (i, "del"))
10390 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10392 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10394 else if (unformat (i, "l2-table %d", &l2_table_index))
10398 clib_warning ("parse error '%U'", format_unformat_error, i);
10403 if (sw_if_index_set == 0)
10405 errmsg ("missing interface name or sw_if_index\n");
10409 M (INPUT_ACL_SET_INTERFACE, input_acl_set_interface);
10411 mp->sw_if_index = ntohl (sw_if_index);
10412 mp->ip4_table_index = ntohl (ip4_table_index);
10413 mp->ip6_table_index = ntohl (ip6_table_index);
10414 mp->l2_table_index = ntohl (l2_table_index);
10415 mp->is_add = is_add;
10424 api_ip_address_dump (vat_main_t * vam)
10426 unformat_input_t *i = vam->input;
10427 vl_api_ip_address_dump_t *mp;
10428 u32 sw_if_index = ~0;
10429 u8 sw_if_index_set = 0;
10434 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10436 if (unformat (i, "sw_if_index %d", &sw_if_index))
10437 sw_if_index_set = 1;
10438 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10439 sw_if_index_set = 1;
10440 else if (unformat (i, "ipv4"))
10442 else if (unformat (i, "ipv6"))
10448 if (ipv4_set && ipv6_set)
10450 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
10454 if ((!ipv4_set) && (!ipv6_set))
10456 errmsg ("no ipv4 nor ipv6 flag set\n");
10460 if (sw_if_index_set == 0)
10462 errmsg ("missing interface name or sw_if_index\n");
10466 vam->current_sw_if_index = sw_if_index;
10467 vam->is_ipv6 = ipv6_set;
10469 M (IP_ADDRESS_DUMP, ip_address_dump);
10470 mp->sw_if_index = ntohl (sw_if_index);
10471 mp->is_ipv6 = ipv6_set;
10474 /* Use a control ping for synchronization */
10476 vl_api_control_ping_t *mp;
10477 M (CONTROL_PING, control_ping);
10484 api_ip_dump (vat_main_t * vam)
10486 vl_api_ip_dump_t *mp;
10487 unformat_input_t *in = vam->input;
10494 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
10496 if (unformat (in, "ipv4"))
10498 else if (unformat (in, "ipv6"))
10504 if (ipv4_set && ipv6_set)
10506 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
10510 if ((!ipv4_set) && (!ipv6_set))
10512 errmsg ("no ipv4 nor ipv6 flag set\n");
10516 is_ipv6 = ipv6_set;
10517 vam->is_ipv6 = is_ipv6;
10519 /* free old data */
10520 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
10522 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
10524 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
10526 M (IP_DUMP, ip_dump);
10527 mp->is_ipv6 = ipv6_set;
10530 /* Use a control ping for synchronization */
10532 vl_api_control_ping_t *mp;
10533 M (CONTROL_PING, control_ping);
10540 api_ipsec_spd_add_del (vat_main_t * vam)
10543 unformat_input_t *i = vam->input;
10544 vl_api_ipsec_spd_add_del_t *mp;
10549 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10551 if (unformat (i, "spd_id %d", &spd_id))
10553 else if (unformat (i, "del"))
10557 clib_warning ("parse error '%U'", format_unformat_error, i);
10563 errmsg ("spd_id must be set\n");
10567 M (IPSEC_SPD_ADD_DEL, ipsec_spd_add_del);
10569 mp->spd_id = ntohl (spd_id);
10570 mp->is_add = is_add;
10577 clib_warning ("unsupported (no dpdk)");
10583 api_ipsec_interface_add_del_spd (vat_main_t * vam)
10586 unformat_input_t *i = vam->input;
10587 vl_api_ipsec_interface_add_del_spd_t *mp;
10590 u8 sw_if_index_set = 0;
10591 u32 spd_id = (u32) ~ 0;
10594 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10596 if (unformat (i, "del"))
10598 else if (unformat (i, "spd_id %d", &spd_id))
10600 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10601 sw_if_index_set = 1;
10602 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10603 sw_if_index_set = 1;
10606 clib_warning ("parse error '%U'", format_unformat_error, i);
10612 if (spd_id == (u32) ~ 0)
10614 errmsg ("spd_id must be set\n");
10618 if (sw_if_index_set == 0)
10620 errmsg ("missing interface name or sw_if_index\n");
10624 M (IPSEC_INTERFACE_ADD_DEL_SPD, ipsec_interface_add_del_spd);
10626 mp->spd_id = ntohl (spd_id);
10627 mp->sw_if_index = ntohl (sw_if_index);
10628 mp->is_add = is_add;
10635 clib_warning ("unsupported (no dpdk)");
10641 api_ipsec_spd_add_del_entry (vat_main_t * vam)
10644 unformat_input_t *i = vam->input;
10645 vl_api_ipsec_spd_add_del_entry_t *mp;
10647 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
10648 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
10650 u32 rport_start = 0, rport_stop = (u32) ~ 0;
10651 u32 lport_start = 0, lport_stop = (u32) ~ 0;
10652 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
10653 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
10655 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
10656 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
10657 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
10658 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
10659 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
10660 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
10662 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10664 if (unformat (i, "del"))
10666 if (unformat (i, "outbound"))
10668 if (unformat (i, "inbound"))
10670 else if (unformat (i, "spd_id %d", &spd_id))
10672 else if (unformat (i, "sa_id %d", &sa_id))
10674 else if (unformat (i, "priority %d", &priority))
10676 else if (unformat (i, "protocol %d", &protocol))
10678 else if (unformat (i, "lport_start %d", &lport_start))
10680 else if (unformat (i, "lport_stop %d", &lport_stop))
10682 else if (unformat (i, "rport_start %d", &rport_start))
10684 else if (unformat (i, "rport_stop %d", &rport_stop))
10688 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
10694 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
10701 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
10707 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
10714 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
10720 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
10727 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
10733 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
10739 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
10741 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
10743 clib_warning ("unsupported action: 'resolve'");
10749 clib_warning ("parse error '%U'", format_unformat_error, i);
10755 M (IPSEC_SPD_ADD_DEL_ENTRY, ipsec_spd_add_del_entry);
10757 mp->spd_id = ntohl (spd_id);
10758 mp->priority = ntohl (priority);
10759 mp->is_outbound = is_outbound;
10761 mp->is_ipv6 = is_ipv6;
10762 if (is_ipv6 || is_ip_any)
10764 clib_memcpy (mp->remote_address_start, &raddr6_start,
10765 sizeof (ip6_address_t));
10766 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
10767 sizeof (ip6_address_t));
10768 clib_memcpy (mp->local_address_start, &laddr6_start,
10769 sizeof (ip6_address_t));
10770 clib_memcpy (mp->local_address_stop, &laddr6_stop,
10771 sizeof (ip6_address_t));
10775 clib_memcpy (mp->remote_address_start, &raddr4_start,
10776 sizeof (ip4_address_t));
10777 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
10778 sizeof (ip4_address_t));
10779 clib_memcpy (mp->local_address_start, &laddr4_start,
10780 sizeof (ip4_address_t));
10781 clib_memcpy (mp->local_address_stop, &laddr4_stop,
10782 sizeof (ip4_address_t));
10784 mp->protocol = (u8) protocol;
10785 mp->local_port_start = ntohs ((u16) lport_start);
10786 mp->local_port_stop = ntohs ((u16) lport_stop);
10787 mp->remote_port_start = ntohs ((u16) rport_start);
10788 mp->remote_port_stop = ntohs ((u16) rport_stop);
10789 mp->policy = (u8) policy;
10790 mp->sa_id = ntohl (sa_id);
10791 mp->is_add = is_add;
10792 mp->is_ip_any = is_ip_any;
10798 clib_warning ("unsupported (no dpdk)");
10804 api_ipsec_sad_add_del_entry (vat_main_t * vam)
10807 unformat_input_t *i = vam->input;
10808 vl_api_ipsec_sad_add_del_entry_t *mp;
10810 u32 sad_id = 0, spi = 0;
10811 u8 *ck = 0, *ik = 0;
10814 u8 protocol = IPSEC_PROTOCOL_AH;
10815 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
10816 u32 crypto_alg = 0, integ_alg = 0;
10817 ip4_address_t tun_src4;
10818 ip4_address_t tun_dst4;
10819 ip6_address_t tun_src6;
10820 ip6_address_t tun_dst6;
10822 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10824 if (unformat (i, "del"))
10826 else if (unformat (i, "sad_id %d", &sad_id))
10828 else if (unformat (i, "spi %d", &spi))
10830 else if (unformat (i, "esp"))
10831 protocol = IPSEC_PROTOCOL_ESP;
10832 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
10835 is_tunnel_ipv6 = 0;
10837 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
10840 is_tunnel_ipv6 = 0;
10842 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
10845 is_tunnel_ipv6 = 1;
10847 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
10850 is_tunnel_ipv6 = 1;
10854 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
10856 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
10857 crypto_alg > IPSEC_INTEG_ALG_SHA_512_256)
10859 clib_warning ("unsupported crypto-alg: '%U'",
10860 format_ipsec_crypto_alg, crypto_alg);
10864 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
10868 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
10870 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
10871 integ_alg > IPSEC_INTEG_ALG_SHA_512_256)
10873 clib_warning ("unsupported integ-alg: '%U'",
10874 format_ipsec_integ_alg, integ_alg);
10878 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
10882 clib_warning ("parse error '%U'", format_unformat_error, i);
10888 M (IPSEC_SAD_ADD_DEL_ENTRY, ipsec_sad_add_del_entry);
10890 mp->sad_id = ntohl (sad_id);
10891 mp->is_add = is_add;
10892 mp->protocol = protocol;
10893 mp->spi = ntohl (spi);
10894 mp->is_tunnel = is_tunnel;
10895 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
10896 mp->crypto_algorithm = crypto_alg;
10897 mp->integrity_algorithm = integ_alg;
10898 mp->crypto_key_length = vec_len (ck);
10899 mp->integrity_key_length = vec_len (ik);
10901 if (mp->crypto_key_length > sizeof (mp->crypto_key))
10902 mp->crypto_key_length = sizeof (mp->crypto_key);
10904 if (mp->integrity_key_length > sizeof (mp->integrity_key))
10905 mp->integrity_key_length = sizeof (mp->integrity_key);
10908 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
10910 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
10914 if (is_tunnel_ipv6)
10916 clib_memcpy (mp->tunnel_src_address, &tun_src6,
10917 sizeof (ip6_address_t));
10918 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
10919 sizeof (ip6_address_t));
10923 clib_memcpy (mp->tunnel_src_address, &tun_src4,
10924 sizeof (ip4_address_t));
10925 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
10926 sizeof (ip4_address_t));
10935 clib_warning ("unsupported (no dpdk)");
10941 api_ipsec_sa_set_key (vat_main_t * vam)
10944 unformat_input_t *i = vam->input;
10945 vl_api_ipsec_sa_set_key_t *mp;
10948 u8 *ck = 0, *ik = 0;
10950 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10952 if (unformat (i, "sa_id %d", &sa_id))
10954 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
10956 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
10960 clib_warning ("parse error '%U'", format_unformat_error, i);
10965 M (IPSEC_SA_SET_KEY, ipsec_set_sa_key);
10967 mp->sa_id = ntohl (sa_id);
10968 mp->crypto_key_length = vec_len (ck);
10969 mp->integrity_key_length = vec_len (ik);
10971 if (mp->crypto_key_length > sizeof (mp->crypto_key))
10972 mp->crypto_key_length = sizeof (mp->crypto_key);
10974 if (mp->integrity_key_length > sizeof (mp->integrity_key))
10975 mp->integrity_key_length = sizeof (mp->integrity_key);
10978 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
10980 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
10987 clib_warning ("unsupported (no dpdk)");
10993 api_ikev2_profile_add_del (vat_main_t * vam)
10996 unformat_input_t *i = vam->input;
10997 vl_api_ikev2_profile_add_del_t *mp;
11002 const char *valid_chars = "a-zA-Z0-9_";
11004 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11006 if (unformat (i, "del"))
11008 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11009 vec_add1 (name, 0);
11012 errmsg ("parse error '%U'", format_unformat_error, i);
11017 if (!vec_len (name))
11019 errmsg ("profile name must be specified");
11023 if (vec_len (name) > 64)
11025 errmsg ("profile name too long");
11029 M (IKEV2_PROFILE_ADD_DEL, ikev2_profile_add_del);
11031 clib_memcpy (mp->name, name, vec_len (name));
11032 mp->is_add = is_add;
11040 clib_warning ("unsupported (no dpdk)");
11046 api_ikev2_profile_set_auth (vat_main_t * vam)
11049 unformat_input_t *i = vam->input;
11050 vl_api_ikev2_profile_set_auth_t *mp;
11054 u32 auth_method = 0;
11057 const char *valid_chars = "a-zA-Z0-9_";
11059 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11061 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11062 vec_add1 (name, 0);
11063 else if (unformat (i, "auth_method %U",
11064 unformat_ikev2_auth_method, &auth_method))
11066 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
11068 else if (unformat (i, "auth_data %v", &data))
11072 errmsg ("parse error '%U'", format_unformat_error, i);
11077 if (!vec_len (name))
11079 errmsg ("profile name must be specified");
11083 if (vec_len (name) > 64)
11085 errmsg ("profile name too long");
11089 if (!vec_len (data))
11091 errmsg ("auth_data must be specified");
11097 errmsg ("auth_method must be specified");
11101 M (IKEV2_PROFILE_SET_AUTH, ikev2_profile_set_auth);
11103 mp->is_hex = is_hex;
11104 mp->auth_method = (u8) auth_method;
11105 mp->data_len = vec_len (data);
11106 clib_memcpy (mp->name, name, vec_len (name));
11107 clib_memcpy (mp->data, data, vec_len (data));
11116 clib_warning ("unsupported (no dpdk)");
11122 api_ikev2_profile_set_id (vat_main_t * vam)
11125 unformat_input_t *i = vam->input;
11126 vl_api_ikev2_profile_set_id_t *mp;
11134 const char *valid_chars = "a-zA-Z0-9_";
11136 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11138 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11139 vec_add1 (name, 0);
11140 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
11142 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
11144 data = vec_new (u8, 4);
11145 clib_memcpy (data, ip4.as_u8, 4);
11147 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
11149 else if (unformat (i, "id_data %v", &data))
11151 else if (unformat (i, "local"))
11153 else if (unformat (i, "remote"))
11157 errmsg ("parse error '%U'", format_unformat_error, i);
11162 if (!vec_len (name))
11164 errmsg ("profile name must be specified");
11168 if (vec_len (name) > 64)
11170 errmsg ("profile name too long");
11174 if (!vec_len (data))
11176 errmsg ("id_data must be specified");
11182 errmsg ("id_type must be specified");
11186 M (IKEV2_PROFILE_SET_ID, ikev2_profile_set_id);
11188 mp->is_local = is_local;
11189 mp->id_type = (u8) id_type;
11190 mp->data_len = vec_len (data);
11191 clib_memcpy (mp->name, name, vec_len (name));
11192 clib_memcpy (mp->data, data, vec_len (data));
11201 clib_warning ("unsupported (no dpdk)");
11207 api_ikev2_profile_set_ts (vat_main_t * vam)
11210 unformat_input_t *i = vam->input;
11211 vl_api_ikev2_profile_set_ts_t *mp;
11215 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
11216 ip4_address_t start_addr, end_addr;
11218 const char *valid_chars = "a-zA-Z0-9_";
11220 start_addr.as_u32 = 0;
11221 end_addr.as_u32 = (u32) ~ 0;
11223 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11225 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11226 vec_add1 (name, 0);
11227 else if (unformat (i, "protocol %d", &proto))
11229 else if (unformat (i, "start_port %d", &start_port))
11231 else if (unformat (i, "end_port %d", &end_port))
11234 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
11236 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
11238 else if (unformat (i, "local"))
11240 else if (unformat (i, "remote"))
11244 errmsg ("parse error '%U'", format_unformat_error, i);
11249 if (!vec_len (name))
11251 errmsg ("profile name must be specified");
11255 if (vec_len (name) > 64)
11257 errmsg ("profile name too long");
11261 M (IKEV2_PROFILE_SET_TS, ikev2_profile_set_ts);
11263 mp->is_local = is_local;
11264 mp->proto = (u8) proto;
11265 mp->start_port = (u16) start_port;
11266 mp->end_port = (u16) end_port;
11267 mp->start_addr = start_addr.as_u32;
11268 mp->end_addr = end_addr.as_u32;
11269 clib_memcpy (mp->name, name, vec_len (name));
11277 clib_warning ("unsupported (no dpdk)");
11283 api_ikev2_set_local_key (vat_main_t * vam)
11286 unformat_input_t *i = vam->input;
11287 vl_api_ikev2_set_local_key_t *mp;
11291 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11293 if (unformat (i, "file %v", &file))
11294 vec_add1 (file, 0);
11297 errmsg ("parse error '%U'", format_unformat_error, i);
11302 if (!vec_len (file))
11304 errmsg ("RSA key file must be specified");
11308 if (vec_len (file) > 256)
11310 errmsg ("file name too long");
11314 M (IKEV2_SET_LOCAL_KEY, ikev2_set_local_key);
11316 clib_memcpy (mp->key_file, file, vec_len (file));
11324 clib_warning ("unsupported (no dpdk)");
11333 api_map_add_domain (vat_main_t * vam)
11335 unformat_input_t *i = vam->input;
11336 vl_api_map_add_domain_t *mp;
11339 ip4_address_t ip4_prefix;
11340 ip6_address_t ip6_prefix;
11341 ip6_address_t ip6_src;
11342 u32 num_m_args = 0;
11343 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
11344 0, psid_length = 0;
11345 u8 is_translation = 0;
11347 u32 ip6_src_len = 128;
11349 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11351 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
11352 &ip4_prefix, &ip4_prefix_len))
11354 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
11355 &ip6_prefix, &ip6_prefix_len))
11359 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
11362 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
11364 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
11366 else if (unformat (i, "psid-offset %d", &psid_offset))
11368 else if (unformat (i, "psid-len %d", &psid_length))
11370 else if (unformat (i, "mtu %d", &mtu))
11372 else if (unformat (i, "map-t"))
11373 is_translation = 1;
11376 clib_warning ("parse error '%U'", format_unformat_error, i);
11381 if (num_m_args < 3)
11383 errmsg ("mandatory argument(s) missing\n");
11387 /* Construct the API message */
11388 M (MAP_ADD_DOMAIN, map_add_domain);
11390 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
11391 mp->ip4_prefix_len = ip4_prefix_len;
11393 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
11394 mp->ip6_prefix_len = ip6_prefix_len;
11396 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
11397 mp->ip6_src_prefix_len = ip6_src_len;
11399 mp->ea_bits_len = ea_bits_len;
11400 mp->psid_offset = psid_offset;
11401 mp->psid_length = psid_length;
11402 mp->is_translation = is_translation;
11403 mp->mtu = htons (mtu);
11408 /* Wait for a reply, return good/bad news */
11413 api_map_del_domain (vat_main_t * vam)
11415 unformat_input_t *i = vam->input;
11416 vl_api_map_del_domain_t *mp;
11419 u32 num_m_args = 0;
11422 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11424 if (unformat (i, "index %d", &index))
11428 clib_warning ("parse error '%U'", format_unformat_error, i);
11433 if (num_m_args != 1)
11435 errmsg ("mandatory argument(s) missing\n");
11439 /* Construct the API message */
11440 M (MAP_DEL_DOMAIN, map_del_domain);
11442 mp->index = ntohl (index);
11447 /* Wait for a reply, return good/bad news */
11452 api_map_add_del_rule (vat_main_t * vam)
11454 unformat_input_t *i = vam->input;
11455 vl_api_map_add_del_rule_t *mp;
11458 ip6_address_t ip6_dst;
11459 u32 num_m_args = 0, index, psid = 0;
11461 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11463 if (unformat (i, "index %d", &index))
11465 else if (unformat (i, "psid %d", &psid))
11467 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
11469 else if (unformat (i, "del"))
11475 clib_warning ("parse error '%U'", format_unformat_error, i);
11480 /* Construct the API message */
11481 M (MAP_ADD_DEL_RULE, map_add_del_rule);
11483 mp->index = ntohl (index);
11484 mp->is_add = is_add;
11485 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
11486 mp->psid = ntohs (psid);
11491 /* Wait for a reply, return good/bad news */
11496 api_map_domain_dump (vat_main_t * vam)
11498 vl_api_map_domain_dump_t *mp;
11501 /* Construct the API message */
11502 M (MAP_DOMAIN_DUMP, map_domain_dump);
11507 /* Use a control ping for synchronization */
11509 vl_api_control_ping_t *mp;
11510 M (CONTROL_PING, control_ping);
11517 api_map_rule_dump (vat_main_t * vam)
11519 unformat_input_t *i = vam->input;
11520 vl_api_map_rule_dump_t *mp;
11522 u32 domain_index = ~0;
11524 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11526 if (unformat (i, "index %u", &domain_index))
11532 if (domain_index == ~0)
11534 clib_warning ("parse error: domain index expected");
11538 /* Construct the API message */
11539 M (MAP_RULE_DUMP, map_rule_dump);
11541 mp->domain_index = htonl (domain_index);
11546 /* Use a control ping for synchronization */
11548 vl_api_control_ping_t *mp;
11549 M (CONTROL_PING, control_ping);
11555 static void vl_api_map_add_domain_reply_t_handler
11556 (vl_api_map_add_domain_reply_t * mp)
11558 vat_main_t *vam = &vat_main;
11559 i32 retval = ntohl (mp->retval);
11561 if (vam->async_mode)
11563 vam->async_errors += (retval < 0);
11567 vam->retval = retval;
11568 vam->result_ready = 1;
11572 static void vl_api_map_add_domain_reply_t_handler_json
11573 (vl_api_map_add_domain_reply_t * mp)
11575 vat_main_t *vam = &vat_main;
11576 vat_json_node_t node;
11578 vat_json_init_object (&node);
11579 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
11580 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
11582 vat_json_print (vam->ofp, &node);
11583 vat_json_free (&node);
11585 vam->retval = ntohl (mp->retval);
11586 vam->result_ready = 1;
11590 api_get_first_msg_id (vat_main_t * vam)
11592 vl_api_get_first_msg_id_t *mp;
11594 unformat_input_t *i = vam->input;
11598 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11600 if (unformat (i, "client %s", &name))
11608 errmsg ("missing client name\n");
11611 vec_add1 (name, 0);
11613 if (vec_len (name) > 63)
11615 errmsg ("client name too long\n");
11619 M (GET_FIRST_MSG_ID, get_first_msg_id);
11620 clib_memcpy (mp->name, name, vec_len (name));
11628 api_cop_interface_enable_disable (vat_main_t * vam)
11630 unformat_input_t *line_input = vam->input;
11631 vl_api_cop_interface_enable_disable_t *mp;
11633 u32 sw_if_index = ~0;
11634 u8 enable_disable = 1;
11636 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11638 if (unformat (line_input, "disable"))
11639 enable_disable = 0;
11640 if (unformat (line_input, "enable"))
11641 enable_disable = 1;
11642 else if (unformat (line_input, "%U", unformat_sw_if_index,
11643 vam, &sw_if_index))
11645 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11651 if (sw_if_index == ~0)
11653 errmsg ("missing interface name or sw_if_index\n");
11657 /* Construct the API message */
11658 M (COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable);
11659 mp->sw_if_index = ntohl (sw_if_index);
11660 mp->enable_disable = enable_disable;
11664 /* Wait for the reply */
11669 api_cop_whitelist_enable_disable (vat_main_t * vam)
11671 unformat_input_t *line_input = vam->input;
11672 vl_api_cop_whitelist_enable_disable_t *mp;
11674 u32 sw_if_index = ~0;
11675 u8 ip4 = 0, ip6 = 0, default_cop = 0;
11678 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11680 if (unformat (line_input, "ip4"))
11682 else if (unformat (line_input, "ip6"))
11684 else if (unformat (line_input, "default"))
11686 else if (unformat (line_input, "%U", unformat_sw_if_index,
11687 vam, &sw_if_index))
11689 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11691 else if (unformat (line_input, "fib-id %d", &fib_id))
11697 if (sw_if_index == ~0)
11699 errmsg ("missing interface name or sw_if_index\n");
11703 /* Construct the API message */
11704 M (COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable);
11705 mp->sw_if_index = ntohl (sw_if_index);
11706 mp->fib_id = ntohl (fib_id);
11709 mp->default_cop = default_cop;
11713 /* Wait for the reply */
11718 api_get_node_graph (vat_main_t * vam)
11720 vl_api_get_node_graph_t *mp;
11723 M (GET_NODE_GRAPH, get_node_graph);
11727 /* Wait for the reply */
11732 /** Used for parsing LISP eids */
11733 typedef CLIB_PACKED(struct{
11734 u8 addr[16]; /**< eid address */
11735 u32 len; /**< prefix length if IP */
11736 u8 type; /**< type of eid */
11741 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
11743 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
11745 memset (a, 0, sizeof (a[0]));
11747 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
11749 a->type = 0; /* ipv4 type */
11751 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
11753 a->type = 1; /* ipv6 type */
11755 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
11757 a->type = 2; /* mac type */
11764 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
11773 lisp_eid_size_vat (u8 type)
11788 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
11790 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
11794 /** Used for transferring locators via VPP API */
11795 typedef CLIB_PACKED(struct
11797 u32 sw_if_index; /**< locator sw_if_index */
11798 u8 priority; /**< locator priority */
11799 u8 weight; /**< locator weight */
11804 api_lisp_add_del_locator_set (vat_main_t * vam)
11806 unformat_input_t *input = vam->input;
11807 vl_api_lisp_add_del_locator_set_t *mp;
11810 u8 *locator_set_name = NULL;
11811 u8 locator_set_name_set = 0;
11812 ls_locator_t locator, *locators = 0;
11813 u32 sw_if_index, priority, weight;
11815 /* Parse args required to build the message */
11816 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11818 if (unformat (input, "del"))
11822 else if (unformat (input, "locator-set %s", &locator_set_name))
11824 locator_set_name_set = 1;
11826 else if (unformat (input, "sw_if_index %u p %u w %u",
11827 &sw_if_index, &priority, &weight))
11829 locator.sw_if_index = htonl (sw_if_index);
11830 locator.priority = priority;
11831 locator.weight = weight;
11832 vec_add1 (locators, locator);
11834 else if (unformat (input, "iface %U p %u w %u", unformat_sw_if_index,
11835 vam, &sw_if_index, &priority, &weight))
11837 locator.sw_if_index = htonl (sw_if_index);
11838 locator.priority = priority;
11839 locator.weight = weight;
11840 vec_add1 (locators, locator);
11846 if (locator_set_name_set == 0)
11848 errmsg ("missing locator-set name");
11849 vec_free (locators);
11853 if (vec_len (locator_set_name) > 64)
11855 errmsg ("locator-set name too long\n");
11856 vec_free (locator_set_name);
11857 vec_free (locators);
11860 vec_add1 (locator_set_name, 0);
11862 /* Construct the API message */
11863 M (LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set);
11865 mp->is_add = is_add;
11866 clib_memcpy (mp->locator_set_name, locator_set_name,
11867 vec_len (locator_set_name));
11868 vec_free (locator_set_name);
11870 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
11872 clib_memcpy (mp->locators, locators,
11873 (sizeof (ls_locator_t) * vec_len (locators)));
11874 vec_free (locators);
11879 /* Wait for a reply... */
11887 api_lisp_add_del_locator (vat_main_t * vam)
11889 unformat_input_t *input = vam->input;
11890 vl_api_lisp_add_del_locator_t *mp;
11892 u32 tmp_if_index = ~0;
11893 u32 sw_if_index = ~0;
11894 u8 sw_if_index_set = 0;
11895 u8 sw_if_index_if_name_set = 0;
11897 u8 priority_set = 0;
11901 u8 *locator_set_name = NULL;
11902 u8 locator_set_name_set = 0;
11904 /* Parse args required to build the message */
11905 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11907 if (unformat (input, "del"))
11911 else if (unformat (input, "locator-set %s", &locator_set_name))
11913 locator_set_name_set = 1;
11915 else if (unformat (input, "iface %U", unformat_sw_if_index, vam,
11918 sw_if_index_if_name_set = 1;
11919 sw_if_index = tmp_if_index;
11921 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
11923 sw_if_index_set = 1;
11924 sw_if_index = tmp_if_index;
11926 else if (unformat (input, "p %d", &priority))
11930 else if (unformat (input, "w %d", &weight))
11938 if (locator_set_name_set == 0)
11940 errmsg ("missing locator-set name");
11944 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
11946 errmsg ("missing sw_if_index");
11947 vec_free (locator_set_name);
11951 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
11953 errmsg ("cannot use both params interface name and sw_if_index");
11954 vec_free (locator_set_name);
11958 if (priority_set == 0)
11960 errmsg ("missing locator-set priority\n");
11961 vec_free (locator_set_name);
11965 if (weight_set == 0)
11967 errmsg ("missing locator-set weight\n");
11968 vec_free (locator_set_name);
11972 if (vec_len (locator_set_name) > 64)
11974 errmsg ("locator-set name too long\n");
11975 vec_free (locator_set_name);
11978 vec_add1 (locator_set_name, 0);
11980 /* Construct the API message */
11981 M (LISP_ADD_DEL_LOCATOR, lisp_add_del_locator);
11983 mp->is_add = is_add;
11984 mp->sw_if_index = ntohl (sw_if_index);
11985 mp->priority = priority;
11986 mp->weight = weight;
11987 clib_memcpy (mp->locator_set_name, locator_set_name,
11988 vec_len (locator_set_name));
11989 vec_free (locator_set_name);
11994 /* Wait for a reply... */
12002 api_lisp_add_del_local_eid (vat_main_t * vam)
12004 unformat_input_t *input = vam->input;
12005 vl_api_lisp_add_del_local_eid_t *mp;
12009 lisp_eid_vat_t _eid, *eid = &_eid;
12010 u8 *locator_set_name = 0;
12011 u8 locator_set_name_set = 0;
12014 /* Parse args required to build the message */
12015 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12017 if (unformat (input, "del"))
12021 else if (unformat (input, "vni %d", &vni))
12025 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
12029 else if (unformat (input, "locator-set %s", &locator_set_name))
12031 locator_set_name_set = 1;
12037 if (locator_set_name_set == 0)
12039 errmsg ("missing locator-set name\n");
12045 errmsg ("EID address not set!");
12046 vec_free (locator_set_name);
12050 if (vec_len (locator_set_name) > 64)
12052 errmsg ("locator-set name too long\n");
12053 vec_free (locator_set_name);
12056 vec_add1 (locator_set_name, 0);
12058 /* Construct the API message */
12059 M (LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid);
12061 mp->is_add = is_add;
12062 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
12063 mp->eid_type = eid->type;
12064 mp->prefix_len = eid->len;
12065 mp->vni = clib_host_to_net_u32 (vni);
12066 clib_memcpy (mp->locator_set_name, locator_set_name,
12067 vec_len (locator_set_name));
12069 vec_free (locator_set_name);
12074 /* Wait for a reply... */
12082 /** Used for transferring locators via VPP API */
12083 typedef CLIB_PACKED(struct
12085 u8 is_ip4; /**< is locator an IPv4 address? */
12086 u8 priority; /**< locator priority */
12087 u8 weight; /**< locator weight */
12088 u8 addr[16]; /**< IPv4/IPv6 address */
12093 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
12095 unformat_input_t *input = vam->input;
12096 vl_api_lisp_gpe_add_del_fwd_entry_t *mp;
12099 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
12100 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
12101 u8 rmt_eid_set = 0, lcl_eid_set = 0;
12102 u32 action = ~0, p, w;
12103 ip4_address_t rmt_rloc4, lcl_rloc4;
12104 ip6_address_t rmt_rloc6, lcl_rloc6;
12105 rloc_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
12107 memset (&rloc, 0, sizeof (rloc));
12109 /* Parse args required to build the message */
12110 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12112 if (unformat (input, "del"))
12116 else if (unformat (input, "rmt_eid %U", unformat_lisp_eid_vat, rmt_eid))
12120 else if (unformat (input, "lcl_eid %U", unformat_lisp_eid_vat, lcl_eid))
12124 else if (unformat (input, "p %d w %d", &p, &w))
12128 errmsg ("No RLOC configured for setting priority/weight!");
12131 curr_rloc->priority = p;
12132 curr_rloc->weight = w;
12134 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
12135 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
12139 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
12140 rloc.priority = rloc.weight = 0;
12141 vec_add1 (lcl_locs, rloc);
12143 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
12144 vec_add1 (rmt_locs, rloc);
12145 /* priority and weight saved in rmt loc */
12146 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
12148 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
12149 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
12152 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
12153 rloc.priority = rloc.weight = 0;
12154 vec_add1 (lcl_locs, rloc);
12156 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
12157 vec_add1 (rmt_locs, rloc);
12158 /* priority and weight saved in rmt loc */
12159 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
12161 else if (unformat (input, "action %d", &action))
12167 clib_warning ("parse error '%U'", format_unformat_error, input);
12174 errmsg ("remote eid addresses not set\n");
12178 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
12180 errmsg ("eid types don't match\n");
12184 if (0 == rmt_locs && (u32) ~ 0 == action)
12186 errmsg ("action not set for negative mapping\n");
12190 /* Construct the API message */
12191 M (LISP_GPE_ADD_DEL_FWD_ENTRY, lisp_gpe_add_del_fwd_entry);
12193 mp->is_add = is_add;
12194 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
12195 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
12196 mp->eid_type = rmt_eid->type;
12197 mp->rmt_len = rmt_eid->len;
12198 mp->lcl_len = lcl_eid->len;
12199 mp->action = action;
12201 if (0 != rmt_locs && 0 != lcl_locs)
12203 mp->loc_num = vec_len (rmt_locs);
12204 clib_memcpy (mp->lcl_locs, lcl_locs,
12205 (sizeof (rloc_t) * vec_len (lcl_locs)));
12206 clib_memcpy (mp->rmt_locs, rmt_locs,
12207 (sizeof (rloc_t) * vec_len (rmt_locs)));
12209 vec_free (lcl_locs);
12210 vec_free (rmt_locs);
12215 /* Wait for a reply... */
12223 api_lisp_add_del_map_resolver (vat_main_t * vam)
12225 unformat_input_t *input = vam->input;
12226 vl_api_lisp_add_del_map_resolver_t *mp;
12231 ip4_address_t ipv4;
12232 ip6_address_t ipv6;
12234 /* Parse args required to build the message */
12235 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12237 if (unformat (input, "del"))
12241 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
12245 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
12253 if (ipv4_set && ipv6_set)
12255 errmsg ("both eid v4 and v6 addresses set\n");
12259 if (!ipv4_set && !ipv6_set)
12261 errmsg ("eid addresses not set\n");
12265 /* Construct the API message */
12266 M (LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver);
12268 mp->is_add = is_add;
12272 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
12277 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
12283 /* Wait for a reply... */
12291 api_lisp_gpe_enable_disable (vat_main_t * vam)
12293 unformat_input_t *input = vam->input;
12294 vl_api_lisp_gpe_enable_disable_t *mp;
12299 /* Parse args required to build the message */
12300 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12302 if (unformat (input, "enable"))
12307 else if (unformat (input, "disable"))
12318 errmsg ("Value not set\n");
12322 /* Construct the API message */
12323 M (LISP_GPE_ENABLE_DISABLE, lisp_gpe_enable_disable);
12330 /* Wait for a reply... */
12338 api_lisp_enable_disable (vat_main_t * vam)
12340 unformat_input_t *input = vam->input;
12341 vl_api_lisp_enable_disable_t *mp;
12346 /* Parse args required to build the message */
12347 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12349 if (unformat (input, "enable"))
12354 else if (unformat (input, "disable"))
12364 errmsg ("Value not set\n");
12368 /* Construct the API message */
12369 M (LISP_ENABLE_DISABLE, lisp_enable_disable);
12376 /* Wait for a reply... */
12384 * Enable/disable LISP proxy ITR.
12386 * @param vam vpp API test context
12387 * @return return code
12390 api_lisp_pitr_set_locator_set (vat_main_t * vam)
12393 u8 ls_name_set = 0;
12394 unformat_input_t *input = vam->input;
12395 vl_api_lisp_pitr_set_locator_set_t *mp;
12399 /* Parse args required to build the message */
12400 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12402 if (unformat (input, "del"))
12404 else if (unformat (input, "locator-set %s", &ls_name))
12408 errmsg ("parse error '%U'", format_unformat_error, input);
12415 errmsg ("locator-set name not set!");
12419 M (LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set);
12421 mp->is_add = is_add;
12422 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
12423 vec_free (ls_name);
12428 /* wait for reply */
12436 api_show_lisp_pitr (vat_main_t * vam)
12438 vl_api_show_lisp_pitr_t *mp;
12441 if (!vam->json_output)
12443 fformat (vam->ofp, "%=20s\n", "lisp status:");
12446 M (SHOW_LISP_PITR, show_lisp_pitr);
12450 /* Wait for a reply... */
12458 * Add/delete mapping between vni and vrf
12461 api_lisp_eid_table_add_del_map (vat_main_t * vam)
12464 unformat_input_t *input = vam->input;
12465 vl_api_lisp_eid_table_add_del_map_t *mp;
12466 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
12467 u32 vni, vrf, bd_index;
12469 /* Parse args required to build the message */
12470 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12472 if (unformat (input, "del"))
12474 else if (unformat (input, "vrf %d", &vrf))
12476 else if (unformat (input, "bd_index %d", &bd_index))
12478 else if (unformat (input, "vni %d", &vni))
12484 if (!vni_set || (!vrf_set && !bd_index_set))
12486 errmsg ("missing arguments!");
12490 if (vrf_set && bd_index_set)
12492 errmsg ("error: both vrf and bd entered!");
12496 M (LISP_EID_TABLE_ADD_DEL_MAP, lisp_eid_table_add_del_map);
12498 mp->is_add = is_add;
12499 mp->vni = htonl (vni);
12500 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
12501 mp->is_l2 = bd_index_set;
12506 /* wait for reply */
12514 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
12516 u32 *action = va_arg (*args, u32 *);
12519 if (unformat (input, "%s", &s))
12521 if (!strcmp ((char *) s, "no-action"))
12523 else if (!strcmp ((char *) s, "natively-forward"))
12525 else if (!strcmp ((char *) s, "send-map-request"))
12527 else if (!strcmp ((char *) s, "drop"))
12531 clib_warning ("invalid action: '%s'", s);
12543 * Add/del remote mapping to/from LISP control plane
12545 * @param vam vpp API test context
12546 * @return return code
12549 api_lisp_add_del_remote_mapping (vat_main_t * vam)
12551 unformat_input_t *input = vam->input;
12552 vl_api_lisp_add_del_remote_mapping_t *mp;
12555 lisp_eid_vat_t _eid, *eid = &_eid;
12556 lisp_eid_vat_t _seid, *seid = &_seid;
12557 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
12558 u32 action = ~0, p, w;
12559 ip4_address_t rloc4;
12560 ip6_address_t rloc6;
12561 rloc_t *rlocs = 0, rloc, *curr_rloc = 0;
12563 memset (&rloc, 0, sizeof (rloc));
12565 /* Parse args required to build the message */
12566 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12568 if (unformat (input, "del-all"))
12572 else if (unformat (input, "del"))
12576 else if (unformat (input, "add"))
12580 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
12584 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
12588 else if (unformat (input, "vni %d", &vni))
12592 else if (unformat (input, "p %d w %d", &p, &w))
12596 errmsg ("No RLOC configured for setting priority/weight!");
12599 curr_rloc->priority = p;
12600 curr_rloc->weight = w;
12602 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
12605 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
12606 vec_add1 (rlocs, rloc);
12607 curr_rloc = &rlocs[vec_len (rlocs) - 1];
12609 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
12612 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
12613 vec_add1 (rlocs, rloc);
12614 curr_rloc = &rlocs[vec_len (rlocs) - 1];
12616 else if (unformat (input, "action %U",
12617 unformat_negative_mapping_action, &action))
12623 clib_warning ("parse error '%U'", format_unformat_error, input);
12630 errmsg ("missing params!");
12634 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
12636 errmsg ("no action set for negative map-reply!");
12640 M (LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping);
12641 mp->is_add = is_add;
12642 mp->vni = htonl (vni);
12643 mp->action = (u8) action;
12644 mp->is_src_dst = seid_set;
12645 mp->eid_len = eid->len;
12646 mp->seid_len = seid->len;
12647 mp->del_all = del_all;
12648 mp->eid_type = eid->type;
12649 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
12650 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
12652 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
12653 clib_memcpy (mp->rlocs, rlocs, (sizeof (rloc_t) * vec_len (rlocs)));
12659 /* Wait for a reply... */
12667 * Add/del LISP adjacency. Saves mapping in LISP control plane and updates
12668 * forwarding entries in data-plane accordingly.
12670 * @param vam vpp API test context
12671 * @return return code
12674 api_lisp_add_del_adjacency (vat_main_t * vam)
12676 unformat_input_t *input = vam->input;
12677 vl_api_lisp_add_del_adjacency_t *mp;
12680 ip4_address_t seid4, deid4;
12681 ip6_address_t seid6, deid6;
12682 u8 deid_mac[6] = { 0 };
12683 u8 seid_mac[6] = { 0 };
12684 u8 deid_type, seid_type;
12685 u32 seid_len = 0, deid_len = 0, len;
12688 seid_type = deid_type = (u8) ~ 0;
12690 /* Parse args required to build the message */
12691 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12693 if (unformat (input, "del"))
12697 else if (unformat (input, "add"))
12701 else if (unformat (input, "deid %U/%d", unformat_ip4_address,
12704 deid_type = 0; /* ipv4 */
12707 else if (unformat (input, "deid %U/%d", unformat_ip6_address,
12710 deid_type = 1; /* ipv6 */
12713 else if (unformat (input, "deid %U", unformat_ethernet_address,
12716 deid_type = 2; /* mac */
12718 else if (unformat (input, "seid %U/%d", unformat_ip4_address,
12721 seid_type = 0; /* ipv4 */
12724 else if (unformat (input, "seid %U/%d", unformat_ip6_address,
12727 seid_type = 1; /* ipv6 */
12730 else if (unformat (input, "seid %U", unformat_ethernet_address,
12733 seid_type = 2; /* mac */
12735 else if (unformat (input, "vni %d", &vni))
12741 errmsg ("parse error '%U'", format_unformat_error, input);
12746 if ((u8) ~ 0 == deid_type)
12748 errmsg ("missing params!");
12752 if (seid_type != deid_type)
12754 errmsg ("source and destination EIDs are of different types!");
12758 M (LISP_ADD_DEL_ADJACENCY, lisp_add_del_adjacency);
12759 mp->is_add = is_add;
12760 mp->vni = htonl (vni);
12761 mp->seid_len = seid_len;
12762 mp->deid_len = deid_len;
12763 mp->eid_type = deid_type;
12765 switch (mp->eid_type)
12768 clib_memcpy (mp->seid, &seid4, sizeof (seid4));
12769 clib_memcpy (mp->deid, &deid4, sizeof (deid4));
12772 clib_memcpy (mp->seid, &seid6, sizeof (seid6));
12773 clib_memcpy (mp->deid, &deid6, sizeof (deid6));
12776 clib_memcpy (mp->seid, seid_mac, 6);
12777 clib_memcpy (mp->deid, deid_mac, 6);
12780 errmsg ("unknown EID type %d!", mp->eid_type);
12787 /* Wait for a reply... */
12795 api_lisp_gpe_add_del_iface (vat_main_t * vam)
12797 unformat_input_t *input = vam->input;
12798 vl_api_lisp_gpe_add_del_iface_t *mp;
12800 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
12801 u32 dp_table = 0, vni = 0;
12803 /* Parse args required to build the message */
12804 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12806 if (unformat (input, "up"))
12811 else if (unformat (input, "down"))
12816 else if (unformat (input, "table_id %d", &dp_table))
12820 else if (unformat (input, "bd_id %d", &dp_table))
12825 else if (unformat (input, "vni %d", &vni))
12833 if (action_set == 0)
12835 errmsg ("Action not set\n");
12838 if (dp_table_set == 0 || vni_set == 0)
12840 errmsg ("vni and dp_table must be set\n");
12844 /* Construct the API message */
12845 M (LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface);
12847 mp->is_add = is_add;
12848 mp->dp_table = dp_table;
12855 /* Wait for a reply... */
12863 * Add/del map request itr rlocs from LISP control plane and updates
12865 * @param vam vpp API test context
12866 * @return return code
12869 api_lisp_add_del_map_request_itr_rlocs (vat_main_t * vam)
12871 unformat_input_t *input = vam->input;
12872 vl_api_lisp_add_del_map_request_itr_rlocs_t *mp;
12874 u8 *locator_set_name = 0;
12875 u8 locator_set_name_set = 0;
12878 /* Parse args required to build the message */
12879 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12881 if (unformat (input, "del"))
12885 else if (unformat (input, "%_%v%_", &locator_set_name))
12887 locator_set_name_set = 1;
12891 clib_warning ("parse error '%U'", format_unformat_error, input);
12896 if (is_add && !locator_set_name_set)
12898 errmsg ("itr-rloc is not set!");
12902 if (is_add && vec_len (locator_set_name) > 64)
12904 errmsg ("itr-rloc locator-set name too long\n");
12905 vec_free (locator_set_name);
12909 M (LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, lisp_add_del_map_request_itr_rlocs);
12910 mp->is_add = is_add;
12913 clib_memcpy (mp->locator_set_name, locator_set_name,
12914 vec_len (locator_set_name));
12918 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
12920 vec_free (locator_set_name);
12925 /* Wait for a reply... */
12933 api_lisp_locator_dump (vat_main_t * vam)
12935 unformat_input_t *input = vam->input;
12936 vl_api_lisp_locator_dump_t *mp;
12938 u8 is_index_set = 0, is_name_set = 0;
12942 /* Parse args required to build the message */
12943 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12945 if (unformat (input, "ls_name %_%v%_", &ls_name))
12949 else if (unformat (input, "ls_index %d", &ls_index))
12955 errmsg ("parse error '%U'", format_unformat_error, input);
12960 if (!is_index_set && !is_name_set)
12962 errmsg ("error: expected one of index or name!\n");
12966 if (is_index_set && is_name_set)
12968 errmsg ("error: only one param expected!\n");
12972 if (vec_len (ls_name) > 62)
12974 errmsg ("error: locator set name too long!");
12978 if (!vam->json_output)
12980 fformat (vam->ofp, "%=16s%=16s%=16s\n", "locator", "priority",
12984 M (LISP_LOCATOR_DUMP, lisp_locator_dump);
12985 mp->is_index_set = is_index_set;
12988 mp->ls_index = clib_host_to_net_u32 (ls_index);
12991 vec_add1 (ls_name, 0);
12992 strncpy ((char *) mp->ls_name, (char *) ls_name,
12993 sizeof (mp->ls_name) - 1);
12999 /* Use a control ping for synchronization */
13001 vl_api_control_ping_t *mp;
13002 M (CONTROL_PING, control_ping);
13005 /* Wait for a reply... */
13013 api_lisp_locator_set_dump (vat_main_t * vam)
13015 vl_api_lisp_locator_set_dump_t *mp;
13016 unformat_input_t *input = vam->input;
13020 /* Parse args required to build the message */
13021 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13023 if (unformat (input, "local"))
13027 else if (unformat (input, "remote"))
13033 errmsg ("parse error '%U'", format_unformat_error, input);
13038 if (!vam->json_output)
13040 fformat (vam->ofp, "%=10s%=15s\n", "ls_index", "ls_name");
13043 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
13045 mp->filter = filter;
13050 /* Use a control ping for synchronization */
13052 vl_api_control_ping_t *mp;
13053 M (CONTROL_PING, control_ping);
13056 /* Wait for a reply... */
13064 api_lisp_eid_table_map_dump (vat_main_t * vam)
13068 unformat_input_t *input = vam->input;
13069 vl_api_lisp_eid_table_map_dump_t *mp;
13072 /* Parse args required to build the message */
13073 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13075 if (unformat (input, "l2"))
13080 else if (unformat (input, "l3"))
13087 errmsg ("parse error '%U'", format_unformat_error, input);
13094 errmsg ("expected one of 'l2' or 'l3' parameter!\n");
13098 if (!vam->json_output)
13100 fformat (vam->ofp, "%=10s%=10s\n", "VNI", is_l2 ? "BD" : "VRF");
13103 M (LISP_EID_TABLE_MAP_DUMP, lisp_eid_table_map_dump);
13109 /* Use a control ping for synchronization */
13111 vl_api_control_ping_t *mp;
13112 M (CONTROL_PING, control_ping);
13115 /* Wait for a reply... */
13123 api_lisp_eid_table_vni_dump (vat_main_t * vam)
13125 vl_api_lisp_eid_table_vni_dump_t *mp;
13128 if (!vam->json_output)
13130 fformat (vam->ofp, "VNI\n");
13133 M (LISP_EID_TABLE_VNI_DUMP, lisp_eid_table_vni_dump);
13138 /* Use a control ping for synchronization */
13140 vl_api_control_ping_t *mp;
13141 M (CONTROL_PING, control_ping);
13144 /* Wait for a reply... */
13152 api_lisp_eid_table_dump (vat_main_t * vam)
13154 unformat_input_t *i = vam->input;
13155 vl_api_lisp_eid_table_dump_t *mp;
13157 struct in_addr ip4;
13158 struct in6_addr ip6;
13160 u8 eid_type = ~0, eid_set = 0;
13161 u32 prefix_length = ~0, t, vni = 0;
13164 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13166 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
13172 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
13178 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
13183 else if (unformat (i, "vni %d", &t))
13187 else if (unformat (i, "local"))
13191 else if (unformat (i, "remote"))
13197 errmsg ("parse error '%U'", format_unformat_error, i);
13202 if (!vam->json_output)
13204 fformat (vam->ofp, "%-35s%-20s%-30s%-20s%-s\n", "EID", "type",
13205 "ls_index", "ttl", "authoritative");
13208 M (LISP_EID_TABLE_DUMP, lisp_eid_table_dump);
13210 mp->filter = filter;
13214 mp->vni = htonl (vni);
13215 mp->eid_type = eid_type;
13219 mp->prefix_length = prefix_length;
13220 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
13223 mp->prefix_length = prefix_length;
13224 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
13227 clib_memcpy (mp->eid, mac, sizeof (mac));
13230 errmsg ("unknown EID type %d!", eid_type);
13238 /* Use a control ping for synchronization */
13240 vl_api_control_ping_t *mp;
13241 M (CONTROL_PING, control_ping);
13245 /* Wait for a reply... */
13253 api_lisp_gpe_tunnel_dump (vat_main_t * vam)
13255 vl_api_lisp_gpe_tunnel_dump_t *mp;
13258 if (!vam->json_output)
13260 fformat (vam->ofp, "%=20s%=30s%=16s%=16s%=16s%=16s"
13261 "%=16s%=16s%=16s%=16s%=16s\n",
13262 "Tunel", "Source", "Destination", "Fib encap", "Fib decap",
13263 "Decap next", "Lisp version", "Flags", "Next protocol",
13264 "ver_res", "res", "iid");
13267 M (LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump);
13271 /* Use a control ping for synchronization */
13273 vl_api_control_ping_t *mp;
13274 M (CONTROL_PING, control_ping);
13277 /* Wait for a reply... */
13285 api_lisp_map_resolver_dump (vat_main_t * vam)
13287 vl_api_lisp_map_resolver_dump_t *mp;
13290 if (!vam->json_output)
13292 fformat (vam->ofp, "%=20s\n", "Map resolver");
13295 M (LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump);
13299 /* Use a control ping for synchronization */
13301 vl_api_control_ping_t *mp;
13302 M (CONTROL_PING, control_ping);
13305 /* Wait for a reply... */
13313 api_show_lisp_status (vat_main_t * vam)
13315 vl_api_show_lisp_status_t *mp;
13318 if (!vam->json_output)
13320 fformat (vam->ofp, "%-20s%-16s\n", "lisp status", "locator-set");
13323 M (SHOW_LISP_STATUS, show_lisp_status);
13326 /* Wait for a reply... */
13334 api_lisp_get_map_request_itr_rlocs (vat_main_t * vam)
13336 vl_api_lisp_get_map_request_itr_rlocs_t *mp;
13339 if (!vam->json_output)
13341 fformat (vam->ofp, "%=20s\n", "itr-rlocs:");
13344 M (LISP_GET_MAP_REQUEST_ITR_RLOCS, lisp_get_map_request_itr_rlocs);
13347 /* Wait for a reply... */
13355 api_af_packet_create (vat_main_t * vam)
13357 unformat_input_t *i = vam->input;
13358 vl_api_af_packet_create_t *mp;
13360 u8 *host_if_name = 0;
13362 u8 random_hw_addr = 1;
13364 memset (hw_addr, 0, sizeof (hw_addr));
13366 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13368 if (unformat (i, "name %s", &host_if_name))
13369 vec_add1 (host_if_name, 0);
13370 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
13371 random_hw_addr = 0;
13376 if (!vec_len (host_if_name))
13378 errmsg ("host-interface name must be specified");
13382 if (vec_len (host_if_name) > 64)
13384 errmsg ("host-interface name too long");
13388 M (AF_PACKET_CREATE, af_packet_create);
13390 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
13391 clib_memcpy (mp->hw_addr, hw_addr, 6);
13392 mp->use_random_hw_addr = random_hw_addr;
13393 vec_free (host_if_name);
13396 W2 (fprintf (vam->ofp, " new sw_if_index = %d ", vam->sw_if_index));
13402 api_af_packet_delete (vat_main_t * vam)
13404 unformat_input_t *i = vam->input;
13405 vl_api_af_packet_delete_t *mp;
13407 u8 *host_if_name = 0;
13409 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13411 if (unformat (i, "name %s", &host_if_name))
13412 vec_add1 (host_if_name, 0);
13417 if (!vec_len (host_if_name))
13419 errmsg ("host-interface name must be specified");
13423 if (vec_len (host_if_name) > 64)
13425 errmsg ("host-interface name too long");
13429 M (AF_PACKET_DELETE, af_packet_delete);
13431 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
13432 vec_free (host_if_name);
13441 api_policer_add_del (vat_main_t * vam)
13443 unformat_input_t *i = vam->input;
13444 vl_api_policer_add_del_t *mp;
13455 u8 color_aware = 0;
13456 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
13458 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
13459 conform_action.dscp = 0;
13460 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
13461 exceed_action.dscp = 0;
13462 violate_action.action_type = SSE2_QOS_ACTION_DROP;
13463 violate_action.dscp = 0;
13465 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13467 if (unformat (i, "del"))
13469 else if (unformat (i, "name %s", &name))
13470 vec_add1 (name, 0);
13471 else if (unformat (i, "cir %u", &cir))
13473 else if (unformat (i, "eir %u", &eir))
13475 else if (unformat (i, "cb %u", &cb))
13477 else if (unformat (i, "eb %u", &eb))
13479 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
13482 else if (unformat (i, "round_type %U", unformat_policer_round_type,
13485 else if (unformat (i, "type %U", unformat_policer_type, &type))
13487 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
13490 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
13493 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
13496 else if (unformat (i, "color-aware"))
13502 if (!vec_len (name))
13504 errmsg ("policer name must be specified");
13508 if (vec_len (name) > 64)
13510 errmsg ("policer name too long");
13514 M (POLICER_ADD_DEL, policer_add_del);
13516 clib_memcpy (mp->name, name, vec_len (name));
13518 mp->is_add = is_add;
13523 mp->rate_type = rate_type;
13524 mp->round_type = round_type;
13526 mp->conform_action_type = conform_action.action_type;
13527 mp->conform_dscp = conform_action.dscp;
13528 mp->exceed_action_type = exceed_action.action_type;
13529 mp->exceed_dscp = exceed_action.dscp;
13530 mp->violate_action_type = violate_action.action_type;
13531 mp->violate_dscp = violate_action.dscp;
13532 mp->color_aware = color_aware;
13541 api_policer_dump (vat_main_t * vam)
13543 unformat_input_t *i = vam->input;
13544 vl_api_policer_dump_t *mp;
13546 u8 *match_name = 0;
13547 u8 match_name_valid = 0;
13549 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13551 if (unformat (i, "name %s", &match_name))
13553 vec_add1 (match_name, 0);
13554 match_name_valid = 1;
13560 M (POLICER_DUMP, policer_dump);
13561 mp->match_name_valid = match_name_valid;
13562 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
13563 vec_free (match_name);
13567 /* Use a control ping for synchronization */
13569 vl_api_control_ping_t *mp;
13570 M (CONTROL_PING, control_ping);
13573 /* Wait for a reply... */
13581 api_policer_classify_set_interface (vat_main_t * vam)
13583 unformat_input_t *i = vam->input;
13584 vl_api_policer_classify_set_interface_t *mp;
13587 int sw_if_index_set;
13588 u32 ip4_table_index = ~0;
13589 u32 ip6_table_index = ~0;
13590 u32 l2_table_index = ~0;
13593 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13595 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
13596 sw_if_index_set = 1;
13597 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13598 sw_if_index_set = 1;
13599 else if (unformat (i, "del"))
13601 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13603 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13605 else if (unformat (i, "l2-table %d", &l2_table_index))
13609 clib_warning ("parse error '%U'", format_unformat_error, i);
13614 if (sw_if_index_set == 0)
13616 errmsg ("missing interface name or sw_if_index\n");
13620 M (POLICER_CLASSIFY_SET_INTERFACE, policer_classify_set_interface);
13622 mp->sw_if_index = ntohl (sw_if_index);
13623 mp->ip4_table_index = ntohl (ip4_table_index);
13624 mp->ip6_table_index = ntohl (ip6_table_index);
13625 mp->l2_table_index = ntohl (l2_table_index);
13626 mp->is_add = is_add;
13635 api_policer_classify_dump (vat_main_t * vam)
13637 unformat_input_t *i = vam->input;
13638 vl_api_policer_classify_dump_t *mp;
13640 u8 type = POLICER_CLASSIFY_N_TABLES;
13642 if (unformat (i, "type %U", unformat_classify_table_type, &type))
13646 errmsg ("classify table type must be specified\n");
13650 if (!vam->json_output)
13652 fformat (vam->ofp, "%10s%20s\n", "Intfc idx", "Classify table");
13655 M (POLICER_CLASSIFY_DUMP, policer_classify_dump);
13660 /* Use a control ping for synchronization */
13662 vl_api_control_ping_t *mp;
13663 M (CONTROL_PING, control_ping);
13666 /* Wait for a reply... */
13674 api_netmap_create (vat_main_t * vam)
13676 unformat_input_t *i = vam->input;
13677 vl_api_netmap_create_t *mp;
13681 u8 random_hw_addr = 1;
13685 memset (hw_addr, 0, sizeof (hw_addr));
13687 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13689 if (unformat (i, "name %s", &if_name))
13690 vec_add1 (if_name, 0);
13691 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
13692 random_hw_addr = 0;
13693 else if (unformat (i, "pipe"))
13695 else if (unformat (i, "master"))
13697 else if (unformat (i, "slave"))
13703 if (!vec_len (if_name))
13705 errmsg ("interface name must be specified");
13709 if (vec_len (if_name) > 64)
13711 errmsg ("interface name too long");
13715 M (NETMAP_CREATE, netmap_create);
13717 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
13718 clib_memcpy (mp->hw_addr, hw_addr, 6);
13719 mp->use_random_hw_addr = random_hw_addr;
13720 mp->is_pipe = is_pipe;
13721 mp->is_master = is_master;
13722 vec_free (if_name);
13731 api_netmap_delete (vat_main_t * vam)
13733 unformat_input_t *i = vam->input;
13734 vl_api_netmap_delete_t *mp;
13738 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13740 if (unformat (i, "name %s", &if_name))
13741 vec_add1 (if_name, 0);
13746 if (!vec_len (if_name))
13748 errmsg ("interface name must be specified");
13752 if (vec_len (if_name) > 64)
13754 errmsg ("interface name too long");
13758 M (NETMAP_DELETE, netmap_delete);
13760 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
13761 vec_free (if_name);
13769 static void vl_api_mpls_gre_tunnel_details_t_handler
13770 (vl_api_mpls_gre_tunnel_details_t * mp)
13772 vat_main_t *vam = &vat_main;
13774 i32 len = ntohl (mp->nlabels);
13776 if (mp->l2_only == 0)
13778 fformat (vam->ofp, "[%d]: src %U, dst %U, adj %U/%d, labels ",
13779 ntohl (mp->tunnel_index),
13780 format_ip4_address, &mp->tunnel_src,
13781 format_ip4_address, &mp->tunnel_dst,
13782 format_ip4_address, &mp->intfc_address,
13783 ntohl (mp->mask_width));
13784 for (i = 0; i < len; i++)
13786 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
13788 fformat (vam->ofp, "\n");
13789 fformat (vam->ofp, " inner fib index %d, outer fib index %d\n",
13790 ntohl (mp->inner_fib_index), ntohl (mp->outer_fib_index));
13794 fformat (vam->ofp, "[%d]: src %U, dst %U, key %U, labels ",
13795 ntohl (mp->tunnel_index),
13796 format_ip4_address, &mp->tunnel_src,
13797 format_ip4_address, &mp->tunnel_dst,
13798 format_ip4_address, &mp->intfc_address);
13799 for (i = 0; i < len; i++)
13801 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
13803 fformat (vam->ofp, "\n");
13804 fformat (vam->ofp, " l2 interface %d, outer fib index %d\n",
13805 ntohl (mp->hw_if_index), ntohl (mp->outer_fib_index));
13809 static void vl_api_mpls_gre_tunnel_details_t_handler_json
13810 (vl_api_mpls_gre_tunnel_details_t * mp)
13812 vat_main_t *vam = &vat_main;
13813 vat_json_node_t *node = NULL;
13814 struct in_addr ip4;
13816 i32 len = ntohl (mp->nlabels);
13818 if (VAT_JSON_ARRAY != vam->json_tree.type)
13820 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13821 vat_json_init_array (&vam->json_tree);
13823 node = vat_json_array_add (&vam->json_tree);
13825 vat_json_init_object (node);
13826 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
13827 clib_memcpy (&ip4, &(mp->intfc_address), sizeof (ip4));
13828 vat_json_object_add_ip4 (node, "intfc_address", ip4);
13829 vat_json_object_add_uint (node, "inner_fib_index",
13830 ntohl (mp->inner_fib_index));
13831 vat_json_object_add_uint (node, "mask_width", ntohl (mp->mask_width));
13832 vat_json_object_add_uint (node, "encap_index", ntohl (mp->encap_index));
13833 vat_json_object_add_uint (node, "hw_if_index", ntohl (mp->hw_if_index));
13834 vat_json_object_add_uint (node, "l2_only", ntohl (mp->l2_only));
13835 clib_memcpy (&ip4, &(mp->tunnel_src), sizeof (ip4));
13836 vat_json_object_add_ip4 (node, "tunnel_src", ip4);
13837 clib_memcpy (&ip4, &(mp->tunnel_dst), sizeof (ip4));
13838 vat_json_object_add_ip4 (node, "tunnel_dst", ip4);
13839 vat_json_object_add_uint (node, "outer_fib_index",
13840 ntohl (mp->outer_fib_index));
13841 vat_json_object_add_uint (node, "label_count", len);
13842 for (i = 0; i < len; i++)
13844 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
13849 api_mpls_gre_tunnel_dump (vat_main_t * vam)
13851 vl_api_mpls_gre_tunnel_dump_t *mp;
13855 /* Parse args required to build the message */
13856 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
13858 if (!unformat (vam->input, "tunnel_index %d", &index))
13865 fformat (vam->ofp, " tunnel_index %d\n", index);
13867 M (MPLS_GRE_TUNNEL_DUMP, mpls_gre_tunnel_dump);
13868 mp->tunnel_index = htonl (index);
13871 /* Use a control ping for synchronization */
13873 vl_api_control_ping_t *mp;
13874 M (CONTROL_PING, control_ping);
13880 static void vl_api_mpls_eth_tunnel_details_t_handler
13881 (vl_api_mpls_eth_tunnel_details_t * mp)
13883 vat_main_t *vam = &vat_main;
13885 i32 len = ntohl (mp->nlabels);
13887 fformat (vam->ofp, "[%d]: dst %U, adj %U/%d, labels ",
13888 ntohl (mp->tunnel_index),
13889 format_ethernet_address, &mp->tunnel_dst_mac,
13890 format_ip4_address, &mp->intfc_address, ntohl (mp->mask_width));
13891 for (i = 0; i < len; i++)
13893 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
13895 fformat (vam->ofp, "\n");
13896 fformat (vam->ofp, " tx on %d, rx fib index %d\n",
13897 ntohl (mp->tx_sw_if_index), ntohl (mp->inner_fib_index));
13900 static void vl_api_mpls_eth_tunnel_details_t_handler_json
13901 (vl_api_mpls_eth_tunnel_details_t * mp)
13903 vat_main_t *vam = &vat_main;
13904 vat_json_node_t *node = NULL;
13905 struct in_addr ip4;
13907 i32 len = ntohl (mp->nlabels);
13909 if (VAT_JSON_ARRAY != vam->json_tree.type)
13911 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13912 vat_json_init_array (&vam->json_tree);
13914 node = vat_json_array_add (&vam->json_tree);
13916 vat_json_init_object (node);
13917 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
13918 clib_memcpy (&ip4, &(mp->intfc_address), sizeof (ip4));
13919 vat_json_object_add_ip4 (node, "intfc_address", ip4);
13920 vat_json_object_add_uint (node, "inner_fib_index",
13921 ntohl (mp->inner_fib_index));
13922 vat_json_object_add_uint (node, "mask_width", ntohl (mp->mask_width));
13923 vat_json_object_add_uint (node, "encap_index", ntohl (mp->encap_index));
13924 vat_json_object_add_uint (node, "hw_if_index", ntohl (mp->hw_if_index));
13925 vat_json_object_add_uint (node, "l2_only", ntohl (mp->l2_only));
13926 vat_json_object_add_string_copy (node, "tunnel_dst_mac",
13927 format (0, "%U", format_ethernet_address,
13928 &mp->tunnel_dst_mac));
13929 vat_json_object_add_uint (node, "tx_sw_if_index",
13930 ntohl (mp->tx_sw_if_index));
13931 vat_json_object_add_uint (node, "label_count", len);
13932 for (i = 0; i < len; i++)
13934 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
13939 api_mpls_eth_tunnel_dump (vat_main_t * vam)
13941 vl_api_mpls_eth_tunnel_dump_t *mp;
13945 /* Parse args required to build the message */
13946 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
13948 if (!unformat (vam->input, "tunnel_index %d", &index))
13955 fformat (vam->ofp, " tunnel_index %d\n", index);
13957 M (MPLS_ETH_TUNNEL_DUMP, mpls_eth_tunnel_dump);
13958 mp->tunnel_index = htonl (index);
13961 /* Use a control ping for synchronization */
13963 vl_api_control_ping_t *mp;
13964 M (CONTROL_PING, control_ping);
13970 static void vl_api_mpls_fib_encap_details_t_handler
13971 (vl_api_mpls_fib_encap_details_t * mp)
13973 vat_main_t *vam = &vat_main;
13975 i32 len = ntohl (mp->nlabels);
13977 fformat (vam->ofp, "table %d, dest %U, label ",
13978 ntohl (mp->fib_index), format_ip4_address, &mp->dest, len);
13979 for (i = 0; i < len; i++)
13981 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
13983 fformat (vam->ofp, "\n");
13986 static void vl_api_mpls_fib_encap_details_t_handler_json
13987 (vl_api_mpls_fib_encap_details_t * mp)
13989 vat_main_t *vam = &vat_main;
13990 vat_json_node_t *node = NULL;
13992 i32 len = ntohl (mp->nlabels);
13993 struct in_addr ip4;
13995 if (VAT_JSON_ARRAY != vam->json_tree.type)
13997 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13998 vat_json_init_array (&vam->json_tree);
14000 node = vat_json_array_add (&vam->json_tree);
14002 vat_json_init_object (node);
14003 vat_json_object_add_uint (node, "table", ntohl (mp->fib_index));
14004 vat_json_object_add_uint (node, "entry_index", ntohl (mp->entry_index));
14005 clib_memcpy (&ip4, &(mp->dest), sizeof (ip4));
14006 vat_json_object_add_ip4 (node, "dest", ip4);
14007 vat_json_object_add_uint (node, "s_bit", ntohl (mp->s_bit));
14008 vat_json_object_add_uint (node, "label_count", len);
14009 for (i = 0; i < len; i++)
14011 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14016 api_mpls_fib_encap_dump (vat_main_t * vam)
14018 vl_api_mpls_fib_encap_dump_t *mp;
14021 M (MPLS_FIB_ENCAP_DUMP, mpls_fib_encap_dump);
14024 /* Use a control ping for synchronization */
14026 vl_api_control_ping_t *mp;
14027 M (CONTROL_PING, control_ping);
14033 static void vl_api_mpls_fib_decap_details_t_handler
14034 (vl_api_mpls_fib_decap_details_t * mp)
14036 vat_main_t *vam = &vat_main;
14039 "RX table %d, TX table/intfc %u, swif_tag '%s', label %u, s_bit %u\n",
14040 ntohl (mp->rx_table_id), ntohl (mp->tx_table_id), mp->swif_tag,
14041 ntohl (mp->label), ntohl (mp->s_bit));
14044 static void vl_api_mpls_fib_decap_details_t_handler_json
14045 (vl_api_mpls_fib_decap_details_t * mp)
14047 vat_main_t *vam = &vat_main;
14048 vat_json_node_t *node = NULL;
14049 struct in_addr ip4;
14051 if (VAT_JSON_ARRAY != vam->json_tree.type)
14053 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14054 vat_json_init_array (&vam->json_tree);
14056 node = vat_json_array_add (&vam->json_tree);
14058 vat_json_init_object (node);
14059 vat_json_object_add_uint (node, "table", ntohl (mp->fib_index));
14060 vat_json_object_add_uint (node, "entry_index", ntohl (mp->entry_index));
14061 clib_memcpy (&ip4, &(mp->dest), sizeof (ip4));
14062 vat_json_object_add_ip4 (node, "dest", ip4);
14063 vat_json_object_add_uint (node, "s_bit", ntohl (mp->s_bit));
14064 vat_json_object_add_uint (node, "label", ntohl (mp->label));
14065 vat_json_object_add_uint (node, "rx_table_id", ntohl (mp->rx_table_id));
14066 vat_json_object_add_uint (node, "tx_table_id", ntohl (mp->tx_table_id));
14067 vat_json_object_add_string_copy (node, "swif_tag", mp->swif_tag);
14071 api_mpls_fib_decap_dump (vat_main_t * vam)
14073 vl_api_mpls_fib_decap_dump_t *mp;
14076 M (MPLS_FIB_DECAP_DUMP, mpls_fib_decap_dump);
14079 /* Use a control ping for synchronization */
14081 vl_api_control_ping_t *mp;
14082 M (CONTROL_PING, control_ping);
14089 api_classify_table_ids (vat_main_t * vam)
14091 vl_api_classify_table_ids_t *mp;
14094 /* Construct the API message */
14095 M (CLASSIFY_TABLE_IDS, classify_table_ids);
14105 api_classify_table_by_interface (vat_main_t * vam)
14107 unformat_input_t *input = vam->input;
14108 vl_api_classify_table_by_interface_t *mp;
14111 u32 sw_if_index = ~0;
14112 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14114 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
14116 else if (unformat (input, "sw_if_index %d", &sw_if_index))
14121 if (sw_if_index == ~0)
14123 errmsg ("missing interface name or sw_if_index\n");
14127 /* Construct the API message */
14128 M (CLASSIFY_TABLE_BY_INTERFACE, classify_table_by_interface);
14130 mp->sw_if_index = ntohl (sw_if_index);
14139 api_classify_table_info (vat_main_t * vam)
14141 unformat_input_t *input = vam->input;
14142 vl_api_classify_table_info_t *mp;
14146 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14148 if (unformat (input, "table_id %d", &table_id))
14153 if (table_id == ~0)
14155 errmsg ("missing table id\n");
14159 /* Construct the API message */
14160 M (CLASSIFY_TABLE_INFO, classify_table_info);
14162 mp->table_id = ntohl (table_id);
14171 api_classify_session_dump (vat_main_t * vam)
14173 unformat_input_t *input = vam->input;
14174 vl_api_classify_session_dump_t *mp;
14178 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14180 if (unformat (input, "table_id %d", &table_id))
14185 if (table_id == ~0)
14187 errmsg ("missing table id\n");
14191 /* Construct the API message */
14192 M (CLASSIFY_SESSION_DUMP, classify_session_dump);
14194 mp->table_id = ntohl (table_id);
14197 /* Use a control ping for synchronization */
14199 vl_api_control_ping_t *mp;
14200 M (CONTROL_PING, control_ping);
14209 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
14211 vat_main_t *vam = &vat_main;
14213 fformat (vam->ofp, "collector_address %U, collector_port %d, "
14214 "src_address %U, vrf_id %d, path_mtu %u, "
14215 "template_interval %u, udp_checksum %d\n",
14216 format_ip4_address, mp->collector_address,
14217 ntohs (mp->collector_port),
14218 format_ip4_address, mp->src_address,
14219 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
14220 ntohl (mp->template_interval), mp->udp_checksum);
14223 vam->result_ready = 1;
14227 vl_api_ipfix_exporter_details_t_handler_json
14228 (vl_api_ipfix_exporter_details_t * mp)
14230 vat_main_t *vam = &vat_main;
14231 vat_json_node_t node;
14232 struct in_addr collector_address;
14233 struct in_addr src_address;
14235 vat_json_init_object (&node);
14236 clib_memcpy (&collector_address, &mp->collector_address,
14237 sizeof (collector_address));
14238 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
14239 vat_json_object_add_uint (&node, "collector_port",
14240 ntohs (mp->collector_port));
14241 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
14242 vat_json_object_add_ip4 (&node, "src_address", src_address);
14243 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
14244 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
14245 vat_json_object_add_uint (&node, "template_interval",
14246 ntohl (mp->template_interval));
14247 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
14249 vat_json_print (vam->ofp, &node);
14250 vat_json_free (&node);
14252 vam->result_ready = 1;
14256 api_ipfix_exporter_dump (vat_main_t * vam)
14258 vl_api_ipfix_exporter_dump_t *mp;
14261 /* Construct the API message */
14262 M (IPFIX_EXPORTER_DUMP, ipfix_exporter_dump);
14272 api_ipfix_classify_stream_dump (vat_main_t * vam)
14274 vl_api_ipfix_classify_stream_dump_t *mp;
14277 /* Construct the API message */
14278 M (IPFIX_CLASSIFY_STREAM_DUMP, ipfix_classify_stream_dump);
14288 vl_api_ipfix_classify_stream_details_t_handler
14289 (vl_api_ipfix_classify_stream_details_t * mp)
14291 vat_main_t *vam = &vat_main;
14292 fformat (vam->ofp, "domain_id %d, src_port %d\n",
14293 ntohl (mp->domain_id), ntohs (mp->src_port));
14295 vam->result_ready = 1;
14299 vl_api_ipfix_classify_stream_details_t_handler_json
14300 (vl_api_ipfix_classify_stream_details_t * mp)
14302 vat_main_t *vam = &vat_main;
14303 vat_json_node_t node;
14305 vat_json_init_object (&node);
14306 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
14307 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
14309 vat_json_print (vam->ofp, &node);
14310 vat_json_free (&node);
14312 vam->result_ready = 1;
14316 api_ipfix_classify_table_dump (vat_main_t * vam)
14318 vl_api_ipfix_classify_table_dump_t *mp;
14321 if (!vam->json_output)
14323 fformat (vam->ofp, "%15s%15s%20s\n", "table_id", "ip_version",
14324 "transport_protocol");
14327 /* Construct the API message */
14328 M (IPFIX_CLASSIFY_TABLE_DUMP, ipfix_classify_table_dump);
14333 /* Use a control ping for synchronization */
14335 vl_api_control_ping_t *mp;
14336 M (CONTROL_PING, control_ping);
14343 vl_api_ipfix_classify_table_details_t_handler
14344 (vl_api_ipfix_classify_table_details_t * mp)
14346 vat_main_t *vam = &vat_main;
14347 fformat (vam->ofp, "%15d%15d%20d\n", ntohl (mp->table_id), mp->ip_version,
14348 mp->transport_protocol);
14352 vl_api_ipfix_classify_table_details_t_handler_json
14353 (vl_api_ipfix_classify_table_details_t * mp)
14355 vat_json_node_t *node = NULL;
14356 vat_main_t *vam = &vat_main;
14358 if (VAT_JSON_ARRAY != vam->json_tree.type)
14360 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14361 vat_json_init_array (&vam->json_tree);
14364 node = vat_json_array_add (&vam->json_tree);
14365 vat_json_init_object (node);
14367 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
14368 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
14369 vat_json_object_add_uint (node, "transport_protocol",
14370 mp->transport_protocol);
14374 api_pg_create_interface (vat_main_t * vam)
14376 unformat_input_t *input = vam->input;
14377 vl_api_pg_create_interface_t *mp;
14381 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14383 if (unformat (input, "if_id %d", &if_id))
14390 errmsg ("missing pg interface index\n");
14394 /* Construct the API message */
14395 M (PG_CREATE_INTERFACE, pg_create_interface);
14397 mp->interface_id = ntohl (if_id);
14406 api_pg_capture (vat_main_t * vam)
14408 unformat_input_t *input = vam->input;
14409 vl_api_pg_capture_t *mp;
14415 u8 pcap_file_set = 0;
14417 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14419 if (unformat (input, "if_id %d", &if_id))
14421 else if (unformat (input, "pcap %s", &pcap_file))
14423 else if (unformat (input, "count %d", &count))
14425 else if (unformat (input, "disable"))
14432 errmsg ("missing pg interface index\n");
14435 if (pcap_file_set > 0)
14437 if (vec_len (pcap_file) > 255)
14439 errmsg ("pcap file name is too long\n");
14444 u32 name_len = vec_len (pcap_file);
14445 /* Construct the API message */
14446 M (PG_CAPTURE, pg_capture);
14448 mp->interface_id = ntohl (if_id);
14449 mp->is_enabled = enable;
14450 mp->count = ntohl (count);
14451 mp->pcap_name_length = ntohl (name_len);
14452 if (pcap_file_set != 0)
14454 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
14456 vec_free (pcap_file);
14465 api_pg_enable_disable (vat_main_t * vam)
14467 unformat_input_t *input = vam->input;
14468 vl_api_pg_enable_disable_t *mp;
14472 u8 stream_name_set = 0;
14473 u8 *stream_name = 0;
14474 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14476 if (unformat (input, "stream %s", &stream_name))
14477 stream_name_set = 1;
14478 else if (unformat (input, "disable"))
14484 if (stream_name_set > 0)
14486 if (vec_len (stream_name) > 255)
14488 errmsg ("stream name too long\n");
14493 u32 name_len = vec_len (stream_name);
14494 /* Construct the API message */
14495 M (PG_ENABLE_DISABLE, pg_enable_disable);
14497 mp->is_enabled = enable;
14498 if (stream_name_set != 0)
14500 mp->stream_name_length = ntohl (name_len);
14501 clib_memcpy (mp->stream_name, stream_name, name_len);
14503 vec_free (stream_name);
14512 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
14514 unformat_input_t *input = vam->input;
14515 vl_api_ip_source_and_port_range_check_add_del_t *mp;
14518 u16 *low_ports = 0;
14519 u16 *high_ports = 0;
14522 ip4_address_t ip4_addr;
14523 ip6_address_t ip6_addr;
14531 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14533 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
14539 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
14544 else if (unformat (input, "vrf %d", &vrf_id))
14546 else if (unformat (input, "del"))
14548 else if (unformat (input, "port %d", &tmp))
14550 if (tmp == 0 || tmp > 65535)
14552 errmsg ("port %d out of range", tmp);
14556 this_hi = this_low + 1;
14557 vec_add1 (low_ports, this_low);
14558 vec_add1 (high_ports, this_hi);
14560 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
14562 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
14564 errmsg ("incorrect range parameters\n");
14568 /* Note: in debug CLI +1 is added to high before
14569 passing to real fn that does "the work"
14570 (ip_source_and_port_range_check_add_del).
14571 This fn is a wrapper around the binary API fn a
14572 control plane will call, which expects this increment
14573 to have occurred. Hence letting the binary API control
14574 plane fn do the increment for consistency between VAT
14575 and other control planes.
14578 vec_add1 (low_ports, this_low);
14579 vec_add1 (high_ports, this_hi);
14585 if (prefix_set == 0)
14587 errmsg ("<address>/<mask> not specified\n");
14593 errmsg ("VRF ID required, not specified\n");
14600 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
14604 if (vec_len (low_ports) == 0)
14606 errmsg ("At least one port or port range required\n");
14610 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL,
14611 ip_source_and_port_range_check_add_del);
14613 mp->is_add = is_add;
14618 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
14623 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
14626 mp->mask_length = length;
14627 mp->number_of_ranges = vec_len (low_ports);
14629 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
14630 vec_free (low_ports);
14632 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
14633 vec_free (high_ports);
14635 mp->vrf_id = ntohl (vrf_id);
14644 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
14646 unformat_input_t *input = vam->input;
14647 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
14649 u32 sw_if_index = ~0;
14651 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
14652 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
14655 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14657 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
14659 else if (unformat (input, "sw_if_index %d", &sw_if_index))
14661 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
14663 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
14665 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
14667 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
14669 else if (unformat (input, "del"))
14675 if (sw_if_index == ~0)
14677 errmsg ("Interface required but not specified\n");
14683 errmsg ("VRF ID required but not specified\n");
14687 if (tcp_out_vrf_id == 0
14688 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
14691 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
14695 /* Construct the API message */
14696 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL,
14697 ip_source_and_port_range_check_interface_add_del);
14699 mp->sw_if_index = ntohl (sw_if_index);
14700 mp->is_add = is_add;
14701 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
14702 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
14703 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
14704 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
14709 /* Wait for a reply... */
14714 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
14716 unformat_input_t *i = vam->input;
14717 vl_api_ipsec_gre_add_del_tunnel_t *mp;
14719 u32 local_sa_id = 0;
14720 u32 remote_sa_id = 0;
14721 ip4_address_t src_address;
14722 ip4_address_t dst_address;
14725 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14727 if (unformat (i, "local_sa %d", &local_sa_id))
14729 else if (unformat (i, "remote_sa %d", &remote_sa_id))
14731 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
14733 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
14735 else if (unformat (i, "del"))
14739 clib_warning ("parse error '%U'", format_unformat_error, i);
14744 M (IPSEC_GRE_ADD_DEL_TUNNEL, ipsec_gre_add_del_tunnel);
14746 mp->local_sa_id = ntohl (local_sa_id);
14747 mp->remote_sa_id = ntohl (remote_sa_id);
14748 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
14749 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
14750 mp->is_add = is_add;
14758 static void vl_api_ipsec_gre_tunnel_details_t_handler
14759 (vl_api_ipsec_gre_tunnel_details_t * mp)
14761 vat_main_t *vam = &vat_main;
14763 fformat (vam->ofp, "%11d%15U%15U%14d%14d\n",
14764 ntohl (mp->sw_if_index),
14765 format_ip4_address, &mp->src_address,
14766 format_ip4_address, &mp->dst_address,
14767 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
14770 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
14771 (vl_api_ipsec_gre_tunnel_details_t * mp)
14773 vat_main_t *vam = &vat_main;
14774 vat_json_node_t *node = NULL;
14775 struct in_addr ip4;
14777 if (VAT_JSON_ARRAY != vam->json_tree.type)
14779 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14780 vat_json_init_array (&vam->json_tree);
14782 node = vat_json_array_add (&vam->json_tree);
14784 vat_json_init_object (node);
14785 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14786 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
14787 vat_json_object_add_ip4 (node, "src_address", ip4);
14788 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
14789 vat_json_object_add_ip4 (node, "dst_address", ip4);
14790 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
14791 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
14795 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
14797 unformat_input_t *i = vam->input;
14798 vl_api_ipsec_gre_tunnel_dump_t *mp;
14801 u8 sw_if_index_set = 0;
14803 /* Parse args required to build the message */
14804 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14806 if (unformat (i, "sw_if_index %d", &sw_if_index))
14807 sw_if_index_set = 1;
14812 if (sw_if_index_set == 0)
14817 if (!vam->json_output)
14819 fformat (vam->ofp, "%11s%15s%15s%14s%14s\n",
14820 "sw_if_index", "src_address", "dst_address",
14821 "local_sa_id", "remote_sa_id");
14824 /* Get list of gre-tunnel interfaces */
14825 M (IPSEC_GRE_TUNNEL_DUMP, ipsec_gre_tunnel_dump);
14827 mp->sw_if_index = htonl (sw_if_index);
14831 /* Use a control ping for synchronization */
14833 vl_api_control_ping_t *mp;
14834 M (CONTROL_PING, control_ping);
14841 api_delete_subif (vat_main_t * vam)
14843 unformat_input_t *i = vam->input;
14844 vl_api_delete_subif_t *mp;
14846 u32 sw_if_index = ~0;
14848 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14850 if (unformat (i, "sw_if_index %d", &sw_if_index))
14856 if (sw_if_index == ~0)
14858 errmsg ("missing sw_if_index\n");
14862 /* Construct the API message */
14863 M (DELETE_SUBIF, delete_subif);
14864 mp->sw_if_index = ntohl (sw_if_index);
14871 q_or_quit (vat_main_t * vam)
14873 longjmp (vam->jump_buf, 1);
14874 return 0; /* not so much */
14878 q (vat_main_t * vam)
14880 return q_or_quit (vam);
14884 quit (vat_main_t * vam)
14886 return q_or_quit (vam);
14890 comment (vat_main_t * vam)
14896 cmd_cmp (void *a1, void *a2)
14901 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
14905 help (vat_main_t * vam)
14910 unformat_input_t *i = vam->input;
14913 if (unformat (i, "%s", &name))
14917 vec_add1 (name, 0);
14919 hs = hash_get_mem (vam->help_by_name, name);
14921 fformat (vam->ofp, "usage: %s %s\n", name, hs[0]);
14923 fformat (vam->ofp, "No such msg / command '%s'\n", name);
14928 fformat (vam->ofp, "Help is available for the following:\n");
14931 hash_foreach_pair (p, vam->function_by_name,
14933 vec_add1 (cmds, (u8 *)(p->key));
14937 vec_sort_with_function (cmds, cmd_cmp);
14939 for (j = 0; j < vec_len (cmds); j++)
14940 fformat (vam->ofp, "%s\n", cmds[j]);
14947 set (vat_main_t * vam)
14949 u8 *name = 0, *value = 0;
14950 unformat_input_t *i = vam->input;
14952 if (unformat (i, "%s", &name))
14954 /* The input buffer is a vector, not a string. */
14955 value = vec_dup (i->buffer);
14956 vec_delete (value, i->index, 0);
14957 /* Almost certainly has a trailing newline */
14958 if (value[vec_len (value) - 1] == '\n')
14959 value[vec_len (value) - 1] = 0;
14960 /* Make sure it's a proper string, one way or the other */
14961 vec_add1 (value, 0);
14962 (void) clib_macro_set_value (&vam->macro_main,
14963 (char *) name, (char *) value);
14966 errmsg ("usage: set <name> <value>\n");
14974 unset (vat_main_t * vam)
14978 if (unformat (vam->input, "%s", &name))
14979 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
14980 errmsg ("unset: %s wasn't set\n", name);
14993 macro_sort_cmp (void *a1, void *a2)
14995 macro_sort_t *s1 = a1;
14996 macro_sort_t *s2 = a2;
14998 return strcmp ((char *) (s1->name), (char *) (s2->name));
15002 dump_macro_table (vat_main_t * vam)
15004 macro_sort_t *sort_me = 0, *sm;
15009 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
15011 vec_add2 (sort_me, sm, 1);
15012 sm->name = (u8 *)(p->key);
15013 sm->value = (u8 *) (p->value[0]);
15017 vec_sort_with_function (sort_me, macro_sort_cmp);
15019 if (vec_len (sort_me))
15020 fformat (vam->ofp, "%-15s%s\n", "Name", "Value");
15022 fformat (vam->ofp, "The macro table is empty...\n");
15024 for (i = 0; i < vec_len (sort_me); i++)
15025 fformat (vam->ofp, "%-15s%s\n", sort_me[i].name, sort_me[i].value);
15030 dump_node_table (vat_main_t * vam)
15033 vlib_node_t *node, *next_node;
15035 if (vec_len (vam->graph_nodes) == 0)
15037 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
15041 for (i = 0; i < vec_len (vam->graph_nodes); i++)
15043 node = vam->graph_nodes[i];
15044 fformat (vam->ofp, "[%d] %s\n", i, node->name);
15045 for (j = 0; j < vec_len (node->next_nodes); j++)
15047 if (node->next_nodes[j] != ~0)
15049 next_node = vam->graph_nodes[node->next_nodes[j]];
15050 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
15058 search_node_table (vat_main_t * vam)
15060 unformat_input_t *line_input = vam->input;
15063 vlib_node_t *node, *next_node;
15066 if (vam->graph_node_index_by_name == 0)
15068 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
15072 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15074 if (unformat (line_input, "%s", &node_to_find))
15076 vec_add1 (node_to_find, 0);
15077 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
15080 fformat (vam->ofp, "%s not found...\n", node_to_find);
15083 node = vam->graph_nodes[p[0]];
15084 fformat (vam->ofp, "[%d] %s\n", p[0], node->name);
15085 for (j = 0; j < vec_len (node->next_nodes); j++)
15087 if (node->next_nodes[j] != ~0)
15089 next_node = vam->graph_nodes[node->next_nodes[j]];
15090 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
15097 clib_warning ("parse error '%U'", format_unformat_error,
15103 vec_free (node_to_find);
15112 script (vat_main_t * vam)
15115 char *save_current_file;
15116 unformat_input_t save_input;
15117 jmp_buf save_jump_buf;
15118 u32 save_line_number;
15120 FILE *new_fp, *save_ifp;
15122 if (unformat (vam->input, "%s", &s))
15124 new_fp = fopen ((char *) s, "r");
15127 errmsg ("Couldn't open script file %s\n", s);
15134 errmsg ("Missing script name\n");
15138 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
15139 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
15140 save_ifp = vam->ifp;
15141 save_line_number = vam->input_line_number;
15142 save_current_file = (char *) vam->current_file;
15144 vam->input_line_number = 0;
15146 vam->current_file = s;
15149 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
15150 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
15151 vam->ifp = save_ifp;
15152 vam->input_line_number = save_line_number;
15153 vam->current_file = (u8 *) save_current_file;
15160 echo (vat_main_t * vam)
15162 fformat (vam->ofp, "%v", vam->input->buffer);
15166 /* List of API message constructors, CLI names map to api_xxx */
15167 #define foreach_vpe_api_msg \
15168 _(create_loopback,"[mac <mac-addr>]") \
15169 _(sw_interface_dump,"") \
15170 _(sw_interface_set_flags, \
15171 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
15172 _(sw_interface_add_del_address, \
15173 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
15174 _(sw_interface_set_table, \
15175 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
15176 _(sw_interface_set_vpath, \
15177 "<intfc> | sw_if_index <id> enable | disable") \
15178 _(sw_interface_set_l2_xconnect, \
15179 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
15180 "enable | disable") \
15181 _(sw_interface_set_l2_bridge, \
15182 "<intfc> | sw_if_index <id> bd_id <bridge-domain-id>\n" \
15183 "[shg <split-horizon-group>] [bvi]\n" \
15184 "enable | disable") \
15185 _(bridge_domain_add_del, \
15186 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n")\
15187 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
15189 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
15191 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
15193 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
15195 "tapname <name> mac <mac-addr> | random-mac") \
15197 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
15199 "<vpp-if-name> | sw_if_index <id>") \
15200 _(sw_interface_tap_dump, "") \
15201 _(ip_add_del_route, \
15202 "<addr>/<mask> via <addr> [vrf <n>]\n" \
15203 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
15204 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
15205 "[multipath] [count <n>]") \
15206 _(proxy_arp_add_del, \
15207 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
15208 _(proxy_arp_intfc_enable_disable, \
15209 "<intfc> | sw_if_index <id> enable | disable") \
15210 _(mpls_add_del_encap, \
15211 "label <n> dst <ip4-addr> [vrf <n>] [del]") \
15212 _(mpls_add_del_decap, \
15213 "label <n> [rx_vrf_id <n>] [tx_vrf_id] [s-bit-clear][del]") \
15214 _(mpls_gre_add_del_tunnel, \
15215 "inner_vrf_id <n> outer_vrf_id <n> src <ip4-address> dst <ip4-address>\n" \
15216 "adj <ip4-address>/<mask-width> [del]") \
15217 _(sw_interface_set_unnumbered, \
15218 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
15219 _(ip_neighbor_add_del, \
15220 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
15221 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
15222 _(reset_vrf, "vrf <id> [ipv6]") \
15223 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
15224 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
15225 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
15226 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
15227 "[outer_vlan_id_any][inner_vlan_id_any]") \
15228 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
15229 _(reset_fib, "vrf <n> [ipv6]") \
15230 _(dhcp_proxy_config, \
15231 "svr <v46-address> src <v46-address>\n" \
15232 "insert-cid <n> [del]") \
15233 _(dhcp_proxy_config_2, \
15234 "svr <v46-address> src <v46-address>\n" \
15235 "rx_vrf_id <nn> server_vrf_id <nn> insert-cid <n> [del]") \
15236 _(dhcp_proxy_set_vss, \
15237 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
15238 _(dhcp_client_config, \
15239 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
15240 _(set_ip_flow_hash, \
15241 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
15242 _(sw_interface_ip6_enable_disable, \
15243 "<intfc> | sw_if_index <id> enable | disable") \
15244 _(sw_interface_ip6_set_link_local_address, \
15245 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
15246 _(sw_interface_ip6nd_ra_prefix, \
15247 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
15248 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
15249 "[nolink] [isno]") \
15250 _(sw_interface_ip6nd_ra_config, \
15251 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
15252 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
15253 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
15254 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
15255 _(l2_patch_add_del, \
15256 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
15257 "enable | disable") \
15258 _(mpls_ethernet_add_del_tunnel, \
15259 "tx <intfc> | tx_sw_if_index <n> dst <mac-addr>\n" \
15260 "adj <ip4-addr>/<mw> dst <mac-addr> [del]") \
15261 _(mpls_ethernet_add_del_tunnel_2, \
15262 "inner_vrf_id <n> outer_vrf_id <n> next-hop <ip4-addr>\n" \
15263 "resolve-attempts <n> resolve-if-needed 0 | 1 [del]") \
15264 _(sr_tunnel_add_del, \
15265 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
15266 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
15267 "[policy <policy_name>]") \
15268 _(sr_policy_add_del, \
15269 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
15270 _(sr_multicast_map_add_del, \
15271 "address [ip6 multicast address] sr-policy [policy name] [del]") \
15272 _(classify_add_del_table, \
15273 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
15274 "[del] mask <mask-value>\n" \
15275 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>") \
15276 _(classify_add_del_session, \
15277 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
15278 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
15279 " [l3 [ip4|ip6]]") \
15280 _(classify_set_interface_ip_table, \
15281 "<intfc> | sw_if_index <nn> table <nn>") \
15282 _(classify_set_interface_l2_tables, \
15283 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15284 " [other-table <nn>]") \
15285 _(get_node_index, "node <node-name") \
15286 _(add_node_next, "node <node-name> next <next-node-name>") \
15287 _(l2tpv3_create_tunnel, \
15288 "client_address <ip6-addr> our_address <ip6-addr>\n" \
15289 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n"\
15290 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
15291 _(l2tpv3_set_tunnel_cookies, \
15292 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
15293 "[new_remote_cookie <nn>]\n") \
15294 _(l2tpv3_interface_enable_disable, \
15295 "<intfc> | sw_if_index <nn> enable | disable") \
15296 _(l2tpv3_set_lookup_key, \
15297 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
15298 _(sw_if_l2tpv3_tunnel_dump, "") \
15299 _(vxlan_add_del_tunnel, \
15300 "src <ip-addr> dst <ip-addr> vni <vni> [encap-vrf-id <nn>]\n" \
15301 " [decap-next l2|ip4|ip6] [del]") \
15302 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15303 _(gre_add_del_tunnel, \
15304 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [teb] [del]\n") \
15305 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15306 _(l2_fib_clear_table, "") \
15307 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
15308 _(l2_interface_vlan_tag_rewrite, \
15309 "<intfc> | sw_if_index <nn> \n" \
15310 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
15311 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
15312 _(create_vhost_user_if, \
15313 "socket <filename> [server] [renumber <dev_instance>] " \
15314 "[mac <mac_address>]") \
15315 _(modify_vhost_user_if, \
15316 "<intfc> | sw_if_index <nn> socket <filename>\n" \
15317 "[server] [renumber <dev_instance>]") \
15318 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
15319 _(sw_interface_vhost_user_dump, "") \
15320 _(show_version, "") \
15321 _(vxlan_gpe_add_del_tunnel, \
15322 "local <addr> remote <addr> vni <nn>\n" \
15323 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
15324 "[next-ethernet] [next-nsh]\n") \
15325 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15326 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
15327 _(interface_name_renumber, \
15328 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
15329 _(input_acl_set_interface, \
15330 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15331 " [l2-table <nn>] [del]") \
15332 _(want_ip4_arp_events, "address <ip4-address> [del]") \
15333 _(want_ip6_nd_events, "address <ip6-address> [del]") \
15334 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
15335 _(ip_dump, "ipv4 | ipv6") \
15336 _(ipsec_spd_add_del, "spd_id <n> [del]") \
15337 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
15339 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
15340 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
15341 " integ_alg <alg> integ_key <hex>") \
15342 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
15343 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
15344 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
15345 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" )\
15346 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
15347 _(ikev2_profile_add_del, "name <profile_name> [del]") \
15348 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
15349 "(auth_data 0x<data> | auth_data <data>)") \
15350 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
15351 "(id_data 0x<data> | id_data <data>) (local|remote)") \
15352 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
15353 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
15354 "(local|remote)") \
15355 _(ikev2_set_local_key, "file <absolute_file_path>") \
15356 _(delete_loopback,"sw_if_index <nn>") \
15357 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
15358 _(map_add_domain, \
15359 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
15360 "ip6-src <ip6addr> " \
15361 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
15362 _(map_del_domain, "index <n>") \
15363 _(map_add_del_rule, \
15364 "index <n> psid <n> dst <ip6addr> [del]") \
15365 _(map_domain_dump, "") \
15366 _(map_rule_dump, "index <map-domain>") \
15367 _(want_interface_events, "enable|disable") \
15368 _(want_stats,"enable|disable") \
15369 _(get_first_msg_id, "client <name>") \
15370 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
15371 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
15372 "fib-id <nn> [ip4][ip6][default]") \
15373 _(get_node_graph, " ") \
15374 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
15375 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
15376 _(ioam_disable, "") \
15377 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
15378 " sw_if_index <sw_if_index> p <priority> " \
15379 "w <weight>] [del]") \
15380 _(lisp_add_del_locator, "locator-set <locator_name> " \
15381 "iface <intf> | sw_if_index <sw_if_index> " \
15382 "p <priority> w <weight> [del]") \
15383 _(lisp_add_del_local_eid,"vni <vni> eid " \
15384 "<ipv4|ipv6>/<prefix> | <L2 address> " \
15385 "locator-set <locator_name> [del]") \
15386 _(lisp_gpe_add_del_fwd_entry, "rmt_eid <eid> [lcl_eid <eid>] vni <vni>" \
15387 "dp_table <table> loc-pair <lcl_loc> <rmt_loc> ... [del]") \
15388 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
15389 _(lisp_gpe_enable_disable, "enable|disable") \
15390 _(lisp_enable_disable, "enable|disable") \
15391 _(lisp_gpe_add_del_iface, "up|down") \
15392 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
15394 "rloc <locator> p <prio> " \
15395 "w <weight> [rloc <loc> ... ] " \
15396 "action <action> [del-all]") \
15397 _(lisp_add_del_adjacency, "add|del vni <vni> deid <dest-eid> seid " \
15398 "<src-eid> rloc <locator> p <prio> w <weight>"\
15399 "[rloc <loc> ... ] action <action>") \
15400 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
15401 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
15402 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
15403 _(lisp_locator_set_dump, "[local | remote]") \
15404 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
15405 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
15406 "[local] | [remote]") \
15407 _(lisp_eid_table_vni_dump, "") \
15408 _(lisp_eid_table_map_dump, "l2|l3") \
15409 _(lisp_gpe_tunnel_dump, "") \
15410 _(lisp_map_resolver_dump, "") \
15411 _(show_lisp_status, "") \
15412 _(lisp_get_map_request_itr_rlocs, "") \
15413 _(show_lisp_pitr, "") \
15414 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
15415 _(af_packet_delete, "name <host interface name>") \
15416 _(policer_add_del, "name <policer name> <params> [del]") \
15417 _(policer_dump, "[name <policer name>]") \
15418 _(policer_classify_set_interface, \
15419 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15420 " [l2-table <nn>] [del]") \
15421 _(policer_classify_dump, "type [ip4|ip6|l2]") \
15422 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
15423 "[master|slave]") \
15424 _(netmap_delete, "name <interface name>") \
15425 _(mpls_gre_tunnel_dump, "tunnel_index <tunnel-id>") \
15426 _(mpls_eth_tunnel_dump, "tunnel_index <tunnel-id>") \
15427 _(mpls_fib_encap_dump, "") \
15428 _(mpls_fib_decap_dump, "") \
15429 _(classify_table_ids, "") \
15430 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
15431 _(classify_table_info, "table_id <nn>") \
15432 _(classify_session_dump, "table_id <nn>") \
15433 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
15434 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
15435 "[template_interval <nn>] [udp_checksum]") \
15436 _(ipfix_exporter_dump, "") \
15437 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
15438 _(ipfix_classify_stream_dump, "") \
15439 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]")\
15440 _(ipfix_classify_table_dump, "") \
15441 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
15442 _(pg_create_interface, "if_id <nn>") \
15443 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
15444 _(pg_enable_disable, "[stream <id>] disable") \
15445 _(ip_source_and_port_range_check_add_del, \
15446 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
15447 _(ip_source_and_port_range_check_interface_add_del, \
15448 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
15449 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
15450 _(ipsec_gre_add_del_tunnel, \
15451 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
15452 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
15453 _(delete_subif,"sub_sw_if_index <nn> sub_if_id <nn>")
15455 /* List of command functions, CLI names map directly to functions */
15456 #define foreach_cli_function \
15457 _(comment, "usage: comment <ignore-rest-of-line>") \
15458 _(dump_interface_table, "usage: dump_interface_table") \
15459 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
15460 _(dump_ipv4_table, "usage: dump_ipv4_table") \
15461 _(dump_ipv6_table, "usage: dump_ipv6_table") \
15462 _(dump_stats_table, "usage: dump_stats_table") \
15463 _(dump_macro_table, "usage: dump_macro_table ") \
15464 _(dump_node_table, "usage: dump_node_table") \
15465 _(echo, "usage: echo <message>") \
15466 _(exec, "usage: exec <vpe-debug-CLI-command>") \
15467 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
15468 _(help, "usage: help") \
15469 _(q, "usage: quit") \
15470 _(quit, "usage: quit") \
15471 _(search_node_table, "usage: search_node_table <name>...") \
15472 _(set, "usage: set <variable-name> <value>") \
15473 _(script, "usage: script <file-name>") \
15474 _(unset, "usage: unset <variable-name>")
15477 static void vl_api_##n##_t_handler_uni \
15478 (vl_api_##n##_t * mp) \
15480 vat_main_t * vam = &vat_main; \
15481 if (vam->json_output) { \
15482 vl_api_##n##_t_handler_json(mp); \
15484 vl_api_##n##_t_handler(mp); \
15487 foreach_vpe_api_reply_msg;
15491 vat_api_hookup (vat_main_t * vam)
15494 vl_msg_api_set_handlers(VL_API_##N, #n, \
15495 vl_api_##n##_t_handler_uni, \
15497 vl_api_##n##_t_endian, \
15498 vl_api_##n##_t_print, \
15499 sizeof(vl_api_##n##_t), 1);
15500 foreach_vpe_api_reply_msg;
15503 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
15505 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
15507 vam->function_by_name = hash_create_string (0, sizeof (uword));
15509 vam->help_by_name = hash_create_string (0, sizeof (uword));
15511 /* API messages we can send */
15512 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
15513 foreach_vpe_api_msg;
15517 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
15518 foreach_vpe_api_msg;
15521 /* CLI functions */
15522 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
15523 foreach_cli_function;
15527 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
15528 foreach_cli_function;
15532 #undef vl_api_version
15533 #define vl_api_version(n,v) static u32 vpe_api_version = v;
15534 #include <vpp-api/vpe.api.h>
15535 #undef vl_api_version
15538 vl_client_add_api_signatures (vl_api_memclnt_create_t * mp)
15541 * Send the main API signature in slot 0. This bit of code must
15542 * match the checks in ../vpe/api/api.c: vl_msg_api_version_check().
15544 mp->api_versions[0] = clib_host_to_net_u32 (vpe_api_version);
15548 * fd.io coding-style-patch-verification: ON
15551 * eval: (c-set-style "gnu")