2 *------------------------------------------------------------------
5 * Copyright (c) 2014 Cisco and/or its affiliates.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at:
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *------------------------------------------------------------------
21 #include <vlibapi/api.h>
22 #include <vlibmemory/api.h>
23 #include <vlibsocket/api.h>
24 #include <vnet/ip/ip.h>
25 #include <vnet/sr/sr_packet.h>
26 #include <vnet/l2/l2_input.h>
27 #include <vnet/l2tp/l2tp.h>
28 #include <vnet/vxlan/vxlan.h>
29 #include <vnet/gre/gre.h>
30 #include <vnet/vxlan-gpe/vxlan_gpe.h>
31 #include <vnet/lisp-gpe/lisp_gpe.h>
33 #include <vpp-api/vpe_msg_enum.h>
34 #include <vnet/l2/l2_classify.h>
35 #include <vnet/l2/l2_vtr.h>
36 #include <vnet/classify/input_acl.h>
37 #include <vnet/classify/policer_classify.h>
38 #include <vnet/mpls/mpls.h>
40 #include <vnet/ipsec/ipsec.h>
41 #include <vnet/ipsec/ikev2.h>
45 #include <vnet/map/map.h>
46 #include <vnet/cop/cop.h>
47 #include <vnet/ip/ip6_hop_by_hop.h>
48 #include <vnet/ip/ip_source_and_port_range_check.h>
49 #include <vnet/policer/xlate.h>
50 #include <vnet/policer/policer.h>
51 #include <vnet/policer/police.h>
53 #include "vat/json_format.h"
57 #define vl_typedefs /* define message structures */
58 #include <vpp-api/vpe_all_api_h.h>
61 /* declare message handlers for each api */
63 #define vl_endianfun /* define message structures */
64 #include <vpp-api/vpe_all_api_h.h>
67 /* instantiate all the print functions we know about */
68 #define vl_print(handle, ...)
70 #include <vpp-api/vpe_all_api_h.h>
74 unformat_sw_if_index (unformat_input_t * input, va_list * args)
76 vat_main_t *vam = va_arg (*args, vat_main_t *);
77 u32 *result = va_arg (*args, u32 *);
81 if (!unformat (input, "%s", &if_name))
84 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
91 /* Parse an IP4 address %d.%d.%d.%d. */
93 unformat_ip4_address (unformat_input_t * input, va_list * args)
95 u8 *result = va_arg (*args, u8 *);
98 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
101 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
114 unformat_ethernet_address (unformat_input_t * input, va_list * args)
116 u8 *result = va_arg (*args, u8 *);
119 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
120 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
124 for (i = 0; i < 6; i++)
125 if (a[i] >= (1 << 8))
128 for (i = 0; i < 6; i++)
134 /* Returns ethernet type as an int in host byte order. */
136 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
139 u16 *result = va_arg (*args, u16 *);
143 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
145 if (type >= (1 << 16))
153 /* Parse an IP6 address. */
155 unformat_ip6_address (unformat_input_t * input, va_list * args)
157 ip6_address_t *result = va_arg (*args, ip6_address_t *);
159 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
160 uword c, n_colon, double_colon_index;
162 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
163 double_colon_index = ARRAY_LEN (hex_quads);
164 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
167 if (c >= '0' && c <= '9')
169 else if (c >= 'a' && c <= 'f')
170 hex_digit = c + 10 - 'a';
171 else if (c >= 'A' && c <= 'F')
172 hex_digit = c + 10 - 'A';
173 else if (c == ':' && n_colon < 2)
177 unformat_put_input (input);
181 /* Too many hex quads. */
182 if (n_hex_quads >= ARRAY_LEN (hex_quads))
187 hex_quad = (hex_quad << 4) | hex_digit;
189 /* Hex quad must fit in 16 bits. */
190 if (n_hex_digits >= 4)
197 /* Save position of :: */
200 /* More than one :: ? */
201 if (double_colon_index < ARRAY_LEN (hex_quads))
203 double_colon_index = n_hex_quads;
206 if (n_colon > 0 && n_hex_digits > 0)
208 hex_quads[n_hex_quads++] = hex_quad;
214 if (n_hex_digits > 0)
215 hex_quads[n_hex_quads++] = hex_quad;
220 /* Expand :: to appropriate number of zero hex quads. */
221 if (double_colon_index < ARRAY_LEN (hex_quads))
223 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
225 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
226 hex_quads[n_zero + i] = hex_quads[i];
228 for (i = 0; i < n_zero; i++)
229 hex_quads[double_colon_index + i] = 0;
231 n_hex_quads = ARRAY_LEN (hex_quads);
234 /* Too few hex quads given. */
235 if (n_hex_quads < ARRAY_LEN (hex_quads))
238 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
239 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
246 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
249 u32 *r = va_arg (*args, u32 *);
252 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
253 foreach_ipsec_policy_action
264 unformat_ipsec_crypto_alg (unformat_input_t * input, va_list * args)
267 u32 *r = va_arg (*args, u32 *);
270 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_CRYPTO_ALG_##f;
271 foreach_ipsec_crypto_alg
282 format_ipsec_crypto_alg (u8 * s, va_list * args)
285 u32 i = va_arg (*args, u32);
290 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
291 foreach_ipsec_crypto_alg
294 return format (s, "unknown");
296 return format (s, "%s", t);
298 return format (s, "Unimplemented");
303 unformat_ipsec_integ_alg (unformat_input_t * input, va_list * args)
306 u32 *r = va_arg (*args, u32 *);
309 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_INTEG_ALG_##f;
310 foreach_ipsec_integ_alg
321 format_ipsec_integ_alg (u8 * s, va_list * args)
324 u32 i = va_arg (*args, u32);
329 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
330 foreach_ipsec_integ_alg
333 return format (s, "unknown");
335 return format (s, "%s", t);
337 return format (s, "Unsupported");
342 unformat_ikev2_auth_method (unformat_input_t * input, va_list * args)
345 u32 *r = va_arg (*args, u32 *);
348 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_AUTH_METHOD_##f;
349 foreach_ikev2_auth_method
360 unformat_ikev2_id_type (unformat_input_t * input, va_list * args)
363 u32 *r = va_arg (*args, u32 *);
366 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_ID_TYPE_##f;
367 foreach_ikev2_id_type
378 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
380 u8 *r = va_arg (*args, u8 *);
382 if (unformat (input, "kbps"))
383 *r = SSE2_QOS_RATE_KBPS;
384 else if (unformat (input, "pps"))
385 *r = SSE2_QOS_RATE_PPS;
392 unformat_policer_round_type (unformat_input_t * input, va_list * args)
394 u8 *r = va_arg (*args, u8 *);
396 if (unformat (input, "closest"))
397 *r = SSE2_QOS_ROUND_TO_CLOSEST;
398 else if (unformat (input, "up"))
399 *r = SSE2_QOS_ROUND_TO_UP;
400 else if (unformat (input, "down"))
401 *r = SSE2_QOS_ROUND_TO_DOWN;
408 unformat_policer_type (unformat_input_t * input, va_list * args)
410 u8 *r = va_arg (*args, u8 *);
412 if (unformat (input, "1r2c"))
413 *r = SSE2_QOS_POLICER_TYPE_1R2C;
414 else if (unformat (input, "1r3c"))
415 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
416 else if (unformat (input, "2r3c-2698"))
417 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
418 else if (unformat (input, "2r3c-4115"))
419 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
420 else if (unformat (input, "2r3c-mef5cf1"))
421 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
428 unformat_dscp (unformat_input_t * input, va_list * va)
430 u8 *r = va_arg (*va, u8 *);
433 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
442 unformat_policer_action_type (unformat_input_t * input, va_list * va)
444 sse2_qos_pol_action_params_st *a
445 = va_arg (*va, sse2_qos_pol_action_params_st *);
447 if (unformat (input, "drop"))
448 a->action_type = SSE2_QOS_ACTION_DROP;
449 else if (unformat (input, "transmit"))
450 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
451 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
452 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
459 unformat_classify_table_type (unformat_input_t * input, va_list * va)
461 u32 *r = va_arg (*va, u32 *);
464 if (unformat (input, "ip4"))
465 tid = POLICER_CLASSIFY_TABLE_IP4;
466 else if (unformat (input, "ip6"))
467 tid = POLICER_CLASSIFY_TABLE_IP6;
468 else if (unformat (input, "l2"))
469 tid = POLICER_CLASSIFY_TABLE_L2;
478 format_ip4_address (u8 * s, va_list * args)
480 u8 *a = va_arg (*args, u8 *);
481 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
485 format_ip6_address (u8 * s, va_list * args)
487 ip6_address_t *a = va_arg (*args, ip6_address_t *);
488 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
490 i_max_n_zero = ARRAY_LEN (a->as_u16);
492 i_first_zero = i_max_n_zero;
494 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
496 u32 is_zero = a->as_u16[i] == 0;
497 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
503 if ((!is_zero && n_zeros > max_n_zeros)
504 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
506 i_max_n_zero = i_first_zero;
507 max_n_zeros = n_zeros;
508 i_first_zero = ARRAY_LEN (a->as_u16);
513 last_double_colon = 0;
514 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
516 if (i == i_max_n_zero && max_n_zeros > 1)
518 s = format (s, "::");
519 i += max_n_zeros - 1;
520 last_double_colon = 1;
524 s = format (s, "%s%x",
525 (last_double_colon || i == 0) ? "" : ":",
526 clib_net_to_host_u16 (a->as_u16[i]));
527 last_double_colon = 0;
534 /* Format an IP46 address. */
536 format_ip46_address (u8 * s, va_list * args)
538 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
539 ip46_type_t type = va_arg (*args, ip46_type_t);
545 is_ip4 = ip46_address_is_ip4 (ip46);
556 format (s, "%U", format_ip4_address, &ip46->ip4) :
557 format (s, "%U", format_ip6_address, &ip46->ip6);
561 format_ethernet_address (u8 * s, va_list * args)
563 u8 *a = va_arg (*args, u8 *);
565 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
566 a[0], a[1], a[2], a[3], a[4], a[5]);
570 increment_v4_address (ip4_address_t * a)
574 v = ntohl (a->as_u32) + 1;
575 a->as_u32 = ntohl (v);
579 increment_v6_address (ip6_address_t * a)
583 v0 = clib_net_to_host_u64 (a->as_u64[0]);
584 v1 = clib_net_to_host_u64 (a->as_u64[1]);
589 a->as_u64[0] = clib_net_to_host_u64 (v0);
590 a->as_u64[1] = clib_net_to_host_u64 (v1);
594 increment_mac_address (u64 * mac)
598 tmp = clib_net_to_host_u64 (tmp);
599 tmp += 1 << 16; /* skip unused (least significant) octets */
600 tmp = clib_host_to_net_u64 (tmp);
604 static void vl_api_create_loopback_reply_t_handler
605 (vl_api_create_loopback_reply_t * mp)
607 vat_main_t *vam = &vat_main;
608 i32 retval = ntohl (mp->retval);
610 vam->retval = retval;
611 vam->regenerate_interface_table = 1;
612 vam->sw_if_index = ntohl (mp->sw_if_index);
613 vam->result_ready = 1;
616 static void vl_api_create_loopback_reply_t_handler_json
617 (vl_api_create_loopback_reply_t * mp)
619 vat_main_t *vam = &vat_main;
620 vat_json_node_t node;
622 vat_json_init_object (&node);
623 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
624 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
626 vat_json_print (vam->ofp, &node);
627 vat_json_free (&node);
628 vam->retval = ntohl (mp->retval);
629 vam->result_ready = 1;
632 static void vl_api_af_packet_create_reply_t_handler
633 (vl_api_af_packet_create_reply_t * mp)
635 vat_main_t *vam = &vat_main;
636 i32 retval = ntohl (mp->retval);
638 vam->retval = retval;
639 vam->regenerate_interface_table = 1;
640 vam->sw_if_index = ntohl (mp->sw_if_index);
641 vam->result_ready = 1;
644 static void vl_api_af_packet_create_reply_t_handler_json
645 (vl_api_af_packet_create_reply_t * mp)
647 vat_main_t *vam = &vat_main;
648 vat_json_node_t node;
650 vat_json_init_object (&node);
651 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
652 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
654 vat_json_print (vam->ofp, &node);
655 vat_json_free (&node);
657 vam->retval = ntohl (mp->retval);
658 vam->result_ready = 1;
661 static void vl_api_create_vlan_subif_reply_t_handler
662 (vl_api_create_vlan_subif_reply_t * mp)
664 vat_main_t *vam = &vat_main;
665 i32 retval = ntohl (mp->retval);
667 vam->retval = retval;
668 vam->regenerate_interface_table = 1;
669 vam->sw_if_index = ntohl (mp->sw_if_index);
670 vam->result_ready = 1;
673 static void vl_api_create_vlan_subif_reply_t_handler_json
674 (vl_api_create_vlan_subif_reply_t * mp)
676 vat_main_t *vam = &vat_main;
677 vat_json_node_t node;
679 vat_json_init_object (&node);
680 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
681 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
683 vat_json_print (vam->ofp, &node);
684 vat_json_free (&node);
686 vam->retval = ntohl (mp->retval);
687 vam->result_ready = 1;
690 static void vl_api_create_subif_reply_t_handler
691 (vl_api_create_subif_reply_t * mp)
693 vat_main_t *vam = &vat_main;
694 i32 retval = ntohl (mp->retval);
696 vam->retval = retval;
697 vam->regenerate_interface_table = 1;
698 vam->sw_if_index = ntohl (mp->sw_if_index);
699 vam->result_ready = 1;
702 static void vl_api_create_subif_reply_t_handler_json
703 (vl_api_create_subif_reply_t * mp)
705 vat_main_t *vam = &vat_main;
706 vat_json_node_t node;
708 vat_json_init_object (&node);
709 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
710 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
712 vat_json_print (vam->ofp, &node);
713 vat_json_free (&node);
715 vam->retval = ntohl (mp->retval);
716 vam->result_ready = 1;
719 static void vl_api_interface_name_renumber_reply_t_handler
720 (vl_api_interface_name_renumber_reply_t * mp)
722 vat_main_t *vam = &vat_main;
723 i32 retval = ntohl (mp->retval);
725 vam->retval = retval;
726 vam->regenerate_interface_table = 1;
727 vam->result_ready = 1;
730 static void vl_api_interface_name_renumber_reply_t_handler_json
731 (vl_api_interface_name_renumber_reply_t * mp)
733 vat_main_t *vam = &vat_main;
734 vat_json_node_t node;
736 vat_json_init_object (&node);
737 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
739 vat_json_print (vam->ofp, &node);
740 vat_json_free (&node);
742 vam->retval = ntohl (mp->retval);
743 vam->result_ready = 1;
747 * Special-case: build the interface table, maintain
748 * the next loopback sw_if_index vbl.
750 static void vl_api_sw_interface_details_t_handler
751 (vl_api_sw_interface_details_t * mp)
753 vat_main_t *vam = &vat_main;
754 u8 *s = format (0, "%s%c", mp->interface_name, 0);
756 hash_set_mem (vam->sw_if_index_by_interface_name, s,
757 ntohl (mp->sw_if_index));
759 /* In sub interface case, fill the sub interface table entry */
760 if (mp->sw_if_index != mp->sup_sw_if_index)
762 sw_interface_subif_t *sub = NULL;
764 vec_add2 (vam->sw_if_subif_table, sub, 1);
766 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
767 strncpy ((char *) sub->interface_name, (char *) s,
768 vec_len (sub->interface_name));
769 sub->sw_if_index = ntohl (mp->sw_if_index);
770 sub->sub_id = ntohl (mp->sub_id);
772 sub->sub_dot1ad = mp->sub_dot1ad;
773 sub->sub_number_of_tags = mp->sub_number_of_tags;
774 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
775 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
776 sub->sub_exact_match = mp->sub_exact_match;
777 sub->sub_default = mp->sub_default;
778 sub->sub_outer_vlan_id_any = mp->sub_outer_vlan_id_any;
779 sub->sub_inner_vlan_id_any = mp->sub_inner_vlan_id_any;
781 /* vlan tag rewrite */
782 sub->vtr_op = ntohl (mp->vtr_op);
783 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
784 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
785 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
789 static void vl_api_sw_interface_details_t_handler_json
790 (vl_api_sw_interface_details_t * mp)
792 vat_main_t *vam = &vat_main;
793 vat_json_node_t *node = NULL;
795 if (VAT_JSON_ARRAY != vam->json_tree.type)
797 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
798 vat_json_init_array (&vam->json_tree);
800 node = vat_json_array_add (&vam->json_tree);
802 vat_json_init_object (node);
803 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
804 vat_json_object_add_uint (node, "sup_sw_if_index",
805 ntohl (mp->sup_sw_if_index));
806 vat_json_object_add_uint (node, "l2_address_length",
807 ntohl (mp->l2_address_length));
808 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
809 sizeof (mp->l2_address));
810 vat_json_object_add_string_copy (node, "interface_name",
812 vat_json_object_add_uint (node, "admin_up_down", mp->admin_up_down);
813 vat_json_object_add_uint (node, "link_up_down", mp->link_up_down);
814 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
815 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
816 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
817 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
818 vat_json_object_add_uint (node, "sub_dot1ad", mp->sub_dot1ad);
819 vat_json_object_add_uint (node, "sub_number_of_tags",
820 mp->sub_number_of_tags);
821 vat_json_object_add_uint (node, "sub_outer_vlan_id",
822 ntohs (mp->sub_outer_vlan_id));
823 vat_json_object_add_uint (node, "sub_inner_vlan_id",
824 ntohs (mp->sub_inner_vlan_id));
825 vat_json_object_add_uint (node, "sub_exact_match", mp->sub_exact_match);
826 vat_json_object_add_uint (node, "sub_default", mp->sub_default);
827 vat_json_object_add_uint (node, "sub_outer_vlan_id_any",
828 mp->sub_outer_vlan_id_any);
829 vat_json_object_add_uint (node, "sub_inner_vlan_id_any",
830 mp->sub_inner_vlan_id_any);
831 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
832 vat_json_object_add_uint (node, "vtr_push_dot1q",
833 ntohl (mp->vtr_push_dot1q));
834 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
835 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
838 static void vl_api_sw_interface_set_flags_t_handler
839 (vl_api_sw_interface_set_flags_t * mp)
841 vat_main_t *vam = &vat_main;
842 if (vam->interface_event_display)
843 errmsg ("interface flags: sw_if_index %d %s %s\n",
844 ntohl (mp->sw_if_index),
845 mp->admin_up_down ? "admin-up" : "admin-down",
846 mp->link_up_down ? "link-up" : "link-down");
849 static void vl_api_sw_interface_set_flags_t_handler_json
850 (vl_api_sw_interface_set_flags_t * mp)
852 /* JSON output not supported */
856 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
858 vat_main_t *vam = &vat_main;
859 i32 retval = ntohl (mp->retval);
861 vam->retval = retval;
862 vam->shmem_result = (u8 *) mp->reply_in_shmem;
863 vam->result_ready = 1;
867 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
869 vat_main_t *vam = &vat_main;
870 vat_json_node_t node;
871 api_main_t *am = &api_main;
875 vat_json_init_object (&node);
876 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
877 vat_json_object_add_uint (&node, "reply_in_shmem",
878 ntohl (mp->reply_in_shmem));
879 /* Toss the shared-memory original... */
880 pthread_mutex_lock (&am->vlib_rp->mutex);
881 oldheap = svm_push_data_heap (am->vlib_rp);
883 reply = (u8 *) (mp->reply_in_shmem);
886 svm_pop_heap (oldheap);
887 pthread_mutex_unlock (&am->vlib_rp->mutex);
889 vat_json_print (vam->ofp, &node);
890 vat_json_free (&node);
892 vam->retval = ntohl (mp->retval);
893 vam->result_ready = 1;
897 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
899 vat_main_t *vam = &vat_main;
900 i32 retval = ntohl (mp->retval);
902 vam->retval = retval;
903 vam->cmd_reply = mp->reply;
904 vam->result_ready = 1;
908 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
910 vat_main_t *vam = &vat_main;
911 vat_json_node_t node;
913 vat_json_init_object (&node);
914 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
915 vat_json_object_add_string_copy (&node, "reply", mp->reply);
917 vat_json_print (vam->ofp, &node);
918 vat_json_free (&node);
920 vam->retval = ntohl (mp->retval);
921 vam->result_ready = 1;
924 static void vl_api_classify_add_del_table_reply_t_handler
925 (vl_api_classify_add_del_table_reply_t * mp)
927 vat_main_t *vam = &vat_main;
928 i32 retval = ntohl (mp->retval);
931 vam->async_errors += (retval < 0);
935 vam->retval = retval;
937 ((mp->new_table_index != 0xFFFFFFFF) ||
938 (mp->skip_n_vectors != 0xFFFFFFFF) ||
939 (mp->match_n_vectors != 0xFFFFFFFF)))
941 * Note: this is just barely thread-safe, depends on
942 * the main thread spinning waiting for an answer...
944 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d\n",
945 ntohl (mp->new_table_index),
946 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
947 vam->result_ready = 1;
951 static void vl_api_classify_add_del_table_reply_t_handler_json
952 (vl_api_classify_add_del_table_reply_t * mp)
954 vat_main_t *vam = &vat_main;
955 vat_json_node_t node;
957 vat_json_init_object (&node);
958 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
959 vat_json_object_add_uint (&node, "new_table_index",
960 ntohl (mp->new_table_index));
961 vat_json_object_add_uint (&node, "skip_n_vectors",
962 ntohl (mp->skip_n_vectors));
963 vat_json_object_add_uint (&node, "match_n_vectors",
964 ntohl (mp->match_n_vectors));
966 vat_json_print (vam->ofp, &node);
967 vat_json_free (&node);
969 vam->retval = ntohl (mp->retval);
970 vam->result_ready = 1;
973 static void vl_api_get_node_index_reply_t_handler
974 (vl_api_get_node_index_reply_t * mp)
976 vat_main_t *vam = &vat_main;
977 i32 retval = ntohl (mp->retval);
980 vam->async_errors += (retval < 0);
984 vam->retval = retval;
986 errmsg ("node index %d\n", ntohl (mp->node_index));
987 vam->result_ready = 1;
991 static void vl_api_get_node_index_reply_t_handler_json
992 (vl_api_get_node_index_reply_t * mp)
994 vat_main_t *vam = &vat_main;
995 vat_json_node_t node;
997 vat_json_init_object (&node);
998 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
999 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1001 vat_json_print (vam->ofp, &node);
1002 vat_json_free (&node);
1004 vam->retval = ntohl (mp->retval);
1005 vam->result_ready = 1;
1008 static void vl_api_get_next_index_reply_t_handler
1009 (vl_api_get_next_index_reply_t * mp)
1011 vat_main_t *vam = &vat_main;
1012 i32 retval = ntohl (mp->retval);
1013 if (vam->async_mode)
1015 vam->async_errors += (retval < 0);
1019 vam->retval = retval;
1021 errmsg ("next node index %d\n", ntohl (mp->next_index));
1022 vam->result_ready = 1;
1026 static void vl_api_get_next_index_reply_t_handler_json
1027 (vl_api_get_next_index_reply_t * mp)
1029 vat_main_t *vam = &vat_main;
1030 vat_json_node_t node;
1032 vat_json_init_object (&node);
1033 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1034 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1036 vat_json_print (vam->ofp, &node);
1037 vat_json_free (&node);
1039 vam->retval = ntohl (mp->retval);
1040 vam->result_ready = 1;
1043 static void vl_api_add_node_next_reply_t_handler
1044 (vl_api_add_node_next_reply_t * mp)
1046 vat_main_t *vam = &vat_main;
1047 i32 retval = ntohl (mp->retval);
1048 if (vam->async_mode)
1050 vam->async_errors += (retval < 0);
1054 vam->retval = retval;
1056 errmsg ("next index %d\n", ntohl (mp->next_index));
1057 vam->result_ready = 1;
1061 static void vl_api_add_node_next_reply_t_handler_json
1062 (vl_api_add_node_next_reply_t * mp)
1064 vat_main_t *vam = &vat_main;
1065 vat_json_node_t node;
1067 vat_json_init_object (&node);
1068 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1069 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1071 vat_json_print (vam->ofp, &node);
1072 vat_json_free (&node);
1074 vam->retval = ntohl (mp->retval);
1075 vam->result_ready = 1;
1078 static void vl_api_mpls_gre_add_del_tunnel_reply_t_handler
1079 (vl_api_mpls_gre_add_del_tunnel_reply_t * mp)
1081 vat_main_t *vam = &vat_main;
1082 i32 retval = ntohl (mp->retval);
1083 u32 sw_if_index = ntohl (mp->tunnel_sw_if_index);
1085 if (retval >= 0 && sw_if_index != (u32) ~ 0)
1087 errmsg ("tunnel_sw_if_index %d\n", sw_if_index);
1089 vam->retval = retval;
1090 vam->result_ready = 1;
1093 static void vl_api_mpls_gre_add_del_tunnel_reply_t_handler_json
1094 (vl_api_mpls_gre_add_del_tunnel_reply_t * mp)
1096 vat_main_t *vam = &vat_main;
1097 vat_json_node_t node;
1099 vat_json_init_object (&node);
1100 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1101 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
1102 ntohl (mp->tunnel_sw_if_index));
1104 vat_json_print (vam->ofp, &node);
1105 vat_json_free (&node);
1107 vam->retval = ntohl (mp->retval);
1108 vam->result_ready = 1;
1112 static void vl_api_show_version_reply_t_handler
1113 (vl_api_show_version_reply_t * mp)
1115 vat_main_t *vam = &vat_main;
1116 i32 retval = ntohl (mp->retval);
1120 errmsg (" program: %s\n", mp->program);
1121 errmsg (" version: %s\n", mp->version);
1122 errmsg (" build date: %s\n", mp->build_date);
1123 errmsg ("build directory: %s\n", mp->build_directory);
1125 vam->retval = retval;
1126 vam->result_ready = 1;
1129 static void vl_api_show_version_reply_t_handler_json
1130 (vl_api_show_version_reply_t * mp)
1132 vat_main_t *vam = &vat_main;
1133 vat_json_node_t node;
1135 vat_json_init_object (&node);
1136 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1137 vat_json_object_add_string_copy (&node, "program", mp->program);
1138 vat_json_object_add_string_copy (&node, "version", mp->version);
1139 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1140 vat_json_object_add_string_copy (&node, "build_directory",
1141 mp->build_directory);
1143 vat_json_print (vam->ofp, &node);
1144 vat_json_free (&node);
1146 vam->retval = ntohl (mp->retval);
1147 vam->result_ready = 1;
1151 vl_api_ip4_arp_event_t_handler (vl_api_ip4_arp_event_t * mp)
1153 vat_main_t *vam = &vat_main;
1154 errmsg ("arp %s event: address %U new mac %U sw_if_index %d\n",
1155 mp->mac_ip ? "mac/ip binding" : "address resolution",
1156 format_ip4_address, &mp->address,
1157 format_ethernet_address, mp->new_mac, mp->sw_if_index);
1161 vl_api_ip4_arp_event_t_handler_json (vl_api_ip4_arp_event_t * mp)
1163 /* JSON output not supported */
1167 vl_api_ip6_nd_event_t_handler (vl_api_ip6_nd_event_t * mp)
1169 vat_main_t *vam = &vat_main;
1170 errmsg ("ip6 nd %s event: address %U new mac %U sw_if_index %d\n",
1171 mp->mac_ip ? "mac/ip binding" : "address resolution",
1172 format_ip6_address, mp->address,
1173 format_ethernet_address, mp->new_mac, mp->sw_if_index);
1177 vl_api_ip6_nd_event_t_handler_json (vl_api_ip6_nd_event_t * mp)
1179 /* JSON output not supported */
1183 * Special-case: build the bridge domain table, maintain
1184 * the next bd id vbl.
1186 static void vl_api_bridge_domain_details_t_handler
1187 (vl_api_bridge_domain_details_t * mp)
1189 vat_main_t *vam = &vat_main;
1190 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1192 fformat (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-3s\n",
1193 " ID", "LRN", "FWD", "FLD", "BVI", "#IF");
1195 fformat (vam->ofp, "%3d %3d %3d %3d %3d %3d\n",
1196 ntohl (mp->bd_id), mp->learn, mp->forward,
1197 mp->flood, ntohl (mp->bvi_sw_if_index), n_sw_ifs);
1200 fformat (vam->ofp, "\n\n%s %s %s\n", "sw_if_index", "SHG",
1204 static void vl_api_bridge_domain_details_t_handler_json
1205 (vl_api_bridge_domain_details_t * mp)
1207 vat_main_t *vam = &vat_main;
1208 vat_json_node_t *node, *array = NULL;
1210 if (VAT_JSON_ARRAY != vam->json_tree.type)
1212 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1213 vat_json_init_array (&vam->json_tree);
1215 node = vat_json_array_add (&vam->json_tree);
1217 vat_json_init_object (node);
1218 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1219 vat_json_object_add_uint (node, "flood", mp->flood);
1220 vat_json_object_add_uint (node, "forward", mp->forward);
1221 vat_json_object_add_uint (node, "learn", mp->learn);
1222 vat_json_object_add_uint (node, "bvi_sw_if_index",
1223 ntohl (mp->bvi_sw_if_index));
1224 vat_json_object_add_uint (node, "n_sw_ifs", ntohl (mp->n_sw_ifs));
1225 array = vat_json_object_add (node, "sw_if");
1226 vat_json_init_array (array);
1230 * Special-case: build the bridge domain sw if table.
1232 static void vl_api_bridge_domain_sw_if_details_t_handler
1233 (vl_api_bridge_domain_sw_if_details_t * mp)
1235 vat_main_t *vam = &vat_main;
1240 sw_if_index = ntohl (mp->sw_if_index);
1242 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1244 if ((u32) p->value[0] == sw_if_index)
1246 sw_if_name = (u8 *)(p->key);
1252 fformat (vam->ofp, "%7d %3d %s", sw_if_index,
1253 mp->shg, sw_if_name ? (char *) sw_if_name :
1254 "sw_if_index not found!");
1257 static void vl_api_bridge_domain_sw_if_details_t_handler_json
1258 (vl_api_bridge_domain_sw_if_details_t * mp)
1260 vat_main_t *vam = &vat_main;
1261 vat_json_node_t *node = NULL;
1262 uword last_index = 0;
1264 ASSERT (VAT_JSON_ARRAY == vam->json_tree.type);
1265 ASSERT (vec_len (vam->json_tree.array) >= 1);
1266 last_index = vec_len (vam->json_tree.array) - 1;
1267 node = &vam->json_tree.array[last_index];
1268 node = vat_json_object_get_element (node, "sw_if");
1269 ASSERT (NULL != node);
1270 node = vat_json_array_add (node);
1272 vat_json_init_object (node);
1273 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1274 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
1275 vat_json_object_add_uint (node, "shg", mp->shg);
1278 static void vl_api_control_ping_reply_t_handler
1279 (vl_api_control_ping_reply_t * mp)
1281 vat_main_t *vam = &vat_main;
1282 i32 retval = ntohl (mp->retval);
1283 if (vam->async_mode)
1285 vam->async_errors += (retval < 0);
1289 vam->retval = retval;
1290 vam->result_ready = 1;
1294 static void vl_api_control_ping_reply_t_handler_json
1295 (vl_api_control_ping_reply_t * mp)
1297 vat_main_t *vam = &vat_main;
1298 i32 retval = ntohl (mp->retval);
1300 if (VAT_JSON_NONE != vam->json_tree.type)
1302 vat_json_print (vam->ofp, &vam->json_tree);
1303 vat_json_free (&vam->json_tree);
1304 vam->json_tree.type = VAT_JSON_NONE;
1309 vat_json_init_array (&vam->json_tree);
1310 vat_json_print (vam->ofp, &vam->json_tree);
1311 vam->json_tree.type = VAT_JSON_NONE;
1314 vam->retval = retval;
1315 vam->result_ready = 1;
1319 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1321 vat_main_t *vam = &vat_main;
1322 i32 retval = ntohl (mp->retval);
1323 if (vam->async_mode)
1325 vam->async_errors += (retval < 0);
1329 vam->retval = retval;
1330 vam->result_ready = 1;
1334 static void vl_api_l2_flags_reply_t_handler_json
1335 (vl_api_l2_flags_reply_t * mp)
1337 vat_main_t *vam = &vat_main;
1338 vat_json_node_t node;
1340 vat_json_init_object (&node);
1341 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1342 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1343 ntohl (mp->resulting_feature_bitmap));
1345 vat_json_print (vam->ofp, &node);
1346 vat_json_free (&node);
1348 vam->retval = ntohl (mp->retval);
1349 vam->result_ready = 1;
1352 static void vl_api_bridge_flags_reply_t_handler
1353 (vl_api_bridge_flags_reply_t * mp)
1355 vat_main_t *vam = &vat_main;
1356 i32 retval = ntohl (mp->retval);
1357 if (vam->async_mode)
1359 vam->async_errors += (retval < 0);
1363 vam->retval = retval;
1364 vam->result_ready = 1;
1368 static void vl_api_bridge_flags_reply_t_handler_json
1369 (vl_api_bridge_flags_reply_t * mp)
1371 vat_main_t *vam = &vat_main;
1372 vat_json_node_t node;
1374 vat_json_init_object (&node);
1375 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1376 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1377 ntohl (mp->resulting_feature_bitmap));
1379 vat_json_print (vam->ofp, &node);
1380 vat_json_free (&node);
1382 vam->retval = ntohl (mp->retval);
1383 vam->result_ready = 1;
1386 static void vl_api_tap_connect_reply_t_handler
1387 (vl_api_tap_connect_reply_t * mp)
1389 vat_main_t *vam = &vat_main;
1390 i32 retval = ntohl (mp->retval);
1391 if (vam->async_mode)
1393 vam->async_errors += (retval < 0);
1397 vam->retval = retval;
1398 vam->sw_if_index = ntohl (mp->sw_if_index);
1399 vam->result_ready = 1;
1404 static void vl_api_tap_connect_reply_t_handler_json
1405 (vl_api_tap_connect_reply_t * mp)
1407 vat_main_t *vam = &vat_main;
1408 vat_json_node_t node;
1410 vat_json_init_object (&node);
1411 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1412 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1414 vat_json_print (vam->ofp, &node);
1415 vat_json_free (&node);
1417 vam->retval = ntohl (mp->retval);
1418 vam->result_ready = 1;
1423 vl_api_tap_modify_reply_t_handler (vl_api_tap_modify_reply_t * mp)
1425 vat_main_t *vam = &vat_main;
1426 i32 retval = ntohl (mp->retval);
1427 if (vam->async_mode)
1429 vam->async_errors += (retval < 0);
1433 vam->retval = retval;
1434 vam->sw_if_index = ntohl (mp->sw_if_index);
1435 vam->result_ready = 1;
1439 static void vl_api_tap_modify_reply_t_handler_json
1440 (vl_api_tap_modify_reply_t * mp)
1442 vat_main_t *vam = &vat_main;
1443 vat_json_node_t node;
1445 vat_json_init_object (&node);
1446 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1447 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1449 vat_json_print (vam->ofp, &node);
1450 vat_json_free (&node);
1452 vam->retval = ntohl (mp->retval);
1453 vam->result_ready = 1;
1457 vl_api_tap_delete_reply_t_handler (vl_api_tap_delete_reply_t * mp)
1459 vat_main_t *vam = &vat_main;
1460 i32 retval = ntohl (mp->retval);
1461 if (vam->async_mode)
1463 vam->async_errors += (retval < 0);
1467 vam->retval = retval;
1468 vam->result_ready = 1;
1472 static void vl_api_tap_delete_reply_t_handler_json
1473 (vl_api_tap_delete_reply_t * mp)
1475 vat_main_t *vam = &vat_main;
1476 vat_json_node_t node;
1478 vat_json_init_object (&node);
1479 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1481 vat_json_print (vam->ofp, &node);
1482 vat_json_free (&node);
1484 vam->retval = ntohl (mp->retval);
1485 vam->result_ready = 1;
1488 static void vl_api_mpls_ethernet_add_del_tunnel_reply_t_handler
1489 (vl_api_mpls_ethernet_add_del_tunnel_reply_t * mp)
1491 vat_main_t *vam = &vat_main;
1492 i32 retval = ntohl (mp->retval);
1493 if (vam->async_mode)
1495 vam->async_errors += (retval < 0);
1499 vam->retval = retval;
1500 vam->result_ready = 1;
1504 static void vl_api_mpls_ethernet_add_del_tunnel_reply_t_handler_json
1505 (vl_api_mpls_ethernet_add_del_tunnel_reply_t * mp)
1507 vat_main_t *vam = &vat_main;
1508 vat_json_node_t node;
1510 vat_json_init_object (&node);
1511 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1512 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
1513 ntohl (mp->tunnel_sw_if_index));
1515 vat_json_print (vam->ofp, &node);
1516 vat_json_free (&node);
1518 vam->retval = ntohl (mp->retval);
1519 vam->result_ready = 1;
1522 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
1523 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1525 vat_main_t *vam = &vat_main;
1526 i32 retval = ntohl (mp->retval);
1527 if (vam->async_mode)
1529 vam->async_errors += (retval < 0);
1533 vam->retval = retval;
1534 vam->sw_if_index = ntohl (mp->sw_if_index);
1535 vam->result_ready = 1;
1539 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
1540 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1542 vat_main_t *vam = &vat_main;
1543 vat_json_node_t node;
1545 vat_json_init_object (&node);
1546 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1547 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1549 vat_json_print (vam->ofp, &node);
1550 vat_json_free (&node);
1552 vam->retval = ntohl (mp->retval);
1553 vam->result_ready = 1;
1557 static void vl_api_lisp_add_del_locator_set_reply_t_handler
1558 (vl_api_lisp_add_del_locator_set_reply_t * mp)
1560 vat_main_t *vam = &vat_main;
1561 i32 retval = ntohl (mp->retval);
1562 if (vam->async_mode)
1564 vam->async_errors += (retval < 0);
1568 vam->retval = retval;
1569 vam->result_ready = 1;
1573 static void vl_api_lisp_add_del_locator_set_reply_t_handler_json
1574 (vl_api_lisp_add_del_locator_set_reply_t * mp)
1576 vat_main_t *vam = &vat_main;
1577 vat_json_node_t node;
1579 vat_json_init_object (&node);
1580 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1581 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
1583 vat_json_print (vam->ofp, &node);
1584 vat_json_free (&node);
1586 vam->retval = ntohl (mp->retval);
1587 vam->result_ready = 1;
1590 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
1591 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1593 vat_main_t *vam = &vat_main;
1594 i32 retval = ntohl (mp->retval);
1595 if (vam->async_mode)
1597 vam->async_errors += (retval < 0);
1601 vam->retval = retval;
1602 vam->sw_if_index = ntohl (mp->sw_if_index);
1603 vam->result_ready = 1;
1607 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
1608 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1610 vat_main_t *vam = &vat_main;
1611 vat_json_node_t node;
1613 vat_json_init_object (&node);
1614 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1615 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1617 vat_json_print (vam->ofp, &node);
1618 vat_json_free (&node);
1620 vam->retval = ntohl (mp->retval);
1621 vam->result_ready = 1;
1624 static void vl_api_gre_add_del_tunnel_reply_t_handler
1625 (vl_api_gre_add_del_tunnel_reply_t * mp)
1627 vat_main_t *vam = &vat_main;
1628 i32 retval = ntohl (mp->retval);
1629 if (vam->async_mode)
1631 vam->async_errors += (retval < 0);
1635 vam->retval = retval;
1636 vam->sw_if_index = ntohl (mp->sw_if_index);
1637 vam->result_ready = 1;
1641 static void vl_api_gre_add_del_tunnel_reply_t_handler_json
1642 (vl_api_gre_add_del_tunnel_reply_t * mp)
1644 vat_main_t *vam = &vat_main;
1645 vat_json_node_t node;
1647 vat_json_init_object (&node);
1648 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1649 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1651 vat_json_print (vam->ofp, &node);
1652 vat_json_free (&node);
1654 vam->retval = ntohl (mp->retval);
1655 vam->result_ready = 1;
1658 static void vl_api_create_vhost_user_if_reply_t_handler
1659 (vl_api_create_vhost_user_if_reply_t * mp)
1661 vat_main_t *vam = &vat_main;
1662 i32 retval = ntohl (mp->retval);
1663 if (vam->async_mode)
1665 vam->async_errors += (retval < 0);
1669 vam->retval = retval;
1670 vam->sw_if_index = ntohl (mp->sw_if_index);
1671 vam->result_ready = 1;
1675 static void vl_api_create_vhost_user_if_reply_t_handler_json
1676 (vl_api_create_vhost_user_if_reply_t * mp)
1678 vat_main_t *vam = &vat_main;
1679 vat_json_node_t node;
1681 vat_json_init_object (&node);
1682 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1683 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1685 vat_json_print (vam->ofp, &node);
1686 vat_json_free (&node);
1688 vam->retval = ntohl (mp->retval);
1689 vam->result_ready = 1;
1692 static void vl_api_ip_address_details_t_handler
1693 (vl_api_ip_address_details_t * mp)
1695 vat_main_t *vam = &vat_main;
1696 static ip_address_details_t empty_ip_address_details = { {0} };
1697 ip_address_details_t *address = NULL;
1698 ip_details_t *current_ip_details = NULL;
1699 ip_details_t *details = NULL;
1701 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
1703 if (!details || vam->current_sw_if_index >= vec_len (details)
1704 || !details[vam->current_sw_if_index].present)
1706 errmsg ("ip address details arrived but not stored\n");
1707 errmsg ("ip_dump should be called first\n");
1711 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
1713 #define addresses (current_ip_details->addr)
1715 vec_validate_init_empty (addresses, vec_len (addresses),
1716 empty_ip_address_details);
1718 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
1720 clib_memcpy (&address->ip, &mp->ip, sizeof (address->ip));
1721 address->prefix_length = mp->prefix_length;
1725 static void vl_api_ip_address_details_t_handler_json
1726 (vl_api_ip_address_details_t * mp)
1728 vat_main_t *vam = &vat_main;
1729 vat_json_node_t *node = NULL;
1730 struct in6_addr ip6;
1733 if (VAT_JSON_ARRAY != vam->json_tree.type)
1735 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1736 vat_json_init_array (&vam->json_tree);
1738 node = vat_json_array_add (&vam->json_tree);
1740 vat_json_init_object (node);
1743 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
1744 vat_json_object_add_ip6 (node, "ip", ip6);
1748 clib_memcpy (&ip4, mp->ip, sizeof (ip4));
1749 vat_json_object_add_ip4 (node, "ip", ip4);
1751 vat_json_object_add_uint (node, "prefix_length", mp->prefix_length);
1755 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
1757 vat_main_t *vam = &vat_main;
1758 static ip_details_t empty_ip_details = { 0 };
1759 ip_details_t *ip = NULL;
1760 u32 sw_if_index = ~0;
1762 sw_if_index = ntohl (mp->sw_if_index);
1764 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1765 sw_if_index, empty_ip_details);
1767 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1774 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
1776 vat_main_t *vam = &vat_main;
1778 if (VAT_JSON_ARRAY != vam->json_tree.type)
1780 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1781 vat_json_init_array (&vam->json_tree);
1783 vat_json_array_add_uint (&vam->json_tree,
1784 clib_net_to_host_u32 (mp->sw_if_index));
1787 static void vl_api_map_domain_details_t_handler_json
1788 (vl_api_map_domain_details_t * mp)
1790 vat_json_node_t *node = NULL;
1791 vat_main_t *vam = &vat_main;
1792 struct in6_addr ip6;
1795 if (VAT_JSON_ARRAY != vam->json_tree.type)
1797 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1798 vat_json_init_array (&vam->json_tree);
1801 node = vat_json_array_add (&vam->json_tree);
1802 vat_json_init_object (node);
1804 vat_json_object_add_uint (node, "domain_index",
1805 clib_net_to_host_u32 (mp->domain_index));
1806 clib_memcpy (&ip6, mp->ip6_prefix, sizeof (ip6));
1807 vat_json_object_add_ip6 (node, "ip6_prefix", ip6);
1808 clib_memcpy (&ip4, mp->ip4_prefix, sizeof (ip4));
1809 vat_json_object_add_ip4 (node, "ip4_prefix", ip4);
1810 clib_memcpy (&ip6, mp->ip6_src, sizeof (ip6));
1811 vat_json_object_add_ip6 (node, "ip6_src", ip6);
1812 vat_json_object_add_int (node, "ip6_prefix_len", mp->ip6_prefix_len);
1813 vat_json_object_add_int (node, "ip4_prefix_len", mp->ip4_prefix_len);
1814 vat_json_object_add_int (node, "ip6_src_len", mp->ip6_src_len);
1815 vat_json_object_add_int (node, "ea_bits_len", mp->ea_bits_len);
1816 vat_json_object_add_int (node, "psid_offset", mp->psid_offset);
1817 vat_json_object_add_int (node, "psid_length", mp->psid_length);
1818 vat_json_object_add_uint (node, "flags", mp->flags);
1819 vat_json_object_add_uint (node, "mtu", clib_net_to_host_u16 (mp->mtu));
1820 vat_json_object_add_int (node, "is_translation", mp->is_translation);
1823 static void vl_api_map_domain_details_t_handler
1824 (vl_api_map_domain_details_t * mp)
1826 vat_main_t *vam = &vat_main;
1828 if (mp->is_translation)
1831 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U/%d (ip6-src) index: %u\n",
1832 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1833 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1834 format_ip6_address, mp->ip6_src, mp->ip6_src_len,
1835 clib_net_to_host_u32 (mp->domain_index));
1840 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U (ip6-src) index: %u\n",
1841 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1842 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1843 format_ip6_address, mp->ip6_src,
1844 clib_net_to_host_u32 (mp->domain_index));
1846 fformat (vam->ofp, " ea-len %d psid-offset %d psid-len %d mtu %d %s\n",
1847 mp->ea_bits_len, mp->psid_offset, mp->psid_length, mp->mtu,
1848 mp->is_translation ? "map-t" : "");
1851 static void vl_api_map_rule_details_t_handler_json
1852 (vl_api_map_rule_details_t * mp)
1854 struct in6_addr ip6;
1855 vat_json_node_t *node = NULL;
1856 vat_main_t *vam = &vat_main;
1858 if (VAT_JSON_ARRAY != vam->json_tree.type)
1860 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1861 vat_json_init_array (&vam->json_tree);
1864 node = vat_json_array_add (&vam->json_tree);
1865 vat_json_init_object (node);
1867 vat_json_object_add_uint (node, "psid", clib_net_to_host_u16 (mp->psid));
1868 clib_memcpy (&ip6, mp->ip6_dst, sizeof (ip6));
1869 vat_json_object_add_ip6 (node, "ip6_dst", ip6);
1873 vl_api_map_rule_details_t_handler (vl_api_map_rule_details_t * mp)
1875 vat_main_t *vam = &vat_main;
1876 fformat (vam->ofp, " %d (psid) %U (ip6-dst)\n",
1877 clib_net_to_host_u16 (mp->psid), format_ip6_address, mp->ip6_dst);
1881 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
1883 vat_main_t *vam = &vat_main;
1884 errmsg ("DHCP compl event: pid %d %s hostname %s host_addr %U "
1885 "router_addr %U host_mac %U\n",
1886 mp->pid, mp->is_ipv6 ? "ipv6" : "ipv4", mp->hostname,
1887 format_ip4_address, &mp->host_address,
1888 format_ip4_address, &mp->router_address,
1889 format_ethernet_address, mp->host_mac);
1892 static void vl_api_dhcp_compl_event_t_handler_json
1893 (vl_api_dhcp_compl_event_t * mp)
1895 /* JSON output not supported */
1899 set_simple_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1902 vat_main_t *vam = &vat_main;
1903 static u64 default_counter = 0;
1905 vec_validate_init_empty (vam->simple_interface_counters, vnet_counter_type,
1907 vec_validate_init_empty (vam->simple_interface_counters[vnet_counter_type],
1908 sw_if_index, default_counter);
1909 vam->simple_interface_counters[vnet_counter_type][sw_if_index] = counter;
1913 set_combined_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1914 interface_counter_t counter)
1916 vat_main_t *vam = &vat_main;
1917 static interface_counter_t default_counter = { 0, };
1919 vec_validate_init_empty (vam->combined_interface_counters,
1920 vnet_counter_type, NULL);
1921 vec_validate_init_empty (vam->combined_interface_counters
1922 [vnet_counter_type], sw_if_index, default_counter);
1923 vam->combined_interface_counters[vnet_counter_type][sw_if_index] = counter;
1926 static void vl_api_vnet_interface_counters_t_handler
1927 (vl_api_vnet_interface_counters_t * mp)
1932 static void vl_api_vnet_interface_counters_t_handler_json
1933 (vl_api_vnet_interface_counters_t * mp)
1935 interface_counter_t counter;
1940 u32 first_sw_if_index;
1943 count = ntohl (mp->count);
1944 first_sw_if_index = ntohl (mp->first_sw_if_index);
1946 if (!mp->is_combined)
1948 v_packets = (u64 *) & mp->data;
1949 for (i = 0; i < count; i++)
1952 clib_net_to_host_u64 (clib_mem_unaligned (v_packets, u64));
1953 set_simple_interface_counter (mp->vnet_counter_type,
1954 first_sw_if_index + i, packets);
1960 v = (vlib_counter_t *) & mp->data;
1961 for (i = 0; i < count; i++)
1964 clib_net_to_host_u64 (clib_mem_unaligned (&v->packets, u64));
1966 clib_net_to_host_u64 (clib_mem_unaligned (&v->bytes, u64));
1967 set_combined_interface_counter (mp->vnet_counter_type,
1968 first_sw_if_index + i, counter);
1975 ip4_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
1977 vat_main_t *vam = &vat_main;
1980 for (i = 0; i < vec_len (vam->ip4_fib_counters_vrf_id_by_index); i++)
1982 if (vam->ip4_fib_counters_vrf_id_by_index[i] == vrf_id)
1991 ip6_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
1993 vat_main_t *vam = &vat_main;
1996 for (i = 0; i < vec_len (vam->ip6_fib_counters_vrf_id_by_index); i++)
1998 if (vam->ip6_fib_counters_vrf_id_by_index[i] == vrf_id)
2006 static void vl_api_vnet_ip4_fib_counters_t_handler
2007 (vl_api_vnet_ip4_fib_counters_t * mp)
2012 static void vl_api_vnet_ip4_fib_counters_t_handler_json
2013 (vl_api_vnet_ip4_fib_counters_t * mp)
2015 vat_main_t *vam = &vat_main;
2016 vl_api_ip4_fib_counter_t *v;
2017 ip4_fib_counter_t *counter;
2024 vrf_id = ntohl (mp->vrf_id);
2025 vrf_index = ip4_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2026 if (~0 == vrf_index)
2028 vrf_index = vec_len (vam->ip4_fib_counters_vrf_id_by_index);
2029 vec_validate (vam->ip4_fib_counters_vrf_id_by_index, vrf_index);
2030 vam->ip4_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2031 vec_validate (vam->ip4_fib_counters, vrf_index);
2032 vam->ip4_fib_counters[vrf_index] = NULL;
2035 vec_free (vam->ip4_fib_counters[vrf_index]);
2036 v = (vl_api_ip4_fib_counter_t *) & mp->c;
2037 count = ntohl (mp->count);
2038 for (i = 0; i < count; i++)
2040 vec_validate (vam->ip4_fib_counters[vrf_index], i);
2041 counter = &vam->ip4_fib_counters[vrf_index][i];
2042 clib_memcpy (&ip4, &v->address, sizeof (ip4));
2043 counter->address = ip4;
2044 counter->address_length = v->address_length;
2045 counter->packets = clib_net_to_host_u64 (v->packets);
2046 counter->bytes = clib_net_to_host_u64 (v->bytes);
2051 static void vl_api_vnet_ip6_fib_counters_t_handler
2052 (vl_api_vnet_ip6_fib_counters_t * mp)
2057 static void vl_api_vnet_ip6_fib_counters_t_handler_json
2058 (vl_api_vnet_ip6_fib_counters_t * mp)
2060 vat_main_t *vam = &vat_main;
2061 vl_api_ip6_fib_counter_t *v;
2062 ip6_fib_counter_t *counter;
2063 struct in6_addr ip6;
2069 vrf_id = ntohl (mp->vrf_id);
2070 vrf_index = ip6_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2071 if (~0 == vrf_index)
2073 vrf_index = vec_len (vam->ip6_fib_counters_vrf_id_by_index);
2074 vec_validate (vam->ip6_fib_counters_vrf_id_by_index, vrf_index);
2075 vam->ip6_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2076 vec_validate (vam->ip6_fib_counters, vrf_index);
2077 vam->ip6_fib_counters[vrf_index] = NULL;
2080 vec_free (vam->ip6_fib_counters[vrf_index]);
2081 v = (vl_api_ip6_fib_counter_t *) & mp->c;
2082 count = ntohl (mp->count);
2083 for (i = 0; i < count; i++)
2085 vec_validate (vam->ip6_fib_counters[vrf_index], i);
2086 counter = &vam->ip6_fib_counters[vrf_index][i];
2087 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2088 counter->address = ip6;
2089 counter->address_length = v->address_length;
2090 counter->packets = clib_net_to_host_u64 (v->packets);
2091 counter->bytes = clib_net_to_host_u64 (v->bytes);
2096 static void vl_api_get_first_msg_id_reply_t_handler
2097 (vl_api_get_first_msg_id_reply_t * mp)
2099 vat_main_t *vam = &vat_main;
2100 i32 retval = ntohl (mp->retval);
2102 if (vam->async_mode)
2104 vam->async_errors += (retval < 0);
2108 vam->retval = retval;
2109 vam->result_ready = 1;
2113 errmsg ("first message id %d\n", ntohs (mp->first_msg_id));
2117 static void vl_api_get_first_msg_id_reply_t_handler_json
2118 (vl_api_get_first_msg_id_reply_t * mp)
2120 vat_main_t *vam = &vat_main;
2121 vat_json_node_t node;
2123 vat_json_init_object (&node);
2124 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2125 vat_json_object_add_uint (&node, "first_msg_id",
2126 (uint) ntohs (mp->first_msg_id));
2128 vat_json_print (vam->ofp, &node);
2129 vat_json_free (&node);
2131 vam->retval = ntohl (mp->retval);
2132 vam->result_ready = 1;
2135 static void vl_api_get_node_graph_reply_t_handler
2136 (vl_api_get_node_graph_reply_t * mp)
2138 vat_main_t *vam = &vat_main;
2139 api_main_t *am = &api_main;
2140 i32 retval = ntohl (mp->retval);
2141 u8 *pvt_copy, *reply;
2146 if (vam->async_mode)
2148 vam->async_errors += (retval < 0);
2152 vam->retval = retval;
2153 vam->result_ready = 1;
2156 /* "Should never happen..." */
2160 reply = (u8 *) (mp->reply_in_shmem);
2161 pvt_copy = vec_dup (reply);
2163 /* Toss the shared-memory original... */
2164 pthread_mutex_lock (&am->vlib_rp->mutex);
2165 oldheap = svm_push_data_heap (am->vlib_rp);
2169 svm_pop_heap (oldheap);
2170 pthread_mutex_unlock (&am->vlib_rp->mutex);
2172 if (vam->graph_nodes)
2174 hash_free (vam->graph_node_index_by_name);
2176 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2178 node = vam->graph_nodes[i];
2179 vec_free (node->name);
2180 vec_free (node->next_nodes);
2183 vec_free (vam->graph_nodes);
2186 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2187 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2188 vec_free (pvt_copy);
2190 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2192 node = vam->graph_nodes[i];
2193 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2197 static void vl_api_get_node_graph_reply_t_handler_json
2198 (vl_api_get_node_graph_reply_t * mp)
2200 vat_main_t *vam = &vat_main;
2201 api_main_t *am = &api_main;
2203 vat_json_node_t node;
2206 /* $$$$ make this real? */
2207 vat_json_init_object (&node);
2208 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2209 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2211 reply = (u8 *) (mp->reply_in_shmem);
2213 /* Toss the shared-memory original... */
2214 pthread_mutex_lock (&am->vlib_rp->mutex);
2215 oldheap = svm_push_data_heap (am->vlib_rp);
2219 svm_pop_heap (oldheap);
2220 pthread_mutex_unlock (&am->vlib_rp->mutex);
2222 vat_json_print (vam->ofp, &node);
2223 vat_json_free (&node);
2225 vam->retval = ntohl (mp->retval);
2226 vam->result_ready = 1;
2230 vl_api_lisp_locator_details_t_handler (vl_api_lisp_locator_details_t * mp)
2232 vat_main_t *vam = &vat_main;
2237 s = format (s, "%=16d%=16d%=16d\n",
2238 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2242 s = format (s, "%=16U%=16d%=16d\n",
2243 mp->is_ipv6 ? format_ip6_address :
2245 mp->ip_address, mp->priority, mp->weight);
2248 fformat (vam->ofp, "%v", s);
2253 vl_api_lisp_locator_details_t_handler_json (vl_api_lisp_locator_details_t *
2256 vat_main_t *vam = &vat_main;
2257 vat_json_node_t *node = NULL;
2258 struct in6_addr ip6;
2261 if (VAT_JSON_ARRAY != vam->json_tree.type)
2263 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2264 vat_json_init_array (&vam->json_tree);
2266 node = vat_json_array_add (&vam->json_tree);
2267 vat_json_init_object (node);
2269 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2270 vat_json_object_add_uint (node, "priority", mp->priority);
2271 vat_json_object_add_uint (node, "weight", mp->weight);
2274 vat_json_object_add_uint (node, "sw_if_index",
2275 clib_net_to_host_u32 (mp->sw_if_index));
2280 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2281 vat_json_object_add_ip6 (node, "address", ip6);
2285 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2286 vat_json_object_add_ip4 (node, "address", ip4);
2292 vl_api_lisp_locator_set_details_t_handler (vl_api_lisp_locator_set_details_t *
2295 vat_main_t *vam = &vat_main;
2298 ls_name = format (0, "%s", mp->ls_name);
2300 fformat (vam->ofp, "%=10d%=15v\n", clib_net_to_host_u32 (mp->ls_index),
2306 vl_api_lisp_locator_set_details_t_handler_json
2307 (vl_api_lisp_locator_set_details_t * mp)
2309 vat_main_t *vam = &vat_main;
2310 vat_json_node_t *node = 0;
2313 ls_name = format (0, "%s", mp->ls_name);
2314 vec_add1 (ls_name, 0);
2316 if (VAT_JSON_ARRAY != vam->json_tree.type)
2318 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2319 vat_json_init_array (&vam->json_tree);
2321 node = vat_json_array_add (&vam->json_tree);
2323 vat_json_init_object (node);
2324 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2325 vat_json_object_add_uint (node, "ls_index",
2326 clib_net_to_host_u32 (mp->ls_index));
2331 format_lisp_flat_eid (u8 * s, va_list * args)
2333 u32 type = va_arg (*args, u32);
2334 u8 *eid = va_arg (*args, u8 *);
2335 u32 eid_len = va_arg (*args, u32);
2340 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
2342 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
2344 return format (s, "%U", format_ethernet_address, eid);
2350 format_lisp_eid_vat (u8 * s, va_list * args)
2352 u32 type = va_arg (*args, u32);
2353 u8 *eid = va_arg (*args, u8 *);
2354 u32 eid_len = va_arg (*args, u32);
2355 u8 *seid = va_arg (*args, u8 *);
2356 u32 seid_len = va_arg (*args, u32);
2357 u32 is_src_dst = va_arg (*args, u32);
2360 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
2362 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
2368 vl_api_lisp_eid_table_details_t_handler (vl_api_lisp_eid_table_details_t * mp)
2370 vat_main_t *vam = &vat_main;
2371 u8 *s = 0, *eid = 0;
2373 if (~0 == mp->locator_set_index)
2374 s = format (0, "action: %d", mp->action);
2376 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
2378 eid = format (0, "%U", format_lisp_eid_vat,
2382 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2385 fformat (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-d\n",
2386 clib_net_to_host_u32 (mp->vni),
2388 mp->is_local ? "local" : "remote",
2389 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative);
2395 vl_api_lisp_eid_table_details_t_handler_json (vl_api_lisp_eid_table_details_t
2398 vat_main_t *vam = &vat_main;
2399 vat_json_node_t *node = 0;
2402 if (VAT_JSON_ARRAY != vam->json_tree.type)
2404 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2405 vat_json_init_array (&vam->json_tree);
2407 node = vat_json_array_add (&vam->json_tree);
2409 vat_json_init_object (node);
2410 if (~0 == mp->locator_set_index)
2411 vat_json_object_add_uint (node, "action", mp->action);
2413 vat_json_object_add_uint (node, "locator_set_index",
2414 clib_net_to_host_u32 (mp->locator_set_index));
2416 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
2417 eid = format (0, "%U", format_lisp_eid_vat,
2421 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2423 vat_json_object_add_string_copy (node, "eid", eid);
2424 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2425 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
2426 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
2431 vl_api_lisp_eid_table_map_details_t_handler
2432 (vl_api_lisp_eid_table_map_details_t * mp)
2434 vat_main_t *vam = &vat_main;
2436 u8 *line = format (0, "%=10d%=10d",
2437 clib_net_to_host_u32 (mp->vni),
2438 clib_net_to_host_u32 (mp->dp_table));
2439 fformat (vam->ofp, "%v\n", line);
2444 vl_api_lisp_eid_table_map_details_t_handler_json
2445 (vl_api_lisp_eid_table_map_details_t * mp)
2447 vat_main_t *vam = &vat_main;
2448 vat_json_node_t *node = NULL;
2450 if (VAT_JSON_ARRAY != vam->json_tree.type)
2452 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2453 vat_json_init_array (&vam->json_tree);
2455 node = vat_json_array_add (&vam->json_tree);
2456 vat_json_init_object (node);
2457 vat_json_object_add_uint (node, "dp_table",
2458 clib_net_to_host_u32 (mp->dp_table));
2459 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2463 vl_api_lisp_eid_table_vni_details_t_handler
2464 (vl_api_lisp_eid_table_vni_details_t * mp)
2466 vat_main_t *vam = &vat_main;
2468 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
2469 fformat (vam->ofp, "%v\n", line);
2474 vl_api_lisp_eid_table_vni_details_t_handler_json
2475 (vl_api_lisp_eid_table_vni_details_t * mp)
2477 vat_main_t *vam = &vat_main;
2478 vat_json_node_t *node = NULL;
2480 if (VAT_JSON_ARRAY != vam->json_tree.type)
2482 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2483 vat_json_init_array (&vam->json_tree);
2485 node = vat_json_array_add (&vam->json_tree);
2486 vat_json_init_object (node);
2487 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2491 format_decap_next (u8 * s, va_list * args)
2493 u32 next_index = va_arg (*args, u32);
2497 case LISP_GPE_INPUT_NEXT_DROP:
2498 return format (s, "drop");
2499 case LISP_GPE_INPUT_NEXT_IP4_INPUT:
2500 return format (s, "ip4");
2501 case LISP_GPE_INPUT_NEXT_IP6_INPUT:
2502 return format (s, "ip6");
2504 return format (s, "unknown %d", next_index);
2510 vl_api_lisp_gpe_tunnel_details_t_handler (vl_api_lisp_gpe_tunnel_details_t *
2513 vat_main_t *vam = &vat_main;
2515 u8 *flag_str = NULL;
2517 iid_str = format (0, "%d (0x%x)", ntohl (mp->iid), ntohl (mp->iid));
2519 #define _(n,v) if (mp->flags & v) flag_str = format (flag_str, "%s-bit ", #n);
2520 foreach_lisp_gpe_flag_bit;
2523 fformat (vam->ofp, "%=20d%=30U%=16U%=16d%=16d%=16U"
2524 "%=16d%=16d%=16sd=16d%=16s%=16s\n",
2526 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2528 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2530 ntohl (mp->encap_fib_id),
2531 ntohl (mp->decap_fib_id),
2532 format_decap_next, ntohl (mp->dcap_next),
2534 flag_str, mp->next_protocol, mp->ver_res, mp->res, iid_str);
2540 vl_api_lisp_gpe_tunnel_details_t_handler_json
2541 (vl_api_lisp_gpe_tunnel_details_t * mp)
2543 vat_main_t *vam = &vat_main;
2544 vat_json_node_t *node = NULL;
2545 struct in6_addr ip6;
2549 next_decap_str = format (0, "%U", format_decap_next, htonl (mp->dcap_next));
2551 if (VAT_JSON_ARRAY != vam->json_tree.type)
2553 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2554 vat_json_init_array (&vam->json_tree);
2556 node = vat_json_array_add (&vam->json_tree);
2558 vat_json_init_object (node);
2559 vat_json_object_add_uint (node, "tunel", mp->tunnels);
2562 clib_memcpy (&ip6, mp->source_ip, sizeof (ip6));
2563 vat_json_object_add_ip6 (node, "source address", ip6);
2564 clib_memcpy (&ip6, mp->destination_ip, sizeof (ip6));
2565 vat_json_object_add_ip6 (node, "destination address", ip6);
2569 clib_memcpy (&ip4, mp->source_ip, sizeof (ip4));
2570 vat_json_object_add_ip4 (node, "source address", ip4);
2571 clib_memcpy (&ip4, mp->destination_ip, sizeof (ip4));
2572 vat_json_object_add_ip4 (node, "destination address", ip4);
2574 vat_json_object_add_uint (node, "fib encap", ntohl (mp->encap_fib_id));
2575 vat_json_object_add_uint (node, "fib decap", ntohl (mp->decap_fib_id));
2576 vat_json_object_add_string_copy (node, "decap next", next_decap_str);
2577 vat_json_object_add_uint (node, "lisp version", mp->ver_res >> 6);
2578 vat_json_object_add_uint (node, "flags", mp->flags);
2579 vat_json_object_add_uint (node, "next protocol", mp->next_protocol);
2580 vat_json_object_add_uint (node, "ver_res", mp->ver_res);
2581 vat_json_object_add_uint (node, "res", mp->res);
2582 vat_json_object_add_uint (node, "iid", ntohl (mp->iid));
2584 vec_free (next_decap_str);
2588 vl_api_lisp_map_resolver_details_t_handler (vl_api_lisp_map_resolver_details_t
2591 vat_main_t *vam = &vat_main;
2593 fformat (vam->ofp, "%=20U\n",
2594 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2599 vl_api_lisp_map_resolver_details_t_handler_json
2600 (vl_api_lisp_map_resolver_details_t * mp)
2602 vat_main_t *vam = &vat_main;
2603 vat_json_node_t *node = NULL;
2604 struct in6_addr ip6;
2607 if (VAT_JSON_ARRAY != vam->json_tree.type)
2609 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2610 vat_json_init_array (&vam->json_tree);
2612 node = vat_json_array_add (&vam->json_tree);
2614 vat_json_init_object (node);
2617 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2618 vat_json_object_add_ip6 (node, "map resolver", ip6);
2622 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2623 vat_json_object_add_ip4 (node, "map resolver", ip4);
2628 vl_api_show_lisp_status_reply_t_handler
2629 (vl_api_show_lisp_status_reply_t * mp)
2631 vat_main_t *vam = &vat_main;
2632 i32 retval = ntohl (mp->retval);
2636 fformat (vam->ofp, "feature: %s\ngpe: %s\n",
2637 mp->feature_status ? "enabled" : "disabled",
2638 mp->gpe_status ? "enabled" : "disabled");
2641 vam->retval = retval;
2642 vam->result_ready = 1;
2646 vl_api_show_lisp_status_reply_t_handler_json
2647 (vl_api_show_lisp_status_reply_t * mp)
2649 vat_main_t *vam = &vat_main;
2650 vat_json_node_t node;
2651 u8 *gpe_status = NULL;
2652 u8 *feature_status = NULL;
2654 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
2655 feature_status = format (0, "%s",
2656 mp->feature_status ? "enabled" : "disabled");
2657 vec_add1 (gpe_status, 0);
2658 vec_add1 (feature_status, 0);
2660 vat_json_init_object (&node);
2661 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
2662 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
2664 vec_free (gpe_status);
2665 vec_free (feature_status);
2667 vat_json_print (vam->ofp, &node);
2668 vat_json_free (&node);
2670 vam->retval = ntohl (mp->retval);
2671 vam->result_ready = 1;
2675 vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler
2676 (vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
2678 vat_main_t *vam = &vat_main;
2679 i32 retval = ntohl (mp->retval);
2683 fformat (vam->ofp, "%=20s\n", mp->locator_set_name);
2686 vam->retval = retval;
2687 vam->result_ready = 1;
2691 vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler_json
2692 (vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
2694 vat_main_t *vam = &vat_main;
2695 vat_json_node_t *node = NULL;
2697 if (VAT_JSON_ARRAY != vam->json_tree.type)
2699 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2700 vat_json_init_array (&vam->json_tree);
2702 node = vat_json_array_add (&vam->json_tree);
2704 vat_json_init_object (node);
2705 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
2707 vat_json_print (vam->ofp, node);
2708 vat_json_free (node);
2710 vam->retval = ntohl (mp->retval);
2711 vam->result_ready = 1;
2715 format_lisp_map_request_mode (u8 * s, va_list * args)
2717 u32 mode = va_arg (*args, u32);
2722 return format (0, "dst-only");
2724 return format (0, "src-dst");
2730 vl_api_show_lisp_map_request_mode_reply_t_handler
2731 (vl_api_show_lisp_map_request_mode_reply_t * mp)
2733 vat_main_t *vam = &vat_main;
2734 i32 retval = ntohl (mp->retval);
2738 u32 mode = mp->mode;
2739 fformat (vam->ofp, "map_request_mode: %U\n",
2740 format_lisp_map_request_mode, mode);
2743 vam->retval = retval;
2744 vam->result_ready = 1;
2748 vl_api_show_lisp_map_request_mode_reply_t_handler_json
2749 (vl_api_show_lisp_map_request_mode_reply_t * mp)
2751 vat_main_t *vam = &vat_main;
2752 vat_json_node_t node;
2757 s = format (0, "%U", format_lisp_map_request_mode, mode);
2760 vat_json_init_object (&node);
2761 vat_json_object_add_string_copy (&node, "map_request_mode", s);
2762 vat_json_print (vam->ofp, &node);
2763 vat_json_free (&node);
2766 vam->retval = ntohl (mp->retval);
2767 vam->result_ready = 1;
2771 vl_api_show_lisp_pitr_reply_t_handler (vl_api_show_lisp_pitr_reply_t * mp)
2773 vat_main_t *vam = &vat_main;
2774 i32 retval = ntohl (mp->retval);
2778 fformat (vam->ofp, "%-20s%-16s\n",
2779 mp->status ? "enabled" : "disabled",
2780 mp->status ? (char *) mp->locator_set_name : "");
2783 vam->retval = retval;
2784 vam->result_ready = 1;
2788 vl_api_show_lisp_pitr_reply_t_handler_json (vl_api_show_lisp_pitr_reply_t *
2791 vat_main_t *vam = &vat_main;
2792 vat_json_node_t node;
2795 status = format (0, "%s", mp->status ? "enabled" : "disabled");
2796 vec_add1 (status, 0);
2798 vat_json_init_object (&node);
2799 vat_json_object_add_string_copy (&node, "status", status);
2802 vat_json_object_add_string_copy (&node, "locator_set",
2803 mp->locator_set_name);
2808 vat_json_print (vam->ofp, &node);
2809 vat_json_free (&node);
2811 vam->retval = ntohl (mp->retval);
2812 vam->result_ready = 1;
2816 format_policer_type (u8 * s, va_list * va)
2818 u32 i = va_arg (*va, u32);
2820 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
2821 s = format (s, "1r2c");
2822 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
2823 s = format (s, "1r3c");
2824 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
2825 s = format (s, "2r3c-2698");
2826 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
2827 s = format (s, "2r3c-4115");
2828 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
2829 s = format (s, "2r3c-mef5cf1");
2831 s = format (s, "ILLEGAL");
2836 format_policer_rate_type (u8 * s, va_list * va)
2838 u32 i = va_arg (*va, u32);
2840 if (i == SSE2_QOS_RATE_KBPS)
2841 s = format (s, "kbps");
2842 else if (i == SSE2_QOS_RATE_PPS)
2843 s = format (s, "pps");
2845 s = format (s, "ILLEGAL");
2850 format_policer_round_type (u8 * s, va_list * va)
2852 u32 i = va_arg (*va, u32);
2854 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
2855 s = format (s, "closest");
2856 else if (i == SSE2_QOS_ROUND_TO_UP)
2857 s = format (s, "up");
2858 else if (i == SSE2_QOS_ROUND_TO_DOWN)
2859 s = format (s, "down");
2861 s = format (s, "ILLEGAL");
2866 format_policer_action_type (u8 * s, va_list * va)
2868 u32 i = va_arg (*va, u32);
2870 if (i == SSE2_QOS_ACTION_DROP)
2871 s = format (s, "drop");
2872 else if (i == SSE2_QOS_ACTION_TRANSMIT)
2873 s = format (s, "transmit");
2874 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2875 s = format (s, "mark-and-transmit");
2877 s = format (s, "ILLEGAL");
2882 format_dscp (u8 * s, va_list * va)
2884 u32 i = va_arg (*va, u32);
2889 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
2893 return format (s, "ILLEGAL");
2895 s = format (s, "%s", t);
2900 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
2902 vat_main_t *vam = &vat_main;
2903 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
2905 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2906 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
2908 conform_dscp_str = format (0, "");
2910 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2911 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
2913 exceed_dscp_str = format (0, "");
2915 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2916 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
2918 violate_dscp_str = format (0, "");
2920 fformat (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
2921 "rate type %U, round type %U, %s rate, %s color-aware, "
2922 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
2923 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
2924 "conform action %U%s, exceed action %U%s, violate action %U%s\n",
2926 format_policer_type, mp->type,
2929 clib_net_to_host_u64 (mp->cb),
2930 clib_net_to_host_u64 (mp->eb),
2931 format_policer_rate_type, mp->rate_type,
2932 format_policer_round_type, mp->round_type,
2933 mp->single_rate ? "single" : "dual",
2934 mp->color_aware ? "is" : "not",
2935 ntohl (mp->cir_tokens_per_period),
2936 ntohl (mp->pir_tokens_per_period),
2938 ntohl (mp->current_limit),
2939 ntohl (mp->current_bucket),
2940 ntohl (mp->extended_limit),
2941 ntohl (mp->extended_bucket),
2942 clib_net_to_host_u64 (mp->last_update_time),
2943 format_policer_action_type, mp->conform_action_type,
2945 format_policer_action_type, mp->exceed_action_type,
2947 format_policer_action_type, mp->violate_action_type,
2950 vec_free (conform_dscp_str);
2951 vec_free (exceed_dscp_str);
2952 vec_free (violate_dscp_str);
2955 static void vl_api_policer_details_t_handler_json
2956 (vl_api_policer_details_t * mp)
2958 vat_main_t *vam = &vat_main;
2959 vat_json_node_t *node;
2960 u8 *rate_type_str, *round_type_str, *type_str;
2961 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
2963 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
2965 format (0, "%U", format_policer_round_type, mp->round_type);
2966 type_str = format (0, "%U", format_policer_type, mp->type);
2967 conform_action_str = format (0, "%U", format_policer_action_type,
2968 mp->conform_action_type);
2969 exceed_action_str = format (0, "%U", format_policer_action_type,
2970 mp->exceed_action_type);
2971 violate_action_str = format (0, "%U", format_policer_action_type,
2972 mp->violate_action_type);
2974 if (VAT_JSON_ARRAY != vam->json_tree.type)
2976 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2977 vat_json_init_array (&vam->json_tree);
2979 node = vat_json_array_add (&vam->json_tree);
2981 vat_json_init_object (node);
2982 vat_json_object_add_string_copy (node, "name", mp->name);
2983 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
2984 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
2985 vat_json_object_add_uint (node, "cb", ntohl (mp->cb));
2986 vat_json_object_add_uint (node, "eb", ntohl (mp->eb));
2987 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
2988 vat_json_object_add_string_copy (node, "round_type", round_type_str);
2989 vat_json_object_add_string_copy (node, "type", type_str);
2990 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
2991 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
2992 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
2993 vat_json_object_add_uint (node, "cir_tokens_per_period",
2994 ntohl (mp->cir_tokens_per_period));
2995 vat_json_object_add_uint (node, "eir_tokens_per_period",
2996 ntohl (mp->pir_tokens_per_period));
2997 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
2998 vat_json_object_add_uint (node, "current_bucket",
2999 ntohl (mp->current_bucket));
3000 vat_json_object_add_uint (node, "extended_limit",
3001 ntohl (mp->extended_limit));
3002 vat_json_object_add_uint (node, "extended_bucket",
3003 ntohl (mp->extended_bucket));
3004 vat_json_object_add_uint (node, "last_update_time",
3005 ntohl (mp->last_update_time));
3006 vat_json_object_add_string_copy (node, "conform_action",
3007 conform_action_str);
3008 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3010 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
3011 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
3012 vec_free (dscp_str);
3014 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
3015 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3017 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
3018 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
3019 vec_free (dscp_str);
3021 vat_json_object_add_string_copy (node, "violate_action",
3022 violate_action_str);
3023 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3025 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
3026 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
3027 vec_free (dscp_str);
3030 vec_free (rate_type_str);
3031 vec_free (round_type_str);
3032 vec_free (type_str);
3033 vec_free (conform_action_str);
3034 vec_free (exceed_action_str);
3035 vec_free (violate_action_str);
3039 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
3042 vat_main_t *vam = &vat_main;
3043 int i, count = ntohl (mp->count);
3046 fformat (vam->ofp, "classify table ids (%d) : ", count);
3047 for (i = 0; i < count; i++)
3049 fformat (vam->ofp, "%d", ntohl (mp->ids[i]));
3050 fformat (vam->ofp, (i < count - 1) ? "," : "\n");
3052 vam->retval = ntohl (mp->retval);
3053 vam->result_ready = 1;
3057 vl_api_classify_table_ids_reply_t_handler_json
3058 (vl_api_classify_table_ids_reply_t * mp)
3060 vat_main_t *vam = &vat_main;
3061 int i, count = ntohl (mp->count);
3065 vat_json_node_t node;
3067 vat_json_init_object (&node);
3068 for (i = 0; i < count; i++)
3070 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
3072 vat_json_print (vam->ofp, &node);
3073 vat_json_free (&node);
3075 vam->retval = ntohl (mp->retval);
3076 vam->result_ready = 1;
3080 vl_api_classify_table_by_interface_reply_t_handler
3081 (vl_api_classify_table_by_interface_reply_t * mp)
3083 vat_main_t *vam = &vat_main;
3086 table_id = ntohl (mp->l2_table_id);
3088 fformat (vam->ofp, "l2 table id : %d\n", table_id);
3090 fformat (vam->ofp, "l2 table id : No input ACL tables configured\n");
3091 table_id = ntohl (mp->ip4_table_id);
3093 fformat (vam->ofp, "ip4 table id : %d\n", table_id);
3095 fformat (vam->ofp, "ip4 table id : No input ACL tables configured\n");
3096 table_id = ntohl (mp->ip6_table_id);
3098 fformat (vam->ofp, "ip6 table id : %d\n", table_id);
3100 fformat (vam->ofp, "ip6 table id : No input ACL tables configured\n");
3101 vam->retval = ntohl (mp->retval);
3102 vam->result_ready = 1;
3106 vl_api_classify_table_by_interface_reply_t_handler_json
3107 (vl_api_classify_table_by_interface_reply_t * mp)
3109 vat_main_t *vam = &vat_main;
3110 vat_json_node_t node;
3112 vat_json_init_object (&node);
3114 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
3115 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
3116 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
3118 vat_json_print (vam->ofp, &node);
3119 vat_json_free (&node);
3121 vam->retval = ntohl (mp->retval);
3122 vam->result_ready = 1;
3125 static void vl_api_policer_add_del_reply_t_handler
3126 (vl_api_policer_add_del_reply_t * mp)
3128 vat_main_t *vam = &vat_main;
3129 i32 retval = ntohl (mp->retval);
3130 if (vam->async_mode)
3132 vam->async_errors += (retval < 0);
3136 vam->retval = retval;
3137 vam->result_ready = 1;
3138 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
3140 * Note: this is just barely thread-safe, depends on
3141 * the main thread spinning waiting for an answer...
3143 errmsg ("policer index %d\n", ntohl (mp->policer_index));
3147 static void vl_api_policer_add_del_reply_t_handler_json
3148 (vl_api_policer_add_del_reply_t * mp)
3150 vat_main_t *vam = &vat_main;
3151 vat_json_node_t node;
3153 vat_json_init_object (&node);
3154 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3155 vat_json_object_add_uint (&node, "policer_index",
3156 ntohl (mp->policer_index));
3158 vat_json_print (vam->ofp, &node);
3159 vat_json_free (&node);
3161 vam->retval = ntohl (mp->retval);
3162 vam->result_ready = 1;
3165 /* Format hex dump. */
3167 format_hex_bytes (u8 * s, va_list * va)
3169 u8 *bytes = va_arg (*va, u8 *);
3170 int n_bytes = va_arg (*va, int);
3173 /* Print short or long form depending on byte count. */
3174 uword short_form = n_bytes <= 32;
3175 uword indent = format_get_indent (s);
3180 for (i = 0; i < n_bytes; i++)
3182 if (!short_form && (i % 32) == 0)
3183 s = format (s, "%08x: ", i);
3184 s = format (s, "%02x", bytes[i]);
3185 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
3186 s = format (s, "\n%U", format_white_space, indent);
3193 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
3196 vat_main_t *vam = &vat_main;
3197 i32 retval = ntohl (mp->retval);
3200 fformat (vam->ofp, "classify table info :\n");
3201 fformat (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d\n",
3202 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
3203 ntohl (mp->miss_next_index));
3204 fformat (vam->ofp, "nbuckets: %d skip: %d match: %d\n",
3205 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
3206 ntohl (mp->match_n_vectors));
3207 fformat (vam->ofp, "mask: %U\n", format_hex_bytes, mp->mask,
3208 ntohl (mp->mask_length));
3210 vam->retval = retval;
3211 vam->result_ready = 1;
3215 vl_api_classify_table_info_reply_t_handler_json
3216 (vl_api_classify_table_info_reply_t * mp)
3218 vat_main_t *vam = &vat_main;
3219 vat_json_node_t node;
3221 i32 retval = ntohl (mp->retval);
3224 vat_json_init_object (&node);
3226 vat_json_object_add_int (&node, "sessions",
3227 ntohl (mp->active_sessions));
3228 vat_json_object_add_int (&node, "nexttbl",
3229 ntohl (mp->next_table_index));
3230 vat_json_object_add_int (&node, "nextnode",
3231 ntohl (mp->miss_next_index));
3232 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
3233 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
3234 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
3235 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
3236 ntohl (mp->mask_length), 0);
3237 vat_json_object_add_string_copy (&node, "mask", s);
3239 vat_json_print (vam->ofp, &node);
3240 vat_json_free (&node);
3242 vam->retval = ntohl (mp->retval);
3243 vam->result_ready = 1;
3247 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
3250 vat_main_t *vam = &vat_main;
3252 fformat (vam->ofp, "next_index: %d advance: %d opaque: %d ",
3253 ntohl (mp->hit_next_index), ntohl (mp->advance),
3254 ntohl (mp->opaque_index));
3255 fformat (vam->ofp, "mask: %U\n", format_hex_bytes, mp->match,
3256 ntohl (mp->match_length));
3260 vl_api_classify_session_details_t_handler_json
3261 (vl_api_classify_session_details_t * mp)
3263 vat_main_t *vam = &vat_main;
3264 vat_json_node_t *node = NULL;
3266 if (VAT_JSON_ARRAY != vam->json_tree.type)
3268 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3269 vat_json_init_array (&vam->json_tree);
3271 node = vat_json_array_add (&vam->json_tree);
3273 vat_json_init_object (node);
3274 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
3275 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
3276 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
3278 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
3280 vat_json_object_add_string_copy (node, "match", s);
3283 static void vl_api_pg_create_interface_reply_t_handler
3284 (vl_api_pg_create_interface_reply_t * mp)
3286 vat_main_t *vam = &vat_main;
3288 vam->retval = ntohl (mp->retval);
3289 vam->result_ready = 1;
3292 static void vl_api_pg_create_interface_reply_t_handler_json
3293 (vl_api_pg_create_interface_reply_t * mp)
3295 vat_main_t *vam = &vat_main;
3296 vat_json_node_t node;
3298 i32 retval = ntohl (mp->retval);
3301 vat_json_init_object (&node);
3303 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
3305 vat_json_print (vam->ofp, &node);
3306 vat_json_free (&node);
3308 vam->retval = ntohl (mp->retval);
3309 vam->result_ready = 1;
3312 static void vl_api_policer_classify_details_t_handler
3313 (vl_api_policer_classify_details_t * mp)
3315 vat_main_t *vam = &vat_main;
3317 fformat (vam->ofp, "%10d%20d\n", ntohl (mp->sw_if_index),
3318 ntohl (mp->table_index));
3321 static void vl_api_policer_classify_details_t_handler_json
3322 (vl_api_policer_classify_details_t * mp)
3324 vat_main_t *vam = &vat_main;
3325 vat_json_node_t *node;
3327 if (VAT_JSON_ARRAY != vam->json_tree.type)
3329 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3330 vat_json_init_array (&vam->json_tree);
3332 node = vat_json_array_add (&vam->json_tree);
3334 vat_json_init_object (node);
3335 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
3336 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
3339 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler
3340 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3342 vat_main_t *vam = &vat_main;
3343 i32 retval = ntohl (mp->retval);
3344 if (vam->async_mode)
3346 vam->async_errors += (retval < 0);
3350 vam->retval = retval;
3351 vam->sw_if_index = ntohl (mp->sw_if_index);
3352 vam->result_ready = 1;
3356 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler_json
3357 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3359 vat_main_t *vam = &vat_main;
3360 vat_json_node_t node;
3362 vat_json_init_object (&node);
3363 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3364 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
3366 vat_json_print (vam->ofp, &node);
3367 vat_json_free (&node);
3369 vam->retval = ntohl (mp->retval);
3370 vam->result_ready = 1;
3373 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
3374 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
3375 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
3376 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
3379 * Generate boilerplate reply handlers, which
3380 * dig the return value out of the xxx_reply_t API message,
3381 * stick it into vam->retval, and set vam->result_ready
3383 * Could also do this by pointing N message decode slots at
3384 * a single function, but that could break in subtle ways.
3387 #define foreach_standard_reply_retval_handler \
3388 _(sw_interface_set_flags_reply) \
3389 _(sw_interface_add_del_address_reply) \
3390 _(sw_interface_set_table_reply) \
3391 _(sw_interface_set_vpath_reply) \
3392 _(sw_interface_set_l2_bridge_reply) \
3393 _(bridge_domain_add_del_reply) \
3394 _(sw_interface_set_l2_xconnect_reply) \
3395 _(l2fib_add_del_reply) \
3396 _(ip_add_del_route_reply) \
3397 _(proxy_arp_add_del_reply) \
3398 _(proxy_arp_intfc_enable_disable_reply) \
3399 _(mpls_add_del_encap_reply) \
3400 _(mpls_add_del_decap_reply) \
3401 _(mpls_ethernet_add_del_tunnel_2_reply) \
3402 _(sw_interface_set_unnumbered_reply) \
3403 _(ip_neighbor_add_del_reply) \
3404 _(reset_vrf_reply) \
3405 _(oam_add_del_reply) \
3406 _(reset_fib_reply) \
3407 _(dhcp_proxy_config_reply) \
3408 _(dhcp_proxy_config_2_reply) \
3409 _(dhcp_proxy_set_vss_reply) \
3410 _(dhcp_client_config_reply) \
3411 _(set_ip_flow_hash_reply) \
3412 _(sw_interface_ip6_enable_disable_reply) \
3413 _(sw_interface_ip6_set_link_local_address_reply) \
3414 _(sw_interface_ip6nd_ra_prefix_reply) \
3415 _(sw_interface_ip6nd_ra_config_reply) \
3416 _(set_arp_neighbor_limit_reply) \
3417 _(l2_patch_add_del_reply) \
3418 _(sr_tunnel_add_del_reply) \
3419 _(sr_policy_add_del_reply) \
3420 _(sr_multicast_map_add_del_reply) \
3421 _(classify_add_del_session_reply) \
3422 _(classify_set_interface_ip_table_reply) \
3423 _(classify_set_interface_l2_tables_reply) \
3424 _(l2tpv3_set_tunnel_cookies_reply) \
3425 _(l2tpv3_interface_enable_disable_reply) \
3426 _(l2tpv3_set_lookup_key_reply) \
3427 _(l2_fib_clear_table_reply) \
3428 _(l2_interface_efp_filter_reply) \
3429 _(l2_interface_vlan_tag_rewrite_reply) \
3430 _(modify_vhost_user_if_reply) \
3431 _(delete_vhost_user_if_reply) \
3432 _(want_ip4_arp_events_reply) \
3433 _(want_ip6_nd_events_reply) \
3434 _(input_acl_set_interface_reply) \
3435 _(ipsec_spd_add_del_reply) \
3436 _(ipsec_interface_add_del_spd_reply) \
3437 _(ipsec_spd_add_del_entry_reply) \
3438 _(ipsec_sad_add_del_entry_reply) \
3439 _(ipsec_sa_set_key_reply) \
3440 _(ikev2_profile_add_del_reply) \
3441 _(ikev2_profile_set_auth_reply) \
3442 _(ikev2_profile_set_id_reply) \
3443 _(ikev2_profile_set_ts_reply) \
3444 _(ikev2_set_local_key_reply) \
3445 _(delete_loopback_reply) \
3446 _(bd_ip_mac_add_del_reply) \
3447 _(map_del_domain_reply) \
3448 _(map_add_del_rule_reply) \
3449 _(want_interface_events_reply) \
3450 _(want_stats_reply) \
3451 _(cop_interface_enable_disable_reply) \
3452 _(cop_whitelist_enable_disable_reply) \
3453 _(sw_interface_clear_stats_reply) \
3454 _(ioam_enable_reply) \
3455 _(ioam_disable_reply) \
3456 _(lisp_add_del_locator_reply) \
3457 _(lisp_add_del_local_eid_reply) \
3458 _(lisp_add_del_remote_mapping_reply) \
3459 _(lisp_add_del_adjacency_reply) \
3460 _(lisp_gpe_add_del_fwd_entry_reply) \
3461 _(lisp_add_del_map_resolver_reply) \
3462 _(lisp_gpe_enable_disable_reply) \
3463 _(lisp_gpe_add_del_iface_reply) \
3464 _(lisp_enable_disable_reply) \
3465 _(lisp_pitr_set_locator_set_reply) \
3466 _(lisp_map_request_mode_reply) \
3467 _(lisp_add_del_map_request_itr_rlocs_reply) \
3468 _(lisp_eid_table_add_del_map_reply) \
3469 _(vxlan_gpe_add_del_tunnel_reply) \
3470 _(af_packet_delete_reply) \
3471 _(policer_classify_set_interface_reply) \
3472 _(netmap_create_reply) \
3473 _(netmap_delete_reply) \
3474 _(set_ipfix_exporter_reply) \
3475 _(set_ipfix_classify_stream_reply) \
3476 _(ipfix_classify_table_add_del_reply) \
3477 _(pg_capture_reply) \
3478 _(pg_enable_disable_reply) \
3479 _(ip_source_and_port_range_check_add_del_reply) \
3480 _(ip_source_and_port_range_check_interface_add_del_reply)\
3481 _(delete_subif_reply)
3484 static void vl_api_##n##_t_handler \
3485 (vl_api_##n##_t * mp) \
3487 vat_main_t * vam = &vat_main; \
3488 i32 retval = ntohl(mp->retval); \
3489 if (vam->async_mode) { \
3490 vam->async_errors += (retval < 0); \
3492 vam->retval = retval; \
3493 vam->result_ready = 1; \
3496 foreach_standard_reply_retval_handler;
3500 static void vl_api_##n##_t_handler_json \
3501 (vl_api_##n##_t * mp) \
3503 vat_main_t * vam = &vat_main; \
3504 vat_json_node_t node; \
3505 vat_json_init_object(&node); \
3506 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
3507 vat_json_print(vam->ofp, &node); \
3508 vam->retval = ntohl(mp->retval); \
3509 vam->result_ready = 1; \
3511 foreach_standard_reply_retval_handler;
3515 * Table of message reply handlers, must include boilerplate handlers
3519 #define foreach_vpe_api_reply_msg \
3520 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
3521 _(SW_INTERFACE_DETAILS, sw_interface_details) \
3522 _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
3523 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
3524 _(CONTROL_PING_REPLY, control_ping_reply) \
3525 _(CLI_REPLY, cli_reply) \
3526 _(CLI_INBAND_REPLY, cli_inband_reply) \
3527 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
3528 sw_interface_add_del_address_reply) \
3529 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
3530 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
3531 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
3532 sw_interface_set_l2_xconnect_reply) \
3533 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
3534 sw_interface_set_l2_bridge_reply) \
3535 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
3536 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
3537 _(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
3538 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
3539 _(L2_FLAGS_REPLY, l2_flags_reply) \
3540 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
3541 _(TAP_CONNECT_REPLY, tap_connect_reply) \
3542 _(TAP_MODIFY_REPLY, tap_modify_reply) \
3543 _(TAP_DELETE_REPLY, tap_delete_reply) \
3544 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
3545 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
3546 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
3547 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
3548 proxy_arp_intfc_enable_disable_reply) \
3549 _(MPLS_ADD_DEL_ENCAP_REPLY, mpls_add_del_encap_reply) \
3550 _(MPLS_ADD_DEL_DECAP_REPLY, mpls_add_del_decap_reply) \
3551 _(MPLS_GRE_ADD_DEL_TUNNEL_REPLY, mpls_gre_add_del_tunnel_reply) \
3552 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_REPLY, \
3553 mpls_ethernet_add_del_tunnel_reply) \
3554 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_2_REPLY, \
3555 mpls_ethernet_add_del_tunnel_2_reply) \
3556 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
3557 sw_interface_set_unnumbered_reply) \
3558 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
3559 _(RESET_VRF_REPLY, reset_vrf_reply) \
3560 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
3561 _(CREATE_SUBIF_REPLY, create_subif_reply) \
3562 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
3563 _(RESET_FIB_REPLY, reset_fib_reply) \
3564 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
3565 _(DHCP_PROXY_CONFIG_2_REPLY, dhcp_proxy_config_2_reply) \
3566 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
3567 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
3568 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
3569 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
3570 sw_interface_ip6_enable_disable_reply) \
3571 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
3572 sw_interface_ip6_set_link_local_address_reply) \
3573 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
3574 sw_interface_ip6nd_ra_prefix_reply) \
3575 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
3576 sw_interface_ip6nd_ra_config_reply) \
3577 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
3578 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
3579 _(SR_TUNNEL_ADD_DEL_REPLY, sr_tunnel_add_del_reply) \
3580 _(SR_POLICY_ADD_DEL_REPLY, sr_policy_add_del_reply) \
3581 _(SR_MULTICAST_MAP_ADD_DEL_REPLY, sr_multicast_map_add_del_reply) \
3582 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
3583 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
3584 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
3585 classify_set_interface_ip_table_reply) \
3586 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
3587 classify_set_interface_l2_tables_reply) \
3588 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
3589 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
3590 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
3591 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
3592 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
3593 l2tpv3_interface_enable_disable_reply) \
3594 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
3595 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
3596 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
3597 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
3598 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
3599 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
3600 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
3601 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
3602 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
3603 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
3604 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
3605 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
3606 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
3607 _(SHOW_VERSION_REPLY, show_version_reply) \
3608 _(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
3609 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
3610 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
3611 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
3612 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
3613 _(IP4_ARP_EVENT, ip4_arp_event) \
3614 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
3615 _(IP6_ND_EVENT, ip6_nd_event) \
3616 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
3617 _(IP_ADDRESS_DETAILS, ip_address_details) \
3618 _(IP_DETAILS, ip_details) \
3619 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
3620 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
3621 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
3622 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
3623 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
3624 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
3625 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
3626 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
3627 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
3628 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
3629 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
3630 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
3631 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
3632 _(VNET_INTERFACE_COUNTERS, vnet_interface_counters) \
3633 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
3634 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
3635 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
3636 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
3637 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
3638 _(MAP_DOMAIN_DETAILS, map_domain_details) \
3639 _(MAP_RULE_DETAILS, map_rule_details) \
3640 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
3641 _(WANT_STATS_REPLY, want_stats_reply) \
3642 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
3643 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
3644 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
3645 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
3646 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
3647 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
3648 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
3649 _(LISP_ADD_DEL_LOCATOR_SET_REPLY, lisp_add_del_locator_set_reply) \
3650 _(LISP_ADD_DEL_LOCATOR_REPLY, lisp_add_del_locator_reply) \
3651 _(LISP_ADD_DEL_LOCAL_EID_REPLY, lisp_add_del_local_eid_reply) \
3652 _(LISP_ADD_DEL_REMOTE_MAPPING_REPLY, lisp_add_del_remote_mapping_reply) \
3653 _(LISP_ADD_DEL_ADJACENCY_REPLY, lisp_add_del_adjacency_reply) \
3654 _(LISP_GPE_ADD_DEL_FWD_ENTRY_REPLY, lisp_gpe_add_del_fwd_entry_reply) \
3655 _(LISP_ADD_DEL_MAP_RESOLVER_REPLY, lisp_add_del_map_resolver_reply) \
3656 _(LISP_GPE_ENABLE_DISABLE_REPLY, lisp_gpe_enable_disable_reply) \
3657 _(LISP_ENABLE_DISABLE_REPLY, lisp_enable_disable_reply) \
3658 _(LISP_PITR_SET_LOCATOR_SET_REPLY, lisp_pitr_set_locator_set_reply) \
3659 _(LISP_MAP_REQUEST_MODE_REPLY, lisp_map_request_mode_reply) \
3660 _(LISP_EID_TABLE_ADD_DEL_MAP_REPLY, lisp_eid_table_add_del_map_reply) \
3661 _(LISP_GPE_ADD_DEL_IFACE_REPLY, lisp_gpe_add_del_iface_reply) \
3662 _(LISP_LOCATOR_SET_DETAILS, lisp_locator_set_details) \
3663 _(LISP_LOCATOR_DETAILS, lisp_locator_details) \
3664 _(LISP_EID_TABLE_DETAILS, lisp_eid_table_details) \
3665 _(LISP_EID_TABLE_MAP_DETAILS, lisp_eid_table_map_details) \
3666 _(LISP_EID_TABLE_VNI_DETAILS, lisp_eid_table_vni_details) \
3667 _(LISP_GPE_TUNNEL_DETAILS, lisp_gpe_tunnel_details) \
3668 _(LISP_MAP_RESOLVER_DETAILS, lisp_map_resolver_details) \
3669 _(SHOW_LISP_STATUS_REPLY, show_lisp_status_reply) \
3670 _(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
3671 lisp_add_del_map_request_itr_rlocs_reply) \
3672 _(LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
3673 lisp_get_map_request_itr_rlocs_reply) \
3674 _(SHOW_LISP_PITR_REPLY, show_lisp_pitr_reply) \
3675 _(SHOW_LISP_MAP_REQUEST_MODE_REPLY, show_lisp_map_request_mode_reply) \
3676 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
3677 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
3678 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
3679 _(POLICER_DETAILS, policer_details) \
3680 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
3681 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
3682 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
3683 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
3684 _(MPLS_GRE_TUNNEL_DETAILS, mpls_gre_tunnel_details) \
3685 _(MPLS_ETH_TUNNEL_DETAILS, mpls_eth_tunnel_details) \
3686 _(MPLS_FIB_ENCAP_DETAILS, mpls_fib_encap_details) \
3687 _(MPLS_FIB_DECAP_DETAILS, mpls_fib_decap_details) \
3688 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
3689 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
3690 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
3691 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
3692 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
3693 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
3694 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
3695 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
3696 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
3697 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
3698 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
3699 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
3700 _(PG_CAPTURE_REPLY, pg_capture_reply) \
3701 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
3702 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
3703 ip_source_and_port_range_check_add_del_reply) \
3704 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
3705 ip_source_and_port_range_check_interface_add_del_reply) \
3706 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
3707 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
3708 _(DELETE_SUBIF_REPLY, delete_subif_reply)
3710 /* M: construct, but don't yet send a message */
3714 vam->result_ready = 0; \
3715 mp = vl_msg_api_alloc(sizeof(*mp)); \
3716 memset (mp, 0, sizeof (*mp)); \
3717 mp->_vl_msg_id = ntohs (VL_API_##T); \
3718 mp->client_index = vam->my_client_index; \
3723 vam->result_ready = 0; \
3724 mp = vl_msg_api_alloc(sizeof(*mp)+(n)); \
3725 memset (mp, 0, sizeof (*mp)); \
3726 mp->_vl_msg_id = ntohs (VL_API_##T); \
3727 mp->client_index = vam->my_client_index; \
3731 /* S: send a message */
3732 #define S (vl_msg_api_send_shmem (vam->vl_input_queue, (u8 *)&mp))
3734 /* W: wait for results, with timeout */
3737 timeout = vat_time_now (vam) + 1.0; \
3739 while (vat_time_now (vam) < timeout) { \
3740 if (vam->result_ready == 1) { \
3741 return (vam->retval); \
3747 /* W2: wait for results, with timeout */
3750 timeout = vat_time_now (vam) + 1.0; \
3752 while (vat_time_now (vam) < timeout) { \
3753 if (vam->result_ready == 1) { \
3755 return (vam->retval); \
3768 #define STR_VTR_OP_CASE(op) \
3769 case L2_VTR_ ## op: \
3773 str_vtr_op (u32 vtr_op)
3777 STR_VTR_OP_CASE (DISABLED);
3778 STR_VTR_OP_CASE (PUSH_1);
3779 STR_VTR_OP_CASE (PUSH_2);
3780 STR_VTR_OP_CASE (POP_1);
3781 STR_VTR_OP_CASE (POP_2);
3782 STR_VTR_OP_CASE (TRANSLATE_1_1);
3783 STR_VTR_OP_CASE (TRANSLATE_1_2);
3784 STR_VTR_OP_CASE (TRANSLATE_2_1);
3785 STR_VTR_OP_CASE (TRANSLATE_2_2);
3792 dump_sub_interface_table (vat_main_t * vam)
3794 const sw_interface_subif_t *sub = NULL;
3796 if (vam->json_output)
3799 ("JSON output supported only for VPE API calls and dump_stats_table");
3804 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s\n",
3805 "Interface", "sw_if_index",
3806 "sub id", "dot1ad", "tags", "outer id",
3807 "inner id", "exact", "default", "outer any", "inner any");
3809 vec_foreach (sub, vam->sw_if_subif_table)
3812 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d\n",
3813 sub->interface_name,
3815 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
3816 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
3817 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
3818 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
3819 if (sub->vtr_op != L2_VTR_DISABLED)
3822 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
3823 "tag1: %d tag2: %d ]\n",
3824 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
3825 sub->vtr_tag1, sub->vtr_tag2);
3833 name_sort_cmp (void *a1, void *a2)
3835 name_sort_t *n1 = a1;
3836 name_sort_t *n2 = a2;
3838 return strcmp ((char *) n1->name, (char *) n2->name);
3842 dump_interface_table (vat_main_t * vam)
3845 name_sort_t *nses = 0, *ns;
3847 if (vam->json_output)
3850 ("JSON output supported only for VPE API calls and dump_stats_table");
3855 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
3857 vec_add2 (nses, ns, 1);
3858 ns->name = (u8 *)(p->key);
3859 ns->value = (u32) p->value[0];
3863 vec_sort_with_function (nses, name_sort_cmp);
3865 fformat (vam->ofp, "%-25s%-15s\n", "Interface", "sw_if_index");
3866 vec_foreach (ns, nses)
3868 fformat (vam->ofp, "%-25s%-15d\n", ns->name, ns->value);
3875 dump_ip_table (vat_main_t * vam, int is_ipv6)
3877 const ip_details_t *det = NULL;
3878 const ip_address_details_t *address = NULL;
3881 fformat (vam->ofp, "%-12s\n", "sw_if_index");
3883 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
3890 fformat (vam->ofp, "%-12d\n", i);
3892 " %-30s%-13s\n", "Address", "Prefix length");
3897 vec_foreach (address, det->addr)
3901 is_ipv6 ? format_ip6_address : format_ip4_address,
3902 address->ip, address->prefix_length);
3910 dump_ipv4_table (vat_main_t * vam)
3912 if (vam->json_output)
3915 ("JSON output supported only for VPE API calls and dump_stats_table");
3919 return dump_ip_table (vam, 0);
3923 dump_ipv6_table (vat_main_t * vam)
3925 if (vam->json_output)
3928 ("JSON output supported only for VPE API calls and dump_stats_table");
3932 return dump_ip_table (vam, 1);
3936 counter_type_to_str (u8 counter_type, u8 is_combined)
3940 switch (counter_type)
3942 case VNET_INTERFACE_COUNTER_DROP:
3944 case VNET_INTERFACE_COUNTER_PUNT:
3946 case VNET_INTERFACE_COUNTER_IP4:
3948 case VNET_INTERFACE_COUNTER_IP6:
3950 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
3952 case VNET_INTERFACE_COUNTER_RX_MISS:
3954 case VNET_INTERFACE_COUNTER_RX_ERROR:
3956 case VNET_INTERFACE_COUNTER_TX_ERROR:
3959 return "INVALID-COUNTER-TYPE";
3964 switch (counter_type)
3966 case VNET_INTERFACE_COUNTER_RX:
3968 case VNET_INTERFACE_COUNTER_TX:
3971 return "INVALID-COUNTER-TYPE";
3977 dump_stats_table (vat_main_t * vam)
3979 vat_json_node_t node;
3980 vat_json_node_t *msg_array;
3981 vat_json_node_t *msg;
3982 vat_json_node_t *counter_array;
3983 vat_json_node_t *counter;
3984 interface_counter_t c;
3986 ip4_fib_counter_t *c4;
3987 ip6_fib_counter_t *c6;
3990 if (!vam->json_output)
3992 clib_warning ("dump_stats_table supported only in JSON format");
3996 vat_json_init_object (&node);
3998 /* interface counters */
3999 msg_array = vat_json_object_add (&node, "interface_counters");
4000 vat_json_init_array (msg_array);
4001 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
4003 msg = vat_json_array_add (msg_array);
4004 vat_json_init_object (msg);
4005 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4006 (u8 *) counter_type_to_str (i, 0));
4007 vat_json_object_add_int (msg, "is_combined", 0);
4008 counter_array = vat_json_object_add (msg, "data");
4009 vat_json_init_array (counter_array);
4010 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
4012 packets = vam->simple_interface_counters[i][j];
4013 vat_json_array_add_uint (counter_array, packets);
4016 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
4018 msg = vat_json_array_add (msg_array);
4019 vat_json_init_object (msg);
4020 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4021 (u8 *) counter_type_to_str (i, 1));
4022 vat_json_object_add_int (msg, "is_combined", 1);
4023 counter_array = vat_json_object_add (msg, "data");
4024 vat_json_init_array (counter_array);
4025 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
4027 c = vam->combined_interface_counters[i][j];
4028 counter = vat_json_array_add (counter_array);
4029 vat_json_init_object (counter);
4030 vat_json_object_add_uint (counter, "packets", c.packets);
4031 vat_json_object_add_uint (counter, "bytes", c.bytes);
4035 /* ip4 fib counters */
4036 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
4037 vat_json_init_array (msg_array);
4038 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
4040 msg = vat_json_array_add (msg_array);
4041 vat_json_init_object (msg);
4042 vat_json_object_add_uint (msg, "vrf_id",
4043 vam->ip4_fib_counters_vrf_id_by_index[i]);
4044 counter_array = vat_json_object_add (msg, "c");
4045 vat_json_init_array (counter_array);
4046 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
4048 counter = vat_json_array_add (counter_array);
4049 vat_json_init_object (counter);
4050 c4 = &vam->ip4_fib_counters[i][j];
4051 vat_json_object_add_ip4 (counter, "address", c4->address);
4052 vat_json_object_add_uint (counter, "address_length",
4053 c4->address_length);
4054 vat_json_object_add_uint (counter, "packets", c4->packets);
4055 vat_json_object_add_uint (counter, "bytes", c4->bytes);
4059 /* ip6 fib counters */
4060 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
4061 vat_json_init_array (msg_array);
4062 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
4064 msg = vat_json_array_add (msg_array);
4065 vat_json_init_object (msg);
4066 vat_json_object_add_uint (msg, "vrf_id",
4067 vam->ip6_fib_counters_vrf_id_by_index[i]);
4068 counter_array = vat_json_object_add (msg, "c");
4069 vat_json_init_array (counter_array);
4070 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
4072 counter = vat_json_array_add (counter_array);
4073 vat_json_init_object (counter);
4074 c6 = &vam->ip6_fib_counters[i][j];
4075 vat_json_object_add_ip6 (counter, "address", c6->address);
4076 vat_json_object_add_uint (counter, "address_length",
4077 c6->address_length);
4078 vat_json_object_add_uint (counter, "packets", c6->packets);
4079 vat_json_object_add_uint (counter, "bytes", c6->bytes);
4083 vat_json_print (vam->ofp, &node);
4084 vat_json_free (&node);
4090 exec (vat_main_t * vam)
4092 api_main_t *am = &api_main;
4093 vl_api_cli_request_t *mp;
4097 unformat_input_t *i = vam->input;
4099 if (vec_len (i->buffer) == 0)
4102 if (vam->exec_mode == 0 && unformat (i, "mode"))
4107 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4114 M (CLI_REQUEST, cli_request);
4117 * Copy cmd into shared memory.
4118 * In order for the CLI command to work, it
4119 * must be a vector ending in \n, not a C-string ending
4122 pthread_mutex_lock (&am->vlib_rp->mutex);
4123 oldheap = svm_push_data_heap (am->vlib_rp);
4125 vec_validate (cmd, vec_len (vam->input->buffer) - 1);
4126 clib_memcpy (cmd, vam->input->buffer, vec_len (vam->input->buffer));
4128 svm_pop_heap (oldheap);
4129 pthread_mutex_unlock (&am->vlib_rp->mutex);
4131 mp->cmd_in_shmem = (u64) cmd;
4133 timeout = vat_time_now (vam) + 10.0;
4135 while (vat_time_now (vam) < timeout)
4137 if (vam->result_ready == 1)
4140 if (vam->shmem_result != NULL)
4141 fformat (vam->ofp, "%s", vam->shmem_result);
4142 pthread_mutex_lock (&am->vlib_rp->mutex);
4143 oldheap = svm_push_data_heap (am->vlib_rp);
4145 free_me = (u8 *) vam->shmem_result;
4148 svm_pop_heap (oldheap);
4149 pthread_mutex_unlock (&am->vlib_rp->mutex);
4157 * Future replacement of exec() that passes CLI buffers directly in
4158 * the API messages instead of an additional shared memory area.
4161 exec_inband (vat_main_t * vam)
4163 vl_api_cli_inband_t *mp;
4165 unformat_input_t *i = vam->input;
4167 if (vec_len (i->buffer) == 0)
4170 if (vam->exec_mode == 0 && unformat (i, "mode"))
4175 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4182 * In order for the CLI command to work, it
4183 * must be a vector ending in \n, not a C-string ending
4186 u32 len = vec_len (vam->input->buffer);
4187 M2 (CLI_INBAND, cli_inband, len);
4188 clib_memcpy (mp->cmd, vam->input->buffer, len);
4189 mp->length = htonl (len);
4192 W2 (fformat (vam->ofp, "%s", vam->cmd_reply));
4196 api_create_loopback (vat_main_t * vam)
4198 unformat_input_t *i = vam->input;
4199 vl_api_create_loopback_t *mp;
4204 memset (mac_address, 0, sizeof (mac_address));
4206 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4208 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
4214 /* Construct the API message */
4215 M (CREATE_LOOPBACK, create_loopback);
4217 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
4224 api_delete_loopback (vat_main_t * vam)
4226 unformat_input_t *i = vam->input;
4227 vl_api_delete_loopback_t *mp;
4229 u32 sw_if_index = ~0;
4231 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4233 if (unformat (i, "sw_if_index %d", &sw_if_index))
4239 if (sw_if_index == ~0)
4241 errmsg ("missing sw_if_index\n");
4245 /* Construct the API message */
4246 M (DELETE_LOOPBACK, delete_loopback);
4247 mp->sw_if_index = ntohl (sw_if_index);
4254 api_want_stats (vat_main_t * vam)
4256 unformat_input_t *i = vam->input;
4257 vl_api_want_stats_t *mp;
4261 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4263 if (unformat (i, "enable"))
4265 else if (unformat (i, "disable"))
4273 errmsg ("missing enable|disable\n");
4277 M (WANT_STATS, want_stats);
4278 mp->enable_disable = enable;
4285 api_want_interface_events (vat_main_t * vam)
4287 unformat_input_t *i = vam->input;
4288 vl_api_want_interface_events_t *mp;
4292 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4294 if (unformat (i, "enable"))
4296 else if (unformat (i, "disable"))
4304 errmsg ("missing enable|disable\n");
4308 M (WANT_INTERFACE_EVENTS, want_interface_events);
4309 mp->enable_disable = enable;
4311 vam->interface_event_display = enable;
4318 /* Note: non-static, called once to set up the initial intfc table */
4320 api_sw_interface_dump (vat_main_t * vam)
4322 vl_api_sw_interface_dump_t *mp;
4325 name_sort_t *nses = 0, *ns;
4326 sw_interface_subif_t *sub = NULL;
4328 /* Toss the old name table */
4330 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4332 vec_add2 (nses, ns, 1);
4333 ns->name = (u8 *)(p->key);
4334 ns->value = (u32) p->value[0];
4338 hash_free (vam->sw_if_index_by_interface_name);
4340 vec_foreach (ns, nses) vec_free (ns->name);
4344 vec_foreach (sub, vam->sw_if_subif_table)
4346 vec_free (sub->interface_name);
4348 vec_free (vam->sw_if_subif_table);
4350 /* recreate the interface name hash table */
4351 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
4353 /* Get list of ethernets */
4354 M (SW_INTERFACE_DUMP, sw_interface_dump);
4355 mp->name_filter_valid = 1;
4356 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
4359 /* and local / loopback interfaces */
4360 M (SW_INTERFACE_DUMP, sw_interface_dump);
4361 mp->name_filter_valid = 1;
4362 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
4366 /* and vxlan-gpe tunnel interfaces */
4367 M (SW_INTERFACE_DUMP, sw_interface_dump);
4368 mp->name_filter_valid = 1;
4369 strncpy ((char *) mp->name_filter, "vxlan_gpe",
4370 sizeof (mp->name_filter) - 1);
4373 /* and vxlan tunnel interfaces */
4374 M (SW_INTERFACE_DUMP, sw_interface_dump);
4375 mp->name_filter_valid = 1;
4376 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
4379 /* and host (af_packet) interfaces */
4380 M (SW_INTERFACE_DUMP, sw_interface_dump);
4381 mp->name_filter_valid = 1;
4382 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
4385 /* and l2tpv3 tunnel interfaces */
4386 M (SW_INTERFACE_DUMP, sw_interface_dump);
4387 mp->name_filter_valid = 1;
4388 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
4389 sizeof (mp->name_filter) - 1);
4392 /* and GRE tunnel interfaces */
4393 M (SW_INTERFACE_DUMP, sw_interface_dump);
4394 mp->name_filter_valid = 1;
4395 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
4398 /* and LISP-GPE interfaces */
4399 M (SW_INTERFACE_DUMP, sw_interface_dump);
4400 mp->name_filter_valid = 1;
4401 strncpy ((char *) mp->name_filter, "lisp_gpe",
4402 sizeof (mp->name_filter) - 1);
4405 /* and IPSEC tunnel interfaces */
4406 M (SW_INTERFACE_DUMP, sw_interface_dump);
4407 mp->name_filter_valid = 1;
4408 strncpy ((char *) mp->name_filter, "ipsec", sizeof (mp->name_filter) - 1);
4411 /* Use a control ping for synchronization */
4413 vl_api_control_ping_t *mp;
4414 M (CONTROL_PING, control_ping);
4421 api_sw_interface_set_flags (vat_main_t * vam)
4423 unformat_input_t *i = vam->input;
4424 vl_api_sw_interface_set_flags_t *mp;
4427 u8 sw_if_index_set = 0;
4428 u8 admin_up = 0, link_up = 0;
4430 /* Parse args required to build the message */
4431 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4433 if (unformat (i, "admin-up"))
4435 else if (unformat (i, "admin-down"))
4437 else if (unformat (i, "link-up"))
4439 else if (unformat (i, "link-down"))
4441 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4442 sw_if_index_set = 1;
4443 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4444 sw_if_index_set = 1;
4449 if (sw_if_index_set == 0)
4451 errmsg ("missing interface name or sw_if_index\n");
4455 /* Construct the API message */
4456 M (SW_INTERFACE_SET_FLAGS, sw_interface_set_flags);
4457 mp->sw_if_index = ntohl (sw_if_index);
4458 mp->admin_up_down = admin_up;
4459 mp->link_up_down = link_up;
4464 /* Wait for a reply, return the good/bad news... */
4469 api_sw_interface_clear_stats (vat_main_t * vam)
4471 unformat_input_t *i = vam->input;
4472 vl_api_sw_interface_clear_stats_t *mp;
4475 u8 sw_if_index_set = 0;
4477 /* Parse args required to build the message */
4478 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4480 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4481 sw_if_index_set = 1;
4482 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4483 sw_if_index_set = 1;
4488 /* Construct the API message */
4489 M (SW_INTERFACE_CLEAR_STATS, sw_interface_clear_stats);
4491 if (sw_if_index_set == 1)
4492 mp->sw_if_index = ntohl (sw_if_index);
4494 mp->sw_if_index = ~0;
4499 /* Wait for a reply, return the good/bad news... */
4504 api_sw_interface_add_del_address (vat_main_t * vam)
4506 unformat_input_t *i = vam->input;
4507 vl_api_sw_interface_add_del_address_t *mp;
4510 u8 sw_if_index_set = 0;
4511 u8 is_add = 1, del_all = 0;
4512 u32 address_length = 0;
4513 u8 v4_address_set = 0;
4514 u8 v6_address_set = 0;
4515 ip4_address_t v4address;
4516 ip6_address_t v6address;
4518 /* Parse args required to build the message */
4519 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4521 if (unformat (i, "del-all"))
4523 else if (unformat (i, "del"))
4525 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4526 sw_if_index_set = 1;
4527 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4528 sw_if_index_set = 1;
4529 else if (unformat (i, "%U/%d",
4530 unformat_ip4_address, &v4address, &address_length))
4532 else if (unformat (i, "%U/%d",
4533 unformat_ip6_address, &v6address, &address_length))
4539 if (sw_if_index_set == 0)
4541 errmsg ("missing interface name or sw_if_index\n");
4544 if (v4_address_set && v6_address_set)
4546 errmsg ("both v4 and v6 addresses set\n");
4549 if (!v4_address_set && !v6_address_set && !del_all)
4551 errmsg ("no addresses set\n");
4555 /* Construct the API message */
4556 M (SW_INTERFACE_ADD_DEL_ADDRESS, sw_interface_add_del_address);
4558 mp->sw_if_index = ntohl (sw_if_index);
4559 mp->is_add = is_add;
4560 mp->del_all = del_all;
4564 clib_memcpy (mp->address, &v6address, sizeof (v6address));
4568 clib_memcpy (mp->address, &v4address, sizeof (v4address));
4570 mp->address_length = address_length;
4575 /* Wait for a reply, return good/bad news */
4580 api_sw_interface_set_table (vat_main_t * vam)
4582 unformat_input_t *i = vam->input;
4583 vl_api_sw_interface_set_table_t *mp;
4585 u32 sw_if_index, vrf_id = 0;
4586 u8 sw_if_index_set = 0;
4589 /* Parse args required to build the message */
4590 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4592 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4593 sw_if_index_set = 1;
4594 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4595 sw_if_index_set = 1;
4596 else if (unformat (i, "vrf %d", &vrf_id))
4598 else if (unformat (i, "ipv6"))
4604 if (sw_if_index_set == 0)
4606 errmsg ("missing interface name or sw_if_index\n");
4610 /* Construct the API message */
4611 M (SW_INTERFACE_SET_TABLE, sw_interface_set_table);
4613 mp->sw_if_index = ntohl (sw_if_index);
4614 mp->is_ipv6 = is_ipv6;
4615 mp->vrf_id = ntohl (vrf_id);
4620 /* Wait for a reply... */
4625 api_sw_interface_set_vpath (vat_main_t * vam)
4627 unformat_input_t *i = vam->input;
4628 vl_api_sw_interface_set_vpath_t *mp;
4630 u32 sw_if_index = 0;
4631 u8 sw_if_index_set = 0;
4634 /* Parse args required to build the message */
4635 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4637 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4638 sw_if_index_set = 1;
4639 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4640 sw_if_index_set = 1;
4641 else if (unformat (i, "enable"))
4643 else if (unformat (i, "disable"))
4649 if (sw_if_index_set == 0)
4651 errmsg ("missing interface name or sw_if_index\n");
4655 /* Construct the API message */
4656 M (SW_INTERFACE_SET_VPATH, sw_interface_set_vpath);
4658 mp->sw_if_index = ntohl (sw_if_index);
4659 mp->enable = is_enable;
4664 /* Wait for a reply... */
4669 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
4671 unformat_input_t *i = vam->input;
4672 vl_api_sw_interface_set_l2_xconnect_t *mp;
4675 u8 rx_sw_if_index_set = 0;
4677 u8 tx_sw_if_index_set = 0;
4680 /* Parse args required to build the message */
4681 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4683 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
4684 rx_sw_if_index_set = 1;
4685 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
4686 tx_sw_if_index_set = 1;
4687 else if (unformat (i, "rx"))
4689 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4691 if (unformat (i, "%U", unformat_sw_if_index, vam,
4693 rx_sw_if_index_set = 1;
4698 else if (unformat (i, "tx"))
4700 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4702 if (unformat (i, "%U", unformat_sw_if_index, vam,
4704 tx_sw_if_index_set = 1;
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 rx_sw_if_index\n");
4723 if (enable && (tx_sw_if_index_set == 0))
4725 errmsg ("missing tx interface name or tx_sw_if_index\n");
4729 M (SW_INTERFACE_SET_L2_XCONNECT, sw_interface_set_l2_xconnect);
4731 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
4732 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
4733 mp->enable = enable;
4742 api_sw_interface_set_l2_bridge (vat_main_t * vam)
4744 unformat_input_t *i = vam->input;
4745 vl_api_sw_interface_set_l2_bridge_t *mp;
4748 u8 rx_sw_if_index_set = 0;
4755 /* Parse args required to build the message */
4756 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4758 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
4759 rx_sw_if_index_set = 1;
4760 else if (unformat (i, "bd_id %d", &bd_id))
4762 else if (unformat (i, "%U", unformat_sw_if_index, vam, &rx_sw_if_index))
4763 rx_sw_if_index_set = 1;
4764 else if (unformat (i, "shg %d", &shg))
4766 else if (unformat (i, "bvi"))
4768 else if (unformat (i, "enable"))
4770 else if (unformat (i, "disable"))
4776 if (rx_sw_if_index_set == 0)
4778 errmsg ("missing rx interface name or sw_if_index\n");
4782 if (enable && (bd_id_set == 0))
4784 errmsg ("missing bridge domain\n");
4788 M (SW_INTERFACE_SET_L2_BRIDGE, sw_interface_set_l2_bridge);
4790 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
4791 mp->bd_id = ntohl (bd_id);
4794 mp->enable = enable;
4803 api_bridge_domain_dump (vat_main_t * vam)
4805 unformat_input_t *i = vam->input;
4806 vl_api_bridge_domain_dump_t *mp;
4810 /* Parse args required to build the message */
4811 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4813 if (unformat (i, "bd_id %d", &bd_id))
4819 M (BRIDGE_DOMAIN_DUMP, bridge_domain_dump);
4820 mp->bd_id = ntohl (bd_id);
4823 /* Use a control ping for synchronization */
4825 vl_api_control_ping_t *mp;
4826 M (CONTROL_PING, control_ping);
4836 api_bridge_domain_add_del (vat_main_t * vam)
4838 unformat_input_t *i = vam->input;
4839 vl_api_bridge_domain_add_del_t *mp;
4843 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
4845 /* Parse args required to build the message */
4846 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4848 if (unformat (i, "bd_id %d", &bd_id))
4850 else if (unformat (i, "flood %d", &flood))
4852 else if (unformat (i, "uu-flood %d", &uu_flood))
4854 else if (unformat (i, "forward %d", &forward))
4856 else if (unformat (i, "learn %d", &learn))
4858 else if (unformat (i, "arp-term %d", &arp_term))
4860 else if (unformat (i, "del"))
4863 flood = uu_flood = forward = learn = 0;
4871 errmsg ("missing bridge domain\n");
4875 M (BRIDGE_DOMAIN_ADD_DEL, bridge_domain_add_del);
4877 mp->bd_id = ntohl (bd_id);
4879 mp->uu_flood = uu_flood;
4880 mp->forward = forward;
4882 mp->arp_term = arp_term;
4883 mp->is_add = is_add;
4892 api_l2fib_add_del (vat_main_t * vam)
4894 unformat_input_t *i = vam->input;
4895 vl_api_l2fib_add_del_t *mp;
4902 u8 sw_if_index_set = 0;
4911 /* Parse args required to build the message */
4912 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4914 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
4916 else if (unformat (i, "bd_id %d", &bd_id))
4918 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4919 sw_if_index_set = 1;
4920 else if (unformat (i, "sw_if"))
4922 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4924 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4925 sw_if_index_set = 1;
4930 else if (unformat (i, "static"))
4932 else if (unformat (i, "filter"))
4937 else if (unformat (i, "bvi"))
4942 else if (unformat (i, "del"))
4944 else if (unformat (i, "count %d", &count))
4952 errmsg ("missing mac address\n");
4958 errmsg ("missing bridge domain\n");
4962 if (is_add && (sw_if_index_set == 0))
4964 errmsg ("missing interface name or sw_if_index\n");
4970 /* Turn on async mode */
4971 vam->async_mode = 1;
4972 vam->async_errors = 0;
4973 before = vat_time_now (vam);
4976 for (j = 0; j < count; j++)
4978 M (L2FIB_ADD_DEL, l2fib_add_del);
4981 mp->bd_id = ntohl (bd_id);
4982 mp->is_add = is_add;
4986 mp->sw_if_index = ntohl (sw_if_index);
4987 mp->static_mac = static_mac;
4988 mp->filter_mac = filter_mac;
4989 mp->bvi_mac = bvi_mac;
4991 increment_mac_address (&mac);
4998 vl_api_control_ping_t *mp;
5001 /* Shut off async mode */
5002 vam->async_mode = 0;
5004 M (CONTROL_PING, control_ping);
5007 timeout = vat_time_now (vam) + 1.0;
5008 while (vat_time_now (vam) < timeout)
5009 if (vam->result_ready == 1)
5014 if (vam->retval == -99)
5015 errmsg ("timeout\n");
5017 if (vam->async_errors > 0)
5019 errmsg ("%d asynchronous errors\n", vam->async_errors);
5022 vam->async_errors = 0;
5023 after = vat_time_now (vam);
5025 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
5026 count, after - before, count / (after - before));
5030 /* Wait for a reply... */
5033 /* Return the good/bad news */
5034 return (vam->retval);
5038 api_l2_flags (vat_main_t * vam)
5040 unformat_input_t *i = vam->input;
5041 vl_api_l2_flags_t *mp;
5044 u32 feature_bitmap = 0;
5045 u8 sw_if_index_set = 0;
5047 /* Parse args required to build the message */
5048 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5050 if (unformat (i, "sw_if_index %d", &sw_if_index))
5051 sw_if_index_set = 1;
5052 else if (unformat (i, "sw_if"))
5054 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5056 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5057 sw_if_index_set = 1;
5062 else if (unformat (i, "learn"))
5063 feature_bitmap |= L2INPUT_FEAT_LEARN;
5064 else if (unformat (i, "forward"))
5065 feature_bitmap |= L2INPUT_FEAT_FWD;
5066 else if (unformat (i, "flood"))
5067 feature_bitmap |= L2INPUT_FEAT_FLOOD;
5068 else if (unformat (i, "uu-flood"))
5069 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
5074 if (sw_if_index_set == 0)
5076 errmsg ("missing interface name or sw_if_index\n");
5080 M (L2_FLAGS, l2_flags);
5082 mp->sw_if_index = ntohl (sw_if_index);
5083 mp->feature_bitmap = ntohl (feature_bitmap);
5092 api_bridge_flags (vat_main_t * vam)
5094 unformat_input_t *i = vam->input;
5095 vl_api_bridge_flags_t *mp;
5102 /* Parse args required to build the message */
5103 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5105 if (unformat (i, "bd_id %d", &bd_id))
5107 else if (unformat (i, "learn"))
5109 else if (unformat (i, "forward"))
5111 else if (unformat (i, "flood"))
5113 else if (unformat (i, "uu-flood"))
5114 flags |= L2_UU_FLOOD;
5115 else if (unformat (i, "arp-term"))
5116 flags |= L2_ARP_TERM;
5117 else if (unformat (i, "off"))
5119 else if (unformat (i, "disable"))
5127 errmsg ("missing bridge domain\n");
5131 M (BRIDGE_FLAGS, bridge_flags);
5133 mp->bd_id = ntohl (bd_id);
5134 mp->feature_bitmap = ntohl (flags);
5135 mp->is_set = is_set;
5144 api_bd_ip_mac_add_del (vat_main_t * vam)
5146 unformat_input_t *i = vam->input;
5147 vl_api_bd_ip_mac_add_del_t *mp;
5155 ip4_address_t v4addr;
5156 ip6_address_t v6addr;
5160 /* Parse args required to build the message */
5161 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5163 if (unformat (i, "bd_id %d", &bd_id))
5167 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
5171 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
5176 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
5180 else if (unformat (i, "del"))
5188 errmsg ("missing bridge domain\n");
5191 else if (ip_set == 0)
5193 errmsg ("missing IP address\n");
5196 else if (mac_set == 0)
5198 errmsg ("missing MAC address\n");
5202 M (BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del);
5204 mp->bd_id = ntohl (bd_id);
5205 mp->is_ipv6 = is_ipv6;
5206 mp->is_add = is_add;
5208 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
5210 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
5211 clib_memcpy (mp->mac_address, macaddr, 6);
5219 api_tap_connect (vat_main_t * vam)
5221 unformat_input_t *i = vam->input;
5222 vl_api_tap_connect_t *mp;
5229 memset (mac_address, 0, sizeof (mac_address));
5231 /* Parse args required to build the message */
5232 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5234 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5238 else if (unformat (i, "random-mac"))
5240 else if (unformat (i, "tapname %s", &tap_name))
5248 errmsg ("missing tap name\n");
5251 if (vec_len (tap_name) > 63)
5253 errmsg ("tap name too long\n");
5255 vec_add1 (tap_name, 0);
5257 /* Construct the API message */
5258 M (TAP_CONNECT, tap_connect);
5260 mp->use_random_mac = random_mac;
5261 clib_memcpy (mp->mac_address, mac_address, 6);
5262 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5263 vec_free (tap_name);
5268 /* Wait for a reply... */
5273 api_tap_modify (vat_main_t * vam)
5275 unformat_input_t *i = vam->input;
5276 vl_api_tap_modify_t *mp;
5282 u32 sw_if_index = ~0;
5283 u8 sw_if_index_set = 0;
5285 memset (mac_address, 0, sizeof (mac_address));
5287 /* Parse args required to build the message */
5288 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5290 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5291 sw_if_index_set = 1;
5292 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5293 sw_if_index_set = 1;
5294 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5298 else if (unformat (i, "random-mac"))
5300 else if (unformat (i, "tapname %s", &tap_name))
5306 if (sw_if_index_set == 0)
5308 errmsg ("missing vpp interface name");
5313 errmsg ("missing tap name\n");
5316 if (vec_len (tap_name) > 63)
5318 errmsg ("tap name too long\n");
5320 vec_add1 (tap_name, 0);
5322 /* Construct the API message */
5323 M (TAP_MODIFY, tap_modify);
5325 mp->use_random_mac = random_mac;
5326 mp->sw_if_index = ntohl (sw_if_index);
5327 clib_memcpy (mp->mac_address, mac_address, 6);
5328 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5329 vec_free (tap_name);
5334 /* Wait for a reply... */
5339 api_tap_delete (vat_main_t * vam)
5341 unformat_input_t *i = vam->input;
5342 vl_api_tap_delete_t *mp;
5344 u32 sw_if_index = ~0;
5345 u8 sw_if_index_set = 0;
5347 /* Parse args required to build the message */
5348 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5350 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5351 sw_if_index_set = 1;
5352 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5353 sw_if_index_set = 1;
5358 if (sw_if_index_set == 0)
5360 errmsg ("missing vpp interface name");
5364 /* Construct the API message */
5365 M (TAP_DELETE, tap_delete);
5367 mp->sw_if_index = ntohl (sw_if_index);
5372 /* Wait for a reply... */
5377 api_ip_add_del_route (vat_main_t * vam)
5379 unformat_input_t *i = vam->input;
5380 vl_api_ip_add_del_route_t *mp;
5382 u32 sw_if_index = ~0, vrf_id = 0;
5383 u8 sw_if_index_set = 0;
5385 u8 is_local = 0, is_drop = 0;
5386 u8 create_vrf_if_needed = 0;
5388 u8 next_hop_weight = 1;
5390 u8 is_multipath = 0;
5392 u8 address_length_set = 0;
5393 u32 lookup_in_vrf = 0;
5394 u32 resolve_attempts = 0;
5395 u32 dst_address_length = 0;
5396 u8 next_hop_set = 0;
5397 ip4_address_t v4_dst_address, v4_next_hop_address;
5398 ip6_address_t v6_dst_address, v6_next_hop_address;
5402 u32 random_add_del = 0;
5403 u32 *random_vector = 0;
5405 u32 random_seed = 0xdeaddabe;
5406 u32 classify_table_index = ~0;
5408 u8 resolve_host, resolve_attached;
5410 /* Parse args required to build the message */
5411 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5413 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5414 sw_if_index_set = 1;
5415 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5416 sw_if_index_set = 1;
5417 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
5422 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
5427 else if (unformat (i, "/%d", &dst_address_length))
5429 address_length_set = 1;
5432 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
5433 &v4_next_hop_address))
5437 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
5438 &v6_next_hop_address))
5442 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
5444 else if (unformat (i, "weight %d", &next_hop_weight))
5446 else if (unformat (i, "drop"))
5450 else if (unformat (i, "local"))
5454 else if (unformat (i, "classify %d", &classify_table_index))
5458 else if (unformat (i, "del"))
5460 else if (unformat (i, "add"))
5462 else if (unformat (i, "not-last"))
5464 else if (unformat (i, "resolve-via-host"))
5466 else if (unformat (i, "resolve-via-attached"))
5467 resolve_attached = 1;
5468 else if (unformat (i, "multipath"))
5470 else if (unformat (i, "vrf %d", &vrf_id))
5472 else if (unformat (i, "create-vrf"))
5473 create_vrf_if_needed = 1;
5474 else if (unformat (i, "count %d", &count))
5476 else if (unformat (i, "lookup-in-vrf %d", &lookup_in_vrf))
5478 else if (unformat (i, "random"))
5480 else if (unformat (i, "seed %d", &random_seed))
5484 clib_warning ("parse error '%U'", format_unformat_error, i);
5489 if (resolve_attempts > 0 && sw_if_index_set == 0)
5491 errmsg ("ARP resolution needs explicit interface or sw_if_index\n");
5495 if (!next_hop_set && !is_drop && !is_local && !is_classify)
5497 errmsg ("next hop / local / drop / classify not set\n");
5501 if (address_set == 0)
5503 errmsg ("missing addresses\n");
5507 if (address_length_set == 0)
5509 errmsg ("missing address length\n");
5513 /* Generate a pile of unique, random routes */
5516 u32 this_random_address;
5517 random_hash = hash_create (count, sizeof (uword));
5519 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
5520 for (j = 0; j <= count; j++)
5524 this_random_address = random_u32 (&random_seed);
5525 this_random_address =
5526 clib_host_to_net_u32 (this_random_address);
5528 while (hash_get (random_hash, this_random_address));
5529 vec_add1 (random_vector, this_random_address);
5530 hash_set (random_hash, this_random_address, 1);
5532 hash_free (random_hash);
5533 v4_dst_address.as_u32 = random_vector[0];
5538 /* Turn on async mode */
5539 vam->async_mode = 1;
5540 vam->async_errors = 0;
5541 before = vat_time_now (vam);
5544 for (j = 0; j < count; j++)
5546 /* Construct the API message */
5547 M (IP_ADD_DEL_ROUTE, ip_add_del_route);
5549 mp->next_hop_sw_if_index = ntohl (sw_if_index);
5550 mp->vrf_id = ntohl (vrf_id);
5551 if (resolve_attempts > 0)
5553 mp->resolve_attempts = ntohl (resolve_attempts);
5554 mp->resolve_if_needed = 1;
5556 mp->create_vrf_if_needed = create_vrf_if_needed;
5558 mp->is_add = is_add;
5559 mp->is_drop = is_drop;
5560 mp->is_ipv6 = is_ipv6;
5561 mp->is_local = is_local;
5562 mp->is_classify = is_classify;
5563 mp->is_multipath = is_multipath;
5564 mp->is_resolve_host = resolve_host;
5565 mp->is_resolve_attached = resolve_attached;
5566 mp->not_last = not_last;
5567 mp->next_hop_weight = next_hop_weight;
5568 mp->dst_address_length = dst_address_length;
5569 mp->lookup_in_vrf = ntohl (lookup_in_vrf);
5570 mp->classify_table_index = ntohl (classify_table_index);
5574 clib_memcpy (mp->dst_address, &v6_dst_address,
5575 sizeof (v6_dst_address));
5577 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
5578 sizeof (v6_next_hop_address));
5579 increment_v6_address (&v6_dst_address);
5583 clib_memcpy (mp->dst_address, &v4_dst_address,
5584 sizeof (v4_dst_address));
5586 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
5587 sizeof (v4_next_hop_address));
5589 v4_dst_address.as_u32 = random_vector[j + 1];
5591 increment_v4_address (&v4_dst_address);
5597 /* When testing multiple add/del ops, use a control-ping to sync */
5600 vl_api_control_ping_t *mp;
5603 /* Shut off async mode */
5604 vam->async_mode = 0;
5606 M (CONTROL_PING, control_ping);
5609 timeout = vat_time_now (vam) + 1.0;
5610 while (vat_time_now (vam) < timeout)
5611 if (vam->result_ready == 1)
5616 if (vam->retval == -99)
5617 errmsg ("timeout\n");
5619 if (vam->async_errors > 0)
5621 errmsg ("%d asynchronous errors\n", vam->async_errors);
5624 vam->async_errors = 0;
5625 after = vat_time_now (vam);
5627 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
5628 count, after - before, count / (after - before));
5632 /* Wait for a reply... */
5636 /* Return the good/bad news */
5637 return (vam->retval);
5641 api_proxy_arp_add_del (vat_main_t * vam)
5643 unformat_input_t *i = vam->input;
5644 vl_api_proxy_arp_add_del_t *mp;
5648 ip4_address_t lo, hi;
5651 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5653 if (unformat (i, "vrf %d", &vrf_id))
5655 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
5656 unformat_ip4_address, &hi))
5658 else if (unformat (i, "del"))
5662 clib_warning ("parse error '%U'", format_unformat_error, i);
5669 errmsg ("address range not set\n");
5673 M (PROXY_ARP_ADD_DEL, proxy_arp_add_del);
5675 mp->vrf_id = ntohl (vrf_id);
5676 mp->is_add = is_add;
5677 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
5678 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
5687 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
5689 unformat_input_t *i = vam->input;
5690 vl_api_proxy_arp_intfc_enable_disable_t *mp;
5694 u8 sw_if_index_set = 0;
5696 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5698 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5699 sw_if_index_set = 1;
5700 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5701 sw_if_index_set = 1;
5702 else if (unformat (i, "enable"))
5704 else if (unformat (i, "disable"))
5708 clib_warning ("parse error '%U'", format_unformat_error, i);
5713 if (sw_if_index_set == 0)
5715 errmsg ("missing interface name or sw_if_index\n");
5719 M (PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable);
5721 mp->sw_if_index = ntohl (sw_if_index);
5722 mp->enable_disable = enable;
5731 api_mpls_add_del_decap (vat_main_t * vam)
5733 unformat_input_t *i = vam->input;
5734 vl_api_mpls_add_del_decap_t *mp;
5743 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5745 if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
5747 else if (unformat (i, "tx_vrf_id %d", &tx_vrf_id))
5749 else if (unformat (i, "label %d", &label))
5751 else if (unformat (i, "next-index %d", &next_index))
5753 else if (unformat (i, "del"))
5755 else if (unformat (i, "s-bit-clear"))
5759 clib_warning ("parse error '%U'", format_unformat_error, i);
5764 M (MPLS_ADD_DEL_DECAP, mpls_add_del_decap);
5766 mp->rx_vrf_id = ntohl (rx_vrf_id);
5767 mp->tx_vrf_id = ntohl (tx_vrf_id);
5768 mp->label = ntohl (label);
5769 mp->next_index = ntohl (next_index);
5771 mp->is_add = is_add;
5780 api_mpls_add_del_encap (vat_main_t * vam)
5782 unformat_input_t *i = vam->input;
5783 vl_api_mpls_add_del_encap_t *mp;
5788 ip4_address_t dst_address;
5791 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5793 if (unformat (i, "vrf %d", &vrf_id))
5795 else if (unformat (i, "label %d", &label))
5796 vec_add1 (labels, ntohl (label));
5797 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
5799 else if (unformat (i, "del"))
5803 clib_warning ("parse error '%U'", format_unformat_error, i);
5808 if (vec_len (labels) == 0)
5810 errmsg ("missing encap label stack\n");
5814 M2 (MPLS_ADD_DEL_ENCAP, mpls_add_del_encap,
5815 sizeof (u32) * vec_len (labels));
5817 mp->vrf_id = ntohl (vrf_id);
5818 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
5819 mp->is_add = is_add;
5820 mp->nlabels = vec_len (labels);
5821 clib_memcpy (mp->labels, labels, sizeof (u32) * mp->nlabels);
5832 api_mpls_gre_add_del_tunnel (vat_main_t * vam)
5834 unformat_input_t *i = vam->input;
5835 vl_api_mpls_gre_add_del_tunnel_t *mp;
5837 u32 inner_vrf_id = 0;
5838 u32 outer_vrf_id = 0;
5839 ip4_address_t src_address;
5840 ip4_address_t dst_address;
5841 ip4_address_t intfc_address;
5843 u8 intfc_address_length = 0;
5847 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5849 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
5851 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
5853 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
5855 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
5857 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
5858 &intfc_address, &tmp))
5859 intfc_address_length = tmp;
5860 else if (unformat (i, "l2-only"))
5862 else if (unformat (i, "del"))
5866 clib_warning ("parse error '%U'", format_unformat_error, i);
5871 M (MPLS_GRE_ADD_DEL_TUNNEL, mpls_gre_add_del_tunnel);
5873 mp->inner_vrf_id = ntohl (inner_vrf_id);
5874 mp->outer_vrf_id = ntohl (outer_vrf_id);
5875 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
5876 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
5877 clib_memcpy (mp->intfc_address, &intfc_address, sizeof (intfc_address));
5878 mp->intfc_address_length = intfc_address_length;
5879 mp->l2_only = l2_only;
5880 mp->is_add = is_add;
5889 api_mpls_ethernet_add_del_tunnel (vat_main_t * vam)
5891 unformat_input_t *i = vam->input;
5892 vl_api_mpls_ethernet_add_del_tunnel_t *mp;
5894 u32 inner_vrf_id = 0;
5895 ip4_address_t intfc_address;
5896 u8 dst_mac_address[6];
5899 u8 intfc_address_length = 0;
5903 int tx_sw_if_index_set = 0;
5905 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5907 if (unformat (i, "vrf %d", &inner_vrf_id))
5909 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
5910 &intfc_address, &tmp))
5911 intfc_address_length = tmp;
5912 else if (unformat (i, "%U", unformat_sw_if_index, vam, &tx_sw_if_index))
5913 tx_sw_if_index_set = 1;
5914 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5915 tx_sw_if_index_set = 1;
5916 else if (unformat (i, "dst %U", unformat_ethernet_address,
5919 else if (unformat (i, "l2-only"))
5921 else if (unformat (i, "del"))
5925 clib_warning ("parse error '%U'", format_unformat_error, i);
5932 errmsg ("dst (mac address) not set\n");
5935 if (!tx_sw_if_index_set)
5937 errmsg ("tx-intfc not set\n");
5941 M (MPLS_ETHERNET_ADD_DEL_TUNNEL, mpls_ethernet_add_del_tunnel);
5943 mp->vrf_id = ntohl (inner_vrf_id);
5944 clib_memcpy (mp->adj_address, &intfc_address, sizeof (intfc_address));
5945 mp->adj_address_length = intfc_address_length;
5946 clib_memcpy (mp->dst_mac_address, dst_mac_address,
5947 sizeof (dst_mac_address));
5948 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
5949 mp->l2_only = l2_only;
5950 mp->is_add = is_add;
5959 api_mpls_ethernet_add_del_tunnel_2 (vat_main_t * vam)
5961 unformat_input_t *i = vam->input;
5962 vl_api_mpls_ethernet_add_del_tunnel_2_t *mp;
5964 u32 inner_vrf_id = 0;
5965 u32 outer_vrf_id = 0;
5966 ip4_address_t adj_address;
5967 int adj_address_set = 0;
5968 ip4_address_t next_hop_address;
5969 int next_hop_address_set = 0;
5971 u8 adj_address_length = 0;
5974 u32 resolve_attempts = 5;
5975 u8 resolve_if_needed = 1;
5977 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5979 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
5981 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
5983 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
5984 &adj_address, &tmp))
5986 adj_address_length = tmp;
5987 adj_address_set = 1;
5989 else if (unformat (i, "next-hop %U", unformat_ip4_address,
5991 next_hop_address_set = 1;
5992 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
5994 else if (unformat (i, "resolve-if-needed %d", &tmp))
5995 resolve_if_needed = tmp;
5996 else if (unformat (i, "l2-only"))
5998 else if (unformat (i, "del"))
6002 clib_warning ("parse error '%U'", format_unformat_error, i);
6007 if (!adj_address_set)
6009 errmsg ("adjacency address/mask not set\n");
6012 if (!next_hop_address_set)
6014 errmsg ("ip4 next hop address (in outer fib) not set\n");
6018 M (MPLS_ETHERNET_ADD_DEL_TUNNEL_2, mpls_ethernet_add_del_tunnel_2);
6020 mp->inner_vrf_id = ntohl (inner_vrf_id);
6021 mp->outer_vrf_id = ntohl (outer_vrf_id);
6022 mp->resolve_attempts = ntohl (resolve_attempts);
6023 mp->resolve_if_needed = resolve_if_needed;
6024 mp->is_add = is_add;
6025 mp->l2_only = l2_only;
6026 clib_memcpy (mp->adj_address, &adj_address, sizeof (adj_address));
6027 mp->adj_address_length = adj_address_length;
6028 clib_memcpy (mp->next_hop_ip4_address_in_outer_vrf, &next_hop_address,
6029 sizeof (next_hop_address));
6038 api_sw_interface_set_unnumbered (vat_main_t * vam)
6040 unformat_input_t *i = vam->input;
6041 vl_api_sw_interface_set_unnumbered_t *mp;
6044 u32 unnum_sw_index = ~0;
6046 u8 sw_if_index_set = 0;
6048 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6050 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6051 sw_if_index_set = 1;
6052 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6053 sw_if_index_set = 1;
6054 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
6056 else if (unformat (i, "del"))
6060 clib_warning ("parse error '%U'", format_unformat_error, i);
6065 if (sw_if_index_set == 0)
6067 errmsg ("missing interface name or sw_if_index\n");
6071 M (SW_INTERFACE_SET_UNNUMBERED, sw_interface_set_unnumbered);
6073 mp->sw_if_index = ntohl (sw_if_index);
6074 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
6075 mp->is_add = is_add;
6084 api_ip_neighbor_add_del (vat_main_t * vam)
6086 unformat_input_t *i = vam->input;
6087 vl_api_ip_neighbor_add_del_t *mp;
6090 u8 sw_if_index_set = 0;
6096 u8 v4_address_set = 0;
6097 u8 v6_address_set = 0;
6098 ip4_address_t v4address;
6099 ip6_address_t v6address;
6101 memset (mac_address, 0, sizeof (mac_address));
6103 /* Parse args required to build the message */
6104 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6106 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6110 else if (unformat (i, "del"))
6112 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6113 sw_if_index_set = 1;
6114 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6115 sw_if_index_set = 1;
6116 else if (unformat (i, "is_static"))
6118 else if (unformat (i, "vrf %d", &vrf_id))
6120 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
6122 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
6126 clib_warning ("parse error '%U'", format_unformat_error, i);
6131 if (sw_if_index_set == 0)
6133 errmsg ("missing interface name or sw_if_index\n");
6136 if (v4_address_set && v6_address_set)
6138 errmsg ("both v4 and v6 addresses set\n");
6141 if (!v4_address_set && !v6_address_set)
6143 errmsg ("no address set\n");
6147 /* Construct the API message */
6148 M (IP_NEIGHBOR_ADD_DEL, ip_neighbor_add_del);
6150 mp->sw_if_index = ntohl (sw_if_index);
6151 mp->is_add = is_add;
6152 mp->vrf_id = ntohl (vrf_id);
6153 mp->is_static = is_static;
6155 clib_memcpy (mp->mac_address, mac_address, 6);
6159 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
6163 /* mp->is_ipv6 = 0; via memset in M macro above */
6164 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
6170 /* Wait for a reply, return good/bad news */
6178 api_reset_vrf (vat_main_t * vam)
6180 unformat_input_t *i = vam->input;
6181 vl_api_reset_vrf_t *mp;
6187 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6189 if (unformat (i, "vrf %d", &vrf_id))
6191 else if (unformat (i, "ipv6"))
6195 clib_warning ("parse error '%U'", format_unformat_error, i);
6200 if (vrf_id_set == 0)
6202 errmsg ("missing vrf id\n");
6206 M (RESET_VRF, reset_vrf);
6208 mp->vrf_id = ntohl (vrf_id);
6209 mp->is_ipv6 = is_ipv6;
6218 api_create_vlan_subif (vat_main_t * vam)
6220 unformat_input_t *i = vam->input;
6221 vl_api_create_vlan_subif_t *mp;
6224 u8 sw_if_index_set = 0;
6228 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6230 if (unformat (i, "sw_if_index %d", &sw_if_index))
6231 sw_if_index_set = 1;
6232 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6233 sw_if_index_set = 1;
6234 else if (unformat (i, "vlan %d", &vlan_id))
6238 clib_warning ("parse error '%U'", format_unformat_error, i);
6243 if (sw_if_index_set == 0)
6245 errmsg ("missing interface name or sw_if_index\n");
6249 if (vlan_id_set == 0)
6251 errmsg ("missing vlan_id\n");
6254 M (CREATE_VLAN_SUBIF, create_vlan_subif);
6256 mp->sw_if_index = ntohl (sw_if_index);
6257 mp->vlan_id = ntohl (vlan_id);
6265 #define foreach_create_subif_bit \
6272 _(outer_vlan_id_any) \
6273 _(inner_vlan_id_any)
6276 api_create_subif (vat_main_t * vam)
6278 unformat_input_t *i = vam->input;
6279 vl_api_create_subif_t *mp;
6282 u8 sw_if_index_set = 0;
6289 u32 exact_match = 0;
6290 u32 default_sub = 0;
6291 u32 outer_vlan_id_any = 0;
6292 u32 inner_vlan_id_any = 0;
6294 u16 outer_vlan_id = 0;
6295 u16 inner_vlan_id = 0;
6297 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6299 if (unformat (i, "sw_if_index %d", &sw_if_index))
6300 sw_if_index_set = 1;
6301 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6302 sw_if_index_set = 1;
6303 else if (unformat (i, "sub_id %d", &sub_id))
6305 else if (unformat (i, "outer_vlan_id %d", &tmp))
6306 outer_vlan_id = tmp;
6307 else if (unformat (i, "inner_vlan_id %d", &tmp))
6308 inner_vlan_id = tmp;
6310 #define _(a) else if (unformat (i, #a)) a = 1 ;
6311 foreach_create_subif_bit
6315 clib_warning ("parse error '%U'", format_unformat_error, i);
6320 if (sw_if_index_set == 0)
6322 errmsg ("missing interface name or sw_if_index\n");
6326 if (sub_id_set == 0)
6328 errmsg ("missing sub_id\n");
6331 M (CREATE_SUBIF, create_subif);
6333 mp->sw_if_index = ntohl (sw_if_index);
6334 mp->sub_id = ntohl (sub_id);
6336 #define _(a) mp->a = a;
6337 foreach_create_subif_bit;
6340 mp->outer_vlan_id = ntohs (outer_vlan_id);
6341 mp->inner_vlan_id = ntohs (inner_vlan_id);
6350 api_oam_add_del (vat_main_t * vam)
6352 unformat_input_t *i = vam->input;
6353 vl_api_oam_add_del_t *mp;
6357 ip4_address_t src, dst;
6361 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6363 if (unformat (i, "vrf %d", &vrf_id))
6365 else if (unformat (i, "src %U", unformat_ip4_address, &src))
6367 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
6369 else if (unformat (i, "del"))
6373 clib_warning ("parse error '%U'", format_unformat_error, i);
6380 errmsg ("missing src addr\n");
6386 errmsg ("missing dst addr\n");
6390 M (OAM_ADD_DEL, oam_add_del);
6392 mp->vrf_id = ntohl (vrf_id);
6393 mp->is_add = is_add;
6394 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
6395 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
6404 api_reset_fib (vat_main_t * vam)
6406 unformat_input_t *i = vam->input;
6407 vl_api_reset_fib_t *mp;
6413 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6415 if (unformat (i, "vrf %d", &vrf_id))
6417 else if (unformat (i, "ipv6"))
6421 clib_warning ("parse error '%U'", format_unformat_error, i);
6426 if (vrf_id_set == 0)
6428 errmsg ("missing vrf id\n");
6432 M (RESET_FIB, reset_fib);
6434 mp->vrf_id = ntohl (vrf_id);
6435 mp->is_ipv6 = is_ipv6;
6444 api_dhcp_proxy_config (vat_main_t * vam)
6446 unformat_input_t *i = vam->input;
6447 vl_api_dhcp_proxy_config_t *mp;
6452 u8 v4_address_set = 0;
6453 u8 v6_address_set = 0;
6454 ip4_address_t v4address;
6455 ip6_address_t v6address;
6456 u8 v4_src_address_set = 0;
6457 u8 v6_src_address_set = 0;
6458 ip4_address_t v4srcaddress;
6459 ip6_address_t v6srcaddress;
6461 /* Parse args required to build the message */
6462 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6464 if (unformat (i, "del"))
6466 else if (unformat (i, "vrf %d", &vrf_id))
6468 else if (unformat (i, "insert-cid %d", &insert_cid))
6470 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
6472 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
6474 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
6475 v4_src_address_set = 1;
6476 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
6477 v6_src_address_set = 1;
6482 if (v4_address_set && v6_address_set)
6484 errmsg ("both v4 and v6 server addresses set\n");
6487 if (!v4_address_set && !v6_address_set)
6489 errmsg ("no server addresses set\n");
6493 if (v4_src_address_set && v6_src_address_set)
6495 errmsg ("both v4 and v6 src addresses set\n");
6498 if (!v4_src_address_set && !v6_src_address_set)
6500 errmsg ("no src addresses set\n");
6504 if (!(v4_src_address_set && v4_address_set) &&
6505 !(v6_src_address_set && v6_address_set))
6507 errmsg ("no matching server and src addresses set\n");
6511 /* Construct the API message */
6512 M (DHCP_PROXY_CONFIG, dhcp_proxy_config);
6514 mp->insert_circuit_id = insert_cid;
6515 mp->is_add = is_add;
6516 mp->vrf_id = ntohl (vrf_id);
6520 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
6521 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
6525 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
6526 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
6532 /* Wait for a reply, return good/bad news */
6539 api_dhcp_proxy_config_2 (vat_main_t * vam)
6541 unformat_input_t *i = vam->input;
6542 vl_api_dhcp_proxy_config_2_t *mp;
6545 u32 server_vrf_id = 0;
6548 u8 v4_address_set = 0;
6549 u8 v6_address_set = 0;
6550 ip4_address_t v4address;
6551 ip6_address_t v6address;
6552 u8 v4_src_address_set = 0;
6553 u8 v6_src_address_set = 0;
6554 ip4_address_t v4srcaddress;
6555 ip6_address_t v6srcaddress;
6557 /* Parse args required to build the message */
6558 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6560 if (unformat (i, "del"))
6562 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
6564 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
6566 else if (unformat (i, "insert-cid %d", &insert_cid))
6568 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
6570 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
6572 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
6573 v4_src_address_set = 1;
6574 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
6575 v6_src_address_set = 1;
6580 if (v4_address_set && v6_address_set)
6582 errmsg ("both v4 and v6 server addresses set\n");
6585 if (!v4_address_set && !v6_address_set)
6587 errmsg ("no server addresses set\n");
6591 if (v4_src_address_set && v6_src_address_set)
6593 errmsg ("both v4 and v6 src addresses set\n");
6596 if (!v4_src_address_set && !v6_src_address_set)
6598 errmsg ("no src addresses set\n");
6602 if (!(v4_src_address_set && v4_address_set) &&
6603 !(v6_src_address_set && v6_address_set))
6605 errmsg ("no matching server and src addresses set\n");
6609 /* Construct the API message */
6610 M (DHCP_PROXY_CONFIG_2, dhcp_proxy_config_2);
6612 mp->insert_circuit_id = insert_cid;
6613 mp->is_add = is_add;
6614 mp->rx_vrf_id = ntohl (rx_vrf_id);
6615 mp->server_vrf_id = ntohl (server_vrf_id);
6619 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
6620 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
6624 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
6625 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
6631 /* Wait for a reply, return good/bad news */
6638 api_dhcp_proxy_set_vss (vat_main_t * vam)
6640 unformat_input_t *i = vam->input;
6641 vl_api_dhcp_proxy_set_vss_t *mp;
6652 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6654 if (unformat (i, "tbl_id %d", &tbl_id))
6656 if (unformat (i, "fib_id %d", &fib_id))
6658 if (unformat (i, "oui %d", &oui))
6660 else if (unformat (i, "ipv6"))
6662 else if (unformat (i, "del"))
6666 clib_warning ("parse error '%U'", format_unformat_error, i);
6671 if (tbl_id_set == 0)
6673 errmsg ("missing tbl id\n");
6677 if (fib_id_set == 0)
6679 errmsg ("missing fib id\n");
6684 errmsg ("missing oui\n");
6688 M (DHCP_PROXY_SET_VSS, dhcp_proxy_set_vss);
6689 mp->tbl_id = ntohl (tbl_id);
6690 mp->fib_id = ntohl (fib_id);
6691 mp->oui = ntohl (oui);
6692 mp->is_ipv6 = is_ipv6;
6693 mp->is_add = is_add;
6702 api_dhcp_client_config (vat_main_t * vam)
6704 unformat_input_t *i = vam->input;
6705 vl_api_dhcp_client_config_t *mp;
6708 u8 sw_if_index_set = 0;
6711 u8 disable_event = 0;
6713 /* Parse args required to build the message */
6714 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6716 if (unformat (i, "del"))
6718 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6719 sw_if_index_set = 1;
6720 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6721 sw_if_index_set = 1;
6722 else if (unformat (i, "hostname %s", &hostname))
6724 else if (unformat (i, "disable_event"))
6730 if (sw_if_index_set == 0)
6732 errmsg ("missing interface name or sw_if_index\n");
6736 if (vec_len (hostname) > 63)
6738 errmsg ("hostname too long\n");
6740 vec_add1 (hostname, 0);
6742 /* Construct the API message */
6743 M (DHCP_CLIENT_CONFIG, dhcp_client_config);
6745 mp->sw_if_index = ntohl (sw_if_index);
6746 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
6747 vec_free (hostname);
6748 mp->is_add = is_add;
6749 mp->want_dhcp_event = disable_event ? 0 : 1;
6750 mp->pid = getpid ();
6755 /* Wait for a reply, return good/bad news */
6762 api_set_ip_flow_hash (vat_main_t * vam)
6764 unformat_input_t *i = vam->input;
6765 vl_api_set_ip_flow_hash_t *mp;
6777 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6779 if (unformat (i, "vrf %d", &vrf_id))
6781 else if (unformat (i, "ipv6"))
6783 else if (unformat (i, "src"))
6785 else if (unformat (i, "dst"))
6787 else if (unformat (i, "sport"))
6789 else if (unformat (i, "dport"))
6791 else if (unformat (i, "proto"))
6793 else if (unformat (i, "reverse"))
6798 clib_warning ("parse error '%U'", format_unformat_error, i);
6803 if (vrf_id_set == 0)
6805 errmsg ("missing vrf id\n");
6809 M (SET_IP_FLOW_HASH, set_ip_flow_hash);
6815 mp->reverse = reverse;
6816 mp->vrf_id = ntohl (vrf_id);
6817 mp->is_ipv6 = is_ipv6;
6826 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
6828 unformat_input_t *i = vam->input;
6829 vl_api_sw_interface_ip6_enable_disable_t *mp;
6832 u8 sw_if_index_set = 0;
6835 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6837 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6838 sw_if_index_set = 1;
6839 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6840 sw_if_index_set = 1;
6841 else if (unformat (i, "enable"))
6843 else if (unformat (i, "disable"))
6847 clib_warning ("parse error '%U'", format_unformat_error, i);
6852 if (sw_if_index_set == 0)
6854 errmsg ("missing interface name or sw_if_index\n");
6858 M (SW_INTERFACE_IP6_ENABLE_DISABLE, sw_interface_ip6_enable_disable);
6860 mp->sw_if_index = ntohl (sw_if_index);
6861 mp->enable = enable;
6870 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
6872 unformat_input_t *i = vam->input;
6873 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
6876 u8 sw_if_index_set = 0;
6877 u32 address_length = 0;
6878 u8 v6_address_set = 0;
6879 ip6_address_t v6address;
6881 /* Parse args required to build the message */
6882 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6884 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6885 sw_if_index_set = 1;
6886 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6887 sw_if_index_set = 1;
6888 else if (unformat (i, "%U/%d",
6889 unformat_ip6_address, &v6address, &address_length))
6895 if (sw_if_index_set == 0)
6897 errmsg ("missing interface name or sw_if_index\n");
6900 if (!v6_address_set)
6902 errmsg ("no address set\n");
6906 /* Construct the API message */
6907 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS,
6908 sw_interface_ip6_set_link_local_address);
6910 mp->sw_if_index = ntohl (sw_if_index);
6911 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6912 mp->address_length = address_length;
6917 /* Wait for a reply, return good/bad news */
6926 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
6928 unformat_input_t *i = vam->input;
6929 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
6932 u8 sw_if_index_set = 0;
6933 u32 address_length = 0;
6934 u8 v6_address_set = 0;
6935 ip6_address_t v6address;
6937 u8 no_advertise = 0;
6939 u8 no_autoconfig = 0;
6942 u32 val_lifetime = 0;
6943 u32 pref_lifetime = 0;
6945 /* Parse args required to build the message */
6946 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6948 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6949 sw_if_index_set = 1;
6950 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6951 sw_if_index_set = 1;
6952 else if (unformat (i, "%U/%d",
6953 unformat_ip6_address, &v6address, &address_length))
6955 else if (unformat (i, "val_life %d", &val_lifetime))
6957 else if (unformat (i, "pref_life %d", &pref_lifetime))
6959 else if (unformat (i, "def"))
6961 else if (unformat (i, "noadv"))
6963 else if (unformat (i, "offl"))
6965 else if (unformat (i, "noauto"))
6967 else if (unformat (i, "nolink"))
6969 else if (unformat (i, "isno"))
6973 clib_warning ("parse error '%U'", format_unformat_error, i);
6978 if (sw_if_index_set == 0)
6980 errmsg ("missing interface name or sw_if_index\n");
6983 if (!v6_address_set)
6985 errmsg ("no address set\n");
6989 /* Construct the API message */
6990 M (SW_INTERFACE_IP6ND_RA_PREFIX, sw_interface_ip6nd_ra_prefix);
6992 mp->sw_if_index = ntohl (sw_if_index);
6993 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6994 mp->address_length = address_length;
6995 mp->use_default = use_default;
6996 mp->no_advertise = no_advertise;
6997 mp->off_link = off_link;
6998 mp->no_autoconfig = no_autoconfig;
6999 mp->no_onlink = no_onlink;
7001 mp->val_lifetime = ntohl (val_lifetime);
7002 mp->pref_lifetime = ntohl (pref_lifetime);
7007 /* Wait for a reply, return good/bad news */
7015 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
7017 unformat_input_t *i = vam->input;
7018 vl_api_sw_interface_ip6nd_ra_config_t *mp;
7021 u8 sw_if_index_set = 0;
7026 u8 send_unicast = 0;
7029 u8 default_router = 0;
7030 u32 max_interval = 0;
7031 u32 min_interval = 0;
7033 u32 initial_count = 0;
7034 u32 initial_interval = 0;
7037 /* Parse args required to build the message */
7038 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7040 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7041 sw_if_index_set = 1;
7042 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7043 sw_if_index_set = 1;
7044 else if (unformat (i, "maxint %d", &max_interval))
7046 else if (unformat (i, "minint %d", &min_interval))
7048 else if (unformat (i, "life %d", &lifetime))
7050 else if (unformat (i, "count %d", &initial_count))
7052 else if (unformat (i, "interval %d", &initial_interval))
7054 else if (unformat (i, "suppress") || unformat (i, "surpress"))
7056 else if (unformat (i, "managed"))
7058 else if (unformat (i, "other"))
7060 else if (unformat (i, "ll"))
7062 else if (unformat (i, "send"))
7064 else if (unformat (i, "cease"))
7066 else if (unformat (i, "isno"))
7068 else if (unformat (i, "def"))
7072 clib_warning ("parse error '%U'", format_unformat_error, i);
7077 if (sw_if_index_set == 0)
7079 errmsg ("missing interface name or sw_if_index\n");
7083 /* Construct the API message */
7084 M (SW_INTERFACE_IP6ND_RA_CONFIG, sw_interface_ip6nd_ra_config);
7086 mp->sw_if_index = ntohl (sw_if_index);
7087 mp->max_interval = ntohl (max_interval);
7088 mp->min_interval = ntohl (min_interval);
7089 mp->lifetime = ntohl (lifetime);
7090 mp->initial_count = ntohl (initial_count);
7091 mp->initial_interval = ntohl (initial_interval);
7092 mp->suppress = suppress;
7093 mp->managed = managed;
7095 mp->ll_option = ll_option;
7096 mp->send_unicast = send_unicast;
7099 mp->default_router = default_router;
7104 /* Wait for a reply, return good/bad news */
7112 api_set_arp_neighbor_limit (vat_main_t * vam)
7114 unformat_input_t *i = vam->input;
7115 vl_api_set_arp_neighbor_limit_t *mp;
7121 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7123 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
7125 else if (unformat (i, "ipv6"))
7129 clib_warning ("parse error '%U'", format_unformat_error, i);
7136 errmsg ("missing limit value\n");
7140 M (SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit);
7142 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
7143 mp->is_ipv6 = is_ipv6;
7152 api_l2_patch_add_del (vat_main_t * vam)
7154 unformat_input_t *i = vam->input;
7155 vl_api_l2_patch_add_del_t *mp;
7158 u8 rx_sw_if_index_set = 0;
7160 u8 tx_sw_if_index_set = 0;
7163 /* Parse args required to build the message */
7164 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7166 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
7167 rx_sw_if_index_set = 1;
7168 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
7169 tx_sw_if_index_set = 1;
7170 else if (unformat (i, "rx"))
7172 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7174 if (unformat (i, "%U", unformat_sw_if_index, vam,
7176 rx_sw_if_index_set = 1;
7181 else if (unformat (i, "tx"))
7183 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7185 if (unformat (i, "%U", unformat_sw_if_index, vam,
7187 tx_sw_if_index_set = 1;
7192 else if (unformat (i, "del"))
7198 if (rx_sw_if_index_set == 0)
7200 errmsg ("missing rx interface name or rx_sw_if_index\n");
7204 if (tx_sw_if_index_set == 0)
7206 errmsg ("missing tx interface name or tx_sw_if_index\n");
7210 M (L2_PATCH_ADD_DEL, l2_patch_add_del);
7212 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
7213 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
7214 mp->is_add = is_add;
7223 api_ioam_enable (vat_main_t * vam)
7225 unformat_input_t *input = vam->input;
7226 vl_api_ioam_enable_t *mp;
7229 int has_trace_option = 0;
7230 int has_pow_option = 0;
7231 int has_ppc_option = 0;
7233 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7235 if (unformat (input, "trace"))
7236 has_trace_option = 1;
7237 else if (unformat (input, "pow"))
7239 else if (unformat (input, "ppc encap"))
7240 has_ppc_option = PPC_ENCAP;
7241 else if (unformat (input, "ppc decap"))
7242 has_ppc_option = PPC_DECAP;
7243 else if (unformat (input, "ppc none"))
7244 has_ppc_option = PPC_NONE;
7248 M (IOAM_ENABLE, ioam_enable);
7249 mp->id = htons (id);
7250 mp->trace_ppc = has_ppc_option;
7251 mp->pow_enable = has_pow_option;
7252 mp->trace_enable = has_trace_option;
7263 api_ioam_disable (vat_main_t * vam)
7265 vl_api_ioam_disable_t *mp;
7268 M (IOAM_DISABLE, ioam_disable);
7275 api_sr_tunnel_add_del (vat_main_t * vam)
7277 unformat_input_t *i = vam->input;
7278 vl_api_sr_tunnel_add_del_t *mp;
7282 ip6_address_t src_address;
7283 int src_address_set = 0;
7284 ip6_address_t dst_address;
7286 int dst_address_set = 0;
7288 u32 rx_table_id = 0;
7289 u32 tx_table_id = 0;
7290 ip6_address_t *segments = 0;
7291 ip6_address_t *this_seg;
7292 ip6_address_t *tags = 0;
7293 ip6_address_t *this_tag;
7294 ip6_address_t next_address, tag;
7296 u8 *policy_name = 0;
7298 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7300 if (unformat (i, "del"))
7302 else if (unformat (i, "name %s", &name))
7304 else if (unformat (i, "policy %s", &policy_name))
7306 else if (unformat (i, "rx_fib_id %d", &rx_table_id))
7308 else if (unformat (i, "tx_fib_id %d", &tx_table_id))
7310 else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
7311 src_address_set = 1;
7312 else if (unformat (i, "dst %U/%d",
7313 unformat_ip6_address, &dst_address, &dst_mask_width))
7314 dst_address_set = 1;
7315 else if (unformat (i, "next %U", unformat_ip6_address, &next_address))
7317 vec_add2 (segments, this_seg, 1);
7318 clib_memcpy (this_seg->as_u8, next_address.as_u8,
7319 sizeof (*this_seg));
7321 else if (unformat (i, "tag %U", unformat_ip6_address, &tag))
7323 vec_add2 (tags, this_tag, 1);
7324 clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
7326 else if (unformat (i, "clean"))
7327 flags |= IP6_SR_HEADER_FLAG_CLEANUP;
7328 else if (unformat (i, "protected"))
7329 flags |= IP6_SR_HEADER_FLAG_PROTECTED;
7330 else if (unformat (i, "InPE %d", &pl_index))
7332 if (pl_index <= 0 || pl_index > 4)
7334 pl_index_range_error:
7335 errmsg ("pl index %d out of range\n", pl_index);
7339 IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE << (3 * (pl_index - 1));
7341 else if (unformat (i, "EgPE %d", &pl_index))
7343 if (pl_index <= 0 || pl_index > 4)
7344 goto pl_index_range_error;
7346 IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE << (3 * (pl_index - 1));
7348 else if (unformat (i, "OrgSrc %d", &pl_index))
7350 if (pl_index <= 0 || pl_index > 4)
7351 goto pl_index_range_error;
7353 IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3 * (pl_index - 1));
7359 if (!src_address_set)
7361 errmsg ("src address required\n");
7365 if (!dst_address_set)
7367 errmsg ("dst address required\n");
7373 errmsg ("at least one sr segment required\n");
7377 M2 (SR_TUNNEL_ADD_DEL, sr_tunnel_add_del,
7378 vec_len (segments) * sizeof (ip6_address_t)
7379 + vec_len (tags) * sizeof (ip6_address_t));
7381 clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
7382 clib_memcpy (mp->dst_address, &dst_address, sizeof (mp->dst_address));
7383 mp->dst_mask_width = dst_mask_width;
7384 mp->flags_net_byte_order = clib_host_to_net_u16 (flags);
7385 mp->n_segments = vec_len (segments);
7386 mp->n_tags = vec_len (tags);
7387 mp->is_add = is_del == 0;
7388 clib_memcpy (mp->segs_and_tags, segments,
7389 vec_len (segments) * sizeof (ip6_address_t));
7390 clib_memcpy (mp->segs_and_tags +
7391 vec_len (segments) * sizeof (ip6_address_t), tags,
7392 vec_len (tags) * sizeof (ip6_address_t));
7394 mp->outer_vrf_id = ntohl (rx_table_id);
7395 mp->inner_vrf_id = ntohl (tx_table_id);
7396 memcpy (mp->name, name, vec_len (name));
7397 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
7399 vec_free (segments);
7408 api_sr_policy_add_del (vat_main_t * vam)
7410 unformat_input_t *input = vam->input;
7411 vl_api_sr_policy_add_del_t *mp;
7415 u8 *tunnel_name = 0;
7416 u8 **tunnel_names = 0;
7421 int tunnel_names_length = 1; // Init to 1 to offset the #tunnel_names counter byte
7422 int tun_name_len = 0; // Different naming convention used as confusing these would be "bad" (TM)
7424 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7426 if (unformat (input, "del"))
7428 else if (unformat (input, "name %s", &name))
7430 else if (unformat (input, "tunnel %s", &tunnel_name))
7434 vec_add1 (tunnel_names, tunnel_name);
7436 - length = #bytes to store in serial vector
7437 - +1 = byte to store that length
7439 tunnel_names_length += (vec_len (tunnel_name) + 1);
7450 errmsg ("policy name required\n");
7454 if ((!tunnel_set) && (!is_del))
7456 errmsg ("tunnel name required\n");
7460 M2 (SR_POLICY_ADD_DEL, sr_policy_add_del, tunnel_names_length);
7464 mp->is_add = !is_del;
7466 memcpy (mp->name, name, vec_len (name));
7467 // Since mp->tunnel_names is of type u8[0] and not a u8 *, u8 ** needs to be serialized
7468 u8 *serial_orig = 0;
7469 vec_validate (serial_orig, tunnel_names_length);
7470 *serial_orig = vec_len (tunnel_names); // Store the number of tunnels as length in first byte of serialized vector
7471 serial_orig += 1; // Move along one byte to store the length of first tunnel_name
7473 for (j = 0; j < vec_len (tunnel_names); j++)
7475 tun_name_len = vec_len (tunnel_names[j]);
7476 *serial_orig = tun_name_len; // Store length of tunnel name in first byte of Length/Value pair
7477 serial_orig += 1; // Move along one byte to store the actual tunnel name
7478 memcpy (serial_orig, tunnel_names[j], tun_name_len);
7479 serial_orig += tun_name_len; // Advance past the copy
7481 memcpy (mp->tunnel_names, serial_orig - tunnel_names_length, tunnel_names_length); // Regress serial_orig to head then copy fwd
7483 vec_free (tunnel_names);
7484 vec_free (tunnel_name);
7492 api_sr_multicast_map_add_del (vat_main_t * vam)
7494 unformat_input_t *input = vam->input;
7495 vl_api_sr_multicast_map_add_del_t *mp;
7498 ip6_address_t multicast_address;
7499 u8 *policy_name = 0;
7500 int multicast_address_set = 0;
7502 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7504 if (unformat (input, "del"))
7508 (input, "address %U", unformat_ip6_address, &multicast_address))
7509 multicast_address_set = 1;
7510 else if (unformat (input, "sr-policy %s", &policy_name))
7516 if (!is_del && !policy_name)
7518 errmsg ("sr-policy name required\n");
7523 if (!multicast_address_set)
7525 errmsg ("address required\n");
7529 M (SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del);
7531 mp->is_add = !is_del;
7532 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
7533 clib_memcpy (mp->multicast_address, &multicast_address,
7534 sizeof (mp->multicast_address));
7537 vec_free (policy_name);
7545 #define foreach_ip4_proto_field \
7556 unformat_ip4_mask (unformat_input_t * input, va_list * args)
7558 u8 **maskp = va_arg (*args, u8 **);
7560 u8 found_something = 0;
7563 #define _(a) u8 a=0;
7564 foreach_ip4_proto_field;
7570 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7572 if (unformat (input, "version"))
7574 else if (unformat (input, "hdr_length"))
7576 else if (unformat (input, "src"))
7578 else if (unformat (input, "dst"))
7580 else if (unformat (input, "proto"))
7583 #define _(a) else if (unformat (input, #a)) a=1;
7584 foreach_ip4_proto_field
7590 #define _(a) found_something += a;
7591 foreach_ip4_proto_field;
7594 if (found_something == 0)
7597 vec_validate (mask, sizeof (*ip) - 1);
7599 ip = (ip4_header_t *) mask;
7601 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
7602 foreach_ip4_proto_field;
7605 ip->ip_version_and_header_length = 0;
7608 ip->ip_version_and_header_length |= 0xF0;
7611 ip->ip_version_and_header_length |= 0x0F;
7617 #define foreach_ip6_proto_field \
7625 unformat_ip6_mask (unformat_input_t * input, va_list * args)
7627 u8 **maskp = va_arg (*args, u8 **);
7629 u8 found_something = 0;
7631 u32 ip_version_traffic_class_and_flow_label;
7633 #define _(a) u8 a=0;
7634 foreach_ip6_proto_field;
7637 u8 traffic_class = 0;
7640 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7642 if (unformat (input, "version"))
7644 else if (unformat (input, "traffic-class"))
7646 else if (unformat (input, "flow-label"))
7648 else if (unformat (input, "src"))
7650 else if (unformat (input, "dst"))
7652 else if (unformat (input, "proto"))
7655 #define _(a) else if (unformat (input, #a)) a=1;
7656 foreach_ip6_proto_field
7662 #define _(a) found_something += a;
7663 foreach_ip6_proto_field;
7666 if (found_something == 0)
7669 vec_validate (mask, sizeof (*ip) - 1);
7671 ip = (ip6_header_t *) mask;
7673 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
7674 foreach_ip6_proto_field;
7677 ip_version_traffic_class_and_flow_label = 0;
7680 ip_version_traffic_class_and_flow_label |= 0xF0000000;
7683 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
7686 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
7688 ip->ip_version_traffic_class_and_flow_label =
7689 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
7696 unformat_l3_mask (unformat_input_t * input, va_list * args)
7698 u8 **maskp = va_arg (*args, u8 **);
7700 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7702 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
7704 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
7713 unformat_l2_mask (unformat_input_t * input, va_list * args)
7715 u8 **maskp = va_arg (*args, u8 **);
7730 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7732 if (unformat (input, "src"))
7734 else if (unformat (input, "dst"))
7736 else if (unformat (input, "proto"))
7738 else if (unformat (input, "tag1"))
7740 else if (unformat (input, "tag2"))
7742 else if (unformat (input, "ignore-tag1"))
7744 else if (unformat (input, "ignore-tag2"))
7746 else if (unformat (input, "cos1"))
7748 else if (unformat (input, "cos2"))
7750 else if (unformat (input, "dot1q"))
7752 else if (unformat (input, "dot1ad"))
7757 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
7758 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
7761 if (tag1 || ignore_tag1 || cos1 || dot1q)
7763 if (tag2 || ignore_tag2 || cos2 || dot1ad)
7766 vec_validate (mask, len - 1);
7769 memset (mask, 0xff, 6);
7772 memset (mask + 6, 0xff, 6);
7776 /* inner vlan tag */
7785 mask[21] = mask[20] = 0xff;
7806 mask[16] = mask[17] = 0xff;
7816 mask[12] = mask[13] = 0xff;
7823 unformat_classify_mask (unformat_input_t * input, va_list * args)
7825 u8 **maskp = va_arg (*args, u8 **);
7826 u32 *skipp = va_arg (*args, u32 *);
7827 u32 *matchp = va_arg (*args, u32 *);
7834 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7836 if (unformat (input, "hex %U", unformat_hex_string, &mask))
7838 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
7840 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
7846 if (mask || l2 || l3)
7850 /* "With a free Ethernet header in every package" */
7852 vec_validate (l2, 13);
7856 vec_append (mask, l3);
7861 /* Scan forward looking for the first significant mask octet */
7862 for (i = 0; i < vec_len (mask); i++)
7866 /* compute (skip, match) params */
7867 *skipp = i / sizeof (u32x4);
7868 vec_delete (mask, *skipp * sizeof (u32x4), 0);
7870 /* Pad mask to an even multiple of the vector size */
7871 while (vec_len (mask) % sizeof (u32x4))
7874 match = vec_len (mask) / sizeof (u32x4);
7876 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
7878 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
7879 if (*tmp || *(tmp + 1))
7884 clib_warning ("BUG: match 0");
7886 _vec_len (mask) = match * sizeof (u32x4);
7897 #define foreach_l2_next \
7899 _(ethernet, ETHERNET_INPUT) \
7904 unformat_l2_next_index (unformat_input_t * input, va_list * args)
7906 u32 *miss_next_indexp = va_arg (*args, u32 *);
7911 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
7915 if (unformat (input, "%d", &tmp))
7924 *miss_next_indexp = next_index;
7928 #define foreach_ip_next \
7934 unformat_ip_next_index (unformat_input_t * input, va_list * args)
7936 u32 *miss_next_indexp = va_arg (*args, u32 *);
7941 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
7945 if (unformat (input, "%d", &tmp))
7954 *miss_next_indexp = next_index;
7958 #define foreach_acl_next \
7962 unformat_acl_next_index (unformat_input_t * input, va_list * args)
7964 u32 *miss_next_indexp = va_arg (*args, u32 *);
7969 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
7973 if (unformat (input, "permit"))
7978 else if (unformat (input, "%d", &tmp))
7987 *miss_next_indexp = next_index;
7992 unformat_policer_precolor (unformat_input_t * input, va_list * args)
7994 u32 *r = va_arg (*args, u32 *);
7996 if (unformat (input, "conform-color"))
7997 *r = POLICE_CONFORM;
7998 else if (unformat (input, "exceed-color"))
8007 api_classify_add_del_table (vat_main_t * vam)
8009 unformat_input_t *i = vam->input;
8010 vl_api_classify_add_del_table_t *mp;
8016 u32 table_index = ~0;
8017 u32 next_table_index = ~0;
8018 u32 miss_next_index = ~0;
8019 u32 memory_size = 32 << 20;
8023 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8025 if (unformat (i, "del"))
8027 else if (unformat (i, "buckets %d", &nbuckets))
8029 else if (unformat (i, "memory_size %d", &memory_size))
8031 else if (unformat (i, "skip %d", &skip))
8033 else if (unformat (i, "match %d", &match))
8035 else if (unformat (i, "table %d", &table_index))
8037 else if (unformat (i, "mask %U", unformat_classify_mask,
8038 &mask, &skip, &match))
8040 else if (unformat (i, "next-table %d", &next_table_index))
8042 else if (unformat (i, "miss-next %U", unformat_ip_next_index,
8045 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
8048 else if (unformat (i, "acl-miss-next %U", unformat_acl_next_index,
8055 if (is_add && mask == 0)
8057 errmsg ("Mask required\n");
8061 if (is_add && skip == ~0)
8063 errmsg ("skip count required\n");
8067 if (is_add && match == ~0)
8069 errmsg ("match count required\n");
8073 if (!is_add && table_index == ~0)
8075 errmsg ("table index required for delete\n");
8079 M2 (CLASSIFY_ADD_DEL_TABLE, classify_add_del_table, vec_len (mask));
8081 mp->is_add = is_add;
8082 mp->table_index = ntohl (table_index);
8083 mp->nbuckets = ntohl (nbuckets);
8084 mp->memory_size = ntohl (memory_size);
8085 mp->skip_n_vectors = ntohl (skip);
8086 mp->match_n_vectors = ntohl (match);
8087 mp->next_table_index = ntohl (next_table_index);
8088 mp->miss_next_index = ntohl (miss_next_index);
8089 clib_memcpy (mp->mask, mask, vec_len (mask));
8099 unformat_ip4_match (unformat_input_t * input, va_list * args)
8101 u8 **matchp = va_arg (*args, u8 **);
8108 int src = 0, dst = 0;
8109 ip4_address_t src_val, dst_val;
8116 int fragment_id = 0;
8117 u32 fragment_id_val;
8123 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8125 if (unformat (input, "version %d", &version_val))
8127 else if (unformat (input, "hdr_length %d", &hdr_length_val))
8129 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
8131 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
8133 else if (unformat (input, "proto %d", &proto_val))
8135 else if (unformat (input, "tos %d", &tos_val))
8137 else if (unformat (input, "length %d", &length_val))
8139 else if (unformat (input, "fragment_id %d", &fragment_id_val))
8141 else if (unformat (input, "ttl %d", &ttl_val))
8143 else if (unformat (input, "checksum %d", &checksum_val))
8149 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
8150 + ttl + checksum == 0)
8154 * Aligned because we use the real comparison functions
8156 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
8158 ip = (ip4_header_t *) match;
8160 /* These are realistically matched in practice */
8162 ip->src_address.as_u32 = src_val.as_u32;
8165 ip->dst_address.as_u32 = dst_val.as_u32;
8168 ip->protocol = proto_val;
8171 /* These are not, but they're included for completeness */
8173 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
8176 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
8182 ip->length = length_val;
8188 ip->checksum = checksum_val;
8195 unformat_ip6_match (unformat_input_t * input, va_list * args)
8197 u8 **matchp = va_arg (*args, u8 **);
8202 u8 traffic_class = 0;
8203 u32 traffic_class_val = 0;
8206 int src = 0, dst = 0;
8207 ip6_address_t src_val, dst_val;
8210 int payload_length = 0;
8211 u32 payload_length_val;
8214 u32 ip_version_traffic_class_and_flow_label;
8216 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8218 if (unformat (input, "version %d", &version_val))
8220 else if (unformat (input, "traffic_class %d", &traffic_class_val))
8222 else if (unformat (input, "flow_label %d", &flow_label_val))
8224 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
8226 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
8228 else if (unformat (input, "proto %d", &proto_val))
8230 else if (unformat (input, "payload_length %d", &payload_length_val))
8232 else if (unformat (input, "hop_limit %d", &hop_limit_val))
8238 if (version + traffic_class + flow_label + src + dst + proto +
8239 payload_length + hop_limit == 0)
8243 * Aligned because we use the real comparison functions
8245 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
8247 ip = (ip6_header_t *) match;
8250 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
8253 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
8256 ip->protocol = proto_val;
8258 ip_version_traffic_class_and_flow_label = 0;
8261 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
8264 ip_version_traffic_class_and_flow_label |=
8265 (traffic_class_val & 0xFF) << 20;
8268 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
8270 ip->ip_version_traffic_class_and_flow_label =
8271 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
8274 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
8277 ip->hop_limit = hop_limit_val;
8284 unformat_l3_match (unformat_input_t * input, va_list * args)
8286 u8 **matchp = va_arg (*args, u8 **);
8288 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8290 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
8292 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
8301 unformat_vlan_tag (unformat_input_t * input, va_list * args)
8303 u8 *tagp = va_arg (*args, u8 *);
8306 if (unformat (input, "%d", &tag))
8308 tagp[0] = (tag >> 8) & 0x0F;
8309 tagp[1] = tag & 0xFF;
8317 unformat_l2_match (unformat_input_t * input, va_list * args)
8319 u8 **matchp = va_arg (*args, u8 **);
8339 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8341 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
8344 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
8346 else if (unformat (input, "proto %U",
8347 unformat_ethernet_type_host_byte_order, &proto_val))
8349 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
8351 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
8353 else if (unformat (input, "ignore-tag1"))
8355 else if (unformat (input, "ignore-tag2"))
8357 else if (unformat (input, "cos1 %d", &cos1_val))
8359 else if (unformat (input, "cos2 %d", &cos2_val))
8364 if ((src + dst + proto + tag1 + tag2 +
8365 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
8368 if (tag1 || ignore_tag1 || cos1)
8370 if (tag2 || ignore_tag2 || cos2)
8373 vec_validate_aligned (match, len - 1, sizeof (u32x4));
8376 clib_memcpy (match, dst_val, 6);
8379 clib_memcpy (match + 6, src_val, 6);
8383 /* inner vlan tag */
8384 match[19] = tag2_val[1];
8385 match[18] = tag2_val[0];
8387 match[18] |= (cos2_val & 0x7) << 5;
8390 match[21] = proto_val & 0xff;
8391 match[20] = proto_val >> 8;
8395 match[15] = tag1_val[1];
8396 match[14] = tag1_val[0];
8399 match[14] |= (cos1_val & 0x7) << 5;
8405 match[15] = tag1_val[1];
8406 match[14] = tag1_val[0];
8409 match[17] = proto_val & 0xff;
8410 match[16] = proto_val >> 8;
8413 match[14] |= (cos1_val & 0x7) << 5;
8419 match[18] |= (cos2_val & 0x7) << 5;
8421 match[14] |= (cos1_val & 0x7) << 5;
8424 match[13] = proto_val & 0xff;
8425 match[12] = proto_val >> 8;
8434 unformat_classify_match (unformat_input_t * input, va_list * args)
8436 u8 **matchp = va_arg (*args, u8 **);
8437 u32 skip_n_vectors = va_arg (*args, u32);
8438 u32 match_n_vectors = va_arg (*args, u32);
8444 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8446 if (unformat (input, "hex %U", unformat_hex_string, &match))
8448 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
8450 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
8456 if (match || l2 || l3)
8460 /* "Win a free Ethernet header in every packet" */
8462 vec_validate_aligned (l2, 13, sizeof (u32x4));
8466 vec_append_aligned (match, l3, sizeof (u32x4));
8471 /* Make sure the vector is big enough even if key is all 0's */
8472 vec_validate_aligned
8473 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
8476 /* Set size, include skipped vectors */
8477 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
8488 api_classify_add_del_session (vat_main_t * vam)
8490 unformat_input_t *i = vam->input;
8491 vl_api_classify_add_del_session_t *mp;
8493 u32 table_index = ~0;
8494 u32 hit_next_index = ~0;
8495 u32 opaque_index = ~0;
8499 u32 skip_n_vectors = 0;
8500 u32 match_n_vectors = 0;
8503 * Warning: you have to supply skip_n and match_n
8504 * because the API client cant simply look at the classify
8508 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8510 if (unformat (i, "del"))
8512 else if (unformat (i, "hit-next %U", unformat_ip_next_index,
8515 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
8518 else if (unformat (i, "acl-hit-next %U", unformat_acl_next_index,
8521 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
8523 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
8525 else if (unformat (i, "opaque-index %d", &opaque_index))
8527 else if (unformat (i, "skip_n %d", &skip_n_vectors))
8529 else if (unformat (i, "match_n %d", &match_n_vectors))
8531 else if (unformat (i, "match %U", unformat_classify_match,
8532 &match, skip_n_vectors, match_n_vectors))
8534 else if (unformat (i, "advance %d", &advance))
8536 else if (unformat (i, "table-index %d", &table_index))
8542 if (table_index == ~0)
8544 errmsg ("Table index required\n");
8548 if (is_add && match == 0)
8550 errmsg ("Match value required\n");
8554 M2 (CLASSIFY_ADD_DEL_SESSION, classify_add_del_session, vec_len (match));
8556 mp->is_add = is_add;
8557 mp->table_index = ntohl (table_index);
8558 mp->hit_next_index = ntohl (hit_next_index);
8559 mp->opaque_index = ntohl (opaque_index);
8560 mp->advance = ntohl (advance);
8561 clib_memcpy (mp->match, match, vec_len (match));
8570 api_classify_set_interface_ip_table (vat_main_t * vam)
8572 unformat_input_t *i = vam->input;
8573 vl_api_classify_set_interface_ip_table_t *mp;
8576 int sw_if_index_set;
8577 u32 table_index = ~0;
8580 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8582 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8583 sw_if_index_set = 1;
8584 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8585 sw_if_index_set = 1;
8586 else if (unformat (i, "table %d", &table_index))
8590 clib_warning ("parse error '%U'", format_unformat_error, i);
8595 if (sw_if_index_set == 0)
8597 errmsg ("missing interface name or sw_if_index\n");
8602 M (CLASSIFY_SET_INTERFACE_IP_TABLE, classify_set_interface_ip_table);
8604 mp->sw_if_index = ntohl (sw_if_index);
8605 mp->table_index = ntohl (table_index);
8606 mp->is_ipv6 = is_ipv6;
8615 api_classify_set_interface_l2_tables (vat_main_t * vam)
8617 unformat_input_t *i = vam->input;
8618 vl_api_classify_set_interface_l2_tables_t *mp;
8621 int sw_if_index_set;
8622 u32 ip4_table_index = ~0;
8623 u32 ip6_table_index = ~0;
8624 u32 other_table_index = ~0;
8627 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8629 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8630 sw_if_index_set = 1;
8631 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8632 sw_if_index_set = 1;
8633 else if (unformat (i, "ip4-table %d", &ip4_table_index))
8635 else if (unformat (i, "ip6-table %d", &ip6_table_index))
8637 else if (unformat (i, "other-table %d", &other_table_index))
8639 else if (unformat (i, "is-input %d", &is_input))
8643 clib_warning ("parse error '%U'", format_unformat_error, i);
8648 if (sw_if_index_set == 0)
8650 errmsg ("missing interface name or sw_if_index\n");
8655 M (CLASSIFY_SET_INTERFACE_L2_TABLES, classify_set_interface_l2_tables);
8657 mp->sw_if_index = ntohl (sw_if_index);
8658 mp->ip4_table_index = ntohl (ip4_table_index);
8659 mp->ip6_table_index = ntohl (ip6_table_index);
8660 mp->other_table_index = ntohl (other_table_index);
8661 mp->is_input = (u8) is_input;
8670 api_set_ipfix_exporter (vat_main_t * vam)
8672 unformat_input_t *i = vam->input;
8673 vl_api_set_ipfix_exporter_t *mp;
8674 ip4_address_t collector_address;
8675 u8 collector_address_set = 0;
8676 u32 collector_port = ~0;
8677 ip4_address_t src_address;
8678 u8 src_address_set = 0;
8681 u32 template_interval = ~0;
8682 u8 udp_checksum = 0;
8685 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8687 if (unformat (i, "collector_address %U", unformat_ip4_address,
8688 &collector_address))
8689 collector_address_set = 1;
8690 else if (unformat (i, "collector_port %d", &collector_port))
8692 else if (unformat (i, "src_address %U", unformat_ip4_address,
8694 src_address_set = 1;
8695 else if (unformat (i, "vrf_id %d", &vrf_id))
8697 else if (unformat (i, "path_mtu %d", &path_mtu))
8699 else if (unformat (i, "template_interval %d", &template_interval))
8701 else if (unformat (i, "udp_checksum"))
8707 if (collector_address_set == 0)
8709 errmsg ("collector_address required\n");
8713 if (src_address_set == 0)
8715 errmsg ("src_address required\n");
8719 M (SET_IPFIX_EXPORTER, set_ipfix_exporter);
8721 memcpy (mp->collector_address, collector_address.data,
8722 sizeof (collector_address.data));
8723 mp->collector_port = htons ((u16) collector_port);
8724 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
8725 mp->vrf_id = htonl (vrf_id);
8726 mp->path_mtu = htonl (path_mtu);
8727 mp->template_interval = htonl (template_interval);
8728 mp->udp_checksum = udp_checksum;
8736 api_set_ipfix_classify_stream (vat_main_t * vam)
8738 unformat_input_t *i = vam->input;
8739 vl_api_set_ipfix_classify_stream_t *mp;
8741 u32 src_port = UDP_DST_PORT_ipfix;
8744 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8746 if (unformat (i, "domain %d", &domain_id))
8748 else if (unformat (i, "src_port %d", &src_port))
8752 errmsg ("unknown input `%U'", format_unformat_error, i);
8757 M (SET_IPFIX_CLASSIFY_STREAM, set_ipfix_classify_stream);
8759 mp->domain_id = htonl (domain_id);
8760 mp->src_port = htons ((u16) src_port);
8768 api_ipfix_classify_table_add_del (vat_main_t * vam)
8770 unformat_input_t *i = vam->input;
8771 vl_api_ipfix_classify_table_add_del_t *mp;
8773 u32 classify_table_index = ~0;
8775 u8 transport_protocol = 255;
8778 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8780 if (unformat (i, "add"))
8782 else if (unformat (i, "del"))
8784 else if (unformat (i, "table %d", &classify_table_index))
8786 else if (unformat (i, "ip4"))
8788 else if (unformat (i, "ip6"))
8790 else if (unformat (i, "tcp"))
8791 transport_protocol = 6;
8792 else if (unformat (i, "udp"))
8793 transport_protocol = 17;
8796 errmsg ("unknown input `%U'", format_unformat_error, i);
8803 errmsg ("expecting: add|del");
8806 if (classify_table_index == ~0)
8808 errmsg ("classifier table not specified");
8811 if (ip_version == 0)
8813 errmsg ("IP version not specified");
8817 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, ipfix_classify_table_add_del);
8819 mp->is_add = is_add;
8820 mp->table_id = htonl (classify_table_index);
8821 mp->ip_version = ip_version;
8822 mp->transport_protocol = transport_protocol;
8830 api_get_node_index (vat_main_t * vam)
8832 unformat_input_t *i = vam->input;
8833 vl_api_get_node_index_t *mp;
8837 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8839 if (unformat (i, "node %s", &name))
8846 errmsg ("node name required\n");
8849 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
8851 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
8855 M (GET_NODE_INDEX, get_node_index);
8856 clib_memcpy (mp->node_name, name, vec_len (name));
8866 api_get_next_index (vat_main_t * vam)
8868 unformat_input_t *i = vam->input;
8869 vl_api_get_next_index_t *mp;
8871 u8 *node_name = 0, *next_node_name = 0;
8873 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8875 if (unformat (i, "node-name %s", &node_name))
8877 else if (unformat (i, "next-node-name %s", &next_node_name))
8883 errmsg ("node name required\n");
8886 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
8888 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
8892 if (next_node_name == 0)
8894 errmsg ("next node name required\n");
8897 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
8899 errmsg ("next node name too long, max %d\n", ARRAY_LEN (mp->next_name));
8903 M (GET_NEXT_INDEX, get_next_index);
8904 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
8905 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
8906 vec_free (node_name);
8907 vec_free (next_node_name);
8916 api_add_node_next (vat_main_t * vam)
8918 unformat_input_t *i = vam->input;
8919 vl_api_add_node_next_t *mp;
8924 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8926 if (unformat (i, "node %s", &name))
8928 else if (unformat (i, "next %s", &next))
8935 errmsg ("node name required\n");
8938 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
8940 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
8945 errmsg ("next node required\n");
8948 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
8950 errmsg ("next name too long, max %d\n", ARRAY_LEN (mp->next_name));
8954 M (ADD_NODE_NEXT, add_node_next);
8955 clib_memcpy (mp->node_name, name, vec_len (name));
8956 clib_memcpy (mp->next_name, next, vec_len (next));
8967 api_l2tpv3_create_tunnel (vat_main_t * vam)
8969 unformat_input_t *i = vam->input;
8970 ip6_address_t client_address, our_address;
8971 int client_address_set = 0;
8972 int our_address_set = 0;
8973 u32 local_session_id = 0;
8974 u32 remote_session_id = 0;
8975 u64 local_cookie = 0;
8976 u64 remote_cookie = 0;
8977 u8 l2_sublayer_present = 0;
8978 vl_api_l2tpv3_create_tunnel_t *mp;
8981 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8983 if (unformat (i, "client_address %U", unformat_ip6_address,
8985 client_address_set = 1;
8986 else if (unformat (i, "our_address %U", unformat_ip6_address,
8988 our_address_set = 1;
8989 else if (unformat (i, "local_session_id %d", &local_session_id))
8991 else if (unformat (i, "remote_session_id %d", &remote_session_id))
8993 else if (unformat (i, "local_cookie %lld", &local_cookie))
8995 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
8997 else if (unformat (i, "l2-sublayer-present"))
8998 l2_sublayer_present = 1;
9003 if (client_address_set == 0)
9005 errmsg ("client_address required\n");
9009 if (our_address_set == 0)
9011 errmsg ("our_address required\n");
9015 M (L2TPV3_CREATE_TUNNEL, l2tpv3_create_tunnel);
9017 clib_memcpy (mp->client_address, client_address.as_u8,
9018 sizeof (mp->client_address));
9020 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
9022 mp->local_session_id = ntohl (local_session_id);
9023 mp->remote_session_id = ntohl (remote_session_id);
9024 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
9025 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
9026 mp->l2_sublayer_present = l2_sublayer_present;
9036 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
9038 unformat_input_t *i = vam->input;
9040 u8 sw_if_index_set = 0;
9041 u64 new_local_cookie = 0;
9042 u64 new_remote_cookie = 0;
9043 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
9046 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9048 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9049 sw_if_index_set = 1;
9050 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9051 sw_if_index_set = 1;
9052 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
9054 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
9060 if (sw_if_index_set == 0)
9062 errmsg ("missing interface name or sw_if_index\n");
9066 M (L2TPV3_SET_TUNNEL_COOKIES, l2tpv3_set_tunnel_cookies);
9068 mp->sw_if_index = ntohl (sw_if_index);
9069 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
9070 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
9079 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
9081 unformat_input_t *i = vam->input;
9082 vl_api_l2tpv3_interface_enable_disable_t *mp;
9085 u8 sw_if_index_set = 0;
9086 u8 enable_disable = 1;
9088 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9090 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9091 sw_if_index_set = 1;
9092 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9093 sw_if_index_set = 1;
9094 else if (unformat (i, "enable"))
9096 else if (unformat (i, "disable"))
9102 if (sw_if_index_set == 0)
9104 errmsg ("missing interface name or sw_if_index\n");
9108 M (L2TPV3_INTERFACE_ENABLE_DISABLE, l2tpv3_interface_enable_disable);
9110 mp->sw_if_index = ntohl (sw_if_index);
9111 mp->enable_disable = enable_disable;
9120 api_l2tpv3_set_lookup_key (vat_main_t * vam)
9122 unformat_input_t *i = vam->input;
9123 vl_api_l2tpv3_set_lookup_key_t *mp;
9127 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9129 if (unformat (i, "lookup_v6_src"))
9130 key = L2T_LOOKUP_SRC_ADDRESS;
9131 else if (unformat (i, "lookup_v6_dst"))
9132 key = L2T_LOOKUP_DST_ADDRESS;
9133 else if (unformat (i, "lookup_session_id"))
9134 key = L2T_LOOKUP_SESSION_ID;
9139 if (key == (u8) ~ 0)
9141 errmsg ("l2tp session lookup key unset\n");
9145 M (L2TPV3_SET_LOOKUP_KEY, l2tpv3_set_lookup_key);
9155 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
9156 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
9158 vat_main_t *vam = &vat_main;
9160 fformat (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)\n",
9161 format_ip6_address, mp->our_address,
9162 format_ip6_address, mp->client_address,
9163 clib_net_to_host_u32 (mp->sw_if_index));
9166 " local cookies %016llx %016llx remote cookie %016llx\n",
9167 clib_net_to_host_u64 (mp->local_cookie[0]),
9168 clib_net_to_host_u64 (mp->local_cookie[1]),
9169 clib_net_to_host_u64 (mp->remote_cookie));
9171 fformat (vam->ofp, " local session-id %d remote session-id %d\n",
9172 clib_net_to_host_u32 (mp->local_session_id),
9173 clib_net_to_host_u32 (mp->remote_session_id));
9175 fformat (vam->ofp, " l2 specific sublayer %s\n\n",
9176 mp->l2_sublayer_present ? "preset" : "absent");
9180 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
9181 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
9183 vat_main_t *vam = &vat_main;
9184 vat_json_node_t *node = NULL;
9185 struct in6_addr addr;
9187 if (VAT_JSON_ARRAY != vam->json_tree.type)
9189 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9190 vat_json_init_array (&vam->json_tree);
9192 node = vat_json_array_add (&vam->json_tree);
9194 vat_json_init_object (node);
9196 clib_memcpy (&addr, mp->our_address, sizeof (addr));
9197 vat_json_object_add_ip6 (node, "our_address", addr);
9198 clib_memcpy (&addr, mp->client_address, sizeof (addr));
9199 vat_json_object_add_ip6 (node, "client_address", addr);
9201 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
9202 vat_json_init_array (lc);
9203 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
9204 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
9205 vat_json_object_add_uint (node, "remote_cookie",
9206 clib_net_to_host_u64 (mp->remote_cookie));
9208 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
9209 vat_json_object_add_uint (node, "local_session_id",
9210 clib_net_to_host_u32 (mp->local_session_id));
9211 vat_json_object_add_uint (node, "remote_session_id",
9212 clib_net_to_host_u32 (mp->remote_session_id));
9213 vat_json_object_add_string_copy (node, "l2_sublayer",
9214 mp->l2_sublayer_present ? (u8 *) "present"
9219 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
9221 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
9224 /* Get list of l2tpv3-tunnel interfaces */
9225 M (SW_IF_L2TPV3_TUNNEL_DUMP, sw_if_l2tpv3_tunnel_dump);
9228 /* Use a control ping for synchronization */
9230 vl_api_control_ping_t *mp;
9231 M (CONTROL_PING, control_ping);
9238 static void vl_api_sw_interface_tap_details_t_handler
9239 (vl_api_sw_interface_tap_details_t * mp)
9241 vat_main_t *vam = &vat_main;
9243 fformat (vam->ofp, "%-16s %d\n",
9244 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
9247 static void vl_api_sw_interface_tap_details_t_handler_json
9248 (vl_api_sw_interface_tap_details_t * mp)
9250 vat_main_t *vam = &vat_main;
9251 vat_json_node_t *node = NULL;
9253 if (VAT_JSON_ARRAY != vam->json_tree.type)
9255 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9256 vat_json_init_array (&vam->json_tree);
9258 node = vat_json_array_add (&vam->json_tree);
9260 vat_json_init_object (node);
9261 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9262 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
9266 api_sw_interface_tap_dump (vat_main_t * vam)
9268 vl_api_sw_interface_tap_dump_t *mp;
9271 fformat (vam->ofp, "\n%-16s %s\n", "dev_name", "sw_if_index");
9272 /* Get list of tap interfaces */
9273 M (SW_INTERFACE_TAP_DUMP, sw_interface_tap_dump);
9276 /* Use a control ping for synchronization */
9278 vl_api_control_ping_t *mp;
9279 M (CONTROL_PING, control_ping);
9285 static uword unformat_vxlan_decap_next
9286 (unformat_input_t * input, va_list * args)
9288 u32 *result = va_arg (*args, u32 *);
9291 if (unformat (input, "drop"))
9292 *result = VXLAN_INPUT_NEXT_DROP;
9293 else if (unformat (input, "ip4"))
9294 *result = VXLAN_INPUT_NEXT_IP4_INPUT;
9295 else if (unformat (input, "ip6"))
9296 *result = VXLAN_INPUT_NEXT_IP6_INPUT;
9297 else if (unformat (input, "l2"))
9298 *result = VXLAN_INPUT_NEXT_L2_INPUT;
9299 else if (unformat (input, "%d", &tmp))
9307 api_vxlan_add_del_tunnel (vat_main_t * vam)
9309 unformat_input_t *line_input = vam->input;
9310 vl_api_vxlan_add_del_tunnel_t *mp;
9312 ip4_address_t src4, dst4;
9313 ip6_address_t src6, dst6;
9315 u8 ipv4_set = 0, ipv6_set = 0;
9318 u32 encap_vrf_id = 0;
9319 u32 decap_next_index = ~0;
9322 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9324 if (unformat (line_input, "del"))
9326 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
9331 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
9336 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
9341 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
9346 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
9348 else if (unformat (line_input, "decap-next %U",
9349 unformat_vxlan_decap_next, &decap_next_index))
9351 else if (unformat (line_input, "vni %d", &vni))
9355 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
9362 errmsg ("tunnel src address not specified\n");
9367 errmsg ("tunnel dst address not specified\n");
9371 if (ipv4_set && ipv6_set)
9373 errmsg ("both IPv4 and IPv6 addresses specified");
9377 if ((vni == 0) || (vni >> 24))
9379 errmsg ("vni not specified or out of range\n");
9383 M (VXLAN_ADD_DEL_TUNNEL, vxlan_add_del_tunnel);
9387 clib_memcpy (&mp->src_address, &src6, sizeof (src6));
9388 clib_memcpy (&mp->dst_address, &dst6, sizeof (dst6));
9392 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
9393 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
9395 mp->encap_vrf_id = ntohl (encap_vrf_id);
9396 mp->decap_next_index = ntohl (decap_next_index);
9397 mp->vni = ntohl (vni);
9398 mp->is_add = is_add;
9399 mp->is_ipv6 = ipv6_set;
9407 static void vl_api_vxlan_tunnel_details_t_handler
9408 (vl_api_vxlan_tunnel_details_t * mp)
9410 vat_main_t *vam = &vat_main;
9412 fformat (vam->ofp, "%11d%24U%24U%14d%18d%13d\n",
9413 ntohl (mp->sw_if_index),
9414 format_ip46_address, &(mp->src_address[0]),
9416 format_ip46_address, &(mp->dst_address[0]),
9418 ntohl (mp->encap_vrf_id),
9419 ntohl (mp->decap_next_index), ntohl (mp->vni));
9422 static void vl_api_vxlan_tunnel_details_t_handler_json
9423 (vl_api_vxlan_tunnel_details_t * mp)
9425 vat_main_t *vam = &vat_main;
9426 vat_json_node_t *node = NULL;
9428 struct in6_addr ip6;
9430 if (VAT_JSON_ARRAY != vam->json_tree.type)
9432 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9433 vat_json_init_array (&vam->json_tree);
9435 node = vat_json_array_add (&vam->json_tree);
9437 vat_json_init_object (node);
9438 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9441 clib_memcpy (&ip6, &(mp->src_address[0]), sizeof (ip6));
9442 vat_json_object_add_ip6 (node, "src_address", ip6);
9443 clib_memcpy (&ip6, &(mp->dst_address[0]), sizeof (ip6));
9444 vat_json_object_add_ip6 (node, "dst_address", ip6);
9448 clib_memcpy (&ip4, &(mp->src_address[0]), sizeof (ip4));
9449 vat_json_object_add_ip4 (node, "src_address", ip4);
9450 clib_memcpy (&ip4, &(mp->dst_address[0]), sizeof (ip4));
9451 vat_json_object_add_ip4 (node, "dst_address", ip4);
9453 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
9454 vat_json_object_add_uint (node, "decap_next_index",
9455 ntohl (mp->decap_next_index));
9456 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
9457 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
9461 api_vxlan_tunnel_dump (vat_main_t * vam)
9463 unformat_input_t *i = vam->input;
9464 vl_api_vxlan_tunnel_dump_t *mp;
9467 u8 sw_if_index_set = 0;
9469 /* Parse args required to build the message */
9470 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9472 if (unformat (i, "sw_if_index %d", &sw_if_index))
9473 sw_if_index_set = 1;
9478 if (sw_if_index_set == 0)
9483 if (!vam->json_output)
9485 fformat (vam->ofp, "%11s%24s%24s%14s%18s%13s\n",
9486 "sw_if_index", "src_address", "dst_address",
9487 "encap_vrf_id", "decap_next_index", "vni");
9490 /* Get list of vxlan-tunnel interfaces */
9491 M (VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump);
9493 mp->sw_if_index = htonl (sw_if_index);
9497 /* Use a control ping for synchronization */
9499 vl_api_control_ping_t *mp;
9500 M (CONTROL_PING, control_ping);
9507 api_gre_add_del_tunnel (vat_main_t * vam)
9509 unformat_input_t *line_input = vam->input;
9510 vl_api_gre_add_del_tunnel_t *mp;
9512 ip4_address_t src4, dst4;
9517 u32 outer_fib_id = 0;
9519 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9521 if (unformat (line_input, "del"))
9523 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
9525 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
9527 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
9529 else if (unformat (line_input, "teb"))
9533 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
9540 errmsg ("tunnel src address not specified\n");
9545 errmsg ("tunnel dst address not specified\n");
9550 M (GRE_ADD_DEL_TUNNEL, gre_add_del_tunnel);
9552 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
9553 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
9554 mp->outer_fib_id = ntohl (outer_fib_id);
9555 mp->is_add = is_add;
9564 static void vl_api_gre_tunnel_details_t_handler
9565 (vl_api_gre_tunnel_details_t * mp)
9567 vat_main_t *vam = &vat_main;
9569 fformat (vam->ofp, "%11d%15U%15U%6d%14d\n",
9570 ntohl (mp->sw_if_index),
9571 format_ip4_address, &mp->src_address,
9572 format_ip4_address, &mp->dst_address,
9573 mp->teb, ntohl (mp->outer_fib_id));
9576 static void vl_api_gre_tunnel_details_t_handler_json
9577 (vl_api_gre_tunnel_details_t * mp)
9579 vat_main_t *vam = &vat_main;
9580 vat_json_node_t *node = NULL;
9583 if (VAT_JSON_ARRAY != vam->json_tree.type)
9585 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9586 vat_json_init_array (&vam->json_tree);
9588 node = vat_json_array_add (&vam->json_tree);
9590 vat_json_init_object (node);
9591 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9592 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
9593 vat_json_object_add_ip4 (node, "src_address", ip4);
9594 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
9595 vat_json_object_add_ip4 (node, "dst_address", ip4);
9596 vat_json_object_add_uint (node, "teb", mp->teb);
9597 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
9601 api_gre_tunnel_dump (vat_main_t * vam)
9603 unformat_input_t *i = vam->input;
9604 vl_api_gre_tunnel_dump_t *mp;
9607 u8 sw_if_index_set = 0;
9609 /* Parse args required to build the message */
9610 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9612 if (unformat (i, "sw_if_index %d", &sw_if_index))
9613 sw_if_index_set = 1;
9618 if (sw_if_index_set == 0)
9623 if (!vam->json_output)
9625 fformat (vam->ofp, "%11s%15s%15s%6s%14s\n",
9626 "sw_if_index", "src_address", "dst_address", "teb",
9630 /* Get list of gre-tunnel interfaces */
9631 M (GRE_TUNNEL_DUMP, gre_tunnel_dump);
9633 mp->sw_if_index = htonl (sw_if_index);
9637 /* Use a control ping for synchronization */
9639 vl_api_control_ping_t *mp;
9640 M (CONTROL_PING, control_ping);
9647 api_l2_fib_clear_table (vat_main_t * vam)
9649 // unformat_input_t * i = vam->input;
9650 vl_api_l2_fib_clear_table_t *mp;
9653 M (L2_FIB_CLEAR_TABLE, l2_fib_clear_table);
9662 api_l2_interface_efp_filter (vat_main_t * vam)
9664 unformat_input_t *i = vam->input;
9665 vl_api_l2_interface_efp_filter_t *mp;
9669 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, "enable"))
9679 else if (unformat (i, "disable"))
9683 clib_warning ("parse error '%U'", format_unformat_error, i);
9688 if (sw_if_index_set == 0)
9690 errmsg ("missing sw_if_index\n");
9694 M (L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter);
9696 mp->sw_if_index = ntohl (sw_if_index);
9697 mp->enable_disable = enable;
9705 #define foreach_vtr_op \
9706 _("disable", L2_VTR_DISABLED) \
9707 _("push-1", L2_VTR_PUSH_1) \
9708 _("push-2", L2_VTR_PUSH_2) \
9709 _("pop-1", L2_VTR_POP_1) \
9710 _("pop-2", L2_VTR_POP_2) \
9711 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
9712 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
9713 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
9714 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
9717 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
9719 unformat_input_t *i = vam->input;
9720 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
9723 u8 sw_if_index_set = 0;
9730 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9732 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9733 sw_if_index_set = 1;
9734 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9735 sw_if_index_set = 1;
9736 else if (unformat (i, "vtr_op %d", &vtr_op))
9738 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
9741 else if (unformat (i, "push_dot1q %d", &push_dot1q))
9743 else if (unformat (i, "tag1 %d", &tag1))
9745 else if (unformat (i, "tag2 %d", &tag2))
9749 clib_warning ("parse error '%U'", format_unformat_error, i);
9754 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
9756 errmsg ("missing vtr operation or sw_if_index\n");
9760 M (L2_INTERFACE_VLAN_TAG_REWRITE, l2_interface_vlan_tag_rewrite)
9761 mp->sw_if_index = ntohl (sw_if_index);
9762 mp->vtr_op = ntohl (vtr_op);
9763 mp->push_dot1q = ntohl (push_dot1q);
9764 mp->tag1 = ntohl (tag1);
9765 mp->tag2 = ntohl (tag2);
9774 api_create_vhost_user_if (vat_main_t * vam)
9776 unformat_input_t *i = vam->input;
9777 vl_api_create_vhost_user_if_t *mp;
9781 u8 file_name_set = 0;
9782 u32 custom_dev_instance = ~0;
9784 u8 use_custom_mac = 0;
9786 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9788 if (unformat (i, "socket %s", &file_name))
9792 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
9794 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
9796 else if (unformat (i, "server"))
9802 if (file_name_set == 0)
9804 errmsg ("missing socket file name\n");
9808 if (vec_len (file_name) > 255)
9810 errmsg ("socket file name too long\n");
9813 vec_add1 (file_name, 0);
9815 M (CREATE_VHOST_USER_IF, create_vhost_user_if);
9817 mp->is_server = is_server;
9818 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
9819 vec_free (file_name);
9820 if (custom_dev_instance != ~0)
9823 mp->custom_dev_instance = ntohl (custom_dev_instance);
9825 mp->use_custom_mac = use_custom_mac;
9826 clib_memcpy (mp->mac_address, hwaddr, 6);
9835 api_modify_vhost_user_if (vat_main_t * vam)
9837 unformat_input_t *i = vam->input;
9838 vl_api_modify_vhost_user_if_t *mp;
9842 u8 file_name_set = 0;
9843 u32 custom_dev_instance = ~0;
9844 u8 sw_if_index_set = 0;
9845 u32 sw_if_index = (u32) ~ 0;
9847 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9849 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9850 sw_if_index_set = 1;
9851 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9852 sw_if_index_set = 1;
9853 else if (unformat (i, "socket %s", &file_name))
9857 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
9859 else if (unformat (i, "server"))
9865 if (sw_if_index_set == 0)
9867 errmsg ("missing sw_if_index or interface name\n");
9871 if (file_name_set == 0)
9873 errmsg ("missing socket file name\n");
9877 if (vec_len (file_name) > 255)
9879 errmsg ("socket file name too long\n");
9882 vec_add1 (file_name, 0);
9884 M (MODIFY_VHOST_USER_IF, modify_vhost_user_if);
9886 mp->sw_if_index = ntohl (sw_if_index);
9887 mp->is_server = is_server;
9888 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
9889 vec_free (file_name);
9890 if (custom_dev_instance != ~0)
9893 mp->custom_dev_instance = ntohl (custom_dev_instance);
9903 api_delete_vhost_user_if (vat_main_t * vam)
9905 unformat_input_t *i = vam->input;
9906 vl_api_delete_vhost_user_if_t *mp;
9908 u32 sw_if_index = ~0;
9909 u8 sw_if_index_set = 0;
9911 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9913 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9914 sw_if_index_set = 1;
9915 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9916 sw_if_index_set = 1;
9921 if (sw_if_index_set == 0)
9923 errmsg ("missing sw_if_index or interface name\n");
9928 M (DELETE_VHOST_USER_IF, delete_vhost_user_if);
9930 mp->sw_if_index = ntohl (sw_if_index);
9938 static void vl_api_sw_interface_vhost_user_details_t_handler
9939 (vl_api_sw_interface_vhost_user_details_t * mp)
9941 vat_main_t *vam = &vat_main;
9943 fformat (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s\n",
9944 (char *) mp->interface_name,
9945 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
9946 clib_net_to_host_u64 (mp->features), mp->is_server,
9947 ntohl (mp->num_regions), (char *) mp->sock_filename);
9948 fformat (vam->ofp, " Status: '%s'\n", strerror (ntohl (mp->sock_errno)));
9951 static void vl_api_sw_interface_vhost_user_details_t_handler_json
9952 (vl_api_sw_interface_vhost_user_details_t * mp)
9954 vat_main_t *vam = &vat_main;
9955 vat_json_node_t *node = NULL;
9957 if (VAT_JSON_ARRAY != vam->json_tree.type)
9959 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9960 vat_json_init_array (&vam->json_tree);
9962 node = vat_json_array_add (&vam->json_tree);
9964 vat_json_init_object (node);
9965 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9966 vat_json_object_add_string_copy (node, "interface_name",
9967 mp->interface_name);
9968 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
9969 ntohl (mp->virtio_net_hdr_sz));
9970 vat_json_object_add_uint (node, "features",
9971 clib_net_to_host_u64 (mp->features));
9972 vat_json_object_add_uint (node, "is_server", mp->is_server);
9973 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
9974 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
9975 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
9979 api_sw_interface_vhost_user_dump (vat_main_t * vam)
9981 vl_api_sw_interface_vhost_user_dump_t *mp;
9984 "Interface name idx hdr_sz features server regions filename\n");
9986 /* Get list of vhost-user interfaces */
9987 M (SW_INTERFACE_VHOST_USER_DUMP, sw_interface_vhost_user_dump);
9990 /* Use a control ping for synchronization */
9992 vl_api_control_ping_t *mp;
9993 M (CONTROL_PING, control_ping);
10000 api_show_version (vat_main_t * vam)
10002 vl_api_show_version_t *mp;
10005 M (SHOW_VERSION, show_version);
10015 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
10017 unformat_input_t *line_input = vam->input;
10018 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
10020 ip4_address_t local4, remote4;
10021 ip6_address_t local6, remote6;
10023 u8 ipv4_set = 0, ipv6_set = 0;
10026 u32 encap_vrf_id = 0;
10027 u32 decap_vrf_id = 0;
10032 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10034 if (unformat (line_input, "del"))
10036 else if (unformat (line_input, "local %U",
10037 unformat_ip4_address, &local4))
10042 else if (unformat (line_input, "remote %U",
10043 unformat_ip4_address, &remote4))
10048 else if (unformat (line_input, "local %U",
10049 unformat_ip6_address, &local6))
10054 else if (unformat (line_input, "remote %U",
10055 unformat_ip6_address, &remote6))
10060 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
10062 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
10064 else if (unformat (line_input, "vni %d", &vni))
10066 else if (unformat (line_input, "next-ip4"))
10068 else if (unformat (line_input, "next-ip6"))
10070 else if (unformat (line_input, "next-ethernet"))
10072 else if (unformat (line_input, "next-nsh"))
10076 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
10081 if (local_set == 0)
10083 errmsg ("tunnel local address not specified\n");
10086 if (remote_set == 0)
10088 errmsg ("tunnel remote address not specified\n");
10091 if (ipv4_set && ipv6_set)
10093 errmsg ("both IPv4 and IPv6 addresses specified");
10099 errmsg ("vni not specified\n");
10103 M (VXLAN_GPE_ADD_DEL_TUNNEL, vxlan_gpe_add_del_tunnel);
10108 clib_memcpy (&mp->local, &local6, sizeof (local6));
10109 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
10113 clib_memcpy (&mp->local, &local4, sizeof (local4));
10114 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
10117 mp->encap_vrf_id = ntohl (encap_vrf_id);
10118 mp->decap_vrf_id = ntohl (decap_vrf_id);
10119 mp->protocol = ntohl (protocol);
10120 mp->vni = ntohl (vni);
10121 mp->is_add = is_add;
10122 mp->is_ipv6 = ipv6_set;
10130 static void vl_api_vxlan_gpe_tunnel_details_t_handler
10131 (vl_api_vxlan_gpe_tunnel_details_t * mp)
10133 vat_main_t *vam = &vat_main;
10135 fformat (vam->ofp, "%11d%24U%24U%13d%12d%14d%14d\n",
10136 ntohl (mp->sw_if_index),
10137 format_ip46_address, &(mp->local[0]),
10138 format_ip46_address, &(mp->remote[0]),
10140 ntohl (mp->protocol),
10141 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
10144 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
10145 (vl_api_vxlan_gpe_tunnel_details_t * mp)
10147 vat_main_t *vam = &vat_main;
10148 vat_json_node_t *node = NULL;
10149 struct in_addr ip4;
10150 struct in6_addr ip6;
10152 if (VAT_JSON_ARRAY != vam->json_tree.type)
10154 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10155 vat_json_init_array (&vam->json_tree);
10157 node = vat_json_array_add (&vam->json_tree);
10159 vat_json_init_object (node);
10160 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10163 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
10164 vat_json_object_add_ip6 (node, "local", ip6);
10165 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
10166 vat_json_object_add_ip6 (node, "remote", ip6);
10170 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
10171 vat_json_object_add_ip4 (node, "local", ip4);
10172 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
10173 vat_json_object_add_ip4 (node, "remote", ip4);
10175 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
10176 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
10177 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
10178 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
10179 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
10183 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
10185 unformat_input_t *i = vam->input;
10186 vl_api_vxlan_gpe_tunnel_dump_t *mp;
10189 u8 sw_if_index_set = 0;
10191 /* Parse args required to build the message */
10192 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10194 if (unformat (i, "sw_if_index %d", &sw_if_index))
10195 sw_if_index_set = 1;
10200 if (sw_if_index_set == 0)
10205 if (!vam->json_output)
10207 fformat (vam->ofp, "%11s%24s%24s%13s%15s%14s%14s\n",
10208 "sw_if_index", "local", "remote", "vni",
10209 "protocol", "encap_vrf_id", "decap_vrf_id");
10212 /* Get list of vxlan-tunnel interfaces */
10213 M (VXLAN_GPE_TUNNEL_DUMP, vxlan_gpe_tunnel_dump);
10215 mp->sw_if_index = htonl (sw_if_index);
10219 /* Use a control ping for synchronization */
10221 vl_api_control_ping_t *mp;
10222 M (CONTROL_PING, control_ping);
10229 format_l2_fib_mac_address (u8 * s, va_list * args)
10231 u8 *a = va_arg (*args, u8 *);
10233 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
10234 a[2], a[3], a[4], a[5], a[6], a[7]);
10237 static void vl_api_l2_fib_table_entry_t_handler
10238 (vl_api_l2_fib_table_entry_t * mp)
10240 vat_main_t *vam = &vat_main;
10242 fformat (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
10244 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
10245 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
10249 static void vl_api_l2_fib_table_entry_t_handler_json
10250 (vl_api_l2_fib_table_entry_t * mp)
10252 vat_main_t *vam = &vat_main;
10253 vat_json_node_t *node = NULL;
10255 if (VAT_JSON_ARRAY != vam->json_tree.type)
10257 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10258 vat_json_init_array (&vam->json_tree);
10260 node = vat_json_array_add (&vam->json_tree);
10262 vat_json_init_object (node);
10263 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
10264 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
10265 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10266 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
10267 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
10268 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
10272 api_l2_fib_table_dump (vat_main_t * vam)
10274 unformat_input_t *i = vam->input;
10275 vl_api_l2_fib_table_dump_t *mp;
10280 /* Parse args required to build the message */
10281 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10283 if (unformat (i, "bd_id %d", &bd_id))
10289 if (bd_id_set == 0)
10291 errmsg ("missing bridge domain\n");
10296 "BD-ID Mac Address sw-ndx Static Filter BVI\n");
10298 /* Get list of l2 fib entries */
10299 M (L2_FIB_TABLE_DUMP, l2_fib_table_dump);
10301 mp->bd_id = ntohl (bd_id);
10304 /* Use a control ping for synchronization */
10306 vl_api_control_ping_t *mp;
10307 M (CONTROL_PING, control_ping);
10315 api_interface_name_renumber (vat_main_t * vam)
10317 unformat_input_t *line_input = vam->input;
10318 vl_api_interface_name_renumber_t *mp;
10319 u32 sw_if_index = ~0;
10321 u32 new_show_dev_instance = ~0;
10323 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10325 if (unformat (line_input, "%U", unformat_sw_if_index, vam,
10328 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
10330 else if (unformat (line_input, "new_show_dev_instance %d",
10331 &new_show_dev_instance))
10337 if (sw_if_index == ~0)
10339 errmsg ("missing interface name or sw_if_index\n");
10343 if (new_show_dev_instance == ~0)
10345 errmsg ("missing new_show_dev_instance\n");
10349 M (INTERFACE_NAME_RENUMBER, interface_name_renumber);
10351 mp->sw_if_index = ntohl (sw_if_index);
10352 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
10359 api_want_ip4_arp_events (vat_main_t * vam)
10361 unformat_input_t *line_input = vam->input;
10362 vl_api_want_ip4_arp_events_t *mp;
10364 ip4_address_t address;
10365 int address_set = 0;
10366 u32 enable_disable = 1;
10368 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10370 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
10372 else if (unformat (line_input, "del"))
10373 enable_disable = 0;
10378 if (address_set == 0)
10380 errmsg ("missing addresses\n");
10384 M (WANT_IP4_ARP_EVENTS, want_ip4_arp_events);
10385 mp->enable_disable = enable_disable;
10386 mp->pid = getpid ();
10387 mp->address = address.as_u32;
10394 api_want_ip6_nd_events (vat_main_t * vam)
10396 unformat_input_t *line_input = vam->input;
10397 vl_api_want_ip6_nd_events_t *mp;
10399 ip6_address_t address;
10400 int address_set = 0;
10401 u32 enable_disable = 1;
10403 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10405 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
10407 else if (unformat (line_input, "del"))
10408 enable_disable = 0;
10413 if (address_set == 0)
10415 errmsg ("missing addresses\n");
10419 M (WANT_IP6_ND_EVENTS, want_ip6_nd_events);
10420 mp->enable_disable = enable_disable;
10421 mp->pid = getpid ();
10422 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
10429 api_input_acl_set_interface (vat_main_t * vam)
10431 unformat_input_t *i = vam->input;
10432 vl_api_input_acl_set_interface_t *mp;
10435 int sw_if_index_set;
10436 u32 ip4_table_index = ~0;
10437 u32 ip6_table_index = ~0;
10438 u32 l2_table_index = ~0;
10441 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10443 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10444 sw_if_index_set = 1;
10445 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10446 sw_if_index_set = 1;
10447 else if (unformat (i, "del"))
10449 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10451 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10453 else if (unformat (i, "l2-table %d", &l2_table_index))
10457 clib_warning ("parse error '%U'", format_unformat_error, i);
10462 if (sw_if_index_set == 0)
10464 errmsg ("missing interface name or sw_if_index\n");
10468 M (INPUT_ACL_SET_INTERFACE, input_acl_set_interface);
10470 mp->sw_if_index = ntohl (sw_if_index);
10471 mp->ip4_table_index = ntohl (ip4_table_index);
10472 mp->ip6_table_index = ntohl (ip6_table_index);
10473 mp->l2_table_index = ntohl (l2_table_index);
10474 mp->is_add = is_add;
10483 api_ip_address_dump (vat_main_t * vam)
10485 unformat_input_t *i = vam->input;
10486 vl_api_ip_address_dump_t *mp;
10487 u32 sw_if_index = ~0;
10488 u8 sw_if_index_set = 0;
10493 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10495 if (unformat (i, "sw_if_index %d", &sw_if_index))
10496 sw_if_index_set = 1;
10497 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10498 sw_if_index_set = 1;
10499 else if (unformat (i, "ipv4"))
10501 else if (unformat (i, "ipv6"))
10507 if (ipv4_set && ipv6_set)
10509 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
10513 if ((!ipv4_set) && (!ipv6_set))
10515 errmsg ("no ipv4 nor ipv6 flag set\n");
10519 if (sw_if_index_set == 0)
10521 errmsg ("missing interface name or sw_if_index\n");
10525 vam->current_sw_if_index = sw_if_index;
10526 vam->is_ipv6 = ipv6_set;
10528 M (IP_ADDRESS_DUMP, ip_address_dump);
10529 mp->sw_if_index = ntohl (sw_if_index);
10530 mp->is_ipv6 = ipv6_set;
10533 /* Use a control ping for synchronization */
10535 vl_api_control_ping_t *mp;
10536 M (CONTROL_PING, control_ping);
10543 api_ip_dump (vat_main_t * vam)
10545 vl_api_ip_dump_t *mp;
10546 unformat_input_t *in = vam->input;
10553 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
10555 if (unformat (in, "ipv4"))
10557 else if (unformat (in, "ipv6"))
10563 if (ipv4_set && ipv6_set)
10565 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
10569 if ((!ipv4_set) && (!ipv6_set))
10571 errmsg ("no ipv4 nor ipv6 flag set\n");
10575 is_ipv6 = ipv6_set;
10576 vam->is_ipv6 = is_ipv6;
10578 /* free old data */
10579 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
10581 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
10583 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
10585 M (IP_DUMP, ip_dump);
10586 mp->is_ipv6 = ipv6_set;
10589 /* Use a control ping for synchronization */
10591 vl_api_control_ping_t *mp;
10592 M (CONTROL_PING, control_ping);
10599 api_ipsec_spd_add_del (vat_main_t * vam)
10602 unformat_input_t *i = vam->input;
10603 vl_api_ipsec_spd_add_del_t *mp;
10608 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10610 if (unformat (i, "spd_id %d", &spd_id))
10612 else if (unformat (i, "del"))
10616 clib_warning ("parse error '%U'", format_unformat_error, i);
10622 errmsg ("spd_id must be set\n");
10626 M (IPSEC_SPD_ADD_DEL, ipsec_spd_add_del);
10628 mp->spd_id = ntohl (spd_id);
10629 mp->is_add = is_add;
10636 clib_warning ("unsupported (no dpdk)");
10642 api_ipsec_interface_add_del_spd (vat_main_t * vam)
10645 unformat_input_t *i = vam->input;
10646 vl_api_ipsec_interface_add_del_spd_t *mp;
10649 u8 sw_if_index_set = 0;
10650 u32 spd_id = (u32) ~ 0;
10653 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10655 if (unformat (i, "del"))
10657 else if (unformat (i, "spd_id %d", &spd_id))
10659 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10660 sw_if_index_set = 1;
10661 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10662 sw_if_index_set = 1;
10665 clib_warning ("parse error '%U'", format_unformat_error, i);
10671 if (spd_id == (u32) ~ 0)
10673 errmsg ("spd_id must be set\n");
10677 if (sw_if_index_set == 0)
10679 errmsg ("missing interface name or sw_if_index\n");
10683 M (IPSEC_INTERFACE_ADD_DEL_SPD, ipsec_interface_add_del_spd);
10685 mp->spd_id = ntohl (spd_id);
10686 mp->sw_if_index = ntohl (sw_if_index);
10687 mp->is_add = is_add;
10694 clib_warning ("unsupported (no dpdk)");
10700 api_ipsec_spd_add_del_entry (vat_main_t * vam)
10703 unformat_input_t *i = vam->input;
10704 vl_api_ipsec_spd_add_del_entry_t *mp;
10706 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
10707 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
10709 u32 rport_start = 0, rport_stop = (u32) ~ 0;
10710 u32 lport_start = 0, lport_stop = (u32) ~ 0;
10711 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
10712 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
10714 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
10715 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
10716 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
10717 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
10718 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
10719 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
10721 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10723 if (unformat (i, "del"))
10725 if (unformat (i, "outbound"))
10727 if (unformat (i, "inbound"))
10729 else if (unformat (i, "spd_id %d", &spd_id))
10731 else if (unformat (i, "sa_id %d", &sa_id))
10733 else if (unformat (i, "priority %d", &priority))
10735 else if (unformat (i, "protocol %d", &protocol))
10737 else if (unformat (i, "lport_start %d", &lport_start))
10739 else if (unformat (i, "lport_stop %d", &lport_stop))
10741 else if (unformat (i, "rport_start %d", &rport_start))
10743 else if (unformat (i, "rport_stop %d", &rport_stop))
10747 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
10753 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
10760 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
10766 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
10773 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
10779 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
10786 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
10792 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
10798 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
10800 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
10802 clib_warning ("unsupported action: 'resolve'");
10808 clib_warning ("parse error '%U'", format_unformat_error, i);
10814 M (IPSEC_SPD_ADD_DEL_ENTRY, ipsec_spd_add_del_entry);
10816 mp->spd_id = ntohl (spd_id);
10817 mp->priority = ntohl (priority);
10818 mp->is_outbound = is_outbound;
10820 mp->is_ipv6 = is_ipv6;
10821 if (is_ipv6 || is_ip_any)
10823 clib_memcpy (mp->remote_address_start, &raddr6_start,
10824 sizeof (ip6_address_t));
10825 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
10826 sizeof (ip6_address_t));
10827 clib_memcpy (mp->local_address_start, &laddr6_start,
10828 sizeof (ip6_address_t));
10829 clib_memcpy (mp->local_address_stop, &laddr6_stop,
10830 sizeof (ip6_address_t));
10834 clib_memcpy (mp->remote_address_start, &raddr4_start,
10835 sizeof (ip4_address_t));
10836 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
10837 sizeof (ip4_address_t));
10838 clib_memcpy (mp->local_address_start, &laddr4_start,
10839 sizeof (ip4_address_t));
10840 clib_memcpy (mp->local_address_stop, &laddr4_stop,
10841 sizeof (ip4_address_t));
10843 mp->protocol = (u8) protocol;
10844 mp->local_port_start = ntohs ((u16) lport_start);
10845 mp->local_port_stop = ntohs ((u16) lport_stop);
10846 mp->remote_port_start = ntohs ((u16) rport_start);
10847 mp->remote_port_stop = ntohs ((u16) rport_stop);
10848 mp->policy = (u8) policy;
10849 mp->sa_id = ntohl (sa_id);
10850 mp->is_add = is_add;
10851 mp->is_ip_any = is_ip_any;
10857 clib_warning ("unsupported (no dpdk)");
10863 api_ipsec_sad_add_del_entry (vat_main_t * vam)
10866 unformat_input_t *i = vam->input;
10867 vl_api_ipsec_sad_add_del_entry_t *mp;
10869 u32 sad_id = 0, spi = 0;
10870 u8 *ck = 0, *ik = 0;
10873 u8 protocol = IPSEC_PROTOCOL_AH;
10874 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
10875 u32 crypto_alg = 0, integ_alg = 0;
10876 ip4_address_t tun_src4;
10877 ip4_address_t tun_dst4;
10878 ip6_address_t tun_src6;
10879 ip6_address_t tun_dst6;
10881 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10883 if (unformat (i, "del"))
10885 else if (unformat (i, "sad_id %d", &sad_id))
10887 else if (unformat (i, "spi %d", &spi))
10889 else if (unformat (i, "esp"))
10890 protocol = IPSEC_PROTOCOL_ESP;
10891 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
10894 is_tunnel_ipv6 = 0;
10896 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
10899 is_tunnel_ipv6 = 0;
10901 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
10904 is_tunnel_ipv6 = 1;
10906 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
10909 is_tunnel_ipv6 = 1;
10913 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
10915 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
10916 crypto_alg > IPSEC_INTEG_ALG_SHA_512_256)
10918 clib_warning ("unsupported crypto-alg: '%U'",
10919 format_ipsec_crypto_alg, crypto_alg);
10923 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
10927 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
10929 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
10930 integ_alg > IPSEC_INTEG_ALG_SHA_512_256)
10932 clib_warning ("unsupported integ-alg: '%U'",
10933 format_ipsec_integ_alg, integ_alg);
10937 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
10941 clib_warning ("parse error '%U'", format_unformat_error, i);
10947 M (IPSEC_SAD_ADD_DEL_ENTRY, ipsec_sad_add_del_entry);
10949 mp->sad_id = ntohl (sad_id);
10950 mp->is_add = is_add;
10951 mp->protocol = protocol;
10952 mp->spi = ntohl (spi);
10953 mp->is_tunnel = is_tunnel;
10954 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
10955 mp->crypto_algorithm = crypto_alg;
10956 mp->integrity_algorithm = integ_alg;
10957 mp->crypto_key_length = vec_len (ck);
10958 mp->integrity_key_length = vec_len (ik);
10960 if (mp->crypto_key_length > sizeof (mp->crypto_key))
10961 mp->crypto_key_length = sizeof (mp->crypto_key);
10963 if (mp->integrity_key_length > sizeof (mp->integrity_key))
10964 mp->integrity_key_length = sizeof (mp->integrity_key);
10967 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
10969 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
10973 if (is_tunnel_ipv6)
10975 clib_memcpy (mp->tunnel_src_address, &tun_src6,
10976 sizeof (ip6_address_t));
10977 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
10978 sizeof (ip6_address_t));
10982 clib_memcpy (mp->tunnel_src_address, &tun_src4,
10983 sizeof (ip4_address_t));
10984 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
10985 sizeof (ip4_address_t));
10994 clib_warning ("unsupported (no dpdk)");
11000 api_ipsec_sa_set_key (vat_main_t * vam)
11003 unformat_input_t *i = vam->input;
11004 vl_api_ipsec_sa_set_key_t *mp;
11007 u8 *ck = 0, *ik = 0;
11009 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11011 if (unformat (i, "sa_id %d", &sa_id))
11013 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
11015 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
11019 clib_warning ("parse error '%U'", format_unformat_error, i);
11024 M (IPSEC_SA_SET_KEY, ipsec_set_sa_key);
11026 mp->sa_id = ntohl (sa_id);
11027 mp->crypto_key_length = vec_len (ck);
11028 mp->integrity_key_length = vec_len (ik);
11030 if (mp->crypto_key_length > sizeof (mp->crypto_key))
11031 mp->crypto_key_length = sizeof (mp->crypto_key);
11033 if (mp->integrity_key_length > sizeof (mp->integrity_key))
11034 mp->integrity_key_length = sizeof (mp->integrity_key);
11037 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
11039 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
11046 clib_warning ("unsupported (no dpdk)");
11052 api_ikev2_profile_add_del (vat_main_t * vam)
11055 unformat_input_t *i = vam->input;
11056 vl_api_ikev2_profile_add_del_t *mp;
11061 const char *valid_chars = "a-zA-Z0-9_";
11063 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11065 if (unformat (i, "del"))
11067 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11068 vec_add1 (name, 0);
11071 errmsg ("parse error '%U'", format_unformat_error, i);
11076 if (!vec_len (name))
11078 errmsg ("profile name must be specified");
11082 if (vec_len (name) > 64)
11084 errmsg ("profile name too long");
11088 M (IKEV2_PROFILE_ADD_DEL, ikev2_profile_add_del);
11090 clib_memcpy (mp->name, name, vec_len (name));
11091 mp->is_add = is_add;
11099 clib_warning ("unsupported (no dpdk)");
11105 api_ikev2_profile_set_auth (vat_main_t * vam)
11108 unformat_input_t *i = vam->input;
11109 vl_api_ikev2_profile_set_auth_t *mp;
11113 u32 auth_method = 0;
11116 const char *valid_chars = "a-zA-Z0-9_";
11118 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11120 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11121 vec_add1 (name, 0);
11122 else if (unformat (i, "auth_method %U",
11123 unformat_ikev2_auth_method, &auth_method))
11125 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
11127 else if (unformat (i, "auth_data %v", &data))
11131 errmsg ("parse error '%U'", format_unformat_error, i);
11136 if (!vec_len (name))
11138 errmsg ("profile name must be specified");
11142 if (vec_len (name) > 64)
11144 errmsg ("profile name too long");
11148 if (!vec_len (data))
11150 errmsg ("auth_data must be specified");
11156 errmsg ("auth_method must be specified");
11160 M (IKEV2_PROFILE_SET_AUTH, ikev2_profile_set_auth);
11162 mp->is_hex = is_hex;
11163 mp->auth_method = (u8) auth_method;
11164 mp->data_len = vec_len (data);
11165 clib_memcpy (mp->name, name, vec_len (name));
11166 clib_memcpy (mp->data, data, vec_len (data));
11175 clib_warning ("unsupported (no dpdk)");
11181 api_ikev2_profile_set_id (vat_main_t * vam)
11184 unformat_input_t *i = vam->input;
11185 vl_api_ikev2_profile_set_id_t *mp;
11193 const char *valid_chars = "a-zA-Z0-9_";
11195 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11197 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11198 vec_add1 (name, 0);
11199 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
11201 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
11203 data = vec_new (u8, 4);
11204 clib_memcpy (data, ip4.as_u8, 4);
11206 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
11208 else if (unformat (i, "id_data %v", &data))
11210 else if (unformat (i, "local"))
11212 else if (unformat (i, "remote"))
11216 errmsg ("parse error '%U'", format_unformat_error, i);
11221 if (!vec_len (name))
11223 errmsg ("profile name must be specified");
11227 if (vec_len (name) > 64)
11229 errmsg ("profile name too long");
11233 if (!vec_len (data))
11235 errmsg ("id_data must be specified");
11241 errmsg ("id_type must be specified");
11245 M (IKEV2_PROFILE_SET_ID, ikev2_profile_set_id);
11247 mp->is_local = is_local;
11248 mp->id_type = (u8) id_type;
11249 mp->data_len = vec_len (data);
11250 clib_memcpy (mp->name, name, vec_len (name));
11251 clib_memcpy (mp->data, data, vec_len (data));
11260 clib_warning ("unsupported (no dpdk)");
11266 api_ikev2_profile_set_ts (vat_main_t * vam)
11269 unformat_input_t *i = vam->input;
11270 vl_api_ikev2_profile_set_ts_t *mp;
11274 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
11275 ip4_address_t start_addr, end_addr;
11277 const char *valid_chars = "a-zA-Z0-9_";
11279 start_addr.as_u32 = 0;
11280 end_addr.as_u32 = (u32) ~ 0;
11282 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11284 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11285 vec_add1 (name, 0);
11286 else if (unformat (i, "protocol %d", &proto))
11288 else if (unformat (i, "start_port %d", &start_port))
11290 else if (unformat (i, "end_port %d", &end_port))
11293 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
11295 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
11297 else if (unformat (i, "local"))
11299 else if (unformat (i, "remote"))
11303 errmsg ("parse error '%U'", format_unformat_error, i);
11308 if (!vec_len (name))
11310 errmsg ("profile name must be specified");
11314 if (vec_len (name) > 64)
11316 errmsg ("profile name too long");
11320 M (IKEV2_PROFILE_SET_TS, ikev2_profile_set_ts);
11322 mp->is_local = is_local;
11323 mp->proto = (u8) proto;
11324 mp->start_port = (u16) start_port;
11325 mp->end_port = (u16) end_port;
11326 mp->start_addr = start_addr.as_u32;
11327 mp->end_addr = end_addr.as_u32;
11328 clib_memcpy (mp->name, name, vec_len (name));
11336 clib_warning ("unsupported (no dpdk)");
11342 api_ikev2_set_local_key (vat_main_t * vam)
11345 unformat_input_t *i = vam->input;
11346 vl_api_ikev2_set_local_key_t *mp;
11350 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11352 if (unformat (i, "file %v", &file))
11353 vec_add1 (file, 0);
11356 errmsg ("parse error '%U'", format_unformat_error, i);
11361 if (!vec_len (file))
11363 errmsg ("RSA key file must be specified");
11367 if (vec_len (file) > 256)
11369 errmsg ("file name too long");
11373 M (IKEV2_SET_LOCAL_KEY, ikev2_set_local_key);
11375 clib_memcpy (mp->key_file, file, vec_len (file));
11383 clib_warning ("unsupported (no dpdk)");
11392 api_map_add_domain (vat_main_t * vam)
11394 unformat_input_t *i = vam->input;
11395 vl_api_map_add_domain_t *mp;
11398 ip4_address_t ip4_prefix;
11399 ip6_address_t ip6_prefix;
11400 ip6_address_t ip6_src;
11401 u32 num_m_args = 0;
11402 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
11403 0, psid_length = 0;
11404 u8 is_translation = 0;
11406 u32 ip6_src_len = 128;
11408 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11410 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
11411 &ip4_prefix, &ip4_prefix_len))
11413 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
11414 &ip6_prefix, &ip6_prefix_len))
11418 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
11421 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
11423 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
11425 else if (unformat (i, "psid-offset %d", &psid_offset))
11427 else if (unformat (i, "psid-len %d", &psid_length))
11429 else if (unformat (i, "mtu %d", &mtu))
11431 else if (unformat (i, "map-t"))
11432 is_translation = 1;
11435 clib_warning ("parse error '%U'", format_unformat_error, i);
11440 if (num_m_args < 3)
11442 errmsg ("mandatory argument(s) missing\n");
11446 /* Construct the API message */
11447 M (MAP_ADD_DOMAIN, map_add_domain);
11449 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
11450 mp->ip4_prefix_len = ip4_prefix_len;
11452 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
11453 mp->ip6_prefix_len = ip6_prefix_len;
11455 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
11456 mp->ip6_src_prefix_len = ip6_src_len;
11458 mp->ea_bits_len = ea_bits_len;
11459 mp->psid_offset = psid_offset;
11460 mp->psid_length = psid_length;
11461 mp->is_translation = is_translation;
11462 mp->mtu = htons (mtu);
11467 /* Wait for a reply, return good/bad news */
11472 api_map_del_domain (vat_main_t * vam)
11474 unformat_input_t *i = vam->input;
11475 vl_api_map_del_domain_t *mp;
11478 u32 num_m_args = 0;
11481 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11483 if (unformat (i, "index %d", &index))
11487 clib_warning ("parse error '%U'", format_unformat_error, i);
11492 if (num_m_args != 1)
11494 errmsg ("mandatory argument(s) missing\n");
11498 /* Construct the API message */
11499 M (MAP_DEL_DOMAIN, map_del_domain);
11501 mp->index = ntohl (index);
11506 /* Wait for a reply, return good/bad news */
11511 api_map_add_del_rule (vat_main_t * vam)
11513 unformat_input_t *i = vam->input;
11514 vl_api_map_add_del_rule_t *mp;
11517 ip6_address_t ip6_dst;
11518 u32 num_m_args = 0, index, psid = 0;
11520 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11522 if (unformat (i, "index %d", &index))
11524 else if (unformat (i, "psid %d", &psid))
11526 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
11528 else if (unformat (i, "del"))
11534 clib_warning ("parse error '%U'", format_unformat_error, i);
11539 /* Construct the API message */
11540 M (MAP_ADD_DEL_RULE, map_add_del_rule);
11542 mp->index = ntohl (index);
11543 mp->is_add = is_add;
11544 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
11545 mp->psid = ntohs (psid);
11550 /* Wait for a reply, return good/bad news */
11555 api_map_domain_dump (vat_main_t * vam)
11557 vl_api_map_domain_dump_t *mp;
11560 /* Construct the API message */
11561 M (MAP_DOMAIN_DUMP, map_domain_dump);
11566 /* Use a control ping for synchronization */
11568 vl_api_control_ping_t *mp;
11569 M (CONTROL_PING, control_ping);
11576 api_map_rule_dump (vat_main_t * vam)
11578 unformat_input_t *i = vam->input;
11579 vl_api_map_rule_dump_t *mp;
11581 u32 domain_index = ~0;
11583 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11585 if (unformat (i, "index %u", &domain_index))
11591 if (domain_index == ~0)
11593 clib_warning ("parse error: domain index expected");
11597 /* Construct the API message */
11598 M (MAP_RULE_DUMP, map_rule_dump);
11600 mp->domain_index = htonl (domain_index);
11605 /* Use a control ping for synchronization */
11607 vl_api_control_ping_t *mp;
11608 M (CONTROL_PING, control_ping);
11614 static void vl_api_map_add_domain_reply_t_handler
11615 (vl_api_map_add_domain_reply_t * mp)
11617 vat_main_t *vam = &vat_main;
11618 i32 retval = ntohl (mp->retval);
11620 if (vam->async_mode)
11622 vam->async_errors += (retval < 0);
11626 vam->retval = retval;
11627 vam->result_ready = 1;
11631 static void vl_api_map_add_domain_reply_t_handler_json
11632 (vl_api_map_add_domain_reply_t * mp)
11634 vat_main_t *vam = &vat_main;
11635 vat_json_node_t node;
11637 vat_json_init_object (&node);
11638 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
11639 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
11641 vat_json_print (vam->ofp, &node);
11642 vat_json_free (&node);
11644 vam->retval = ntohl (mp->retval);
11645 vam->result_ready = 1;
11649 api_get_first_msg_id (vat_main_t * vam)
11651 vl_api_get_first_msg_id_t *mp;
11653 unformat_input_t *i = vam->input;
11657 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11659 if (unformat (i, "client %s", &name))
11667 errmsg ("missing client name\n");
11670 vec_add1 (name, 0);
11672 if (vec_len (name) > 63)
11674 errmsg ("client name too long\n");
11678 M (GET_FIRST_MSG_ID, get_first_msg_id);
11679 clib_memcpy (mp->name, name, vec_len (name));
11687 api_cop_interface_enable_disable (vat_main_t * vam)
11689 unformat_input_t *line_input = vam->input;
11690 vl_api_cop_interface_enable_disable_t *mp;
11692 u32 sw_if_index = ~0;
11693 u8 enable_disable = 1;
11695 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11697 if (unformat (line_input, "disable"))
11698 enable_disable = 0;
11699 if (unformat (line_input, "enable"))
11700 enable_disable = 1;
11701 else if (unformat (line_input, "%U", unformat_sw_if_index,
11702 vam, &sw_if_index))
11704 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11710 if (sw_if_index == ~0)
11712 errmsg ("missing interface name or sw_if_index\n");
11716 /* Construct the API message */
11717 M (COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable);
11718 mp->sw_if_index = ntohl (sw_if_index);
11719 mp->enable_disable = enable_disable;
11723 /* Wait for the reply */
11728 api_cop_whitelist_enable_disable (vat_main_t * vam)
11730 unformat_input_t *line_input = vam->input;
11731 vl_api_cop_whitelist_enable_disable_t *mp;
11733 u32 sw_if_index = ~0;
11734 u8 ip4 = 0, ip6 = 0, default_cop = 0;
11737 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11739 if (unformat (line_input, "ip4"))
11741 else if (unformat (line_input, "ip6"))
11743 else if (unformat (line_input, "default"))
11745 else if (unformat (line_input, "%U", unformat_sw_if_index,
11746 vam, &sw_if_index))
11748 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11750 else if (unformat (line_input, "fib-id %d", &fib_id))
11756 if (sw_if_index == ~0)
11758 errmsg ("missing interface name or sw_if_index\n");
11762 /* Construct the API message */
11763 M (COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable);
11764 mp->sw_if_index = ntohl (sw_if_index);
11765 mp->fib_id = ntohl (fib_id);
11768 mp->default_cop = default_cop;
11772 /* Wait for the reply */
11777 api_get_node_graph (vat_main_t * vam)
11779 vl_api_get_node_graph_t *mp;
11782 M (GET_NODE_GRAPH, get_node_graph);
11786 /* Wait for the reply */
11791 /** Used for parsing LISP eids */
11792 typedef CLIB_PACKED(struct{
11793 u8 addr[16]; /**< eid address */
11794 u32 len; /**< prefix length if IP */
11795 u8 type; /**< type of eid */
11800 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
11802 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
11804 memset (a, 0, sizeof (a[0]));
11806 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
11808 a->type = 0; /* ipv4 type */
11810 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
11812 a->type = 1; /* ipv6 type */
11814 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
11816 a->type = 2; /* mac type */
11823 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
11832 lisp_eid_size_vat (u8 type)
11847 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
11849 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
11853 /** Used for transferring locators via VPP API */
11854 typedef CLIB_PACKED(struct
11856 u32 sw_if_index; /**< locator sw_if_index */
11857 u8 priority; /**< locator priority */
11858 u8 weight; /**< locator weight */
11863 api_lisp_add_del_locator_set (vat_main_t * vam)
11865 unformat_input_t *input = vam->input;
11866 vl_api_lisp_add_del_locator_set_t *mp;
11869 u8 *locator_set_name = NULL;
11870 u8 locator_set_name_set = 0;
11871 ls_locator_t locator, *locators = 0;
11872 u32 sw_if_index, priority, weight;
11874 /* Parse args required to build the message */
11875 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11877 if (unformat (input, "del"))
11881 else if (unformat (input, "locator-set %s", &locator_set_name))
11883 locator_set_name_set = 1;
11885 else if (unformat (input, "sw_if_index %u p %u w %u",
11886 &sw_if_index, &priority, &weight))
11888 locator.sw_if_index = htonl (sw_if_index);
11889 locator.priority = priority;
11890 locator.weight = weight;
11891 vec_add1 (locators, locator);
11893 else if (unformat (input, "iface %U p %u w %u", unformat_sw_if_index,
11894 vam, &sw_if_index, &priority, &weight))
11896 locator.sw_if_index = htonl (sw_if_index);
11897 locator.priority = priority;
11898 locator.weight = weight;
11899 vec_add1 (locators, locator);
11905 if (locator_set_name_set == 0)
11907 errmsg ("missing locator-set name");
11908 vec_free (locators);
11912 if (vec_len (locator_set_name) > 64)
11914 errmsg ("locator-set name too long\n");
11915 vec_free (locator_set_name);
11916 vec_free (locators);
11919 vec_add1 (locator_set_name, 0);
11921 /* Construct the API message */
11922 M (LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set);
11924 mp->is_add = is_add;
11925 clib_memcpy (mp->locator_set_name, locator_set_name,
11926 vec_len (locator_set_name));
11927 vec_free (locator_set_name);
11929 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
11931 clib_memcpy (mp->locators, locators,
11932 (sizeof (ls_locator_t) * vec_len (locators)));
11933 vec_free (locators);
11938 /* Wait for a reply... */
11946 api_lisp_add_del_locator (vat_main_t * vam)
11948 unformat_input_t *input = vam->input;
11949 vl_api_lisp_add_del_locator_t *mp;
11951 u32 tmp_if_index = ~0;
11952 u32 sw_if_index = ~0;
11953 u8 sw_if_index_set = 0;
11954 u8 sw_if_index_if_name_set = 0;
11956 u8 priority_set = 0;
11960 u8 *locator_set_name = NULL;
11961 u8 locator_set_name_set = 0;
11963 /* Parse args required to build the message */
11964 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11966 if (unformat (input, "del"))
11970 else if (unformat (input, "locator-set %s", &locator_set_name))
11972 locator_set_name_set = 1;
11974 else if (unformat (input, "iface %U", unformat_sw_if_index, vam,
11977 sw_if_index_if_name_set = 1;
11978 sw_if_index = tmp_if_index;
11980 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
11982 sw_if_index_set = 1;
11983 sw_if_index = tmp_if_index;
11985 else if (unformat (input, "p %d", &priority))
11989 else if (unformat (input, "w %d", &weight))
11997 if (locator_set_name_set == 0)
11999 errmsg ("missing locator-set name");
12003 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
12005 errmsg ("missing sw_if_index");
12006 vec_free (locator_set_name);
12010 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
12012 errmsg ("cannot use both params interface name and sw_if_index");
12013 vec_free (locator_set_name);
12017 if (priority_set == 0)
12019 errmsg ("missing locator-set priority\n");
12020 vec_free (locator_set_name);
12024 if (weight_set == 0)
12026 errmsg ("missing locator-set weight\n");
12027 vec_free (locator_set_name);
12031 if (vec_len (locator_set_name) > 64)
12033 errmsg ("locator-set name too long\n");
12034 vec_free (locator_set_name);
12037 vec_add1 (locator_set_name, 0);
12039 /* Construct the API message */
12040 M (LISP_ADD_DEL_LOCATOR, lisp_add_del_locator);
12042 mp->is_add = is_add;
12043 mp->sw_if_index = ntohl (sw_if_index);
12044 mp->priority = priority;
12045 mp->weight = weight;
12046 clib_memcpy (mp->locator_set_name, locator_set_name,
12047 vec_len (locator_set_name));
12048 vec_free (locator_set_name);
12053 /* Wait for a reply... */
12061 api_lisp_add_del_local_eid (vat_main_t * vam)
12063 unformat_input_t *input = vam->input;
12064 vl_api_lisp_add_del_local_eid_t *mp;
12068 lisp_eid_vat_t _eid, *eid = &_eid;
12069 u8 *locator_set_name = 0;
12070 u8 locator_set_name_set = 0;
12073 /* Parse args required to build the message */
12074 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12076 if (unformat (input, "del"))
12080 else if (unformat (input, "vni %d", &vni))
12084 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
12088 else if (unformat (input, "locator-set %s", &locator_set_name))
12090 locator_set_name_set = 1;
12096 if (locator_set_name_set == 0)
12098 errmsg ("missing locator-set name\n");
12104 errmsg ("EID address not set!");
12105 vec_free (locator_set_name);
12109 if (vec_len (locator_set_name) > 64)
12111 errmsg ("locator-set name too long\n");
12112 vec_free (locator_set_name);
12115 vec_add1 (locator_set_name, 0);
12117 /* Construct the API message */
12118 M (LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid);
12120 mp->is_add = is_add;
12121 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
12122 mp->eid_type = eid->type;
12123 mp->prefix_len = eid->len;
12124 mp->vni = clib_host_to_net_u32 (vni);
12125 clib_memcpy (mp->locator_set_name, locator_set_name,
12126 vec_len (locator_set_name));
12128 vec_free (locator_set_name);
12133 /* Wait for a reply... */
12141 /** Used for transferring locators via VPP API */
12142 typedef CLIB_PACKED(struct
12144 u8 is_ip4; /**< is locator an IPv4 address? */
12145 u8 priority; /**< locator priority */
12146 u8 weight; /**< locator weight */
12147 u8 addr[16]; /**< IPv4/IPv6 address */
12152 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
12154 unformat_input_t *input = vam->input;
12155 vl_api_lisp_gpe_add_del_fwd_entry_t *mp;
12158 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
12159 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
12160 u8 rmt_eid_set = 0, lcl_eid_set = 0;
12161 u32 action = ~0, p, w;
12162 ip4_address_t rmt_rloc4, lcl_rloc4;
12163 ip6_address_t rmt_rloc6, lcl_rloc6;
12164 rloc_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
12166 memset (&rloc, 0, sizeof (rloc));
12168 /* Parse args required to build the message */
12169 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12171 if (unformat (input, "del"))
12175 else if (unformat (input, "rmt_eid %U", unformat_lisp_eid_vat, rmt_eid))
12179 else if (unformat (input, "lcl_eid %U", unformat_lisp_eid_vat, lcl_eid))
12183 else if (unformat (input, "p %d w %d", &p, &w))
12187 errmsg ("No RLOC configured for setting priority/weight!");
12190 curr_rloc->priority = p;
12191 curr_rloc->weight = w;
12193 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
12194 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
12198 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
12199 rloc.priority = rloc.weight = 0;
12200 vec_add1 (lcl_locs, rloc);
12202 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
12203 vec_add1 (rmt_locs, rloc);
12204 /* priority and weight saved in rmt loc */
12205 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
12207 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
12208 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
12211 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
12212 rloc.priority = rloc.weight = 0;
12213 vec_add1 (lcl_locs, rloc);
12215 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
12216 vec_add1 (rmt_locs, rloc);
12217 /* priority and weight saved in rmt loc */
12218 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
12220 else if (unformat (input, "action %d", &action))
12226 clib_warning ("parse error '%U'", format_unformat_error, input);
12233 errmsg ("remote eid addresses not set\n");
12237 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
12239 errmsg ("eid types don't match\n");
12243 if (0 == rmt_locs && (u32) ~ 0 == action)
12245 errmsg ("action not set for negative mapping\n");
12249 /* Construct the API message */
12250 M (LISP_GPE_ADD_DEL_FWD_ENTRY, lisp_gpe_add_del_fwd_entry);
12252 mp->is_add = is_add;
12253 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
12254 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
12255 mp->eid_type = rmt_eid->type;
12256 mp->rmt_len = rmt_eid->len;
12257 mp->lcl_len = lcl_eid->len;
12258 mp->action = action;
12260 if (0 != rmt_locs && 0 != lcl_locs)
12262 mp->loc_num = vec_len (rmt_locs);
12263 clib_memcpy (mp->lcl_locs, lcl_locs,
12264 (sizeof (rloc_t) * vec_len (lcl_locs)));
12265 clib_memcpy (mp->rmt_locs, rmt_locs,
12266 (sizeof (rloc_t) * vec_len (rmt_locs)));
12268 vec_free (lcl_locs);
12269 vec_free (rmt_locs);
12274 /* Wait for a reply... */
12282 api_lisp_add_del_map_resolver (vat_main_t * vam)
12284 unformat_input_t *input = vam->input;
12285 vl_api_lisp_add_del_map_resolver_t *mp;
12290 ip4_address_t ipv4;
12291 ip6_address_t ipv6;
12293 /* Parse args required to build the message */
12294 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12296 if (unformat (input, "del"))
12300 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
12304 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
12312 if (ipv4_set && ipv6_set)
12314 errmsg ("both eid v4 and v6 addresses set\n");
12318 if (!ipv4_set && !ipv6_set)
12320 errmsg ("eid addresses not set\n");
12324 /* Construct the API message */
12325 M (LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver);
12327 mp->is_add = is_add;
12331 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
12336 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
12342 /* Wait for a reply... */
12350 api_lisp_gpe_enable_disable (vat_main_t * vam)
12352 unformat_input_t *input = vam->input;
12353 vl_api_lisp_gpe_enable_disable_t *mp;
12358 /* Parse args required to build the message */
12359 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12361 if (unformat (input, "enable"))
12366 else if (unformat (input, "disable"))
12377 errmsg ("Value not set\n");
12381 /* Construct the API message */
12382 M (LISP_GPE_ENABLE_DISABLE, lisp_gpe_enable_disable);
12389 /* Wait for a reply... */
12397 api_lisp_enable_disable (vat_main_t * vam)
12399 unformat_input_t *input = vam->input;
12400 vl_api_lisp_enable_disable_t *mp;
12405 /* Parse args required to build the message */
12406 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12408 if (unformat (input, "enable"))
12413 else if (unformat (input, "disable"))
12423 errmsg ("Value not set\n");
12427 /* Construct the API message */
12428 M (LISP_ENABLE_DISABLE, lisp_enable_disable);
12435 /* Wait for a reply... */
12443 api_show_lisp_map_request_mode (vat_main_t * vam)
12446 vl_api_show_lisp_map_request_mode_t *mp;
12448 M (SHOW_LISP_MAP_REQUEST_MODE, show_lisp_map_request_mode);
12453 /* wait for reply */
12460 api_lisp_map_request_mode (vat_main_t * vam)
12463 unformat_input_t *input = vam->input;
12464 vl_api_lisp_map_request_mode_t *mp;
12467 /* Parse args required to build the message */
12468 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12470 if (unformat (input, "dst-only"))
12472 else if (unformat (input, "src-dst"))
12476 errmsg ("parse error '%U'", format_unformat_error, input);
12481 M (LISP_MAP_REQUEST_MODE, lisp_map_request_mode);
12488 /* wait for reply */
12496 * Enable/disable LISP proxy ITR.
12498 * @param vam vpp API test context
12499 * @return return code
12502 api_lisp_pitr_set_locator_set (vat_main_t * vam)
12505 u8 ls_name_set = 0;
12506 unformat_input_t *input = vam->input;
12507 vl_api_lisp_pitr_set_locator_set_t *mp;
12511 /* Parse args required to build the message */
12512 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12514 if (unformat (input, "del"))
12516 else if (unformat (input, "locator-set %s", &ls_name))
12520 errmsg ("parse error '%U'", format_unformat_error, input);
12527 errmsg ("locator-set name not set!");
12531 M (LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set);
12533 mp->is_add = is_add;
12534 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
12535 vec_free (ls_name);
12540 /* wait for reply */
12548 api_show_lisp_pitr (vat_main_t * vam)
12550 vl_api_show_lisp_pitr_t *mp;
12553 if (!vam->json_output)
12555 fformat (vam->ofp, "%=20s\n", "lisp status:");
12558 M (SHOW_LISP_PITR, show_lisp_pitr);
12562 /* Wait for a reply... */
12570 * Add/delete mapping between vni and vrf
12573 api_lisp_eid_table_add_del_map (vat_main_t * vam)
12576 unformat_input_t *input = vam->input;
12577 vl_api_lisp_eid_table_add_del_map_t *mp;
12578 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
12579 u32 vni, vrf, bd_index;
12581 /* Parse args required to build the message */
12582 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12584 if (unformat (input, "del"))
12586 else if (unformat (input, "vrf %d", &vrf))
12588 else if (unformat (input, "bd_index %d", &bd_index))
12590 else if (unformat (input, "vni %d", &vni))
12596 if (!vni_set || (!vrf_set && !bd_index_set))
12598 errmsg ("missing arguments!");
12602 if (vrf_set && bd_index_set)
12604 errmsg ("error: both vrf and bd entered!");
12608 M (LISP_EID_TABLE_ADD_DEL_MAP, lisp_eid_table_add_del_map);
12610 mp->is_add = is_add;
12611 mp->vni = htonl (vni);
12612 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
12613 mp->is_l2 = bd_index_set;
12618 /* wait for reply */
12626 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
12628 u32 *action = va_arg (*args, u32 *);
12631 if (unformat (input, "%s", &s))
12633 if (!strcmp ((char *) s, "no-action"))
12635 else if (!strcmp ((char *) s, "natively-forward"))
12637 else if (!strcmp ((char *) s, "send-map-request"))
12639 else if (!strcmp ((char *) s, "drop"))
12643 clib_warning ("invalid action: '%s'", s);
12655 * Add/del remote mapping to/from LISP control plane
12657 * @param vam vpp API test context
12658 * @return return code
12661 api_lisp_add_del_remote_mapping (vat_main_t * vam)
12663 unformat_input_t *input = vam->input;
12664 vl_api_lisp_add_del_remote_mapping_t *mp;
12667 lisp_eid_vat_t _eid, *eid = &_eid;
12668 lisp_eid_vat_t _seid, *seid = &_seid;
12669 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
12670 u32 action = ~0, p, w;
12671 ip4_address_t rloc4;
12672 ip6_address_t rloc6;
12673 rloc_t *rlocs = 0, rloc, *curr_rloc = 0;
12675 memset (&rloc, 0, sizeof (rloc));
12677 /* Parse args required to build the message */
12678 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12680 if (unformat (input, "del-all"))
12684 else if (unformat (input, "del"))
12688 else if (unformat (input, "add"))
12692 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
12696 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
12700 else if (unformat (input, "vni %d", &vni))
12704 else if (unformat (input, "p %d w %d", &p, &w))
12708 errmsg ("No RLOC configured for setting priority/weight!");
12711 curr_rloc->priority = p;
12712 curr_rloc->weight = w;
12714 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
12717 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
12718 vec_add1 (rlocs, rloc);
12719 curr_rloc = &rlocs[vec_len (rlocs) - 1];
12721 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
12724 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
12725 vec_add1 (rlocs, rloc);
12726 curr_rloc = &rlocs[vec_len (rlocs) - 1];
12728 else if (unformat (input, "action %U",
12729 unformat_negative_mapping_action, &action))
12735 clib_warning ("parse error '%U'", format_unformat_error, input);
12742 errmsg ("missing params!");
12746 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
12748 errmsg ("no action set for negative map-reply!");
12752 M (LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping);
12753 mp->is_add = is_add;
12754 mp->vni = htonl (vni);
12755 mp->action = (u8) action;
12756 mp->is_src_dst = seid_set;
12757 mp->eid_len = eid->len;
12758 mp->seid_len = seid->len;
12759 mp->del_all = del_all;
12760 mp->eid_type = eid->type;
12761 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
12762 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
12764 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
12765 clib_memcpy (mp->rlocs, rlocs, (sizeof (rloc_t) * vec_len (rlocs)));
12771 /* Wait for a reply... */
12779 * Add/del LISP adjacency. Saves mapping in LISP control plane and updates
12780 * forwarding entries in data-plane accordingly.
12782 * @param vam vpp API test context
12783 * @return return code
12786 api_lisp_add_del_adjacency (vat_main_t * vam)
12788 unformat_input_t *input = vam->input;
12789 vl_api_lisp_add_del_adjacency_t *mp;
12792 ip4_address_t seid4, deid4;
12793 ip6_address_t seid6, deid6;
12794 u8 deid_mac[6] = { 0 };
12795 u8 seid_mac[6] = { 0 };
12796 u8 deid_type, seid_type;
12797 u32 seid_len = 0, deid_len = 0, len;
12800 seid_type = deid_type = (u8) ~ 0;
12802 /* Parse args required to build the message */
12803 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12805 if (unformat (input, "del"))
12809 else if (unformat (input, "add"))
12813 else if (unformat (input, "deid %U/%d", unformat_ip4_address,
12816 deid_type = 0; /* ipv4 */
12819 else if (unformat (input, "deid %U/%d", unformat_ip6_address,
12822 deid_type = 1; /* ipv6 */
12825 else if (unformat (input, "deid %U", unformat_ethernet_address,
12828 deid_type = 2; /* mac */
12830 else if (unformat (input, "seid %U/%d", unformat_ip4_address,
12833 seid_type = 0; /* ipv4 */
12836 else if (unformat (input, "seid %U/%d", unformat_ip6_address,
12839 seid_type = 1; /* ipv6 */
12842 else if (unformat (input, "seid %U", unformat_ethernet_address,
12845 seid_type = 2; /* mac */
12847 else if (unformat (input, "vni %d", &vni))
12853 errmsg ("parse error '%U'", format_unformat_error, input);
12858 if ((u8) ~ 0 == deid_type)
12860 errmsg ("missing params!");
12864 if (seid_type != deid_type)
12866 errmsg ("source and destination EIDs are of different types!");
12870 M (LISP_ADD_DEL_ADJACENCY, lisp_add_del_adjacency);
12871 mp->is_add = is_add;
12872 mp->vni = htonl (vni);
12873 mp->seid_len = seid_len;
12874 mp->deid_len = deid_len;
12875 mp->eid_type = deid_type;
12877 switch (mp->eid_type)
12880 clib_memcpy (mp->seid, &seid4, sizeof (seid4));
12881 clib_memcpy (mp->deid, &deid4, sizeof (deid4));
12884 clib_memcpy (mp->seid, &seid6, sizeof (seid6));
12885 clib_memcpy (mp->deid, &deid6, sizeof (deid6));
12888 clib_memcpy (mp->seid, seid_mac, 6);
12889 clib_memcpy (mp->deid, deid_mac, 6);
12892 errmsg ("unknown EID type %d!", mp->eid_type);
12899 /* Wait for a reply... */
12907 api_lisp_gpe_add_del_iface (vat_main_t * vam)
12909 unformat_input_t *input = vam->input;
12910 vl_api_lisp_gpe_add_del_iface_t *mp;
12912 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
12913 u32 dp_table = 0, vni = 0;
12915 /* Parse args required to build the message */
12916 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12918 if (unformat (input, "up"))
12923 else if (unformat (input, "down"))
12928 else if (unformat (input, "table_id %d", &dp_table))
12932 else if (unformat (input, "bd_id %d", &dp_table))
12937 else if (unformat (input, "vni %d", &vni))
12945 if (action_set == 0)
12947 errmsg ("Action not set\n");
12950 if (dp_table_set == 0 || vni_set == 0)
12952 errmsg ("vni and dp_table must be set\n");
12956 /* Construct the API message */
12957 M (LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface);
12959 mp->is_add = is_add;
12960 mp->dp_table = dp_table;
12967 /* Wait for a reply... */
12975 * Add/del map request itr rlocs from LISP control plane and updates
12977 * @param vam vpp API test context
12978 * @return return code
12981 api_lisp_add_del_map_request_itr_rlocs (vat_main_t * vam)
12983 unformat_input_t *input = vam->input;
12984 vl_api_lisp_add_del_map_request_itr_rlocs_t *mp;
12986 u8 *locator_set_name = 0;
12987 u8 locator_set_name_set = 0;
12990 /* Parse args required to build the message */
12991 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12993 if (unformat (input, "del"))
12997 else if (unformat (input, "%_%v%_", &locator_set_name))
12999 locator_set_name_set = 1;
13003 clib_warning ("parse error '%U'", format_unformat_error, input);
13008 if (is_add && !locator_set_name_set)
13010 errmsg ("itr-rloc is not set!");
13014 if (is_add && vec_len (locator_set_name) > 64)
13016 errmsg ("itr-rloc locator-set name too long\n");
13017 vec_free (locator_set_name);
13021 M (LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, lisp_add_del_map_request_itr_rlocs);
13022 mp->is_add = is_add;
13025 clib_memcpy (mp->locator_set_name, locator_set_name,
13026 vec_len (locator_set_name));
13030 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
13032 vec_free (locator_set_name);
13037 /* Wait for a reply... */
13045 api_lisp_locator_dump (vat_main_t * vam)
13047 unformat_input_t *input = vam->input;
13048 vl_api_lisp_locator_dump_t *mp;
13050 u8 is_index_set = 0, is_name_set = 0;
13054 /* Parse args required to build the message */
13055 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13057 if (unformat (input, "ls_name %_%v%_", &ls_name))
13061 else if (unformat (input, "ls_index %d", &ls_index))
13067 errmsg ("parse error '%U'", format_unformat_error, input);
13072 if (!is_index_set && !is_name_set)
13074 errmsg ("error: expected one of index or name!\n");
13078 if (is_index_set && is_name_set)
13080 errmsg ("error: only one param expected!\n");
13084 if (vec_len (ls_name) > 62)
13086 errmsg ("error: locator set name too long!");
13090 if (!vam->json_output)
13092 fformat (vam->ofp, "%=16s%=16s%=16s\n", "locator", "priority",
13096 M (LISP_LOCATOR_DUMP, lisp_locator_dump);
13097 mp->is_index_set = is_index_set;
13100 mp->ls_index = clib_host_to_net_u32 (ls_index);
13103 vec_add1 (ls_name, 0);
13104 strncpy ((char *) mp->ls_name, (char *) ls_name,
13105 sizeof (mp->ls_name) - 1);
13111 /* Use a control ping for synchronization */
13113 vl_api_control_ping_t *mp;
13114 M (CONTROL_PING, control_ping);
13117 /* Wait for a reply... */
13125 api_lisp_locator_set_dump (vat_main_t * vam)
13127 vl_api_lisp_locator_set_dump_t *mp;
13128 unformat_input_t *input = vam->input;
13132 /* Parse args required to build the message */
13133 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13135 if (unformat (input, "local"))
13139 else if (unformat (input, "remote"))
13145 errmsg ("parse error '%U'", format_unformat_error, input);
13150 if (!vam->json_output)
13152 fformat (vam->ofp, "%=10s%=15s\n", "ls_index", "ls_name");
13155 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
13157 mp->filter = filter;
13162 /* Use a control ping for synchronization */
13164 vl_api_control_ping_t *mp;
13165 M (CONTROL_PING, control_ping);
13168 /* Wait for a reply... */
13176 api_lisp_eid_table_map_dump (vat_main_t * vam)
13180 unformat_input_t *input = vam->input;
13181 vl_api_lisp_eid_table_map_dump_t *mp;
13184 /* Parse args required to build the message */
13185 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13187 if (unformat (input, "l2"))
13192 else if (unformat (input, "l3"))
13199 errmsg ("parse error '%U'", format_unformat_error, input);
13206 errmsg ("expected one of 'l2' or 'l3' parameter!\n");
13210 if (!vam->json_output)
13212 fformat (vam->ofp, "%=10s%=10s\n", "VNI", is_l2 ? "BD" : "VRF");
13215 M (LISP_EID_TABLE_MAP_DUMP, lisp_eid_table_map_dump);
13221 /* Use a control ping for synchronization */
13223 vl_api_control_ping_t *mp;
13224 M (CONTROL_PING, control_ping);
13227 /* Wait for a reply... */
13235 api_lisp_eid_table_vni_dump (vat_main_t * vam)
13237 vl_api_lisp_eid_table_vni_dump_t *mp;
13240 if (!vam->json_output)
13242 fformat (vam->ofp, "VNI\n");
13245 M (LISP_EID_TABLE_VNI_DUMP, lisp_eid_table_vni_dump);
13250 /* Use a control ping for synchronization */
13252 vl_api_control_ping_t *mp;
13253 M (CONTROL_PING, control_ping);
13256 /* Wait for a reply... */
13264 api_lisp_eid_table_dump (vat_main_t * vam)
13266 unformat_input_t *i = vam->input;
13267 vl_api_lisp_eid_table_dump_t *mp;
13269 struct in_addr ip4;
13270 struct in6_addr ip6;
13272 u8 eid_type = ~0, eid_set = 0;
13273 u32 prefix_length = ~0, t, vni = 0;
13276 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13278 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
13284 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
13290 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
13295 else if (unformat (i, "vni %d", &t))
13299 else if (unformat (i, "local"))
13303 else if (unformat (i, "remote"))
13309 errmsg ("parse error '%U'", format_unformat_error, i);
13314 if (!vam->json_output)
13316 fformat (vam->ofp, "%-35s%-20s%-30s%-20s%-s\n", "EID", "type",
13317 "ls_index", "ttl", "authoritative");
13320 M (LISP_EID_TABLE_DUMP, lisp_eid_table_dump);
13322 mp->filter = filter;
13326 mp->vni = htonl (vni);
13327 mp->eid_type = eid_type;
13331 mp->prefix_length = prefix_length;
13332 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
13335 mp->prefix_length = prefix_length;
13336 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
13339 clib_memcpy (mp->eid, mac, sizeof (mac));
13342 errmsg ("unknown EID type %d!", eid_type);
13350 /* Use a control ping for synchronization */
13352 vl_api_control_ping_t *mp;
13353 M (CONTROL_PING, control_ping);
13357 /* Wait for a reply... */
13365 api_lisp_gpe_tunnel_dump (vat_main_t * vam)
13367 vl_api_lisp_gpe_tunnel_dump_t *mp;
13370 if (!vam->json_output)
13372 fformat (vam->ofp, "%=20s%=30s%=16s%=16s%=16s%=16s"
13373 "%=16s%=16s%=16s%=16s%=16s\n",
13374 "Tunel", "Source", "Destination", "Fib encap", "Fib decap",
13375 "Decap next", "Lisp version", "Flags", "Next protocol",
13376 "ver_res", "res", "iid");
13379 M (LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump);
13383 /* Use a control ping for synchronization */
13385 vl_api_control_ping_t *mp;
13386 M (CONTROL_PING, control_ping);
13389 /* Wait for a reply... */
13397 api_lisp_map_resolver_dump (vat_main_t * vam)
13399 vl_api_lisp_map_resolver_dump_t *mp;
13402 if (!vam->json_output)
13404 fformat (vam->ofp, "%=20s\n", "Map resolver");
13407 M (LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump);
13411 /* Use a control ping for synchronization */
13413 vl_api_control_ping_t *mp;
13414 M (CONTROL_PING, control_ping);
13417 /* Wait for a reply... */
13425 api_show_lisp_status (vat_main_t * vam)
13427 vl_api_show_lisp_status_t *mp;
13430 if (!vam->json_output)
13432 fformat (vam->ofp, "%-20s%-16s\n", "lisp status", "locator-set");
13435 M (SHOW_LISP_STATUS, show_lisp_status);
13438 /* Wait for a reply... */
13446 api_lisp_get_map_request_itr_rlocs (vat_main_t * vam)
13448 vl_api_lisp_get_map_request_itr_rlocs_t *mp;
13451 if (!vam->json_output)
13453 fformat (vam->ofp, "%=20s\n", "itr-rlocs:");
13456 M (LISP_GET_MAP_REQUEST_ITR_RLOCS, lisp_get_map_request_itr_rlocs);
13459 /* Wait for a reply... */
13467 api_af_packet_create (vat_main_t * vam)
13469 unformat_input_t *i = vam->input;
13470 vl_api_af_packet_create_t *mp;
13472 u8 *host_if_name = 0;
13474 u8 random_hw_addr = 1;
13476 memset (hw_addr, 0, sizeof (hw_addr));
13478 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13480 if (unformat (i, "name %s", &host_if_name))
13481 vec_add1 (host_if_name, 0);
13482 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
13483 random_hw_addr = 0;
13488 if (!vec_len (host_if_name))
13490 errmsg ("host-interface name must be specified");
13494 if (vec_len (host_if_name) > 64)
13496 errmsg ("host-interface name too long");
13500 M (AF_PACKET_CREATE, af_packet_create);
13502 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
13503 clib_memcpy (mp->hw_addr, hw_addr, 6);
13504 mp->use_random_hw_addr = random_hw_addr;
13505 vec_free (host_if_name);
13508 W2 (fprintf (vam->ofp, " new sw_if_index = %d ", vam->sw_if_index));
13514 api_af_packet_delete (vat_main_t * vam)
13516 unformat_input_t *i = vam->input;
13517 vl_api_af_packet_delete_t *mp;
13519 u8 *host_if_name = 0;
13521 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13523 if (unformat (i, "name %s", &host_if_name))
13524 vec_add1 (host_if_name, 0);
13529 if (!vec_len (host_if_name))
13531 errmsg ("host-interface name must be specified");
13535 if (vec_len (host_if_name) > 64)
13537 errmsg ("host-interface name too long");
13541 M (AF_PACKET_DELETE, af_packet_delete);
13543 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
13544 vec_free (host_if_name);
13553 api_policer_add_del (vat_main_t * vam)
13555 unformat_input_t *i = vam->input;
13556 vl_api_policer_add_del_t *mp;
13567 u8 color_aware = 0;
13568 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
13570 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
13571 conform_action.dscp = 0;
13572 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
13573 exceed_action.dscp = 0;
13574 violate_action.action_type = SSE2_QOS_ACTION_DROP;
13575 violate_action.dscp = 0;
13577 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13579 if (unformat (i, "del"))
13581 else if (unformat (i, "name %s", &name))
13582 vec_add1 (name, 0);
13583 else if (unformat (i, "cir %u", &cir))
13585 else if (unformat (i, "eir %u", &eir))
13587 else if (unformat (i, "cb %u", &cb))
13589 else if (unformat (i, "eb %u", &eb))
13591 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
13594 else if (unformat (i, "round_type %U", unformat_policer_round_type,
13597 else if (unformat (i, "type %U", unformat_policer_type, &type))
13599 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
13602 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
13605 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
13608 else if (unformat (i, "color-aware"))
13614 if (!vec_len (name))
13616 errmsg ("policer name must be specified");
13620 if (vec_len (name) > 64)
13622 errmsg ("policer name too long");
13626 M (POLICER_ADD_DEL, policer_add_del);
13628 clib_memcpy (mp->name, name, vec_len (name));
13630 mp->is_add = is_add;
13635 mp->rate_type = rate_type;
13636 mp->round_type = round_type;
13638 mp->conform_action_type = conform_action.action_type;
13639 mp->conform_dscp = conform_action.dscp;
13640 mp->exceed_action_type = exceed_action.action_type;
13641 mp->exceed_dscp = exceed_action.dscp;
13642 mp->violate_action_type = violate_action.action_type;
13643 mp->violate_dscp = violate_action.dscp;
13644 mp->color_aware = color_aware;
13653 api_policer_dump (vat_main_t * vam)
13655 unformat_input_t *i = vam->input;
13656 vl_api_policer_dump_t *mp;
13658 u8 *match_name = 0;
13659 u8 match_name_valid = 0;
13661 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13663 if (unformat (i, "name %s", &match_name))
13665 vec_add1 (match_name, 0);
13666 match_name_valid = 1;
13672 M (POLICER_DUMP, policer_dump);
13673 mp->match_name_valid = match_name_valid;
13674 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
13675 vec_free (match_name);
13679 /* Use a control ping for synchronization */
13681 vl_api_control_ping_t *mp;
13682 M (CONTROL_PING, control_ping);
13685 /* Wait for a reply... */
13693 api_policer_classify_set_interface (vat_main_t * vam)
13695 unformat_input_t *i = vam->input;
13696 vl_api_policer_classify_set_interface_t *mp;
13699 int sw_if_index_set;
13700 u32 ip4_table_index = ~0;
13701 u32 ip6_table_index = ~0;
13702 u32 l2_table_index = ~0;
13705 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13707 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
13708 sw_if_index_set = 1;
13709 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13710 sw_if_index_set = 1;
13711 else if (unformat (i, "del"))
13713 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13715 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13717 else if (unformat (i, "l2-table %d", &l2_table_index))
13721 clib_warning ("parse error '%U'", format_unformat_error, i);
13726 if (sw_if_index_set == 0)
13728 errmsg ("missing interface name or sw_if_index\n");
13732 M (POLICER_CLASSIFY_SET_INTERFACE, policer_classify_set_interface);
13734 mp->sw_if_index = ntohl (sw_if_index);
13735 mp->ip4_table_index = ntohl (ip4_table_index);
13736 mp->ip6_table_index = ntohl (ip6_table_index);
13737 mp->l2_table_index = ntohl (l2_table_index);
13738 mp->is_add = is_add;
13747 api_policer_classify_dump (vat_main_t * vam)
13749 unformat_input_t *i = vam->input;
13750 vl_api_policer_classify_dump_t *mp;
13752 u8 type = POLICER_CLASSIFY_N_TABLES;
13754 if (unformat (i, "type %U", unformat_classify_table_type, &type))
13758 errmsg ("classify table type must be specified\n");
13762 if (!vam->json_output)
13764 fformat (vam->ofp, "%10s%20s\n", "Intfc idx", "Classify table");
13767 M (POLICER_CLASSIFY_DUMP, policer_classify_dump);
13772 /* Use a control ping for synchronization */
13774 vl_api_control_ping_t *mp;
13775 M (CONTROL_PING, control_ping);
13778 /* Wait for a reply... */
13786 api_netmap_create (vat_main_t * vam)
13788 unformat_input_t *i = vam->input;
13789 vl_api_netmap_create_t *mp;
13793 u8 random_hw_addr = 1;
13797 memset (hw_addr, 0, sizeof (hw_addr));
13799 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13801 if (unformat (i, "name %s", &if_name))
13802 vec_add1 (if_name, 0);
13803 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
13804 random_hw_addr = 0;
13805 else if (unformat (i, "pipe"))
13807 else if (unformat (i, "master"))
13809 else if (unformat (i, "slave"))
13815 if (!vec_len (if_name))
13817 errmsg ("interface name must be specified");
13821 if (vec_len (if_name) > 64)
13823 errmsg ("interface name too long");
13827 M (NETMAP_CREATE, netmap_create);
13829 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
13830 clib_memcpy (mp->hw_addr, hw_addr, 6);
13831 mp->use_random_hw_addr = random_hw_addr;
13832 mp->is_pipe = is_pipe;
13833 mp->is_master = is_master;
13834 vec_free (if_name);
13843 api_netmap_delete (vat_main_t * vam)
13845 unformat_input_t *i = vam->input;
13846 vl_api_netmap_delete_t *mp;
13850 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13852 if (unformat (i, "name %s", &if_name))
13853 vec_add1 (if_name, 0);
13858 if (!vec_len (if_name))
13860 errmsg ("interface name must be specified");
13864 if (vec_len (if_name) > 64)
13866 errmsg ("interface name too long");
13870 M (NETMAP_DELETE, netmap_delete);
13872 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
13873 vec_free (if_name);
13881 static void vl_api_mpls_gre_tunnel_details_t_handler
13882 (vl_api_mpls_gre_tunnel_details_t * mp)
13884 vat_main_t *vam = &vat_main;
13886 i32 len = ntohl (mp->nlabels);
13888 if (mp->l2_only == 0)
13890 fformat (vam->ofp, "[%d]: src %U, dst %U, adj %U/%d, labels ",
13891 ntohl (mp->tunnel_index),
13892 format_ip4_address, &mp->tunnel_src,
13893 format_ip4_address, &mp->tunnel_dst,
13894 format_ip4_address, &mp->intfc_address,
13895 ntohl (mp->mask_width));
13896 for (i = 0; i < len; i++)
13898 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
13900 fformat (vam->ofp, "\n");
13901 fformat (vam->ofp, " inner fib index %d, outer fib index %d\n",
13902 ntohl (mp->inner_fib_index), ntohl (mp->outer_fib_index));
13906 fformat (vam->ofp, "[%d]: src %U, dst %U, key %U, labels ",
13907 ntohl (mp->tunnel_index),
13908 format_ip4_address, &mp->tunnel_src,
13909 format_ip4_address, &mp->tunnel_dst,
13910 format_ip4_address, &mp->intfc_address);
13911 for (i = 0; i < len; i++)
13913 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
13915 fformat (vam->ofp, "\n");
13916 fformat (vam->ofp, " l2 interface %d, outer fib index %d\n",
13917 ntohl (mp->hw_if_index), ntohl (mp->outer_fib_index));
13921 static void vl_api_mpls_gre_tunnel_details_t_handler_json
13922 (vl_api_mpls_gre_tunnel_details_t * mp)
13924 vat_main_t *vam = &vat_main;
13925 vat_json_node_t *node = NULL;
13926 struct in_addr ip4;
13928 i32 len = ntohl (mp->nlabels);
13930 if (VAT_JSON_ARRAY != vam->json_tree.type)
13932 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13933 vat_json_init_array (&vam->json_tree);
13935 node = vat_json_array_add (&vam->json_tree);
13937 vat_json_init_object (node);
13938 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
13939 clib_memcpy (&ip4, &(mp->intfc_address), sizeof (ip4));
13940 vat_json_object_add_ip4 (node, "intfc_address", ip4);
13941 vat_json_object_add_uint (node, "inner_fib_index",
13942 ntohl (mp->inner_fib_index));
13943 vat_json_object_add_uint (node, "mask_width", ntohl (mp->mask_width));
13944 vat_json_object_add_uint (node, "encap_index", ntohl (mp->encap_index));
13945 vat_json_object_add_uint (node, "hw_if_index", ntohl (mp->hw_if_index));
13946 vat_json_object_add_uint (node, "l2_only", ntohl (mp->l2_only));
13947 clib_memcpy (&ip4, &(mp->tunnel_src), sizeof (ip4));
13948 vat_json_object_add_ip4 (node, "tunnel_src", ip4);
13949 clib_memcpy (&ip4, &(mp->tunnel_dst), sizeof (ip4));
13950 vat_json_object_add_ip4 (node, "tunnel_dst", ip4);
13951 vat_json_object_add_uint (node, "outer_fib_index",
13952 ntohl (mp->outer_fib_index));
13953 vat_json_object_add_uint (node, "label_count", len);
13954 for (i = 0; i < len; i++)
13956 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
13961 api_mpls_gre_tunnel_dump (vat_main_t * vam)
13963 vl_api_mpls_gre_tunnel_dump_t *mp;
13967 /* Parse args required to build the message */
13968 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
13970 if (!unformat (vam->input, "tunnel_index %d", &index))
13977 fformat (vam->ofp, " tunnel_index %d\n", index);
13979 M (MPLS_GRE_TUNNEL_DUMP, mpls_gre_tunnel_dump);
13980 mp->tunnel_index = htonl (index);
13983 /* Use a control ping for synchronization */
13985 vl_api_control_ping_t *mp;
13986 M (CONTROL_PING, control_ping);
13992 static void vl_api_mpls_eth_tunnel_details_t_handler
13993 (vl_api_mpls_eth_tunnel_details_t * mp)
13995 vat_main_t *vam = &vat_main;
13997 i32 len = ntohl (mp->nlabels);
13999 fformat (vam->ofp, "[%d]: dst %U, adj %U/%d, labels ",
14000 ntohl (mp->tunnel_index),
14001 format_ethernet_address, &mp->tunnel_dst_mac,
14002 format_ip4_address, &mp->intfc_address, ntohl (mp->mask_width));
14003 for (i = 0; i < len; i++)
14005 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14007 fformat (vam->ofp, "\n");
14008 fformat (vam->ofp, " tx on %d, rx fib index %d\n",
14009 ntohl (mp->tx_sw_if_index), ntohl (mp->inner_fib_index));
14012 static void vl_api_mpls_eth_tunnel_details_t_handler_json
14013 (vl_api_mpls_eth_tunnel_details_t * mp)
14015 vat_main_t *vam = &vat_main;
14016 vat_json_node_t *node = NULL;
14017 struct in_addr ip4;
14019 i32 len = ntohl (mp->nlabels);
14021 if (VAT_JSON_ARRAY != vam->json_tree.type)
14023 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14024 vat_json_init_array (&vam->json_tree);
14026 node = vat_json_array_add (&vam->json_tree);
14028 vat_json_init_object (node);
14029 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
14030 clib_memcpy (&ip4, &(mp->intfc_address), sizeof (ip4));
14031 vat_json_object_add_ip4 (node, "intfc_address", ip4);
14032 vat_json_object_add_uint (node, "inner_fib_index",
14033 ntohl (mp->inner_fib_index));
14034 vat_json_object_add_uint (node, "mask_width", ntohl (mp->mask_width));
14035 vat_json_object_add_uint (node, "encap_index", ntohl (mp->encap_index));
14036 vat_json_object_add_uint (node, "hw_if_index", ntohl (mp->hw_if_index));
14037 vat_json_object_add_uint (node, "l2_only", ntohl (mp->l2_only));
14038 vat_json_object_add_string_copy (node, "tunnel_dst_mac",
14039 format (0, "%U", format_ethernet_address,
14040 &mp->tunnel_dst_mac));
14041 vat_json_object_add_uint (node, "tx_sw_if_index",
14042 ntohl (mp->tx_sw_if_index));
14043 vat_json_object_add_uint (node, "label_count", len);
14044 for (i = 0; i < len; i++)
14046 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14051 api_mpls_eth_tunnel_dump (vat_main_t * vam)
14053 vl_api_mpls_eth_tunnel_dump_t *mp;
14057 /* Parse args required to build the message */
14058 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
14060 if (!unformat (vam->input, "tunnel_index %d", &index))
14067 fformat (vam->ofp, " tunnel_index %d\n", index);
14069 M (MPLS_ETH_TUNNEL_DUMP, mpls_eth_tunnel_dump);
14070 mp->tunnel_index = htonl (index);
14073 /* Use a control ping for synchronization */
14075 vl_api_control_ping_t *mp;
14076 M (CONTROL_PING, control_ping);
14082 static void vl_api_mpls_fib_encap_details_t_handler
14083 (vl_api_mpls_fib_encap_details_t * mp)
14085 vat_main_t *vam = &vat_main;
14087 i32 len = ntohl (mp->nlabels);
14089 fformat (vam->ofp, "table %d, dest %U, label ",
14090 ntohl (mp->fib_index), format_ip4_address, &mp->dest, len);
14091 for (i = 0; i < len; i++)
14093 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14095 fformat (vam->ofp, "\n");
14098 static void vl_api_mpls_fib_encap_details_t_handler_json
14099 (vl_api_mpls_fib_encap_details_t * mp)
14101 vat_main_t *vam = &vat_main;
14102 vat_json_node_t *node = NULL;
14104 i32 len = ntohl (mp->nlabels);
14105 struct in_addr ip4;
14107 if (VAT_JSON_ARRAY != vam->json_tree.type)
14109 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14110 vat_json_init_array (&vam->json_tree);
14112 node = vat_json_array_add (&vam->json_tree);
14114 vat_json_init_object (node);
14115 vat_json_object_add_uint (node, "table", ntohl (mp->fib_index));
14116 vat_json_object_add_uint (node, "entry_index", ntohl (mp->entry_index));
14117 clib_memcpy (&ip4, &(mp->dest), sizeof (ip4));
14118 vat_json_object_add_ip4 (node, "dest", ip4);
14119 vat_json_object_add_uint (node, "s_bit", ntohl (mp->s_bit));
14120 vat_json_object_add_uint (node, "label_count", len);
14121 for (i = 0; i < len; i++)
14123 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14128 api_mpls_fib_encap_dump (vat_main_t * vam)
14130 vl_api_mpls_fib_encap_dump_t *mp;
14133 M (MPLS_FIB_ENCAP_DUMP, mpls_fib_encap_dump);
14136 /* Use a control ping for synchronization */
14138 vl_api_control_ping_t *mp;
14139 M (CONTROL_PING, control_ping);
14145 static void vl_api_mpls_fib_decap_details_t_handler
14146 (vl_api_mpls_fib_decap_details_t * mp)
14148 vat_main_t *vam = &vat_main;
14151 "RX table %d, TX table/intfc %u, swif_tag '%s', label %u, s_bit %u\n",
14152 ntohl (mp->rx_table_id), ntohl (mp->tx_table_id), mp->swif_tag,
14153 ntohl (mp->label), ntohl (mp->s_bit));
14156 static void vl_api_mpls_fib_decap_details_t_handler_json
14157 (vl_api_mpls_fib_decap_details_t * mp)
14159 vat_main_t *vam = &vat_main;
14160 vat_json_node_t *node = NULL;
14161 struct in_addr ip4;
14163 if (VAT_JSON_ARRAY != vam->json_tree.type)
14165 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14166 vat_json_init_array (&vam->json_tree);
14168 node = vat_json_array_add (&vam->json_tree);
14170 vat_json_init_object (node);
14171 vat_json_object_add_uint (node, "table", ntohl (mp->fib_index));
14172 vat_json_object_add_uint (node, "entry_index", ntohl (mp->entry_index));
14173 clib_memcpy (&ip4, &(mp->dest), sizeof (ip4));
14174 vat_json_object_add_ip4 (node, "dest", ip4);
14175 vat_json_object_add_uint (node, "s_bit", ntohl (mp->s_bit));
14176 vat_json_object_add_uint (node, "label", ntohl (mp->label));
14177 vat_json_object_add_uint (node, "rx_table_id", ntohl (mp->rx_table_id));
14178 vat_json_object_add_uint (node, "tx_table_id", ntohl (mp->tx_table_id));
14179 vat_json_object_add_string_copy (node, "swif_tag", mp->swif_tag);
14183 api_mpls_fib_decap_dump (vat_main_t * vam)
14185 vl_api_mpls_fib_decap_dump_t *mp;
14188 M (MPLS_FIB_DECAP_DUMP, mpls_fib_decap_dump);
14191 /* Use a control ping for synchronization */
14193 vl_api_control_ping_t *mp;
14194 M (CONTROL_PING, control_ping);
14201 api_classify_table_ids (vat_main_t * vam)
14203 vl_api_classify_table_ids_t *mp;
14206 /* Construct the API message */
14207 M (CLASSIFY_TABLE_IDS, classify_table_ids);
14217 api_classify_table_by_interface (vat_main_t * vam)
14219 unformat_input_t *input = vam->input;
14220 vl_api_classify_table_by_interface_t *mp;
14223 u32 sw_if_index = ~0;
14224 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14226 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
14228 else if (unformat (input, "sw_if_index %d", &sw_if_index))
14233 if (sw_if_index == ~0)
14235 errmsg ("missing interface name or sw_if_index\n");
14239 /* Construct the API message */
14240 M (CLASSIFY_TABLE_BY_INTERFACE, classify_table_by_interface);
14242 mp->sw_if_index = ntohl (sw_if_index);
14251 api_classify_table_info (vat_main_t * vam)
14253 unformat_input_t *input = vam->input;
14254 vl_api_classify_table_info_t *mp;
14258 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14260 if (unformat (input, "table_id %d", &table_id))
14265 if (table_id == ~0)
14267 errmsg ("missing table id\n");
14271 /* Construct the API message */
14272 M (CLASSIFY_TABLE_INFO, classify_table_info);
14274 mp->table_id = ntohl (table_id);
14283 api_classify_session_dump (vat_main_t * vam)
14285 unformat_input_t *input = vam->input;
14286 vl_api_classify_session_dump_t *mp;
14290 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14292 if (unformat (input, "table_id %d", &table_id))
14297 if (table_id == ~0)
14299 errmsg ("missing table id\n");
14303 /* Construct the API message */
14304 M (CLASSIFY_SESSION_DUMP, classify_session_dump);
14306 mp->table_id = ntohl (table_id);
14309 /* Use a control ping for synchronization */
14311 vl_api_control_ping_t *mp;
14312 M (CONTROL_PING, control_ping);
14321 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
14323 vat_main_t *vam = &vat_main;
14325 fformat (vam->ofp, "collector_address %U, collector_port %d, "
14326 "src_address %U, vrf_id %d, path_mtu %u, "
14327 "template_interval %u, udp_checksum %d\n",
14328 format_ip4_address, mp->collector_address,
14329 ntohs (mp->collector_port),
14330 format_ip4_address, mp->src_address,
14331 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
14332 ntohl (mp->template_interval), mp->udp_checksum);
14335 vam->result_ready = 1;
14339 vl_api_ipfix_exporter_details_t_handler_json
14340 (vl_api_ipfix_exporter_details_t * mp)
14342 vat_main_t *vam = &vat_main;
14343 vat_json_node_t node;
14344 struct in_addr collector_address;
14345 struct in_addr src_address;
14347 vat_json_init_object (&node);
14348 clib_memcpy (&collector_address, &mp->collector_address,
14349 sizeof (collector_address));
14350 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
14351 vat_json_object_add_uint (&node, "collector_port",
14352 ntohs (mp->collector_port));
14353 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
14354 vat_json_object_add_ip4 (&node, "src_address", src_address);
14355 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
14356 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
14357 vat_json_object_add_uint (&node, "template_interval",
14358 ntohl (mp->template_interval));
14359 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
14361 vat_json_print (vam->ofp, &node);
14362 vat_json_free (&node);
14364 vam->result_ready = 1;
14368 api_ipfix_exporter_dump (vat_main_t * vam)
14370 vl_api_ipfix_exporter_dump_t *mp;
14373 /* Construct the API message */
14374 M (IPFIX_EXPORTER_DUMP, ipfix_exporter_dump);
14384 api_ipfix_classify_stream_dump (vat_main_t * vam)
14386 vl_api_ipfix_classify_stream_dump_t *mp;
14389 /* Construct the API message */
14390 M (IPFIX_CLASSIFY_STREAM_DUMP, ipfix_classify_stream_dump);
14400 vl_api_ipfix_classify_stream_details_t_handler
14401 (vl_api_ipfix_classify_stream_details_t * mp)
14403 vat_main_t *vam = &vat_main;
14404 fformat (vam->ofp, "domain_id %d, src_port %d\n",
14405 ntohl (mp->domain_id), ntohs (mp->src_port));
14407 vam->result_ready = 1;
14411 vl_api_ipfix_classify_stream_details_t_handler_json
14412 (vl_api_ipfix_classify_stream_details_t * mp)
14414 vat_main_t *vam = &vat_main;
14415 vat_json_node_t node;
14417 vat_json_init_object (&node);
14418 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
14419 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
14421 vat_json_print (vam->ofp, &node);
14422 vat_json_free (&node);
14424 vam->result_ready = 1;
14428 api_ipfix_classify_table_dump (vat_main_t * vam)
14430 vl_api_ipfix_classify_table_dump_t *mp;
14433 if (!vam->json_output)
14435 fformat (vam->ofp, "%15s%15s%20s\n", "table_id", "ip_version",
14436 "transport_protocol");
14439 /* Construct the API message */
14440 M (IPFIX_CLASSIFY_TABLE_DUMP, ipfix_classify_table_dump);
14445 /* Use a control ping for synchronization */
14447 vl_api_control_ping_t *mp;
14448 M (CONTROL_PING, control_ping);
14455 vl_api_ipfix_classify_table_details_t_handler
14456 (vl_api_ipfix_classify_table_details_t * mp)
14458 vat_main_t *vam = &vat_main;
14459 fformat (vam->ofp, "%15d%15d%20d\n", ntohl (mp->table_id), mp->ip_version,
14460 mp->transport_protocol);
14464 vl_api_ipfix_classify_table_details_t_handler_json
14465 (vl_api_ipfix_classify_table_details_t * mp)
14467 vat_json_node_t *node = NULL;
14468 vat_main_t *vam = &vat_main;
14470 if (VAT_JSON_ARRAY != vam->json_tree.type)
14472 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14473 vat_json_init_array (&vam->json_tree);
14476 node = vat_json_array_add (&vam->json_tree);
14477 vat_json_init_object (node);
14479 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
14480 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
14481 vat_json_object_add_uint (node, "transport_protocol",
14482 mp->transport_protocol);
14486 api_pg_create_interface (vat_main_t * vam)
14488 unformat_input_t *input = vam->input;
14489 vl_api_pg_create_interface_t *mp;
14493 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14495 if (unformat (input, "if_id %d", &if_id))
14502 errmsg ("missing pg interface index\n");
14506 /* Construct the API message */
14507 M (PG_CREATE_INTERFACE, pg_create_interface);
14509 mp->interface_id = ntohl (if_id);
14518 api_pg_capture (vat_main_t * vam)
14520 unformat_input_t *input = vam->input;
14521 vl_api_pg_capture_t *mp;
14527 u8 pcap_file_set = 0;
14529 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14531 if (unformat (input, "if_id %d", &if_id))
14533 else if (unformat (input, "pcap %s", &pcap_file))
14535 else if (unformat (input, "count %d", &count))
14537 else if (unformat (input, "disable"))
14544 errmsg ("missing pg interface index\n");
14547 if (pcap_file_set > 0)
14549 if (vec_len (pcap_file) > 255)
14551 errmsg ("pcap file name is too long\n");
14556 u32 name_len = vec_len (pcap_file);
14557 /* Construct the API message */
14558 M (PG_CAPTURE, pg_capture);
14560 mp->interface_id = ntohl (if_id);
14561 mp->is_enabled = enable;
14562 mp->count = ntohl (count);
14563 mp->pcap_name_length = ntohl (name_len);
14564 if (pcap_file_set != 0)
14566 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
14568 vec_free (pcap_file);
14577 api_pg_enable_disable (vat_main_t * vam)
14579 unformat_input_t *input = vam->input;
14580 vl_api_pg_enable_disable_t *mp;
14584 u8 stream_name_set = 0;
14585 u8 *stream_name = 0;
14586 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14588 if (unformat (input, "stream %s", &stream_name))
14589 stream_name_set = 1;
14590 else if (unformat (input, "disable"))
14596 if (stream_name_set > 0)
14598 if (vec_len (stream_name) > 255)
14600 errmsg ("stream name too long\n");
14605 u32 name_len = vec_len (stream_name);
14606 /* Construct the API message */
14607 M (PG_ENABLE_DISABLE, pg_enable_disable);
14609 mp->is_enabled = enable;
14610 if (stream_name_set != 0)
14612 mp->stream_name_length = ntohl (name_len);
14613 clib_memcpy (mp->stream_name, stream_name, name_len);
14615 vec_free (stream_name);
14624 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
14626 unformat_input_t *input = vam->input;
14627 vl_api_ip_source_and_port_range_check_add_del_t *mp;
14630 u16 *low_ports = 0;
14631 u16 *high_ports = 0;
14634 ip4_address_t ip4_addr;
14635 ip6_address_t ip6_addr;
14643 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14645 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
14651 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
14656 else if (unformat (input, "vrf %d", &vrf_id))
14658 else if (unformat (input, "del"))
14660 else if (unformat (input, "port %d", &tmp))
14662 if (tmp == 0 || tmp > 65535)
14664 errmsg ("port %d out of range", tmp);
14668 this_hi = this_low + 1;
14669 vec_add1 (low_ports, this_low);
14670 vec_add1 (high_ports, this_hi);
14672 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
14674 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
14676 errmsg ("incorrect range parameters\n");
14680 /* Note: in debug CLI +1 is added to high before
14681 passing to real fn that does "the work"
14682 (ip_source_and_port_range_check_add_del).
14683 This fn is a wrapper around the binary API fn a
14684 control plane will call, which expects this increment
14685 to have occurred. Hence letting the binary API control
14686 plane fn do the increment for consistency between VAT
14687 and other control planes.
14690 vec_add1 (low_ports, this_low);
14691 vec_add1 (high_ports, this_hi);
14697 if (prefix_set == 0)
14699 errmsg ("<address>/<mask> not specified\n");
14705 errmsg ("VRF ID required, not specified\n");
14712 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
14716 if (vec_len (low_ports) == 0)
14718 errmsg ("At least one port or port range required\n");
14722 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL,
14723 ip_source_and_port_range_check_add_del);
14725 mp->is_add = is_add;
14730 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
14735 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
14738 mp->mask_length = length;
14739 mp->number_of_ranges = vec_len (low_ports);
14741 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
14742 vec_free (low_ports);
14744 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
14745 vec_free (high_ports);
14747 mp->vrf_id = ntohl (vrf_id);
14756 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
14758 unformat_input_t *input = vam->input;
14759 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
14761 u32 sw_if_index = ~0;
14763 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
14764 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
14767 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14769 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
14771 else if (unformat (input, "sw_if_index %d", &sw_if_index))
14773 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
14775 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
14777 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
14779 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
14781 else if (unformat (input, "del"))
14787 if (sw_if_index == ~0)
14789 errmsg ("Interface required but not specified\n");
14795 errmsg ("VRF ID required but not specified\n");
14799 if (tcp_out_vrf_id == 0
14800 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
14803 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
14807 /* Construct the API message */
14808 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL,
14809 ip_source_and_port_range_check_interface_add_del);
14811 mp->sw_if_index = ntohl (sw_if_index);
14812 mp->is_add = is_add;
14813 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
14814 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
14815 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
14816 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
14821 /* Wait for a reply... */
14826 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
14828 unformat_input_t *i = vam->input;
14829 vl_api_ipsec_gre_add_del_tunnel_t *mp;
14831 u32 local_sa_id = 0;
14832 u32 remote_sa_id = 0;
14833 ip4_address_t src_address;
14834 ip4_address_t dst_address;
14837 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14839 if (unformat (i, "local_sa %d", &local_sa_id))
14841 else if (unformat (i, "remote_sa %d", &remote_sa_id))
14843 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
14845 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
14847 else if (unformat (i, "del"))
14851 clib_warning ("parse error '%U'", format_unformat_error, i);
14856 M (IPSEC_GRE_ADD_DEL_TUNNEL, ipsec_gre_add_del_tunnel);
14858 mp->local_sa_id = ntohl (local_sa_id);
14859 mp->remote_sa_id = ntohl (remote_sa_id);
14860 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
14861 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
14862 mp->is_add = is_add;
14870 static void vl_api_ipsec_gre_tunnel_details_t_handler
14871 (vl_api_ipsec_gre_tunnel_details_t * mp)
14873 vat_main_t *vam = &vat_main;
14875 fformat (vam->ofp, "%11d%15U%15U%14d%14d\n",
14876 ntohl (mp->sw_if_index),
14877 format_ip4_address, &mp->src_address,
14878 format_ip4_address, &mp->dst_address,
14879 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
14882 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
14883 (vl_api_ipsec_gre_tunnel_details_t * mp)
14885 vat_main_t *vam = &vat_main;
14886 vat_json_node_t *node = NULL;
14887 struct in_addr ip4;
14889 if (VAT_JSON_ARRAY != vam->json_tree.type)
14891 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14892 vat_json_init_array (&vam->json_tree);
14894 node = vat_json_array_add (&vam->json_tree);
14896 vat_json_init_object (node);
14897 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
14898 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
14899 vat_json_object_add_ip4 (node, "src_address", ip4);
14900 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
14901 vat_json_object_add_ip4 (node, "dst_address", ip4);
14902 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
14903 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
14907 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
14909 unformat_input_t *i = vam->input;
14910 vl_api_ipsec_gre_tunnel_dump_t *mp;
14913 u8 sw_if_index_set = 0;
14915 /* Parse args required to build the message */
14916 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14918 if (unformat (i, "sw_if_index %d", &sw_if_index))
14919 sw_if_index_set = 1;
14924 if (sw_if_index_set == 0)
14929 if (!vam->json_output)
14931 fformat (vam->ofp, "%11s%15s%15s%14s%14s\n",
14932 "sw_if_index", "src_address", "dst_address",
14933 "local_sa_id", "remote_sa_id");
14936 /* Get list of gre-tunnel interfaces */
14937 M (IPSEC_GRE_TUNNEL_DUMP, ipsec_gre_tunnel_dump);
14939 mp->sw_if_index = htonl (sw_if_index);
14943 /* Use a control ping for synchronization */
14945 vl_api_control_ping_t *mp;
14946 M (CONTROL_PING, control_ping);
14953 api_delete_subif (vat_main_t * vam)
14955 unformat_input_t *i = vam->input;
14956 vl_api_delete_subif_t *mp;
14958 u32 sw_if_index = ~0;
14960 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14962 if (unformat (i, "sw_if_index %d", &sw_if_index))
14968 if (sw_if_index == ~0)
14970 errmsg ("missing sw_if_index\n");
14974 /* Construct the API message */
14975 M (DELETE_SUBIF, delete_subif);
14976 mp->sw_if_index = ntohl (sw_if_index);
14983 q_or_quit (vat_main_t * vam)
14985 longjmp (vam->jump_buf, 1);
14986 return 0; /* not so much */
14990 q (vat_main_t * vam)
14992 return q_or_quit (vam);
14996 quit (vat_main_t * vam)
14998 return q_or_quit (vam);
15002 comment (vat_main_t * vam)
15008 cmd_cmp (void *a1, void *a2)
15013 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
15017 help (vat_main_t * vam)
15022 unformat_input_t *i = vam->input;
15025 if (unformat (i, "%s", &name))
15029 vec_add1 (name, 0);
15031 hs = hash_get_mem (vam->help_by_name, name);
15033 fformat (vam->ofp, "usage: %s %s\n", name, hs[0]);
15035 fformat (vam->ofp, "No such msg / command '%s'\n", name);
15040 fformat (vam->ofp, "Help is available for the following:\n");
15043 hash_foreach_pair (p, vam->function_by_name,
15045 vec_add1 (cmds, (u8 *)(p->key));
15049 vec_sort_with_function (cmds, cmd_cmp);
15051 for (j = 0; j < vec_len (cmds); j++)
15052 fformat (vam->ofp, "%s\n", cmds[j]);
15059 set (vat_main_t * vam)
15061 u8 *name = 0, *value = 0;
15062 unformat_input_t *i = vam->input;
15064 if (unformat (i, "%s", &name))
15066 /* The input buffer is a vector, not a string. */
15067 value = vec_dup (i->buffer);
15068 vec_delete (value, i->index, 0);
15069 /* Almost certainly has a trailing newline */
15070 if (value[vec_len (value) - 1] == '\n')
15071 value[vec_len (value) - 1] = 0;
15072 /* Make sure it's a proper string, one way or the other */
15073 vec_add1 (value, 0);
15074 (void) clib_macro_set_value (&vam->macro_main,
15075 (char *) name, (char *) value);
15078 errmsg ("usage: set <name> <value>\n");
15086 unset (vat_main_t * vam)
15090 if (unformat (vam->input, "%s", &name))
15091 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
15092 errmsg ("unset: %s wasn't set\n", name);
15105 macro_sort_cmp (void *a1, void *a2)
15107 macro_sort_t *s1 = a1;
15108 macro_sort_t *s2 = a2;
15110 return strcmp ((char *) (s1->name), (char *) (s2->name));
15114 dump_macro_table (vat_main_t * vam)
15116 macro_sort_t *sort_me = 0, *sm;
15121 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
15123 vec_add2 (sort_me, sm, 1);
15124 sm->name = (u8 *)(p->key);
15125 sm->value = (u8 *) (p->value[0]);
15129 vec_sort_with_function (sort_me, macro_sort_cmp);
15131 if (vec_len (sort_me))
15132 fformat (vam->ofp, "%-15s%s\n", "Name", "Value");
15134 fformat (vam->ofp, "The macro table is empty...\n");
15136 for (i = 0; i < vec_len (sort_me); i++)
15137 fformat (vam->ofp, "%-15s%s\n", sort_me[i].name, sort_me[i].value);
15142 dump_node_table (vat_main_t * vam)
15145 vlib_node_t *node, *next_node;
15147 if (vec_len (vam->graph_nodes) == 0)
15149 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
15153 for (i = 0; i < vec_len (vam->graph_nodes); i++)
15155 node = vam->graph_nodes[i];
15156 fformat (vam->ofp, "[%d] %s\n", i, node->name);
15157 for (j = 0; j < vec_len (node->next_nodes); j++)
15159 if (node->next_nodes[j] != ~0)
15161 next_node = vam->graph_nodes[node->next_nodes[j]];
15162 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
15170 search_node_table (vat_main_t * vam)
15172 unformat_input_t *line_input = vam->input;
15175 vlib_node_t *node, *next_node;
15178 if (vam->graph_node_index_by_name == 0)
15180 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
15184 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15186 if (unformat (line_input, "%s", &node_to_find))
15188 vec_add1 (node_to_find, 0);
15189 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
15192 fformat (vam->ofp, "%s not found...\n", node_to_find);
15195 node = vam->graph_nodes[p[0]];
15196 fformat (vam->ofp, "[%d] %s\n", p[0], node->name);
15197 for (j = 0; j < vec_len (node->next_nodes); j++)
15199 if (node->next_nodes[j] != ~0)
15201 next_node = vam->graph_nodes[node->next_nodes[j]];
15202 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
15209 clib_warning ("parse error '%U'", format_unformat_error,
15215 vec_free (node_to_find);
15224 script (vat_main_t * vam)
15227 char *save_current_file;
15228 unformat_input_t save_input;
15229 jmp_buf save_jump_buf;
15230 u32 save_line_number;
15232 FILE *new_fp, *save_ifp;
15234 if (unformat (vam->input, "%s", &s))
15236 new_fp = fopen ((char *) s, "r");
15239 errmsg ("Couldn't open script file %s\n", s);
15246 errmsg ("Missing script name\n");
15250 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
15251 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
15252 save_ifp = vam->ifp;
15253 save_line_number = vam->input_line_number;
15254 save_current_file = (char *) vam->current_file;
15256 vam->input_line_number = 0;
15258 vam->current_file = s;
15261 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
15262 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
15263 vam->ifp = save_ifp;
15264 vam->input_line_number = save_line_number;
15265 vam->current_file = (u8 *) save_current_file;
15272 echo (vat_main_t * vam)
15274 fformat (vam->ofp, "%v", vam->input->buffer);
15278 /* List of API message constructors, CLI names map to api_xxx */
15279 #define foreach_vpe_api_msg \
15280 _(create_loopback,"[mac <mac-addr>]") \
15281 _(sw_interface_dump,"") \
15282 _(sw_interface_set_flags, \
15283 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
15284 _(sw_interface_add_del_address, \
15285 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
15286 _(sw_interface_set_table, \
15287 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
15288 _(sw_interface_set_vpath, \
15289 "<intfc> | sw_if_index <id> enable | disable") \
15290 _(sw_interface_set_l2_xconnect, \
15291 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
15292 "enable | disable") \
15293 _(sw_interface_set_l2_bridge, \
15294 "<intfc> | sw_if_index <id> bd_id <bridge-domain-id>\n" \
15295 "[shg <split-horizon-group>] [bvi]\n" \
15296 "enable | disable") \
15297 _(bridge_domain_add_del, \
15298 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n")\
15299 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
15301 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
15303 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
15305 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
15307 "tapname <name> mac <mac-addr> | random-mac") \
15309 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
15311 "<vpp-if-name> | sw_if_index <id>") \
15312 _(sw_interface_tap_dump, "") \
15313 _(ip_add_del_route, \
15314 "<addr>/<mask> via <addr> [vrf <n>]\n" \
15315 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
15316 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
15317 "[multipath] [count <n>]") \
15318 _(proxy_arp_add_del, \
15319 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
15320 _(proxy_arp_intfc_enable_disable, \
15321 "<intfc> | sw_if_index <id> enable | disable") \
15322 _(mpls_add_del_encap, \
15323 "label <n> dst <ip4-addr> [vrf <n>] [del]") \
15324 _(mpls_add_del_decap, \
15325 "label <n> [rx_vrf_id <n>] [tx_vrf_id] [s-bit-clear][del]") \
15326 _(mpls_gre_add_del_tunnel, \
15327 "inner_vrf_id <n> outer_vrf_id <n> src <ip4-address> dst <ip4-address>\n" \
15328 "adj <ip4-address>/<mask-width> [del]") \
15329 _(sw_interface_set_unnumbered, \
15330 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
15331 _(ip_neighbor_add_del, \
15332 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
15333 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
15334 _(reset_vrf, "vrf <id> [ipv6]") \
15335 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
15336 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
15337 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
15338 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
15339 "[outer_vlan_id_any][inner_vlan_id_any]") \
15340 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
15341 _(reset_fib, "vrf <n> [ipv6]") \
15342 _(dhcp_proxy_config, \
15343 "svr <v46-address> src <v46-address>\n" \
15344 "insert-cid <n> [del]") \
15345 _(dhcp_proxy_config_2, \
15346 "svr <v46-address> src <v46-address>\n" \
15347 "rx_vrf_id <nn> server_vrf_id <nn> insert-cid <n> [del]") \
15348 _(dhcp_proxy_set_vss, \
15349 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
15350 _(dhcp_client_config, \
15351 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
15352 _(set_ip_flow_hash, \
15353 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
15354 _(sw_interface_ip6_enable_disable, \
15355 "<intfc> | sw_if_index <id> enable | disable") \
15356 _(sw_interface_ip6_set_link_local_address, \
15357 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
15358 _(sw_interface_ip6nd_ra_prefix, \
15359 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
15360 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
15361 "[nolink] [isno]") \
15362 _(sw_interface_ip6nd_ra_config, \
15363 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
15364 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
15365 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
15366 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
15367 _(l2_patch_add_del, \
15368 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
15369 "enable | disable") \
15370 _(mpls_ethernet_add_del_tunnel, \
15371 "tx <intfc> | tx_sw_if_index <n> dst <mac-addr>\n" \
15372 "adj <ip4-addr>/<mw> dst <mac-addr> [del]") \
15373 _(mpls_ethernet_add_del_tunnel_2, \
15374 "inner_vrf_id <n> outer_vrf_id <n> next-hop <ip4-addr>\n" \
15375 "resolve-attempts <n> resolve-if-needed 0 | 1 [del]") \
15376 _(sr_tunnel_add_del, \
15377 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
15378 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
15379 "[policy <policy_name>]") \
15380 _(sr_policy_add_del, \
15381 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
15382 _(sr_multicast_map_add_del, \
15383 "address [ip6 multicast address] sr-policy [policy name] [del]") \
15384 _(classify_add_del_table, \
15385 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
15386 "[del] mask <mask-value>\n" \
15387 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>") \
15388 _(classify_add_del_session, \
15389 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
15390 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
15391 " [l3 [ip4|ip6]]") \
15392 _(classify_set_interface_ip_table, \
15393 "<intfc> | sw_if_index <nn> table <nn>") \
15394 _(classify_set_interface_l2_tables, \
15395 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15396 " [other-table <nn>]") \
15397 _(get_node_index, "node <node-name") \
15398 _(add_node_next, "node <node-name> next <next-node-name>") \
15399 _(l2tpv3_create_tunnel, \
15400 "client_address <ip6-addr> our_address <ip6-addr>\n" \
15401 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n"\
15402 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
15403 _(l2tpv3_set_tunnel_cookies, \
15404 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
15405 "[new_remote_cookie <nn>]\n") \
15406 _(l2tpv3_interface_enable_disable, \
15407 "<intfc> | sw_if_index <nn> enable | disable") \
15408 _(l2tpv3_set_lookup_key, \
15409 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
15410 _(sw_if_l2tpv3_tunnel_dump, "") \
15411 _(vxlan_add_del_tunnel, \
15412 "src <ip-addr> dst <ip-addr> vni <vni> [encap-vrf-id <nn>]\n" \
15413 " [decap-next l2|ip4|ip6] [del]") \
15414 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15415 _(gre_add_del_tunnel, \
15416 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [teb] [del]\n") \
15417 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15418 _(l2_fib_clear_table, "") \
15419 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
15420 _(l2_interface_vlan_tag_rewrite, \
15421 "<intfc> | sw_if_index <nn> \n" \
15422 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
15423 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
15424 _(create_vhost_user_if, \
15425 "socket <filename> [server] [renumber <dev_instance>] " \
15426 "[mac <mac_address>]") \
15427 _(modify_vhost_user_if, \
15428 "<intfc> | sw_if_index <nn> socket <filename>\n" \
15429 "[server] [renumber <dev_instance>]") \
15430 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
15431 _(sw_interface_vhost_user_dump, "") \
15432 _(show_version, "") \
15433 _(vxlan_gpe_add_del_tunnel, \
15434 "local <addr> remote <addr> vni <nn>\n" \
15435 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
15436 "[next-ethernet] [next-nsh]\n") \
15437 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15438 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
15439 _(interface_name_renumber, \
15440 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
15441 _(input_acl_set_interface, \
15442 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15443 " [l2-table <nn>] [del]") \
15444 _(want_ip4_arp_events, "address <ip4-address> [del]") \
15445 _(want_ip6_nd_events, "address <ip6-address> [del]") \
15446 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
15447 _(ip_dump, "ipv4 | ipv6") \
15448 _(ipsec_spd_add_del, "spd_id <n> [del]") \
15449 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
15451 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
15452 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
15453 " integ_alg <alg> integ_key <hex>") \
15454 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
15455 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
15456 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
15457 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" )\
15458 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
15459 _(ikev2_profile_add_del, "name <profile_name> [del]") \
15460 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
15461 "(auth_data 0x<data> | auth_data <data>)") \
15462 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
15463 "(id_data 0x<data> | id_data <data>) (local|remote)") \
15464 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
15465 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
15466 "(local|remote)") \
15467 _(ikev2_set_local_key, "file <absolute_file_path>") \
15468 _(delete_loopback,"sw_if_index <nn>") \
15469 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
15470 _(map_add_domain, \
15471 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
15472 "ip6-src <ip6addr> " \
15473 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
15474 _(map_del_domain, "index <n>") \
15475 _(map_add_del_rule, \
15476 "index <n> psid <n> dst <ip6addr> [del]") \
15477 _(map_domain_dump, "") \
15478 _(map_rule_dump, "index <map-domain>") \
15479 _(want_interface_events, "enable|disable") \
15480 _(want_stats,"enable|disable") \
15481 _(get_first_msg_id, "client <name>") \
15482 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
15483 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
15484 "fib-id <nn> [ip4][ip6][default]") \
15485 _(get_node_graph, " ") \
15486 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
15487 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
15488 _(ioam_disable, "") \
15489 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
15490 " sw_if_index <sw_if_index> p <priority> " \
15491 "w <weight>] [del]") \
15492 _(lisp_add_del_locator, "locator-set <locator_name> " \
15493 "iface <intf> | sw_if_index <sw_if_index> " \
15494 "p <priority> w <weight> [del]") \
15495 _(lisp_add_del_local_eid,"vni <vni> eid " \
15496 "<ipv4|ipv6>/<prefix> | <L2 address> " \
15497 "locator-set <locator_name> [del]") \
15498 _(lisp_gpe_add_del_fwd_entry, "rmt_eid <eid> [lcl_eid <eid>] vni <vni>" \
15499 "dp_table <table> loc-pair <lcl_loc> <rmt_loc> ... [del]") \
15500 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
15501 _(lisp_gpe_enable_disable, "enable|disable") \
15502 _(lisp_enable_disable, "enable|disable") \
15503 _(lisp_gpe_add_del_iface, "up|down") \
15504 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
15506 "rloc <locator> p <prio> " \
15507 "w <weight> [rloc <loc> ... ] " \
15508 "action <action> [del-all]") \
15509 _(lisp_add_del_adjacency, "add|del vni <vni> deid <dest-eid> seid " \
15510 "<src-eid> rloc <locator> p <prio> w <weight>"\
15511 "[rloc <loc> ... ] action <action>") \
15512 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
15513 _(lisp_map_request_mode, "src-dst|dst-only") \
15514 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
15515 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
15516 _(lisp_locator_set_dump, "[local | remote]") \
15517 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
15518 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
15519 "[local] | [remote]") \
15520 _(lisp_eid_table_vni_dump, "") \
15521 _(lisp_eid_table_map_dump, "l2|l3") \
15522 _(lisp_gpe_tunnel_dump, "") \
15523 _(lisp_map_resolver_dump, "") \
15524 _(show_lisp_status, "") \
15525 _(lisp_get_map_request_itr_rlocs, "") \
15526 _(show_lisp_pitr, "") \
15527 _(show_lisp_map_request_mode, "") \
15528 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
15529 _(af_packet_delete, "name <host interface name>") \
15530 _(policer_add_del, "name <policer name> <params> [del]") \
15531 _(policer_dump, "[name <policer name>]") \
15532 _(policer_classify_set_interface, \
15533 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15534 " [l2-table <nn>] [del]") \
15535 _(policer_classify_dump, "type [ip4|ip6|l2]") \
15536 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
15537 "[master|slave]") \
15538 _(netmap_delete, "name <interface name>") \
15539 _(mpls_gre_tunnel_dump, "tunnel_index <tunnel-id>") \
15540 _(mpls_eth_tunnel_dump, "tunnel_index <tunnel-id>") \
15541 _(mpls_fib_encap_dump, "") \
15542 _(mpls_fib_decap_dump, "") \
15543 _(classify_table_ids, "") \
15544 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
15545 _(classify_table_info, "table_id <nn>") \
15546 _(classify_session_dump, "table_id <nn>") \
15547 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
15548 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
15549 "[template_interval <nn>] [udp_checksum]") \
15550 _(ipfix_exporter_dump, "") \
15551 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
15552 _(ipfix_classify_stream_dump, "") \
15553 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]")\
15554 _(ipfix_classify_table_dump, "") \
15555 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
15556 _(pg_create_interface, "if_id <nn>") \
15557 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
15558 _(pg_enable_disable, "[stream <id>] disable") \
15559 _(ip_source_and_port_range_check_add_del, \
15560 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
15561 _(ip_source_and_port_range_check_interface_add_del, \
15562 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
15563 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
15564 _(ipsec_gre_add_del_tunnel, \
15565 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
15566 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
15567 _(delete_subif,"sub_sw_if_index <nn> sub_if_id <nn>")
15569 /* List of command functions, CLI names map directly to functions */
15570 #define foreach_cli_function \
15571 _(comment, "usage: comment <ignore-rest-of-line>") \
15572 _(dump_interface_table, "usage: dump_interface_table") \
15573 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
15574 _(dump_ipv4_table, "usage: dump_ipv4_table") \
15575 _(dump_ipv6_table, "usage: dump_ipv6_table") \
15576 _(dump_stats_table, "usage: dump_stats_table") \
15577 _(dump_macro_table, "usage: dump_macro_table ") \
15578 _(dump_node_table, "usage: dump_node_table") \
15579 _(echo, "usage: echo <message>") \
15580 _(exec, "usage: exec <vpe-debug-CLI-command>") \
15581 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
15582 _(help, "usage: help") \
15583 _(q, "usage: quit") \
15584 _(quit, "usage: quit") \
15585 _(search_node_table, "usage: search_node_table <name>...") \
15586 _(set, "usage: set <variable-name> <value>") \
15587 _(script, "usage: script <file-name>") \
15588 _(unset, "usage: unset <variable-name>")
15591 static void vl_api_##n##_t_handler_uni \
15592 (vl_api_##n##_t * mp) \
15594 vat_main_t * vam = &vat_main; \
15595 if (vam->json_output) { \
15596 vl_api_##n##_t_handler_json(mp); \
15598 vl_api_##n##_t_handler(mp); \
15601 foreach_vpe_api_reply_msg;
15605 vat_api_hookup (vat_main_t * vam)
15608 vl_msg_api_set_handlers(VL_API_##N, #n, \
15609 vl_api_##n##_t_handler_uni, \
15611 vl_api_##n##_t_endian, \
15612 vl_api_##n##_t_print, \
15613 sizeof(vl_api_##n##_t), 1);
15614 foreach_vpe_api_reply_msg;
15617 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
15619 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
15621 vam->function_by_name = hash_create_string (0, sizeof (uword));
15623 vam->help_by_name = hash_create_string (0, sizeof (uword));
15625 /* API messages we can send */
15626 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
15627 foreach_vpe_api_msg;
15631 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
15632 foreach_vpe_api_msg;
15635 /* CLI functions */
15636 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
15637 foreach_cli_function;
15641 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
15642 foreach_cli_function;
15646 #undef vl_api_version
15647 #define vl_api_version(n,v) static u32 vpe_api_version = v;
15648 #include <vpp-api/vpe.api.h>
15649 #undef vl_api_version
15652 vl_client_add_api_signatures (vl_api_memclnt_create_t * mp)
15655 * Send the main API signature in slot 0. This bit of code must
15656 * match the checks in ../vpe/api/api.c: vl_msg_api_version_check().
15658 mp->api_versions[0] = clib_host_to_net_u32 (vpe_api_version);
15662 * fd.io coding-style-patch-verification: ON
15665 * eval: (c-set-style "gnu")