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-gre/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;
1318 static void vl_api_noprint_control_ping_reply_t_handler
1319 (vl_api_noprint_control_ping_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_noprint_control_ping_reply_t_handler_json
1335 (vl_api_noprint_control_ping_reply_t * mp)
1337 vat_main_t *vam = &vat_main;
1338 i32 retval = ntohl (mp->retval);
1340 if (vam->noprint_msg)
1342 vam->retval = retval;
1343 vam->result_ready = 1;
1347 if (VAT_JSON_NONE != vam->json_tree.type)
1349 vat_json_print (vam->ofp, &vam->json_tree);
1350 vat_json_free (&vam->json_tree);
1351 vam->json_tree.type = VAT_JSON_NONE;
1356 vat_json_init_array (&vam->json_tree);
1357 vat_json_print (vam->ofp, &vam->json_tree);
1358 vam->json_tree.type = VAT_JSON_NONE;
1361 vam->retval = retval;
1362 vam->result_ready = 1;
1366 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1368 vat_main_t *vam = &vat_main;
1369 i32 retval = ntohl (mp->retval);
1370 if (vam->async_mode)
1372 vam->async_errors += (retval < 0);
1376 vam->retval = retval;
1377 vam->result_ready = 1;
1381 static void vl_api_l2_flags_reply_t_handler_json
1382 (vl_api_l2_flags_reply_t * mp)
1384 vat_main_t *vam = &vat_main;
1385 vat_json_node_t node;
1387 vat_json_init_object (&node);
1388 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1389 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1390 ntohl (mp->resulting_feature_bitmap));
1392 vat_json_print (vam->ofp, &node);
1393 vat_json_free (&node);
1395 vam->retval = ntohl (mp->retval);
1396 vam->result_ready = 1;
1399 static void vl_api_bridge_flags_reply_t_handler
1400 (vl_api_bridge_flags_reply_t * mp)
1402 vat_main_t *vam = &vat_main;
1403 i32 retval = ntohl (mp->retval);
1404 if (vam->async_mode)
1406 vam->async_errors += (retval < 0);
1410 vam->retval = retval;
1411 vam->result_ready = 1;
1415 static void vl_api_bridge_flags_reply_t_handler_json
1416 (vl_api_bridge_flags_reply_t * mp)
1418 vat_main_t *vam = &vat_main;
1419 vat_json_node_t node;
1421 vat_json_init_object (&node);
1422 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1423 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1424 ntohl (mp->resulting_feature_bitmap));
1426 vat_json_print (vam->ofp, &node);
1427 vat_json_free (&node);
1429 vam->retval = ntohl (mp->retval);
1430 vam->result_ready = 1;
1433 static void vl_api_tap_connect_reply_t_handler
1434 (vl_api_tap_connect_reply_t * mp)
1436 vat_main_t *vam = &vat_main;
1437 i32 retval = ntohl (mp->retval);
1438 if (vam->async_mode)
1440 vam->async_errors += (retval < 0);
1444 vam->retval = retval;
1445 vam->sw_if_index = ntohl (mp->sw_if_index);
1446 vam->result_ready = 1;
1451 static void vl_api_tap_connect_reply_t_handler_json
1452 (vl_api_tap_connect_reply_t * mp)
1454 vat_main_t *vam = &vat_main;
1455 vat_json_node_t node;
1457 vat_json_init_object (&node);
1458 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1459 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1461 vat_json_print (vam->ofp, &node);
1462 vat_json_free (&node);
1464 vam->retval = ntohl (mp->retval);
1465 vam->result_ready = 1;
1470 vl_api_tap_modify_reply_t_handler (vl_api_tap_modify_reply_t * mp)
1472 vat_main_t *vam = &vat_main;
1473 i32 retval = ntohl (mp->retval);
1474 if (vam->async_mode)
1476 vam->async_errors += (retval < 0);
1480 vam->retval = retval;
1481 vam->sw_if_index = ntohl (mp->sw_if_index);
1482 vam->result_ready = 1;
1486 static void vl_api_tap_modify_reply_t_handler_json
1487 (vl_api_tap_modify_reply_t * mp)
1489 vat_main_t *vam = &vat_main;
1490 vat_json_node_t node;
1492 vat_json_init_object (&node);
1493 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1494 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1496 vat_json_print (vam->ofp, &node);
1497 vat_json_free (&node);
1499 vam->retval = ntohl (mp->retval);
1500 vam->result_ready = 1;
1504 vl_api_tap_delete_reply_t_handler (vl_api_tap_delete_reply_t * mp)
1506 vat_main_t *vam = &vat_main;
1507 i32 retval = ntohl (mp->retval);
1508 if (vam->async_mode)
1510 vam->async_errors += (retval < 0);
1514 vam->retval = retval;
1515 vam->result_ready = 1;
1519 static void vl_api_tap_delete_reply_t_handler_json
1520 (vl_api_tap_delete_reply_t * mp)
1522 vat_main_t *vam = &vat_main;
1523 vat_json_node_t node;
1525 vat_json_init_object (&node);
1526 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1528 vat_json_print (vam->ofp, &node);
1529 vat_json_free (&node);
1531 vam->retval = ntohl (mp->retval);
1532 vam->result_ready = 1;
1535 static void vl_api_mpls_ethernet_add_del_tunnel_reply_t_handler
1536 (vl_api_mpls_ethernet_add_del_tunnel_reply_t * mp)
1538 vat_main_t *vam = &vat_main;
1539 i32 retval = ntohl (mp->retval);
1540 if (vam->async_mode)
1542 vam->async_errors += (retval < 0);
1546 vam->retval = retval;
1547 vam->result_ready = 1;
1551 static void vl_api_mpls_ethernet_add_del_tunnel_reply_t_handler_json
1552 (vl_api_mpls_ethernet_add_del_tunnel_reply_t * mp)
1554 vat_main_t *vam = &vat_main;
1555 vat_json_node_t node;
1557 vat_json_init_object (&node);
1558 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1559 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
1560 ntohl (mp->tunnel_sw_if_index));
1562 vat_json_print (vam->ofp, &node);
1563 vat_json_free (&node);
1565 vam->retval = ntohl (mp->retval);
1566 vam->result_ready = 1;
1569 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
1570 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1572 vat_main_t *vam = &vat_main;
1573 i32 retval = ntohl (mp->retval);
1574 if (vam->async_mode)
1576 vam->async_errors += (retval < 0);
1580 vam->retval = retval;
1581 vam->sw_if_index = ntohl (mp->sw_if_index);
1582 vam->result_ready = 1;
1586 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
1587 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1589 vat_main_t *vam = &vat_main;
1590 vat_json_node_t node;
1592 vat_json_init_object (&node);
1593 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1594 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1596 vat_json_print (vam->ofp, &node);
1597 vat_json_free (&node);
1599 vam->retval = ntohl (mp->retval);
1600 vam->result_ready = 1;
1604 static void vl_api_lisp_add_del_locator_set_reply_t_handler
1605 (vl_api_lisp_add_del_locator_set_reply_t * mp)
1607 vat_main_t *vam = &vat_main;
1608 i32 retval = ntohl (mp->retval);
1609 if (vam->async_mode)
1611 vam->async_errors += (retval < 0);
1615 vam->retval = retval;
1616 vam->result_ready = 1;
1620 static void vl_api_lisp_add_del_locator_set_reply_t_handler_json
1621 (vl_api_lisp_add_del_locator_set_reply_t * mp)
1623 vat_main_t *vam = &vat_main;
1624 vat_json_node_t node;
1626 vat_json_init_object (&node);
1627 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1628 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
1630 vat_json_print (vam->ofp, &node);
1631 vat_json_free (&node);
1633 vam->retval = ntohl (mp->retval);
1634 vam->result_ready = 1;
1637 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
1638 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1640 vat_main_t *vam = &vat_main;
1641 i32 retval = ntohl (mp->retval);
1642 if (vam->async_mode)
1644 vam->async_errors += (retval < 0);
1648 vam->retval = retval;
1649 vam->sw_if_index = ntohl (mp->sw_if_index);
1650 vam->result_ready = 1;
1654 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
1655 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1657 vat_main_t *vam = &vat_main;
1658 vat_json_node_t node;
1660 vat_json_init_object (&node);
1661 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1662 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1664 vat_json_print (vam->ofp, &node);
1665 vat_json_free (&node);
1667 vam->retval = ntohl (mp->retval);
1668 vam->result_ready = 1;
1671 static void vl_api_gre_add_del_tunnel_reply_t_handler
1672 (vl_api_gre_add_del_tunnel_reply_t * mp)
1674 vat_main_t *vam = &vat_main;
1675 i32 retval = ntohl (mp->retval);
1676 if (vam->async_mode)
1678 vam->async_errors += (retval < 0);
1682 vam->retval = retval;
1683 vam->sw_if_index = ntohl (mp->sw_if_index);
1684 vam->result_ready = 1;
1688 static void vl_api_gre_add_del_tunnel_reply_t_handler_json
1689 (vl_api_gre_add_del_tunnel_reply_t * mp)
1691 vat_main_t *vam = &vat_main;
1692 vat_json_node_t node;
1694 vat_json_init_object (&node);
1695 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1696 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1698 vat_json_print (vam->ofp, &node);
1699 vat_json_free (&node);
1701 vam->retval = ntohl (mp->retval);
1702 vam->result_ready = 1;
1705 static void vl_api_create_vhost_user_if_reply_t_handler
1706 (vl_api_create_vhost_user_if_reply_t * mp)
1708 vat_main_t *vam = &vat_main;
1709 i32 retval = ntohl (mp->retval);
1710 if (vam->async_mode)
1712 vam->async_errors += (retval < 0);
1716 vam->retval = retval;
1717 vam->sw_if_index = ntohl (mp->sw_if_index);
1718 vam->result_ready = 1;
1722 static void vl_api_create_vhost_user_if_reply_t_handler_json
1723 (vl_api_create_vhost_user_if_reply_t * mp)
1725 vat_main_t *vam = &vat_main;
1726 vat_json_node_t node;
1728 vat_json_init_object (&node);
1729 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1730 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1732 vat_json_print (vam->ofp, &node);
1733 vat_json_free (&node);
1735 vam->retval = ntohl (mp->retval);
1736 vam->result_ready = 1;
1739 static void vl_api_ip_address_details_t_handler
1740 (vl_api_ip_address_details_t * mp)
1742 vat_main_t *vam = &vat_main;
1743 static ip_address_details_t empty_ip_address_details = { {0} };
1744 ip_address_details_t *address = NULL;
1745 ip_details_t *current_ip_details = NULL;
1746 ip_details_t *details = NULL;
1748 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
1750 if (!details || vam->current_sw_if_index >= vec_len (details)
1751 || !details[vam->current_sw_if_index].present)
1753 errmsg ("ip address details arrived but not stored\n");
1754 errmsg ("ip_dump should be called first\n");
1758 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
1760 #define addresses (current_ip_details->addr)
1762 vec_validate_init_empty (addresses, vec_len (addresses),
1763 empty_ip_address_details);
1765 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
1767 clib_memcpy (&address->ip, &mp->ip, sizeof (address->ip));
1768 address->prefix_length = mp->prefix_length;
1772 static void vl_api_ip_address_details_t_handler_json
1773 (vl_api_ip_address_details_t * mp)
1775 vat_main_t *vam = &vat_main;
1776 vat_json_node_t *node = NULL;
1777 struct in6_addr ip6;
1780 if (VAT_JSON_ARRAY != vam->json_tree.type)
1782 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1783 vat_json_init_array (&vam->json_tree);
1785 node = vat_json_array_add (&vam->json_tree);
1787 vat_json_init_object (node);
1790 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
1791 vat_json_object_add_ip6 (node, "ip", ip6);
1795 clib_memcpy (&ip4, mp->ip, sizeof (ip4));
1796 vat_json_object_add_ip4 (node, "ip", ip4);
1798 vat_json_object_add_uint (node, "prefix_length", mp->prefix_length);
1802 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
1804 vat_main_t *vam = &vat_main;
1805 static ip_details_t empty_ip_details = { 0 };
1806 ip_details_t *ip = NULL;
1807 u32 sw_if_index = ~0;
1809 sw_if_index = ntohl (mp->sw_if_index);
1811 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1812 sw_if_index, empty_ip_details);
1814 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1821 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
1823 vat_main_t *vam = &vat_main;
1825 if (VAT_JSON_ARRAY != vam->json_tree.type)
1827 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1828 vat_json_init_array (&vam->json_tree);
1830 vat_json_array_add_uint (&vam->json_tree,
1831 clib_net_to_host_u32 (mp->sw_if_index));
1834 static void vl_api_map_domain_details_t_handler_json
1835 (vl_api_map_domain_details_t * mp)
1837 vat_json_node_t *node = NULL;
1838 vat_main_t *vam = &vat_main;
1839 struct in6_addr ip6;
1842 if (VAT_JSON_ARRAY != vam->json_tree.type)
1844 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1845 vat_json_init_array (&vam->json_tree);
1848 node = vat_json_array_add (&vam->json_tree);
1849 vat_json_init_object (node);
1851 vat_json_object_add_uint (node, "domain_index",
1852 clib_net_to_host_u32 (mp->domain_index));
1853 clib_memcpy (&ip6, mp->ip6_prefix, sizeof (ip6));
1854 vat_json_object_add_ip6 (node, "ip6_prefix", ip6);
1855 clib_memcpy (&ip4, mp->ip4_prefix, sizeof (ip4));
1856 vat_json_object_add_ip4 (node, "ip4_prefix", ip4);
1857 clib_memcpy (&ip6, mp->ip6_src, sizeof (ip6));
1858 vat_json_object_add_ip6 (node, "ip6_src", ip6);
1859 vat_json_object_add_int (node, "ip6_prefix_len", mp->ip6_prefix_len);
1860 vat_json_object_add_int (node, "ip4_prefix_len", mp->ip4_prefix_len);
1861 vat_json_object_add_int (node, "ip6_src_len", mp->ip6_src_len);
1862 vat_json_object_add_int (node, "ea_bits_len", mp->ea_bits_len);
1863 vat_json_object_add_int (node, "psid_offset", mp->psid_offset);
1864 vat_json_object_add_int (node, "psid_length", mp->psid_length);
1865 vat_json_object_add_uint (node, "flags", mp->flags);
1866 vat_json_object_add_uint (node, "mtu", clib_net_to_host_u16 (mp->mtu));
1867 vat_json_object_add_int (node, "is_translation", mp->is_translation);
1870 static void vl_api_map_domain_details_t_handler
1871 (vl_api_map_domain_details_t * mp)
1873 vat_main_t *vam = &vat_main;
1875 if (mp->is_translation)
1878 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U/%d (ip6-src) index: %u\n",
1879 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1880 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1881 format_ip6_address, mp->ip6_src, mp->ip6_src_len,
1882 clib_net_to_host_u32 (mp->domain_index));
1887 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U (ip6-src) index: %u\n",
1888 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1889 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1890 format_ip6_address, mp->ip6_src,
1891 clib_net_to_host_u32 (mp->domain_index));
1893 fformat (vam->ofp, " ea-len %d psid-offset %d psid-len %d mtu %d %s\n",
1894 mp->ea_bits_len, mp->psid_offset, mp->psid_length, mp->mtu,
1895 mp->is_translation ? "map-t" : "");
1898 static void vl_api_map_rule_details_t_handler_json
1899 (vl_api_map_rule_details_t * mp)
1901 struct in6_addr ip6;
1902 vat_json_node_t *node = NULL;
1903 vat_main_t *vam = &vat_main;
1905 if (VAT_JSON_ARRAY != vam->json_tree.type)
1907 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1908 vat_json_init_array (&vam->json_tree);
1911 node = vat_json_array_add (&vam->json_tree);
1912 vat_json_init_object (node);
1914 vat_json_object_add_uint (node, "psid", clib_net_to_host_u16 (mp->psid));
1915 clib_memcpy (&ip6, mp->ip6_dst, sizeof (ip6));
1916 vat_json_object_add_ip6 (node, "ip6_dst", ip6);
1920 vl_api_map_rule_details_t_handler (vl_api_map_rule_details_t * mp)
1922 vat_main_t *vam = &vat_main;
1923 fformat (vam->ofp, " %d (psid) %U (ip6-dst)\n",
1924 clib_net_to_host_u16 (mp->psid), format_ip6_address, mp->ip6_dst);
1928 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
1930 vat_main_t *vam = &vat_main;
1931 errmsg ("DHCP compl event: pid %d %s hostname %s host_addr %U "
1932 "router_addr %U host_mac %U\n",
1933 mp->pid, mp->is_ipv6 ? "ipv6" : "ipv4", mp->hostname,
1934 format_ip4_address, &mp->host_address,
1935 format_ip4_address, &mp->router_address,
1936 format_ethernet_address, mp->host_mac);
1939 static void vl_api_dhcp_compl_event_t_handler_json
1940 (vl_api_dhcp_compl_event_t * mp)
1942 /* JSON output not supported */
1946 set_simple_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1949 vat_main_t *vam = &vat_main;
1950 static u64 default_counter = 0;
1952 vec_validate_init_empty (vam->simple_interface_counters, vnet_counter_type,
1954 vec_validate_init_empty (vam->simple_interface_counters[vnet_counter_type],
1955 sw_if_index, default_counter);
1956 vam->simple_interface_counters[vnet_counter_type][sw_if_index] = counter;
1960 set_combined_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1961 interface_counter_t counter)
1963 vat_main_t *vam = &vat_main;
1964 static interface_counter_t default_counter = { 0, };
1966 vec_validate_init_empty (vam->combined_interface_counters,
1967 vnet_counter_type, NULL);
1968 vec_validate_init_empty (vam->combined_interface_counters
1969 [vnet_counter_type], sw_if_index, default_counter);
1970 vam->combined_interface_counters[vnet_counter_type][sw_if_index] = counter;
1973 static void vl_api_vnet_interface_counters_t_handler
1974 (vl_api_vnet_interface_counters_t * mp)
1979 static void vl_api_vnet_interface_counters_t_handler_json
1980 (vl_api_vnet_interface_counters_t * mp)
1982 interface_counter_t counter;
1987 u32 first_sw_if_index;
1990 count = ntohl (mp->count);
1991 first_sw_if_index = ntohl (mp->first_sw_if_index);
1993 if (!mp->is_combined)
1995 v_packets = (u64 *) & mp->data;
1996 for (i = 0; i < count; i++)
1999 clib_net_to_host_u64 (clib_mem_unaligned (v_packets, u64));
2000 set_simple_interface_counter (mp->vnet_counter_type,
2001 first_sw_if_index + i, packets);
2007 v = (vlib_counter_t *) & mp->data;
2008 for (i = 0; i < count; i++)
2011 clib_net_to_host_u64 (clib_mem_unaligned (&v->packets, u64));
2013 clib_net_to_host_u64 (clib_mem_unaligned (&v->bytes, u64));
2014 set_combined_interface_counter (mp->vnet_counter_type,
2015 first_sw_if_index + i, counter);
2022 ip4_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
2024 vat_main_t *vam = &vat_main;
2027 for (i = 0; i < vec_len (vam->ip4_fib_counters_vrf_id_by_index); i++)
2029 if (vam->ip4_fib_counters_vrf_id_by_index[i] == vrf_id)
2038 ip6_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
2040 vat_main_t *vam = &vat_main;
2043 for (i = 0; i < vec_len (vam->ip6_fib_counters_vrf_id_by_index); i++)
2045 if (vam->ip6_fib_counters_vrf_id_by_index[i] == vrf_id)
2053 static void vl_api_vnet_ip4_fib_counters_t_handler
2054 (vl_api_vnet_ip4_fib_counters_t * mp)
2059 static void vl_api_vnet_ip4_fib_counters_t_handler_json
2060 (vl_api_vnet_ip4_fib_counters_t * mp)
2062 vat_main_t *vam = &vat_main;
2063 vl_api_ip4_fib_counter_t *v;
2064 ip4_fib_counter_t *counter;
2071 vrf_id = ntohl (mp->vrf_id);
2072 vrf_index = ip4_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2073 if (~0 == vrf_index)
2075 vrf_index = vec_len (vam->ip4_fib_counters_vrf_id_by_index);
2076 vec_validate (vam->ip4_fib_counters_vrf_id_by_index, vrf_index);
2077 vam->ip4_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2078 vec_validate (vam->ip4_fib_counters, vrf_index);
2079 vam->ip4_fib_counters[vrf_index] = NULL;
2082 vec_free (vam->ip4_fib_counters[vrf_index]);
2083 v = (vl_api_ip4_fib_counter_t *) & mp->c;
2084 count = ntohl (mp->count);
2085 for (i = 0; i < count; i++)
2087 vec_validate (vam->ip4_fib_counters[vrf_index], i);
2088 counter = &vam->ip4_fib_counters[vrf_index][i];
2089 clib_memcpy (&ip4, &v->address, sizeof (ip4));
2090 counter->address = ip4;
2091 counter->address_length = v->address_length;
2092 counter->packets = clib_net_to_host_u64 (v->packets);
2093 counter->bytes = clib_net_to_host_u64 (v->bytes);
2098 static void vl_api_vnet_ip6_fib_counters_t_handler
2099 (vl_api_vnet_ip6_fib_counters_t * mp)
2104 static void vl_api_vnet_ip6_fib_counters_t_handler_json
2105 (vl_api_vnet_ip6_fib_counters_t * mp)
2107 vat_main_t *vam = &vat_main;
2108 vl_api_ip6_fib_counter_t *v;
2109 ip6_fib_counter_t *counter;
2110 struct in6_addr ip6;
2116 vrf_id = ntohl (mp->vrf_id);
2117 vrf_index = ip6_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2118 if (~0 == vrf_index)
2120 vrf_index = vec_len (vam->ip6_fib_counters_vrf_id_by_index);
2121 vec_validate (vam->ip6_fib_counters_vrf_id_by_index, vrf_index);
2122 vam->ip6_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2123 vec_validate (vam->ip6_fib_counters, vrf_index);
2124 vam->ip6_fib_counters[vrf_index] = NULL;
2127 vec_free (vam->ip6_fib_counters[vrf_index]);
2128 v = (vl_api_ip6_fib_counter_t *) & mp->c;
2129 count = ntohl (mp->count);
2130 for (i = 0; i < count; i++)
2132 vec_validate (vam->ip6_fib_counters[vrf_index], i);
2133 counter = &vam->ip6_fib_counters[vrf_index][i];
2134 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2135 counter->address = ip6;
2136 counter->address_length = v->address_length;
2137 counter->packets = clib_net_to_host_u64 (v->packets);
2138 counter->bytes = clib_net_to_host_u64 (v->bytes);
2143 static void vl_api_get_first_msg_id_reply_t_handler
2144 (vl_api_get_first_msg_id_reply_t * mp)
2146 vat_main_t *vam = &vat_main;
2147 i32 retval = ntohl (mp->retval);
2149 if (vam->async_mode)
2151 vam->async_errors += (retval < 0);
2155 vam->retval = retval;
2156 vam->result_ready = 1;
2160 errmsg ("first message id %d\n", ntohs (mp->first_msg_id));
2164 static void vl_api_get_first_msg_id_reply_t_handler_json
2165 (vl_api_get_first_msg_id_reply_t * mp)
2167 vat_main_t *vam = &vat_main;
2168 vat_json_node_t node;
2170 vat_json_init_object (&node);
2171 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2172 vat_json_object_add_uint (&node, "first_msg_id",
2173 (uint) ntohs (mp->first_msg_id));
2175 vat_json_print (vam->ofp, &node);
2176 vat_json_free (&node);
2178 vam->retval = ntohl (mp->retval);
2179 vam->result_ready = 1;
2182 static void vl_api_get_node_graph_reply_t_handler
2183 (vl_api_get_node_graph_reply_t * mp)
2185 vat_main_t *vam = &vat_main;
2186 api_main_t *am = &api_main;
2187 i32 retval = ntohl (mp->retval);
2188 u8 *pvt_copy, *reply;
2193 if (vam->async_mode)
2195 vam->async_errors += (retval < 0);
2199 vam->retval = retval;
2200 vam->result_ready = 1;
2203 /* "Should never happen..." */
2207 reply = (u8 *) (mp->reply_in_shmem);
2208 pvt_copy = vec_dup (reply);
2210 /* Toss the shared-memory original... */
2211 pthread_mutex_lock (&am->vlib_rp->mutex);
2212 oldheap = svm_push_data_heap (am->vlib_rp);
2216 svm_pop_heap (oldheap);
2217 pthread_mutex_unlock (&am->vlib_rp->mutex);
2219 if (vam->graph_nodes)
2221 hash_free (vam->graph_node_index_by_name);
2223 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2225 node = vam->graph_nodes[i];
2226 vec_free (node->name);
2227 vec_free (node->next_nodes);
2230 vec_free (vam->graph_nodes);
2233 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2234 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2235 vec_free (pvt_copy);
2237 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2239 node = vam->graph_nodes[i];
2240 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2244 static void vl_api_get_node_graph_reply_t_handler_json
2245 (vl_api_get_node_graph_reply_t * mp)
2247 vat_main_t *vam = &vat_main;
2248 api_main_t *am = &api_main;
2250 vat_json_node_t node;
2253 /* $$$$ make this real? */
2254 vat_json_init_object (&node);
2255 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2256 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2258 reply = (u8 *) (mp->reply_in_shmem);
2260 /* Toss the shared-memory original... */
2261 pthread_mutex_lock (&am->vlib_rp->mutex);
2262 oldheap = svm_push_data_heap (am->vlib_rp);
2266 svm_pop_heap (oldheap);
2267 pthread_mutex_unlock (&am->vlib_rp->mutex);
2269 vat_json_print (vam->ofp, &node);
2270 vat_json_free (&node);
2272 vam->retval = ntohl (mp->retval);
2273 vam->result_ready = 1;
2277 vl_api_lisp_locator_details_t_handler (vl_api_lisp_locator_details_t * mp)
2279 vat_main_t *vam = &vat_main;
2283 memset (&loc, 0, sizeof (loc));
2284 if (vam->noprint_msg)
2286 loc.local = mp->local;
2287 loc.priority = mp->priority;
2288 loc.weight = mp->weight;
2291 loc.sw_if_index = ntohl (mp->sw_if_index);
2295 loc.is_ipv6 = mp->is_ipv6;
2296 clib_memcpy (loc.ip_address, mp->ip_address,
2297 sizeof (loc.ip_address));
2299 vec_add1 (vam->locator_msg, loc);
2305 tmp_str = format (tmp_str, "%=16d%=16d%=16d\n",
2306 ntohl (mp->sw_if_index),
2307 mp->priority, mp->weight);
2311 tmp_str = format (tmp_str, "%=16U%=16d%=16d\n",
2312 mp->is_ipv6 ? format_ip6_address :
2314 mp->ip_address, mp->priority, mp->weight);
2317 fformat (vam->ofp, "%s", tmp_str);
2324 vl_api_lisp_locator_details_t_handler_json (vl_api_lisp_locator_details_t *
2327 vat_main_t *vam = &vat_main;
2328 vat_json_node_t *node = NULL;
2330 struct in6_addr ip6;
2333 memset (&loc, 0, sizeof (loc));
2334 if (vam->noprint_msg)
2336 loc.local = mp->local;
2337 loc.priority = mp->priority;
2338 loc.weight = mp->weight;
2341 loc.sw_if_index = ntohl (mp->sw_if_index);
2345 loc.is_ipv6 = mp->is_ipv6;
2346 clib_memcpy (loc.ip_address, mp->ip_address,
2347 sizeof (loc.ip_address));
2349 vec_add1 (vam->locator_msg, loc);
2353 if (VAT_JSON_ARRAY != vam->json_tree.type)
2355 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2356 vat_json_init_array (&vam->json_tree);
2358 node = vat_json_array_add (&vam->json_tree);
2360 vat_json_init_object (node);
2364 vat_json_object_add_uint (node, "locator_index",
2365 ntohl (mp->sw_if_index));
2371 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2372 vat_json_object_add_ip6 (node, "locator", ip6);
2376 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2377 vat_json_object_add_ip4 (node, "locator", ip4);
2380 vat_json_object_add_uint (node, "priority", mp->priority);
2381 vat_json_object_add_uint (node, "weight", mp->weight);
2385 vl_api_lisp_locator_set_details_t_handler (vl_api_lisp_locator_set_details_t *
2388 vat_main_t *vam = &vat_main;
2389 locator_set_msg_t ls;
2391 ls.locator_set_index = ntohl (mp->locator_set_index);
2392 ls.locator_set_name = format (0, "%s", mp->locator_set_name);
2393 vec_add1 (vam->locator_set_msg, ls);
2397 vl_api_lisp_locator_set_details_t_handler_json
2398 (vl_api_lisp_locator_set_details_t * mp)
2400 vat_main_t *vam = &vat_main;
2401 locator_set_msg_t ls;
2403 ls.locator_set_index = ntohl (mp->locator_set_index);
2404 ls.locator_set_name = format (0, "%s", mp->locator_set_name);
2405 vec_add1 (vam->locator_set_msg, ls);
2409 add_lisp_eid_table_entry (vat_main_t * vam,
2410 vl_api_lisp_eid_table_details_t * mp)
2412 eid_table_t eid_table;
2414 memset (&eid_table, 0, sizeof (eid_table));
2415 eid_table.is_local = mp->is_local;
2416 eid_table.locator_set_index = clib_net_to_host_u32 (mp->locator_set_index);
2417 eid_table.eid_type = mp->eid_type;
2418 eid_table.vni = clib_net_to_host_u32 (mp->vni);
2419 eid_table.eid_prefix_len = mp->eid_prefix_len;
2420 eid_table.ttl = clib_net_to_host_u32 (mp->ttl);
2421 eid_table.action = mp->action;
2422 eid_table.authoritative = mp->authoritative;
2423 clib_memcpy (eid_table.eid, mp->eid, sizeof (eid_table.eid));
2424 vec_add1 (vam->eid_tables, eid_table);
2428 vl_api_lisp_eid_table_details_t_handler (vl_api_lisp_eid_table_details_t * mp)
2430 vat_main_t *vam = &vat_main;
2431 add_lisp_eid_table_entry (vam, mp);
2435 vl_api_lisp_eid_table_details_t_handler_json (vl_api_lisp_eid_table_details_t
2438 vat_main_t *vam = &vat_main;
2439 add_lisp_eid_table_entry (vam, mp);
2443 vl_api_lisp_eid_table_map_details_t_handler
2444 (vl_api_lisp_eid_table_map_details_t * mp)
2446 vat_main_t *vam = &vat_main;
2448 u8 *line = format (0, "%=10d%=10d",
2449 clib_net_to_host_u32 (mp->vni),
2450 clib_net_to_host_u32 (mp->dp_table));
2451 fformat (vam->ofp, "%v\n", line);
2456 vl_api_lisp_eid_table_map_details_t_handler_json
2457 (vl_api_lisp_eid_table_map_details_t * mp)
2459 vat_main_t *vam = &vat_main;
2460 vat_json_node_t *node = NULL;
2462 if (VAT_JSON_ARRAY != vam->json_tree.type)
2464 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2465 vat_json_init_array (&vam->json_tree);
2467 node = vat_json_array_add (&vam->json_tree);
2468 vat_json_init_object (node);
2469 vat_json_object_add_uint (node, "dp_table",
2470 clib_net_to_host_u32 (mp->dp_table));
2471 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2475 vl_api_lisp_eid_table_vni_details_t_handler
2476 (vl_api_lisp_eid_table_vni_details_t * mp)
2478 vat_main_t *vam = &vat_main;
2480 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
2481 fformat (vam->ofp, "%v\n", line);
2486 vl_api_lisp_eid_table_vni_details_t_handler_json
2487 (vl_api_lisp_eid_table_vni_details_t * mp)
2489 vat_main_t *vam = &vat_main;
2490 vat_json_node_t *node = NULL;
2492 if (VAT_JSON_ARRAY != vam->json_tree.type)
2494 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2495 vat_json_init_array (&vam->json_tree);
2497 node = vat_json_array_add (&vam->json_tree);
2498 vat_json_init_object (node);
2499 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2503 format_decap_next (u8 * s, va_list * args)
2505 u32 next_index = va_arg (*args, u32);
2509 case LISP_GPE_INPUT_NEXT_DROP:
2510 return format (s, "drop");
2511 case LISP_GPE_INPUT_NEXT_IP4_INPUT:
2512 return format (s, "ip4");
2513 case LISP_GPE_INPUT_NEXT_IP6_INPUT:
2514 return format (s, "ip6");
2516 return format (s, "unknown %d", next_index);
2522 vl_api_lisp_gpe_tunnel_details_t_handler (vl_api_lisp_gpe_tunnel_details_t *
2525 vat_main_t *vam = &vat_main;
2527 u8 *flag_str = NULL;
2529 iid_str = format (0, "%d (0x%x)", ntohl (mp->iid), ntohl (mp->iid));
2531 #define _(n,v) if (mp->flags & v) flag_str = format (flag_str, "%s-bit ", #n);
2532 foreach_lisp_gpe_flag_bit;
2535 fformat (vam->ofp, "%=20d%=30U%=16U%=16d%=16d%=16U"
2536 "%=16d%=16d%=16sd=16d%=16s%=16s\n",
2538 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2540 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2542 ntohl (mp->encap_fib_id),
2543 ntohl (mp->decap_fib_id),
2544 format_decap_next, ntohl (mp->dcap_next),
2546 flag_str, mp->next_protocol, mp->ver_res, mp->res, iid_str);
2552 vl_api_lisp_gpe_tunnel_details_t_handler_json
2553 (vl_api_lisp_gpe_tunnel_details_t * mp)
2555 vat_main_t *vam = &vat_main;
2556 vat_json_node_t *node = NULL;
2557 struct in6_addr ip6;
2561 next_decap_str = format (0, "%U", format_decap_next, htonl (mp->dcap_next));
2563 if (VAT_JSON_ARRAY != vam->json_tree.type)
2565 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2566 vat_json_init_array (&vam->json_tree);
2568 node = vat_json_array_add (&vam->json_tree);
2570 vat_json_init_object (node);
2571 vat_json_object_add_uint (node, "tunel", mp->tunnels);
2574 clib_memcpy (&ip6, mp->source_ip, sizeof (ip6));
2575 vat_json_object_add_ip6 (node, "source address", ip6);
2576 clib_memcpy (&ip6, mp->destination_ip, sizeof (ip6));
2577 vat_json_object_add_ip6 (node, "destination address", ip6);
2581 clib_memcpy (&ip4, mp->source_ip, sizeof (ip4));
2582 vat_json_object_add_ip4 (node, "source address", ip4);
2583 clib_memcpy (&ip4, mp->destination_ip, sizeof (ip4));
2584 vat_json_object_add_ip4 (node, "destination address", ip4);
2586 vat_json_object_add_uint (node, "fib encap", ntohl (mp->encap_fib_id));
2587 vat_json_object_add_uint (node, "fib decap", ntohl (mp->decap_fib_id));
2588 vat_json_object_add_string_copy (node, "decap next", next_decap_str);
2589 vat_json_object_add_uint (node, "lisp version", mp->ver_res >> 6);
2590 vat_json_object_add_uint (node, "flags", mp->flags);
2591 vat_json_object_add_uint (node, "next protocol", mp->next_protocol);
2592 vat_json_object_add_uint (node, "ver_res", mp->ver_res);
2593 vat_json_object_add_uint (node, "res", mp->res);
2594 vat_json_object_add_uint (node, "iid", ntohl (mp->iid));
2596 vec_free (next_decap_str);
2600 vl_api_lisp_map_resolver_details_t_handler (vl_api_lisp_map_resolver_details_t
2603 vat_main_t *vam = &vat_main;
2605 fformat (vam->ofp, "%=20U\n",
2606 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2611 vl_api_lisp_map_resolver_details_t_handler_json
2612 (vl_api_lisp_map_resolver_details_t * mp)
2614 vat_main_t *vam = &vat_main;
2615 vat_json_node_t *node = NULL;
2616 struct in6_addr ip6;
2619 if (VAT_JSON_ARRAY != vam->json_tree.type)
2621 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2622 vat_json_init_array (&vam->json_tree);
2624 node = vat_json_array_add (&vam->json_tree);
2626 vat_json_init_object (node);
2629 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2630 vat_json_object_add_ip6 (node, "map resolver", ip6);
2634 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2635 vat_json_object_add_ip4 (node, "map resolver", ip4);
2640 vl_api_show_lisp_status_reply_t_handler
2641 (vl_api_show_lisp_status_reply_t * mp)
2643 vat_main_t *vam = &vat_main;
2644 i32 retval = ntohl (mp->retval);
2648 fformat (vam->ofp, "feature: %s\ngpe: %s\n",
2649 mp->feature_status ? "enabled" : "disabled",
2650 mp->gpe_status ? "enabled" : "disabled");
2653 vam->retval = retval;
2654 vam->result_ready = 1;
2658 vl_api_show_lisp_status_reply_t_handler_json
2659 (vl_api_show_lisp_status_reply_t * mp)
2661 vat_main_t *vam = &vat_main;
2662 vat_json_node_t node;
2663 u8 *gpe_status = NULL;
2664 u8 *feature_status = NULL;
2666 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
2667 feature_status = format (0, "%s",
2668 mp->feature_status ? "enabled" : "disabled");
2669 vec_add1 (gpe_status, 0);
2670 vec_add1 (feature_status, 0);
2672 vat_json_init_object (&node);
2673 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
2674 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
2676 vec_free (gpe_status);
2677 vec_free (feature_status);
2679 vat_json_print (vam->ofp, &node);
2680 vat_json_free (&node);
2682 vam->retval = ntohl (mp->retval);
2683 vam->result_ready = 1;
2687 vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler
2688 (vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
2690 vat_main_t *vam = &vat_main;
2691 i32 retval = ntohl (mp->retval);
2695 fformat (vam->ofp, "%=20s\n", mp->locator_set_name);
2698 vam->retval = retval;
2699 vam->result_ready = 1;
2703 vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler_json
2704 (vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
2706 vat_main_t *vam = &vat_main;
2707 vat_json_node_t *node = NULL;
2709 if (VAT_JSON_ARRAY != vam->json_tree.type)
2711 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2712 vat_json_init_array (&vam->json_tree);
2714 node = vat_json_array_add (&vam->json_tree);
2716 vat_json_init_object (node);
2717 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
2719 vat_json_print (vam->ofp, node);
2720 vat_json_free (node);
2722 vam->retval = ntohl (mp->retval);
2723 vam->result_ready = 1;
2727 vl_api_show_lisp_pitr_reply_t_handler (vl_api_show_lisp_pitr_reply_t * mp)
2729 vat_main_t *vam = &vat_main;
2730 i32 retval = ntohl (mp->retval);
2734 fformat (vam->ofp, "%-20s%-16s\n",
2735 mp->status ? "enabled" : "disabled",
2736 mp->status ? (char *) mp->locator_set_name : "");
2739 vam->retval = retval;
2740 vam->result_ready = 1;
2744 vl_api_show_lisp_pitr_reply_t_handler_json (vl_api_show_lisp_pitr_reply_t *
2747 vat_main_t *vam = &vat_main;
2748 vat_json_node_t node;
2751 status = format (0, "%s", mp->status ? "enabled" : "disabled");
2752 vec_add1 (status, 0);
2754 vat_json_init_object (&node);
2755 vat_json_object_add_string_copy (&node, "status", status);
2758 vat_json_object_add_string_copy (&node, "locator_set",
2759 mp->locator_set_name);
2764 vat_json_print (vam->ofp, &node);
2765 vat_json_free (&node);
2767 vam->retval = ntohl (mp->retval);
2768 vam->result_ready = 1;
2772 format_policer_type (u8 * s, va_list * va)
2774 u32 i = va_arg (*va, u32);
2776 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
2777 s = format (s, "1r2c");
2778 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
2779 s = format (s, "1r3c");
2780 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
2781 s = format (s, "2r3c-2698");
2782 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
2783 s = format (s, "2r3c-4115");
2784 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
2785 s = format (s, "2r3c-mef5cf1");
2787 s = format (s, "ILLEGAL");
2792 format_policer_rate_type (u8 * s, va_list * va)
2794 u32 i = va_arg (*va, u32);
2796 if (i == SSE2_QOS_RATE_KBPS)
2797 s = format (s, "kbps");
2798 else if (i == SSE2_QOS_RATE_PPS)
2799 s = format (s, "pps");
2801 s = format (s, "ILLEGAL");
2806 format_policer_round_type (u8 * s, va_list * va)
2808 u32 i = va_arg (*va, u32);
2810 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
2811 s = format (s, "closest");
2812 else if (i == SSE2_QOS_ROUND_TO_UP)
2813 s = format (s, "up");
2814 else if (i == SSE2_QOS_ROUND_TO_DOWN)
2815 s = format (s, "down");
2817 s = format (s, "ILLEGAL");
2822 format_policer_action_type (u8 * s, va_list * va)
2824 u32 i = va_arg (*va, u32);
2826 if (i == SSE2_QOS_ACTION_DROP)
2827 s = format (s, "drop");
2828 else if (i == SSE2_QOS_ACTION_TRANSMIT)
2829 s = format (s, "transmit");
2830 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2831 s = format (s, "mark-and-transmit");
2833 s = format (s, "ILLEGAL");
2838 format_dscp (u8 * s, va_list * va)
2840 u32 i = va_arg (*va, u32);
2845 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
2849 return format (s, "ILLEGAL");
2851 s = format (s, "%s", t);
2856 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
2858 vat_main_t *vam = &vat_main;
2859 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
2861 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2862 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
2864 conform_dscp_str = format (0, "");
2866 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2867 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
2869 exceed_dscp_str = format (0, "");
2871 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2872 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
2874 violate_dscp_str = format (0, "");
2876 fformat (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
2877 "rate type %U, round type %U, %s rate, %s color-aware, "
2878 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
2879 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
2880 "conform action %U%s, exceed action %U%s, violate action %U%s\n",
2882 format_policer_type, mp->type,
2885 clib_net_to_host_u64 (mp->cb),
2886 clib_net_to_host_u64 (mp->eb),
2887 format_policer_rate_type, mp->rate_type,
2888 format_policer_round_type, mp->round_type,
2889 mp->single_rate ? "single" : "dual",
2890 mp->color_aware ? "is" : "not",
2891 ntohl (mp->cir_tokens_per_period),
2892 ntohl (mp->pir_tokens_per_period),
2894 ntohl (mp->current_limit),
2895 ntohl (mp->current_bucket),
2896 ntohl (mp->extended_limit),
2897 ntohl (mp->extended_bucket),
2898 clib_net_to_host_u64 (mp->last_update_time),
2899 format_policer_action_type, mp->conform_action_type,
2901 format_policer_action_type, mp->exceed_action_type,
2903 format_policer_action_type, mp->violate_action_type,
2906 vec_free (conform_dscp_str);
2907 vec_free (exceed_dscp_str);
2908 vec_free (violate_dscp_str);
2911 static void vl_api_policer_details_t_handler_json
2912 (vl_api_policer_details_t * mp)
2914 vat_main_t *vam = &vat_main;
2915 vat_json_node_t *node;
2916 u8 *rate_type_str, *round_type_str, *type_str;
2917 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
2919 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
2921 format (0, "%U", format_policer_round_type, mp->round_type);
2922 type_str = format (0, "%U", format_policer_type, mp->type);
2923 conform_action_str = format (0, "%U", format_policer_action_type,
2924 mp->conform_action_type);
2925 exceed_action_str = format (0, "%U", format_policer_action_type,
2926 mp->exceed_action_type);
2927 violate_action_str = format (0, "%U", format_policer_action_type,
2928 mp->violate_action_type);
2930 if (VAT_JSON_ARRAY != vam->json_tree.type)
2932 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2933 vat_json_init_array (&vam->json_tree);
2935 node = vat_json_array_add (&vam->json_tree);
2937 vat_json_init_object (node);
2938 vat_json_object_add_string_copy (node, "name", mp->name);
2939 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
2940 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
2941 vat_json_object_add_uint (node, "cb", ntohl (mp->cb));
2942 vat_json_object_add_uint (node, "eb", ntohl (mp->eb));
2943 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
2944 vat_json_object_add_string_copy (node, "round_type", round_type_str);
2945 vat_json_object_add_string_copy (node, "type", type_str);
2946 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
2947 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
2948 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
2949 vat_json_object_add_uint (node, "cir_tokens_per_period",
2950 ntohl (mp->cir_tokens_per_period));
2951 vat_json_object_add_uint (node, "eir_tokens_per_period",
2952 ntohl (mp->pir_tokens_per_period));
2953 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
2954 vat_json_object_add_uint (node, "current_bucket",
2955 ntohl (mp->current_bucket));
2956 vat_json_object_add_uint (node, "extended_limit",
2957 ntohl (mp->extended_limit));
2958 vat_json_object_add_uint (node, "extended_bucket",
2959 ntohl (mp->extended_bucket));
2960 vat_json_object_add_uint (node, "last_update_time",
2961 ntohl (mp->last_update_time));
2962 vat_json_object_add_string_copy (node, "conform_action",
2963 conform_action_str);
2964 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2966 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
2967 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
2968 vec_free (dscp_str);
2970 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
2971 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2973 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
2974 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
2975 vec_free (dscp_str);
2977 vat_json_object_add_string_copy (node, "violate_action",
2978 violate_action_str);
2979 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2981 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
2982 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
2983 vec_free (dscp_str);
2986 vec_free (rate_type_str);
2987 vec_free (round_type_str);
2988 vec_free (type_str);
2989 vec_free (conform_action_str);
2990 vec_free (exceed_action_str);
2991 vec_free (violate_action_str);
2995 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
2998 vat_main_t *vam = &vat_main;
2999 int i, count = ntohl (mp->count);
3002 fformat (vam->ofp, "classify table ids (%d) : ", count);
3003 for (i = 0; i < count; i++)
3005 fformat (vam->ofp, "%d", ntohl (mp->ids[i]));
3006 fformat (vam->ofp, (i < count - 1) ? "," : "\n");
3008 vam->retval = ntohl (mp->retval);
3009 vam->result_ready = 1;
3013 vl_api_classify_table_ids_reply_t_handler_json
3014 (vl_api_classify_table_ids_reply_t * mp)
3016 vat_main_t *vam = &vat_main;
3017 int i, count = ntohl (mp->count);
3021 vat_json_node_t node;
3023 vat_json_init_object (&node);
3024 for (i = 0; i < count; i++)
3026 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
3028 vat_json_print (vam->ofp, &node);
3029 vat_json_free (&node);
3031 vam->retval = ntohl (mp->retval);
3032 vam->result_ready = 1;
3036 vl_api_classify_table_by_interface_reply_t_handler
3037 (vl_api_classify_table_by_interface_reply_t * mp)
3039 vat_main_t *vam = &vat_main;
3042 table_id = ntohl (mp->l2_table_id);
3044 fformat (vam->ofp, "l2 table id : %d\n", table_id);
3046 fformat (vam->ofp, "l2 table id : No input ACL tables configured\n");
3047 table_id = ntohl (mp->ip4_table_id);
3049 fformat (vam->ofp, "ip4 table id : %d\n", table_id);
3051 fformat (vam->ofp, "ip4 table id : No input ACL tables configured\n");
3052 table_id = ntohl (mp->ip6_table_id);
3054 fformat (vam->ofp, "ip6 table id : %d\n", table_id);
3056 fformat (vam->ofp, "ip6 table id : No input ACL tables configured\n");
3057 vam->retval = ntohl (mp->retval);
3058 vam->result_ready = 1;
3062 vl_api_classify_table_by_interface_reply_t_handler_json
3063 (vl_api_classify_table_by_interface_reply_t * mp)
3065 vat_main_t *vam = &vat_main;
3066 vat_json_node_t node;
3068 vat_json_init_object (&node);
3070 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
3071 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
3072 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
3074 vat_json_print (vam->ofp, &node);
3075 vat_json_free (&node);
3077 vam->retval = ntohl (mp->retval);
3078 vam->result_ready = 1;
3081 static void vl_api_policer_add_del_reply_t_handler
3082 (vl_api_policer_add_del_reply_t * mp)
3084 vat_main_t *vam = &vat_main;
3085 i32 retval = ntohl (mp->retval);
3086 if (vam->async_mode)
3088 vam->async_errors += (retval < 0);
3092 vam->retval = retval;
3093 vam->result_ready = 1;
3094 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
3096 * Note: this is just barely thread-safe, depends on
3097 * the main thread spinning waiting for an answer...
3099 errmsg ("policer index %d\n", ntohl (mp->policer_index));
3103 static void vl_api_policer_add_del_reply_t_handler_json
3104 (vl_api_policer_add_del_reply_t * mp)
3106 vat_main_t *vam = &vat_main;
3107 vat_json_node_t node;
3109 vat_json_init_object (&node);
3110 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3111 vat_json_object_add_uint (&node, "policer_index",
3112 ntohl (mp->policer_index));
3114 vat_json_print (vam->ofp, &node);
3115 vat_json_free (&node);
3117 vam->retval = ntohl (mp->retval);
3118 vam->result_ready = 1;
3121 /* Format hex dump. */
3123 format_hex_bytes (u8 * s, va_list * va)
3125 u8 *bytes = va_arg (*va, u8 *);
3126 int n_bytes = va_arg (*va, int);
3129 /* Print short or long form depending on byte count. */
3130 uword short_form = n_bytes <= 32;
3131 uword indent = format_get_indent (s);
3136 for (i = 0; i < n_bytes; i++)
3138 if (!short_form && (i % 32) == 0)
3139 s = format (s, "%08x: ", i);
3140 s = format (s, "%02x", bytes[i]);
3141 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
3142 s = format (s, "\n%U", format_white_space, indent);
3149 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
3152 vat_main_t *vam = &vat_main;
3153 i32 retval = ntohl (mp->retval);
3156 fformat (vam->ofp, "classify table info :\n");
3157 fformat (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d\n",
3158 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
3159 ntohl (mp->miss_next_index));
3160 fformat (vam->ofp, "nbuckets: %d skip: %d match: %d\n",
3161 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
3162 ntohl (mp->match_n_vectors));
3163 fformat (vam->ofp, "mask: %U\n", format_hex_bytes, mp->mask,
3164 ntohl (mp->mask_length));
3166 vam->retval = retval;
3167 vam->result_ready = 1;
3171 vl_api_classify_table_info_reply_t_handler_json
3172 (vl_api_classify_table_info_reply_t * mp)
3174 vat_main_t *vam = &vat_main;
3175 vat_json_node_t node;
3177 i32 retval = ntohl (mp->retval);
3180 vat_json_init_object (&node);
3182 vat_json_object_add_int (&node, "sessions",
3183 ntohl (mp->active_sessions));
3184 vat_json_object_add_int (&node, "nexttbl",
3185 ntohl (mp->next_table_index));
3186 vat_json_object_add_int (&node, "nextnode",
3187 ntohl (mp->miss_next_index));
3188 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
3189 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
3190 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
3191 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
3192 ntohl (mp->mask_length), 0);
3193 vat_json_object_add_string_copy (&node, "mask", s);
3195 vat_json_print (vam->ofp, &node);
3196 vat_json_free (&node);
3198 vam->retval = ntohl (mp->retval);
3199 vam->result_ready = 1;
3203 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
3206 vat_main_t *vam = &vat_main;
3208 fformat (vam->ofp, "next_index: %d advance: %d opaque: %d ",
3209 ntohl (mp->hit_next_index), ntohl (mp->advance),
3210 ntohl (mp->opaque_index));
3211 fformat (vam->ofp, "mask: %U\n", format_hex_bytes, mp->match,
3212 ntohl (mp->match_length));
3216 vl_api_classify_session_details_t_handler_json
3217 (vl_api_classify_session_details_t * mp)
3219 vat_main_t *vam = &vat_main;
3220 vat_json_node_t *node = NULL;
3222 if (VAT_JSON_ARRAY != vam->json_tree.type)
3224 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3225 vat_json_init_array (&vam->json_tree);
3227 node = vat_json_array_add (&vam->json_tree);
3229 vat_json_init_object (node);
3230 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
3231 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
3232 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
3234 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
3236 vat_json_object_add_string_copy (node, "match", s);
3239 static void vl_api_pg_create_interface_reply_t_handler
3240 (vl_api_pg_create_interface_reply_t * mp)
3242 vat_main_t *vam = &vat_main;
3244 vam->retval = ntohl (mp->retval);
3245 vam->result_ready = 1;
3248 static void vl_api_pg_create_interface_reply_t_handler_json
3249 (vl_api_pg_create_interface_reply_t * mp)
3251 vat_main_t *vam = &vat_main;
3252 vat_json_node_t node;
3254 i32 retval = ntohl (mp->retval);
3257 vat_json_init_object (&node);
3259 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
3261 vat_json_print (vam->ofp, &node);
3262 vat_json_free (&node);
3264 vam->retval = ntohl (mp->retval);
3265 vam->result_ready = 1;
3268 static void vl_api_policer_classify_details_t_handler
3269 (vl_api_policer_classify_details_t * mp)
3271 vat_main_t *vam = &vat_main;
3273 fformat (vam->ofp, "%10d%20d\n", ntohl (mp->sw_if_index),
3274 ntohl (mp->table_index));
3277 static void vl_api_policer_classify_details_t_handler_json
3278 (vl_api_policer_classify_details_t * mp)
3280 vat_main_t *vam = &vat_main;
3281 vat_json_node_t *node;
3283 if (VAT_JSON_ARRAY != vam->json_tree.type)
3285 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3286 vat_json_init_array (&vam->json_tree);
3288 node = vat_json_array_add (&vam->json_tree);
3290 vat_json_init_object (node);
3291 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
3292 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
3295 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler
3296 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3298 vat_main_t *vam = &vat_main;
3299 i32 retval = ntohl (mp->retval);
3300 if (vam->async_mode)
3302 vam->async_errors += (retval < 0);
3306 vam->retval = retval;
3307 vam->sw_if_index = ntohl (mp->sw_if_index);
3308 vam->result_ready = 1;
3312 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler_json
3313 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3315 vat_main_t *vam = &vat_main;
3316 vat_json_node_t node;
3318 vat_json_init_object (&node);
3319 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3320 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
3322 vat_json_print (vam->ofp, &node);
3323 vat_json_free (&node);
3325 vam->retval = ntohl (mp->retval);
3326 vam->result_ready = 1;
3329 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
3330 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
3331 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
3332 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
3335 * Generate boilerplate reply handlers, which
3336 * dig the return value out of the xxx_reply_t API message,
3337 * stick it into vam->retval, and set vam->result_ready
3339 * Could also do this by pointing N message decode slots at
3340 * a single function, but that could break in subtle ways.
3343 #define foreach_standard_reply_retval_handler \
3344 _(sw_interface_set_flags_reply) \
3345 _(sw_interface_add_del_address_reply) \
3346 _(sw_interface_set_table_reply) \
3347 _(sw_interface_set_vpath_reply) \
3348 _(sw_interface_set_l2_bridge_reply) \
3349 _(bridge_domain_add_del_reply) \
3350 _(sw_interface_set_l2_xconnect_reply) \
3351 _(l2fib_add_del_reply) \
3352 _(ip_add_del_route_reply) \
3353 _(proxy_arp_add_del_reply) \
3354 _(proxy_arp_intfc_enable_disable_reply) \
3355 _(mpls_add_del_encap_reply) \
3356 _(mpls_add_del_decap_reply) \
3357 _(mpls_ethernet_add_del_tunnel_2_reply) \
3358 _(sw_interface_set_unnumbered_reply) \
3359 _(ip_neighbor_add_del_reply) \
3360 _(reset_vrf_reply) \
3361 _(oam_add_del_reply) \
3362 _(reset_fib_reply) \
3363 _(dhcp_proxy_config_reply) \
3364 _(dhcp_proxy_config_2_reply) \
3365 _(dhcp_proxy_set_vss_reply) \
3366 _(dhcp_client_config_reply) \
3367 _(set_ip_flow_hash_reply) \
3368 _(sw_interface_ip6_enable_disable_reply) \
3369 _(sw_interface_ip6_set_link_local_address_reply) \
3370 _(sw_interface_ip6nd_ra_prefix_reply) \
3371 _(sw_interface_ip6nd_ra_config_reply) \
3372 _(set_arp_neighbor_limit_reply) \
3373 _(l2_patch_add_del_reply) \
3374 _(sr_tunnel_add_del_reply) \
3375 _(sr_policy_add_del_reply) \
3376 _(sr_multicast_map_add_del_reply) \
3377 _(classify_add_del_session_reply) \
3378 _(classify_set_interface_ip_table_reply) \
3379 _(classify_set_interface_l2_tables_reply) \
3380 _(l2tpv3_set_tunnel_cookies_reply) \
3381 _(l2tpv3_interface_enable_disable_reply) \
3382 _(l2tpv3_set_lookup_key_reply) \
3383 _(l2_fib_clear_table_reply) \
3384 _(l2_interface_efp_filter_reply) \
3385 _(l2_interface_vlan_tag_rewrite_reply) \
3386 _(modify_vhost_user_if_reply) \
3387 _(delete_vhost_user_if_reply) \
3388 _(want_ip4_arp_events_reply) \
3389 _(want_ip6_nd_events_reply) \
3390 _(input_acl_set_interface_reply) \
3391 _(ipsec_spd_add_del_reply) \
3392 _(ipsec_interface_add_del_spd_reply) \
3393 _(ipsec_spd_add_del_entry_reply) \
3394 _(ipsec_sad_add_del_entry_reply) \
3395 _(ipsec_sa_set_key_reply) \
3396 _(ikev2_profile_add_del_reply) \
3397 _(ikev2_profile_set_auth_reply) \
3398 _(ikev2_profile_set_id_reply) \
3399 _(ikev2_profile_set_ts_reply) \
3400 _(ikev2_set_local_key_reply) \
3401 _(delete_loopback_reply) \
3402 _(bd_ip_mac_add_del_reply) \
3403 _(map_del_domain_reply) \
3404 _(map_add_del_rule_reply) \
3405 _(want_interface_events_reply) \
3406 _(want_stats_reply) \
3407 _(cop_interface_enable_disable_reply) \
3408 _(cop_whitelist_enable_disable_reply) \
3409 _(sw_interface_clear_stats_reply) \
3410 _(ioam_enable_reply) \
3411 _(ioam_disable_reply) \
3412 _(lisp_add_del_locator_reply) \
3413 _(lisp_add_del_local_eid_reply) \
3414 _(lisp_add_del_remote_mapping_reply) \
3415 _(lisp_add_del_adjacency_reply) \
3416 _(lisp_gpe_add_del_fwd_entry_reply) \
3417 _(lisp_add_del_map_resolver_reply) \
3418 _(lisp_gpe_enable_disable_reply) \
3419 _(lisp_gpe_add_del_iface_reply) \
3420 _(lisp_enable_disable_reply) \
3421 _(lisp_pitr_set_locator_set_reply) \
3422 _(lisp_add_del_map_request_itr_rlocs_reply) \
3423 _(lisp_eid_table_add_del_map_reply) \
3424 _(vxlan_gpe_add_del_tunnel_reply) \
3425 _(af_packet_delete_reply) \
3426 _(policer_classify_set_interface_reply) \
3427 _(netmap_create_reply) \
3428 _(netmap_delete_reply) \
3429 _(set_ipfix_exporter_reply) \
3430 _(set_ipfix_classify_stream_reply) \
3431 _(ipfix_classify_table_add_del_reply) \
3432 _(pg_capture_reply) \
3433 _(pg_enable_disable_reply) \
3434 _(ip_source_and_port_range_check_add_del_reply) \
3435 _(ip_source_and_port_range_check_interface_add_del_reply)\
3436 _(delete_subif_reply)
3439 static void vl_api_##n##_t_handler \
3440 (vl_api_##n##_t * mp) \
3442 vat_main_t * vam = &vat_main; \
3443 i32 retval = ntohl(mp->retval); \
3444 if (vam->async_mode) { \
3445 vam->async_errors += (retval < 0); \
3447 vam->retval = retval; \
3448 vam->result_ready = 1; \
3451 foreach_standard_reply_retval_handler;
3455 static void vl_api_##n##_t_handler_json \
3456 (vl_api_##n##_t * mp) \
3458 vat_main_t * vam = &vat_main; \
3459 vat_json_node_t node; \
3460 vat_json_init_object(&node); \
3461 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
3462 vat_json_print(vam->ofp, &node); \
3463 vam->retval = ntohl(mp->retval); \
3464 vam->result_ready = 1; \
3466 foreach_standard_reply_retval_handler;
3470 * Table of message reply handlers, must include boilerplate handlers
3474 #define foreach_vpe_api_reply_msg \
3475 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
3476 _(SW_INTERFACE_DETAILS, sw_interface_details) \
3477 _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
3478 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
3479 _(CONTROL_PING_REPLY, control_ping_reply) \
3480 _(NOPRINT_CONTROL_PING_REPLY, noprint_control_ping_reply) \
3481 _(CLI_REPLY, cli_reply) \
3482 _(CLI_INBAND_REPLY, cli_inband_reply) \
3483 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
3484 sw_interface_add_del_address_reply) \
3485 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
3486 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
3487 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
3488 sw_interface_set_l2_xconnect_reply) \
3489 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
3490 sw_interface_set_l2_bridge_reply) \
3491 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
3492 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
3493 _(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
3494 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
3495 _(L2_FLAGS_REPLY, l2_flags_reply) \
3496 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
3497 _(TAP_CONNECT_REPLY, tap_connect_reply) \
3498 _(TAP_MODIFY_REPLY, tap_modify_reply) \
3499 _(TAP_DELETE_REPLY, tap_delete_reply) \
3500 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
3501 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
3502 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
3503 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
3504 proxy_arp_intfc_enable_disable_reply) \
3505 _(MPLS_ADD_DEL_ENCAP_REPLY, mpls_add_del_encap_reply) \
3506 _(MPLS_ADD_DEL_DECAP_REPLY, mpls_add_del_decap_reply) \
3507 _(MPLS_GRE_ADD_DEL_TUNNEL_REPLY, mpls_gre_add_del_tunnel_reply) \
3508 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_REPLY, \
3509 mpls_ethernet_add_del_tunnel_reply) \
3510 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_2_REPLY, \
3511 mpls_ethernet_add_del_tunnel_2_reply) \
3512 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
3513 sw_interface_set_unnumbered_reply) \
3514 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
3515 _(RESET_VRF_REPLY, reset_vrf_reply) \
3516 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
3517 _(CREATE_SUBIF_REPLY, create_subif_reply) \
3518 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
3519 _(RESET_FIB_REPLY, reset_fib_reply) \
3520 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
3521 _(DHCP_PROXY_CONFIG_2_REPLY, dhcp_proxy_config_2_reply) \
3522 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
3523 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
3524 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
3525 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
3526 sw_interface_ip6_enable_disable_reply) \
3527 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
3528 sw_interface_ip6_set_link_local_address_reply) \
3529 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
3530 sw_interface_ip6nd_ra_prefix_reply) \
3531 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
3532 sw_interface_ip6nd_ra_config_reply) \
3533 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
3534 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
3535 _(SR_TUNNEL_ADD_DEL_REPLY, sr_tunnel_add_del_reply) \
3536 _(SR_POLICY_ADD_DEL_REPLY, sr_policy_add_del_reply) \
3537 _(SR_MULTICAST_MAP_ADD_DEL_REPLY, sr_multicast_map_add_del_reply) \
3538 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
3539 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
3540 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
3541 classify_set_interface_ip_table_reply) \
3542 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
3543 classify_set_interface_l2_tables_reply) \
3544 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
3545 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
3546 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
3547 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
3548 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
3549 l2tpv3_interface_enable_disable_reply) \
3550 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
3551 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
3552 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
3553 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
3554 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
3555 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
3556 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
3557 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
3558 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
3559 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
3560 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
3561 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
3562 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
3563 _(SHOW_VERSION_REPLY, show_version_reply) \
3564 _(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
3565 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
3566 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
3567 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
3568 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
3569 _(IP4_ARP_EVENT, ip4_arp_event) \
3570 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
3571 _(IP6_ND_EVENT, ip6_nd_event) \
3572 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
3573 _(IP_ADDRESS_DETAILS, ip_address_details) \
3574 _(IP_DETAILS, ip_details) \
3575 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
3576 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
3577 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
3578 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
3579 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
3580 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
3581 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
3582 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
3583 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
3584 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
3585 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
3586 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
3587 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
3588 _(VNET_INTERFACE_COUNTERS, vnet_interface_counters) \
3589 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
3590 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
3591 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
3592 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
3593 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
3594 _(MAP_DOMAIN_DETAILS, map_domain_details) \
3595 _(MAP_RULE_DETAILS, map_rule_details) \
3596 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
3597 _(WANT_STATS_REPLY, want_stats_reply) \
3598 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
3599 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
3600 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
3601 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
3602 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
3603 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
3604 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
3605 _(LISP_ADD_DEL_LOCATOR_SET_REPLY, lisp_add_del_locator_set_reply) \
3606 _(LISP_ADD_DEL_LOCATOR_REPLY, lisp_add_del_locator_reply) \
3607 _(LISP_ADD_DEL_LOCAL_EID_REPLY, lisp_add_del_local_eid_reply) \
3608 _(LISP_ADD_DEL_REMOTE_MAPPING_REPLY, lisp_add_del_remote_mapping_reply) \
3609 _(LISP_ADD_DEL_ADJACENCY_REPLY, lisp_add_del_adjacency_reply) \
3610 _(LISP_GPE_ADD_DEL_FWD_ENTRY_REPLY, lisp_gpe_add_del_fwd_entry_reply) \
3611 _(LISP_ADD_DEL_MAP_RESOLVER_REPLY, lisp_add_del_map_resolver_reply) \
3612 _(LISP_GPE_ENABLE_DISABLE_REPLY, lisp_gpe_enable_disable_reply) \
3613 _(LISP_ENABLE_DISABLE_REPLY, lisp_enable_disable_reply) \
3614 _(LISP_PITR_SET_LOCATOR_SET_REPLY, lisp_pitr_set_locator_set_reply) \
3615 _(LISP_EID_TABLE_ADD_DEL_MAP_REPLY, lisp_eid_table_add_del_map_reply) \
3616 _(LISP_GPE_ADD_DEL_IFACE_REPLY, lisp_gpe_add_del_iface_reply) \
3617 _(LISP_LOCATOR_SET_DETAILS, lisp_locator_set_details) \
3618 _(LISP_LOCATOR_DETAILS, lisp_locator_details) \
3619 _(LISP_EID_TABLE_DETAILS, lisp_eid_table_details) \
3620 _(LISP_EID_TABLE_MAP_DETAILS, lisp_eid_table_map_details) \
3621 _(LISP_EID_TABLE_VNI_DETAILS, lisp_eid_table_vni_details) \
3622 _(LISP_GPE_TUNNEL_DETAILS, lisp_gpe_tunnel_details) \
3623 _(LISP_MAP_RESOLVER_DETAILS, lisp_map_resolver_details) \
3624 _(SHOW_LISP_STATUS_REPLY, show_lisp_status_reply) \
3625 _(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
3626 lisp_add_del_map_request_itr_rlocs_reply) \
3627 _(LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
3628 lisp_get_map_request_itr_rlocs_reply) \
3629 _(SHOW_LISP_PITR_REPLY, show_lisp_pitr_reply) \
3630 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
3631 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
3632 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
3633 _(POLICER_DETAILS, policer_details) \
3634 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
3635 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
3636 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
3637 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
3638 _(MPLS_GRE_TUNNEL_DETAILS, mpls_gre_tunnel_details) \
3639 _(MPLS_ETH_TUNNEL_DETAILS, mpls_eth_tunnel_details) \
3640 _(MPLS_FIB_ENCAP_DETAILS, mpls_fib_encap_details) \
3641 _(MPLS_FIB_DECAP_DETAILS, mpls_fib_decap_details) \
3642 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
3643 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
3644 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
3645 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
3646 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
3647 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
3648 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
3649 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
3650 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
3651 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
3652 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
3653 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
3654 _(PG_CAPTURE_REPLY, pg_capture_reply) \
3655 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
3656 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
3657 ip_source_and_port_range_check_add_del_reply) \
3658 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
3659 ip_source_and_port_range_check_interface_add_del_reply) \
3660 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
3661 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
3662 _(DELETE_SUBIF_REPLY, delete_subif_reply)
3664 /* M: construct, but don't yet send a message */
3668 vam->result_ready = 0; \
3669 mp = vl_msg_api_alloc(sizeof(*mp)); \
3670 memset (mp, 0, sizeof (*mp)); \
3671 mp->_vl_msg_id = ntohs (VL_API_##T); \
3672 mp->client_index = vam->my_client_index; \
3677 vam->result_ready = 0; \
3678 mp = vl_msg_api_alloc(sizeof(*mp)+(n)); \
3679 memset (mp, 0, sizeof (*mp)); \
3680 mp->_vl_msg_id = ntohs (VL_API_##T); \
3681 mp->client_index = vam->my_client_index; \
3685 /* S: send a message */
3686 #define S (vl_msg_api_send_shmem (vam->vl_input_queue, (u8 *)&mp))
3688 /* W: wait for results, with timeout */
3691 timeout = vat_time_now (vam) + 1.0; \
3693 while (vat_time_now (vam) < timeout) { \
3694 if (vam->result_ready == 1) { \
3695 return (vam->retval); \
3701 /* W2: wait for results, with timeout */
3704 timeout = vat_time_now (vam) + 1.0; \
3706 while (vat_time_now (vam) < timeout) { \
3707 if (vam->result_ready == 1) { \
3709 return (vam->retval); \
3715 /* W_L: wait for results, with timeout */
3718 timeout = vat_time_now (vam) + 1.0; \
3720 while (vat_time_now (vam) < timeout) { \
3721 if (vam->result_ready == 1) { \
3723 return (vam->retval); \
3726 vam->noprint_msg = 0; \
3737 #define STR_VTR_OP_CASE(op) \
3738 case L2_VTR_ ## op: \
3742 str_vtr_op (u32 vtr_op)
3746 STR_VTR_OP_CASE (DISABLED);
3747 STR_VTR_OP_CASE (PUSH_1);
3748 STR_VTR_OP_CASE (PUSH_2);
3749 STR_VTR_OP_CASE (POP_1);
3750 STR_VTR_OP_CASE (POP_2);
3751 STR_VTR_OP_CASE (TRANSLATE_1_1);
3752 STR_VTR_OP_CASE (TRANSLATE_1_2);
3753 STR_VTR_OP_CASE (TRANSLATE_2_1);
3754 STR_VTR_OP_CASE (TRANSLATE_2_2);
3761 dump_sub_interface_table (vat_main_t * vam)
3763 const sw_interface_subif_t *sub = NULL;
3765 if (vam->json_output)
3768 ("JSON output supported only for VPE API calls and dump_stats_table");
3773 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s\n",
3774 "Interface", "sw_if_index",
3775 "sub id", "dot1ad", "tags", "outer id",
3776 "inner id", "exact", "default", "outer any", "inner any");
3778 vec_foreach (sub, vam->sw_if_subif_table)
3781 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d\n",
3782 sub->interface_name,
3784 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
3785 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
3786 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
3787 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
3788 if (sub->vtr_op != L2_VTR_DISABLED)
3791 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
3792 "tag1: %d tag2: %d ]\n",
3793 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
3794 sub->vtr_tag1, sub->vtr_tag2);
3802 name_sort_cmp (void *a1, void *a2)
3804 name_sort_t *n1 = a1;
3805 name_sort_t *n2 = a2;
3807 return strcmp ((char *) n1->name, (char *) n2->name);
3811 dump_interface_table (vat_main_t * vam)
3814 name_sort_t *nses = 0, *ns;
3816 if (vam->json_output)
3819 ("JSON output supported only for VPE API calls and dump_stats_table");
3824 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
3826 vec_add2 (nses, ns, 1);
3827 ns->name = (u8 *)(p->key);
3828 ns->value = (u32) p->value[0];
3832 vec_sort_with_function (nses, name_sort_cmp);
3834 fformat (vam->ofp, "%-25s%-15s\n", "Interface", "sw_if_index");
3835 vec_foreach (ns, nses)
3837 fformat (vam->ofp, "%-25s%-15d\n", ns->name, ns->value);
3844 dump_ip_table (vat_main_t * vam, int is_ipv6)
3846 const ip_details_t *det = NULL;
3847 const ip_address_details_t *address = NULL;
3850 fformat (vam->ofp, "%-12s\n", "sw_if_index");
3852 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
3859 fformat (vam->ofp, "%-12d\n", i);
3861 " %-30s%-13s\n", "Address", "Prefix length");
3866 vec_foreach (address, det->addr)
3870 is_ipv6 ? format_ip6_address : format_ip4_address,
3871 address->ip, address->prefix_length);
3879 dump_ipv4_table (vat_main_t * vam)
3881 if (vam->json_output)
3884 ("JSON output supported only for VPE API calls and dump_stats_table");
3888 return dump_ip_table (vam, 0);
3892 dump_ipv6_table (vat_main_t * vam)
3894 if (vam->json_output)
3897 ("JSON output supported only for VPE API calls and dump_stats_table");
3901 return dump_ip_table (vam, 1);
3905 counter_type_to_str (u8 counter_type, u8 is_combined)
3909 switch (counter_type)
3911 case VNET_INTERFACE_COUNTER_DROP:
3913 case VNET_INTERFACE_COUNTER_PUNT:
3915 case VNET_INTERFACE_COUNTER_IP4:
3917 case VNET_INTERFACE_COUNTER_IP6:
3919 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
3921 case VNET_INTERFACE_COUNTER_RX_MISS:
3923 case VNET_INTERFACE_COUNTER_RX_ERROR:
3925 case VNET_INTERFACE_COUNTER_TX_ERROR:
3928 return "INVALID-COUNTER-TYPE";
3933 switch (counter_type)
3935 case VNET_INTERFACE_COUNTER_RX:
3937 case VNET_INTERFACE_COUNTER_TX:
3940 return "INVALID-COUNTER-TYPE";
3946 dump_stats_table (vat_main_t * vam)
3948 vat_json_node_t node;
3949 vat_json_node_t *msg_array;
3950 vat_json_node_t *msg;
3951 vat_json_node_t *counter_array;
3952 vat_json_node_t *counter;
3953 interface_counter_t c;
3955 ip4_fib_counter_t *c4;
3956 ip6_fib_counter_t *c6;
3959 if (!vam->json_output)
3961 clib_warning ("dump_stats_table supported only in JSON format");
3965 vat_json_init_object (&node);
3967 /* interface counters */
3968 msg_array = vat_json_object_add (&node, "interface_counters");
3969 vat_json_init_array (msg_array);
3970 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
3972 msg = vat_json_array_add (msg_array);
3973 vat_json_init_object (msg);
3974 vat_json_object_add_string_copy (msg, "vnet_counter_type",
3975 (u8 *) counter_type_to_str (i, 0));
3976 vat_json_object_add_int (msg, "is_combined", 0);
3977 counter_array = vat_json_object_add (msg, "data");
3978 vat_json_init_array (counter_array);
3979 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
3981 packets = vam->simple_interface_counters[i][j];
3982 vat_json_array_add_uint (counter_array, packets);
3985 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
3987 msg = vat_json_array_add (msg_array);
3988 vat_json_init_object (msg);
3989 vat_json_object_add_string_copy (msg, "vnet_counter_type",
3990 (u8 *) counter_type_to_str (i, 1));
3991 vat_json_object_add_int (msg, "is_combined", 1);
3992 counter_array = vat_json_object_add (msg, "data");
3993 vat_json_init_array (counter_array);
3994 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
3996 c = vam->combined_interface_counters[i][j];
3997 counter = vat_json_array_add (counter_array);
3998 vat_json_init_object (counter);
3999 vat_json_object_add_uint (counter, "packets", c.packets);
4000 vat_json_object_add_uint (counter, "bytes", c.bytes);
4004 /* ip4 fib counters */
4005 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
4006 vat_json_init_array (msg_array);
4007 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
4009 msg = vat_json_array_add (msg_array);
4010 vat_json_init_object (msg);
4011 vat_json_object_add_uint (msg, "vrf_id",
4012 vam->ip4_fib_counters_vrf_id_by_index[i]);
4013 counter_array = vat_json_object_add (msg, "c");
4014 vat_json_init_array (counter_array);
4015 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
4017 counter = vat_json_array_add (counter_array);
4018 vat_json_init_object (counter);
4019 c4 = &vam->ip4_fib_counters[i][j];
4020 vat_json_object_add_ip4 (counter, "address", c4->address);
4021 vat_json_object_add_uint (counter, "address_length",
4022 c4->address_length);
4023 vat_json_object_add_uint (counter, "packets", c4->packets);
4024 vat_json_object_add_uint (counter, "bytes", c4->bytes);
4028 /* ip6 fib counters */
4029 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
4030 vat_json_init_array (msg_array);
4031 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
4033 msg = vat_json_array_add (msg_array);
4034 vat_json_init_object (msg);
4035 vat_json_object_add_uint (msg, "vrf_id",
4036 vam->ip6_fib_counters_vrf_id_by_index[i]);
4037 counter_array = vat_json_object_add (msg, "c");
4038 vat_json_init_array (counter_array);
4039 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
4041 counter = vat_json_array_add (counter_array);
4042 vat_json_init_object (counter);
4043 c6 = &vam->ip6_fib_counters[i][j];
4044 vat_json_object_add_ip6 (counter, "address", c6->address);
4045 vat_json_object_add_uint (counter, "address_length",
4046 c6->address_length);
4047 vat_json_object_add_uint (counter, "packets", c6->packets);
4048 vat_json_object_add_uint (counter, "bytes", c6->bytes);
4052 vat_json_print (vam->ofp, &node);
4053 vat_json_free (&node);
4059 exec (vat_main_t * vam)
4061 api_main_t *am = &api_main;
4062 vl_api_cli_request_t *mp;
4066 unformat_input_t *i = vam->input;
4068 if (vec_len (i->buffer) == 0)
4071 if (vam->exec_mode == 0 && unformat (i, "mode"))
4076 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4083 M (CLI_REQUEST, cli_request);
4086 * Copy cmd into shared memory.
4087 * In order for the CLI command to work, it
4088 * must be a vector ending in \n, not a C-string ending
4091 pthread_mutex_lock (&am->vlib_rp->mutex);
4092 oldheap = svm_push_data_heap (am->vlib_rp);
4094 vec_validate (cmd, vec_len (vam->input->buffer) - 1);
4095 clib_memcpy (cmd, vam->input->buffer, vec_len (vam->input->buffer));
4097 svm_pop_heap (oldheap);
4098 pthread_mutex_unlock (&am->vlib_rp->mutex);
4100 mp->cmd_in_shmem = (u64) cmd;
4102 timeout = vat_time_now (vam) + 10.0;
4104 while (vat_time_now (vam) < timeout)
4106 if (vam->result_ready == 1)
4109 if (vam->shmem_result != NULL)
4110 fformat (vam->ofp, "%s", vam->shmem_result);
4111 pthread_mutex_lock (&am->vlib_rp->mutex);
4112 oldheap = svm_push_data_heap (am->vlib_rp);
4114 free_me = (u8 *) vam->shmem_result;
4117 svm_pop_heap (oldheap);
4118 pthread_mutex_unlock (&am->vlib_rp->mutex);
4126 * Future replacement of exec() that passes CLI buffers directly in
4127 * the API messages instead of an additional shared memory area.
4130 exec_inband (vat_main_t * vam)
4132 vl_api_cli_inband_t *mp;
4134 unformat_input_t *i = vam->input;
4136 if (vec_len (i->buffer) == 0)
4139 if (vam->exec_mode == 0 && unformat (i, "mode"))
4144 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4151 * In order for the CLI command to work, it
4152 * must be a vector ending in \n, not a C-string ending
4155 u32 len = vec_len (vam->input->buffer);
4156 M2 (CLI_INBAND, cli_inband, len);
4157 clib_memcpy (mp->cmd, vam->input->buffer, len);
4158 mp->length = htonl (len);
4161 W2 (fformat (vam->ofp, "%s", vam->cmd_reply));
4165 api_create_loopback (vat_main_t * vam)
4167 unformat_input_t *i = vam->input;
4168 vl_api_create_loopback_t *mp;
4173 memset (mac_address, 0, sizeof (mac_address));
4175 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4177 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
4183 /* Construct the API message */
4184 M (CREATE_LOOPBACK, create_loopback);
4186 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
4193 api_delete_loopback (vat_main_t * vam)
4195 unformat_input_t *i = vam->input;
4196 vl_api_delete_loopback_t *mp;
4198 u32 sw_if_index = ~0;
4200 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4202 if (unformat (i, "sw_if_index %d", &sw_if_index))
4208 if (sw_if_index == ~0)
4210 errmsg ("missing sw_if_index\n");
4214 /* Construct the API message */
4215 M (DELETE_LOOPBACK, delete_loopback);
4216 mp->sw_if_index = ntohl (sw_if_index);
4223 api_want_stats (vat_main_t * vam)
4225 unformat_input_t *i = vam->input;
4226 vl_api_want_stats_t *mp;
4230 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4232 if (unformat (i, "enable"))
4234 else if (unformat (i, "disable"))
4242 errmsg ("missing enable|disable\n");
4246 M (WANT_STATS, want_stats);
4247 mp->enable_disable = enable;
4254 api_want_interface_events (vat_main_t * vam)
4256 unformat_input_t *i = vam->input;
4257 vl_api_want_interface_events_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_INTERFACE_EVENTS, want_interface_events);
4278 mp->enable_disable = enable;
4280 vam->interface_event_display = enable;
4287 /* Note: non-static, called once to set up the initial intfc table */
4289 api_sw_interface_dump (vat_main_t * vam)
4291 vl_api_sw_interface_dump_t *mp;
4294 name_sort_t *nses = 0, *ns;
4295 sw_interface_subif_t *sub = NULL;
4297 /* Toss the old name table */
4299 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4301 vec_add2 (nses, ns, 1);
4302 ns->name = (u8 *)(p->key);
4303 ns->value = (u32) p->value[0];
4307 hash_free (vam->sw_if_index_by_interface_name);
4309 vec_foreach (ns, nses) vec_free (ns->name);
4313 vec_foreach (sub, vam->sw_if_subif_table)
4315 vec_free (sub->interface_name);
4317 vec_free (vam->sw_if_subif_table);
4319 /* recreate the interface name hash table */
4320 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
4322 /* Get list of ethernets */
4323 M (SW_INTERFACE_DUMP, sw_interface_dump);
4324 mp->name_filter_valid = 1;
4325 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
4328 /* and local / loopback interfaces */
4329 M (SW_INTERFACE_DUMP, sw_interface_dump);
4330 mp->name_filter_valid = 1;
4331 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
4335 /* and vxlan-gpe tunnel interfaces */
4336 M (SW_INTERFACE_DUMP, sw_interface_dump);
4337 mp->name_filter_valid = 1;
4338 strncpy ((char *) mp->name_filter, "vxlan_gpe",
4339 sizeof (mp->name_filter) - 1);
4342 /* and vxlan tunnel interfaces */
4343 M (SW_INTERFACE_DUMP, sw_interface_dump);
4344 mp->name_filter_valid = 1;
4345 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
4348 /* and host (af_packet) interfaces */
4349 M (SW_INTERFACE_DUMP, sw_interface_dump);
4350 mp->name_filter_valid = 1;
4351 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
4354 /* and l2tpv3 tunnel interfaces */
4355 M (SW_INTERFACE_DUMP, sw_interface_dump);
4356 mp->name_filter_valid = 1;
4357 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
4358 sizeof (mp->name_filter) - 1);
4361 /* and GRE tunnel interfaces */
4362 M (SW_INTERFACE_DUMP, sw_interface_dump);
4363 mp->name_filter_valid = 1;
4364 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
4367 /* and LISP-GPE interfaces */
4368 M (SW_INTERFACE_DUMP, sw_interface_dump);
4369 mp->name_filter_valid = 1;
4370 strncpy ((char *) mp->name_filter, "lisp_gpe",
4371 sizeof (mp->name_filter) - 1);
4374 /* Use a control ping for synchronization */
4376 vl_api_control_ping_t *mp;
4377 M (CONTROL_PING, control_ping);
4384 api_sw_interface_set_flags (vat_main_t * vam)
4386 unformat_input_t *i = vam->input;
4387 vl_api_sw_interface_set_flags_t *mp;
4390 u8 sw_if_index_set = 0;
4391 u8 admin_up = 0, link_up = 0;
4393 /* Parse args required to build the message */
4394 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4396 if (unformat (i, "admin-up"))
4398 else if (unformat (i, "admin-down"))
4400 else if (unformat (i, "link-up"))
4402 else if (unformat (i, "link-down"))
4404 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4405 sw_if_index_set = 1;
4406 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4407 sw_if_index_set = 1;
4412 if (sw_if_index_set == 0)
4414 errmsg ("missing interface name or sw_if_index\n");
4418 /* Construct the API message */
4419 M (SW_INTERFACE_SET_FLAGS, sw_interface_set_flags);
4420 mp->sw_if_index = ntohl (sw_if_index);
4421 mp->admin_up_down = admin_up;
4422 mp->link_up_down = link_up;
4427 /* Wait for a reply, return the good/bad news... */
4432 api_sw_interface_clear_stats (vat_main_t * vam)
4434 unformat_input_t *i = vam->input;
4435 vl_api_sw_interface_clear_stats_t *mp;
4438 u8 sw_if_index_set = 0;
4440 /* Parse args required to build the message */
4441 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4443 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4444 sw_if_index_set = 1;
4445 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4446 sw_if_index_set = 1;
4451 /* Construct the API message */
4452 M (SW_INTERFACE_CLEAR_STATS, sw_interface_clear_stats);
4454 if (sw_if_index_set == 1)
4455 mp->sw_if_index = ntohl (sw_if_index);
4457 mp->sw_if_index = ~0;
4462 /* Wait for a reply, return the good/bad news... */
4467 api_sw_interface_add_del_address (vat_main_t * vam)
4469 unformat_input_t *i = vam->input;
4470 vl_api_sw_interface_add_del_address_t *mp;
4473 u8 sw_if_index_set = 0;
4474 u8 is_add = 1, del_all = 0;
4475 u32 address_length = 0;
4476 u8 v4_address_set = 0;
4477 u8 v6_address_set = 0;
4478 ip4_address_t v4address;
4479 ip6_address_t v6address;
4481 /* Parse args required to build the message */
4482 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4484 if (unformat (i, "del-all"))
4486 else if (unformat (i, "del"))
4488 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4489 sw_if_index_set = 1;
4490 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4491 sw_if_index_set = 1;
4492 else if (unformat (i, "%U/%d",
4493 unformat_ip4_address, &v4address, &address_length))
4495 else if (unformat (i, "%U/%d",
4496 unformat_ip6_address, &v6address, &address_length))
4502 if (sw_if_index_set == 0)
4504 errmsg ("missing interface name or sw_if_index\n");
4507 if (v4_address_set && v6_address_set)
4509 errmsg ("both v4 and v6 addresses set\n");
4512 if (!v4_address_set && !v6_address_set && !del_all)
4514 errmsg ("no addresses set\n");
4518 /* Construct the API message */
4519 M (SW_INTERFACE_ADD_DEL_ADDRESS, sw_interface_add_del_address);
4521 mp->sw_if_index = ntohl (sw_if_index);
4522 mp->is_add = is_add;
4523 mp->del_all = del_all;
4527 clib_memcpy (mp->address, &v6address, sizeof (v6address));
4531 clib_memcpy (mp->address, &v4address, sizeof (v4address));
4533 mp->address_length = address_length;
4538 /* Wait for a reply, return good/bad news */
4543 api_sw_interface_set_table (vat_main_t * vam)
4545 unformat_input_t *i = vam->input;
4546 vl_api_sw_interface_set_table_t *mp;
4548 u32 sw_if_index, vrf_id = 0;
4549 u8 sw_if_index_set = 0;
4552 /* Parse args required to build the message */
4553 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4555 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4556 sw_if_index_set = 1;
4557 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4558 sw_if_index_set = 1;
4559 else if (unformat (i, "vrf %d", &vrf_id))
4561 else if (unformat (i, "ipv6"))
4567 if (sw_if_index_set == 0)
4569 errmsg ("missing interface name or sw_if_index\n");
4573 /* Construct the API message */
4574 M (SW_INTERFACE_SET_TABLE, sw_interface_set_table);
4576 mp->sw_if_index = ntohl (sw_if_index);
4577 mp->is_ipv6 = is_ipv6;
4578 mp->vrf_id = ntohl (vrf_id);
4583 /* Wait for a reply... */
4588 api_sw_interface_set_vpath (vat_main_t * vam)
4590 unformat_input_t *i = vam->input;
4591 vl_api_sw_interface_set_vpath_t *mp;
4593 u32 sw_if_index = 0;
4594 u8 sw_if_index_set = 0;
4597 /* Parse args required to build the message */
4598 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4600 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4601 sw_if_index_set = 1;
4602 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4603 sw_if_index_set = 1;
4604 else if (unformat (i, "enable"))
4606 else if (unformat (i, "disable"))
4612 if (sw_if_index_set == 0)
4614 errmsg ("missing interface name or sw_if_index\n");
4618 /* Construct the API message */
4619 M (SW_INTERFACE_SET_VPATH, sw_interface_set_vpath);
4621 mp->sw_if_index = ntohl (sw_if_index);
4622 mp->enable = is_enable;
4627 /* Wait for a reply... */
4632 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
4634 unformat_input_t *i = vam->input;
4635 vl_api_sw_interface_set_l2_xconnect_t *mp;
4638 u8 rx_sw_if_index_set = 0;
4640 u8 tx_sw_if_index_set = 0;
4643 /* Parse args required to build the message */
4644 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4646 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
4647 rx_sw_if_index_set = 1;
4648 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
4649 tx_sw_if_index_set = 1;
4650 else if (unformat (i, "rx"))
4652 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4654 if (unformat (i, "%U", unformat_sw_if_index, vam,
4656 rx_sw_if_index_set = 1;
4661 else if (unformat (i, "tx"))
4663 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4665 if (unformat (i, "%U", unformat_sw_if_index, vam,
4667 tx_sw_if_index_set = 1;
4672 else if (unformat (i, "enable"))
4674 else if (unformat (i, "disable"))
4680 if (rx_sw_if_index_set == 0)
4682 errmsg ("missing rx interface name or rx_sw_if_index\n");
4686 if (enable && (tx_sw_if_index_set == 0))
4688 errmsg ("missing tx interface name or tx_sw_if_index\n");
4692 M (SW_INTERFACE_SET_L2_XCONNECT, sw_interface_set_l2_xconnect);
4694 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
4695 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
4696 mp->enable = enable;
4705 api_sw_interface_set_l2_bridge (vat_main_t * vam)
4707 unformat_input_t *i = vam->input;
4708 vl_api_sw_interface_set_l2_bridge_t *mp;
4711 u8 rx_sw_if_index_set = 0;
4718 /* Parse args required to build the message */
4719 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4721 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
4722 rx_sw_if_index_set = 1;
4723 else if (unformat (i, "bd_id %d", &bd_id))
4725 else if (unformat (i, "%U", unformat_sw_if_index, vam, &rx_sw_if_index))
4726 rx_sw_if_index_set = 1;
4727 else if (unformat (i, "shg %d", &shg))
4729 else if (unformat (i, "bvi"))
4731 else if (unformat (i, "enable"))
4733 else if (unformat (i, "disable"))
4739 if (rx_sw_if_index_set == 0)
4741 errmsg ("missing rx interface name or sw_if_index\n");
4745 if (enable && (bd_id_set == 0))
4747 errmsg ("missing bridge domain\n");
4751 M (SW_INTERFACE_SET_L2_BRIDGE, sw_interface_set_l2_bridge);
4753 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
4754 mp->bd_id = ntohl (bd_id);
4757 mp->enable = enable;
4766 api_bridge_domain_dump (vat_main_t * vam)
4768 unformat_input_t *i = vam->input;
4769 vl_api_bridge_domain_dump_t *mp;
4773 /* Parse args required to build the message */
4774 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4776 if (unformat (i, "bd_id %d", &bd_id))
4782 M (BRIDGE_DOMAIN_DUMP, bridge_domain_dump);
4783 mp->bd_id = ntohl (bd_id);
4786 /* Use a control ping for synchronization */
4788 vl_api_control_ping_t *mp;
4789 M (CONTROL_PING, control_ping);
4799 api_bridge_domain_add_del (vat_main_t * vam)
4801 unformat_input_t *i = vam->input;
4802 vl_api_bridge_domain_add_del_t *mp;
4806 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
4808 /* Parse args required to build the message */
4809 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4811 if (unformat (i, "bd_id %d", &bd_id))
4813 else if (unformat (i, "flood %d", &flood))
4815 else if (unformat (i, "uu-flood %d", &uu_flood))
4817 else if (unformat (i, "forward %d", &forward))
4819 else if (unformat (i, "learn %d", &learn))
4821 else if (unformat (i, "arp-term %d", &arp_term))
4823 else if (unformat (i, "del"))
4826 flood = uu_flood = forward = learn = 0;
4834 errmsg ("missing bridge domain\n");
4838 M (BRIDGE_DOMAIN_ADD_DEL, bridge_domain_add_del);
4840 mp->bd_id = ntohl (bd_id);
4842 mp->uu_flood = uu_flood;
4843 mp->forward = forward;
4845 mp->arp_term = arp_term;
4846 mp->is_add = is_add;
4855 api_l2fib_add_del (vat_main_t * vam)
4857 unformat_input_t *i = vam->input;
4858 vl_api_l2fib_add_del_t *mp;
4865 u8 sw_if_index_set = 0;
4874 /* Parse args required to build the message */
4875 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4877 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
4879 else if (unformat (i, "bd_id %d", &bd_id))
4881 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4882 sw_if_index_set = 1;
4883 else if (unformat (i, "sw_if"))
4885 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4887 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4888 sw_if_index_set = 1;
4893 else if (unformat (i, "static"))
4895 else if (unformat (i, "filter"))
4900 else if (unformat (i, "bvi"))
4905 else if (unformat (i, "del"))
4907 else if (unformat (i, "count %d", &count))
4915 errmsg ("missing mac address\n");
4921 errmsg ("missing bridge domain\n");
4925 if (is_add && (sw_if_index_set == 0))
4927 errmsg ("missing interface name or sw_if_index\n");
4933 /* Turn on async mode */
4934 vam->async_mode = 1;
4935 vam->async_errors = 0;
4936 before = vat_time_now (vam);
4939 for (j = 0; j < count; j++)
4941 M (L2FIB_ADD_DEL, l2fib_add_del);
4944 mp->bd_id = ntohl (bd_id);
4945 mp->is_add = is_add;
4949 mp->sw_if_index = ntohl (sw_if_index);
4950 mp->static_mac = static_mac;
4951 mp->filter_mac = filter_mac;
4952 mp->bvi_mac = bvi_mac;
4954 increment_mac_address (&mac);
4961 vl_api_control_ping_t *mp;
4964 /* Shut off async mode */
4965 vam->async_mode = 0;
4967 M (CONTROL_PING, control_ping);
4970 timeout = vat_time_now (vam) + 1.0;
4971 while (vat_time_now (vam) < timeout)
4972 if (vam->result_ready == 1)
4977 if (vam->retval == -99)
4978 errmsg ("timeout\n");
4980 if (vam->async_errors > 0)
4982 errmsg ("%d asynchronous errors\n", vam->async_errors);
4985 vam->async_errors = 0;
4986 after = vat_time_now (vam);
4988 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
4989 count, after - before, count / (after - before));
4993 /* Wait for a reply... */
4996 /* Return the good/bad news */
4997 return (vam->retval);
5001 api_l2_flags (vat_main_t * vam)
5003 unformat_input_t *i = vam->input;
5004 vl_api_l2_flags_t *mp;
5007 u32 feature_bitmap = 0;
5008 u8 sw_if_index_set = 0;
5010 /* Parse args required to build the message */
5011 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5013 if (unformat (i, "sw_if_index %d", &sw_if_index))
5014 sw_if_index_set = 1;
5015 else if (unformat (i, "sw_if"))
5017 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5019 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5020 sw_if_index_set = 1;
5025 else if (unformat (i, "learn"))
5026 feature_bitmap |= L2INPUT_FEAT_LEARN;
5027 else if (unformat (i, "forward"))
5028 feature_bitmap |= L2INPUT_FEAT_FWD;
5029 else if (unformat (i, "flood"))
5030 feature_bitmap |= L2INPUT_FEAT_FLOOD;
5031 else if (unformat (i, "uu-flood"))
5032 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
5037 if (sw_if_index_set == 0)
5039 errmsg ("missing interface name or sw_if_index\n");
5043 M (L2_FLAGS, l2_flags);
5045 mp->sw_if_index = ntohl (sw_if_index);
5046 mp->feature_bitmap = ntohl (feature_bitmap);
5055 api_bridge_flags (vat_main_t * vam)
5057 unformat_input_t *i = vam->input;
5058 vl_api_bridge_flags_t *mp;
5065 /* Parse args required to build the message */
5066 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5068 if (unformat (i, "bd_id %d", &bd_id))
5070 else if (unformat (i, "learn"))
5072 else if (unformat (i, "forward"))
5074 else if (unformat (i, "flood"))
5076 else if (unformat (i, "uu-flood"))
5077 flags |= L2_UU_FLOOD;
5078 else if (unformat (i, "arp-term"))
5079 flags |= L2_ARP_TERM;
5080 else if (unformat (i, "off"))
5082 else if (unformat (i, "disable"))
5090 errmsg ("missing bridge domain\n");
5094 M (BRIDGE_FLAGS, bridge_flags);
5096 mp->bd_id = ntohl (bd_id);
5097 mp->feature_bitmap = ntohl (flags);
5098 mp->is_set = is_set;
5107 api_bd_ip_mac_add_del (vat_main_t * vam)
5109 unformat_input_t *i = vam->input;
5110 vl_api_bd_ip_mac_add_del_t *mp;
5118 ip4_address_t v4addr;
5119 ip6_address_t v6addr;
5123 /* Parse args required to build the message */
5124 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5126 if (unformat (i, "bd_id %d", &bd_id))
5130 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
5134 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
5139 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
5143 else if (unformat (i, "del"))
5151 errmsg ("missing bridge domain\n");
5154 else if (ip_set == 0)
5156 errmsg ("missing IP address\n");
5159 else if (mac_set == 0)
5161 errmsg ("missing MAC address\n");
5165 M (BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del);
5167 mp->bd_id = ntohl (bd_id);
5168 mp->is_ipv6 = is_ipv6;
5169 mp->is_add = is_add;
5171 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
5173 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
5174 clib_memcpy (mp->mac_address, macaddr, 6);
5182 api_tap_connect (vat_main_t * vam)
5184 unformat_input_t *i = vam->input;
5185 vl_api_tap_connect_t *mp;
5192 memset (mac_address, 0, sizeof (mac_address));
5194 /* Parse args required to build the message */
5195 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5197 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5201 else if (unformat (i, "random-mac"))
5203 else if (unformat (i, "tapname %s", &tap_name))
5211 errmsg ("missing tap name\n");
5214 if (vec_len (tap_name) > 63)
5216 errmsg ("tap name too long\n");
5218 vec_add1 (tap_name, 0);
5220 /* Construct the API message */
5221 M (TAP_CONNECT, tap_connect);
5223 mp->use_random_mac = random_mac;
5224 clib_memcpy (mp->mac_address, mac_address, 6);
5225 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5226 vec_free (tap_name);
5231 /* Wait for a reply... */
5236 api_tap_modify (vat_main_t * vam)
5238 unformat_input_t *i = vam->input;
5239 vl_api_tap_modify_t *mp;
5245 u32 sw_if_index = ~0;
5246 u8 sw_if_index_set = 0;
5248 memset (mac_address, 0, sizeof (mac_address));
5250 /* Parse args required to build the message */
5251 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5253 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5254 sw_if_index_set = 1;
5255 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5256 sw_if_index_set = 1;
5257 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5261 else if (unformat (i, "random-mac"))
5263 else if (unformat (i, "tapname %s", &tap_name))
5269 if (sw_if_index_set == 0)
5271 errmsg ("missing vpp interface name");
5276 errmsg ("missing tap name\n");
5279 if (vec_len (tap_name) > 63)
5281 errmsg ("tap name too long\n");
5283 vec_add1 (tap_name, 0);
5285 /* Construct the API message */
5286 M (TAP_MODIFY, tap_modify);
5288 mp->use_random_mac = random_mac;
5289 mp->sw_if_index = ntohl (sw_if_index);
5290 clib_memcpy (mp->mac_address, mac_address, 6);
5291 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5292 vec_free (tap_name);
5297 /* Wait for a reply... */
5302 api_tap_delete (vat_main_t * vam)
5304 unformat_input_t *i = vam->input;
5305 vl_api_tap_delete_t *mp;
5307 u32 sw_if_index = ~0;
5308 u8 sw_if_index_set = 0;
5310 /* Parse args required to build the message */
5311 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5313 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5314 sw_if_index_set = 1;
5315 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5316 sw_if_index_set = 1;
5321 if (sw_if_index_set == 0)
5323 errmsg ("missing vpp interface name");
5327 /* Construct the API message */
5328 M (TAP_DELETE, tap_delete);
5330 mp->sw_if_index = ntohl (sw_if_index);
5335 /* Wait for a reply... */
5340 api_ip_add_del_route (vat_main_t * vam)
5342 unformat_input_t *i = vam->input;
5343 vl_api_ip_add_del_route_t *mp;
5345 u32 sw_if_index = ~0, vrf_id = 0;
5346 u8 sw_if_index_set = 0;
5348 u8 is_local = 0, is_drop = 0;
5349 u8 create_vrf_if_needed = 0;
5351 u8 next_hop_weight = 1;
5353 u8 is_multipath = 0;
5355 u8 address_length_set = 0;
5356 u32 lookup_in_vrf = 0;
5357 u32 resolve_attempts = 0;
5358 u32 dst_address_length = 0;
5359 u8 next_hop_set = 0;
5360 ip4_address_t v4_dst_address, v4_next_hop_address;
5361 ip6_address_t v6_dst_address, v6_next_hop_address;
5365 u32 random_add_del = 0;
5366 u32 *random_vector = 0;
5368 u32 random_seed = 0xdeaddabe;
5369 u32 classify_table_index = ~0;
5372 /* Parse args required to build the message */
5373 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5375 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5376 sw_if_index_set = 1;
5377 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5378 sw_if_index_set = 1;
5379 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
5384 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
5389 else if (unformat (i, "/%d", &dst_address_length))
5391 address_length_set = 1;
5394 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
5395 &v4_next_hop_address))
5399 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
5400 &v6_next_hop_address))
5404 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
5406 else if (unformat (i, "weight %d", &next_hop_weight))
5408 else if (unformat (i, "drop"))
5412 else if (unformat (i, "local"))
5416 else if (unformat (i, "classify %d", &classify_table_index))
5420 else if (unformat (i, "del"))
5422 else if (unformat (i, "add"))
5424 else if (unformat (i, "not-last"))
5426 else if (unformat (i, "multipath"))
5428 else if (unformat (i, "vrf %d", &vrf_id))
5430 else if (unformat (i, "create-vrf"))
5431 create_vrf_if_needed = 1;
5432 else if (unformat (i, "count %d", &count))
5434 else if (unformat (i, "lookup-in-vrf %d", &lookup_in_vrf))
5436 else if (unformat (i, "random"))
5438 else if (unformat (i, "seed %d", &random_seed))
5442 clib_warning ("parse error '%U'", format_unformat_error, i);
5447 if (resolve_attempts > 0 && sw_if_index_set == 0)
5449 errmsg ("ARP resolution needs explicit interface or sw_if_index\n");
5453 if (!next_hop_set && !is_drop && !is_local && !is_classify)
5455 errmsg ("next hop / local / drop / classify not set\n");
5459 if (address_set == 0)
5461 errmsg ("missing addresses\n");
5465 if (address_length_set == 0)
5467 errmsg ("missing address length\n");
5471 /* Generate a pile of unique, random routes */
5474 u32 this_random_address;
5475 random_hash = hash_create (count, sizeof (uword));
5477 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
5478 for (j = 0; j <= count; j++)
5482 this_random_address = random_u32 (&random_seed);
5483 this_random_address =
5484 clib_host_to_net_u32 (this_random_address);
5486 while (hash_get (random_hash, this_random_address));
5487 vec_add1 (random_vector, this_random_address);
5488 hash_set (random_hash, this_random_address, 1);
5490 hash_free (random_hash);
5491 v4_dst_address.as_u32 = random_vector[0];
5496 /* Turn on async mode */
5497 vam->async_mode = 1;
5498 vam->async_errors = 0;
5499 before = vat_time_now (vam);
5502 for (j = 0; j < count; j++)
5504 /* Construct the API message */
5505 M (IP_ADD_DEL_ROUTE, ip_add_del_route);
5507 mp->next_hop_sw_if_index = ntohl (sw_if_index);
5508 mp->vrf_id = ntohl (vrf_id);
5509 if (resolve_attempts > 0)
5511 mp->resolve_attempts = ntohl (resolve_attempts);
5512 mp->resolve_if_needed = 1;
5514 mp->create_vrf_if_needed = create_vrf_if_needed;
5516 mp->is_add = is_add;
5517 mp->is_drop = is_drop;
5518 mp->is_ipv6 = is_ipv6;
5519 mp->is_local = is_local;
5520 mp->is_classify = is_classify;
5521 mp->is_multipath = is_multipath;
5522 mp->not_last = not_last;
5523 mp->next_hop_weight = next_hop_weight;
5524 mp->dst_address_length = dst_address_length;
5525 mp->lookup_in_vrf = ntohl (lookup_in_vrf);
5526 mp->classify_table_index = ntohl (classify_table_index);
5530 clib_memcpy (mp->dst_address, &v6_dst_address,
5531 sizeof (v6_dst_address));
5533 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
5534 sizeof (v6_next_hop_address));
5535 increment_v6_address (&v6_dst_address);
5539 clib_memcpy (mp->dst_address, &v4_dst_address,
5540 sizeof (v4_dst_address));
5542 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
5543 sizeof (v4_next_hop_address));
5545 v4_dst_address.as_u32 = random_vector[j + 1];
5547 increment_v4_address (&v4_dst_address);
5553 /* When testing multiple add/del ops, use a control-ping to sync */
5556 vl_api_control_ping_t *mp;
5559 /* Shut off async mode */
5560 vam->async_mode = 0;
5562 M (CONTROL_PING, control_ping);
5565 timeout = vat_time_now (vam) + 1.0;
5566 while (vat_time_now (vam) < timeout)
5567 if (vam->result_ready == 1)
5572 if (vam->retval == -99)
5573 errmsg ("timeout\n");
5575 if (vam->async_errors > 0)
5577 errmsg ("%d asynchronous errors\n", vam->async_errors);
5580 vam->async_errors = 0;
5581 after = vat_time_now (vam);
5583 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
5584 count, after - before, count / (after - before));
5588 /* Wait for a reply... */
5592 /* Return the good/bad news */
5593 return (vam->retval);
5597 api_proxy_arp_add_del (vat_main_t * vam)
5599 unformat_input_t *i = vam->input;
5600 vl_api_proxy_arp_add_del_t *mp;
5604 ip4_address_t lo, hi;
5607 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5609 if (unformat (i, "vrf %d", &vrf_id))
5611 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
5612 unformat_ip4_address, &hi))
5614 else if (unformat (i, "del"))
5618 clib_warning ("parse error '%U'", format_unformat_error, i);
5625 errmsg ("address range not set\n");
5629 M (PROXY_ARP_ADD_DEL, proxy_arp_add_del);
5631 mp->vrf_id = ntohl (vrf_id);
5632 mp->is_add = is_add;
5633 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
5634 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
5643 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
5645 unformat_input_t *i = vam->input;
5646 vl_api_proxy_arp_intfc_enable_disable_t *mp;
5650 u8 sw_if_index_set = 0;
5652 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5654 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5655 sw_if_index_set = 1;
5656 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5657 sw_if_index_set = 1;
5658 else if (unformat (i, "enable"))
5660 else if (unformat (i, "disable"))
5664 clib_warning ("parse error '%U'", format_unformat_error, i);
5669 if (sw_if_index_set == 0)
5671 errmsg ("missing interface name or sw_if_index\n");
5675 M (PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable);
5677 mp->sw_if_index = ntohl (sw_if_index);
5678 mp->enable_disable = enable;
5687 api_mpls_add_del_decap (vat_main_t * vam)
5689 unformat_input_t *i = vam->input;
5690 vl_api_mpls_add_del_decap_t *mp;
5699 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5701 if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
5703 else if (unformat (i, "tx_vrf_id %d", &tx_vrf_id))
5705 else if (unformat (i, "label %d", &label))
5707 else if (unformat (i, "next-index %d", &next_index))
5709 else if (unformat (i, "del"))
5711 else if (unformat (i, "s-bit-clear"))
5715 clib_warning ("parse error '%U'", format_unformat_error, i);
5720 M (MPLS_ADD_DEL_DECAP, mpls_add_del_decap);
5722 mp->rx_vrf_id = ntohl (rx_vrf_id);
5723 mp->tx_vrf_id = ntohl (tx_vrf_id);
5724 mp->label = ntohl (label);
5725 mp->next_index = ntohl (next_index);
5727 mp->is_add = is_add;
5736 api_mpls_add_del_encap (vat_main_t * vam)
5738 unformat_input_t *i = vam->input;
5739 vl_api_mpls_add_del_encap_t *mp;
5744 ip4_address_t dst_address;
5747 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5749 if (unformat (i, "vrf %d", &vrf_id))
5751 else if (unformat (i, "label %d", &label))
5752 vec_add1 (labels, ntohl (label));
5753 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
5755 else if (unformat (i, "del"))
5759 clib_warning ("parse error '%U'", format_unformat_error, i);
5764 if (vec_len (labels) == 0)
5766 errmsg ("missing encap label stack\n");
5770 M2 (MPLS_ADD_DEL_ENCAP, mpls_add_del_encap,
5771 sizeof (u32) * vec_len (labels));
5773 mp->vrf_id = ntohl (vrf_id);
5774 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
5775 mp->is_add = is_add;
5776 mp->nlabels = vec_len (labels);
5777 clib_memcpy (mp->labels, labels, sizeof (u32) * mp->nlabels);
5788 api_mpls_gre_add_del_tunnel (vat_main_t * vam)
5790 unformat_input_t *i = vam->input;
5791 vl_api_mpls_gre_add_del_tunnel_t *mp;
5793 u32 inner_vrf_id = 0;
5794 u32 outer_vrf_id = 0;
5795 ip4_address_t src_address;
5796 ip4_address_t dst_address;
5797 ip4_address_t intfc_address;
5799 u8 intfc_address_length = 0;
5803 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5805 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
5807 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
5809 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
5811 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
5813 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
5814 &intfc_address, &tmp))
5815 intfc_address_length = tmp;
5816 else if (unformat (i, "l2-only"))
5818 else if (unformat (i, "del"))
5822 clib_warning ("parse error '%U'", format_unformat_error, i);
5827 M (MPLS_GRE_ADD_DEL_TUNNEL, mpls_gre_add_del_tunnel);
5829 mp->inner_vrf_id = ntohl (inner_vrf_id);
5830 mp->outer_vrf_id = ntohl (outer_vrf_id);
5831 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
5832 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
5833 clib_memcpy (mp->intfc_address, &intfc_address, sizeof (intfc_address));
5834 mp->intfc_address_length = intfc_address_length;
5835 mp->l2_only = l2_only;
5836 mp->is_add = is_add;
5845 api_mpls_ethernet_add_del_tunnel (vat_main_t * vam)
5847 unformat_input_t *i = vam->input;
5848 vl_api_mpls_ethernet_add_del_tunnel_t *mp;
5850 u32 inner_vrf_id = 0;
5851 ip4_address_t intfc_address;
5852 u8 dst_mac_address[6];
5855 u8 intfc_address_length = 0;
5859 int tx_sw_if_index_set = 0;
5861 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5863 if (unformat (i, "vrf %d", &inner_vrf_id))
5865 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
5866 &intfc_address, &tmp))
5867 intfc_address_length = tmp;
5868 else if (unformat (i, "%U", unformat_sw_if_index, vam, &tx_sw_if_index))
5869 tx_sw_if_index_set = 1;
5870 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5871 tx_sw_if_index_set = 1;
5872 else if (unformat (i, "dst %U", unformat_ethernet_address,
5875 else if (unformat (i, "l2-only"))
5877 else if (unformat (i, "del"))
5881 clib_warning ("parse error '%U'", format_unformat_error, i);
5888 errmsg ("dst (mac address) not set\n");
5891 if (!tx_sw_if_index_set)
5893 errmsg ("tx-intfc not set\n");
5897 M (MPLS_ETHERNET_ADD_DEL_TUNNEL, mpls_ethernet_add_del_tunnel);
5899 mp->vrf_id = ntohl (inner_vrf_id);
5900 clib_memcpy (mp->adj_address, &intfc_address, sizeof (intfc_address));
5901 mp->adj_address_length = intfc_address_length;
5902 clib_memcpy (mp->dst_mac_address, dst_mac_address,
5903 sizeof (dst_mac_address));
5904 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
5905 mp->l2_only = l2_only;
5906 mp->is_add = is_add;
5915 api_mpls_ethernet_add_del_tunnel_2 (vat_main_t * vam)
5917 unformat_input_t *i = vam->input;
5918 vl_api_mpls_ethernet_add_del_tunnel_2_t *mp;
5920 u32 inner_vrf_id = 0;
5921 u32 outer_vrf_id = 0;
5922 ip4_address_t adj_address;
5923 int adj_address_set = 0;
5924 ip4_address_t next_hop_address;
5925 int next_hop_address_set = 0;
5927 u8 adj_address_length = 0;
5930 u32 resolve_attempts = 5;
5931 u8 resolve_if_needed = 1;
5933 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5935 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
5937 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
5939 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
5940 &adj_address, &tmp))
5942 adj_address_length = tmp;
5943 adj_address_set = 1;
5945 else if (unformat (i, "next-hop %U", unformat_ip4_address,
5947 next_hop_address_set = 1;
5948 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
5950 else if (unformat (i, "resolve-if-needed %d", &tmp))
5951 resolve_if_needed = tmp;
5952 else if (unformat (i, "l2-only"))
5954 else if (unformat (i, "del"))
5958 clib_warning ("parse error '%U'", format_unformat_error, i);
5963 if (!adj_address_set)
5965 errmsg ("adjacency address/mask not set\n");
5968 if (!next_hop_address_set)
5970 errmsg ("ip4 next hop address (in outer fib) not set\n");
5974 M (MPLS_ETHERNET_ADD_DEL_TUNNEL_2, mpls_ethernet_add_del_tunnel_2);
5976 mp->inner_vrf_id = ntohl (inner_vrf_id);
5977 mp->outer_vrf_id = ntohl (outer_vrf_id);
5978 mp->resolve_attempts = ntohl (resolve_attempts);
5979 mp->resolve_if_needed = resolve_if_needed;
5980 mp->is_add = is_add;
5981 mp->l2_only = l2_only;
5982 clib_memcpy (mp->adj_address, &adj_address, sizeof (adj_address));
5983 mp->adj_address_length = adj_address_length;
5984 clib_memcpy (mp->next_hop_ip4_address_in_outer_vrf, &next_hop_address,
5985 sizeof (next_hop_address));
5994 api_sw_interface_set_unnumbered (vat_main_t * vam)
5996 unformat_input_t *i = vam->input;
5997 vl_api_sw_interface_set_unnumbered_t *mp;
6000 u32 unnum_sw_index = ~0;
6002 u8 sw_if_index_set = 0;
6004 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6006 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6007 sw_if_index_set = 1;
6008 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6009 sw_if_index_set = 1;
6010 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
6012 else if (unformat (i, "del"))
6016 clib_warning ("parse error '%U'", format_unformat_error, i);
6021 if (sw_if_index_set == 0)
6023 errmsg ("missing interface name or sw_if_index\n");
6027 M (SW_INTERFACE_SET_UNNUMBERED, sw_interface_set_unnumbered);
6029 mp->sw_if_index = ntohl (sw_if_index);
6030 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
6031 mp->is_add = is_add;
6040 api_ip_neighbor_add_del (vat_main_t * vam)
6042 unformat_input_t *i = vam->input;
6043 vl_api_ip_neighbor_add_del_t *mp;
6046 u8 sw_if_index_set = 0;
6052 u8 v4_address_set = 0;
6053 u8 v6_address_set = 0;
6054 ip4_address_t v4address;
6055 ip6_address_t v6address;
6057 memset (mac_address, 0, sizeof (mac_address));
6059 /* Parse args required to build the message */
6060 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6062 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6066 else if (unformat (i, "del"))
6068 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6069 sw_if_index_set = 1;
6070 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6071 sw_if_index_set = 1;
6072 else if (unformat (i, "is_static"))
6074 else if (unformat (i, "vrf %d", &vrf_id))
6076 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
6078 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
6082 clib_warning ("parse error '%U'", format_unformat_error, i);
6087 if (sw_if_index_set == 0)
6089 errmsg ("missing interface name or sw_if_index\n");
6092 if (v4_address_set && v6_address_set)
6094 errmsg ("both v4 and v6 addresses set\n");
6097 if (!v4_address_set && !v6_address_set)
6099 errmsg ("no address set\n");
6103 /* Construct the API message */
6104 M (IP_NEIGHBOR_ADD_DEL, ip_neighbor_add_del);
6106 mp->sw_if_index = ntohl (sw_if_index);
6107 mp->is_add = is_add;
6108 mp->vrf_id = ntohl (vrf_id);
6109 mp->is_static = is_static;
6111 clib_memcpy (mp->mac_address, mac_address, 6);
6115 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
6119 /* mp->is_ipv6 = 0; via memset in M macro above */
6120 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
6126 /* Wait for a reply, return good/bad news */
6134 api_reset_vrf (vat_main_t * vam)
6136 unformat_input_t *i = vam->input;
6137 vl_api_reset_vrf_t *mp;
6143 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6145 if (unformat (i, "vrf %d", &vrf_id))
6147 else if (unformat (i, "ipv6"))
6151 clib_warning ("parse error '%U'", format_unformat_error, i);
6156 if (vrf_id_set == 0)
6158 errmsg ("missing vrf id\n");
6162 M (RESET_VRF, reset_vrf);
6164 mp->vrf_id = ntohl (vrf_id);
6165 mp->is_ipv6 = is_ipv6;
6174 api_create_vlan_subif (vat_main_t * vam)
6176 unformat_input_t *i = vam->input;
6177 vl_api_create_vlan_subif_t *mp;
6180 u8 sw_if_index_set = 0;
6184 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6186 if (unformat (i, "sw_if_index %d", &sw_if_index))
6187 sw_if_index_set = 1;
6188 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6189 sw_if_index_set = 1;
6190 else if (unformat (i, "vlan %d", &vlan_id))
6194 clib_warning ("parse error '%U'", format_unformat_error, i);
6199 if (sw_if_index_set == 0)
6201 errmsg ("missing interface name or sw_if_index\n");
6205 if (vlan_id_set == 0)
6207 errmsg ("missing vlan_id\n");
6210 M (CREATE_VLAN_SUBIF, create_vlan_subif);
6212 mp->sw_if_index = ntohl (sw_if_index);
6213 mp->vlan_id = ntohl (vlan_id);
6221 #define foreach_create_subif_bit \
6228 _(outer_vlan_id_any) \
6229 _(inner_vlan_id_any)
6232 api_create_subif (vat_main_t * vam)
6234 unformat_input_t *i = vam->input;
6235 vl_api_create_subif_t *mp;
6238 u8 sw_if_index_set = 0;
6245 u32 exact_match = 0;
6246 u32 default_sub = 0;
6247 u32 outer_vlan_id_any = 0;
6248 u32 inner_vlan_id_any = 0;
6250 u16 outer_vlan_id = 0;
6251 u16 inner_vlan_id = 0;
6253 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6255 if (unformat (i, "sw_if_index %d", &sw_if_index))
6256 sw_if_index_set = 1;
6257 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6258 sw_if_index_set = 1;
6259 else if (unformat (i, "sub_id %d", &sub_id))
6261 else if (unformat (i, "outer_vlan_id %d", &tmp))
6262 outer_vlan_id = tmp;
6263 else if (unformat (i, "inner_vlan_id %d", &tmp))
6264 inner_vlan_id = tmp;
6266 #define _(a) else if (unformat (i, #a)) a = 1 ;
6267 foreach_create_subif_bit
6271 clib_warning ("parse error '%U'", format_unformat_error, i);
6276 if (sw_if_index_set == 0)
6278 errmsg ("missing interface name or sw_if_index\n");
6282 if (sub_id_set == 0)
6284 errmsg ("missing sub_id\n");
6287 M (CREATE_SUBIF, create_subif);
6289 mp->sw_if_index = ntohl (sw_if_index);
6290 mp->sub_id = ntohl (sub_id);
6292 #define _(a) mp->a = a;
6293 foreach_create_subif_bit;
6296 mp->outer_vlan_id = ntohs (outer_vlan_id);
6297 mp->inner_vlan_id = ntohs (inner_vlan_id);
6306 api_oam_add_del (vat_main_t * vam)
6308 unformat_input_t *i = vam->input;
6309 vl_api_oam_add_del_t *mp;
6313 ip4_address_t src, dst;
6317 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6319 if (unformat (i, "vrf %d", &vrf_id))
6321 else if (unformat (i, "src %U", unformat_ip4_address, &src))
6323 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
6325 else if (unformat (i, "del"))
6329 clib_warning ("parse error '%U'", format_unformat_error, i);
6336 errmsg ("missing src addr\n");
6342 errmsg ("missing dst addr\n");
6346 M (OAM_ADD_DEL, oam_add_del);
6348 mp->vrf_id = ntohl (vrf_id);
6349 mp->is_add = is_add;
6350 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
6351 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
6360 api_reset_fib (vat_main_t * vam)
6362 unformat_input_t *i = vam->input;
6363 vl_api_reset_fib_t *mp;
6369 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6371 if (unformat (i, "vrf %d", &vrf_id))
6373 else if (unformat (i, "ipv6"))
6377 clib_warning ("parse error '%U'", format_unformat_error, i);
6382 if (vrf_id_set == 0)
6384 errmsg ("missing vrf id\n");
6388 M (RESET_FIB, reset_fib);
6390 mp->vrf_id = ntohl (vrf_id);
6391 mp->is_ipv6 = is_ipv6;
6400 api_dhcp_proxy_config (vat_main_t * vam)
6402 unformat_input_t *i = vam->input;
6403 vl_api_dhcp_proxy_config_t *mp;
6408 u8 v4_address_set = 0;
6409 u8 v6_address_set = 0;
6410 ip4_address_t v4address;
6411 ip6_address_t v6address;
6412 u8 v4_src_address_set = 0;
6413 u8 v6_src_address_set = 0;
6414 ip4_address_t v4srcaddress;
6415 ip6_address_t v6srcaddress;
6417 /* Parse args required to build the message */
6418 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6420 if (unformat (i, "del"))
6422 else if (unformat (i, "vrf %d", &vrf_id))
6424 else if (unformat (i, "insert-cid %d", &insert_cid))
6426 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
6428 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
6430 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
6431 v4_src_address_set = 1;
6432 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
6433 v6_src_address_set = 1;
6438 if (v4_address_set && v6_address_set)
6440 errmsg ("both v4 and v6 server addresses set\n");
6443 if (!v4_address_set && !v6_address_set)
6445 errmsg ("no server addresses set\n");
6449 if (v4_src_address_set && v6_src_address_set)
6451 errmsg ("both v4 and v6 src addresses set\n");
6454 if (!v4_src_address_set && !v6_src_address_set)
6456 errmsg ("no src addresses set\n");
6460 if (!(v4_src_address_set && v4_address_set) &&
6461 !(v6_src_address_set && v6_address_set))
6463 errmsg ("no matching server and src addresses set\n");
6467 /* Construct the API message */
6468 M (DHCP_PROXY_CONFIG, dhcp_proxy_config);
6470 mp->insert_circuit_id = insert_cid;
6471 mp->is_add = is_add;
6472 mp->vrf_id = ntohl (vrf_id);
6476 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
6477 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
6481 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
6482 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
6488 /* Wait for a reply, return good/bad news */
6495 api_dhcp_proxy_config_2 (vat_main_t * vam)
6497 unformat_input_t *i = vam->input;
6498 vl_api_dhcp_proxy_config_2_t *mp;
6501 u32 server_vrf_id = 0;
6504 u8 v4_address_set = 0;
6505 u8 v6_address_set = 0;
6506 ip4_address_t v4address;
6507 ip6_address_t v6address;
6508 u8 v4_src_address_set = 0;
6509 u8 v6_src_address_set = 0;
6510 ip4_address_t v4srcaddress;
6511 ip6_address_t v6srcaddress;
6513 /* Parse args required to build the message */
6514 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6516 if (unformat (i, "del"))
6518 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
6520 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
6522 else if (unformat (i, "insert-cid %d", &insert_cid))
6524 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
6526 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
6528 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
6529 v4_src_address_set = 1;
6530 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
6531 v6_src_address_set = 1;
6536 if (v4_address_set && v6_address_set)
6538 errmsg ("both v4 and v6 server addresses set\n");
6541 if (!v4_address_set && !v6_address_set)
6543 errmsg ("no server addresses set\n");
6547 if (v4_src_address_set && v6_src_address_set)
6549 errmsg ("both v4 and v6 src addresses set\n");
6552 if (!v4_src_address_set && !v6_src_address_set)
6554 errmsg ("no src addresses set\n");
6558 if (!(v4_src_address_set && v4_address_set) &&
6559 !(v6_src_address_set && v6_address_set))
6561 errmsg ("no matching server and src addresses set\n");
6565 /* Construct the API message */
6566 M (DHCP_PROXY_CONFIG_2, dhcp_proxy_config_2);
6568 mp->insert_circuit_id = insert_cid;
6569 mp->is_add = is_add;
6570 mp->rx_vrf_id = ntohl (rx_vrf_id);
6571 mp->server_vrf_id = ntohl (server_vrf_id);
6575 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
6576 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
6580 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
6581 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
6587 /* Wait for a reply, return good/bad news */
6594 api_dhcp_proxy_set_vss (vat_main_t * vam)
6596 unformat_input_t *i = vam->input;
6597 vl_api_dhcp_proxy_set_vss_t *mp;
6608 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6610 if (unformat (i, "tbl_id %d", &tbl_id))
6612 if (unformat (i, "fib_id %d", &fib_id))
6614 if (unformat (i, "oui %d", &oui))
6616 else if (unformat (i, "ipv6"))
6618 else if (unformat (i, "del"))
6622 clib_warning ("parse error '%U'", format_unformat_error, i);
6627 if (tbl_id_set == 0)
6629 errmsg ("missing tbl id\n");
6633 if (fib_id_set == 0)
6635 errmsg ("missing fib id\n");
6640 errmsg ("missing oui\n");
6644 M (DHCP_PROXY_SET_VSS, dhcp_proxy_set_vss);
6645 mp->tbl_id = ntohl (tbl_id);
6646 mp->fib_id = ntohl (fib_id);
6647 mp->oui = ntohl (oui);
6648 mp->is_ipv6 = is_ipv6;
6649 mp->is_add = is_add;
6658 api_dhcp_client_config (vat_main_t * vam)
6660 unformat_input_t *i = vam->input;
6661 vl_api_dhcp_client_config_t *mp;
6664 u8 sw_if_index_set = 0;
6667 u8 disable_event = 0;
6669 /* Parse args required to build the message */
6670 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6672 if (unformat (i, "del"))
6674 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6675 sw_if_index_set = 1;
6676 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6677 sw_if_index_set = 1;
6678 else if (unformat (i, "hostname %s", &hostname))
6680 else if (unformat (i, "disable_event"))
6686 if (sw_if_index_set == 0)
6688 errmsg ("missing interface name or sw_if_index\n");
6692 if (vec_len (hostname) > 63)
6694 errmsg ("hostname too long\n");
6696 vec_add1 (hostname, 0);
6698 /* Construct the API message */
6699 M (DHCP_CLIENT_CONFIG, dhcp_client_config);
6701 mp->sw_if_index = ntohl (sw_if_index);
6702 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
6703 vec_free (hostname);
6704 mp->is_add = is_add;
6705 mp->want_dhcp_event = disable_event ? 0 : 1;
6706 mp->pid = getpid ();
6711 /* Wait for a reply, return good/bad news */
6718 api_set_ip_flow_hash (vat_main_t * vam)
6720 unformat_input_t *i = vam->input;
6721 vl_api_set_ip_flow_hash_t *mp;
6733 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6735 if (unformat (i, "vrf %d", &vrf_id))
6737 else if (unformat (i, "ipv6"))
6739 else if (unformat (i, "src"))
6741 else if (unformat (i, "dst"))
6743 else if (unformat (i, "sport"))
6745 else if (unformat (i, "dport"))
6747 else if (unformat (i, "proto"))
6749 else if (unformat (i, "reverse"))
6754 clib_warning ("parse error '%U'", format_unformat_error, i);
6759 if (vrf_id_set == 0)
6761 errmsg ("missing vrf id\n");
6765 M (SET_IP_FLOW_HASH, set_ip_flow_hash);
6771 mp->reverse = reverse;
6772 mp->vrf_id = ntohl (vrf_id);
6773 mp->is_ipv6 = is_ipv6;
6782 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
6784 unformat_input_t *i = vam->input;
6785 vl_api_sw_interface_ip6_enable_disable_t *mp;
6788 u8 sw_if_index_set = 0;
6791 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6793 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6794 sw_if_index_set = 1;
6795 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6796 sw_if_index_set = 1;
6797 else if (unformat (i, "enable"))
6799 else if (unformat (i, "disable"))
6803 clib_warning ("parse error '%U'", format_unformat_error, i);
6808 if (sw_if_index_set == 0)
6810 errmsg ("missing interface name or sw_if_index\n");
6814 M (SW_INTERFACE_IP6_ENABLE_DISABLE, sw_interface_ip6_enable_disable);
6816 mp->sw_if_index = ntohl (sw_if_index);
6817 mp->enable = enable;
6826 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
6828 unformat_input_t *i = vam->input;
6829 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
6832 u8 sw_if_index_set = 0;
6833 u32 address_length = 0;
6834 u8 v6_address_set = 0;
6835 ip6_address_t v6address;
6837 /* Parse args required to build the message */
6838 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6840 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6841 sw_if_index_set = 1;
6842 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6843 sw_if_index_set = 1;
6844 else if (unformat (i, "%U/%d",
6845 unformat_ip6_address, &v6address, &address_length))
6851 if (sw_if_index_set == 0)
6853 errmsg ("missing interface name or sw_if_index\n");
6856 if (!v6_address_set)
6858 errmsg ("no address set\n");
6862 /* Construct the API message */
6863 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS,
6864 sw_interface_ip6_set_link_local_address);
6866 mp->sw_if_index = ntohl (sw_if_index);
6867 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6868 mp->address_length = address_length;
6873 /* Wait for a reply, return good/bad news */
6882 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
6884 unformat_input_t *i = vam->input;
6885 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
6888 u8 sw_if_index_set = 0;
6889 u32 address_length = 0;
6890 u8 v6_address_set = 0;
6891 ip6_address_t v6address;
6893 u8 no_advertise = 0;
6895 u8 no_autoconfig = 0;
6898 u32 val_lifetime = 0;
6899 u32 pref_lifetime = 0;
6901 /* Parse args required to build the message */
6902 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6904 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6905 sw_if_index_set = 1;
6906 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6907 sw_if_index_set = 1;
6908 else if (unformat (i, "%U/%d",
6909 unformat_ip6_address, &v6address, &address_length))
6911 else if (unformat (i, "val_life %d", &val_lifetime))
6913 else if (unformat (i, "pref_life %d", &pref_lifetime))
6915 else if (unformat (i, "def"))
6917 else if (unformat (i, "noadv"))
6919 else if (unformat (i, "offl"))
6921 else if (unformat (i, "noauto"))
6923 else if (unformat (i, "nolink"))
6925 else if (unformat (i, "isno"))
6929 clib_warning ("parse error '%U'", format_unformat_error, i);
6934 if (sw_if_index_set == 0)
6936 errmsg ("missing interface name or sw_if_index\n");
6939 if (!v6_address_set)
6941 errmsg ("no address set\n");
6945 /* Construct the API message */
6946 M (SW_INTERFACE_IP6ND_RA_PREFIX, sw_interface_ip6nd_ra_prefix);
6948 mp->sw_if_index = ntohl (sw_if_index);
6949 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6950 mp->address_length = address_length;
6951 mp->use_default = use_default;
6952 mp->no_advertise = no_advertise;
6953 mp->off_link = off_link;
6954 mp->no_autoconfig = no_autoconfig;
6955 mp->no_onlink = no_onlink;
6957 mp->val_lifetime = ntohl (val_lifetime);
6958 mp->pref_lifetime = ntohl (pref_lifetime);
6963 /* Wait for a reply, return good/bad news */
6971 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
6973 unformat_input_t *i = vam->input;
6974 vl_api_sw_interface_ip6nd_ra_config_t *mp;
6977 u8 sw_if_index_set = 0;
6982 u8 send_unicast = 0;
6985 u8 default_router = 0;
6986 u32 max_interval = 0;
6987 u32 min_interval = 0;
6989 u32 initial_count = 0;
6990 u32 initial_interval = 0;
6993 /* Parse args required to build the message */
6994 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6996 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6997 sw_if_index_set = 1;
6998 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6999 sw_if_index_set = 1;
7000 else if (unformat (i, "maxint %d", &max_interval))
7002 else if (unformat (i, "minint %d", &min_interval))
7004 else if (unformat (i, "life %d", &lifetime))
7006 else if (unformat (i, "count %d", &initial_count))
7008 else if (unformat (i, "interval %d", &initial_interval))
7010 else if (unformat (i, "suppress") || unformat (i, "surpress"))
7012 else if (unformat (i, "managed"))
7014 else if (unformat (i, "other"))
7016 else if (unformat (i, "ll"))
7018 else if (unformat (i, "send"))
7020 else if (unformat (i, "cease"))
7022 else if (unformat (i, "isno"))
7024 else if (unformat (i, "def"))
7028 clib_warning ("parse error '%U'", format_unformat_error, i);
7033 if (sw_if_index_set == 0)
7035 errmsg ("missing interface name or sw_if_index\n");
7039 /* Construct the API message */
7040 M (SW_INTERFACE_IP6ND_RA_CONFIG, sw_interface_ip6nd_ra_config);
7042 mp->sw_if_index = ntohl (sw_if_index);
7043 mp->max_interval = ntohl (max_interval);
7044 mp->min_interval = ntohl (min_interval);
7045 mp->lifetime = ntohl (lifetime);
7046 mp->initial_count = ntohl (initial_count);
7047 mp->initial_interval = ntohl (initial_interval);
7048 mp->suppress = suppress;
7049 mp->managed = managed;
7051 mp->ll_option = ll_option;
7052 mp->send_unicast = send_unicast;
7055 mp->default_router = default_router;
7060 /* Wait for a reply, return good/bad news */
7068 api_set_arp_neighbor_limit (vat_main_t * vam)
7070 unformat_input_t *i = vam->input;
7071 vl_api_set_arp_neighbor_limit_t *mp;
7077 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7079 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
7081 else if (unformat (i, "ipv6"))
7085 clib_warning ("parse error '%U'", format_unformat_error, i);
7092 errmsg ("missing limit value\n");
7096 M (SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit);
7098 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
7099 mp->is_ipv6 = is_ipv6;
7108 api_l2_patch_add_del (vat_main_t * vam)
7110 unformat_input_t *i = vam->input;
7111 vl_api_l2_patch_add_del_t *mp;
7114 u8 rx_sw_if_index_set = 0;
7116 u8 tx_sw_if_index_set = 0;
7119 /* Parse args required to build the message */
7120 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7122 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
7123 rx_sw_if_index_set = 1;
7124 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
7125 tx_sw_if_index_set = 1;
7126 else if (unformat (i, "rx"))
7128 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7130 if (unformat (i, "%U", unformat_sw_if_index, vam,
7132 rx_sw_if_index_set = 1;
7137 else if (unformat (i, "tx"))
7139 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7141 if (unformat (i, "%U", unformat_sw_if_index, vam,
7143 tx_sw_if_index_set = 1;
7148 else if (unformat (i, "del"))
7154 if (rx_sw_if_index_set == 0)
7156 errmsg ("missing rx interface name or rx_sw_if_index\n");
7160 if (tx_sw_if_index_set == 0)
7162 errmsg ("missing tx interface name or tx_sw_if_index\n");
7166 M (L2_PATCH_ADD_DEL, l2_patch_add_del);
7168 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
7169 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
7170 mp->is_add = is_add;
7179 api_ioam_enable (vat_main_t * vam)
7181 unformat_input_t *input = vam->input;
7182 vl_api_ioam_enable_t *mp;
7185 int has_trace_option = 0;
7186 int has_pow_option = 0;
7187 int has_ppc_option = 0;
7189 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7191 if (unformat (input, "trace"))
7192 has_trace_option = 1;
7193 else if (unformat (input, "pow"))
7195 else if (unformat (input, "ppc encap"))
7196 has_ppc_option = PPC_ENCAP;
7197 else if (unformat (input, "ppc decap"))
7198 has_ppc_option = PPC_DECAP;
7199 else if (unformat (input, "ppc none"))
7200 has_ppc_option = PPC_NONE;
7204 M (IOAM_ENABLE, ioam_enable);
7205 mp->id = htons (id);
7206 mp->trace_ppc = has_ppc_option;
7207 mp->pow_enable = has_pow_option;
7208 mp->trace_enable = has_trace_option;
7219 api_ioam_disable (vat_main_t * vam)
7221 vl_api_ioam_disable_t *mp;
7224 M (IOAM_DISABLE, ioam_disable);
7231 api_sr_tunnel_add_del (vat_main_t * vam)
7233 unformat_input_t *i = vam->input;
7234 vl_api_sr_tunnel_add_del_t *mp;
7238 ip6_address_t src_address;
7239 int src_address_set = 0;
7240 ip6_address_t dst_address;
7242 int dst_address_set = 0;
7244 u32 rx_table_id = 0;
7245 u32 tx_table_id = 0;
7246 ip6_address_t *segments = 0;
7247 ip6_address_t *this_seg;
7248 ip6_address_t *tags = 0;
7249 ip6_address_t *this_tag;
7250 ip6_address_t next_address, tag;
7252 u8 *policy_name = 0;
7254 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7256 if (unformat (i, "del"))
7258 else if (unformat (i, "name %s", &name))
7260 else if (unformat (i, "policy %s", &policy_name))
7262 else if (unformat (i, "rx_fib_id %d", &rx_table_id))
7264 else if (unformat (i, "tx_fib_id %d", &tx_table_id))
7266 else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
7267 src_address_set = 1;
7268 else if (unformat (i, "dst %U/%d",
7269 unformat_ip6_address, &dst_address, &dst_mask_width))
7270 dst_address_set = 1;
7271 else if (unformat (i, "next %U", unformat_ip6_address, &next_address))
7273 vec_add2 (segments, this_seg, 1);
7274 clib_memcpy (this_seg->as_u8, next_address.as_u8,
7275 sizeof (*this_seg));
7277 else if (unformat (i, "tag %U", unformat_ip6_address, &tag))
7279 vec_add2 (tags, this_tag, 1);
7280 clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
7282 else if (unformat (i, "clean"))
7283 flags |= IP6_SR_HEADER_FLAG_CLEANUP;
7284 else if (unformat (i, "protected"))
7285 flags |= IP6_SR_HEADER_FLAG_PROTECTED;
7286 else if (unformat (i, "InPE %d", &pl_index))
7288 if (pl_index <= 0 || pl_index > 4)
7290 pl_index_range_error:
7291 errmsg ("pl index %d out of range\n", pl_index);
7295 IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE << (3 * (pl_index - 1));
7297 else if (unformat (i, "EgPE %d", &pl_index))
7299 if (pl_index <= 0 || pl_index > 4)
7300 goto pl_index_range_error;
7302 IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE << (3 * (pl_index - 1));
7304 else if (unformat (i, "OrgSrc %d", &pl_index))
7306 if (pl_index <= 0 || pl_index > 4)
7307 goto pl_index_range_error;
7309 IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3 * (pl_index - 1));
7315 if (!src_address_set)
7317 errmsg ("src address required\n");
7321 if (!dst_address_set)
7323 errmsg ("dst address required\n");
7329 errmsg ("at least one sr segment required\n");
7333 M2 (SR_TUNNEL_ADD_DEL, sr_tunnel_add_del,
7334 vec_len (segments) * sizeof (ip6_address_t)
7335 + vec_len (tags) * sizeof (ip6_address_t));
7337 clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
7338 clib_memcpy (mp->dst_address, &dst_address, sizeof (mp->dst_address));
7339 mp->dst_mask_width = dst_mask_width;
7340 mp->flags_net_byte_order = clib_host_to_net_u16 (flags);
7341 mp->n_segments = vec_len (segments);
7342 mp->n_tags = vec_len (tags);
7343 mp->is_add = is_del == 0;
7344 clib_memcpy (mp->segs_and_tags, segments,
7345 vec_len (segments) * sizeof (ip6_address_t));
7346 clib_memcpy (mp->segs_and_tags +
7347 vec_len (segments) * sizeof (ip6_address_t), tags,
7348 vec_len (tags) * sizeof (ip6_address_t));
7350 mp->outer_vrf_id = ntohl (rx_table_id);
7351 mp->inner_vrf_id = ntohl (tx_table_id);
7352 memcpy (mp->name, name, vec_len (name));
7353 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
7355 vec_free (segments);
7364 api_sr_policy_add_del (vat_main_t * vam)
7366 unformat_input_t *input = vam->input;
7367 vl_api_sr_policy_add_del_t *mp;
7371 u8 *tunnel_name = 0;
7372 u8 **tunnel_names = 0;
7377 int tunnel_names_length = 1; // Init to 1 to offset the #tunnel_names counter byte
7378 int tun_name_len = 0; // Different naming convention used as confusing these would be "bad" (TM)
7380 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7382 if (unformat (input, "del"))
7384 else if (unformat (input, "name %s", &name))
7386 else if (unformat (input, "tunnel %s", &tunnel_name))
7390 vec_add1 (tunnel_names, tunnel_name);
7392 - length = #bytes to store in serial vector
7393 - +1 = byte to store that length
7395 tunnel_names_length += (vec_len (tunnel_name) + 1);
7406 errmsg ("policy name required\n");
7410 if ((!tunnel_set) && (!is_del))
7412 errmsg ("tunnel name required\n");
7416 M2 (SR_POLICY_ADD_DEL, sr_policy_add_del, tunnel_names_length);
7420 mp->is_add = !is_del;
7422 memcpy (mp->name, name, vec_len (name));
7423 // Since mp->tunnel_names is of type u8[0] and not a u8 *, u8 ** needs to be serialized
7424 u8 *serial_orig = 0;
7425 vec_validate (serial_orig, tunnel_names_length);
7426 *serial_orig = vec_len (tunnel_names); // Store the number of tunnels as length in first byte of serialized vector
7427 serial_orig += 1; // Move along one byte to store the length of first tunnel_name
7429 for (j = 0; j < vec_len (tunnel_names); j++)
7431 tun_name_len = vec_len (tunnel_names[j]);
7432 *serial_orig = tun_name_len; // Store length of tunnel name in first byte of Length/Value pair
7433 serial_orig += 1; // Move along one byte to store the actual tunnel name
7434 memcpy (serial_orig, tunnel_names[j], tun_name_len);
7435 serial_orig += tun_name_len; // Advance past the copy
7437 memcpy (mp->tunnel_names, serial_orig - tunnel_names_length, tunnel_names_length); // Regress serial_orig to head then copy fwd
7439 vec_free (tunnel_names);
7440 vec_free (tunnel_name);
7448 api_sr_multicast_map_add_del (vat_main_t * vam)
7450 unformat_input_t *input = vam->input;
7451 vl_api_sr_multicast_map_add_del_t *mp;
7454 ip6_address_t multicast_address;
7455 u8 *policy_name = 0;
7456 int multicast_address_set = 0;
7458 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7460 if (unformat (input, "del"))
7464 (input, "address %U", unformat_ip6_address, &multicast_address))
7465 multicast_address_set = 1;
7466 else if (unformat (input, "sr-policy %s", &policy_name))
7472 if (!is_del && !policy_name)
7474 errmsg ("sr-policy name required\n");
7479 if (!multicast_address_set)
7481 errmsg ("address required\n");
7485 M (SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del);
7487 mp->is_add = !is_del;
7488 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
7489 clib_memcpy (mp->multicast_address, &multicast_address,
7490 sizeof (mp->multicast_address));
7493 vec_free (policy_name);
7501 #define foreach_ip4_proto_field \
7512 unformat_ip4_mask (unformat_input_t * input, va_list * args)
7514 u8 **maskp = va_arg (*args, u8 **);
7516 u8 found_something = 0;
7519 #define _(a) u8 a=0;
7520 foreach_ip4_proto_field;
7526 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7528 if (unformat (input, "version"))
7530 else if (unformat (input, "hdr_length"))
7532 else if (unformat (input, "src"))
7534 else if (unformat (input, "dst"))
7536 else if (unformat (input, "proto"))
7539 #define _(a) else if (unformat (input, #a)) a=1;
7540 foreach_ip4_proto_field
7546 #define _(a) found_something += a;
7547 foreach_ip4_proto_field;
7550 if (found_something == 0)
7553 vec_validate (mask, sizeof (*ip) - 1);
7555 ip = (ip4_header_t *) mask;
7557 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
7558 foreach_ip4_proto_field;
7561 ip->ip_version_and_header_length = 0;
7564 ip->ip_version_and_header_length |= 0xF0;
7567 ip->ip_version_and_header_length |= 0x0F;
7573 #define foreach_ip6_proto_field \
7581 unformat_ip6_mask (unformat_input_t * input, va_list * args)
7583 u8 **maskp = va_arg (*args, u8 **);
7585 u8 found_something = 0;
7587 u32 ip_version_traffic_class_and_flow_label;
7589 #define _(a) u8 a=0;
7590 foreach_ip6_proto_field;
7593 u8 traffic_class = 0;
7596 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7598 if (unformat (input, "version"))
7600 else if (unformat (input, "traffic-class"))
7602 else if (unformat (input, "flow-label"))
7604 else if (unformat (input, "src"))
7606 else if (unformat (input, "dst"))
7608 else if (unformat (input, "proto"))
7611 #define _(a) else if (unformat (input, #a)) a=1;
7612 foreach_ip6_proto_field
7618 #define _(a) found_something += a;
7619 foreach_ip6_proto_field;
7622 if (found_something == 0)
7625 vec_validate (mask, sizeof (*ip) - 1);
7627 ip = (ip6_header_t *) mask;
7629 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
7630 foreach_ip6_proto_field;
7633 ip_version_traffic_class_and_flow_label = 0;
7636 ip_version_traffic_class_and_flow_label |= 0xF0000000;
7639 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
7642 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
7644 ip->ip_version_traffic_class_and_flow_label =
7645 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
7652 unformat_l3_mask (unformat_input_t * input, va_list * args)
7654 u8 **maskp = va_arg (*args, u8 **);
7656 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7658 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
7660 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
7669 unformat_l2_mask (unformat_input_t * input, va_list * args)
7671 u8 **maskp = va_arg (*args, u8 **);
7686 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7688 if (unformat (input, "src"))
7690 else if (unformat (input, "dst"))
7692 else if (unformat (input, "proto"))
7694 else if (unformat (input, "tag1"))
7696 else if (unformat (input, "tag2"))
7698 else if (unformat (input, "ignore-tag1"))
7700 else if (unformat (input, "ignore-tag2"))
7702 else if (unformat (input, "cos1"))
7704 else if (unformat (input, "cos2"))
7706 else if (unformat (input, "dot1q"))
7708 else if (unformat (input, "dot1ad"))
7713 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
7714 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
7717 if (tag1 || ignore_tag1 || cos1 || dot1q)
7719 if (tag2 || ignore_tag2 || cos2 || dot1ad)
7722 vec_validate (mask, len - 1);
7725 memset (mask, 0xff, 6);
7728 memset (mask + 6, 0xff, 6);
7732 /* inner vlan tag */
7741 mask[21] = mask[20] = 0xff;
7762 mask[16] = mask[17] = 0xff;
7772 mask[12] = mask[13] = 0xff;
7779 unformat_classify_mask (unformat_input_t * input, va_list * args)
7781 u8 **maskp = va_arg (*args, u8 **);
7782 u32 *skipp = va_arg (*args, u32 *);
7783 u32 *matchp = va_arg (*args, u32 *);
7790 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7792 if (unformat (input, "hex %U", unformat_hex_string, &mask))
7794 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
7796 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
7802 if (mask || l2 || l3)
7806 /* "With a free Ethernet header in every package" */
7808 vec_validate (l2, 13);
7812 vec_append (mask, l3);
7817 /* Scan forward looking for the first significant mask octet */
7818 for (i = 0; i < vec_len (mask); i++)
7822 /* compute (skip, match) params */
7823 *skipp = i / sizeof (u32x4);
7824 vec_delete (mask, *skipp * sizeof (u32x4), 0);
7826 /* Pad mask to an even multiple of the vector size */
7827 while (vec_len (mask) % sizeof (u32x4))
7830 match = vec_len (mask) / sizeof (u32x4);
7832 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
7834 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
7835 if (*tmp || *(tmp + 1))
7840 clib_warning ("BUG: match 0");
7842 _vec_len (mask) = match * sizeof (u32x4);
7853 #define foreach_l2_next \
7855 _(ethernet, ETHERNET_INPUT) \
7860 unformat_l2_next_index (unformat_input_t * input, va_list * args)
7862 u32 *miss_next_indexp = va_arg (*args, u32 *);
7867 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
7871 if (unformat (input, "%d", &tmp))
7880 *miss_next_indexp = next_index;
7884 #define foreach_ip_next \
7891 unformat_ip_next_index (unformat_input_t * input, va_list * args)
7893 u32 *miss_next_indexp = va_arg (*args, u32 *);
7898 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
7902 if (unformat (input, "%d", &tmp))
7911 *miss_next_indexp = next_index;
7915 #define foreach_acl_next \
7919 unformat_acl_next_index (unformat_input_t * input, va_list * args)
7921 u32 *miss_next_indexp = va_arg (*args, u32 *);
7926 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
7930 if (unformat (input, "permit"))
7935 else if (unformat (input, "%d", &tmp))
7944 *miss_next_indexp = next_index;
7949 unformat_policer_precolor (unformat_input_t * input, va_list * args)
7951 u32 *r = va_arg (*args, u32 *);
7953 if (unformat (input, "conform-color"))
7954 *r = POLICE_CONFORM;
7955 else if (unformat (input, "exceed-color"))
7964 api_classify_add_del_table (vat_main_t * vam)
7966 unformat_input_t *i = vam->input;
7967 vl_api_classify_add_del_table_t *mp;
7973 u32 table_index = ~0;
7974 u32 next_table_index = ~0;
7975 u32 miss_next_index = ~0;
7976 u32 memory_size = 32 << 20;
7980 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7982 if (unformat (i, "del"))
7984 else if (unformat (i, "buckets %d", &nbuckets))
7986 else if (unformat (i, "memory_size %d", &memory_size))
7988 else if (unformat (i, "skip %d", &skip))
7990 else if (unformat (i, "match %d", &match))
7992 else if (unformat (i, "table %d", &table_index))
7994 else if (unformat (i, "mask %U", unformat_classify_mask,
7995 &mask, &skip, &match))
7997 else if (unformat (i, "next-table %d", &next_table_index))
7999 else if (unformat (i, "miss-next %U", unformat_ip_next_index,
8002 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
8005 else if (unformat (i, "acl-miss-next %U", unformat_acl_next_index,
8012 if (is_add && mask == 0)
8014 errmsg ("Mask required\n");
8018 if (is_add && skip == ~0)
8020 errmsg ("skip count required\n");
8024 if (is_add && match == ~0)
8026 errmsg ("match count required\n");
8030 if (!is_add && table_index == ~0)
8032 errmsg ("table index required for delete\n");
8036 M2 (CLASSIFY_ADD_DEL_TABLE, classify_add_del_table, vec_len (mask));
8038 mp->is_add = is_add;
8039 mp->table_index = ntohl (table_index);
8040 mp->nbuckets = ntohl (nbuckets);
8041 mp->memory_size = ntohl (memory_size);
8042 mp->skip_n_vectors = ntohl (skip);
8043 mp->match_n_vectors = ntohl (match);
8044 mp->next_table_index = ntohl (next_table_index);
8045 mp->miss_next_index = ntohl (miss_next_index);
8046 clib_memcpy (mp->mask, mask, vec_len (mask));
8056 unformat_ip4_match (unformat_input_t * input, va_list * args)
8058 u8 **matchp = va_arg (*args, u8 **);
8065 int src = 0, dst = 0;
8066 ip4_address_t src_val, dst_val;
8073 int fragment_id = 0;
8074 u32 fragment_id_val;
8080 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8082 if (unformat (input, "version %d", &version_val))
8084 else if (unformat (input, "hdr_length %d", &hdr_length_val))
8086 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
8088 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
8090 else if (unformat (input, "proto %d", &proto_val))
8092 else if (unformat (input, "tos %d", &tos_val))
8094 else if (unformat (input, "length %d", &length_val))
8096 else if (unformat (input, "fragment_id %d", &fragment_id_val))
8098 else if (unformat (input, "ttl %d", &ttl_val))
8100 else if (unformat (input, "checksum %d", &checksum_val))
8106 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
8107 + ttl + checksum == 0)
8111 * Aligned because we use the real comparison functions
8113 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
8115 ip = (ip4_header_t *) match;
8117 /* These are realistically matched in practice */
8119 ip->src_address.as_u32 = src_val.as_u32;
8122 ip->dst_address.as_u32 = dst_val.as_u32;
8125 ip->protocol = proto_val;
8128 /* These are not, but they're included for completeness */
8130 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
8133 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
8139 ip->length = length_val;
8145 ip->checksum = checksum_val;
8152 unformat_ip6_match (unformat_input_t * input, va_list * args)
8154 u8 **matchp = va_arg (*args, u8 **);
8159 u8 traffic_class = 0;
8160 u32 traffic_class_val = 0;
8163 int src = 0, dst = 0;
8164 ip6_address_t src_val, dst_val;
8167 int payload_length = 0;
8168 u32 payload_length_val;
8171 u32 ip_version_traffic_class_and_flow_label;
8173 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8175 if (unformat (input, "version %d", &version_val))
8177 else if (unformat (input, "traffic_class %d", &traffic_class_val))
8179 else if (unformat (input, "flow_label %d", &flow_label_val))
8181 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
8183 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
8185 else if (unformat (input, "proto %d", &proto_val))
8187 else if (unformat (input, "payload_length %d", &payload_length_val))
8189 else if (unformat (input, "hop_limit %d", &hop_limit_val))
8195 if (version + traffic_class + flow_label + src + dst + proto +
8196 payload_length + hop_limit == 0)
8200 * Aligned because we use the real comparison functions
8202 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
8204 ip = (ip6_header_t *) match;
8207 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
8210 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
8213 ip->protocol = proto_val;
8215 ip_version_traffic_class_and_flow_label = 0;
8218 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
8221 ip_version_traffic_class_and_flow_label |=
8222 (traffic_class_val & 0xFF) << 20;
8225 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
8227 ip->ip_version_traffic_class_and_flow_label =
8228 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
8231 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
8234 ip->hop_limit = hop_limit_val;
8241 unformat_l3_match (unformat_input_t * input, va_list * args)
8243 u8 **matchp = va_arg (*args, u8 **);
8245 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8247 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
8249 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
8258 unformat_vlan_tag (unformat_input_t * input, va_list * args)
8260 u8 *tagp = va_arg (*args, u8 *);
8263 if (unformat (input, "%d", &tag))
8265 tagp[0] = (tag >> 8) & 0x0F;
8266 tagp[1] = tag & 0xFF;
8274 unformat_l2_match (unformat_input_t * input, va_list * args)
8276 u8 **matchp = va_arg (*args, u8 **);
8296 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8298 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
8301 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
8303 else if (unformat (input, "proto %U",
8304 unformat_ethernet_type_host_byte_order, &proto_val))
8306 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
8308 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
8310 else if (unformat (input, "ignore-tag1"))
8312 else if (unformat (input, "ignore-tag2"))
8314 else if (unformat (input, "cos1 %d", &cos1_val))
8316 else if (unformat (input, "cos2 %d", &cos2_val))
8321 if ((src + dst + proto + tag1 + tag2 +
8322 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
8325 if (tag1 || ignore_tag1 || cos1)
8327 if (tag2 || ignore_tag2 || cos2)
8330 vec_validate_aligned (match, len - 1, sizeof (u32x4));
8333 clib_memcpy (match, dst_val, 6);
8336 clib_memcpy (match + 6, src_val, 6);
8340 /* inner vlan tag */
8341 match[19] = tag2_val[1];
8342 match[18] = tag2_val[0];
8344 match[18] |= (cos2_val & 0x7) << 5;
8347 match[21] = proto_val & 0xff;
8348 match[20] = proto_val >> 8;
8352 match[15] = tag1_val[1];
8353 match[14] = tag1_val[0];
8356 match[14] |= (cos1_val & 0x7) << 5;
8362 match[15] = tag1_val[1];
8363 match[14] = tag1_val[0];
8366 match[17] = proto_val & 0xff;
8367 match[16] = proto_val >> 8;
8370 match[14] |= (cos1_val & 0x7) << 5;
8376 match[18] |= (cos2_val & 0x7) << 5;
8378 match[14] |= (cos1_val & 0x7) << 5;
8381 match[13] = proto_val & 0xff;
8382 match[12] = proto_val >> 8;
8391 unformat_classify_match (unformat_input_t * input, va_list * args)
8393 u8 **matchp = va_arg (*args, u8 **);
8394 u32 skip_n_vectors = va_arg (*args, u32);
8395 u32 match_n_vectors = va_arg (*args, u32);
8401 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8403 if (unformat (input, "hex %U", unformat_hex_string, &match))
8405 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
8407 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
8413 if (match || l2 || l3)
8417 /* "Win a free Ethernet header in every packet" */
8419 vec_validate_aligned (l2, 13, sizeof (u32x4));
8423 vec_append_aligned (match, l3, sizeof (u32x4));
8428 /* Make sure the vector is big enough even if key is all 0's */
8429 vec_validate_aligned
8430 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
8433 /* Set size, include skipped vectors */
8434 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
8445 api_classify_add_del_session (vat_main_t * vam)
8447 unformat_input_t *i = vam->input;
8448 vl_api_classify_add_del_session_t *mp;
8450 u32 table_index = ~0;
8451 u32 hit_next_index = ~0;
8452 u32 opaque_index = ~0;
8456 u32 skip_n_vectors = 0;
8457 u32 match_n_vectors = 0;
8460 * Warning: you have to supply skip_n and match_n
8461 * because the API client cant simply look at the classify
8465 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8467 if (unformat (i, "del"))
8469 else if (unformat (i, "hit-next %U", unformat_ip_next_index,
8472 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
8475 else if (unformat (i, "acl-hit-next %U", unformat_acl_next_index,
8478 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
8480 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
8482 else if (unformat (i, "opaque-index %d", &opaque_index))
8484 else if (unformat (i, "skip_n %d", &skip_n_vectors))
8486 else if (unformat (i, "match_n %d", &match_n_vectors))
8488 else if (unformat (i, "match %U", unformat_classify_match,
8489 &match, skip_n_vectors, match_n_vectors))
8491 else if (unformat (i, "advance %d", &advance))
8493 else if (unformat (i, "table-index %d", &table_index))
8499 if (table_index == ~0)
8501 errmsg ("Table index required\n");
8505 if (is_add && match == 0)
8507 errmsg ("Match value required\n");
8511 M2 (CLASSIFY_ADD_DEL_SESSION, classify_add_del_session, vec_len (match));
8513 mp->is_add = is_add;
8514 mp->table_index = ntohl (table_index);
8515 mp->hit_next_index = ntohl (hit_next_index);
8516 mp->opaque_index = ntohl (opaque_index);
8517 mp->advance = ntohl (advance);
8518 clib_memcpy (mp->match, match, vec_len (match));
8527 api_classify_set_interface_ip_table (vat_main_t * vam)
8529 unformat_input_t *i = vam->input;
8530 vl_api_classify_set_interface_ip_table_t *mp;
8533 int sw_if_index_set;
8534 u32 table_index = ~0;
8537 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8539 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8540 sw_if_index_set = 1;
8541 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8542 sw_if_index_set = 1;
8543 else if (unformat (i, "table %d", &table_index))
8547 clib_warning ("parse error '%U'", format_unformat_error, i);
8552 if (sw_if_index_set == 0)
8554 errmsg ("missing interface name or sw_if_index\n");
8559 M (CLASSIFY_SET_INTERFACE_IP_TABLE, classify_set_interface_ip_table);
8561 mp->sw_if_index = ntohl (sw_if_index);
8562 mp->table_index = ntohl (table_index);
8563 mp->is_ipv6 = is_ipv6;
8572 api_classify_set_interface_l2_tables (vat_main_t * vam)
8574 unformat_input_t *i = vam->input;
8575 vl_api_classify_set_interface_l2_tables_t *mp;
8578 int sw_if_index_set;
8579 u32 ip4_table_index = ~0;
8580 u32 ip6_table_index = ~0;
8581 u32 other_table_index = ~0;
8584 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8586 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8587 sw_if_index_set = 1;
8588 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8589 sw_if_index_set = 1;
8590 else if (unformat (i, "ip4-table %d", &ip4_table_index))
8592 else if (unformat (i, "ip6-table %d", &ip6_table_index))
8594 else if (unformat (i, "other-table %d", &other_table_index))
8596 else if (unformat (i, "is-input %d", &is_input))
8600 clib_warning ("parse error '%U'", format_unformat_error, i);
8605 if (sw_if_index_set == 0)
8607 errmsg ("missing interface name or sw_if_index\n");
8612 M (CLASSIFY_SET_INTERFACE_L2_TABLES, classify_set_interface_l2_tables);
8614 mp->sw_if_index = ntohl (sw_if_index);
8615 mp->ip4_table_index = ntohl (ip4_table_index);
8616 mp->ip6_table_index = ntohl (ip6_table_index);
8617 mp->other_table_index = ntohl (other_table_index);
8618 mp->is_input = (u8) is_input;
8627 api_set_ipfix_exporter (vat_main_t * vam)
8629 unformat_input_t *i = vam->input;
8630 vl_api_set_ipfix_exporter_t *mp;
8631 ip4_address_t collector_address;
8632 u8 collector_address_set = 0;
8633 u32 collector_port = ~0;
8634 ip4_address_t src_address;
8635 u8 src_address_set = 0;
8638 u32 template_interval = ~0;
8639 u8 udp_checksum = 0;
8642 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8644 if (unformat (i, "collector_address %U", unformat_ip4_address,
8645 &collector_address))
8646 collector_address_set = 1;
8647 else if (unformat (i, "collector_port %d", &collector_port))
8649 else if (unformat (i, "src_address %U", unformat_ip4_address,
8651 src_address_set = 1;
8652 else if (unformat (i, "vrf_id %d", &vrf_id))
8654 else if (unformat (i, "path_mtu %d", &path_mtu))
8656 else if (unformat (i, "template_interval %d", &template_interval))
8658 else if (unformat (i, "udp_checksum"))
8664 if (collector_address_set == 0)
8666 errmsg ("collector_address required\n");
8670 if (src_address_set == 0)
8672 errmsg ("src_address required\n");
8676 M (SET_IPFIX_EXPORTER, set_ipfix_exporter);
8678 memcpy (mp->collector_address, collector_address.data,
8679 sizeof (collector_address.data));
8680 mp->collector_port = htons ((u16) collector_port);
8681 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
8682 mp->vrf_id = htonl (vrf_id);
8683 mp->path_mtu = htonl (path_mtu);
8684 mp->template_interval = htonl (template_interval);
8685 mp->udp_checksum = udp_checksum;
8693 api_set_ipfix_classify_stream (vat_main_t * vam)
8695 unformat_input_t *i = vam->input;
8696 vl_api_set_ipfix_classify_stream_t *mp;
8698 u32 src_port = UDP_DST_PORT_ipfix;
8701 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8703 if (unformat (i, "domain %d", &domain_id))
8705 else if (unformat (i, "src_port %d", &src_port))
8709 errmsg ("unknown input `%U'", format_unformat_error, i);
8714 M (SET_IPFIX_CLASSIFY_STREAM, set_ipfix_classify_stream);
8716 mp->domain_id = htonl (domain_id);
8717 mp->src_port = htons ((u16) src_port);
8725 api_ipfix_classify_table_add_del (vat_main_t * vam)
8727 unformat_input_t *i = vam->input;
8728 vl_api_ipfix_classify_table_add_del_t *mp;
8730 u32 classify_table_index;
8732 u8 transport_protocol = 255;
8735 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8737 if (unformat (i, "add"))
8739 else if (unformat (i, "del"))
8741 else if (unformat (i, "table %d", &classify_table_index))
8743 else if (unformat (i, "ip4"))
8745 else if (unformat (i, "ip6"))
8747 else if (unformat (i, "tcp"))
8748 transport_protocol = 6;
8749 else if (unformat (i, "udp"))
8750 transport_protocol = 17;
8753 errmsg ("unknown input `%U'", format_unformat_error, i);
8760 errmsg ("expecting: add|del");
8763 if (classify_table_index == ~0)
8765 errmsg ("classifier table not specified");
8768 if (ip_version == 0)
8770 errmsg ("IP version not specified");
8774 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, ipfix_classify_table_add_del);
8776 mp->is_add = is_add;
8777 mp->table_id = htonl (classify_table_index);
8778 mp->ip_version = ip_version;
8779 mp->transport_protocol = transport_protocol;
8787 api_get_node_index (vat_main_t * vam)
8789 unformat_input_t *i = vam->input;
8790 vl_api_get_node_index_t *mp;
8794 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8796 if (unformat (i, "node %s", &name))
8803 errmsg ("node name required\n");
8806 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
8808 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
8812 M (GET_NODE_INDEX, get_node_index);
8813 clib_memcpy (mp->node_name, name, vec_len (name));
8823 api_get_next_index (vat_main_t * vam)
8825 unformat_input_t *i = vam->input;
8826 vl_api_get_next_index_t *mp;
8828 u8 *node_name = 0, *next_node_name = 0;
8830 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8832 if (unformat (i, "node-name %s", &node_name))
8834 else if (unformat (i, "next-node-name %s", &next_node_name))
8840 errmsg ("node name required\n");
8843 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
8845 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
8849 if (next_node_name == 0)
8851 errmsg ("next node name required\n");
8854 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
8856 errmsg ("next node name too long, max %d\n", ARRAY_LEN (mp->next_name));
8860 M (GET_NEXT_INDEX, get_next_index);
8861 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
8862 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
8863 vec_free (node_name);
8864 vec_free (next_node_name);
8873 api_add_node_next (vat_main_t * vam)
8875 unformat_input_t *i = vam->input;
8876 vl_api_add_node_next_t *mp;
8881 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8883 if (unformat (i, "node %s", &name))
8885 else if (unformat (i, "next %s", &next))
8892 errmsg ("node name required\n");
8895 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
8897 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
8902 errmsg ("next node required\n");
8905 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
8907 errmsg ("next name too long, max %d\n", ARRAY_LEN (mp->next_name));
8911 M (ADD_NODE_NEXT, add_node_next);
8912 clib_memcpy (mp->node_name, name, vec_len (name));
8913 clib_memcpy (mp->next_name, next, vec_len (next));
8924 api_l2tpv3_create_tunnel (vat_main_t * vam)
8926 unformat_input_t *i = vam->input;
8927 ip6_address_t client_address, our_address;
8928 int client_address_set = 0;
8929 int our_address_set = 0;
8930 u32 local_session_id = 0;
8931 u32 remote_session_id = 0;
8932 u64 local_cookie = 0;
8933 u64 remote_cookie = 0;
8934 u8 l2_sublayer_present = 0;
8935 vl_api_l2tpv3_create_tunnel_t *mp;
8938 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8940 if (unformat (i, "client_address %U", unformat_ip6_address,
8942 client_address_set = 1;
8943 else if (unformat (i, "our_address %U", unformat_ip6_address,
8945 our_address_set = 1;
8946 else if (unformat (i, "local_session_id %d", &local_session_id))
8948 else if (unformat (i, "remote_session_id %d", &remote_session_id))
8950 else if (unformat (i, "local_cookie %lld", &local_cookie))
8952 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
8954 else if (unformat (i, "l2-sublayer-present"))
8955 l2_sublayer_present = 1;
8960 if (client_address_set == 0)
8962 errmsg ("client_address required\n");
8966 if (our_address_set == 0)
8968 errmsg ("our_address required\n");
8972 M (L2TPV3_CREATE_TUNNEL, l2tpv3_create_tunnel);
8974 clib_memcpy (mp->client_address, client_address.as_u8,
8975 sizeof (mp->client_address));
8977 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
8979 mp->local_session_id = ntohl (local_session_id);
8980 mp->remote_session_id = ntohl (remote_session_id);
8981 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
8982 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
8983 mp->l2_sublayer_present = l2_sublayer_present;
8993 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
8995 unformat_input_t *i = vam->input;
8997 u8 sw_if_index_set = 0;
8998 u64 new_local_cookie = 0;
8999 u64 new_remote_cookie = 0;
9000 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
9003 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9005 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9006 sw_if_index_set = 1;
9007 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9008 sw_if_index_set = 1;
9009 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
9011 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
9017 if (sw_if_index_set == 0)
9019 errmsg ("missing interface name or sw_if_index\n");
9023 M (L2TPV3_SET_TUNNEL_COOKIES, l2tpv3_set_tunnel_cookies);
9025 mp->sw_if_index = ntohl (sw_if_index);
9026 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
9027 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
9036 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
9038 unformat_input_t *i = vam->input;
9039 vl_api_l2tpv3_interface_enable_disable_t *mp;
9042 u8 sw_if_index_set = 0;
9043 u8 enable_disable = 1;
9045 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9047 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9048 sw_if_index_set = 1;
9049 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9050 sw_if_index_set = 1;
9051 else if (unformat (i, "enable"))
9053 else if (unformat (i, "disable"))
9059 if (sw_if_index_set == 0)
9061 errmsg ("missing interface name or sw_if_index\n");
9065 M (L2TPV3_INTERFACE_ENABLE_DISABLE, l2tpv3_interface_enable_disable);
9067 mp->sw_if_index = ntohl (sw_if_index);
9068 mp->enable_disable = enable_disable;
9077 api_l2tpv3_set_lookup_key (vat_main_t * vam)
9079 unformat_input_t *i = vam->input;
9080 vl_api_l2tpv3_set_lookup_key_t *mp;
9084 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9086 if (unformat (i, "lookup_v6_src"))
9087 key = L2T_LOOKUP_SRC_ADDRESS;
9088 else if (unformat (i, "lookup_v6_dst"))
9089 key = L2T_LOOKUP_DST_ADDRESS;
9090 else if (unformat (i, "lookup_session_id"))
9091 key = L2T_LOOKUP_SESSION_ID;
9096 if (key == (u8) ~ 0)
9098 errmsg ("l2tp session lookup key unset\n");
9102 M (L2TPV3_SET_LOOKUP_KEY, l2tpv3_set_lookup_key);
9112 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
9113 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
9115 vat_main_t *vam = &vat_main;
9117 fformat (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)\n",
9118 format_ip6_address, mp->our_address,
9119 format_ip6_address, mp->client_address,
9120 clib_net_to_host_u32 (mp->sw_if_index));
9123 " local cookies %016llx %016llx remote cookie %016llx\n",
9124 clib_net_to_host_u64 (mp->local_cookie[0]),
9125 clib_net_to_host_u64 (mp->local_cookie[1]),
9126 clib_net_to_host_u64 (mp->remote_cookie));
9128 fformat (vam->ofp, " local session-id %d remote session-id %d\n",
9129 clib_net_to_host_u32 (mp->local_session_id),
9130 clib_net_to_host_u32 (mp->remote_session_id));
9132 fformat (vam->ofp, " l2 specific sublayer %s\n\n",
9133 mp->l2_sublayer_present ? "preset" : "absent");
9137 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
9138 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
9140 vat_main_t *vam = &vat_main;
9141 vat_json_node_t *node = NULL;
9142 struct in6_addr addr;
9144 if (VAT_JSON_ARRAY != vam->json_tree.type)
9146 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9147 vat_json_init_array (&vam->json_tree);
9149 node = vat_json_array_add (&vam->json_tree);
9151 vat_json_init_object (node);
9153 clib_memcpy (&addr, mp->our_address, sizeof (addr));
9154 vat_json_object_add_ip6 (node, "our_address", addr);
9155 clib_memcpy (&addr, mp->client_address, sizeof (addr));
9156 vat_json_object_add_ip6 (node, "client_address", addr);
9158 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
9159 vat_json_init_array (lc);
9160 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
9161 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
9162 vat_json_object_add_uint (node, "remote_cookie",
9163 clib_net_to_host_u64 (mp->remote_cookie));
9165 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
9166 vat_json_object_add_uint (node, "local_session_id",
9167 clib_net_to_host_u32 (mp->local_session_id));
9168 vat_json_object_add_uint (node, "remote_session_id",
9169 clib_net_to_host_u32 (mp->remote_session_id));
9170 vat_json_object_add_string_copy (node, "l2_sublayer",
9171 mp->l2_sublayer_present ? (u8 *) "present"
9176 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
9178 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
9181 /* Get list of l2tpv3-tunnel interfaces */
9182 M (SW_IF_L2TPV3_TUNNEL_DUMP, sw_if_l2tpv3_tunnel_dump);
9185 /* Use a control ping for synchronization */
9187 vl_api_control_ping_t *mp;
9188 M (CONTROL_PING, control_ping);
9195 static void vl_api_sw_interface_tap_details_t_handler
9196 (vl_api_sw_interface_tap_details_t * mp)
9198 vat_main_t *vam = &vat_main;
9200 fformat (vam->ofp, "%-16s %d\n",
9201 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
9204 static void vl_api_sw_interface_tap_details_t_handler_json
9205 (vl_api_sw_interface_tap_details_t * mp)
9207 vat_main_t *vam = &vat_main;
9208 vat_json_node_t *node = NULL;
9210 if (VAT_JSON_ARRAY != vam->json_tree.type)
9212 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9213 vat_json_init_array (&vam->json_tree);
9215 node = vat_json_array_add (&vam->json_tree);
9217 vat_json_init_object (node);
9218 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9219 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
9223 api_sw_interface_tap_dump (vat_main_t * vam)
9225 vl_api_sw_interface_tap_dump_t *mp;
9228 fformat (vam->ofp, "\n%-16s %s\n", "dev_name", "sw_if_index");
9229 /* Get list of tap interfaces */
9230 M (SW_INTERFACE_TAP_DUMP, sw_interface_tap_dump);
9233 /* Use a control ping for synchronization */
9235 vl_api_control_ping_t *mp;
9236 M (CONTROL_PING, control_ping);
9242 static uword unformat_vxlan_decap_next
9243 (unformat_input_t * input, va_list * args)
9245 u32 *result = va_arg (*args, u32 *);
9248 if (unformat (input, "drop"))
9249 *result = VXLAN_INPUT_NEXT_DROP;
9250 else if (unformat (input, "ip4"))
9251 *result = VXLAN_INPUT_NEXT_IP4_INPUT;
9252 else if (unformat (input, "ip6"))
9253 *result = VXLAN_INPUT_NEXT_IP6_INPUT;
9254 else if (unformat (input, "l2"))
9255 *result = VXLAN_INPUT_NEXT_L2_INPUT;
9256 else if (unformat (input, "%d", &tmp))
9264 api_vxlan_add_del_tunnel (vat_main_t * vam)
9266 unformat_input_t *line_input = vam->input;
9267 vl_api_vxlan_add_del_tunnel_t *mp;
9269 ip4_address_t src4, dst4;
9270 ip6_address_t src6, dst6;
9272 u8 ipv4_set = 0, ipv6_set = 0;
9275 u32 encap_vrf_id = 0;
9276 u32 decap_next_index = ~0;
9279 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9281 if (unformat (line_input, "del"))
9283 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
9288 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
9293 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
9298 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
9303 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
9305 else if (unformat (line_input, "decap-next %U",
9306 unformat_vxlan_decap_next, &decap_next_index))
9308 else if (unformat (line_input, "vni %d", &vni))
9312 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
9319 errmsg ("tunnel src address not specified\n");
9324 errmsg ("tunnel dst address not specified\n");
9328 if (ipv4_set && ipv6_set)
9330 errmsg ("both IPv4 and IPv6 addresses specified");
9334 if ((vni == 0) || (vni >> 24))
9336 errmsg ("vni not specified or out of range\n");
9340 M (VXLAN_ADD_DEL_TUNNEL, vxlan_add_del_tunnel);
9344 clib_memcpy (&mp->src_address, &src6, sizeof (src6));
9345 clib_memcpy (&mp->dst_address, &dst6, sizeof (dst6));
9349 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
9350 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
9352 mp->encap_vrf_id = ntohl (encap_vrf_id);
9353 mp->decap_next_index = ntohl (decap_next_index);
9354 mp->vni = ntohl (vni);
9355 mp->is_add = is_add;
9356 mp->is_ipv6 = ipv6_set;
9364 static void vl_api_vxlan_tunnel_details_t_handler
9365 (vl_api_vxlan_tunnel_details_t * mp)
9367 vat_main_t *vam = &vat_main;
9369 fformat (vam->ofp, "%11d%24U%24U%14d%18d%13d\n",
9370 ntohl (mp->sw_if_index),
9371 format_ip46_address, &(mp->src_address[0]),
9373 format_ip46_address, &(mp->dst_address[0]),
9375 ntohl (mp->encap_vrf_id),
9376 ntohl (mp->decap_next_index), ntohl (mp->vni));
9379 static void vl_api_vxlan_tunnel_details_t_handler_json
9380 (vl_api_vxlan_tunnel_details_t * mp)
9382 vat_main_t *vam = &vat_main;
9383 vat_json_node_t *node = NULL;
9385 struct in6_addr ip6;
9387 if (VAT_JSON_ARRAY != vam->json_tree.type)
9389 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9390 vat_json_init_array (&vam->json_tree);
9392 node = vat_json_array_add (&vam->json_tree);
9394 vat_json_init_object (node);
9395 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9398 clib_memcpy (&ip6, &(mp->src_address[0]), sizeof (ip6));
9399 vat_json_object_add_ip6 (node, "src_address", ip6);
9400 clib_memcpy (&ip6, &(mp->dst_address[0]), sizeof (ip6));
9401 vat_json_object_add_ip6 (node, "dst_address", ip6);
9405 clib_memcpy (&ip4, &(mp->src_address[0]), sizeof (ip4));
9406 vat_json_object_add_ip4 (node, "src_address", ip4);
9407 clib_memcpy (&ip4, &(mp->dst_address[0]), sizeof (ip4));
9408 vat_json_object_add_ip4 (node, "dst_address", ip4);
9410 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
9411 vat_json_object_add_uint (node, "decap_next_index",
9412 ntohl (mp->decap_next_index));
9413 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
9414 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
9418 api_vxlan_tunnel_dump (vat_main_t * vam)
9420 unformat_input_t *i = vam->input;
9421 vl_api_vxlan_tunnel_dump_t *mp;
9424 u8 sw_if_index_set = 0;
9426 /* Parse args required to build the message */
9427 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9429 if (unformat (i, "sw_if_index %d", &sw_if_index))
9430 sw_if_index_set = 1;
9435 if (sw_if_index_set == 0)
9440 if (!vam->json_output)
9442 fformat (vam->ofp, "%11s%24s%24s%14s%18s%13s\n",
9443 "sw_if_index", "src_address", "dst_address",
9444 "encap_vrf_id", "decap_next_index", "vni");
9447 /* Get list of vxlan-tunnel interfaces */
9448 M (VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump);
9450 mp->sw_if_index = htonl (sw_if_index);
9454 /* Use a control ping for synchronization */
9456 vl_api_control_ping_t *mp;
9457 M (CONTROL_PING, control_ping);
9464 api_gre_add_del_tunnel (vat_main_t * vam)
9466 unformat_input_t *line_input = vam->input;
9467 vl_api_gre_add_del_tunnel_t *mp;
9469 ip4_address_t src4, dst4;
9473 u32 outer_fib_id = 0;
9475 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9477 if (unformat (line_input, "del"))
9479 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
9481 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
9483 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
9487 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
9494 errmsg ("tunnel src address not specified\n");
9499 errmsg ("tunnel dst address not specified\n");
9504 M (GRE_ADD_DEL_TUNNEL, gre_add_del_tunnel);
9506 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
9507 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
9508 mp->outer_fib_id = ntohl (outer_fib_id);
9509 mp->is_add = is_add;
9517 static void vl_api_gre_tunnel_details_t_handler
9518 (vl_api_gre_tunnel_details_t * mp)
9520 vat_main_t *vam = &vat_main;
9522 fformat (vam->ofp, "%11d%15U%15U%14d\n",
9523 ntohl (mp->sw_if_index),
9524 format_ip4_address, &mp->src_address,
9525 format_ip4_address, &mp->dst_address, ntohl (mp->outer_fib_id));
9528 static void vl_api_gre_tunnel_details_t_handler_json
9529 (vl_api_gre_tunnel_details_t * mp)
9531 vat_main_t *vam = &vat_main;
9532 vat_json_node_t *node = NULL;
9535 if (VAT_JSON_ARRAY != vam->json_tree.type)
9537 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9538 vat_json_init_array (&vam->json_tree);
9540 node = vat_json_array_add (&vam->json_tree);
9542 vat_json_init_object (node);
9543 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9544 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
9545 vat_json_object_add_ip4 (node, "src_address", ip4);
9546 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
9547 vat_json_object_add_ip4 (node, "dst_address", ip4);
9548 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
9552 api_gre_tunnel_dump (vat_main_t * vam)
9554 unformat_input_t *i = vam->input;
9555 vl_api_gre_tunnel_dump_t *mp;
9558 u8 sw_if_index_set = 0;
9560 /* Parse args required to build the message */
9561 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9563 if (unformat (i, "sw_if_index %d", &sw_if_index))
9564 sw_if_index_set = 1;
9569 if (sw_if_index_set == 0)
9574 if (!vam->json_output)
9576 fformat (vam->ofp, "%11s%15s%15s%14s\n",
9577 "sw_if_index", "src_address", "dst_address", "outer_fib_id");
9580 /* Get list of gre-tunnel interfaces */
9581 M (GRE_TUNNEL_DUMP, gre_tunnel_dump);
9583 mp->sw_if_index = htonl (sw_if_index);
9587 /* Use a control ping for synchronization */
9589 vl_api_control_ping_t *mp;
9590 M (CONTROL_PING, control_ping);
9597 api_l2_fib_clear_table (vat_main_t * vam)
9599 // unformat_input_t * i = vam->input;
9600 vl_api_l2_fib_clear_table_t *mp;
9603 M (L2_FIB_CLEAR_TABLE, l2_fib_clear_table);
9612 api_l2_interface_efp_filter (vat_main_t * vam)
9614 unformat_input_t *i = vam->input;
9615 vl_api_l2_interface_efp_filter_t *mp;
9619 u8 sw_if_index_set = 0;
9621 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9623 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9624 sw_if_index_set = 1;
9625 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9626 sw_if_index_set = 1;
9627 else if (unformat (i, "enable"))
9629 else if (unformat (i, "disable"))
9633 clib_warning ("parse error '%U'", format_unformat_error, i);
9638 if (sw_if_index_set == 0)
9640 errmsg ("missing sw_if_index\n");
9644 M (L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter);
9646 mp->sw_if_index = ntohl (sw_if_index);
9647 mp->enable_disable = enable;
9655 #define foreach_vtr_op \
9656 _("disable", L2_VTR_DISABLED) \
9657 _("push-1", L2_VTR_PUSH_1) \
9658 _("push-2", L2_VTR_PUSH_2) \
9659 _("pop-1", L2_VTR_POP_1) \
9660 _("pop-2", L2_VTR_POP_2) \
9661 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
9662 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
9663 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
9664 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
9667 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
9669 unformat_input_t *i = vam->input;
9670 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
9673 u8 sw_if_index_set = 0;
9680 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9682 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9683 sw_if_index_set = 1;
9684 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9685 sw_if_index_set = 1;
9686 else if (unformat (i, "vtr_op %d", &vtr_op))
9688 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
9691 else if (unformat (i, "push_dot1q %d", &push_dot1q))
9693 else if (unformat (i, "tag1 %d", &tag1))
9695 else if (unformat (i, "tag2 %d", &tag2))
9699 clib_warning ("parse error '%U'", format_unformat_error, i);
9704 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
9706 errmsg ("missing vtr operation or sw_if_index\n");
9710 M (L2_INTERFACE_VLAN_TAG_REWRITE, l2_interface_vlan_tag_rewrite)
9711 mp->sw_if_index = ntohl (sw_if_index);
9712 mp->vtr_op = ntohl (vtr_op);
9713 mp->push_dot1q = ntohl (push_dot1q);
9714 mp->tag1 = ntohl (tag1);
9715 mp->tag2 = ntohl (tag2);
9724 api_create_vhost_user_if (vat_main_t * vam)
9726 unformat_input_t *i = vam->input;
9727 vl_api_create_vhost_user_if_t *mp;
9731 u8 file_name_set = 0;
9732 u32 custom_dev_instance = ~0;
9734 u8 use_custom_mac = 0;
9736 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9738 if (unformat (i, "socket %s", &file_name))
9742 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
9744 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
9746 else if (unformat (i, "server"))
9752 if (file_name_set == 0)
9754 errmsg ("missing socket file name\n");
9758 if (vec_len (file_name) > 255)
9760 errmsg ("socket file name too long\n");
9763 vec_add1 (file_name, 0);
9765 M (CREATE_VHOST_USER_IF, create_vhost_user_if);
9767 mp->is_server = is_server;
9768 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
9769 vec_free (file_name);
9770 if (custom_dev_instance != ~0)
9773 mp->custom_dev_instance = ntohl (custom_dev_instance);
9775 mp->use_custom_mac = use_custom_mac;
9776 clib_memcpy (mp->mac_address, hwaddr, 6);
9785 api_modify_vhost_user_if (vat_main_t * vam)
9787 unformat_input_t *i = vam->input;
9788 vl_api_modify_vhost_user_if_t *mp;
9792 u8 file_name_set = 0;
9793 u32 custom_dev_instance = ~0;
9794 u8 sw_if_index_set = 0;
9795 u32 sw_if_index = (u32) ~ 0;
9797 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9799 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9800 sw_if_index_set = 1;
9801 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9802 sw_if_index_set = 1;
9803 else if (unformat (i, "socket %s", &file_name))
9807 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
9809 else if (unformat (i, "server"))
9815 if (sw_if_index_set == 0)
9817 errmsg ("missing sw_if_index or interface name\n");
9821 if (file_name_set == 0)
9823 errmsg ("missing socket file name\n");
9827 if (vec_len (file_name) > 255)
9829 errmsg ("socket file name too long\n");
9832 vec_add1 (file_name, 0);
9834 M (MODIFY_VHOST_USER_IF, modify_vhost_user_if);
9836 mp->sw_if_index = ntohl (sw_if_index);
9837 mp->is_server = is_server;
9838 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
9839 vec_free (file_name);
9840 if (custom_dev_instance != ~0)
9843 mp->custom_dev_instance = ntohl (custom_dev_instance);
9853 api_delete_vhost_user_if (vat_main_t * vam)
9855 unformat_input_t *i = vam->input;
9856 vl_api_delete_vhost_user_if_t *mp;
9858 u32 sw_if_index = ~0;
9859 u8 sw_if_index_set = 0;
9861 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9863 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9864 sw_if_index_set = 1;
9865 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9866 sw_if_index_set = 1;
9871 if (sw_if_index_set == 0)
9873 errmsg ("missing sw_if_index or interface name\n");
9878 M (DELETE_VHOST_USER_IF, delete_vhost_user_if);
9880 mp->sw_if_index = ntohl (sw_if_index);
9888 static void vl_api_sw_interface_vhost_user_details_t_handler
9889 (vl_api_sw_interface_vhost_user_details_t * mp)
9891 vat_main_t *vam = &vat_main;
9893 fformat (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s\n",
9894 (char *) mp->interface_name,
9895 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
9896 clib_net_to_host_u64 (mp->features), mp->is_server,
9897 ntohl (mp->num_regions), (char *) mp->sock_filename);
9898 fformat (vam->ofp, " Status: '%s'\n", strerror (ntohl (mp->sock_errno)));
9901 static void vl_api_sw_interface_vhost_user_details_t_handler_json
9902 (vl_api_sw_interface_vhost_user_details_t * mp)
9904 vat_main_t *vam = &vat_main;
9905 vat_json_node_t *node = NULL;
9907 if (VAT_JSON_ARRAY != vam->json_tree.type)
9909 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9910 vat_json_init_array (&vam->json_tree);
9912 node = vat_json_array_add (&vam->json_tree);
9914 vat_json_init_object (node);
9915 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9916 vat_json_object_add_string_copy (node, "interface_name",
9917 mp->interface_name);
9918 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
9919 ntohl (mp->virtio_net_hdr_sz));
9920 vat_json_object_add_uint (node, "features",
9921 clib_net_to_host_u64 (mp->features));
9922 vat_json_object_add_uint (node, "is_server", mp->is_server);
9923 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
9924 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
9925 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
9929 api_sw_interface_vhost_user_dump (vat_main_t * vam)
9931 vl_api_sw_interface_vhost_user_dump_t *mp;
9934 "Interface name idx hdr_sz features server regions filename\n");
9936 /* Get list of vhost-user interfaces */
9937 M (SW_INTERFACE_VHOST_USER_DUMP, sw_interface_vhost_user_dump);
9940 /* Use a control ping for synchronization */
9942 vl_api_control_ping_t *mp;
9943 M (CONTROL_PING, control_ping);
9950 api_show_version (vat_main_t * vam)
9952 vl_api_show_version_t *mp;
9955 M (SHOW_VERSION, show_version);
9965 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
9967 unformat_input_t *line_input = vam->input;
9968 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
9970 ip4_address_t local4, remote4;
9971 ip6_address_t local6, remote6;
9973 u8 ipv4_set = 0, ipv6_set = 0;
9976 u32 encap_vrf_id = 0;
9977 u32 decap_vrf_id = 0;
9982 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9984 if (unformat (line_input, "del"))
9986 else if (unformat (line_input, "local %U",
9987 unformat_ip4_address, &local4))
9992 else if (unformat (line_input, "remote %U",
9993 unformat_ip4_address, &remote4))
9998 else if (unformat (line_input, "local %U",
9999 unformat_ip6_address, &local6))
10004 else if (unformat (line_input, "remote %U",
10005 unformat_ip6_address, &remote6))
10010 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
10012 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
10014 else if (unformat (line_input, "vni %d", &vni))
10016 else if (unformat (line_input, "next-ip4"))
10018 else if (unformat (line_input, "next-ip6"))
10020 else if (unformat (line_input, "next-ethernet"))
10022 else if (unformat (line_input, "next-nsh"))
10026 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
10031 if (local_set == 0)
10033 errmsg ("tunnel local address not specified\n");
10036 if (remote_set == 0)
10038 errmsg ("tunnel remote address not specified\n");
10041 if (ipv4_set && ipv6_set)
10043 errmsg ("both IPv4 and IPv6 addresses specified");
10049 errmsg ("vni not specified\n");
10053 M (VXLAN_GPE_ADD_DEL_TUNNEL, vxlan_gpe_add_del_tunnel);
10058 clib_memcpy (&mp->local, &local6, sizeof (local6));
10059 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
10063 clib_memcpy (&mp->local, &local4, sizeof (local4));
10064 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
10067 mp->encap_vrf_id = ntohl (encap_vrf_id);
10068 mp->decap_vrf_id = ntohl (decap_vrf_id);
10069 mp->protocol = ntohl (protocol);
10070 mp->vni = ntohl (vni);
10071 mp->is_add = is_add;
10072 mp->is_ipv6 = ipv6_set;
10080 static void vl_api_vxlan_gpe_tunnel_details_t_handler
10081 (vl_api_vxlan_gpe_tunnel_details_t * mp)
10083 vat_main_t *vam = &vat_main;
10085 fformat (vam->ofp, "%11d%24U%24U%13d%12d%14d%14d\n",
10086 ntohl (mp->sw_if_index),
10087 format_ip46_address, &(mp->local[0]),
10088 format_ip46_address, &(mp->remote[0]),
10090 ntohl (mp->protocol),
10091 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
10094 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
10095 (vl_api_vxlan_gpe_tunnel_details_t * mp)
10097 vat_main_t *vam = &vat_main;
10098 vat_json_node_t *node = NULL;
10099 struct in_addr ip4;
10100 struct in6_addr ip6;
10102 if (VAT_JSON_ARRAY != vam->json_tree.type)
10104 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10105 vat_json_init_array (&vam->json_tree);
10107 node = vat_json_array_add (&vam->json_tree);
10109 vat_json_init_object (node);
10110 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10113 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
10114 vat_json_object_add_ip6 (node, "local", ip6);
10115 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
10116 vat_json_object_add_ip6 (node, "remote", ip6);
10120 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
10121 vat_json_object_add_ip4 (node, "local", ip4);
10122 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
10123 vat_json_object_add_ip4 (node, "remote", ip4);
10125 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
10126 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
10127 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
10128 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
10129 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
10133 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
10135 unformat_input_t *i = vam->input;
10136 vl_api_vxlan_gpe_tunnel_dump_t *mp;
10139 u8 sw_if_index_set = 0;
10141 /* Parse args required to build the message */
10142 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10144 if (unformat (i, "sw_if_index %d", &sw_if_index))
10145 sw_if_index_set = 1;
10150 if (sw_if_index_set == 0)
10155 if (!vam->json_output)
10157 fformat (vam->ofp, "%11s%24s%24s%13s%15s%14s%14s\n",
10158 "sw_if_index", "local", "remote", "vni",
10159 "protocol", "encap_vrf_id", "decap_vrf_id");
10162 /* Get list of vxlan-tunnel interfaces */
10163 M (VXLAN_GPE_TUNNEL_DUMP, vxlan_gpe_tunnel_dump);
10165 mp->sw_if_index = htonl (sw_if_index);
10169 /* Use a control ping for synchronization */
10171 vl_api_control_ping_t *mp;
10172 M (CONTROL_PING, control_ping);
10179 format_l2_fib_mac_address (u8 * s, va_list * args)
10181 u8 *a = va_arg (*args, u8 *);
10183 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
10184 a[2], a[3], a[4], a[5], a[6], a[7]);
10187 static void vl_api_l2_fib_table_entry_t_handler
10188 (vl_api_l2_fib_table_entry_t * mp)
10190 vat_main_t *vam = &vat_main;
10192 fformat (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
10194 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
10195 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
10199 static void vl_api_l2_fib_table_entry_t_handler_json
10200 (vl_api_l2_fib_table_entry_t * mp)
10202 vat_main_t *vam = &vat_main;
10203 vat_json_node_t *node = NULL;
10205 if (VAT_JSON_ARRAY != vam->json_tree.type)
10207 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10208 vat_json_init_array (&vam->json_tree);
10210 node = vat_json_array_add (&vam->json_tree);
10212 vat_json_init_object (node);
10213 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
10214 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
10215 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10216 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
10217 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
10218 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
10222 api_l2_fib_table_dump (vat_main_t * vam)
10224 unformat_input_t *i = vam->input;
10225 vl_api_l2_fib_table_dump_t *mp;
10230 /* Parse args required to build the message */
10231 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10233 if (unformat (i, "bd_id %d", &bd_id))
10239 if (bd_id_set == 0)
10241 errmsg ("missing bridge domain\n");
10246 "BD-ID Mac Address sw-ndx Static Filter BVI\n");
10248 /* Get list of l2 fib entries */
10249 M (L2_FIB_TABLE_DUMP, l2_fib_table_dump);
10251 mp->bd_id = ntohl (bd_id);
10254 /* Use a control ping for synchronization */
10256 vl_api_control_ping_t *mp;
10257 M (CONTROL_PING, control_ping);
10265 api_interface_name_renumber (vat_main_t * vam)
10267 unformat_input_t *line_input = vam->input;
10268 vl_api_interface_name_renumber_t *mp;
10269 u32 sw_if_index = ~0;
10271 u32 new_show_dev_instance = ~0;
10273 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10275 if (unformat (line_input, "%U", unformat_sw_if_index, vam,
10278 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
10280 else if (unformat (line_input, "new_show_dev_instance %d",
10281 &new_show_dev_instance))
10287 if (sw_if_index == ~0)
10289 errmsg ("missing interface name or sw_if_index\n");
10293 if (new_show_dev_instance == ~0)
10295 errmsg ("missing new_show_dev_instance\n");
10299 M (INTERFACE_NAME_RENUMBER, interface_name_renumber);
10301 mp->sw_if_index = ntohl (sw_if_index);
10302 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
10309 api_want_ip4_arp_events (vat_main_t * vam)
10311 unformat_input_t *line_input = vam->input;
10312 vl_api_want_ip4_arp_events_t *mp;
10314 ip4_address_t address;
10315 int address_set = 0;
10316 u32 enable_disable = 1;
10318 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10320 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
10322 else if (unformat (line_input, "del"))
10323 enable_disable = 0;
10328 if (address_set == 0)
10330 errmsg ("missing addresses\n");
10334 M (WANT_IP4_ARP_EVENTS, want_ip4_arp_events);
10335 mp->enable_disable = enable_disable;
10336 mp->pid = getpid ();
10337 mp->address = address.as_u32;
10344 api_want_ip6_nd_events (vat_main_t * vam)
10346 unformat_input_t *line_input = vam->input;
10347 vl_api_want_ip6_nd_events_t *mp;
10349 ip6_address_t address;
10350 int address_set = 0;
10351 u32 enable_disable = 1;
10353 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10355 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
10357 else if (unformat (line_input, "del"))
10358 enable_disable = 0;
10363 if (address_set == 0)
10365 errmsg ("missing addresses\n");
10369 M (WANT_IP6_ND_EVENTS, want_ip6_nd_events);
10370 mp->enable_disable = enable_disable;
10371 mp->pid = getpid ();
10372 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
10379 api_input_acl_set_interface (vat_main_t * vam)
10381 unformat_input_t *i = vam->input;
10382 vl_api_input_acl_set_interface_t *mp;
10385 int sw_if_index_set;
10386 u32 ip4_table_index = ~0;
10387 u32 ip6_table_index = ~0;
10388 u32 l2_table_index = ~0;
10391 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10393 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10394 sw_if_index_set = 1;
10395 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10396 sw_if_index_set = 1;
10397 else if (unformat (i, "del"))
10399 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10401 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10403 else if (unformat (i, "l2-table %d", &l2_table_index))
10407 clib_warning ("parse error '%U'", format_unformat_error, i);
10412 if (sw_if_index_set == 0)
10414 errmsg ("missing interface name or sw_if_index\n");
10418 M (INPUT_ACL_SET_INTERFACE, input_acl_set_interface);
10420 mp->sw_if_index = ntohl (sw_if_index);
10421 mp->ip4_table_index = ntohl (ip4_table_index);
10422 mp->ip6_table_index = ntohl (ip6_table_index);
10423 mp->l2_table_index = ntohl (l2_table_index);
10424 mp->is_add = is_add;
10433 api_ip_address_dump (vat_main_t * vam)
10435 unformat_input_t *i = vam->input;
10436 vl_api_ip_address_dump_t *mp;
10437 u32 sw_if_index = ~0;
10438 u8 sw_if_index_set = 0;
10443 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10445 if (unformat (i, "sw_if_index %d", &sw_if_index))
10446 sw_if_index_set = 1;
10447 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10448 sw_if_index_set = 1;
10449 else if (unformat (i, "ipv4"))
10451 else if (unformat (i, "ipv6"))
10457 if (ipv4_set && ipv6_set)
10459 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
10463 if ((!ipv4_set) && (!ipv6_set))
10465 errmsg ("no ipv4 nor ipv6 flag set\n");
10469 if (sw_if_index_set == 0)
10471 errmsg ("missing interface name or sw_if_index\n");
10475 vam->current_sw_if_index = sw_if_index;
10476 vam->is_ipv6 = ipv6_set;
10478 M (IP_ADDRESS_DUMP, ip_address_dump);
10479 mp->sw_if_index = ntohl (sw_if_index);
10480 mp->is_ipv6 = ipv6_set;
10483 /* Use a control ping for synchronization */
10485 vl_api_control_ping_t *mp;
10486 M (CONTROL_PING, control_ping);
10493 api_ip_dump (vat_main_t * vam)
10495 vl_api_ip_dump_t *mp;
10496 unformat_input_t *in = vam->input;
10503 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
10505 if (unformat (in, "ipv4"))
10507 else if (unformat (in, "ipv6"))
10513 if (ipv4_set && ipv6_set)
10515 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
10519 if ((!ipv4_set) && (!ipv6_set))
10521 errmsg ("no ipv4 nor ipv6 flag set\n");
10525 is_ipv6 = ipv6_set;
10526 vam->is_ipv6 = is_ipv6;
10528 /* free old data */
10529 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
10531 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
10533 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
10535 M (IP_DUMP, ip_dump);
10536 mp->is_ipv6 = ipv6_set;
10539 /* Use a control ping for synchronization */
10541 vl_api_control_ping_t *mp;
10542 M (CONTROL_PING, control_ping);
10549 api_ipsec_spd_add_del (vat_main_t * vam)
10552 unformat_input_t *i = vam->input;
10553 vl_api_ipsec_spd_add_del_t *mp;
10558 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10560 if (unformat (i, "spd_id %d", &spd_id))
10562 else if (unformat (i, "del"))
10566 clib_warning ("parse error '%U'", format_unformat_error, i);
10572 errmsg ("spd_id must be set\n");
10576 M (IPSEC_SPD_ADD_DEL, ipsec_spd_add_del);
10578 mp->spd_id = ntohl (spd_id);
10579 mp->is_add = is_add;
10586 clib_warning ("unsupported (no dpdk)");
10592 api_ipsec_interface_add_del_spd (vat_main_t * vam)
10595 unformat_input_t *i = vam->input;
10596 vl_api_ipsec_interface_add_del_spd_t *mp;
10599 u8 sw_if_index_set = 0;
10600 u32 spd_id = (u32) ~ 0;
10603 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10605 if (unformat (i, "del"))
10607 else if (unformat (i, "spd_id %d", &spd_id))
10609 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10610 sw_if_index_set = 1;
10611 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10612 sw_if_index_set = 1;
10615 clib_warning ("parse error '%U'", format_unformat_error, i);
10621 if (spd_id == (u32) ~ 0)
10623 errmsg ("spd_id must be set\n");
10627 if (sw_if_index_set == 0)
10629 errmsg ("missing interface name or sw_if_index\n");
10633 M (IPSEC_INTERFACE_ADD_DEL_SPD, ipsec_interface_add_del_spd);
10635 mp->spd_id = ntohl (spd_id);
10636 mp->sw_if_index = ntohl (sw_if_index);
10637 mp->is_add = is_add;
10644 clib_warning ("unsupported (no dpdk)");
10650 api_ipsec_spd_add_del_entry (vat_main_t * vam)
10653 unformat_input_t *i = vam->input;
10654 vl_api_ipsec_spd_add_del_entry_t *mp;
10656 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
10657 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
10659 u32 rport_start = 0, rport_stop = (u32) ~ 0;
10660 u32 lport_start = 0, lport_stop = (u32) ~ 0;
10661 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
10662 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
10664 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
10665 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
10666 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
10667 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
10668 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
10669 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
10671 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10673 if (unformat (i, "del"))
10675 if (unformat (i, "outbound"))
10677 if (unformat (i, "inbound"))
10679 else if (unformat (i, "spd_id %d", &spd_id))
10681 else if (unformat (i, "sa_id %d", &sa_id))
10683 else if (unformat (i, "priority %d", &priority))
10685 else if (unformat (i, "protocol %d", &protocol))
10687 else if (unformat (i, "lport_start %d", &lport_start))
10689 else if (unformat (i, "lport_stop %d", &lport_stop))
10691 else if (unformat (i, "rport_start %d", &rport_start))
10693 else if (unformat (i, "rport_stop %d", &rport_stop))
10697 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
10703 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
10710 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
10716 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
10723 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
10729 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
10736 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
10742 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
10748 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
10750 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
10752 clib_warning ("unsupported action: 'resolve'");
10758 clib_warning ("parse error '%U'", format_unformat_error, i);
10764 M (IPSEC_SPD_ADD_DEL_ENTRY, ipsec_spd_add_del_entry);
10766 mp->spd_id = ntohl (spd_id);
10767 mp->priority = ntohl (priority);
10768 mp->is_outbound = is_outbound;
10770 mp->is_ipv6 = is_ipv6;
10771 if (is_ipv6 || is_ip_any)
10773 clib_memcpy (mp->remote_address_start, &raddr6_start,
10774 sizeof (ip6_address_t));
10775 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
10776 sizeof (ip6_address_t));
10777 clib_memcpy (mp->local_address_start, &laddr6_start,
10778 sizeof (ip6_address_t));
10779 clib_memcpy (mp->local_address_stop, &laddr6_stop,
10780 sizeof (ip6_address_t));
10784 clib_memcpy (mp->remote_address_start, &raddr4_start,
10785 sizeof (ip4_address_t));
10786 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
10787 sizeof (ip4_address_t));
10788 clib_memcpy (mp->local_address_start, &laddr4_start,
10789 sizeof (ip4_address_t));
10790 clib_memcpy (mp->local_address_stop, &laddr4_stop,
10791 sizeof (ip4_address_t));
10793 mp->protocol = (u8) protocol;
10794 mp->local_port_start = ntohs ((u16) lport_start);
10795 mp->local_port_stop = ntohs ((u16) lport_stop);
10796 mp->remote_port_start = ntohs ((u16) rport_start);
10797 mp->remote_port_stop = ntohs ((u16) rport_stop);
10798 mp->policy = (u8) policy;
10799 mp->sa_id = ntohl (sa_id);
10800 mp->is_add = is_add;
10801 mp->is_ip_any = is_ip_any;
10807 clib_warning ("unsupported (no dpdk)");
10813 api_ipsec_sad_add_del_entry (vat_main_t * vam)
10816 unformat_input_t *i = vam->input;
10817 vl_api_ipsec_sad_add_del_entry_t *mp;
10819 u32 sad_id = 0, spi = 0;
10820 u8 *ck = 0, *ik = 0;
10823 u8 protocol = IPSEC_PROTOCOL_AH;
10824 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
10825 u32 crypto_alg = 0, integ_alg = 0;
10826 ip4_address_t tun_src4;
10827 ip4_address_t tun_dst4;
10828 ip6_address_t tun_src6;
10829 ip6_address_t tun_dst6;
10831 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10833 if (unformat (i, "del"))
10835 else if (unformat (i, "sad_id %d", &sad_id))
10837 else if (unformat (i, "spi %d", &spi))
10839 else if (unformat (i, "esp"))
10840 protocol = IPSEC_PROTOCOL_ESP;
10841 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
10844 is_tunnel_ipv6 = 0;
10846 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
10849 is_tunnel_ipv6 = 0;
10851 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
10854 is_tunnel_ipv6 = 1;
10856 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
10859 is_tunnel_ipv6 = 1;
10863 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
10865 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
10866 crypto_alg > IPSEC_INTEG_ALG_SHA_512_256)
10868 clib_warning ("unsupported crypto-alg: '%U'",
10869 format_ipsec_crypto_alg, crypto_alg);
10873 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
10877 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
10879 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
10880 integ_alg > IPSEC_INTEG_ALG_SHA_512_256)
10882 clib_warning ("unsupported integ-alg: '%U'",
10883 format_ipsec_integ_alg, integ_alg);
10887 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
10891 clib_warning ("parse error '%U'", format_unformat_error, i);
10897 M (IPSEC_SAD_ADD_DEL_ENTRY, ipsec_sad_add_del_entry);
10899 mp->sad_id = ntohl (sad_id);
10900 mp->is_add = is_add;
10901 mp->protocol = protocol;
10902 mp->spi = ntohl (spi);
10903 mp->is_tunnel = is_tunnel;
10904 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
10905 mp->crypto_algorithm = crypto_alg;
10906 mp->integrity_algorithm = integ_alg;
10907 mp->crypto_key_length = vec_len (ck);
10908 mp->integrity_key_length = vec_len (ik);
10910 if (mp->crypto_key_length > sizeof (mp->crypto_key))
10911 mp->crypto_key_length = sizeof (mp->crypto_key);
10913 if (mp->integrity_key_length > sizeof (mp->integrity_key))
10914 mp->integrity_key_length = sizeof (mp->integrity_key);
10917 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
10919 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
10923 if (is_tunnel_ipv6)
10925 clib_memcpy (mp->tunnel_src_address, &tun_src6,
10926 sizeof (ip6_address_t));
10927 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
10928 sizeof (ip6_address_t));
10932 clib_memcpy (mp->tunnel_src_address, &tun_src4,
10933 sizeof (ip4_address_t));
10934 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
10935 sizeof (ip4_address_t));
10944 clib_warning ("unsupported (no dpdk)");
10950 api_ipsec_sa_set_key (vat_main_t * vam)
10953 unformat_input_t *i = vam->input;
10954 vl_api_ipsec_sa_set_key_t *mp;
10957 u8 *ck = 0, *ik = 0;
10959 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10961 if (unformat (i, "sa_id %d", &sa_id))
10963 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
10965 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
10969 clib_warning ("parse error '%U'", format_unformat_error, i);
10974 M (IPSEC_SA_SET_KEY, ipsec_set_sa_key);
10976 mp->sa_id = ntohl (sa_id);
10977 mp->crypto_key_length = vec_len (ck);
10978 mp->integrity_key_length = vec_len (ik);
10980 if (mp->crypto_key_length > sizeof (mp->crypto_key))
10981 mp->crypto_key_length = sizeof (mp->crypto_key);
10983 if (mp->integrity_key_length > sizeof (mp->integrity_key))
10984 mp->integrity_key_length = sizeof (mp->integrity_key);
10987 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
10989 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
10996 clib_warning ("unsupported (no dpdk)");
11002 api_ikev2_profile_add_del (vat_main_t * vam)
11005 unformat_input_t *i = vam->input;
11006 vl_api_ikev2_profile_add_del_t *mp;
11011 const char *valid_chars = "a-zA-Z0-9_";
11013 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11015 if (unformat (i, "del"))
11017 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11018 vec_add1 (name, 0);
11021 errmsg ("parse error '%U'", format_unformat_error, i);
11026 if (!vec_len (name))
11028 errmsg ("profile name must be specified");
11032 if (vec_len (name) > 64)
11034 errmsg ("profile name too long");
11038 M (IKEV2_PROFILE_ADD_DEL, ikev2_profile_add_del);
11040 clib_memcpy (mp->name, name, vec_len (name));
11041 mp->is_add = is_add;
11049 clib_warning ("unsupported (no dpdk)");
11055 api_ikev2_profile_set_auth (vat_main_t * vam)
11058 unformat_input_t *i = vam->input;
11059 vl_api_ikev2_profile_set_auth_t *mp;
11063 u32 auth_method = 0;
11066 const char *valid_chars = "a-zA-Z0-9_";
11068 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11070 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11071 vec_add1 (name, 0);
11072 else if (unformat (i, "auth_method %U",
11073 unformat_ikev2_auth_method, &auth_method))
11075 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
11077 else if (unformat (i, "auth_data %v", &data))
11081 errmsg ("parse error '%U'", format_unformat_error, i);
11086 if (!vec_len (name))
11088 errmsg ("profile name must be specified");
11092 if (vec_len (name) > 64)
11094 errmsg ("profile name too long");
11098 if (!vec_len (data))
11100 errmsg ("auth_data must be specified");
11106 errmsg ("auth_method must be specified");
11110 M (IKEV2_PROFILE_SET_AUTH, ikev2_profile_set_auth);
11112 mp->is_hex = is_hex;
11113 mp->auth_method = (u8) auth_method;
11114 mp->data_len = vec_len (data);
11115 clib_memcpy (mp->name, name, vec_len (name));
11116 clib_memcpy (mp->data, data, vec_len (data));
11125 clib_warning ("unsupported (no dpdk)");
11131 api_ikev2_profile_set_id (vat_main_t * vam)
11134 unformat_input_t *i = vam->input;
11135 vl_api_ikev2_profile_set_id_t *mp;
11143 const char *valid_chars = "a-zA-Z0-9_";
11145 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11147 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11148 vec_add1 (name, 0);
11149 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
11151 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
11153 data = vec_new (u8, 4);
11154 clib_memcpy (data, ip4.as_u8, 4);
11156 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
11158 else if (unformat (i, "id_data %v", &data))
11160 else if (unformat (i, "local"))
11162 else if (unformat (i, "remote"))
11166 errmsg ("parse error '%U'", format_unformat_error, i);
11171 if (!vec_len (name))
11173 errmsg ("profile name must be specified");
11177 if (vec_len (name) > 64)
11179 errmsg ("profile name too long");
11183 if (!vec_len (data))
11185 errmsg ("id_data must be specified");
11191 errmsg ("id_type must be specified");
11195 M (IKEV2_PROFILE_SET_ID, ikev2_profile_set_id);
11197 mp->is_local = is_local;
11198 mp->id_type = (u8) id_type;
11199 mp->data_len = vec_len (data);
11200 clib_memcpy (mp->name, name, vec_len (name));
11201 clib_memcpy (mp->data, data, vec_len (data));
11210 clib_warning ("unsupported (no dpdk)");
11216 api_ikev2_profile_set_ts (vat_main_t * vam)
11219 unformat_input_t *i = vam->input;
11220 vl_api_ikev2_profile_set_ts_t *mp;
11224 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
11225 ip4_address_t start_addr, end_addr;
11227 const char *valid_chars = "a-zA-Z0-9_";
11229 start_addr.as_u32 = 0;
11230 end_addr.as_u32 = (u32) ~ 0;
11232 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11234 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11235 vec_add1 (name, 0);
11236 else if (unformat (i, "protocol %d", &proto))
11238 else if (unformat (i, "start_port %d", &start_port))
11240 else if (unformat (i, "end_port %d", &end_port))
11243 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
11245 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
11247 else if (unformat (i, "local"))
11249 else if (unformat (i, "remote"))
11253 errmsg ("parse error '%U'", format_unformat_error, i);
11258 if (!vec_len (name))
11260 errmsg ("profile name must be specified");
11264 if (vec_len (name) > 64)
11266 errmsg ("profile name too long");
11270 M (IKEV2_PROFILE_SET_TS, ikev2_profile_set_ts);
11272 mp->is_local = is_local;
11273 mp->proto = (u8) proto;
11274 mp->start_port = (u16) start_port;
11275 mp->end_port = (u16) end_port;
11276 mp->start_addr = start_addr.as_u32;
11277 mp->end_addr = end_addr.as_u32;
11278 clib_memcpy (mp->name, name, vec_len (name));
11286 clib_warning ("unsupported (no dpdk)");
11292 api_ikev2_set_local_key (vat_main_t * vam)
11295 unformat_input_t *i = vam->input;
11296 vl_api_ikev2_set_local_key_t *mp;
11300 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11302 if (unformat (i, "file %v", &file))
11303 vec_add1 (file, 0);
11306 errmsg ("parse error '%U'", format_unformat_error, i);
11311 if (!vec_len (file))
11313 errmsg ("RSA key file must be specified");
11317 if (vec_len (file) > 256)
11319 errmsg ("file name too long");
11323 M (IKEV2_SET_LOCAL_KEY, ikev2_set_local_key);
11325 clib_memcpy (mp->key_file, file, vec_len (file));
11333 clib_warning ("unsupported (no dpdk)");
11342 api_map_add_domain (vat_main_t * vam)
11344 unformat_input_t *i = vam->input;
11345 vl_api_map_add_domain_t *mp;
11348 ip4_address_t ip4_prefix;
11349 ip6_address_t ip6_prefix;
11350 ip6_address_t ip6_src;
11351 u32 num_m_args = 0;
11352 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
11353 0, psid_length = 0;
11354 u8 is_translation = 0;
11356 u32 ip6_src_len = 128;
11358 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11360 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
11361 &ip4_prefix, &ip4_prefix_len))
11363 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
11364 &ip6_prefix, &ip6_prefix_len))
11368 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
11371 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
11373 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
11375 else if (unformat (i, "psid-offset %d", &psid_offset))
11377 else if (unformat (i, "psid-len %d", &psid_length))
11379 else if (unformat (i, "mtu %d", &mtu))
11381 else if (unformat (i, "map-t"))
11382 is_translation = 1;
11385 clib_warning ("parse error '%U'", format_unformat_error, i);
11390 if (num_m_args < 3)
11392 errmsg ("mandatory argument(s) missing\n");
11396 /* Construct the API message */
11397 M (MAP_ADD_DOMAIN, map_add_domain);
11399 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
11400 mp->ip4_prefix_len = ip4_prefix_len;
11402 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
11403 mp->ip6_prefix_len = ip6_prefix_len;
11405 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
11406 mp->ip6_src_prefix_len = ip6_src_len;
11408 mp->ea_bits_len = ea_bits_len;
11409 mp->psid_offset = psid_offset;
11410 mp->psid_length = psid_length;
11411 mp->is_translation = is_translation;
11412 mp->mtu = htons (mtu);
11417 /* Wait for a reply, return good/bad news */
11422 api_map_del_domain (vat_main_t * vam)
11424 unformat_input_t *i = vam->input;
11425 vl_api_map_del_domain_t *mp;
11428 u32 num_m_args = 0;
11431 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11433 if (unformat (i, "index %d", &index))
11437 clib_warning ("parse error '%U'", format_unformat_error, i);
11442 if (num_m_args != 1)
11444 errmsg ("mandatory argument(s) missing\n");
11448 /* Construct the API message */
11449 M (MAP_DEL_DOMAIN, map_del_domain);
11451 mp->index = ntohl (index);
11456 /* Wait for a reply, return good/bad news */
11461 api_map_add_del_rule (vat_main_t * vam)
11463 unformat_input_t *i = vam->input;
11464 vl_api_map_add_del_rule_t *mp;
11467 ip6_address_t ip6_dst;
11468 u32 num_m_args = 0, index, psid = 0;
11470 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11472 if (unformat (i, "index %d", &index))
11474 else if (unformat (i, "psid %d", &psid))
11476 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
11478 else if (unformat (i, "del"))
11484 clib_warning ("parse error '%U'", format_unformat_error, i);
11489 /* Construct the API message */
11490 M (MAP_ADD_DEL_RULE, map_add_del_rule);
11492 mp->index = ntohl (index);
11493 mp->is_add = is_add;
11494 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
11495 mp->psid = ntohs (psid);
11500 /* Wait for a reply, return good/bad news */
11505 api_map_domain_dump (vat_main_t * vam)
11507 vl_api_map_domain_dump_t *mp;
11510 /* Construct the API message */
11511 M (MAP_DOMAIN_DUMP, map_domain_dump);
11516 /* Use a control ping for synchronization */
11518 vl_api_control_ping_t *mp;
11519 M (CONTROL_PING, control_ping);
11526 api_map_rule_dump (vat_main_t * vam)
11528 unformat_input_t *i = vam->input;
11529 vl_api_map_rule_dump_t *mp;
11531 u32 domain_index = ~0;
11533 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11535 if (unformat (i, "index %u", &domain_index))
11541 if (domain_index == ~0)
11543 clib_warning ("parse error: domain index expected");
11547 /* Construct the API message */
11548 M (MAP_RULE_DUMP, map_rule_dump);
11550 mp->domain_index = htonl (domain_index);
11555 /* Use a control ping for synchronization */
11557 vl_api_control_ping_t *mp;
11558 M (CONTROL_PING, control_ping);
11564 static void vl_api_map_add_domain_reply_t_handler
11565 (vl_api_map_add_domain_reply_t * mp)
11567 vat_main_t *vam = &vat_main;
11568 i32 retval = ntohl (mp->retval);
11570 if (vam->async_mode)
11572 vam->async_errors += (retval < 0);
11576 vam->retval = retval;
11577 vam->result_ready = 1;
11581 static void vl_api_map_add_domain_reply_t_handler_json
11582 (vl_api_map_add_domain_reply_t * mp)
11584 vat_main_t *vam = &vat_main;
11585 vat_json_node_t node;
11587 vat_json_init_object (&node);
11588 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
11589 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
11591 vat_json_print (vam->ofp, &node);
11592 vat_json_free (&node);
11594 vam->retval = ntohl (mp->retval);
11595 vam->result_ready = 1;
11599 api_get_first_msg_id (vat_main_t * vam)
11601 vl_api_get_first_msg_id_t *mp;
11603 unformat_input_t *i = vam->input;
11607 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11609 if (unformat (i, "client %s", &name))
11617 errmsg ("missing client name\n");
11620 vec_add1 (name, 0);
11622 if (vec_len (name) > 63)
11624 errmsg ("client name too long\n");
11628 M (GET_FIRST_MSG_ID, get_first_msg_id);
11629 clib_memcpy (mp->name, name, vec_len (name));
11637 api_cop_interface_enable_disable (vat_main_t * vam)
11639 unformat_input_t *line_input = vam->input;
11640 vl_api_cop_interface_enable_disable_t *mp;
11642 u32 sw_if_index = ~0;
11643 u8 enable_disable = 1;
11645 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11647 if (unformat (line_input, "disable"))
11648 enable_disable = 0;
11649 if (unformat (line_input, "enable"))
11650 enable_disable = 1;
11651 else if (unformat (line_input, "%U", unformat_sw_if_index,
11652 vam, &sw_if_index))
11654 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11660 if (sw_if_index == ~0)
11662 errmsg ("missing interface name or sw_if_index\n");
11666 /* Construct the API message */
11667 M (COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable);
11668 mp->sw_if_index = ntohl (sw_if_index);
11669 mp->enable_disable = enable_disable;
11673 /* Wait for the reply */
11678 api_cop_whitelist_enable_disable (vat_main_t * vam)
11680 unformat_input_t *line_input = vam->input;
11681 vl_api_cop_whitelist_enable_disable_t *mp;
11683 u32 sw_if_index = ~0;
11684 u8 ip4 = 0, ip6 = 0, default_cop = 0;
11687 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11689 if (unformat (line_input, "ip4"))
11691 else if (unformat (line_input, "ip6"))
11693 else if (unformat (line_input, "default"))
11695 else if (unformat (line_input, "%U", unformat_sw_if_index,
11696 vam, &sw_if_index))
11698 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11700 else if (unformat (line_input, "fib-id %d", &fib_id))
11706 if (sw_if_index == ~0)
11708 errmsg ("missing interface name or sw_if_index\n");
11712 /* Construct the API message */
11713 M (COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable);
11714 mp->sw_if_index = ntohl (sw_if_index);
11715 mp->fib_id = ntohl (fib_id);
11718 mp->default_cop = default_cop;
11722 /* Wait for the reply */
11727 api_get_node_graph (vat_main_t * vam)
11729 vl_api_get_node_graph_t *mp;
11732 M (GET_NODE_GRAPH, get_node_graph);
11736 /* Wait for the reply */
11741 /** Used for parsing LISP eids */
11742 typedef CLIB_PACKED(struct{
11743 u8 addr[16]; /**< eid address */
11744 u32 len; /**< prefix length if IP */
11745 u8 type; /**< type of eid */
11750 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
11752 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
11754 memset (a, 0, sizeof (a[0]));
11756 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
11758 a->type = 0; /* ipv4 type */
11760 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
11762 a->type = 1; /* ipv6 type */
11764 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
11766 a->type = 2; /* mac type */
11773 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
11782 lisp_eid_size_vat (u8 type)
11797 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
11799 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
11803 /** Used for transferring locators via VPP API */
11804 typedef CLIB_PACKED(struct
11806 u32 sw_if_index; /**< locator sw_if_index */
11807 u8 priority; /**< locator priority */
11808 u8 weight; /**< locator weight */
11813 api_lisp_add_del_locator_set (vat_main_t * vam)
11815 unformat_input_t *input = vam->input;
11816 vl_api_lisp_add_del_locator_set_t *mp;
11819 u8 *locator_set_name = NULL;
11820 u8 locator_set_name_set = 0;
11821 ls_locator_t locator, *locators = 0;
11822 u32 sw_if_index, priority, weight;
11824 /* Parse args required to build the message */
11825 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11827 if (unformat (input, "del"))
11831 else if (unformat (input, "locator-set %s", &locator_set_name))
11833 locator_set_name_set = 1;
11835 else if (unformat (input, "sw_if_index %u p %u w %u",
11836 &sw_if_index, &priority, &weight))
11838 locator.sw_if_index = htonl (sw_if_index);
11839 locator.priority = priority;
11840 locator.weight = weight;
11841 vec_add1 (locators, locator);
11843 else if (unformat (input, "iface %U p %u w %u", unformat_sw_if_index,
11844 vam, &sw_if_index, &priority, &weight))
11846 locator.sw_if_index = htonl (sw_if_index);
11847 locator.priority = priority;
11848 locator.weight = weight;
11849 vec_add1 (locators, locator);
11855 if (locator_set_name_set == 0)
11857 errmsg ("missing locator-set name");
11858 vec_free (locators);
11862 if (vec_len (locator_set_name) > 64)
11864 errmsg ("locator-set name too long\n");
11865 vec_free (locator_set_name);
11866 vec_free (locators);
11869 vec_add1 (locator_set_name, 0);
11871 /* Construct the API message */
11872 M (LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set);
11874 mp->is_add = is_add;
11875 clib_memcpy (mp->locator_set_name, locator_set_name,
11876 vec_len (locator_set_name));
11877 vec_free (locator_set_name);
11879 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
11881 clib_memcpy (mp->locators, locators,
11882 (sizeof (ls_locator_t) * vec_len (locators)));
11883 vec_free (locators);
11888 /* Wait for a reply... */
11896 api_lisp_add_del_locator (vat_main_t * vam)
11898 unformat_input_t *input = vam->input;
11899 vl_api_lisp_add_del_locator_t *mp;
11901 u32 tmp_if_index = ~0;
11902 u32 sw_if_index = ~0;
11903 u8 sw_if_index_set = 0;
11904 u8 sw_if_index_if_name_set = 0;
11906 u8 priority_set = 0;
11910 u8 *locator_set_name = NULL;
11911 u8 locator_set_name_set = 0;
11913 /* Parse args required to build the message */
11914 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11916 if (unformat (input, "del"))
11920 else if (unformat (input, "locator-set %s", &locator_set_name))
11922 locator_set_name_set = 1;
11924 else if (unformat (input, "iface %U", unformat_sw_if_index, vam,
11927 sw_if_index_if_name_set = 1;
11928 sw_if_index = tmp_if_index;
11930 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
11932 sw_if_index_set = 1;
11933 sw_if_index = tmp_if_index;
11935 else if (unformat (input, "p %d", &priority))
11939 else if (unformat (input, "w %d", &weight))
11947 if (locator_set_name_set == 0)
11949 errmsg ("missing locator-set name");
11953 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
11955 errmsg ("missing sw_if_index");
11956 vec_free (locator_set_name);
11960 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
11962 errmsg ("cannot use both params interface name and sw_if_index");
11963 vec_free (locator_set_name);
11967 if (priority_set == 0)
11969 errmsg ("missing locator-set priority\n");
11970 vec_free (locator_set_name);
11974 if (weight_set == 0)
11976 errmsg ("missing locator-set weight\n");
11977 vec_free (locator_set_name);
11981 if (vec_len (locator_set_name) > 64)
11983 errmsg ("locator-set name too long\n");
11984 vec_free (locator_set_name);
11987 vec_add1 (locator_set_name, 0);
11989 /* Construct the API message */
11990 M (LISP_ADD_DEL_LOCATOR, lisp_add_del_locator);
11992 mp->is_add = is_add;
11993 mp->sw_if_index = ntohl (sw_if_index);
11994 mp->priority = priority;
11995 mp->weight = weight;
11996 clib_memcpy (mp->locator_set_name, locator_set_name,
11997 vec_len (locator_set_name));
11998 vec_free (locator_set_name);
12003 /* Wait for a reply... */
12011 api_lisp_add_del_local_eid (vat_main_t * vam)
12013 unformat_input_t *input = vam->input;
12014 vl_api_lisp_add_del_local_eid_t *mp;
12018 lisp_eid_vat_t _eid, *eid = &_eid;
12019 u8 *locator_set_name = 0;
12020 u8 locator_set_name_set = 0;
12023 /* Parse args required to build the message */
12024 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12026 if (unformat (input, "del"))
12030 else if (unformat (input, "vni %d", &vni))
12034 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
12038 else if (unformat (input, "locator-set %s", &locator_set_name))
12040 locator_set_name_set = 1;
12046 if (locator_set_name_set == 0)
12048 errmsg ("missing locator-set name\n");
12054 errmsg ("EID address not set!");
12055 vec_free (locator_set_name);
12059 if (vec_len (locator_set_name) > 64)
12061 errmsg ("locator-set name too long\n");
12062 vec_free (locator_set_name);
12065 vec_add1 (locator_set_name, 0);
12067 /* Construct the API message */
12068 M (LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid);
12070 mp->is_add = is_add;
12071 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
12072 mp->eid_type = eid->type;
12073 mp->prefix_len = eid->len;
12074 mp->vni = clib_host_to_net_u32 (vni);
12075 clib_memcpy (mp->locator_set_name, locator_set_name,
12076 vec_len (locator_set_name));
12078 vec_free (locator_set_name);
12083 /* Wait for a reply... */
12091 /** Used for transferring locators via VPP API */
12092 typedef CLIB_PACKED(struct
12094 u8 is_ip4; /**< is locator an IPv4 address? */
12095 u8 priority; /**< locator priority */
12096 u8 weight; /**< locator weight */
12097 u8 addr[16]; /**< IPv4/IPv6 address */
12102 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
12104 unformat_input_t *input = vam->input;
12105 vl_api_lisp_gpe_add_del_fwd_entry_t *mp;
12108 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
12109 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
12110 u8 rmt_eid_set = 0, lcl_eid_set = 0;
12111 u32 action = ~0, p, w;
12112 ip4_address_t rmt_rloc4, lcl_rloc4;
12113 ip6_address_t rmt_rloc6, lcl_rloc6;
12114 rloc_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
12116 memset (&rloc, 0, sizeof (rloc));
12118 /* Parse args required to build the message */
12119 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12121 if (unformat (input, "del"))
12125 else if (unformat (input, "rmt_eid %U", unformat_lisp_eid_vat, rmt_eid))
12129 else if (unformat (input, "lcl_eid %U", unformat_lisp_eid_vat, lcl_eid))
12133 else if (unformat (input, "p %d w %d", &p, &w))
12137 errmsg ("No RLOC configured for setting priority/weight!");
12140 curr_rloc->priority = p;
12141 curr_rloc->weight = w;
12143 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
12144 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
12148 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
12149 rloc.priority = rloc.weight = 0;
12150 vec_add1 (lcl_locs, rloc);
12152 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
12153 vec_add1 (rmt_locs, rloc);
12154 /* priority and weight saved in rmt loc */
12155 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
12157 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
12158 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
12161 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
12162 rloc.priority = rloc.weight = 0;
12163 vec_add1 (lcl_locs, rloc);
12165 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
12166 vec_add1 (rmt_locs, rloc);
12167 /* priority and weight saved in rmt loc */
12168 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
12170 else if (unformat (input, "action %d", &action))
12176 clib_warning ("parse error '%U'", format_unformat_error, input);
12183 errmsg ("remote eid addresses not set\n");
12187 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
12189 errmsg ("eid types don't match\n");
12193 if (0 == rmt_locs && (u32) ~ 0 == action)
12195 errmsg ("action not set for negative mapping\n");
12199 /* Construct the API message */
12200 M (LISP_GPE_ADD_DEL_FWD_ENTRY, lisp_gpe_add_del_fwd_entry);
12202 mp->is_add = is_add;
12203 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
12204 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
12205 mp->eid_type = rmt_eid->type;
12206 mp->rmt_len = rmt_eid->len;
12207 mp->lcl_len = lcl_eid->len;
12208 mp->action = action;
12210 if (0 != rmt_locs && 0 != lcl_locs)
12212 mp->loc_num = vec_len (rmt_locs);
12213 clib_memcpy (mp->lcl_locs, lcl_locs,
12214 (sizeof (rloc_t) * vec_len (lcl_locs)));
12215 clib_memcpy (mp->rmt_locs, rmt_locs,
12216 (sizeof (rloc_t) * vec_len (rmt_locs)));
12218 vec_free (lcl_locs);
12219 vec_free (rmt_locs);
12224 /* Wait for a reply... */
12232 api_lisp_add_del_map_resolver (vat_main_t * vam)
12234 unformat_input_t *input = vam->input;
12235 vl_api_lisp_add_del_map_resolver_t *mp;
12240 ip4_address_t ipv4;
12241 ip6_address_t ipv6;
12243 /* Parse args required to build the message */
12244 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12246 if (unformat (input, "del"))
12250 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
12254 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
12262 if (ipv4_set && ipv6_set)
12264 errmsg ("both eid v4 and v6 addresses set\n");
12268 if (!ipv4_set && !ipv6_set)
12270 errmsg ("eid addresses not set\n");
12274 /* Construct the API message */
12275 M (LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver);
12277 mp->is_add = is_add;
12281 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
12286 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
12292 /* Wait for a reply... */
12300 api_lisp_gpe_enable_disable (vat_main_t * vam)
12302 unformat_input_t *input = vam->input;
12303 vl_api_lisp_gpe_enable_disable_t *mp;
12308 /* Parse args required to build the message */
12309 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12311 if (unformat (input, "enable"))
12316 else if (unformat (input, "disable"))
12327 errmsg ("Value not set\n");
12331 /* Construct the API message */
12332 M (LISP_GPE_ENABLE_DISABLE, lisp_gpe_enable_disable);
12339 /* Wait for a reply... */
12347 api_lisp_enable_disable (vat_main_t * vam)
12349 unformat_input_t *input = vam->input;
12350 vl_api_lisp_enable_disable_t *mp;
12355 /* Parse args required to build the message */
12356 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12358 if (unformat (input, "enable"))
12363 else if (unformat (input, "disable"))
12373 errmsg ("Value not set\n");
12377 /* Construct the API message */
12378 M (LISP_ENABLE_DISABLE, lisp_enable_disable);
12385 /* Wait for a reply... */
12393 * Enable/disable LISP proxy ITR.
12395 * @param vam vpp API test context
12396 * @return return code
12399 api_lisp_pitr_set_locator_set (vat_main_t * vam)
12402 u8 ls_name_set = 0;
12403 unformat_input_t *input = vam->input;
12404 vl_api_lisp_pitr_set_locator_set_t *mp;
12408 /* Parse args required to build the message */
12409 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12411 if (unformat (input, "del"))
12413 else if (unformat (input, "locator-set %s", &ls_name))
12417 errmsg ("parse error '%U'", format_unformat_error, input);
12424 errmsg ("locator-set name not set!");
12428 M (LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set);
12430 mp->is_add = is_add;
12431 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
12432 vec_free (ls_name);
12437 /* wait for reply */
12445 api_show_lisp_pitr (vat_main_t * vam)
12447 vl_api_show_lisp_pitr_t *mp;
12450 if (!vam->json_output)
12452 fformat (vam->ofp, "%=20s\n", "lisp status:");
12455 M (SHOW_LISP_PITR, show_lisp_pitr);
12459 /* Wait for a reply... */
12467 * Add/delete mapping between vni and vrf
12470 api_lisp_eid_table_add_del_map (vat_main_t * vam)
12473 unformat_input_t *input = vam->input;
12474 vl_api_lisp_eid_table_add_del_map_t *mp;
12475 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
12476 u32 vni, vrf, bd_index;
12478 /* Parse args required to build the message */
12479 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12481 if (unformat (input, "del"))
12483 else if (unformat (input, "vrf %d", &vrf))
12485 else if (unformat (input, "bd_index %d", &bd_index))
12487 else if (unformat (input, "vni %d", &vni))
12493 if (!vni_set || (!vrf_set && !bd_index_set))
12495 errmsg ("missing arguments!");
12499 if (vrf_set && bd_index_set)
12501 errmsg ("error: both vrf and bd entered!");
12505 M (LISP_EID_TABLE_ADD_DEL_MAP, lisp_eid_table_add_del_map);
12507 mp->is_add = is_add;
12508 mp->vni = htonl (vni);
12509 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
12510 mp->is_l2 = bd_index_set;
12515 /* wait for reply */
12523 * Add/del remote mapping to/from LISP control plane
12525 * @param vam vpp API test context
12526 * @return return code
12529 api_lisp_add_del_remote_mapping (vat_main_t * vam)
12531 unformat_input_t *input = vam->input;
12532 vl_api_lisp_add_del_remote_mapping_t *mp;
12535 //TODO: seid need remove
12536 lisp_eid_vat_t _eid, *eid = &_eid;
12537 lisp_eid_vat_t _seid, *seid = &_seid;
12538 u8 is_add = 1, del_all = 0, eid_set = 0;
12539 u32 action = ~0, p, w;
12540 ip4_address_t rloc4;
12541 ip6_address_t rloc6;
12542 rloc_t *rlocs = 0, rloc, *curr_rloc = 0;
12544 memset (&rloc, 0, sizeof (rloc));
12546 /* Parse args required to build the message */
12547 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12549 if (unformat (input, "del-all"))
12553 else if (unformat (input, "del"))
12557 else if (unformat (input, "add"))
12561 else if (unformat (input, "deid %U", unformat_lisp_eid_vat, eid))
12565 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, &seid))
12567 //TODO: Need remove, but first must be remove from CSIT test
12569 else if (unformat (input, "vni %d", &vni))
12573 else if (unformat (input, "p %d w %d", &p, &w))
12577 errmsg ("No RLOC configured for setting priority/weight!");
12580 curr_rloc->priority = p;
12581 curr_rloc->weight = w;
12583 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
12586 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
12587 vec_add1 (rlocs, rloc);
12588 curr_rloc = &rlocs[vec_len (rlocs) - 1];
12590 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
12593 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
12594 vec_add1 (rlocs, rloc);
12595 curr_rloc = &rlocs[vec_len (rlocs) - 1];
12597 else if (unformat (input, "action %d", &action))
12603 clib_warning ("parse error '%U'", format_unformat_error, input);
12610 errmsg ("missing params!");
12614 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
12616 errmsg ("no action set for negative map-reply!");
12620 M (LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping);
12621 mp->is_add = is_add;
12622 mp->vni = htonl (vni);
12623 mp->action = (u8) action;
12624 mp->eid_len = eid->len;
12625 mp->del_all = del_all;
12626 mp->eid_type = eid->type;
12627 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
12629 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
12630 clib_memcpy (mp->rlocs, rlocs, (sizeof (rloc_t) * vec_len (rlocs)));
12636 /* Wait for a reply... */
12644 * Add/del LISP adjacency. Saves mapping in LISP control plane and updates
12645 * forwarding entries in data-plane accordingly.
12647 * @param vam vpp API test context
12648 * @return return code
12651 api_lisp_add_del_adjacency (vat_main_t * vam)
12653 unformat_input_t *input = vam->input;
12654 vl_api_lisp_add_del_adjacency_t *mp;
12657 ip4_address_t seid4, deid4;
12658 ip6_address_t seid6, deid6;
12659 u8 deid_mac[6] = { 0 };
12660 u8 seid_mac[6] = { 0 };
12661 u8 deid_type, seid_type;
12662 u32 seid_len = 0, deid_len = 0, len;
12665 seid_type = deid_type = (u8) ~ 0;
12667 /* Parse args required to build the message */
12668 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12670 if (unformat (input, "del"))
12674 else if (unformat (input, "add"))
12678 else if (unformat (input, "deid %U/%d", unformat_ip4_address,
12681 deid_type = 0; /* ipv4 */
12684 else if (unformat (input, "deid %U/%d", unformat_ip6_address,
12687 deid_type = 1; /* ipv6 */
12690 else if (unformat (input, "deid %U", unformat_ethernet_address,
12693 deid_type = 2; /* mac */
12695 else if (unformat (input, "seid %U/%d", unformat_ip4_address,
12698 seid_type = 0; /* ipv4 */
12701 else if (unformat (input, "seid %U/%d", unformat_ip6_address,
12704 seid_type = 1; /* ipv6 */
12707 else if (unformat (input, "seid %U", unformat_ethernet_address,
12710 seid_type = 2; /* mac */
12712 else if (unformat (input, "vni %d", &vni))
12718 errmsg ("parse error '%U'", format_unformat_error, input);
12723 if ((u8) ~ 0 == deid_type)
12725 errmsg ("missing params!");
12729 if (seid_type != deid_type)
12731 errmsg ("source and destination EIDs are of different types!");
12735 M (LISP_ADD_DEL_ADJACENCY, lisp_add_del_adjacency);
12736 mp->is_add = is_add;
12737 mp->vni = htonl (vni);
12738 mp->seid_len = seid_len;
12739 mp->deid_len = deid_len;
12740 mp->eid_type = deid_type;
12742 switch (mp->eid_type)
12745 clib_memcpy (mp->seid, &seid4, sizeof (seid4));
12746 clib_memcpy (mp->deid, &deid4, sizeof (deid4));
12749 clib_memcpy (mp->seid, &seid6, sizeof (seid6));
12750 clib_memcpy (mp->deid, &deid6, sizeof (deid6));
12753 clib_memcpy (mp->seid, seid_mac, 6);
12754 clib_memcpy (mp->deid, deid_mac, 6);
12757 errmsg ("unknown EID type %d!", mp->eid_type);
12764 /* Wait for a reply... */
12772 api_lisp_gpe_add_del_iface (vat_main_t * vam)
12774 unformat_input_t *input = vam->input;
12775 vl_api_lisp_gpe_add_del_iface_t *mp;
12777 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
12778 u32 dp_table = 0, vni = 0;
12780 /* Parse args required to build the message */
12781 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12783 if (unformat (input, "up"))
12788 else if (unformat (input, "down"))
12793 else if (unformat (input, "table_id %d", &dp_table))
12797 else if (unformat (input, "bd_id %d", &dp_table))
12802 else if (unformat (input, "vni %d", &vni))
12810 if (action_set == 0)
12812 errmsg ("Action not set\n");
12815 if (dp_table_set == 0 || vni_set == 0)
12817 errmsg ("vni and dp_table must be set\n");
12821 /* Construct the API message */
12822 M (LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface);
12824 mp->is_add = is_add;
12825 mp->dp_table = dp_table;
12832 /* Wait for a reply... */
12840 * Add/del map request itr rlocs from LISP control plane and updates
12842 * @param vam vpp API test context
12843 * @return return code
12846 api_lisp_add_del_map_request_itr_rlocs (vat_main_t * vam)
12848 unformat_input_t *input = vam->input;
12849 vl_api_lisp_add_del_map_request_itr_rlocs_t *mp;
12851 u8 *locator_set_name = 0;
12852 u8 locator_set_name_set = 0;
12855 /* Parse args required to build the message */
12856 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12858 if (unformat (input, "del"))
12862 else if (unformat (input, "%_%v%_", &locator_set_name))
12864 locator_set_name_set = 1;
12868 clib_warning ("parse error '%U'", format_unformat_error, input);
12873 if (is_add && !locator_set_name_set)
12875 errmsg ("itr-rloc is not set!");
12879 if (is_add && vec_len (locator_set_name) > 64)
12881 errmsg ("itr-rloc locator-set name too long\n");
12882 vec_free (locator_set_name);
12886 M (LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, lisp_add_del_map_request_itr_rlocs);
12887 mp->is_add = is_add;
12890 clib_memcpy (mp->locator_set_name, locator_set_name,
12891 vec_len (locator_set_name));
12895 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
12897 vec_free (locator_set_name);
12902 /* Wait for a reply... */
12910 lisp_locator_dump_send_msg (vat_main_t * vam, u32 locator_set_index,
12913 vl_api_lisp_locator_dump_t *mp;
12916 M (LISP_LOCATOR_DUMP, lisp_locator_dump);
12918 mp->locator_set_index = htonl (locator_set_index);
12919 mp->filter = filter;
12924 /* Use a control ping for synchronization */
12926 vl_api_noprint_control_ping_t *mp;
12927 M (NOPRINT_CONTROL_PING, noprint_control_ping);
12930 /* Wait for a reply... */
12935 clean_locator_set_message (vat_main_t * vam)
12937 locator_set_msg_t *ls = 0;
12939 vec_foreach (ls, vam->locator_set_msg)
12941 vec_free (ls->locator_set_name);
12944 vec_free (vam->locator_set_msg);
12948 print_locator_in_locator_set (vat_main_t * vam, u8 filter)
12950 locator_set_msg_t *ls;
12951 locator_msg_t *loc;
12953 int i = 0, ret = 0;
12955 vec_foreach (ls, vam->locator_set_msg)
12957 ret = lisp_locator_dump_send_msg (vam, ls->locator_set_index, filter);
12960 vec_free (vam->locator_msg);
12961 clean_locator_set_message (vam);
12965 tmp_str = format (0, "%=20s%=16d%s", ls->locator_set_name,
12966 ls->locator_set_index,
12967 vec_len (vam->locator_msg) ? "" : "\n");
12969 vec_foreach (loc, vam->locator_msg)
12973 tmp_str = format (tmp_str, "%=37s", " ");
12977 tmp_str = format (tmp_str, "%=16d%=16d%=16d\n",
12978 loc->sw_if_index, loc->priority, loc->weight);
12982 tmp_str = format (tmp_str, "%=16U%=16d%=16d\n",
12983 loc->is_ipv6 ? format_ip6_address :
12984 format_ip4_address,
12985 loc->ip_address, loc->priority, loc->weight);
12990 fformat (vam->ofp, "%s", tmp_str);
12991 vec_free (tmp_str);
12992 vec_free (vam->locator_msg);
12995 clean_locator_set_message (vam);
13001 json_locator_in_locator_set (vat_main_t * vam, u8 filter)
13003 locator_set_msg_t *ls;
13004 locator_msg_t *loc;
13005 vat_json_node_t *node = NULL;
13006 vat_json_node_t *locator_array;
13007 vat_json_node_t *locator;
13008 struct in6_addr ip6;
13009 struct in_addr ip4;
13012 if (!vec_len (vam->locator_set_msg))
13014 /* just print [] */
13015 vat_json_init_array (&vam->json_tree);
13016 vat_json_print (vam->ofp, &vam->json_tree);
13017 vam->json_tree.type = VAT_JSON_NONE;
13021 if (VAT_JSON_ARRAY != vam->json_tree.type)
13023 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13024 vat_json_init_array (&vam->json_tree);
13027 vec_foreach (ls, vam->locator_set_msg)
13029 ret = lisp_locator_dump_send_msg (vam, ls->locator_set_index, filter);
13032 vec_free (ls->locator_set_name);
13033 vec_free (vam->locator_msg);
13034 vec_free (vam->locator_set_msg);
13035 vat_json_free (&vam->json_tree);
13036 vam->json_tree.type = VAT_JSON_NONE;
13040 node = vat_json_array_add (&vam->json_tree);
13041 vat_json_init_object (node);
13043 vat_json_object_add_uint (node, "locator-set-index",
13044 ls->locator_set_index);
13045 vat_json_object_add_string_copy (node, "locator-set",
13046 ls->locator_set_name);
13047 locator_array = vat_json_object_add_list (node, "locator");
13048 vec_foreach (loc, vam->locator_msg)
13050 locator = vat_json_array_add (locator_array);
13051 vat_json_init_object (locator);
13054 vat_json_object_add_uint (locator, "locator-index",
13061 clib_memcpy (&ip6, loc->ip_address, sizeof (ip6));
13062 vat_json_object_add_ip6 (locator, "locator", ip6);
13066 clib_memcpy (&ip4, loc->ip_address, sizeof (ip4));
13067 vat_json_object_add_ip4 (locator, "locator", ip4);
13070 vat_json_object_add_uint (locator, "priority", loc->priority);
13071 vat_json_object_add_uint (locator, "weight", loc->weight);
13074 vec_free (ls->locator_set_name);
13075 vec_free (vam->locator_msg);
13078 vat_json_print (vam->ofp, &vam->json_tree);
13079 vat_json_free (&vam->json_tree);
13080 vam->json_tree.type = VAT_JSON_NONE;
13082 vec_free (vam->locator_set_msg);
13088 get_locator_set_index_from_msg (vat_main_t * vam, u8 * locator_set,
13089 u32 * locator_set_index)
13091 locator_set_msg_t *ls;
13094 *locator_set_index = ~0;
13096 if (!vec_len (vam->locator_set_msg))
13101 vec_foreach (ls, vam->locator_set_msg)
13103 if (!strcmp ((char *) locator_set, (char *) ls->locator_set_name))
13105 *locator_set_index = ls->locator_set_index;
13106 vec_free (vam->locator_set_msg);
13111 vec_free (vam->locator_set_msg);
13117 get_locator_set_index (vat_main_t * vam, u8 * locator_set,
13118 u32 * locator_set_index)
13120 vl_api_lisp_locator_set_dump_t *mp;
13123 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
13127 /* Use a control ping for synchronization */
13129 vl_api_noprint_control_ping_t *mp;
13130 M (NOPRINT_CONTROL_PING, noprint_control_ping);
13134 vam->noprint_msg = 1;
13135 /* Wait for a reply... */
13139 get_locator_set_index_from_msg (vam, locator_set, locator_set_index);
13140 vam->noprint_msg = 0;
13149 lisp_locator_dump (vat_main_t * vam, u32 locator_set_index, u8 * locator_set,
13156 if (!vam->json_output)
13158 fformat (vam->ofp, "%=20s%=16s%=16s\n",
13159 "locator", "priority", "weight");
13164 ret = get_locator_set_index (vam, locator_set, &locator_set_index);
13167 if (!ret && ~0 == locator_set_index)
13172 ret = lisp_locator_dump_send_msg (vam, locator_set_index, filter);
13178 lisp_locator_set_dump (vat_main_t * vam, u8 filter)
13180 vl_api_lisp_locator_set_dump_t *mp;
13183 if (!vam->json_output)
13185 fformat (vam->ofp, "%=20s%=16s%=16s%=16s%=16s\n",
13186 "locator-set", "locator-set-index", "locator", "priority",
13190 vam->noprint_msg = 1;
13192 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
13194 mp->filter = filter;
13199 /* Use a control ping for synchronization */
13201 vl_api_noprint_control_ping_t *mp;
13202 M (NOPRINT_CONTROL_PING, noprint_control_ping);
13206 /* Wait for a reply... */
13210 if (vam->noprint_msg)
13212 if (!vam->json_output)
13214 print_locator_in_locator_set(vam, filter);
13218 json_locator_in_locator_set(vam, filter);
13221 vam->noprint_msg = 0;
13230 api_lisp_locator_set_dump (vat_main_t * vam)
13232 unformat_input_t *input = vam->input;
13233 vam->noprint_msg = 0;
13234 u32 locator_set_index = ~0;
13235 u8 locator_set_index_set = 0;
13236 u8 *locator_set = 0;
13237 u8 locator_set_set = 0;
13241 /* Parse args required to build the message */
13242 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13244 if (unformat (input, "locator-set-index %u", &locator_set_index))
13246 locator_set_index_set = 1;
13248 else if (unformat (input, "locator-set %s", &locator_set))
13250 locator_set_set = 1;
13252 else if (unformat (input, "local"))
13256 else if (unformat (input, "remote"))
13266 if (locator_set_index_set && locator_set_set)
13268 errmsg ("use only input parameter!\n");
13272 if (locator_set_index_set || locator_set_set)
13274 ret = lisp_locator_dump (vam, locator_set_index, locator_set, filter);
13278 ret = lisp_locator_set_dump (vam, filter);
13281 vec_free (locator_set);
13287 api_lisp_eid_table_map_dump (vat_main_t * vam)
13291 unformat_input_t *input = vam->input;
13292 vl_api_lisp_eid_table_map_dump_t *mp;
13295 /* Parse args required to build the message */
13296 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13298 if (unformat (input, "l2"))
13303 else if (unformat (input, "l3"))
13310 errmsg ("parse error '%U'", format_unformat_error, input);
13317 errmsg ("expected one of 'l2' or 'l3' parameter!\n");
13321 if (!vam->json_output)
13323 fformat (vam->ofp, "%=10s%=10s\n", "VNI", is_l2 ? "BD" : "VRF");
13326 M (LISP_EID_TABLE_MAP_DUMP, lisp_eid_table_map_dump);
13332 /* Use a control ping for synchronization */
13334 vl_api_control_ping_t *mp;
13335 M (CONTROL_PING, control_ping);
13338 /* Wait for a reply... */
13346 api_lisp_eid_table_vni_dump (vat_main_t * vam)
13348 vl_api_lisp_eid_table_vni_dump_t *mp;
13351 if (!vam->json_output)
13353 fformat (vam->ofp, "VNI\n");
13356 M (LISP_EID_TABLE_VNI_DUMP, lisp_eid_table_vni_dump);
13361 /* Use a control ping for synchronization */
13363 vl_api_control_ping_t *mp;
13364 M (CONTROL_PING, control_ping);
13367 /* Wait for a reply... */
13375 get_locator_set (vat_main_t * vam)
13377 vl_api_lisp_locator_set_dump_t *mp;
13380 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
13384 /* Use a control ping for synchronization */
13386 vl_api_noprint_control_ping_t *mp;
13387 M (NOPRINT_CONTROL_PING, noprint_control_ping);
13391 /* Wait for a reply... */
13399 format_eid_for_eid_table (vat_main_t * vam, u8 * str, eid_table_t * eid_table,
13402 u8 *(*format_eid) (u8 *, va_list *) = 0;
13404 ASSERT (vam != NULL);
13405 ASSERT (eid_table != NULL);
13412 switch (eid_table->eid_type)
13416 format_eid = (eid_table->eid_type ? format_ip6_address :
13417 format_ip4_address);
13418 str = format (0, "[%d] %U/%d", eid_table->vni,
13419 format_eid, eid_table->eid, eid_table->eid_prefix_len);
13422 str = format (0, "[%d] %U", eid_table->vni,
13423 format_ethernet_address, eid_table->eid);
13426 errmsg ("unknown EID type %d!", eid_table->eid_type);
13438 format_locator_set_for_eid_table (vat_main_t * vam, u8 * str,
13439 eid_table_t * eid_table)
13441 locator_set_msg_t *ls = 0;
13443 ASSERT (vam != NULL);
13444 ASSERT (eid_table != NULL);
13446 if (eid_table->is_local)
13448 vec_foreach (ls, vam->locator_set_msg)
13450 if (ls->locator_set_index == eid_table->locator_set_index)
13452 str = format (0, "local(%s)", ls->locator_set_name);
13457 str = format (0, "local(N/A)");
13461 str = format (0, "remote");
13468 format_locator_for_eid_table (vat_main_t * vam, u8 * str,
13469 eid_table_t * eid_table)
13471 locator_msg_t *loc = 0;
13472 int first_line = 1;
13474 ASSERT (vam != NULL);
13475 ASSERT (eid_table != NULL);
13477 if (~0 == eid_table->locator_set_index)
13479 return format (0, "action: %d\n", eid_table->action);
13482 vec_foreach (loc, vam->locator_msg)
13488 str = format (str, "%-55s%-d\n", " ", loc->sw_if_index);
13492 str = format (str, "%=55s%-U\n", " ",
13493 loc->is_ipv6 ? format_ip6_address :
13494 format_ip4_address, loc->ip_address);
13502 str = format (str, "%-30d%-20u%-u\n", loc->sw_if_index,
13503 eid_table->ttl, eid_table->authoritative);
13507 str = format (str, "%-30U%-20u%-u\n",
13508 loc->is_ipv6 ? format_ip6_address :
13509 format_ip4_address,
13510 loc->ip_address, eid_table->ttl,
13511 eid_table->authoritative);
13520 print_lisp_eid_table_dump (vat_main_t * vam)
13522 eid_table_t *eid_table = 0;
13523 u8 *tmp_str = 0, *tmp_str2 = 0;
13526 ASSERT (vam != NULL);
13528 ret = get_locator_set (vam);
13531 vec_free (vam->eid_tables);
13535 fformat (vam->ofp, "%-35s%-20s%-30s%-20s%-s\n", "EID", "type", "locators",
13536 "ttl", "authoritative");
13538 vec_foreach (eid_table, vam->eid_tables)
13540 if (~0 != eid_table->locator_set_index)
13542 ret = lisp_locator_dump_send_msg (vam, eid_table->locator_set_index,
13546 vec_free (vam->locator_msg);
13547 clean_locator_set_message (vam);
13548 vec_free (vam->eid_tables);
13553 tmp_str2 = format_eid_for_eid_table (vam, tmp_str2, eid_table, &ret);
13556 vec_free (vam->locator_msg);
13557 clean_locator_set_message (vam);
13558 vec_free (vam->eid_tables);
13562 tmp_str = format (0, "%-35s", tmp_str2);
13563 vec_free (tmp_str2);
13565 tmp_str2 = format_locator_set_for_eid_table (vam, tmp_str2, eid_table);
13566 tmp_str = format (tmp_str, "%-20s", tmp_str2);
13567 vec_free (tmp_str2);
13569 tmp_str2 = format_locator_for_eid_table (vam, tmp_str2, eid_table);
13570 tmp_str = format (tmp_str, "%-s", tmp_str2);
13571 vec_free (tmp_str2);
13573 fformat (vam->ofp, "%s", tmp_str);
13574 vec_free (tmp_str);
13575 vec_free (vam->locator_msg);
13578 clean_locator_set_message (vam);
13579 vec_free (vam->eid_tables);
13585 json_locator_set_for_eid_table (vat_main_t * vam, vat_json_node_t * node,
13586 eid_table_t * eid_table)
13588 locator_set_msg_t *ls = 0;
13591 ASSERT (vam != NULL);
13592 ASSERT (node != NULL);
13593 ASSERT (eid_table != NULL);
13595 if (eid_table->is_local)
13597 vec_foreach (ls, vam->locator_set_msg)
13599 if (ls->locator_set_index == eid_table->locator_set_index)
13601 vat_json_object_add_string_copy (node, "locator-set",
13602 ls->locator_set_name);
13607 s = format (0, "N/A");
13609 vat_json_object_add_string_copy (node, "locator-set", s);
13614 s = format (0, "remote");
13616 vat_json_object_add_string_copy (node, "locator-set", s);
13622 json_eid_for_eid_table (vat_main_t * vam, vat_json_node_t * node,
13623 eid_table_t * eid_table)
13626 struct in6_addr ip6;
13627 struct in_addr ip4;
13629 ASSERT (vam != NULL);
13630 ASSERT (node != NULL);
13631 ASSERT (eid_table != NULL);
13633 switch (eid_table->eid_type)
13636 clib_memcpy (&ip4, eid_table->eid, sizeof (ip4));
13637 vat_json_object_add_ip4 (node, "eid", ip4);
13638 vat_json_object_add_uint (node, "eid-prefix-len",
13639 eid_table->eid_prefix_len);
13642 clib_memcpy (&ip6, eid_table->eid, sizeof (ip6));
13643 vat_json_object_add_ip6 (node, "eid", ip6);
13644 vat_json_object_add_uint (node, "eid-prefix-len",
13645 eid_table->eid_prefix_len);
13648 s = format (0, "%U", format_ethernet_address, eid_table->eid);
13650 vat_json_object_add_string_copy (node, "eid", s);
13654 errmsg ("unknown EID type %d!", eid_table->eid_type);
13662 json_locator_for_eid_table (vat_main_t * vam, vat_json_node_t * node,
13663 eid_table_t * eid_table)
13665 locator_msg_t *loc = 0;
13666 vat_json_node_t *locator_array = 0;
13667 vat_json_node_t *locator = 0;
13668 struct in6_addr ip6;
13669 struct in_addr ip4;
13671 ASSERT (vam != NULL);
13672 ASSERT (node != NULL);
13673 ASSERT (eid_table != NULL);
13675 locator_array = vat_json_object_add_list (node, "locator");
13676 vec_foreach (loc, vam->locator_msg)
13678 locator = vat_json_array_add (locator_array);
13679 vat_json_init_object (locator);
13682 vat_json_object_add_uint (locator, "locator-index", loc->sw_if_index);
13688 clib_memcpy (&ip6, loc->ip_address, sizeof (ip6));
13689 vat_json_object_add_ip6 (locator, "locator", ip6);
13693 clib_memcpy (&ip4, loc->ip_address, sizeof (ip4));
13694 vat_json_object_add_ip4 (locator, "locator", ip4);
13701 json_lisp_eid_table_dump (vat_main_t * vam)
13703 eid_table_t *eid_table;
13704 vat_json_node_t *node = 0;
13707 ASSERT (vam != NULL);
13709 ret = get_locator_set (vam);
13712 vec_free (vam->eid_tables);
13716 if (!vec_len (vam->eid_tables))
13718 /* just print [] */
13719 vat_json_init_array (&vam->json_tree);
13720 vat_json_print (vam->ofp, &vam->json_tree);
13721 vam->json_tree.type = VAT_JSON_NONE;
13725 if (VAT_JSON_ARRAY != vam->json_tree.type)
13727 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13728 vat_json_init_array (&vam->json_tree);
13731 vec_foreach (eid_table, vam->eid_tables)
13733 ret = lisp_locator_dump_send_msg (vam, eid_table->locator_set_index, 0);
13736 vec_free (vam->locator_msg);
13737 vec_free (vam->eid_tables);
13738 clean_locator_set_message (vam);
13739 vat_json_free (&vam->json_tree);
13740 vam->json_tree.type = VAT_JSON_NONE;
13744 node = vat_json_array_add (&vam->json_tree);
13745 vat_json_init_object (node);
13747 vat_json_object_add_uint (node, "vni", eid_table->vni);
13749 json_locator_set_for_eid_table (vam, node, eid_table);
13750 ret = json_eid_for_eid_table (vam, node, eid_table);
13753 vec_free (vam->locator_msg);
13754 vec_free (vam->eid_tables);
13755 clean_locator_set_message (vam);
13756 vat_json_free (&vam->json_tree);
13757 vam->json_tree.type = VAT_JSON_NONE;
13761 json_locator_for_eid_table (vam, node, eid_table);
13763 vat_json_object_add_uint (node, "ttl", eid_table->ttl);
13764 vat_json_object_add_uint (node, "authoritative",
13765 eid_table->authoritative);
13767 vec_free (vam->locator_msg);
13770 vat_json_print (vam->ofp, &vam->json_tree);
13771 vat_json_free (&vam->json_tree);
13772 vam->json_tree.type = VAT_JSON_NONE;
13774 clean_locator_set_message (vam);
13775 vec_free (vam->eid_tables);
13781 api_lisp_eid_table_dump (vat_main_t * vam)
13783 unformat_input_t *i = vam->input;
13784 vl_api_lisp_eid_table_dump_t *mp;
13786 struct in_addr ip4;
13787 struct in6_addr ip6;
13789 u8 eid_type = ~0, eid_set = 0;
13790 u32 prefix_length = ~0, t, vni = 0;
13793 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13795 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
13801 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
13807 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
13812 else if (unformat (i, "vni %d", &t))
13816 else if (unformat (i, "local"))
13820 else if (unformat (i, "remote"))
13826 errmsg ("parse error '%U'", format_unformat_error, i);
13831 M (LISP_EID_TABLE_DUMP, lisp_eid_table_dump);
13833 mp->filter = filter;
13837 mp->vni = htonl (vni);
13838 mp->eid_type = eid_type;
13842 mp->prefix_length = prefix_length;
13843 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
13846 mp->prefix_length = prefix_length;
13847 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
13850 clib_memcpy (mp->eid, mac, sizeof (mac));
13853 errmsg ("unknown EID type %d!", eid_type);
13858 vam->noprint_msg = 1;
13863 /* Use a control ping for synchronization */
13865 vl_api_noprint_control_ping_t *mp;
13866 M (NOPRINT_CONTROL_PING, noprint_control_ping);
13870 /* Wait for a reply... */
13874 if (vam->noprint_msg)
13876 if (!vam->json_output)
13878 vam->retval = print_lisp_eid_table_dump(vam);
13882 vam->retval = json_lisp_eid_table_dump(vam);
13885 vam->noprint_msg = 0;
13894 api_lisp_gpe_tunnel_dump (vat_main_t * vam)
13896 vl_api_lisp_gpe_tunnel_dump_t *mp;
13899 if (!vam->json_output)
13901 fformat (vam->ofp, "%=20s%=30s%=16s%=16s%=16s%=16s"
13902 "%=16s%=16s%=16s%=16s%=16s\n",
13903 "Tunel", "Source", "Destination", "Fib encap", "Fib decap",
13904 "Decap next", "Lisp version", "Flags", "Next protocol",
13905 "ver_res", "res", "iid");
13908 M (LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump);
13912 /* Use a control ping for synchronization */
13914 vl_api_control_ping_t *mp;
13915 M (CONTROL_PING, control_ping);
13918 /* Wait for a reply... */
13926 api_lisp_map_resolver_dump (vat_main_t * vam)
13928 vl_api_lisp_map_resolver_dump_t *mp;
13931 if (!vam->json_output)
13933 fformat (vam->ofp, "%=20s\n", "Map resolver");
13936 M (LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump);
13940 /* Use a control ping for synchronization */
13942 vl_api_control_ping_t *mp;
13943 M (CONTROL_PING, control_ping);
13946 /* Wait for a reply... */
13954 api_show_lisp_status (vat_main_t * vam)
13956 vl_api_show_lisp_status_t *mp;
13959 if (!vam->json_output)
13961 fformat (vam->ofp, "%-20s%-16s\n", "lisp status", "locator-set");
13964 M (SHOW_LISP_STATUS, show_lisp_status);
13967 /* Wait for a reply... */
13975 api_lisp_get_map_request_itr_rlocs (vat_main_t * vam)
13977 vl_api_lisp_get_map_request_itr_rlocs_t *mp;
13980 if (!vam->json_output)
13982 fformat (vam->ofp, "%=20s\n", "itr-rlocs:");
13985 M (LISP_GET_MAP_REQUEST_ITR_RLOCS, lisp_get_map_request_itr_rlocs);
13988 /* Wait for a reply... */
13996 api_af_packet_create (vat_main_t * vam)
13998 unformat_input_t *i = vam->input;
13999 vl_api_af_packet_create_t *mp;
14001 u8 *host_if_name = 0;
14003 u8 random_hw_addr = 1;
14005 memset (hw_addr, 0, sizeof (hw_addr));
14007 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14009 if (unformat (i, "name %s", &host_if_name))
14010 vec_add1 (host_if_name, 0);
14011 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
14012 random_hw_addr = 0;
14017 if (!vec_len (host_if_name))
14019 errmsg ("host-interface name must be specified");
14023 if (vec_len (host_if_name) > 64)
14025 errmsg ("host-interface name too long");
14029 M (AF_PACKET_CREATE, af_packet_create);
14031 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
14032 clib_memcpy (mp->hw_addr, hw_addr, 6);
14033 mp->use_random_hw_addr = random_hw_addr;
14034 vec_free (host_if_name);
14037 W2 (fprintf (vam->ofp, " new sw_if_index = %d ", vam->sw_if_index));
14043 api_af_packet_delete (vat_main_t * vam)
14045 unformat_input_t *i = vam->input;
14046 vl_api_af_packet_delete_t *mp;
14048 u8 *host_if_name = 0;
14050 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14052 if (unformat (i, "name %s", &host_if_name))
14053 vec_add1 (host_if_name, 0);
14058 if (!vec_len (host_if_name))
14060 errmsg ("host-interface name must be specified");
14064 if (vec_len (host_if_name) > 64)
14066 errmsg ("host-interface name too long");
14070 M (AF_PACKET_DELETE, af_packet_delete);
14072 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
14073 vec_free (host_if_name);
14082 api_policer_add_del (vat_main_t * vam)
14084 unformat_input_t *i = vam->input;
14085 vl_api_policer_add_del_t *mp;
14096 u8 color_aware = 0;
14097 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
14099 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
14100 conform_action.dscp = 0;
14101 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
14102 exceed_action.dscp = 0;
14103 violate_action.action_type = SSE2_QOS_ACTION_DROP;
14104 violate_action.dscp = 0;
14106 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14108 if (unformat (i, "del"))
14110 else if (unformat (i, "name %s", &name))
14111 vec_add1 (name, 0);
14112 else if (unformat (i, "cir %u", &cir))
14114 else if (unformat (i, "eir %u", &eir))
14116 else if (unformat (i, "cb %u", &cb))
14118 else if (unformat (i, "eb %u", &eb))
14120 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
14123 else if (unformat (i, "round_type %U", unformat_policer_round_type,
14126 else if (unformat (i, "type %U", unformat_policer_type, &type))
14128 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
14131 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
14134 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
14137 else if (unformat (i, "color-aware"))
14143 if (!vec_len (name))
14145 errmsg ("policer name must be specified");
14149 if (vec_len (name) > 64)
14151 errmsg ("policer name too long");
14155 M (POLICER_ADD_DEL, policer_add_del);
14157 clib_memcpy (mp->name, name, vec_len (name));
14159 mp->is_add = is_add;
14164 mp->rate_type = rate_type;
14165 mp->round_type = round_type;
14167 mp->conform_action_type = conform_action.action_type;
14168 mp->conform_dscp = conform_action.dscp;
14169 mp->exceed_action_type = exceed_action.action_type;
14170 mp->exceed_dscp = exceed_action.dscp;
14171 mp->violate_action_type = violate_action.action_type;
14172 mp->violate_dscp = violate_action.dscp;
14173 mp->color_aware = color_aware;
14182 api_policer_dump (vat_main_t * vam)
14184 unformat_input_t *i = vam->input;
14185 vl_api_policer_dump_t *mp;
14187 u8 *match_name = 0;
14188 u8 match_name_valid = 0;
14190 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14192 if (unformat (i, "name %s", &match_name))
14194 vec_add1 (match_name, 0);
14195 match_name_valid = 1;
14201 M (POLICER_DUMP, policer_dump);
14202 mp->match_name_valid = match_name_valid;
14203 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
14204 vec_free (match_name);
14208 /* Use a control ping for synchronization */
14210 vl_api_control_ping_t *mp;
14211 M (CONTROL_PING, control_ping);
14214 /* Wait for a reply... */
14222 api_policer_classify_set_interface (vat_main_t * vam)
14224 unformat_input_t *i = vam->input;
14225 vl_api_policer_classify_set_interface_t *mp;
14228 int sw_if_index_set;
14229 u32 ip4_table_index = ~0;
14230 u32 ip6_table_index = ~0;
14231 u32 l2_table_index = ~0;
14234 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14236 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
14237 sw_if_index_set = 1;
14238 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14239 sw_if_index_set = 1;
14240 else if (unformat (i, "del"))
14242 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14244 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14246 else if (unformat (i, "l2-table %d", &l2_table_index))
14250 clib_warning ("parse error '%U'", format_unformat_error, i);
14255 if (sw_if_index_set == 0)
14257 errmsg ("missing interface name or sw_if_index\n");
14261 M (POLICER_CLASSIFY_SET_INTERFACE, policer_classify_set_interface);
14263 mp->sw_if_index = ntohl (sw_if_index);
14264 mp->ip4_table_index = ntohl (ip4_table_index);
14265 mp->ip6_table_index = ntohl (ip6_table_index);
14266 mp->l2_table_index = ntohl (l2_table_index);
14267 mp->is_add = is_add;
14276 api_policer_classify_dump (vat_main_t * vam)
14278 unformat_input_t *i = vam->input;
14279 vl_api_policer_classify_dump_t *mp;
14281 u8 type = POLICER_CLASSIFY_N_TABLES;
14283 if (unformat (i, "type %U", unformat_classify_table_type, &type))
14287 errmsg ("classify table type must be specified\n");
14291 if (!vam->json_output)
14293 fformat (vam->ofp, "%10s%20s\n", "Intfc idx", "Classify table");
14296 M (POLICER_CLASSIFY_DUMP, policer_classify_dump);
14301 /* Use a control ping for synchronization */
14303 vl_api_control_ping_t *mp;
14304 M (CONTROL_PING, control_ping);
14307 /* Wait for a reply... */
14315 api_netmap_create (vat_main_t * vam)
14317 unformat_input_t *i = vam->input;
14318 vl_api_netmap_create_t *mp;
14322 u8 random_hw_addr = 1;
14326 memset (hw_addr, 0, sizeof (hw_addr));
14328 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14330 if (unformat (i, "name %s", &if_name))
14331 vec_add1 (if_name, 0);
14332 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
14333 random_hw_addr = 0;
14334 else if (unformat (i, "pipe"))
14336 else if (unformat (i, "master"))
14338 else if (unformat (i, "slave"))
14344 if (!vec_len (if_name))
14346 errmsg ("interface name must be specified");
14350 if (vec_len (if_name) > 64)
14352 errmsg ("interface name too long");
14356 M (NETMAP_CREATE, netmap_create);
14358 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
14359 clib_memcpy (mp->hw_addr, hw_addr, 6);
14360 mp->use_random_hw_addr = random_hw_addr;
14361 mp->is_pipe = is_pipe;
14362 mp->is_master = is_master;
14363 vec_free (if_name);
14372 api_netmap_delete (vat_main_t * vam)
14374 unformat_input_t *i = vam->input;
14375 vl_api_netmap_delete_t *mp;
14379 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14381 if (unformat (i, "name %s", &if_name))
14382 vec_add1 (if_name, 0);
14387 if (!vec_len (if_name))
14389 errmsg ("interface name must be specified");
14393 if (vec_len (if_name) > 64)
14395 errmsg ("interface name too long");
14399 M (NETMAP_DELETE, netmap_delete);
14401 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
14402 vec_free (if_name);
14410 static void vl_api_mpls_gre_tunnel_details_t_handler
14411 (vl_api_mpls_gre_tunnel_details_t * mp)
14413 vat_main_t *vam = &vat_main;
14415 i32 len = ntohl (mp->nlabels);
14417 if (mp->l2_only == 0)
14419 fformat (vam->ofp, "[%d]: src %U, dst %U, adj %U/%d, labels ",
14420 ntohl (mp->tunnel_index),
14421 format_ip4_address, &mp->tunnel_src,
14422 format_ip4_address, &mp->tunnel_dst,
14423 format_ip4_address, &mp->intfc_address,
14424 ntohl (mp->mask_width));
14425 for (i = 0; i < len; i++)
14427 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14429 fformat (vam->ofp, "\n");
14430 fformat (vam->ofp, " inner fib index %d, outer fib index %d\n",
14431 ntohl (mp->inner_fib_index), ntohl (mp->outer_fib_index));
14435 fformat (vam->ofp, "[%d]: src %U, dst %U, key %U, labels ",
14436 ntohl (mp->tunnel_index),
14437 format_ip4_address, &mp->tunnel_src,
14438 format_ip4_address, &mp->tunnel_dst,
14439 format_ip4_address, &mp->intfc_address);
14440 for (i = 0; i < len; i++)
14442 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14444 fformat (vam->ofp, "\n");
14445 fformat (vam->ofp, " l2 interface %d, outer fib index %d\n",
14446 ntohl (mp->hw_if_index), ntohl (mp->outer_fib_index));
14450 static void vl_api_mpls_gre_tunnel_details_t_handler_json
14451 (vl_api_mpls_gre_tunnel_details_t * mp)
14453 vat_main_t *vam = &vat_main;
14454 vat_json_node_t *node = NULL;
14455 struct in_addr ip4;
14457 i32 len = ntohl (mp->nlabels);
14459 if (VAT_JSON_ARRAY != vam->json_tree.type)
14461 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14462 vat_json_init_array (&vam->json_tree);
14464 node = vat_json_array_add (&vam->json_tree);
14466 vat_json_init_object (node);
14467 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
14468 clib_memcpy (&ip4, &(mp->intfc_address), sizeof (ip4));
14469 vat_json_object_add_ip4 (node, "intfc_address", ip4);
14470 vat_json_object_add_uint (node, "inner_fib_index",
14471 ntohl (mp->inner_fib_index));
14472 vat_json_object_add_uint (node, "mask_width", ntohl (mp->mask_width));
14473 vat_json_object_add_uint (node, "encap_index", ntohl (mp->encap_index));
14474 vat_json_object_add_uint (node, "hw_if_index", ntohl (mp->hw_if_index));
14475 vat_json_object_add_uint (node, "l2_only", ntohl (mp->l2_only));
14476 clib_memcpy (&ip4, &(mp->tunnel_src), sizeof (ip4));
14477 vat_json_object_add_ip4 (node, "tunnel_src", ip4);
14478 clib_memcpy (&ip4, &(mp->tunnel_dst), sizeof (ip4));
14479 vat_json_object_add_ip4 (node, "tunnel_dst", ip4);
14480 vat_json_object_add_uint (node, "outer_fib_index",
14481 ntohl (mp->outer_fib_index));
14482 vat_json_object_add_uint (node, "label_count", len);
14483 for (i = 0; i < len; i++)
14485 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14490 api_mpls_gre_tunnel_dump (vat_main_t * vam)
14492 vl_api_mpls_gre_tunnel_dump_t *mp;
14496 /* Parse args required to build the message */
14497 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
14499 if (!unformat (vam->input, "tunnel_index %d", &index))
14506 fformat (vam->ofp, " tunnel_index %d\n", index);
14508 M (MPLS_GRE_TUNNEL_DUMP, mpls_gre_tunnel_dump);
14509 mp->tunnel_index = htonl (index);
14512 /* Use a control ping for synchronization */
14514 vl_api_control_ping_t *mp;
14515 M (CONTROL_PING, control_ping);
14521 static void vl_api_mpls_eth_tunnel_details_t_handler
14522 (vl_api_mpls_eth_tunnel_details_t * mp)
14524 vat_main_t *vam = &vat_main;
14526 i32 len = ntohl (mp->nlabels);
14528 fformat (vam->ofp, "[%d]: dst %U, adj %U/%d, labels ",
14529 ntohl (mp->tunnel_index),
14530 format_ethernet_address, &mp->tunnel_dst_mac,
14531 format_ip4_address, &mp->intfc_address, ntohl (mp->mask_width));
14532 for (i = 0; i < len; i++)
14534 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14536 fformat (vam->ofp, "\n");
14537 fformat (vam->ofp, " tx on %d, rx fib index %d\n",
14538 ntohl (mp->tx_sw_if_index), ntohl (mp->inner_fib_index));
14541 static void vl_api_mpls_eth_tunnel_details_t_handler_json
14542 (vl_api_mpls_eth_tunnel_details_t * mp)
14544 vat_main_t *vam = &vat_main;
14545 vat_json_node_t *node = NULL;
14546 struct in_addr ip4;
14548 i32 len = ntohl (mp->nlabels);
14550 if (VAT_JSON_ARRAY != vam->json_tree.type)
14552 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14553 vat_json_init_array (&vam->json_tree);
14555 node = vat_json_array_add (&vam->json_tree);
14557 vat_json_init_object (node);
14558 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
14559 clib_memcpy (&ip4, &(mp->intfc_address), sizeof (ip4));
14560 vat_json_object_add_ip4 (node, "intfc_address", ip4);
14561 vat_json_object_add_uint (node, "inner_fib_index",
14562 ntohl (mp->inner_fib_index));
14563 vat_json_object_add_uint (node, "mask_width", ntohl (mp->mask_width));
14564 vat_json_object_add_uint (node, "encap_index", ntohl (mp->encap_index));
14565 vat_json_object_add_uint (node, "hw_if_index", ntohl (mp->hw_if_index));
14566 vat_json_object_add_uint (node, "l2_only", ntohl (mp->l2_only));
14567 vat_json_object_add_string_copy (node, "tunnel_dst_mac",
14568 format (0, "%U", format_ethernet_address,
14569 &mp->tunnel_dst_mac));
14570 vat_json_object_add_uint (node, "tx_sw_if_index",
14571 ntohl (mp->tx_sw_if_index));
14572 vat_json_object_add_uint (node, "label_count", len);
14573 for (i = 0; i < len; i++)
14575 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14580 api_mpls_eth_tunnel_dump (vat_main_t * vam)
14582 vl_api_mpls_eth_tunnel_dump_t *mp;
14586 /* Parse args required to build the message */
14587 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
14589 if (!unformat (vam->input, "tunnel_index %d", &index))
14596 fformat (vam->ofp, " tunnel_index %d\n", index);
14598 M (MPLS_ETH_TUNNEL_DUMP, mpls_eth_tunnel_dump);
14599 mp->tunnel_index = htonl (index);
14602 /* Use a control ping for synchronization */
14604 vl_api_control_ping_t *mp;
14605 M (CONTROL_PING, control_ping);
14611 static void vl_api_mpls_fib_encap_details_t_handler
14612 (vl_api_mpls_fib_encap_details_t * mp)
14614 vat_main_t *vam = &vat_main;
14616 i32 len = ntohl (mp->nlabels);
14618 fformat (vam->ofp, "table %d, dest %U, label ",
14619 ntohl (mp->fib_index), format_ip4_address, &mp->dest, len);
14620 for (i = 0; i < len; i++)
14622 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14624 fformat (vam->ofp, "\n");
14627 static void vl_api_mpls_fib_encap_details_t_handler_json
14628 (vl_api_mpls_fib_encap_details_t * mp)
14630 vat_main_t *vam = &vat_main;
14631 vat_json_node_t *node = NULL;
14633 i32 len = ntohl (mp->nlabels);
14634 struct in_addr ip4;
14636 if (VAT_JSON_ARRAY != vam->json_tree.type)
14638 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14639 vat_json_init_array (&vam->json_tree);
14641 node = vat_json_array_add (&vam->json_tree);
14643 vat_json_init_object (node);
14644 vat_json_object_add_uint (node, "table", ntohl (mp->fib_index));
14645 vat_json_object_add_uint (node, "entry_index", ntohl (mp->entry_index));
14646 clib_memcpy (&ip4, &(mp->dest), sizeof (ip4));
14647 vat_json_object_add_ip4 (node, "dest", ip4);
14648 vat_json_object_add_uint (node, "s_bit", ntohl (mp->s_bit));
14649 vat_json_object_add_uint (node, "label_count", len);
14650 for (i = 0; i < len; i++)
14652 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14657 api_mpls_fib_encap_dump (vat_main_t * vam)
14659 vl_api_mpls_fib_encap_dump_t *mp;
14662 M (MPLS_FIB_ENCAP_DUMP, mpls_fib_encap_dump);
14665 /* Use a control ping for synchronization */
14667 vl_api_control_ping_t *mp;
14668 M (CONTROL_PING, control_ping);
14674 static void vl_api_mpls_fib_decap_details_t_handler
14675 (vl_api_mpls_fib_decap_details_t * mp)
14677 vat_main_t *vam = &vat_main;
14680 "RX table %d, TX table/intfc %u, swif_tag '%s', label %u, s_bit %u\n",
14681 ntohl (mp->rx_table_id), ntohl (mp->tx_table_id), mp->swif_tag,
14682 ntohl (mp->label), ntohl (mp->s_bit));
14685 static void vl_api_mpls_fib_decap_details_t_handler_json
14686 (vl_api_mpls_fib_decap_details_t * mp)
14688 vat_main_t *vam = &vat_main;
14689 vat_json_node_t *node = NULL;
14690 struct in_addr ip4;
14692 if (VAT_JSON_ARRAY != vam->json_tree.type)
14694 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14695 vat_json_init_array (&vam->json_tree);
14697 node = vat_json_array_add (&vam->json_tree);
14699 vat_json_init_object (node);
14700 vat_json_object_add_uint (node, "table", ntohl (mp->fib_index));
14701 vat_json_object_add_uint (node, "entry_index", ntohl (mp->entry_index));
14702 clib_memcpy (&ip4, &(mp->dest), sizeof (ip4));
14703 vat_json_object_add_ip4 (node, "dest", ip4);
14704 vat_json_object_add_uint (node, "s_bit", ntohl (mp->s_bit));
14705 vat_json_object_add_uint (node, "label", ntohl (mp->label));
14706 vat_json_object_add_uint (node, "rx_table_id", ntohl (mp->rx_table_id));
14707 vat_json_object_add_uint (node, "tx_table_id", ntohl (mp->tx_table_id));
14708 vat_json_object_add_string_copy (node, "swif_tag", mp->swif_tag);
14712 api_mpls_fib_decap_dump (vat_main_t * vam)
14714 vl_api_mpls_fib_decap_dump_t *mp;
14717 M (MPLS_FIB_DECAP_DUMP, mpls_fib_decap_dump);
14720 /* Use a control ping for synchronization */
14722 vl_api_control_ping_t *mp;
14723 M (CONTROL_PING, control_ping);
14730 api_classify_table_ids (vat_main_t * vam)
14732 vl_api_classify_table_ids_t *mp;
14735 /* Construct the API message */
14736 M (CLASSIFY_TABLE_IDS, classify_table_ids);
14746 api_classify_table_by_interface (vat_main_t * vam)
14748 unformat_input_t *input = vam->input;
14749 vl_api_classify_table_by_interface_t *mp;
14752 u32 sw_if_index = ~0;
14753 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14755 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
14757 else if (unformat (input, "sw_if_index %d", &sw_if_index))
14762 if (sw_if_index == ~0)
14764 errmsg ("missing interface name or sw_if_index\n");
14768 /* Construct the API message */
14769 M (CLASSIFY_TABLE_BY_INTERFACE, classify_table_by_interface);
14771 mp->sw_if_index = ntohl (sw_if_index);
14780 api_classify_table_info (vat_main_t * vam)
14782 unformat_input_t *input = vam->input;
14783 vl_api_classify_table_info_t *mp;
14787 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14789 if (unformat (input, "table_id %d", &table_id))
14794 if (table_id == ~0)
14796 errmsg ("missing table id\n");
14800 /* Construct the API message */
14801 M (CLASSIFY_TABLE_INFO, classify_table_info);
14803 mp->table_id = ntohl (table_id);
14812 api_classify_session_dump (vat_main_t * vam)
14814 unformat_input_t *input = vam->input;
14815 vl_api_classify_session_dump_t *mp;
14819 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14821 if (unformat (input, "table_id %d", &table_id))
14826 if (table_id == ~0)
14828 errmsg ("missing table id\n");
14832 /* Construct the API message */
14833 M (CLASSIFY_SESSION_DUMP, classify_session_dump);
14835 mp->table_id = ntohl (table_id);
14838 /* Use a control ping for synchronization */
14840 vl_api_control_ping_t *mp;
14841 M (CONTROL_PING, control_ping);
14850 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
14852 vat_main_t *vam = &vat_main;
14854 fformat (vam->ofp, "collector_address %U, collector_port %d, "
14855 "src_address %U, vrf_id %d, path_mtu %u, "
14856 "template_interval %u, udp_checksum %d\n",
14857 format_ip4_address, mp->collector_address,
14858 ntohs (mp->collector_port),
14859 format_ip4_address, mp->src_address,
14860 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
14861 ntohl (mp->template_interval), mp->udp_checksum);
14864 vam->result_ready = 1;
14868 vl_api_ipfix_exporter_details_t_handler_json
14869 (vl_api_ipfix_exporter_details_t * mp)
14871 vat_main_t *vam = &vat_main;
14872 vat_json_node_t node;
14873 struct in_addr collector_address;
14874 struct in_addr src_address;
14876 vat_json_init_object (&node);
14877 clib_memcpy (&collector_address, &mp->collector_address,
14878 sizeof (collector_address));
14879 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
14880 vat_json_object_add_uint (&node, "collector_port",
14881 ntohs (mp->collector_port));
14882 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
14883 vat_json_object_add_ip4 (&node, "src_address", src_address);
14884 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
14885 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
14886 vat_json_object_add_uint (&node, "template_interval",
14887 ntohl (mp->template_interval));
14888 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
14890 vat_json_print (vam->ofp, &node);
14891 vat_json_free (&node);
14893 vam->result_ready = 1;
14897 api_ipfix_exporter_dump (vat_main_t * vam)
14899 vl_api_ipfix_exporter_dump_t *mp;
14902 /* Construct the API message */
14903 M (IPFIX_EXPORTER_DUMP, ipfix_exporter_dump);
14913 api_ipfix_classify_stream_dump (vat_main_t * vam)
14915 vl_api_ipfix_classify_stream_dump_t *mp;
14918 /* Construct the API message */
14919 M (IPFIX_CLASSIFY_STREAM_DUMP, ipfix_classify_stream_dump);
14929 vl_api_ipfix_classify_stream_details_t_handler
14930 (vl_api_ipfix_classify_stream_details_t * mp)
14932 vat_main_t *vam = &vat_main;
14933 fformat (vam->ofp, "domain_id %d, src_port %d\n",
14934 ntohl (mp->domain_id), ntohs (mp->src_port));
14936 vam->result_ready = 1;
14940 vl_api_ipfix_classify_stream_details_t_handler_json
14941 (vl_api_ipfix_classify_stream_details_t * mp)
14943 vat_main_t *vam = &vat_main;
14944 vat_json_node_t node;
14946 vat_json_init_object (&node);
14947 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
14948 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
14950 vat_json_print (vam->ofp, &node);
14951 vat_json_free (&node);
14953 vam->result_ready = 1;
14957 api_ipfix_classify_table_dump (vat_main_t * vam)
14959 vl_api_ipfix_classify_table_dump_t *mp;
14962 if (!vam->json_output)
14964 fformat (vam->ofp, "%15s%15s%20s\n", "table_id", "ip_version",
14965 "transport_protocol");
14968 /* Construct the API message */
14969 M (IPFIX_CLASSIFY_TABLE_DUMP, ipfix_classify_table_dump);
14974 /* Use a control ping for synchronization */
14976 vl_api_control_ping_t *mp;
14977 M (CONTROL_PING, control_ping);
14984 vl_api_ipfix_classify_table_details_t_handler
14985 (vl_api_ipfix_classify_table_details_t * mp)
14987 vat_main_t *vam = &vat_main;
14988 fformat (vam->ofp, "%15d%15d%20d\n", ntohl (mp->table_id), mp->ip_version,
14989 mp->transport_protocol);
14993 vl_api_ipfix_classify_table_details_t_handler_json
14994 (vl_api_ipfix_classify_table_details_t * mp)
14996 vat_json_node_t *node = NULL;
14997 vat_main_t *vam = &vat_main;
14999 if (VAT_JSON_ARRAY != vam->json_tree.type)
15001 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15002 vat_json_init_array (&vam->json_tree);
15005 node = vat_json_array_add (&vam->json_tree);
15006 vat_json_init_object (node);
15008 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
15009 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
15010 vat_json_object_add_uint (node, "transport_protocol",
15011 mp->transport_protocol);
15015 api_pg_create_interface (vat_main_t * vam)
15017 unformat_input_t *input = vam->input;
15018 vl_api_pg_create_interface_t *mp;
15022 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15024 if (unformat (input, "if_id %d", &if_id))
15031 errmsg ("missing pg interface index\n");
15035 /* Construct the API message */
15036 M (PG_CREATE_INTERFACE, pg_create_interface);
15038 mp->interface_id = ntohl (if_id);
15047 api_pg_capture (vat_main_t * vam)
15049 unformat_input_t *input = vam->input;
15050 vl_api_pg_capture_t *mp;
15056 u8 pcap_file_set = 0;
15058 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15060 if (unformat (input, "if_id %d", &if_id))
15062 else if (unformat (input, "pcap %s", &pcap_file))
15064 else if (unformat (input, "count %d", &count))
15066 else if (unformat (input, "disable"))
15073 errmsg ("missing pg interface index\n");
15076 if (pcap_file_set > 0)
15078 if (vec_len (pcap_file) > 255)
15080 errmsg ("pcap file name is too long\n");
15085 u32 name_len = vec_len (pcap_file);
15086 /* Construct the API message */
15087 M (PG_CAPTURE, pg_capture);
15089 mp->interface_id = ntohl (if_id);
15090 mp->is_enabled = enable;
15091 mp->count = ntohl (count);
15092 mp->pcap_name_length = ntohl (name_len);
15093 if (pcap_file_set != 0)
15095 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
15097 vec_free (pcap_file);
15106 api_pg_enable_disable (vat_main_t * vam)
15108 unformat_input_t *input = vam->input;
15109 vl_api_pg_enable_disable_t *mp;
15113 u8 stream_name_set = 0;
15114 u8 *stream_name = 0;
15115 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15117 if (unformat (input, "stream %s", &stream_name))
15118 stream_name_set = 1;
15119 else if (unformat (input, "disable"))
15125 if (stream_name_set > 0)
15127 if (vec_len (stream_name) > 255)
15129 errmsg ("stream name too long\n");
15134 u32 name_len = vec_len (stream_name);
15135 /* Construct the API message */
15136 M (PG_ENABLE_DISABLE, pg_enable_disable);
15138 mp->is_enabled = enable;
15139 if (stream_name_set != 0)
15141 mp->stream_name_length = ntohl (name_len);
15142 clib_memcpy (mp->stream_name, stream_name, name_len);
15144 vec_free (stream_name);
15153 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
15155 unformat_input_t *input = vam->input;
15156 vl_api_ip_source_and_port_range_check_add_del_t *mp;
15159 u16 *low_ports = 0;
15160 u16 *high_ports = 0;
15163 ip4_address_t ip4_addr;
15164 ip6_address_t ip6_addr;
15172 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15174 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
15180 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
15185 else if (unformat (input, "vrf %d", &vrf_id))
15187 else if (unformat (input, "del"))
15189 else if (unformat (input, "port %d", &tmp))
15191 if (tmp == 0 || tmp > 65535)
15193 errmsg ("port %d out of range", tmp);
15197 this_hi = this_low + 1;
15198 vec_add1 (low_ports, this_low);
15199 vec_add1 (high_ports, this_hi);
15201 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
15203 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
15205 errmsg ("incorrect range parameters\n");
15209 /* Note: in debug CLI +1 is added to high before
15210 passing to real fn that does "the work"
15211 (ip_source_and_port_range_check_add_del).
15212 This fn is a wrapper around the binary API fn a
15213 control plane will call, which expects this increment
15214 to have occurred. Hence letting the binary API control
15215 plane fn do the increment for consistency between VAT
15216 and other control planes.
15219 vec_add1 (low_ports, this_low);
15220 vec_add1 (high_ports, this_hi);
15226 if (prefix_set == 0)
15228 errmsg ("<address>/<mask> not specified\n");
15234 errmsg ("VRF ID required, not specified\n");
15241 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
15245 if (vec_len (low_ports) == 0)
15247 errmsg ("At least one port or port range required\n");
15251 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL,
15252 ip_source_and_port_range_check_add_del);
15254 mp->is_add = is_add;
15259 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
15264 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
15267 mp->mask_length = length;
15268 mp->number_of_ranges = vec_len (low_ports);
15270 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
15271 vec_free (low_ports);
15273 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
15274 vec_free (high_ports);
15276 mp->vrf_id = ntohl (vrf_id);
15285 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
15287 unformat_input_t *input = vam->input;
15288 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
15290 u32 sw_if_index = ~0;
15292 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
15293 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
15296 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15298 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
15300 else if (unformat (input, "sw_if_index %d", &sw_if_index))
15302 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
15304 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
15306 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
15308 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
15310 else if (unformat (input, "del"))
15316 if (sw_if_index == ~0)
15318 errmsg ("Interface required but not specified\n");
15324 errmsg ("VRF ID required but not specified\n");
15328 if (tcp_out_vrf_id == 0
15329 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
15332 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
15336 /* Construct the API message */
15337 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL,
15338 ip_source_and_port_range_check_interface_add_del);
15340 mp->sw_if_index = ntohl (sw_if_index);
15341 mp->is_add = is_add;
15342 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
15343 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
15344 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
15345 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
15350 /* Wait for a reply... */
15355 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
15357 unformat_input_t *i = vam->input;
15358 vl_api_ipsec_gre_add_del_tunnel_t *mp;
15360 u32 local_sa_id = 0;
15361 u32 remote_sa_id = 0;
15362 ip4_address_t src_address;
15363 ip4_address_t dst_address;
15366 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15368 if (unformat (i, "local_sa %d", &local_sa_id))
15370 else if (unformat (i, "remote_sa %d", &remote_sa_id))
15372 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
15374 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
15376 else if (unformat (i, "del"))
15380 clib_warning ("parse error '%U'", format_unformat_error, i);
15385 M (IPSEC_GRE_ADD_DEL_TUNNEL, ipsec_gre_add_del_tunnel);
15387 mp->local_sa_id = ntohl (local_sa_id);
15388 mp->remote_sa_id = ntohl (remote_sa_id);
15389 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
15390 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
15391 mp->is_add = is_add;
15399 static void vl_api_ipsec_gre_tunnel_details_t_handler
15400 (vl_api_ipsec_gre_tunnel_details_t * mp)
15402 vat_main_t *vam = &vat_main;
15404 fformat (vam->ofp, "%11d%15U%15U%14d%14d\n",
15405 ntohl (mp->sw_if_index),
15406 format_ip4_address, &mp->src_address,
15407 format_ip4_address, &mp->dst_address,
15408 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
15411 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
15412 (vl_api_ipsec_gre_tunnel_details_t * mp)
15414 vat_main_t *vam = &vat_main;
15415 vat_json_node_t *node = NULL;
15416 struct in_addr ip4;
15418 if (VAT_JSON_ARRAY != vam->json_tree.type)
15420 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15421 vat_json_init_array (&vam->json_tree);
15423 node = vat_json_array_add (&vam->json_tree);
15425 vat_json_init_object (node);
15426 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
15427 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
15428 vat_json_object_add_ip4 (node, "src_address", ip4);
15429 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
15430 vat_json_object_add_ip4 (node, "dst_address", ip4);
15431 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
15432 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
15436 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
15438 unformat_input_t *i = vam->input;
15439 vl_api_ipsec_gre_tunnel_dump_t *mp;
15442 u8 sw_if_index_set = 0;
15444 /* Parse args required to build the message */
15445 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15447 if (unformat (i, "sw_if_index %d", &sw_if_index))
15448 sw_if_index_set = 1;
15453 if (sw_if_index_set == 0)
15458 if (!vam->json_output)
15460 fformat (vam->ofp, "%11s%15s%15s%14s%14s\n",
15461 "sw_if_index", "src_address", "dst_address",
15462 "local_sa_id", "remote_sa_id");
15465 /* Get list of gre-tunnel interfaces */
15466 M (IPSEC_GRE_TUNNEL_DUMP, ipsec_gre_tunnel_dump);
15468 mp->sw_if_index = htonl (sw_if_index);
15472 /* Use a control ping for synchronization */
15474 vl_api_control_ping_t *mp;
15475 M (CONTROL_PING, control_ping);
15482 api_delete_subif (vat_main_t * vam)
15484 unformat_input_t *i = vam->input;
15485 vl_api_delete_subif_t *mp;
15487 u32 sw_if_index = ~0;
15489 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15491 if (unformat (i, "sw_if_index %d", &sw_if_index))
15497 if (sw_if_index == ~0)
15499 errmsg ("missing sw_if_index\n");
15503 /* Construct the API message */
15504 M (DELETE_SUBIF, delete_subif);
15505 mp->sw_if_index = ntohl (sw_if_index);
15512 q_or_quit (vat_main_t * vam)
15514 longjmp (vam->jump_buf, 1);
15515 return 0; /* not so much */
15519 q (vat_main_t * vam)
15521 return q_or_quit (vam);
15525 quit (vat_main_t * vam)
15527 return q_or_quit (vam);
15531 comment (vat_main_t * vam)
15537 cmd_cmp (void *a1, void *a2)
15542 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
15546 help (vat_main_t * vam)
15551 unformat_input_t *i = vam->input;
15554 if (unformat (i, "%s", &name))
15558 vec_add1 (name, 0);
15560 hs = hash_get_mem (vam->help_by_name, name);
15562 fformat (vam->ofp, "usage: %s %s\n", name, hs[0]);
15564 fformat (vam->ofp, "No such msg / command '%s'\n", name);
15569 fformat (vam->ofp, "Help is available for the following:\n");
15572 hash_foreach_pair (p, vam->function_by_name,
15574 vec_add1 (cmds, (u8 *)(p->key));
15578 vec_sort_with_function (cmds, cmd_cmp);
15580 for (j = 0; j < vec_len (cmds); j++)
15581 fformat (vam->ofp, "%s\n", cmds[j]);
15588 set (vat_main_t * vam)
15590 u8 *name = 0, *value = 0;
15591 unformat_input_t *i = vam->input;
15593 if (unformat (i, "%s", &name))
15595 /* The input buffer is a vector, not a string. */
15596 value = vec_dup (i->buffer);
15597 vec_delete (value, i->index, 0);
15598 /* Almost certainly has a trailing newline */
15599 if (value[vec_len (value) - 1] == '\n')
15600 value[vec_len (value) - 1] = 0;
15601 /* Make sure it's a proper string, one way or the other */
15602 vec_add1 (value, 0);
15603 (void) clib_macro_set_value (&vam->macro_main,
15604 (char *) name, (char *) value);
15607 errmsg ("usage: set <name> <value>\n");
15615 unset (vat_main_t * vam)
15619 if (unformat (vam->input, "%s", &name))
15620 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
15621 errmsg ("unset: %s wasn't set\n", name);
15634 macro_sort_cmp (void *a1, void *a2)
15636 macro_sort_t *s1 = a1;
15637 macro_sort_t *s2 = a2;
15639 return strcmp ((char *) (s1->name), (char *) (s2->name));
15643 dump_macro_table (vat_main_t * vam)
15645 macro_sort_t *sort_me = 0, *sm;
15650 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
15652 vec_add2 (sort_me, sm, 1);
15653 sm->name = (u8 *)(p->key);
15654 sm->value = (u8 *) (p->value[0]);
15658 vec_sort_with_function (sort_me, macro_sort_cmp);
15660 if (vec_len (sort_me))
15661 fformat (vam->ofp, "%-15s%s\n", "Name", "Value");
15663 fformat (vam->ofp, "The macro table is empty...\n");
15665 for (i = 0; i < vec_len (sort_me); i++)
15666 fformat (vam->ofp, "%-15s%s\n", sort_me[i].name, sort_me[i].value);
15671 dump_node_table (vat_main_t * vam)
15674 vlib_node_t *node, *next_node;
15676 if (vec_len (vam->graph_nodes) == 0)
15678 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
15682 for (i = 0; i < vec_len (vam->graph_nodes); i++)
15684 node = vam->graph_nodes[i];
15685 fformat (vam->ofp, "[%d] %s\n", i, node->name);
15686 for (j = 0; j < vec_len (node->next_nodes); j++)
15688 if (node->next_nodes[j] != ~0)
15690 next_node = vam->graph_nodes[node->next_nodes[j]];
15691 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
15699 search_node_table (vat_main_t * vam)
15701 unformat_input_t *line_input = vam->input;
15704 vlib_node_t *node, *next_node;
15707 if (vam->graph_node_index_by_name == 0)
15709 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
15713 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15715 if (unformat (line_input, "%s", &node_to_find))
15717 vec_add1 (node_to_find, 0);
15718 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
15721 fformat (vam->ofp, "%s not found...\n", node_to_find);
15724 node = vam->graph_nodes[p[0]];
15725 fformat (vam->ofp, "[%d] %s\n", p[0], node->name);
15726 for (j = 0; j < vec_len (node->next_nodes); j++)
15728 if (node->next_nodes[j] != ~0)
15730 next_node = vam->graph_nodes[node->next_nodes[j]];
15731 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
15738 clib_warning ("parse error '%U'", format_unformat_error,
15744 vec_free (node_to_find);
15753 script (vat_main_t * vam)
15756 char *save_current_file;
15757 unformat_input_t save_input;
15758 jmp_buf save_jump_buf;
15759 u32 save_line_number;
15761 FILE *new_fp, *save_ifp;
15763 if (unformat (vam->input, "%s", &s))
15765 new_fp = fopen ((char *) s, "r");
15768 errmsg ("Couldn't open script file %s\n", s);
15775 errmsg ("Missing script name\n");
15779 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
15780 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
15781 save_ifp = vam->ifp;
15782 save_line_number = vam->input_line_number;
15783 save_current_file = (char *) vam->current_file;
15785 vam->input_line_number = 0;
15787 vam->current_file = s;
15790 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
15791 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
15792 vam->ifp = save_ifp;
15793 vam->input_line_number = save_line_number;
15794 vam->current_file = (u8 *) save_current_file;
15801 echo (vat_main_t * vam)
15803 fformat (vam->ofp, "%v", vam->input->buffer);
15807 /* List of API message constructors, CLI names map to api_xxx */
15808 #define foreach_vpe_api_msg \
15809 _(create_loopback,"[mac <mac-addr>]") \
15810 _(sw_interface_dump,"") \
15811 _(sw_interface_set_flags, \
15812 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
15813 _(sw_interface_add_del_address, \
15814 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
15815 _(sw_interface_set_table, \
15816 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
15817 _(sw_interface_set_vpath, \
15818 "<intfc> | sw_if_index <id> enable | disable") \
15819 _(sw_interface_set_l2_xconnect, \
15820 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
15821 "enable | disable") \
15822 _(sw_interface_set_l2_bridge, \
15823 "<intfc> | sw_if_index <id> bd_id <bridge-domain-id>\n" \
15824 "[shg <split-horizon-group>] [bvi]\n" \
15825 "enable | disable") \
15826 _(bridge_domain_add_del, \
15827 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n")\
15828 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
15830 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
15832 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
15834 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
15836 "tapname <name> mac <mac-addr> | random-mac") \
15838 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
15840 "<vpp-if-name> | sw_if_index <id>") \
15841 _(sw_interface_tap_dump, "") \
15842 _(ip_add_del_route, \
15843 "<addr>/<mask> via <addr> [vrf <n>]\n" \
15844 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
15845 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
15846 "[multipath] [count <n>]") \
15847 _(proxy_arp_add_del, \
15848 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
15849 _(proxy_arp_intfc_enable_disable, \
15850 "<intfc> | sw_if_index <id> enable | disable") \
15851 _(mpls_add_del_encap, \
15852 "label <n> dst <ip4-addr> [vrf <n>] [del]") \
15853 _(mpls_add_del_decap, \
15854 "label <n> [rx_vrf_id <n>] [tx_vrf_id] [s-bit-clear][del]") \
15855 _(mpls_gre_add_del_tunnel, \
15856 "inner_vrf_id <n> outer_vrf_id <n> src <ip4-address> dst <ip4-address>\n" \
15857 "adj <ip4-address>/<mask-width> [del]") \
15858 _(sw_interface_set_unnumbered, \
15859 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
15860 _(ip_neighbor_add_del, \
15861 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
15862 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
15863 _(reset_vrf, "vrf <id> [ipv6]") \
15864 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
15865 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
15866 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
15867 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
15868 "[outer_vlan_id_any][inner_vlan_id_any]") \
15869 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
15870 _(reset_fib, "vrf <n> [ipv6]") \
15871 _(dhcp_proxy_config, \
15872 "svr <v46-address> src <v46-address>\n" \
15873 "insert-cid <n> [del]") \
15874 _(dhcp_proxy_config_2, \
15875 "svr <v46-address> src <v46-address>\n" \
15876 "rx_vrf_id <nn> server_vrf_id <nn> insert-cid <n> [del]") \
15877 _(dhcp_proxy_set_vss, \
15878 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
15879 _(dhcp_client_config, \
15880 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
15881 _(set_ip_flow_hash, \
15882 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
15883 _(sw_interface_ip6_enable_disable, \
15884 "<intfc> | sw_if_index <id> enable | disable") \
15885 _(sw_interface_ip6_set_link_local_address, \
15886 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
15887 _(sw_interface_ip6nd_ra_prefix, \
15888 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
15889 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
15890 "[nolink] [isno]") \
15891 _(sw_interface_ip6nd_ra_config, \
15892 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
15893 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
15894 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
15895 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
15896 _(l2_patch_add_del, \
15897 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
15898 "enable | disable") \
15899 _(mpls_ethernet_add_del_tunnel, \
15900 "tx <intfc> | tx_sw_if_index <n> dst <mac-addr>\n" \
15901 "adj <ip4-addr>/<mw> dst <mac-addr> [del]") \
15902 _(mpls_ethernet_add_del_tunnel_2, \
15903 "inner_vrf_id <n> outer_vrf_id <n> next-hop <ip4-addr>\n" \
15904 "resolve-attempts <n> resolve-if-needed 0 | 1 [del]") \
15905 _(sr_tunnel_add_del, \
15906 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
15907 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
15908 "[policy <policy_name>]") \
15909 _(sr_policy_add_del, \
15910 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
15911 _(sr_multicast_map_add_del, \
15912 "address [ip6 multicast address] sr-policy [policy name] [del]") \
15913 _(classify_add_del_table, \
15914 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
15915 "[del] mask <mask-value>\n" \
15916 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>") \
15917 _(classify_add_del_session, \
15918 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
15919 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
15920 " [l3 [ip4|ip6]]") \
15921 _(classify_set_interface_ip_table, \
15922 "<intfc> | sw_if_index <nn> table <nn>") \
15923 _(classify_set_interface_l2_tables, \
15924 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15925 " [other-table <nn>]") \
15926 _(get_node_index, "node <node-name") \
15927 _(add_node_next, "node <node-name> next <next-node-name>") \
15928 _(l2tpv3_create_tunnel, \
15929 "client_address <ip6-addr> our_address <ip6-addr>\n" \
15930 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n"\
15931 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
15932 _(l2tpv3_set_tunnel_cookies, \
15933 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
15934 "[new_remote_cookie <nn>]\n") \
15935 _(l2tpv3_interface_enable_disable, \
15936 "<intfc> | sw_if_index <nn> enable | disable") \
15937 _(l2tpv3_set_lookup_key, \
15938 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
15939 _(sw_if_l2tpv3_tunnel_dump, "") \
15940 _(vxlan_add_del_tunnel, \
15941 "src <ip-addr> dst <ip-addr> vni <vni> [encap-vrf-id <nn>]\n" \
15942 " [decap-next l2|ip4|ip6] [del]") \
15943 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15944 _(gre_add_del_tunnel, \
15945 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [del]\n") \
15946 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15947 _(l2_fib_clear_table, "") \
15948 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
15949 _(l2_interface_vlan_tag_rewrite, \
15950 "<intfc> | sw_if_index <nn> \n" \
15951 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
15952 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
15953 _(create_vhost_user_if, \
15954 "socket <filename> [server] [renumber <dev_instance>] " \
15955 "[mac <mac_address>]") \
15956 _(modify_vhost_user_if, \
15957 "<intfc> | sw_if_index <nn> socket <filename>\n" \
15958 "[server] [renumber <dev_instance>]") \
15959 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
15960 _(sw_interface_vhost_user_dump, "") \
15961 _(show_version, "") \
15962 _(vxlan_gpe_add_del_tunnel, \
15963 "local <addr> remote <addr> vni <nn>\n" \
15964 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
15965 "[next-ethernet] [next-nsh]\n") \
15966 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15967 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
15968 _(interface_name_renumber, \
15969 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
15970 _(input_acl_set_interface, \
15971 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15972 " [l2-table <nn>] [del]") \
15973 _(want_ip4_arp_events, "address <ip4-address> [del]") \
15974 _(want_ip6_nd_events, "address <ip6-address> [del]") \
15975 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
15976 _(ip_dump, "ipv4 | ipv6") \
15977 _(ipsec_spd_add_del, "spd_id <n> [del]") \
15978 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
15980 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
15981 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
15982 " integ_alg <alg> integ_key <hex>") \
15983 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
15984 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
15985 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
15986 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" )\
15987 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
15988 _(ikev2_profile_add_del, "name <profile_name> [del]") \
15989 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
15990 "(auth_data 0x<data> | auth_data <data>)") \
15991 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
15992 "(id_data 0x<data> | id_data <data>) (local|remote)") \
15993 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
15994 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
15995 "(local|remote)") \
15996 _(ikev2_set_local_key, "file <absolute_file_path>") \
15997 _(delete_loopback,"sw_if_index <nn>") \
15998 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
15999 _(map_add_domain, \
16000 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
16001 "ip6-src <ip6addr> " \
16002 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
16003 _(map_del_domain, "index <n>") \
16004 _(map_add_del_rule, \
16005 "index <n> psid <n> dst <ip6addr> [del]") \
16006 _(map_domain_dump, "") \
16007 _(map_rule_dump, "index <map-domain>") \
16008 _(want_interface_events, "enable|disable") \
16009 _(want_stats,"enable|disable") \
16010 _(get_first_msg_id, "client <name>") \
16011 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
16012 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
16013 "fib-id <nn> [ip4][ip6][default]") \
16014 _(get_node_graph, " ") \
16015 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
16016 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
16017 _(ioam_disable, "") \
16018 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
16019 " sw_if_index <sw_if_index> p <priority> " \
16020 "w <weight>] [del]") \
16021 _(lisp_add_del_locator, "locator-set <locator_name> " \
16022 "iface <intf> | sw_if_index <sw_if_index> " \
16023 "p <priority> w <weight> [del]") \
16024 _(lisp_add_del_local_eid,"vni <vni> eid " \
16025 "<ipv4|ipv6>/<prefix> | <L2 address> " \
16026 "locator-set <locator_name> [del]") \
16027 _(lisp_gpe_add_del_fwd_entry, "rmt_eid <eid> [lcl_eid <eid>] vni <vni>" \
16028 "dp_table <table> loc-pair <lcl_loc> <rmt_loc> ... [del]") \
16029 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
16030 _(lisp_gpe_enable_disable, "enable|disable") \
16031 _(lisp_enable_disable, "enable|disable") \
16032 _(lisp_gpe_add_del_iface, "up|down") \
16033 _(lisp_add_del_remote_mapping, "add|del vni <vni> deid <dest-eid> " \
16034 "rloc <locator> p <prio> " \
16035 "w <weight> [rloc <loc> ... ] " \
16036 "action <action> [del-all]") \
16037 _(lisp_add_del_adjacency, "add|del vni <vni> deid <dest-eid> seid " \
16038 "<src-eid> rloc <locator> p <prio> w <weight>"\
16039 "[rloc <loc> ... ] action <action>") \
16040 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
16041 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
16042 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
16043 _(lisp_locator_set_dump, "[locator-set-index <ls-index> | " \
16044 "locator-set <loc-set-name>] [local | remote]")\
16045 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
16046 "[local] | [remote]") \
16047 _(lisp_eid_table_vni_dump, "") \
16048 _(lisp_eid_table_map_dump, "l2|l3") \
16049 _(lisp_gpe_tunnel_dump, "") \
16050 _(lisp_map_resolver_dump, "") \
16051 _(show_lisp_status, "") \
16052 _(lisp_get_map_request_itr_rlocs, "") \
16053 _(show_lisp_pitr, "") \
16054 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
16055 _(af_packet_delete, "name <host interface name>") \
16056 _(policer_add_del, "name <policer name> <params> [del]") \
16057 _(policer_dump, "[name <policer name>]") \
16058 _(policer_classify_set_interface, \
16059 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
16060 " [l2-table <nn>] [del]") \
16061 _(policer_classify_dump, "type [ip4|ip6|l2]") \
16062 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
16063 "[master|slave]") \
16064 _(netmap_delete, "name <interface name>") \
16065 _(mpls_gre_tunnel_dump, "tunnel_index <tunnel-id>") \
16066 _(mpls_eth_tunnel_dump, "tunnel_index <tunnel-id>") \
16067 _(mpls_fib_encap_dump, "") \
16068 _(mpls_fib_decap_dump, "") \
16069 _(classify_table_ids, "") \
16070 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
16071 _(classify_table_info, "table_id <nn>") \
16072 _(classify_session_dump, "table_id <nn>") \
16073 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
16074 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
16075 "[template_interval <nn>] [udp_checksum]") \
16076 _(ipfix_exporter_dump, "") \
16077 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
16078 _(ipfix_classify_stream_dump, "") \
16079 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]")\
16080 _(ipfix_classify_table_dump, "") \
16081 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
16082 _(pg_create_interface, "if_id <nn>") \
16083 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
16084 _(pg_enable_disable, "[stream <id>] disable") \
16085 _(ip_source_and_port_range_check_add_del, \
16086 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
16087 _(ip_source_and_port_range_check_interface_add_del, \
16088 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
16089 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
16090 _(ipsec_gre_add_del_tunnel, \
16091 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
16092 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
16093 _(delete_subif,"sub_sw_if_index <nn> sub_if_id <nn>")
16095 /* List of command functions, CLI names map directly to functions */
16096 #define foreach_cli_function \
16097 _(comment, "usage: comment <ignore-rest-of-line>") \
16098 _(dump_interface_table, "usage: dump_interface_table") \
16099 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
16100 _(dump_ipv4_table, "usage: dump_ipv4_table") \
16101 _(dump_ipv6_table, "usage: dump_ipv6_table") \
16102 _(dump_stats_table, "usage: dump_stats_table") \
16103 _(dump_macro_table, "usage: dump_macro_table ") \
16104 _(dump_node_table, "usage: dump_node_table") \
16105 _(echo, "usage: echo <message>") \
16106 _(exec, "usage: exec <vpe-debug-CLI-command>") \
16107 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
16108 _(help, "usage: help") \
16109 _(q, "usage: quit") \
16110 _(quit, "usage: quit") \
16111 _(search_node_table, "usage: search_node_table <name>...") \
16112 _(set, "usage: set <variable-name> <value>") \
16113 _(script, "usage: script <file-name>") \
16114 _(unset, "usage: unset <variable-name>")
16117 static void vl_api_##n##_t_handler_uni \
16118 (vl_api_##n##_t * mp) \
16120 vat_main_t * vam = &vat_main; \
16121 if (vam->json_output) { \
16122 vl_api_##n##_t_handler_json(mp); \
16124 vl_api_##n##_t_handler(mp); \
16127 foreach_vpe_api_reply_msg;
16131 vat_api_hookup (vat_main_t * vam)
16134 vl_msg_api_set_handlers(VL_API_##N, #n, \
16135 vl_api_##n##_t_handler_uni, \
16137 vl_api_##n##_t_endian, \
16138 vl_api_##n##_t_print, \
16139 sizeof(vl_api_##n##_t), 1);
16140 foreach_vpe_api_reply_msg;
16143 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
16145 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
16147 vam->function_by_name = hash_create_string (0, sizeof (uword));
16149 vam->help_by_name = hash_create_string (0, sizeof (uword));
16151 /* API messages we can send */
16152 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
16153 foreach_vpe_api_msg;
16157 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
16158 foreach_vpe_api_msg;
16161 /* CLI functions */
16162 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
16163 foreach_cli_function;
16167 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
16168 foreach_cli_function;
16172 #undef vl_api_version
16173 #define vl_api_version(n,v) static u32 vpe_api_version = v;
16174 #include <vpp-api/vpe.api.h>
16175 #undef vl_api_version
16178 vl_client_add_api_signatures (vl_api_memclnt_create_t * mp)
16181 * Send the main API signature in slot 0. This bit of code must
16182 * match the checks in ../vpe/api/api.c: vl_msg_api_version_check().
16184 mp->api_versions[0] = clib_host_to_net_u32 (vpe_api_version);
16188 * fd.io coding-style-patch-verification: ON
16191 * eval: (c-set-style "gnu")