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;
896 static void vl_api_classify_add_del_table_reply_t_handler
897 (vl_api_classify_add_del_table_reply_t * mp)
899 vat_main_t *vam = &vat_main;
900 i32 retval = ntohl (mp->retval);
903 vam->async_errors += (retval < 0);
907 vam->retval = retval;
909 ((mp->new_table_index != 0xFFFFFFFF) ||
910 (mp->skip_n_vectors != 0xFFFFFFFF) ||
911 (mp->match_n_vectors != 0xFFFFFFFF)))
913 * Note: this is just barely thread-safe, depends on
914 * the main thread spinning waiting for an answer...
916 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d\n",
917 ntohl (mp->new_table_index),
918 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
919 vam->result_ready = 1;
923 static void vl_api_classify_add_del_table_reply_t_handler_json
924 (vl_api_classify_add_del_table_reply_t * mp)
926 vat_main_t *vam = &vat_main;
927 vat_json_node_t node;
929 vat_json_init_object (&node);
930 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
931 vat_json_object_add_uint (&node, "new_table_index",
932 ntohl (mp->new_table_index));
933 vat_json_object_add_uint (&node, "skip_n_vectors",
934 ntohl (mp->skip_n_vectors));
935 vat_json_object_add_uint (&node, "match_n_vectors",
936 ntohl (mp->match_n_vectors));
938 vat_json_print (vam->ofp, &node);
939 vat_json_free (&node);
941 vam->retval = ntohl (mp->retval);
942 vam->result_ready = 1;
945 static void vl_api_get_node_index_reply_t_handler
946 (vl_api_get_node_index_reply_t * mp)
948 vat_main_t *vam = &vat_main;
949 i32 retval = ntohl (mp->retval);
952 vam->async_errors += (retval < 0);
956 vam->retval = retval;
958 errmsg ("node index %d\n", ntohl (mp->node_index));
959 vam->result_ready = 1;
963 static void vl_api_get_node_index_reply_t_handler_json
964 (vl_api_get_node_index_reply_t * mp)
966 vat_main_t *vam = &vat_main;
967 vat_json_node_t node;
969 vat_json_init_object (&node);
970 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
971 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
973 vat_json_print (vam->ofp, &node);
974 vat_json_free (&node);
976 vam->retval = ntohl (mp->retval);
977 vam->result_ready = 1;
980 static void vl_api_get_next_index_reply_t_handler
981 (vl_api_get_next_index_reply_t * mp)
983 vat_main_t *vam = &vat_main;
984 i32 retval = ntohl (mp->retval);
987 vam->async_errors += (retval < 0);
991 vam->retval = retval;
993 errmsg ("next node index %d\n", ntohl (mp->next_index));
994 vam->result_ready = 1;
998 static void vl_api_get_next_index_reply_t_handler_json
999 (vl_api_get_next_index_reply_t * mp)
1001 vat_main_t *vam = &vat_main;
1002 vat_json_node_t node;
1004 vat_json_init_object (&node);
1005 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1006 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1008 vat_json_print (vam->ofp, &node);
1009 vat_json_free (&node);
1011 vam->retval = ntohl (mp->retval);
1012 vam->result_ready = 1;
1015 static void vl_api_add_node_next_reply_t_handler
1016 (vl_api_add_node_next_reply_t * mp)
1018 vat_main_t *vam = &vat_main;
1019 i32 retval = ntohl (mp->retval);
1020 if (vam->async_mode)
1022 vam->async_errors += (retval < 0);
1026 vam->retval = retval;
1028 errmsg ("next index %d\n", ntohl (mp->next_index));
1029 vam->result_ready = 1;
1033 static void vl_api_add_node_next_reply_t_handler_json
1034 (vl_api_add_node_next_reply_t * mp)
1036 vat_main_t *vam = &vat_main;
1037 vat_json_node_t node;
1039 vat_json_init_object (&node);
1040 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1041 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1043 vat_json_print (vam->ofp, &node);
1044 vat_json_free (&node);
1046 vam->retval = ntohl (mp->retval);
1047 vam->result_ready = 1;
1050 static void vl_api_mpls_gre_add_del_tunnel_reply_t_handler
1051 (vl_api_mpls_gre_add_del_tunnel_reply_t * mp)
1053 vat_main_t *vam = &vat_main;
1054 i32 retval = ntohl (mp->retval);
1055 u32 sw_if_index = ntohl (mp->tunnel_sw_if_index);
1057 if (retval >= 0 && sw_if_index != (u32) ~ 0)
1059 errmsg ("tunnel_sw_if_index %d\n", sw_if_index);
1061 vam->retval = retval;
1062 vam->result_ready = 1;
1065 static void vl_api_mpls_gre_add_del_tunnel_reply_t_handler_json
1066 (vl_api_mpls_gre_add_del_tunnel_reply_t * mp)
1068 vat_main_t *vam = &vat_main;
1069 vat_json_node_t node;
1071 vat_json_init_object (&node);
1072 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1073 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
1074 ntohl (mp->tunnel_sw_if_index));
1076 vat_json_print (vam->ofp, &node);
1077 vat_json_free (&node);
1079 vam->retval = ntohl (mp->retval);
1080 vam->result_ready = 1;
1084 static void vl_api_show_version_reply_t_handler
1085 (vl_api_show_version_reply_t * mp)
1087 vat_main_t *vam = &vat_main;
1088 i32 retval = ntohl (mp->retval);
1092 errmsg (" program: %s\n", mp->program);
1093 errmsg (" version: %s\n", mp->version);
1094 errmsg (" build date: %s\n", mp->build_date);
1095 errmsg ("build directory: %s\n", mp->build_directory);
1097 vam->retval = retval;
1098 vam->result_ready = 1;
1101 static void vl_api_show_version_reply_t_handler_json
1102 (vl_api_show_version_reply_t * mp)
1104 vat_main_t *vam = &vat_main;
1105 vat_json_node_t node;
1107 vat_json_init_object (&node);
1108 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1109 vat_json_object_add_string_copy (&node, "program", mp->program);
1110 vat_json_object_add_string_copy (&node, "version", mp->version);
1111 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1112 vat_json_object_add_string_copy (&node, "build_directory",
1113 mp->build_directory);
1115 vat_json_print (vam->ofp, &node);
1116 vat_json_free (&node);
1118 vam->retval = ntohl (mp->retval);
1119 vam->result_ready = 1;
1123 vl_api_ip4_arp_event_t_handler (vl_api_ip4_arp_event_t * mp)
1125 vat_main_t *vam = &vat_main;
1126 errmsg ("arp event: address %U new mac %U sw_if_index %d\n",
1127 format_ip4_address, &mp->address,
1128 format_ethernet_address, mp->new_mac, mp->sw_if_index);
1132 vl_api_ip4_arp_event_t_handler_json (vl_api_ip4_arp_event_t * mp)
1134 /* JSON output not supported */
1138 * Special-case: build the bridge domain table, maintain
1139 * the next bd id vbl.
1141 static void vl_api_bridge_domain_details_t_handler
1142 (vl_api_bridge_domain_details_t * mp)
1144 vat_main_t *vam = &vat_main;
1145 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1147 fformat (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-3s\n",
1148 " ID", "LRN", "FWD", "FLD", "BVI", "#IF");
1150 fformat (vam->ofp, "%3d %3d %3d %3d %3d %3d\n",
1151 ntohl (mp->bd_id), mp->learn, mp->forward,
1152 mp->flood, ntohl (mp->bvi_sw_if_index), n_sw_ifs);
1155 fformat (vam->ofp, "\n\n%s %s %s\n", "sw_if_index", "SHG",
1159 static void vl_api_bridge_domain_details_t_handler_json
1160 (vl_api_bridge_domain_details_t * mp)
1162 vat_main_t *vam = &vat_main;
1163 vat_json_node_t *node, *array = NULL;
1165 if (VAT_JSON_ARRAY != vam->json_tree.type)
1167 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1168 vat_json_init_array (&vam->json_tree);
1170 node = vat_json_array_add (&vam->json_tree);
1172 vat_json_init_object (node);
1173 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1174 vat_json_object_add_uint (node, "flood", mp->flood);
1175 vat_json_object_add_uint (node, "forward", mp->forward);
1176 vat_json_object_add_uint (node, "learn", mp->learn);
1177 vat_json_object_add_uint (node, "bvi_sw_if_index",
1178 ntohl (mp->bvi_sw_if_index));
1179 vat_json_object_add_uint (node, "n_sw_ifs", ntohl (mp->n_sw_ifs));
1180 array = vat_json_object_add (node, "sw_if");
1181 vat_json_init_array (array);
1185 * Special-case: build the bridge domain sw if table.
1187 static void vl_api_bridge_domain_sw_if_details_t_handler
1188 (vl_api_bridge_domain_sw_if_details_t * mp)
1190 vat_main_t *vam = &vat_main;
1195 sw_if_index = ntohl (mp->sw_if_index);
1197 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1199 if ((u32) p->value[0] == sw_if_index)
1201 sw_if_name = (u8 *)(p->key);
1207 fformat (vam->ofp, "%7d %3d %s", sw_if_index,
1208 mp->shg, sw_if_name ? (char *) sw_if_name :
1209 "sw_if_index not found!");
1212 static void vl_api_bridge_domain_sw_if_details_t_handler_json
1213 (vl_api_bridge_domain_sw_if_details_t * mp)
1215 vat_main_t *vam = &vat_main;
1216 vat_json_node_t *node = NULL;
1217 uword last_index = 0;
1219 ASSERT (VAT_JSON_ARRAY == vam->json_tree.type);
1220 ASSERT (vec_len (vam->json_tree.array) >= 1);
1221 last_index = vec_len (vam->json_tree.array) - 1;
1222 node = &vam->json_tree.array[last_index];
1223 node = vat_json_object_get_element (node, "sw_if");
1224 ASSERT (NULL != node);
1225 node = vat_json_array_add (node);
1227 vat_json_init_object (node);
1228 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1229 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
1230 vat_json_object_add_uint (node, "shg", mp->shg);
1233 static void vl_api_control_ping_reply_t_handler
1234 (vl_api_control_ping_reply_t * mp)
1236 vat_main_t *vam = &vat_main;
1237 i32 retval = ntohl (mp->retval);
1238 if (vam->async_mode)
1240 vam->async_errors += (retval < 0);
1244 vam->retval = retval;
1245 vam->result_ready = 1;
1249 static void vl_api_control_ping_reply_t_handler_json
1250 (vl_api_control_ping_reply_t * mp)
1252 vat_main_t *vam = &vat_main;
1253 i32 retval = ntohl (mp->retval);
1255 if (VAT_JSON_NONE != vam->json_tree.type)
1257 vat_json_print (vam->ofp, &vam->json_tree);
1258 vat_json_free (&vam->json_tree);
1259 vam->json_tree.type = VAT_JSON_NONE;
1264 vat_json_init_array (&vam->json_tree);
1265 vat_json_print (vam->ofp, &vam->json_tree);
1266 vam->json_tree.type = VAT_JSON_NONE;
1269 vam->retval = retval;
1270 vam->result_ready = 1;
1273 static void vl_api_noprint_control_ping_reply_t_handler
1274 (vl_api_noprint_control_ping_reply_t * mp)
1276 vat_main_t *vam = &vat_main;
1277 i32 retval = ntohl (mp->retval);
1278 if (vam->async_mode)
1280 vam->async_errors += (retval < 0);
1284 vam->retval = retval;
1285 vam->result_ready = 1;
1289 static void vl_api_noprint_control_ping_reply_t_handler_json
1290 (vl_api_noprint_control_ping_reply_t * mp)
1292 vat_main_t *vam = &vat_main;
1293 i32 retval = ntohl (mp->retval);
1295 if (vam->noprint_msg)
1297 vam->retval = retval;
1298 vam->result_ready = 1;
1302 if (VAT_JSON_NONE != vam->json_tree.type)
1304 vat_json_print (vam->ofp, &vam->json_tree);
1305 vat_json_free (&vam->json_tree);
1306 vam->json_tree.type = VAT_JSON_NONE;
1311 vat_json_init_array (&vam->json_tree);
1312 vat_json_print (vam->ofp, &vam->json_tree);
1313 vam->json_tree.type = VAT_JSON_NONE;
1316 vam->retval = retval;
1317 vam->result_ready = 1;
1321 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1323 vat_main_t *vam = &vat_main;
1324 i32 retval = ntohl (mp->retval);
1325 if (vam->async_mode)
1327 vam->async_errors += (retval < 0);
1331 vam->retval = retval;
1332 vam->result_ready = 1;
1336 static void vl_api_l2_flags_reply_t_handler_json
1337 (vl_api_l2_flags_reply_t * mp)
1339 vat_main_t *vam = &vat_main;
1340 vat_json_node_t node;
1342 vat_json_init_object (&node);
1343 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1344 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1345 ntohl (mp->resulting_feature_bitmap));
1347 vat_json_print (vam->ofp, &node);
1348 vat_json_free (&node);
1350 vam->retval = ntohl (mp->retval);
1351 vam->result_ready = 1;
1354 static void vl_api_bridge_flags_reply_t_handler
1355 (vl_api_bridge_flags_reply_t * mp)
1357 vat_main_t *vam = &vat_main;
1358 i32 retval = ntohl (mp->retval);
1359 if (vam->async_mode)
1361 vam->async_errors += (retval < 0);
1365 vam->retval = retval;
1366 vam->result_ready = 1;
1370 static void vl_api_bridge_flags_reply_t_handler_json
1371 (vl_api_bridge_flags_reply_t * mp)
1373 vat_main_t *vam = &vat_main;
1374 vat_json_node_t node;
1376 vat_json_init_object (&node);
1377 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1378 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1379 ntohl (mp->resulting_feature_bitmap));
1381 vat_json_print (vam->ofp, &node);
1382 vat_json_free (&node);
1384 vam->retval = ntohl (mp->retval);
1385 vam->result_ready = 1;
1388 static void vl_api_tap_connect_reply_t_handler
1389 (vl_api_tap_connect_reply_t * mp)
1391 vat_main_t *vam = &vat_main;
1392 i32 retval = ntohl (mp->retval);
1393 if (vam->async_mode)
1395 vam->async_errors += (retval < 0);
1399 vam->retval = retval;
1400 vam->sw_if_index = ntohl (mp->sw_if_index);
1401 vam->result_ready = 1;
1406 static void vl_api_tap_connect_reply_t_handler_json
1407 (vl_api_tap_connect_reply_t * mp)
1409 vat_main_t *vam = &vat_main;
1410 vat_json_node_t node;
1412 vat_json_init_object (&node);
1413 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1414 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1416 vat_json_print (vam->ofp, &node);
1417 vat_json_free (&node);
1419 vam->retval = ntohl (mp->retval);
1420 vam->result_ready = 1;
1425 vl_api_tap_modify_reply_t_handler (vl_api_tap_modify_reply_t * mp)
1427 vat_main_t *vam = &vat_main;
1428 i32 retval = ntohl (mp->retval);
1429 if (vam->async_mode)
1431 vam->async_errors += (retval < 0);
1435 vam->retval = retval;
1436 vam->sw_if_index = ntohl (mp->sw_if_index);
1437 vam->result_ready = 1;
1441 static void vl_api_tap_modify_reply_t_handler_json
1442 (vl_api_tap_modify_reply_t * mp)
1444 vat_main_t *vam = &vat_main;
1445 vat_json_node_t node;
1447 vat_json_init_object (&node);
1448 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1449 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1451 vat_json_print (vam->ofp, &node);
1452 vat_json_free (&node);
1454 vam->retval = ntohl (mp->retval);
1455 vam->result_ready = 1;
1459 vl_api_tap_delete_reply_t_handler (vl_api_tap_delete_reply_t * mp)
1461 vat_main_t *vam = &vat_main;
1462 i32 retval = ntohl (mp->retval);
1463 if (vam->async_mode)
1465 vam->async_errors += (retval < 0);
1469 vam->retval = retval;
1470 vam->result_ready = 1;
1474 static void vl_api_tap_delete_reply_t_handler_json
1475 (vl_api_tap_delete_reply_t * mp)
1477 vat_main_t *vam = &vat_main;
1478 vat_json_node_t node;
1480 vat_json_init_object (&node);
1481 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1483 vat_json_print (vam->ofp, &node);
1484 vat_json_free (&node);
1486 vam->retval = ntohl (mp->retval);
1487 vam->result_ready = 1;
1490 static void vl_api_mpls_ethernet_add_del_tunnel_reply_t_handler
1491 (vl_api_mpls_ethernet_add_del_tunnel_reply_t * mp)
1493 vat_main_t *vam = &vat_main;
1494 i32 retval = ntohl (mp->retval);
1495 if (vam->async_mode)
1497 vam->async_errors += (retval < 0);
1501 vam->retval = retval;
1502 vam->result_ready = 1;
1506 static void vl_api_mpls_ethernet_add_del_tunnel_reply_t_handler_json
1507 (vl_api_mpls_ethernet_add_del_tunnel_reply_t * mp)
1509 vat_main_t *vam = &vat_main;
1510 vat_json_node_t node;
1512 vat_json_init_object (&node);
1513 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1514 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
1515 ntohl (mp->tunnel_sw_if_index));
1517 vat_json_print (vam->ofp, &node);
1518 vat_json_free (&node);
1520 vam->retval = ntohl (mp->retval);
1521 vam->result_ready = 1;
1524 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
1525 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1527 vat_main_t *vam = &vat_main;
1528 i32 retval = ntohl (mp->retval);
1529 if (vam->async_mode)
1531 vam->async_errors += (retval < 0);
1535 vam->retval = retval;
1536 vam->sw_if_index = ntohl (mp->sw_if_index);
1537 vam->result_ready = 1;
1541 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
1542 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1544 vat_main_t *vam = &vat_main;
1545 vat_json_node_t node;
1547 vat_json_init_object (&node);
1548 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1549 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1551 vat_json_print (vam->ofp, &node);
1552 vat_json_free (&node);
1554 vam->retval = ntohl (mp->retval);
1555 vam->result_ready = 1;
1559 static void vl_api_lisp_add_del_locator_set_reply_t_handler
1560 (vl_api_lisp_add_del_locator_set_reply_t * mp)
1562 vat_main_t *vam = &vat_main;
1563 i32 retval = ntohl (mp->retval);
1564 if (vam->async_mode)
1566 vam->async_errors += (retval < 0);
1570 vam->retval = retval;
1571 vam->result_ready = 1;
1575 static void vl_api_lisp_add_del_locator_set_reply_t_handler_json
1576 (vl_api_lisp_add_del_locator_set_reply_t * mp)
1578 vat_main_t *vam = &vat_main;
1579 vat_json_node_t node;
1581 vat_json_init_object (&node);
1582 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1583 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
1585 vat_json_print (vam->ofp, &node);
1586 vat_json_free (&node);
1588 vam->retval = ntohl (mp->retval);
1589 vam->result_ready = 1;
1592 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
1593 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1595 vat_main_t *vam = &vat_main;
1596 i32 retval = ntohl (mp->retval);
1597 if (vam->async_mode)
1599 vam->async_errors += (retval < 0);
1603 vam->retval = retval;
1604 vam->sw_if_index = ntohl (mp->sw_if_index);
1605 vam->result_ready = 1;
1609 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
1610 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1612 vat_main_t *vam = &vat_main;
1613 vat_json_node_t node;
1615 vat_json_init_object (&node);
1616 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1617 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1619 vat_json_print (vam->ofp, &node);
1620 vat_json_free (&node);
1622 vam->retval = ntohl (mp->retval);
1623 vam->result_ready = 1;
1626 static void vl_api_gre_add_del_tunnel_reply_t_handler
1627 (vl_api_gre_add_del_tunnel_reply_t * mp)
1629 vat_main_t *vam = &vat_main;
1630 i32 retval = ntohl (mp->retval);
1631 if (vam->async_mode)
1633 vam->async_errors += (retval < 0);
1637 vam->retval = retval;
1638 vam->sw_if_index = ntohl (mp->sw_if_index);
1639 vam->result_ready = 1;
1643 static void vl_api_gre_add_del_tunnel_reply_t_handler_json
1644 (vl_api_gre_add_del_tunnel_reply_t * mp)
1646 vat_main_t *vam = &vat_main;
1647 vat_json_node_t node;
1649 vat_json_init_object (&node);
1650 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1651 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1653 vat_json_print (vam->ofp, &node);
1654 vat_json_free (&node);
1656 vam->retval = ntohl (mp->retval);
1657 vam->result_ready = 1;
1660 static void vl_api_create_vhost_user_if_reply_t_handler
1661 (vl_api_create_vhost_user_if_reply_t * mp)
1663 vat_main_t *vam = &vat_main;
1664 i32 retval = ntohl (mp->retval);
1665 if (vam->async_mode)
1667 vam->async_errors += (retval < 0);
1671 vam->retval = retval;
1672 vam->sw_if_index = ntohl (mp->sw_if_index);
1673 vam->result_ready = 1;
1677 static void vl_api_create_vhost_user_if_reply_t_handler_json
1678 (vl_api_create_vhost_user_if_reply_t * mp)
1680 vat_main_t *vam = &vat_main;
1681 vat_json_node_t node;
1683 vat_json_init_object (&node);
1684 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1685 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1687 vat_json_print (vam->ofp, &node);
1688 vat_json_free (&node);
1690 vam->retval = ntohl (mp->retval);
1691 vam->result_ready = 1;
1694 static void vl_api_ip_address_details_t_handler
1695 (vl_api_ip_address_details_t * mp)
1697 vat_main_t *vam = &vat_main;
1698 static ip_address_details_t empty_ip_address_details = { {0} };
1699 ip_address_details_t *address = NULL;
1700 ip_details_t *current_ip_details = NULL;
1701 ip_details_t *details = NULL;
1703 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
1705 if (!details || vam->current_sw_if_index >= vec_len (details)
1706 || !details[vam->current_sw_if_index].present)
1708 errmsg ("ip address details arrived but not stored\n");
1709 errmsg ("ip_dump should be called first\n");
1713 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
1715 #define addresses (current_ip_details->addr)
1717 vec_validate_init_empty (addresses, vec_len (addresses),
1718 empty_ip_address_details);
1720 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
1722 clib_memcpy (&address->ip, &mp->ip, sizeof (address->ip));
1723 address->prefix_length = mp->prefix_length;
1727 static void vl_api_ip_address_details_t_handler_json
1728 (vl_api_ip_address_details_t * mp)
1730 vat_main_t *vam = &vat_main;
1731 vat_json_node_t *node = NULL;
1732 struct in6_addr ip6;
1735 if (VAT_JSON_ARRAY != vam->json_tree.type)
1737 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1738 vat_json_init_array (&vam->json_tree);
1740 node = vat_json_array_add (&vam->json_tree);
1742 vat_json_init_object (node);
1745 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
1746 vat_json_object_add_ip6 (node, "ip", ip6);
1750 clib_memcpy (&ip4, mp->ip, sizeof (ip4));
1751 vat_json_object_add_ip4 (node, "ip", ip4);
1753 vat_json_object_add_uint (node, "prefix_length", mp->prefix_length);
1757 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
1759 vat_main_t *vam = &vat_main;
1760 static ip_details_t empty_ip_details = { 0 };
1761 ip_details_t *ip = NULL;
1762 u32 sw_if_index = ~0;
1764 sw_if_index = ntohl (mp->sw_if_index);
1766 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1767 sw_if_index, empty_ip_details);
1769 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1776 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
1778 vat_main_t *vam = &vat_main;
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 vat_json_array_add_uint (&vam->json_tree,
1786 clib_net_to_host_u32 (mp->sw_if_index));
1789 static void vl_api_map_domain_details_t_handler_json
1790 (vl_api_map_domain_details_t * mp)
1792 vat_json_node_t *node = NULL;
1793 vat_main_t *vam = &vat_main;
1794 struct in6_addr ip6;
1797 if (VAT_JSON_ARRAY != vam->json_tree.type)
1799 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1800 vat_json_init_array (&vam->json_tree);
1803 node = vat_json_array_add (&vam->json_tree);
1804 vat_json_init_object (node);
1806 vat_json_object_add_uint (node, "domain_index",
1807 clib_net_to_host_u32 (mp->domain_index));
1808 clib_memcpy (&ip6, mp->ip6_prefix, sizeof (ip6));
1809 vat_json_object_add_ip6 (node, "ip6_prefix", ip6);
1810 clib_memcpy (&ip4, mp->ip4_prefix, sizeof (ip4));
1811 vat_json_object_add_ip4 (node, "ip4_prefix", ip4);
1812 clib_memcpy (&ip6, mp->ip6_src, sizeof (ip6));
1813 vat_json_object_add_ip6 (node, "ip6_src", ip6);
1814 vat_json_object_add_int (node, "ip6_prefix_len", mp->ip6_prefix_len);
1815 vat_json_object_add_int (node, "ip4_prefix_len", mp->ip4_prefix_len);
1816 vat_json_object_add_int (node, "ip6_src_len", mp->ip6_src_len);
1817 vat_json_object_add_int (node, "ea_bits_len", mp->ea_bits_len);
1818 vat_json_object_add_int (node, "psid_offset", mp->psid_offset);
1819 vat_json_object_add_int (node, "psid_length", mp->psid_length);
1820 vat_json_object_add_uint (node, "flags", mp->flags);
1821 vat_json_object_add_uint (node, "mtu", clib_net_to_host_u16 (mp->mtu));
1822 vat_json_object_add_int (node, "is_translation", mp->is_translation);
1825 static void vl_api_map_domain_details_t_handler
1826 (vl_api_map_domain_details_t * mp)
1828 vat_main_t *vam = &vat_main;
1830 if (mp->is_translation)
1833 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U/%d (ip6-src) index: %u\n",
1834 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1835 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1836 format_ip6_address, mp->ip6_src, mp->ip6_src_len,
1837 clib_net_to_host_u32 (mp->domain_index));
1842 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U (ip6-src) index: %u\n",
1843 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1844 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1845 format_ip6_address, mp->ip6_src,
1846 clib_net_to_host_u32 (mp->domain_index));
1848 fformat (vam->ofp, " ea-len %d psid-offset %d psid-len %d mtu %d %s\n",
1849 mp->ea_bits_len, mp->psid_offset, mp->psid_length, mp->mtu,
1850 mp->is_translation ? "map-t" : "");
1853 static void vl_api_map_rule_details_t_handler_json
1854 (vl_api_map_rule_details_t * mp)
1856 struct in6_addr ip6;
1857 vat_json_node_t *node = NULL;
1858 vat_main_t *vam = &vat_main;
1860 if (VAT_JSON_ARRAY != vam->json_tree.type)
1862 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1863 vat_json_init_array (&vam->json_tree);
1866 node = vat_json_array_add (&vam->json_tree);
1867 vat_json_init_object (node);
1869 vat_json_object_add_uint (node, "psid", clib_net_to_host_u16 (mp->psid));
1870 clib_memcpy (&ip6, mp->ip6_dst, sizeof (ip6));
1871 vat_json_object_add_ip6 (node, "ip6_dst", ip6);
1875 vl_api_map_rule_details_t_handler (vl_api_map_rule_details_t * mp)
1877 vat_main_t *vam = &vat_main;
1878 fformat (vam->ofp, " %d (psid) %U (ip6-dst)\n",
1879 clib_net_to_host_u16 (mp->psid), format_ip6_address, mp->ip6_dst);
1883 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
1885 vat_main_t *vam = &vat_main;
1886 errmsg ("DHCP compl event: pid %d %s hostname %s host_addr %U "
1887 "router_addr %U host_mac %U\n",
1888 mp->pid, mp->is_ipv6 ? "ipv6" : "ipv4", mp->hostname,
1889 format_ip4_address, &mp->host_address,
1890 format_ip4_address, &mp->router_address,
1891 format_ethernet_address, mp->host_mac);
1894 static void vl_api_dhcp_compl_event_t_handler_json
1895 (vl_api_dhcp_compl_event_t * mp)
1897 /* JSON output not supported */
1901 set_simple_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1904 vat_main_t *vam = &vat_main;
1905 static u64 default_counter = 0;
1907 vec_validate_init_empty (vam->simple_interface_counters, vnet_counter_type,
1909 vec_validate_init_empty (vam->simple_interface_counters[vnet_counter_type],
1910 sw_if_index, default_counter);
1911 vam->simple_interface_counters[vnet_counter_type][sw_if_index] = counter;
1915 set_combined_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1916 interface_counter_t counter)
1918 vat_main_t *vam = &vat_main;
1919 static interface_counter_t default_counter = { 0, };
1921 vec_validate_init_empty (vam->combined_interface_counters,
1922 vnet_counter_type, NULL);
1923 vec_validate_init_empty (vam->combined_interface_counters
1924 [vnet_counter_type], sw_if_index, default_counter);
1925 vam->combined_interface_counters[vnet_counter_type][sw_if_index] = counter;
1928 static void vl_api_vnet_interface_counters_t_handler
1929 (vl_api_vnet_interface_counters_t * mp)
1934 static void vl_api_vnet_interface_counters_t_handler_json
1935 (vl_api_vnet_interface_counters_t * mp)
1937 interface_counter_t counter;
1942 u32 first_sw_if_index;
1945 count = ntohl (mp->count);
1946 first_sw_if_index = ntohl (mp->first_sw_if_index);
1948 if (!mp->is_combined)
1950 v_packets = (u64 *) & mp->data;
1951 for (i = 0; i < count; i++)
1954 clib_net_to_host_u64 (clib_mem_unaligned (v_packets, u64));
1955 set_simple_interface_counter (mp->vnet_counter_type,
1956 first_sw_if_index + i, packets);
1962 v = (vlib_counter_t *) & mp->data;
1963 for (i = 0; i < count; i++)
1966 clib_net_to_host_u64 (clib_mem_unaligned (&v->packets, u64));
1968 clib_net_to_host_u64 (clib_mem_unaligned (&v->bytes, u64));
1969 set_combined_interface_counter (mp->vnet_counter_type,
1970 first_sw_if_index + i, counter);
1977 ip4_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
1979 vat_main_t *vam = &vat_main;
1982 for (i = 0; i < vec_len (vam->ip4_fib_counters_vrf_id_by_index); i++)
1984 if (vam->ip4_fib_counters_vrf_id_by_index[i] == vrf_id)
1993 ip6_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
1995 vat_main_t *vam = &vat_main;
1998 for (i = 0; i < vec_len (vam->ip6_fib_counters_vrf_id_by_index); i++)
2000 if (vam->ip6_fib_counters_vrf_id_by_index[i] == vrf_id)
2008 static void vl_api_vnet_ip4_fib_counters_t_handler
2009 (vl_api_vnet_ip4_fib_counters_t * mp)
2014 static void vl_api_vnet_ip4_fib_counters_t_handler_json
2015 (vl_api_vnet_ip4_fib_counters_t * mp)
2017 vat_main_t *vam = &vat_main;
2018 vl_api_ip4_fib_counter_t *v;
2019 ip4_fib_counter_t *counter;
2026 vrf_id = ntohl (mp->vrf_id);
2027 vrf_index = ip4_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2028 if (~0 == vrf_index)
2030 vrf_index = vec_len (vam->ip4_fib_counters_vrf_id_by_index);
2031 vec_validate (vam->ip4_fib_counters_vrf_id_by_index, vrf_index);
2032 vam->ip4_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2033 vec_validate (vam->ip4_fib_counters, vrf_index);
2034 vam->ip4_fib_counters[vrf_index] = NULL;
2037 vec_free (vam->ip4_fib_counters[vrf_index]);
2038 v = (vl_api_ip4_fib_counter_t *) & mp->c;
2039 count = ntohl (mp->count);
2040 for (i = 0; i < count; i++)
2042 vec_validate (vam->ip4_fib_counters[vrf_index], i);
2043 counter = &vam->ip4_fib_counters[vrf_index][i];
2044 clib_memcpy (&ip4, &v->address, sizeof (ip4));
2045 counter->address = ip4;
2046 counter->address_length = v->address_length;
2047 counter->packets = clib_net_to_host_u64 (v->packets);
2048 counter->bytes = clib_net_to_host_u64 (v->bytes);
2053 static void vl_api_vnet_ip6_fib_counters_t_handler
2054 (vl_api_vnet_ip6_fib_counters_t * mp)
2059 static void vl_api_vnet_ip6_fib_counters_t_handler_json
2060 (vl_api_vnet_ip6_fib_counters_t * mp)
2062 vat_main_t *vam = &vat_main;
2063 vl_api_ip6_fib_counter_t *v;
2064 ip6_fib_counter_t *counter;
2065 struct in6_addr ip6;
2071 vrf_id = ntohl (mp->vrf_id);
2072 vrf_index = ip6_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2073 if (~0 == vrf_index)
2075 vrf_index = vec_len (vam->ip6_fib_counters_vrf_id_by_index);
2076 vec_validate (vam->ip6_fib_counters_vrf_id_by_index, vrf_index);
2077 vam->ip6_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2078 vec_validate (vam->ip6_fib_counters, vrf_index);
2079 vam->ip6_fib_counters[vrf_index] = NULL;
2082 vec_free (vam->ip6_fib_counters[vrf_index]);
2083 v = (vl_api_ip6_fib_counter_t *) & mp->c;
2084 count = ntohl (mp->count);
2085 for (i = 0; i < count; i++)
2087 vec_validate (vam->ip6_fib_counters[vrf_index], i);
2088 counter = &vam->ip6_fib_counters[vrf_index][i];
2089 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2090 counter->address = ip6;
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_get_first_msg_id_reply_t_handler
2099 (vl_api_get_first_msg_id_reply_t * mp)
2101 vat_main_t *vam = &vat_main;
2102 i32 retval = ntohl (mp->retval);
2104 if (vam->async_mode)
2106 vam->async_errors += (retval < 0);
2110 vam->retval = retval;
2111 vam->result_ready = 1;
2115 errmsg ("first message id %d\n", ntohs (mp->first_msg_id));
2119 static void vl_api_get_first_msg_id_reply_t_handler_json
2120 (vl_api_get_first_msg_id_reply_t * mp)
2122 vat_main_t *vam = &vat_main;
2123 vat_json_node_t node;
2125 vat_json_init_object (&node);
2126 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2127 vat_json_object_add_uint (&node, "first_msg_id",
2128 (uint) ntohs (mp->first_msg_id));
2130 vat_json_print (vam->ofp, &node);
2131 vat_json_free (&node);
2133 vam->retval = ntohl (mp->retval);
2134 vam->result_ready = 1;
2137 static void vl_api_get_node_graph_reply_t_handler
2138 (vl_api_get_node_graph_reply_t * mp)
2140 vat_main_t *vam = &vat_main;
2141 api_main_t *am = &api_main;
2142 i32 retval = ntohl (mp->retval);
2143 u8 *pvt_copy, *reply;
2148 if (vam->async_mode)
2150 vam->async_errors += (retval < 0);
2154 vam->retval = retval;
2155 vam->result_ready = 1;
2158 /* "Should never happen..." */
2162 reply = (u8 *) (mp->reply_in_shmem);
2163 pvt_copy = vec_dup (reply);
2165 /* Toss the shared-memory original... */
2166 pthread_mutex_lock (&am->vlib_rp->mutex);
2167 oldheap = svm_push_data_heap (am->vlib_rp);
2171 svm_pop_heap (oldheap);
2172 pthread_mutex_unlock (&am->vlib_rp->mutex);
2174 if (vam->graph_nodes)
2176 hash_free (vam->graph_node_index_by_name);
2178 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2180 node = vam->graph_nodes[i];
2181 vec_free (node->name);
2182 vec_free (node->next_nodes);
2185 vec_free (vam->graph_nodes);
2188 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2189 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2190 vec_free (pvt_copy);
2192 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2194 node = vam->graph_nodes[i];
2195 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2199 static void vl_api_get_node_graph_reply_t_handler_json
2200 (vl_api_get_node_graph_reply_t * mp)
2202 vat_main_t *vam = &vat_main;
2203 api_main_t *am = &api_main;
2205 vat_json_node_t node;
2208 /* $$$$ make this real? */
2209 vat_json_init_object (&node);
2210 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2211 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2213 reply = (u8 *) (mp->reply_in_shmem);
2215 /* Toss the shared-memory original... */
2216 pthread_mutex_lock (&am->vlib_rp->mutex);
2217 oldheap = svm_push_data_heap (am->vlib_rp);
2221 svm_pop_heap (oldheap);
2222 pthread_mutex_unlock (&am->vlib_rp->mutex);
2224 vat_json_print (vam->ofp, &node);
2225 vat_json_free (&node);
2227 vam->retval = ntohl (mp->retval);
2228 vam->result_ready = 1;
2232 vl_api_lisp_locator_details_t_handler (vl_api_lisp_locator_details_t * mp)
2234 vat_main_t *vam = &vat_main;
2238 memset (&loc, 0, sizeof (loc));
2239 if (vam->noprint_msg)
2241 loc.local = mp->local;
2242 loc.priority = mp->priority;
2243 loc.weight = mp->weight;
2246 loc.sw_if_index = ntohl (mp->sw_if_index);
2250 loc.is_ipv6 = mp->is_ipv6;
2251 clib_memcpy (loc.ip_address, mp->ip_address,
2252 sizeof (loc.ip_address));
2254 vec_add1 (vam->locator_msg, loc);
2260 tmp_str = format (tmp_str, "%=16d%=16d%=16d\n",
2261 ntohl (mp->sw_if_index),
2262 mp->priority, mp->weight);
2266 tmp_str = format (tmp_str, "%=16U%=16d%=16d\n",
2267 mp->is_ipv6 ? format_ip6_address :
2269 mp->ip_address, mp->priority, mp->weight);
2272 fformat (vam->ofp, "%s", tmp_str);
2279 vl_api_lisp_locator_details_t_handler_json (vl_api_lisp_locator_details_t *
2282 vat_main_t *vam = &vat_main;
2283 vat_json_node_t *node = NULL;
2285 struct in6_addr ip6;
2288 memset (&loc, 0, sizeof (loc));
2289 if (vam->noprint_msg)
2291 loc.local = mp->local;
2292 loc.priority = mp->priority;
2293 loc.weight = mp->weight;
2296 loc.sw_if_index = ntohl (mp->sw_if_index);
2300 loc.is_ipv6 = mp->is_ipv6;
2301 clib_memcpy (loc.ip_address, mp->ip_address,
2302 sizeof (loc.ip_address));
2304 vec_add1 (vam->locator_msg, loc);
2308 if (VAT_JSON_ARRAY != vam->json_tree.type)
2310 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2311 vat_json_init_array (&vam->json_tree);
2313 node = vat_json_array_add (&vam->json_tree);
2315 vat_json_init_object (node);
2319 vat_json_object_add_uint (node, "locator_index",
2320 ntohl (mp->sw_if_index));
2326 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2327 vat_json_object_add_ip6 (node, "locator", ip6);
2331 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2332 vat_json_object_add_ip4 (node, "locator", ip4);
2335 vat_json_object_add_uint (node, "priority", mp->priority);
2336 vat_json_object_add_uint (node, "weight", mp->weight);
2340 vl_api_lisp_locator_set_details_t_handler (vl_api_lisp_locator_set_details_t *
2343 vat_main_t *vam = &vat_main;
2344 locator_set_msg_t ls;
2346 ls.locator_set_index = ntohl (mp->locator_set_index);
2347 ls.locator_set_name = format (0, "%s", mp->locator_set_name);
2348 vec_add1 (vam->locator_set_msg, ls);
2352 vl_api_lisp_locator_set_details_t_handler_json
2353 (vl_api_lisp_locator_set_details_t * mp)
2355 vat_main_t *vam = &vat_main;
2356 locator_set_msg_t ls;
2358 ls.locator_set_index = ntohl (mp->locator_set_index);
2359 ls.locator_set_name = format (0, "%s", mp->locator_set_name);
2360 vec_add1 (vam->locator_set_msg, ls);
2364 vl_api_lisp_eid_table_details_t_handler (vl_api_lisp_eid_table_details_t * mp)
2366 vat_main_t *vam = &vat_main;
2367 eid_table_t eid_table;
2369 memset (&eid_table, 0, sizeof (eid_table));
2370 eid_table.is_local = mp->is_local;
2371 eid_table.locator_set_index = mp->locator_set_index;
2372 eid_table.eid_type = mp->eid_type;
2373 eid_table.vni = mp->vni;
2374 eid_table.eid_prefix_len = mp->eid_prefix_len;
2375 eid_table.ttl = mp->ttl;
2376 eid_table.authoritative = mp->authoritative;
2377 clib_memcpy (eid_table.eid, mp->eid, sizeof (eid_table.eid));
2378 vec_add1 (vam->eid_tables, eid_table);
2382 vl_api_lisp_eid_table_details_t_handler_json (vl_api_lisp_eid_table_details_t
2385 vat_main_t *vam = &vat_main;
2386 eid_table_t eid_table;
2388 memset (&eid_table, 0, sizeof (eid_table));
2389 eid_table.is_local = mp->is_local;
2390 eid_table.locator_set_index = mp->locator_set_index;
2391 eid_table.eid_type = mp->eid_type;
2392 eid_table.vni = mp->vni;
2393 eid_table.eid_prefix_len = mp->eid_prefix_len;
2394 eid_table.ttl = mp->ttl;
2395 eid_table.authoritative = mp->authoritative;
2396 clib_memcpy (eid_table.eid, mp->eid, sizeof (eid_table.eid));
2397 vec_add1 (vam->eid_tables, eid_table);
2401 vl_api_lisp_eid_table_map_details_t_handler
2402 (vl_api_lisp_eid_table_map_details_t * mp)
2404 vat_main_t *vam = &vat_main;
2406 u8 *line = format (0, "%=10d%=10d",
2407 clib_net_to_host_u32 (mp->vni),
2408 clib_net_to_host_u32 (mp->vrf));
2409 fformat (vam->ofp, "%v\n", line);
2414 vl_api_lisp_eid_table_map_details_t_handler_json
2415 (vl_api_lisp_eid_table_map_details_t * mp)
2417 vat_main_t *vam = &vat_main;
2418 vat_json_node_t *node = NULL;
2420 if (VAT_JSON_ARRAY != vam->json_tree.type)
2422 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2423 vat_json_init_array (&vam->json_tree);
2425 node = vat_json_array_add (&vam->json_tree);
2426 vat_json_init_object (node);
2427 vat_json_object_add_uint (node, "vrf", clib_net_to_host_u32 (mp->vrf));
2428 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2432 vl_api_lisp_eid_table_vni_details_t_handler
2433 (vl_api_lisp_eid_table_vni_details_t * mp)
2435 vat_main_t *vam = &vat_main;
2437 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
2438 fformat (vam->ofp, "%v\n", line);
2443 vl_api_lisp_eid_table_vni_details_t_handler_json
2444 (vl_api_lisp_eid_table_vni_details_t * mp)
2446 vat_main_t *vam = &vat_main;
2447 vat_json_node_t *node = NULL;
2449 if (VAT_JSON_ARRAY != vam->json_tree.type)
2451 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2452 vat_json_init_array (&vam->json_tree);
2454 node = vat_json_array_add (&vam->json_tree);
2455 vat_json_init_object (node);
2456 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2460 format_decap_next (u8 * s, va_list * args)
2462 u32 next_index = va_arg (*args, u32);
2466 case LISP_GPE_INPUT_NEXT_DROP:
2467 return format (s, "drop");
2468 case LISP_GPE_INPUT_NEXT_IP4_INPUT:
2469 return format (s, "ip4");
2470 case LISP_GPE_INPUT_NEXT_IP6_INPUT:
2471 return format (s, "ip6");
2473 return format (s, "unknown %d", next_index);
2479 vl_api_lisp_gpe_tunnel_details_t_handler (vl_api_lisp_gpe_tunnel_details_t *
2482 vat_main_t *vam = &vat_main;
2484 u8 *flag_str = NULL;
2486 iid_str = format (0, "%d (0x%x)", ntohl (mp->iid), ntohl (mp->iid));
2488 #define _(n,v) if (mp->flags & v) flag_str = format (flag_str, "%s-bit ", #n);
2489 foreach_lisp_gpe_flag_bit;
2492 fformat (vam->ofp, "%=20d%=30U%=16U%=16d%=16d%=16U"
2493 "%=16d%=16d%=16sd=16d%=16s%=16s\n",
2495 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2497 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2499 ntohl (mp->encap_fib_id),
2500 ntohl (mp->decap_fib_id),
2501 format_decap_next, ntohl (mp->dcap_next),
2503 flag_str, mp->next_protocol, mp->ver_res, mp->res, iid_str);
2509 vl_api_lisp_gpe_tunnel_details_t_handler_json
2510 (vl_api_lisp_gpe_tunnel_details_t * mp)
2512 vat_main_t *vam = &vat_main;
2513 vat_json_node_t *node = NULL;
2514 struct in6_addr ip6;
2518 next_decap_str = format (0, "%U", format_decap_next, htonl (mp->dcap_next));
2520 if (VAT_JSON_ARRAY != vam->json_tree.type)
2522 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2523 vat_json_init_array (&vam->json_tree);
2525 node = vat_json_array_add (&vam->json_tree);
2527 vat_json_init_object (node);
2528 vat_json_object_add_uint (node, "tunel", mp->tunnels);
2531 clib_memcpy (&ip6, mp->source_ip, sizeof (ip6));
2532 vat_json_object_add_ip6 (node, "source address", ip6);
2533 clib_memcpy (&ip6, mp->destination_ip, sizeof (ip6));
2534 vat_json_object_add_ip6 (node, "destination address", ip6);
2538 clib_memcpy (&ip4, mp->source_ip, sizeof (ip4));
2539 vat_json_object_add_ip4 (node, "source address", ip4);
2540 clib_memcpy (&ip4, mp->destination_ip, sizeof (ip4));
2541 vat_json_object_add_ip4 (node, "destination address", ip4);
2543 vat_json_object_add_uint (node, "fib encap", ntohl (mp->encap_fib_id));
2544 vat_json_object_add_uint (node, "fib decap", ntohl (mp->decap_fib_id));
2545 vat_json_object_add_string_copy (node, "decap next", next_decap_str);
2546 vat_json_object_add_uint (node, "lisp version", mp->ver_res >> 6);
2547 vat_json_object_add_uint (node, "flags", mp->flags);
2548 vat_json_object_add_uint (node, "next protocol", mp->next_protocol);
2549 vat_json_object_add_uint (node, "ver_res", mp->ver_res);
2550 vat_json_object_add_uint (node, "res", mp->res);
2551 vat_json_object_add_uint (node, "iid", ntohl (mp->iid));
2553 vec_free (next_decap_str);
2557 vl_api_lisp_map_resolver_details_t_handler (vl_api_lisp_map_resolver_details_t
2560 vat_main_t *vam = &vat_main;
2562 fformat (vam->ofp, "%=20U\n",
2563 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2568 vl_api_lisp_map_resolver_details_t_handler_json
2569 (vl_api_lisp_map_resolver_details_t * mp)
2571 vat_main_t *vam = &vat_main;
2572 vat_json_node_t *node = NULL;
2573 struct in6_addr ip6;
2576 if (VAT_JSON_ARRAY != vam->json_tree.type)
2578 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2579 vat_json_init_array (&vam->json_tree);
2581 node = vat_json_array_add (&vam->json_tree);
2583 vat_json_init_object (node);
2586 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2587 vat_json_object_add_ip6 (node, "map resolver", ip6);
2591 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2592 vat_json_object_add_ip4 (node, "map resolver", ip4);
2597 vl_api_show_lisp_status_reply_t_handler
2598 (vl_api_show_lisp_status_reply_t * mp)
2600 vat_main_t *vam = &vat_main;
2601 i32 retval = ntohl (mp->retval);
2605 fformat (vam->ofp, "feature: %s\ngpe: %s\n",
2606 mp->feature_status ? "enabled" : "disabled",
2607 mp->gpe_status ? "enabled" : "disabled");
2610 vam->retval = retval;
2611 vam->result_ready = 1;
2615 vl_api_show_lisp_status_reply_t_handler_json
2616 (vl_api_show_lisp_status_reply_t * mp)
2618 vat_main_t *vam = &vat_main;
2619 vat_json_node_t node;
2620 u8 *gpe_status = NULL;
2621 u8 *feature_status = NULL;
2623 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
2624 feature_status = format (0, "%s",
2625 mp->feature_status ? "enabled" : "disabled");
2626 vec_add1 (gpe_status, 0);
2627 vec_add1 (feature_status, 0);
2629 vat_json_init_object (&node);
2630 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
2631 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
2633 vec_free (gpe_status);
2634 vec_free (feature_status);
2636 vat_json_print (vam->ofp, &node);
2637 vat_json_free (&node);
2639 vam->retval = ntohl (mp->retval);
2640 vam->result_ready = 1;
2644 vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler
2645 (vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
2647 vat_main_t *vam = &vat_main;
2648 i32 retval = ntohl (mp->retval);
2652 fformat (vam->ofp, "%=20s\n", mp->locator_set_name);
2655 vam->retval = retval;
2656 vam->result_ready = 1;
2660 vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler_json
2661 (vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
2663 vat_main_t *vam = &vat_main;
2664 vat_json_node_t *node = NULL;
2666 if (VAT_JSON_ARRAY != vam->json_tree.type)
2668 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2669 vat_json_init_array (&vam->json_tree);
2671 node = vat_json_array_add (&vam->json_tree);
2673 vat_json_init_object (node);
2674 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
2676 vat_json_print (vam->ofp, node);
2677 vat_json_free (node);
2679 vam->retval = ntohl (mp->retval);
2680 vam->result_ready = 1;
2684 vl_api_show_lisp_pitr_reply_t_handler (vl_api_show_lisp_pitr_reply_t * mp)
2686 vat_main_t *vam = &vat_main;
2687 i32 retval = ntohl (mp->retval);
2691 fformat (vam->ofp, "%-20s%-16s\n",
2692 mp->status ? "enabled" : "disabled",
2693 mp->status ? (char *) mp->locator_set_name : "");
2696 vam->retval = retval;
2697 vam->result_ready = 1;
2701 vl_api_show_lisp_pitr_reply_t_handler_json (vl_api_show_lisp_pitr_reply_t *
2704 vat_main_t *vam = &vat_main;
2705 vat_json_node_t node;
2708 status = format (0, "%s", mp->status ? "enabled" : "disabled");
2709 vec_add1 (status, 0);
2711 vat_json_init_object (&node);
2712 vat_json_object_add_string_copy (&node, "status", status);
2715 vat_json_object_add_string_copy (&node, "locator_set",
2716 mp->locator_set_name);
2721 vat_json_print (vam->ofp, &node);
2722 vat_json_free (&node);
2724 vam->retval = ntohl (mp->retval);
2725 vam->result_ready = 1;
2729 format_policer_type (u8 * s, va_list * va)
2731 u32 i = va_arg (*va, u32);
2733 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
2734 s = format (s, "1r2c");
2735 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
2736 s = format (s, "1r3c");
2737 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
2738 s = format (s, "2r3c-2698");
2739 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
2740 s = format (s, "2r3c-4115");
2741 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
2742 s = format (s, "2r3c-mef5cf1");
2744 s = format (s, "ILLEGAL");
2749 format_policer_rate_type (u8 * s, va_list * va)
2751 u32 i = va_arg (*va, u32);
2753 if (i == SSE2_QOS_RATE_KBPS)
2754 s = format (s, "kbps");
2755 else if (i == SSE2_QOS_RATE_PPS)
2756 s = format (s, "pps");
2758 s = format (s, "ILLEGAL");
2763 format_policer_round_type (u8 * s, va_list * va)
2765 u32 i = va_arg (*va, u32);
2767 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
2768 s = format (s, "closest");
2769 else if (i == SSE2_QOS_ROUND_TO_UP)
2770 s = format (s, "up");
2771 else if (i == SSE2_QOS_ROUND_TO_DOWN)
2772 s = format (s, "down");
2774 s = format (s, "ILLEGAL");
2779 format_policer_action_type (u8 * s, va_list * va)
2781 u32 i = va_arg (*va, u32);
2783 if (i == SSE2_QOS_ACTION_DROP)
2784 s = format (s, "drop");
2785 else if (i == SSE2_QOS_ACTION_TRANSMIT)
2786 s = format (s, "transmit");
2787 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2788 s = format (s, "mark-and-transmit");
2790 s = format (s, "ILLEGAL");
2795 format_dscp (u8 * s, va_list * va)
2797 u32 i = va_arg (*va, u32);
2802 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
2806 return format (s, "ILLEGAL");
2808 s = format (s, "%s", t);
2813 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
2815 vat_main_t *vam = &vat_main;
2816 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
2818 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2819 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
2821 conform_dscp_str = format (0, "");
2823 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2824 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
2826 exceed_dscp_str = format (0, "");
2828 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2829 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
2831 violate_dscp_str = format (0, "");
2833 fformat (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
2834 "rate type %U, round type %U, %s rate, %s color-aware, "
2835 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
2836 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
2837 "conform action %U%s, exceed action %U%s, violate action %U%s\n",
2839 format_policer_type, mp->type,
2842 clib_net_to_host_u64 (mp->cb),
2843 clib_net_to_host_u64 (mp->eb),
2844 format_policer_rate_type, mp->rate_type,
2845 format_policer_round_type, mp->round_type,
2846 mp->single_rate ? "single" : "dual",
2847 mp->color_aware ? "is" : "not",
2848 ntohl (mp->cir_tokens_per_period),
2849 ntohl (mp->pir_tokens_per_period),
2851 ntohl (mp->current_limit),
2852 ntohl (mp->current_bucket),
2853 ntohl (mp->extended_limit),
2854 ntohl (mp->extended_bucket),
2855 clib_net_to_host_u64 (mp->last_update_time),
2856 format_policer_action_type, mp->conform_action_type,
2858 format_policer_action_type, mp->exceed_action_type,
2860 format_policer_action_type, mp->violate_action_type,
2863 vec_free (conform_dscp_str);
2864 vec_free (exceed_dscp_str);
2865 vec_free (violate_dscp_str);
2868 static void vl_api_policer_details_t_handler_json
2869 (vl_api_policer_details_t * mp)
2871 vat_main_t *vam = &vat_main;
2872 vat_json_node_t *node;
2873 u8 *rate_type_str, *round_type_str, *type_str;
2874 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
2876 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
2878 format (0, "%U", format_policer_round_type, mp->round_type);
2879 type_str = format (0, "%U", format_policer_type, mp->type);
2880 conform_action_str = format (0, "%U", format_policer_action_type,
2881 mp->conform_action_type);
2882 exceed_action_str = format (0, "%U", format_policer_action_type,
2883 mp->exceed_action_type);
2884 violate_action_str = format (0, "%U", format_policer_action_type,
2885 mp->violate_action_type);
2887 if (VAT_JSON_ARRAY != vam->json_tree.type)
2889 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2890 vat_json_init_array (&vam->json_tree);
2892 node = vat_json_array_add (&vam->json_tree);
2894 vat_json_init_object (node);
2895 vat_json_object_add_string_copy (node, "name", mp->name);
2896 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
2897 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
2898 vat_json_object_add_uint (node, "cb", ntohl (mp->cb));
2899 vat_json_object_add_uint (node, "eb", ntohl (mp->eb));
2900 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
2901 vat_json_object_add_string_copy (node, "round_type", round_type_str);
2902 vat_json_object_add_string_copy (node, "type", type_str);
2903 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
2904 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
2905 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
2906 vat_json_object_add_uint (node, "cir_tokens_per_period",
2907 ntohl (mp->cir_tokens_per_period));
2908 vat_json_object_add_uint (node, "eir_tokens_per_period",
2909 ntohl (mp->pir_tokens_per_period));
2910 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
2911 vat_json_object_add_uint (node, "current_bucket",
2912 ntohl (mp->current_bucket));
2913 vat_json_object_add_uint (node, "extended_limit",
2914 ntohl (mp->extended_limit));
2915 vat_json_object_add_uint (node, "extended_bucket",
2916 ntohl (mp->extended_bucket));
2917 vat_json_object_add_uint (node, "last_update_time",
2918 ntohl (mp->last_update_time));
2919 vat_json_object_add_string_copy (node, "conform_action",
2920 conform_action_str);
2921 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2923 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
2924 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
2925 vec_free (dscp_str);
2927 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
2928 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2930 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
2931 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
2932 vec_free (dscp_str);
2934 vat_json_object_add_string_copy (node, "violate_action",
2935 violate_action_str);
2936 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2938 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
2939 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
2940 vec_free (dscp_str);
2943 vec_free (rate_type_str);
2944 vec_free (round_type_str);
2945 vec_free (type_str);
2946 vec_free (conform_action_str);
2947 vec_free (exceed_action_str);
2948 vec_free (violate_action_str);
2952 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
2955 vat_main_t *vam = &vat_main;
2956 int i, count = ntohl (mp->count);
2959 fformat (vam->ofp, "classify table ids (%d) : ", count);
2960 for (i = 0; i < count; i++)
2962 fformat (vam->ofp, "%d", ntohl (mp->ids[i]));
2963 fformat (vam->ofp, (i < count - 1) ? "," : "\n");
2965 vam->retval = ntohl (mp->retval);
2966 vam->result_ready = 1;
2970 vl_api_classify_table_ids_reply_t_handler_json
2971 (vl_api_classify_table_ids_reply_t * mp)
2973 vat_main_t *vam = &vat_main;
2974 int i, count = ntohl (mp->count);
2978 vat_json_node_t node;
2980 vat_json_init_object (&node);
2981 for (i = 0; i < count; i++)
2983 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
2985 vat_json_print (vam->ofp, &node);
2986 vat_json_free (&node);
2988 vam->retval = ntohl (mp->retval);
2989 vam->result_ready = 1;
2993 vl_api_classify_table_by_interface_reply_t_handler
2994 (vl_api_classify_table_by_interface_reply_t * mp)
2996 vat_main_t *vam = &vat_main;
2999 table_id = ntohl (mp->l2_table_id);
3001 fformat (vam->ofp, "l2 table id : %d\n", table_id);
3003 fformat (vam->ofp, "l2 table id : No input ACL tables configured\n");
3004 table_id = ntohl (mp->ip4_table_id);
3006 fformat (vam->ofp, "ip4 table id : %d\n", table_id);
3008 fformat (vam->ofp, "ip4 table id : No input ACL tables configured\n");
3009 table_id = ntohl (mp->ip6_table_id);
3011 fformat (vam->ofp, "ip6 table id : %d\n", table_id);
3013 fformat (vam->ofp, "ip6 table id : No input ACL tables configured\n");
3014 vam->retval = ntohl (mp->retval);
3015 vam->result_ready = 1;
3019 vl_api_classify_table_by_interface_reply_t_handler_json
3020 (vl_api_classify_table_by_interface_reply_t * mp)
3022 vat_main_t *vam = &vat_main;
3023 vat_json_node_t node;
3025 vat_json_init_object (&node);
3027 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
3028 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
3029 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
3031 vat_json_print (vam->ofp, &node);
3032 vat_json_free (&node);
3034 vam->retval = ntohl (mp->retval);
3035 vam->result_ready = 1;
3038 static void vl_api_policer_add_del_reply_t_handler
3039 (vl_api_policer_add_del_reply_t * mp)
3041 vat_main_t *vam = &vat_main;
3042 i32 retval = ntohl (mp->retval);
3043 if (vam->async_mode)
3045 vam->async_errors += (retval < 0);
3049 vam->retval = retval;
3050 vam->result_ready = 1;
3051 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
3053 * Note: this is just barely thread-safe, depends on
3054 * the main thread spinning waiting for an answer...
3056 errmsg ("policer index %d\n", ntohl (mp->policer_index));
3060 static void vl_api_policer_add_del_reply_t_handler_json
3061 (vl_api_policer_add_del_reply_t * mp)
3063 vat_main_t *vam = &vat_main;
3064 vat_json_node_t node;
3066 vat_json_init_object (&node);
3067 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3068 vat_json_object_add_uint (&node, "policer_index",
3069 ntohl (mp->policer_index));
3071 vat_json_print (vam->ofp, &node);
3072 vat_json_free (&node);
3074 vam->retval = ntohl (mp->retval);
3075 vam->result_ready = 1;
3078 /* Format hex dump. */
3080 format_hex_bytes (u8 * s, va_list * va)
3082 u8 *bytes = va_arg (*va, u8 *);
3083 int n_bytes = va_arg (*va, int);
3086 /* Print short or long form depending on byte count. */
3087 uword short_form = n_bytes <= 32;
3088 uword indent = format_get_indent (s);
3093 for (i = 0; i < n_bytes; i++)
3095 if (!short_form && (i % 32) == 0)
3096 s = format (s, "%08x: ", i);
3097 s = format (s, "%02x", bytes[i]);
3098 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
3099 s = format (s, "\n%U", format_white_space, indent);
3106 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
3109 vat_main_t *vam = &vat_main;
3110 i32 retval = ntohl (mp->retval);
3113 fformat (vam->ofp, "classify table info :\n");
3114 fformat (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d\n",
3115 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
3116 ntohl (mp->miss_next_index));
3117 fformat (vam->ofp, "nbuckets: %d skip: %d match: %d\n",
3118 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
3119 ntohl (mp->match_n_vectors));
3120 fformat (vam->ofp, "mask: %U\n", format_hex_bytes, mp->mask,
3121 ntohl (mp->mask_length));
3123 vam->retval = retval;
3124 vam->result_ready = 1;
3128 vl_api_classify_table_info_reply_t_handler_json
3129 (vl_api_classify_table_info_reply_t * mp)
3131 vat_main_t *vam = &vat_main;
3132 vat_json_node_t node;
3134 i32 retval = ntohl (mp->retval);
3137 vat_json_init_object (&node);
3139 vat_json_object_add_int (&node, "sessions",
3140 ntohl (mp->active_sessions));
3141 vat_json_object_add_int (&node, "nexttbl",
3142 ntohl (mp->next_table_index));
3143 vat_json_object_add_int (&node, "nextnode",
3144 ntohl (mp->miss_next_index));
3145 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
3146 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
3147 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
3148 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
3149 ntohl (mp->mask_length), 0);
3150 vat_json_object_add_string_copy (&node, "mask", s);
3152 vat_json_print (vam->ofp, &node);
3153 vat_json_free (&node);
3155 vam->retval = ntohl (mp->retval);
3156 vam->result_ready = 1;
3160 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
3163 vat_main_t *vam = &vat_main;
3165 fformat (vam->ofp, "next_index: %d advance: %d opaque: %d ",
3166 ntohl (mp->hit_next_index), ntohl (mp->advance),
3167 ntohl (mp->opaque_index));
3168 fformat (vam->ofp, "mask: %U\n", format_hex_bytes, mp->match,
3169 ntohl (mp->match_length));
3173 vl_api_classify_session_details_t_handler_json
3174 (vl_api_classify_session_details_t * mp)
3176 vat_main_t *vam = &vat_main;
3177 vat_json_node_t *node = NULL;
3179 if (VAT_JSON_ARRAY != vam->json_tree.type)
3181 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3182 vat_json_init_array (&vam->json_tree);
3184 node = vat_json_array_add (&vam->json_tree);
3186 vat_json_init_object (node);
3187 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
3188 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
3189 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
3191 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
3193 vat_json_object_add_string_copy (node, "match", s);
3196 static void vl_api_pg_create_interface_reply_t_handler
3197 (vl_api_pg_create_interface_reply_t * mp)
3199 vat_main_t *vam = &vat_main;
3201 vam->retval = ntohl (mp->retval);
3202 vam->result_ready = 1;
3205 static void vl_api_pg_create_interface_reply_t_handler_json
3206 (vl_api_pg_create_interface_reply_t * mp)
3208 vat_main_t *vam = &vat_main;
3209 vat_json_node_t node;
3211 i32 retval = ntohl (mp->retval);
3214 vat_json_init_object (&node);
3216 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
3218 vat_json_print (vam->ofp, &node);
3219 vat_json_free (&node);
3221 vam->retval = ntohl (mp->retval);
3222 vam->result_ready = 1;
3225 static void vl_api_policer_classify_details_t_handler
3226 (vl_api_policer_classify_details_t * mp)
3228 vat_main_t *vam = &vat_main;
3230 fformat (vam->ofp, "%10d%20d\n", ntohl (mp->sw_if_index),
3231 ntohl (mp->table_index));
3234 static void vl_api_policer_classify_details_t_handler_json
3235 (vl_api_policer_classify_details_t * mp)
3237 vat_main_t *vam = &vat_main;
3238 vat_json_node_t *node;
3240 if (VAT_JSON_ARRAY != vam->json_tree.type)
3242 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3243 vat_json_init_array (&vam->json_tree);
3245 node = vat_json_array_add (&vam->json_tree);
3247 vat_json_init_object (node);
3248 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
3249 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
3252 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler
3253 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3255 vat_main_t *vam = &vat_main;
3256 i32 retval = ntohl (mp->retval);
3257 if (vam->async_mode)
3259 vam->async_errors += (retval < 0);
3263 vam->retval = retval;
3264 vam->sw_if_index = ntohl (mp->sw_if_index);
3265 vam->result_ready = 1;
3269 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler_json
3270 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3272 vat_main_t *vam = &vat_main;
3273 vat_json_node_t node;
3275 vat_json_init_object (&node);
3276 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3277 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
3279 vat_json_print (vam->ofp, &node);
3280 vat_json_free (&node);
3282 vam->retval = ntohl (mp->retval);
3283 vam->result_ready = 1;
3286 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
3287 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
3288 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
3289 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
3292 * Generate boilerplate reply handlers, which
3293 * dig the return value out of the xxx_reply_t API message,
3294 * stick it into vam->retval, and set vam->result_ready
3296 * Could also do this by pointing N message decode slots at
3297 * a single function, but that could break in subtle ways.
3300 #define foreach_standard_reply_retval_handler \
3301 _(sw_interface_set_flags_reply) \
3302 _(sw_interface_add_del_address_reply) \
3303 _(sw_interface_set_table_reply) \
3304 _(sw_interface_set_vpath_reply) \
3305 _(sw_interface_set_l2_bridge_reply) \
3306 _(bridge_domain_add_del_reply) \
3307 _(sw_interface_set_l2_xconnect_reply) \
3308 _(l2fib_add_del_reply) \
3309 _(ip_add_del_route_reply) \
3310 _(proxy_arp_add_del_reply) \
3311 _(proxy_arp_intfc_enable_disable_reply) \
3312 _(mpls_add_del_encap_reply) \
3313 _(mpls_add_del_decap_reply) \
3314 _(mpls_ethernet_add_del_tunnel_2_reply) \
3315 _(sw_interface_set_unnumbered_reply) \
3316 _(ip_neighbor_add_del_reply) \
3317 _(reset_vrf_reply) \
3318 _(oam_add_del_reply) \
3319 _(reset_fib_reply) \
3320 _(dhcp_proxy_config_reply) \
3321 _(dhcp_proxy_config_2_reply) \
3322 _(dhcp_proxy_set_vss_reply) \
3323 _(dhcp_client_config_reply) \
3324 _(set_ip_flow_hash_reply) \
3325 _(sw_interface_ip6_enable_disable_reply) \
3326 _(sw_interface_ip6_set_link_local_address_reply) \
3327 _(sw_interface_ip6nd_ra_prefix_reply) \
3328 _(sw_interface_ip6nd_ra_config_reply) \
3329 _(set_arp_neighbor_limit_reply) \
3330 _(l2_patch_add_del_reply) \
3331 _(sr_tunnel_add_del_reply) \
3332 _(sr_policy_add_del_reply) \
3333 _(sr_multicast_map_add_del_reply) \
3334 _(classify_add_del_session_reply) \
3335 _(classify_set_interface_ip_table_reply) \
3336 _(classify_set_interface_l2_tables_reply) \
3337 _(l2tpv3_set_tunnel_cookies_reply) \
3338 _(l2tpv3_interface_enable_disable_reply) \
3339 _(l2tpv3_set_lookup_key_reply) \
3340 _(l2_fib_clear_table_reply) \
3341 _(l2_interface_efp_filter_reply) \
3342 _(l2_interface_vlan_tag_rewrite_reply) \
3343 _(modify_vhost_user_if_reply) \
3344 _(delete_vhost_user_if_reply) \
3345 _(want_ip4_arp_events_reply) \
3346 _(input_acl_set_interface_reply) \
3347 _(ipsec_spd_add_del_reply) \
3348 _(ipsec_interface_add_del_spd_reply) \
3349 _(ipsec_spd_add_del_entry_reply) \
3350 _(ipsec_sad_add_del_entry_reply) \
3351 _(ipsec_sa_set_key_reply) \
3352 _(ikev2_profile_add_del_reply) \
3353 _(ikev2_profile_set_auth_reply) \
3354 _(ikev2_profile_set_id_reply) \
3355 _(ikev2_profile_set_ts_reply) \
3356 _(ikev2_set_local_key_reply) \
3357 _(delete_loopback_reply) \
3358 _(bd_ip_mac_add_del_reply) \
3359 _(map_del_domain_reply) \
3360 _(map_add_del_rule_reply) \
3361 _(want_interface_events_reply) \
3362 _(want_stats_reply) \
3363 _(cop_interface_enable_disable_reply) \
3364 _(cop_whitelist_enable_disable_reply) \
3365 _(sw_interface_clear_stats_reply) \
3366 _(trace_profile_add_reply) \
3367 _(trace_profile_apply_reply) \
3368 _(trace_profile_del_reply) \
3369 _(lisp_add_del_locator_reply) \
3370 _(lisp_add_del_local_eid_reply) \
3371 _(lisp_add_del_remote_mapping_reply) \
3372 _(lisp_add_del_adjacency_reply) \
3373 _(lisp_gpe_add_del_fwd_entry_reply) \
3374 _(lisp_add_del_map_resolver_reply) \
3375 _(lisp_gpe_enable_disable_reply) \
3376 _(lisp_gpe_add_del_iface_reply) \
3377 _(lisp_enable_disable_reply) \
3378 _(lisp_pitr_set_locator_set_reply) \
3379 _(lisp_add_del_map_request_itr_rlocs_reply) \
3380 _(lisp_eid_table_add_del_map_reply) \
3381 _(vxlan_gpe_add_del_tunnel_reply) \
3382 _(af_packet_delete_reply) \
3383 _(policer_classify_set_interface_reply) \
3384 _(netmap_create_reply) \
3385 _(netmap_delete_reply) \
3386 _(ipfix_enable_reply) \
3387 _(pg_capture_reply) \
3388 _(pg_enable_disable_reply) \
3389 _(ip_source_and_port_range_check_add_del_reply) \
3390 _(ip_source_and_port_range_check_interface_add_del_reply)
3393 static void vl_api_##n##_t_handler \
3394 (vl_api_##n##_t * mp) \
3396 vat_main_t * vam = &vat_main; \
3397 i32 retval = ntohl(mp->retval); \
3398 if (vam->async_mode) { \
3399 vam->async_errors += (retval < 0); \
3401 vam->retval = retval; \
3402 vam->result_ready = 1; \
3405 foreach_standard_reply_retval_handler;
3409 static void vl_api_##n##_t_handler_json \
3410 (vl_api_##n##_t * mp) \
3412 vat_main_t * vam = &vat_main; \
3413 vat_json_node_t node; \
3414 vat_json_init_object(&node); \
3415 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
3416 vat_json_print(vam->ofp, &node); \
3417 vam->retval = ntohl(mp->retval); \
3418 vam->result_ready = 1; \
3420 foreach_standard_reply_retval_handler;
3424 * Table of message reply handlers, must include boilerplate handlers
3428 #define foreach_vpe_api_reply_msg \
3429 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
3430 _(SW_INTERFACE_DETAILS, sw_interface_details) \
3431 _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
3432 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
3433 _(CONTROL_PING_REPLY, control_ping_reply) \
3434 _(NOPRINT_CONTROL_PING_REPLY, noprint_control_ping_reply) \
3435 _(CLI_REPLY, cli_reply) \
3436 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
3437 sw_interface_add_del_address_reply) \
3438 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
3439 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
3440 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
3441 sw_interface_set_l2_xconnect_reply) \
3442 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
3443 sw_interface_set_l2_bridge_reply) \
3444 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
3445 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
3446 _(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
3447 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
3448 _(L2_FLAGS_REPLY, l2_flags_reply) \
3449 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
3450 _(TAP_CONNECT_REPLY, tap_connect_reply) \
3451 _(TAP_MODIFY_REPLY, tap_modify_reply) \
3452 _(TAP_DELETE_REPLY, tap_delete_reply) \
3453 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
3454 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
3455 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
3456 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
3457 proxy_arp_intfc_enable_disable_reply) \
3458 _(MPLS_ADD_DEL_ENCAP_REPLY, mpls_add_del_encap_reply) \
3459 _(MPLS_ADD_DEL_DECAP_REPLY, mpls_add_del_decap_reply) \
3460 _(MPLS_GRE_ADD_DEL_TUNNEL_REPLY, mpls_gre_add_del_tunnel_reply) \
3461 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_REPLY, \
3462 mpls_ethernet_add_del_tunnel_reply) \
3463 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_2_REPLY, \
3464 mpls_ethernet_add_del_tunnel_2_reply) \
3465 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
3466 sw_interface_set_unnumbered_reply) \
3467 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
3468 _(RESET_VRF_REPLY, reset_vrf_reply) \
3469 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
3470 _(CREATE_SUBIF_REPLY, create_subif_reply) \
3471 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
3472 _(RESET_FIB_REPLY, reset_fib_reply) \
3473 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
3474 _(DHCP_PROXY_CONFIG_2_REPLY, dhcp_proxy_config_2_reply) \
3475 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
3476 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
3477 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
3478 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
3479 sw_interface_ip6_enable_disable_reply) \
3480 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
3481 sw_interface_ip6_set_link_local_address_reply) \
3482 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
3483 sw_interface_ip6nd_ra_prefix_reply) \
3484 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
3485 sw_interface_ip6nd_ra_config_reply) \
3486 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
3487 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
3488 _(SR_TUNNEL_ADD_DEL_REPLY, sr_tunnel_add_del_reply) \
3489 _(SR_POLICY_ADD_DEL_REPLY, sr_policy_add_del_reply) \
3490 _(SR_MULTICAST_MAP_ADD_DEL_REPLY, sr_multicast_map_add_del_reply) \
3491 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
3492 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
3493 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
3494 classify_set_interface_ip_table_reply) \
3495 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
3496 classify_set_interface_l2_tables_reply) \
3497 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
3498 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
3499 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
3500 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
3501 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
3502 l2tpv3_interface_enable_disable_reply) \
3503 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
3504 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
3505 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
3506 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
3507 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
3508 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
3509 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
3510 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
3511 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
3512 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
3513 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
3514 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
3515 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
3516 _(SHOW_VERSION_REPLY, show_version_reply) \
3517 _(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
3518 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
3519 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
3520 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
3521 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
3522 _(IP4_ARP_EVENT, ip4_arp_event) \
3523 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
3524 _(IP_ADDRESS_DETAILS, ip_address_details) \
3525 _(IP_DETAILS, ip_details) \
3526 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
3527 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
3528 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
3529 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
3530 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
3531 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
3532 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
3533 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
3534 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
3535 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
3536 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
3537 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
3538 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
3539 _(VNET_INTERFACE_COUNTERS, vnet_interface_counters) \
3540 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
3541 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
3542 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
3543 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
3544 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
3545 _(MAP_DOMAIN_DETAILS, map_domain_details) \
3546 _(MAP_RULE_DETAILS, map_rule_details) \
3547 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
3548 _(WANT_STATS_REPLY, want_stats_reply) \
3549 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
3550 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
3551 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
3552 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
3553 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
3554 _(TRACE_PROFILE_ADD_REPLY, trace_profile_add_reply) \
3555 _(TRACE_PROFILE_APPLY_REPLY, trace_profile_apply_reply) \
3556 _(TRACE_PROFILE_DEL_REPLY, trace_profile_del_reply) \
3557 _(LISP_ADD_DEL_LOCATOR_SET_REPLY, lisp_add_del_locator_set_reply) \
3558 _(LISP_ADD_DEL_LOCATOR_REPLY, lisp_add_del_locator_reply) \
3559 _(LISP_ADD_DEL_LOCAL_EID_REPLY, lisp_add_del_local_eid_reply) \
3560 _(LISP_ADD_DEL_REMOTE_MAPPING_REPLY, lisp_add_del_remote_mapping_reply) \
3561 _(LISP_ADD_DEL_ADJACENCY_REPLY, lisp_add_del_adjacency_reply) \
3562 _(LISP_GPE_ADD_DEL_FWD_ENTRY_REPLY, lisp_gpe_add_del_fwd_entry_reply) \
3563 _(LISP_ADD_DEL_MAP_RESOLVER_REPLY, lisp_add_del_map_resolver_reply) \
3564 _(LISP_GPE_ENABLE_DISABLE_REPLY, lisp_gpe_enable_disable_reply) \
3565 _(LISP_ENABLE_DISABLE_REPLY, lisp_enable_disable_reply) \
3566 _(LISP_PITR_SET_LOCATOR_SET_REPLY, lisp_pitr_set_locator_set_reply) \
3567 _(LISP_EID_TABLE_ADD_DEL_MAP_REPLY, lisp_eid_table_add_del_map_reply) \
3568 _(LISP_GPE_ADD_DEL_IFACE_REPLY, lisp_gpe_add_del_iface_reply) \
3569 _(LISP_LOCATOR_SET_DETAILS, lisp_locator_set_details) \
3570 _(LISP_LOCATOR_DETAILS, lisp_locator_details) \
3571 _(LISP_EID_TABLE_DETAILS, lisp_eid_table_details) \
3572 _(LISP_EID_TABLE_MAP_DETAILS, lisp_eid_table_map_details) \
3573 _(LISP_EID_TABLE_VNI_DETAILS, lisp_eid_table_vni_details) \
3574 _(LISP_GPE_TUNNEL_DETAILS, lisp_gpe_tunnel_details) \
3575 _(LISP_MAP_RESOLVER_DETAILS, lisp_map_resolver_details) \
3576 _(SHOW_LISP_STATUS_REPLY, show_lisp_status_reply) \
3577 _(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
3578 lisp_add_del_map_request_itr_rlocs_reply) \
3579 _(LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
3580 lisp_get_map_request_itr_rlocs_reply) \
3581 _(SHOW_LISP_PITR_REPLY, show_lisp_pitr_reply) \
3582 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
3583 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
3584 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
3585 _(POLICER_DETAILS, policer_details) \
3586 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
3587 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
3588 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
3589 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
3590 _(MPLS_GRE_TUNNEL_DETAILS, mpls_gre_tunnel_details) \
3591 _(MPLS_ETH_TUNNEL_DETAILS, mpls_eth_tunnel_details) \
3592 _(MPLS_FIB_ENCAP_DETAILS, mpls_fib_encap_details) \
3593 _(MPLS_FIB_DECAP_DETAILS, mpls_fib_decap_details) \
3594 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
3595 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
3596 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
3597 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
3598 _(IPFIX_ENABLE_REPLY, ipfix_enable_reply) \
3599 _(IPFIX_DETAILS, ipfix_details) \
3600 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
3601 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
3602 _(PG_CAPTURE_REPLY, pg_capture_reply) \
3603 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
3604 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
3605 ip_source_and_port_range_check_add_del_reply) \
3606 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
3607 ip_source_and_port_range_check_interface_add_del_reply) \
3608 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
3609 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details)
3611 /* M: construct, but don't yet send a message */
3615 vam->result_ready = 0; \
3616 mp = vl_msg_api_alloc(sizeof(*mp)); \
3617 memset (mp, 0, sizeof (*mp)); \
3618 mp->_vl_msg_id = ntohs (VL_API_##T); \
3619 mp->client_index = vam->my_client_index; \
3624 vam->result_ready = 0; \
3625 mp = vl_msg_api_alloc(sizeof(*mp)+(n)); \
3626 memset (mp, 0, sizeof (*mp)); \
3627 mp->_vl_msg_id = ntohs (VL_API_##T); \
3628 mp->client_index = vam->my_client_index; \
3632 /* S: send a message */
3633 #define S (vl_msg_api_send_shmem (vam->vl_input_queue, (u8 *)&mp))
3635 /* W: wait for results, with timeout */
3638 timeout = vat_time_now (vam) + 1.0; \
3640 while (vat_time_now (vam) < timeout) { \
3641 if (vam->result_ready == 1) { \
3642 return (vam->retval); \
3648 /* W2: wait for results, with timeout */
3651 timeout = vat_time_now (vam) + 1.0; \
3653 while (vat_time_now (vam) < timeout) { \
3654 if (vam->result_ready == 1) { \
3656 return (vam->retval); \
3662 /* W_L: wait for results, with timeout */
3665 timeout = vat_time_now (vam) + 1.0; \
3667 while (vat_time_now (vam) < timeout) { \
3668 if (vam->result_ready == 1) { \
3670 return (vam->retval); \
3673 vam->noprint_msg = 0; \
3684 #define STR_VTR_OP_CASE(op) \
3685 case L2_VTR_ ## op: \
3689 str_vtr_op (u32 vtr_op)
3693 STR_VTR_OP_CASE (DISABLED);
3694 STR_VTR_OP_CASE (PUSH_1);
3695 STR_VTR_OP_CASE (PUSH_2);
3696 STR_VTR_OP_CASE (POP_1);
3697 STR_VTR_OP_CASE (POP_2);
3698 STR_VTR_OP_CASE (TRANSLATE_1_1);
3699 STR_VTR_OP_CASE (TRANSLATE_1_2);
3700 STR_VTR_OP_CASE (TRANSLATE_2_1);
3701 STR_VTR_OP_CASE (TRANSLATE_2_2);
3708 dump_sub_interface_table (vat_main_t * vam)
3710 const sw_interface_subif_t *sub = NULL;
3712 if (vam->json_output)
3715 ("JSON output supported only for VPE API calls and dump_stats_table");
3720 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s\n",
3721 "Interface", "sw_if_index",
3722 "sub id", "dot1ad", "tags", "outer id",
3723 "inner id", "exact", "default", "outer any", "inner any");
3725 vec_foreach (sub, vam->sw_if_subif_table)
3728 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d\n",
3729 sub->interface_name,
3731 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
3732 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
3733 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
3734 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
3735 if (sub->vtr_op != L2_VTR_DISABLED)
3738 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
3739 "tag1: %d tag2: %d ]\n",
3740 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
3741 sub->vtr_tag1, sub->vtr_tag2);
3749 name_sort_cmp (void *a1, void *a2)
3751 name_sort_t *n1 = a1;
3752 name_sort_t *n2 = a2;
3754 return strcmp ((char *) n1->name, (char *) n2->name);
3758 dump_interface_table (vat_main_t * vam)
3761 name_sort_t *nses = 0, *ns;
3763 if (vam->json_output)
3766 ("JSON output supported only for VPE API calls and dump_stats_table");
3771 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
3773 vec_add2 (nses, ns, 1);
3774 ns->name = (u8 *)(p->key);
3775 ns->value = (u32) p->value[0];
3779 vec_sort_with_function (nses, name_sort_cmp);
3781 fformat (vam->ofp, "%-25s%-15s\n", "Interface", "sw_if_index");
3782 vec_foreach (ns, nses)
3784 fformat (vam->ofp, "%-25s%-15d\n", ns->name, ns->value);
3791 dump_ip_table (vat_main_t * vam, int is_ipv6)
3793 const ip_details_t *det = NULL;
3794 const ip_address_details_t *address = NULL;
3797 fformat (vam->ofp, "%-12s\n", "sw_if_index");
3799 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
3806 fformat (vam->ofp, "%-12d\n", i);
3808 " %-30s%-13s\n", "Address", "Prefix length");
3813 vec_foreach (address, det->addr)
3817 is_ipv6 ? format_ip6_address : format_ip4_address,
3818 address->ip, address->prefix_length);
3826 dump_ipv4_table (vat_main_t * vam)
3828 if (vam->json_output)
3831 ("JSON output supported only for VPE API calls and dump_stats_table");
3835 return dump_ip_table (vam, 0);
3839 dump_ipv6_table (vat_main_t * vam)
3841 if (vam->json_output)
3844 ("JSON output supported only for VPE API calls and dump_stats_table");
3848 return dump_ip_table (vam, 1);
3852 counter_type_to_str (u8 counter_type, u8 is_combined)
3856 switch (counter_type)
3858 case VNET_INTERFACE_COUNTER_DROP:
3860 case VNET_INTERFACE_COUNTER_PUNT:
3862 case VNET_INTERFACE_COUNTER_IP4:
3864 case VNET_INTERFACE_COUNTER_IP6:
3866 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
3868 case VNET_INTERFACE_COUNTER_RX_MISS:
3870 case VNET_INTERFACE_COUNTER_RX_ERROR:
3872 case VNET_INTERFACE_COUNTER_TX_ERROR:
3875 return "INVALID-COUNTER-TYPE";
3880 switch (counter_type)
3882 case VNET_INTERFACE_COUNTER_RX:
3884 case VNET_INTERFACE_COUNTER_TX:
3887 return "INVALID-COUNTER-TYPE";
3893 dump_stats_table (vat_main_t * vam)
3895 vat_json_node_t node;
3896 vat_json_node_t *msg_array;
3897 vat_json_node_t *msg;
3898 vat_json_node_t *counter_array;
3899 vat_json_node_t *counter;
3900 interface_counter_t c;
3902 ip4_fib_counter_t *c4;
3903 ip6_fib_counter_t *c6;
3906 if (!vam->json_output)
3908 clib_warning ("dump_stats_table supported only in JSON format");
3912 vat_json_init_object (&node);
3914 /* interface counters */
3915 msg_array = vat_json_object_add (&node, "interface_counters");
3916 vat_json_init_array (msg_array);
3917 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
3919 msg = vat_json_array_add (msg_array);
3920 vat_json_init_object (msg);
3921 vat_json_object_add_string_copy (msg, "vnet_counter_type",
3922 (u8 *) counter_type_to_str (i, 0));
3923 vat_json_object_add_int (msg, "is_combined", 0);
3924 counter_array = vat_json_object_add (msg, "data");
3925 vat_json_init_array (counter_array);
3926 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
3928 packets = vam->simple_interface_counters[i][j];
3929 vat_json_array_add_uint (counter_array, packets);
3932 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
3934 msg = vat_json_array_add (msg_array);
3935 vat_json_init_object (msg);
3936 vat_json_object_add_string_copy (msg, "vnet_counter_type",
3937 (u8 *) counter_type_to_str (i, 1));
3938 vat_json_object_add_int (msg, "is_combined", 1);
3939 counter_array = vat_json_object_add (msg, "data");
3940 vat_json_init_array (counter_array);
3941 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
3943 c = vam->combined_interface_counters[i][j];
3944 counter = vat_json_array_add (counter_array);
3945 vat_json_init_object (counter);
3946 vat_json_object_add_uint (counter, "packets", c.packets);
3947 vat_json_object_add_uint (counter, "bytes", c.bytes);
3951 /* ip4 fib counters */
3952 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
3953 vat_json_init_array (msg_array);
3954 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
3956 msg = vat_json_array_add (msg_array);
3957 vat_json_init_object (msg);
3958 vat_json_object_add_uint (msg, "vrf_id",
3959 vam->ip4_fib_counters_vrf_id_by_index[i]);
3960 counter_array = vat_json_object_add (msg, "c");
3961 vat_json_init_array (counter_array);
3962 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
3964 counter = vat_json_array_add (counter_array);
3965 vat_json_init_object (counter);
3966 c4 = &vam->ip4_fib_counters[i][j];
3967 vat_json_object_add_ip4 (counter, "address", c4->address);
3968 vat_json_object_add_uint (counter, "address_length",
3969 c4->address_length);
3970 vat_json_object_add_uint (counter, "packets", c4->packets);
3971 vat_json_object_add_uint (counter, "bytes", c4->bytes);
3975 /* ip6 fib counters */
3976 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
3977 vat_json_init_array (msg_array);
3978 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
3980 msg = vat_json_array_add (msg_array);
3981 vat_json_init_object (msg);
3982 vat_json_object_add_uint (msg, "vrf_id",
3983 vam->ip6_fib_counters_vrf_id_by_index[i]);
3984 counter_array = vat_json_object_add (msg, "c");
3985 vat_json_init_array (counter_array);
3986 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
3988 counter = vat_json_array_add (counter_array);
3989 vat_json_init_object (counter);
3990 c6 = &vam->ip6_fib_counters[i][j];
3991 vat_json_object_add_ip6 (counter, "address", c6->address);
3992 vat_json_object_add_uint (counter, "address_length",
3993 c6->address_length);
3994 vat_json_object_add_uint (counter, "packets", c6->packets);
3995 vat_json_object_add_uint (counter, "bytes", c6->bytes);
3999 vat_json_print (vam->ofp, &node);
4000 vat_json_free (&node);
4006 exec (vat_main_t * vam)
4008 api_main_t *am = &api_main;
4009 vl_api_cli_request_t *mp;
4013 unformat_input_t *i = vam->input;
4015 if (vec_len (i->buffer) == 0)
4018 if (vam->exec_mode == 0 && unformat (i, "mode"))
4023 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4030 M (CLI_REQUEST, cli_request);
4033 * Copy cmd into shared memory.
4034 * In order for the CLI command to work, it
4035 * must be a vector ending in \n, not a C-string ending
4038 pthread_mutex_lock (&am->vlib_rp->mutex);
4039 oldheap = svm_push_data_heap (am->vlib_rp);
4041 vec_validate (cmd, vec_len (vam->input->buffer) - 1);
4042 clib_memcpy (cmd, vam->input->buffer, vec_len (vam->input->buffer));
4044 svm_pop_heap (oldheap);
4045 pthread_mutex_unlock (&am->vlib_rp->mutex);
4047 mp->cmd_in_shmem = (u64) cmd;
4049 timeout = vat_time_now (vam) + 10.0;
4051 while (vat_time_now (vam) < timeout)
4053 if (vam->result_ready == 1)
4056 if (vam->shmem_result != NULL)
4057 fformat (vam->ofp, "%s", vam->shmem_result);
4058 pthread_mutex_lock (&am->vlib_rp->mutex);
4059 oldheap = svm_push_data_heap (am->vlib_rp);
4061 free_me = (u8 *) vam->shmem_result;
4064 svm_pop_heap (oldheap);
4065 pthread_mutex_unlock (&am->vlib_rp->mutex);
4073 api_create_loopback (vat_main_t * vam)
4075 unformat_input_t *i = vam->input;
4076 vl_api_create_loopback_t *mp;
4081 memset (mac_address, 0, sizeof (mac_address));
4083 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4085 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
4091 /* Construct the API message */
4092 M (CREATE_LOOPBACK, create_loopback);
4094 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
4101 api_delete_loopback (vat_main_t * vam)
4103 unformat_input_t *i = vam->input;
4104 vl_api_delete_loopback_t *mp;
4106 u32 sw_if_index = ~0;
4108 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4110 if (unformat (i, "sw_if_index %d", &sw_if_index))
4116 if (sw_if_index == ~0)
4118 errmsg ("missing sw_if_index\n");
4122 /* Construct the API message */
4123 M (DELETE_LOOPBACK, delete_loopback);
4124 mp->sw_if_index = ntohl (sw_if_index);
4131 api_want_stats (vat_main_t * vam)
4133 unformat_input_t *i = vam->input;
4134 vl_api_want_stats_t *mp;
4138 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4140 if (unformat (i, "enable"))
4142 else if (unformat (i, "disable"))
4150 errmsg ("missing enable|disable\n");
4154 M (WANT_STATS, want_stats);
4155 mp->enable_disable = enable;
4162 api_want_interface_events (vat_main_t * vam)
4164 unformat_input_t *i = vam->input;
4165 vl_api_want_interface_events_t *mp;
4169 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4171 if (unformat (i, "enable"))
4173 else if (unformat (i, "disable"))
4181 errmsg ("missing enable|disable\n");
4185 M (WANT_INTERFACE_EVENTS, want_interface_events);
4186 mp->enable_disable = enable;
4188 vam->interface_event_display = enable;
4195 /* Note: non-static, called once to set up the initial intfc table */
4197 api_sw_interface_dump (vat_main_t * vam)
4199 vl_api_sw_interface_dump_t *mp;
4202 name_sort_t *nses = 0, *ns;
4203 sw_interface_subif_t *sub = NULL;
4205 /* Toss the old name table */
4207 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4209 vec_add2 (nses, ns, 1);
4210 ns->name = (u8 *)(p->key);
4211 ns->value = (u32) p->value[0];
4215 hash_free (vam->sw_if_index_by_interface_name);
4217 vec_foreach (ns, nses) vec_free (ns->name);
4221 vec_foreach (sub, vam->sw_if_subif_table)
4223 vec_free (sub->interface_name);
4225 vec_free (vam->sw_if_subif_table);
4227 /* recreate the interface name hash table */
4228 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
4230 /* Get list of ethernets */
4231 M (SW_INTERFACE_DUMP, sw_interface_dump);
4232 mp->name_filter_valid = 1;
4233 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
4236 /* and local / loopback interfaces */
4237 M (SW_INTERFACE_DUMP, sw_interface_dump);
4238 mp->name_filter_valid = 1;
4239 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
4243 /* and vxlan-gpe tunnel interfaces */
4244 M (SW_INTERFACE_DUMP, sw_interface_dump);
4245 mp->name_filter_valid = 1;
4246 strncpy ((char *) mp->name_filter, "vxlan_gpe",
4247 sizeof (mp->name_filter) - 1);
4250 /* and vxlan tunnel interfaces */
4251 M (SW_INTERFACE_DUMP, sw_interface_dump);
4252 mp->name_filter_valid = 1;
4253 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
4256 /* and host (af_packet) interfaces */
4257 M (SW_INTERFACE_DUMP, sw_interface_dump);
4258 mp->name_filter_valid = 1;
4259 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
4262 /* and l2tpv3 tunnel interfaces */
4263 M (SW_INTERFACE_DUMP, sw_interface_dump);
4264 mp->name_filter_valid = 1;
4265 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
4266 sizeof (mp->name_filter) - 1);
4269 /* and GRE tunnel interfaces */
4270 M (SW_INTERFACE_DUMP, sw_interface_dump);
4271 mp->name_filter_valid = 1;
4272 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
4275 /* Use a control ping for synchronization */
4277 vl_api_control_ping_t *mp;
4278 M (CONTROL_PING, control_ping);
4285 api_sw_interface_set_flags (vat_main_t * vam)
4287 unformat_input_t *i = vam->input;
4288 vl_api_sw_interface_set_flags_t *mp;
4291 u8 sw_if_index_set = 0;
4292 u8 admin_up = 0, link_up = 0;
4294 /* Parse args required to build the message */
4295 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4297 if (unformat (i, "admin-up"))
4299 else if (unformat (i, "admin-down"))
4301 else if (unformat (i, "link-up"))
4303 else if (unformat (i, "link-down"))
4305 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4306 sw_if_index_set = 1;
4307 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4308 sw_if_index_set = 1;
4313 if (sw_if_index_set == 0)
4315 errmsg ("missing interface name or sw_if_index\n");
4319 /* Construct the API message */
4320 M (SW_INTERFACE_SET_FLAGS, sw_interface_set_flags);
4321 mp->sw_if_index = ntohl (sw_if_index);
4322 mp->admin_up_down = admin_up;
4323 mp->link_up_down = link_up;
4328 /* Wait for a reply, return the good/bad news... */
4333 api_sw_interface_clear_stats (vat_main_t * vam)
4335 unformat_input_t *i = vam->input;
4336 vl_api_sw_interface_clear_stats_t *mp;
4339 u8 sw_if_index_set = 0;
4341 /* Parse args required to build the message */
4342 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4344 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4345 sw_if_index_set = 1;
4346 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4347 sw_if_index_set = 1;
4352 /* Construct the API message */
4353 M (SW_INTERFACE_CLEAR_STATS, sw_interface_clear_stats);
4355 if (sw_if_index_set == 1)
4356 mp->sw_if_index = ntohl (sw_if_index);
4358 mp->sw_if_index = ~0;
4363 /* Wait for a reply, return the good/bad news... */
4368 api_sw_interface_add_del_address (vat_main_t * vam)
4370 unformat_input_t *i = vam->input;
4371 vl_api_sw_interface_add_del_address_t *mp;
4374 u8 sw_if_index_set = 0;
4375 u8 is_add = 1, del_all = 0;
4376 u32 address_length = 0;
4377 u8 v4_address_set = 0;
4378 u8 v6_address_set = 0;
4379 ip4_address_t v4address;
4380 ip6_address_t v6address;
4382 /* Parse args required to build the message */
4383 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4385 if (unformat (i, "del-all"))
4387 else if (unformat (i, "del"))
4389 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4390 sw_if_index_set = 1;
4391 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4392 sw_if_index_set = 1;
4393 else if (unformat (i, "%U/%d",
4394 unformat_ip4_address, &v4address, &address_length))
4396 else if (unformat (i, "%U/%d",
4397 unformat_ip6_address, &v6address, &address_length))
4403 if (sw_if_index_set == 0)
4405 errmsg ("missing interface name or sw_if_index\n");
4408 if (v4_address_set && v6_address_set)
4410 errmsg ("both v4 and v6 addresses set\n");
4413 if (!v4_address_set && !v6_address_set && !del_all)
4415 errmsg ("no addresses set\n");
4419 /* Construct the API message */
4420 M (SW_INTERFACE_ADD_DEL_ADDRESS, sw_interface_add_del_address);
4422 mp->sw_if_index = ntohl (sw_if_index);
4423 mp->is_add = is_add;
4424 mp->del_all = del_all;
4428 clib_memcpy (mp->address, &v6address, sizeof (v6address));
4432 clib_memcpy (mp->address, &v4address, sizeof (v4address));
4434 mp->address_length = address_length;
4439 /* Wait for a reply, return good/bad news */
4444 api_sw_interface_set_table (vat_main_t * vam)
4446 unformat_input_t *i = vam->input;
4447 vl_api_sw_interface_set_table_t *mp;
4449 u32 sw_if_index, vrf_id = 0;
4450 u8 sw_if_index_set = 0;
4453 /* Parse args required to build the message */
4454 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4456 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4457 sw_if_index_set = 1;
4458 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4459 sw_if_index_set = 1;
4460 else if (unformat (i, "vrf %d", &vrf_id))
4462 else if (unformat (i, "ipv6"))
4468 if (sw_if_index_set == 0)
4470 errmsg ("missing interface name or sw_if_index\n");
4474 /* Construct the API message */
4475 M (SW_INTERFACE_SET_TABLE, sw_interface_set_table);
4477 mp->sw_if_index = ntohl (sw_if_index);
4478 mp->is_ipv6 = is_ipv6;
4479 mp->vrf_id = ntohl (vrf_id);
4484 /* Wait for a reply... */
4489 api_sw_interface_set_vpath (vat_main_t * vam)
4491 unformat_input_t *i = vam->input;
4492 vl_api_sw_interface_set_vpath_t *mp;
4494 u32 sw_if_index = 0;
4495 u8 sw_if_index_set = 0;
4498 /* Parse args required to build the message */
4499 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4501 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4502 sw_if_index_set = 1;
4503 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4504 sw_if_index_set = 1;
4505 else if (unformat (i, "enable"))
4507 else if (unformat (i, "disable"))
4513 if (sw_if_index_set == 0)
4515 errmsg ("missing interface name or sw_if_index\n");
4519 /* Construct the API message */
4520 M (SW_INTERFACE_SET_VPATH, sw_interface_set_vpath);
4522 mp->sw_if_index = ntohl (sw_if_index);
4523 mp->enable = is_enable;
4528 /* Wait for a reply... */
4533 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
4535 unformat_input_t *i = vam->input;
4536 vl_api_sw_interface_set_l2_xconnect_t *mp;
4539 u8 rx_sw_if_index_set = 0;
4541 u8 tx_sw_if_index_set = 0;
4544 /* Parse args required to build the message */
4545 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4547 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
4548 rx_sw_if_index_set = 1;
4549 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
4550 tx_sw_if_index_set = 1;
4551 else if (unformat (i, "rx"))
4553 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4555 if (unformat (i, "%U", unformat_sw_if_index, vam,
4557 rx_sw_if_index_set = 1;
4562 else if (unformat (i, "tx"))
4564 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4566 if (unformat (i, "%U", unformat_sw_if_index, vam,
4568 tx_sw_if_index_set = 1;
4573 else if (unformat (i, "enable"))
4575 else if (unformat (i, "disable"))
4581 if (rx_sw_if_index_set == 0)
4583 errmsg ("missing rx interface name or rx_sw_if_index\n");
4587 if (enable && (tx_sw_if_index_set == 0))
4589 errmsg ("missing tx interface name or tx_sw_if_index\n");
4593 M (SW_INTERFACE_SET_L2_XCONNECT, sw_interface_set_l2_xconnect);
4595 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
4596 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
4597 mp->enable = enable;
4606 api_sw_interface_set_l2_bridge (vat_main_t * vam)
4608 unformat_input_t *i = vam->input;
4609 vl_api_sw_interface_set_l2_bridge_t *mp;
4612 u8 rx_sw_if_index_set = 0;
4619 /* Parse args required to build the message */
4620 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4622 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
4623 rx_sw_if_index_set = 1;
4624 else if (unformat (i, "bd_id %d", &bd_id))
4626 else if (unformat (i, "%U", unformat_sw_if_index, vam, &rx_sw_if_index))
4627 rx_sw_if_index_set = 1;
4628 else if (unformat (i, "shg %d", &shg))
4630 else if (unformat (i, "bvi"))
4632 else if (unformat (i, "enable"))
4634 else if (unformat (i, "disable"))
4640 if (rx_sw_if_index_set == 0)
4642 errmsg ("missing rx interface name or sw_if_index\n");
4646 if (enable && (bd_id_set == 0))
4648 errmsg ("missing bridge domain\n");
4652 M (SW_INTERFACE_SET_L2_BRIDGE, sw_interface_set_l2_bridge);
4654 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
4655 mp->bd_id = ntohl (bd_id);
4658 mp->enable = enable;
4667 api_bridge_domain_dump (vat_main_t * vam)
4669 unformat_input_t *i = vam->input;
4670 vl_api_bridge_domain_dump_t *mp;
4674 /* Parse args required to build the message */
4675 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4677 if (unformat (i, "bd_id %d", &bd_id))
4683 M (BRIDGE_DOMAIN_DUMP, bridge_domain_dump);
4684 mp->bd_id = ntohl (bd_id);
4687 /* Use a control ping for synchronization */
4689 vl_api_control_ping_t *mp;
4690 M (CONTROL_PING, control_ping);
4700 api_bridge_domain_add_del (vat_main_t * vam)
4702 unformat_input_t *i = vam->input;
4703 vl_api_bridge_domain_add_del_t *mp;
4707 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
4709 /* Parse args required to build the message */
4710 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4712 if (unformat (i, "bd_id %d", &bd_id))
4714 else if (unformat (i, "flood %d", &flood))
4716 else if (unformat (i, "uu-flood %d", &uu_flood))
4718 else if (unformat (i, "forward %d", &forward))
4720 else if (unformat (i, "learn %d", &learn))
4722 else if (unformat (i, "arp-term %d", &arp_term))
4724 else if (unformat (i, "del"))
4727 flood = uu_flood = forward = learn = 0;
4735 errmsg ("missing bridge domain\n");
4739 M (BRIDGE_DOMAIN_ADD_DEL, bridge_domain_add_del);
4741 mp->bd_id = ntohl (bd_id);
4743 mp->uu_flood = uu_flood;
4744 mp->forward = forward;
4746 mp->arp_term = arp_term;
4747 mp->is_add = is_add;
4756 api_l2fib_add_del (vat_main_t * vam)
4758 unformat_input_t *i = vam->input;
4759 vl_api_l2fib_add_del_t *mp;
4766 u8 sw_if_index_set = 0;
4775 /* Parse args required to build the message */
4776 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4778 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
4780 else if (unformat (i, "bd_id %d", &bd_id))
4782 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4783 sw_if_index_set = 1;
4784 else if (unformat (i, "sw_if"))
4786 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4788 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4789 sw_if_index_set = 1;
4794 else if (unformat (i, "static"))
4796 else if (unformat (i, "filter"))
4801 else if (unformat (i, "bvi"))
4806 else if (unformat (i, "del"))
4808 else if (unformat (i, "count %d", &count))
4816 errmsg ("missing mac address\n");
4822 errmsg ("missing bridge domain\n");
4826 if (is_add && (sw_if_index_set == 0))
4828 errmsg ("missing interface name or sw_if_index\n");
4834 /* Turn on async mode */
4835 vam->async_mode = 1;
4836 vam->async_errors = 0;
4837 before = vat_time_now (vam);
4840 for (j = 0; j < count; j++)
4842 M (L2FIB_ADD_DEL, l2fib_add_del);
4845 mp->bd_id = ntohl (bd_id);
4846 mp->is_add = is_add;
4850 mp->sw_if_index = ntohl (sw_if_index);
4851 mp->static_mac = static_mac;
4852 mp->filter_mac = filter_mac;
4853 mp->bvi_mac = bvi_mac;
4855 increment_mac_address (&mac);
4862 vl_api_control_ping_t *mp;
4865 /* Shut off async mode */
4866 vam->async_mode = 0;
4868 M (CONTROL_PING, control_ping);
4871 timeout = vat_time_now (vam) + 1.0;
4872 while (vat_time_now (vam) < timeout)
4873 if (vam->result_ready == 1)
4878 if (vam->retval == -99)
4879 errmsg ("timeout\n");
4881 if (vam->async_errors > 0)
4883 errmsg ("%d asynchronous errors\n", vam->async_errors);
4886 vam->async_errors = 0;
4887 after = vat_time_now (vam);
4889 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
4890 count, after - before, count / (after - before));
4894 /* Wait for a reply... */
4897 /* Return the good/bad news */
4898 return (vam->retval);
4902 api_l2_flags (vat_main_t * vam)
4904 unformat_input_t *i = vam->input;
4905 vl_api_l2_flags_t *mp;
4908 u32 feature_bitmap = 0;
4909 u8 sw_if_index_set = 0;
4911 /* Parse args required to build the message */
4912 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4914 if (unformat (i, "sw_if_index %d", &sw_if_index))
4915 sw_if_index_set = 1;
4916 else if (unformat (i, "sw_if"))
4918 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4920 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4921 sw_if_index_set = 1;
4926 else if (unformat (i, "learn"))
4927 feature_bitmap |= L2INPUT_FEAT_LEARN;
4928 else if (unformat (i, "forward"))
4929 feature_bitmap |= L2INPUT_FEAT_FWD;
4930 else if (unformat (i, "flood"))
4931 feature_bitmap |= L2INPUT_FEAT_FLOOD;
4932 else if (unformat (i, "uu-flood"))
4933 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
4938 if (sw_if_index_set == 0)
4940 errmsg ("missing interface name or sw_if_index\n");
4944 M (L2_FLAGS, l2_flags);
4946 mp->sw_if_index = ntohl (sw_if_index);
4947 mp->feature_bitmap = ntohl (feature_bitmap);
4956 api_bridge_flags (vat_main_t * vam)
4958 unformat_input_t *i = vam->input;
4959 vl_api_bridge_flags_t *mp;
4966 /* Parse args required to build the message */
4967 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4969 if (unformat (i, "bd_id %d", &bd_id))
4971 else if (unformat (i, "learn"))
4973 else if (unformat (i, "forward"))
4975 else if (unformat (i, "flood"))
4977 else if (unformat (i, "uu-flood"))
4978 flags |= L2_UU_FLOOD;
4979 else if (unformat (i, "arp-term"))
4980 flags |= L2_ARP_TERM;
4981 else if (unformat (i, "off"))
4983 else if (unformat (i, "disable"))
4991 errmsg ("missing bridge domain\n");
4995 M (BRIDGE_FLAGS, bridge_flags);
4997 mp->bd_id = ntohl (bd_id);
4998 mp->feature_bitmap = ntohl (flags);
4999 mp->is_set = is_set;
5008 api_bd_ip_mac_add_del (vat_main_t * vam)
5010 unformat_input_t *i = vam->input;
5011 vl_api_bd_ip_mac_add_del_t *mp;
5019 ip4_address_t v4addr;
5020 ip6_address_t v6addr;
5024 /* Parse args required to build the message */
5025 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5027 if (unformat (i, "bd_id %d", &bd_id))
5031 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
5035 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
5040 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
5044 else if (unformat (i, "del"))
5052 errmsg ("missing bridge domain\n");
5055 else if (ip_set == 0)
5057 errmsg ("missing IP address\n");
5060 else if (mac_set == 0)
5062 errmsg ("missing MAC address\n");
5066 M (BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del);
5068 mp->bd_id = ntohl (bd_id);
5069 mp->is_ipv6 = is_ipv6;
5070 mp->is_add = is_add;
5072 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
5074 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
5075 clib_memcpy (mp->mac_address, macaddr, 6);
5083 api_tap_connect (vat_main_t * vam)
5085 unformat_input_t *i = vam->input;
5086 vl_api_tap_connect_t *mp;
5093 memset (mac_address, 0, sizeof (mac_address));
5095 /* Parse args required to build the message */
5096 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5098 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5102 else if (unformat (i, "random-mac"))
5104 else if (unformat (i, "tapname %s", &tap_name))
5112 errmsg ("missing tap name\n");
5115 if (vec_len (tap_name) > 63)
5117 errmsg ("tap name too long\n");
5119 vec_add1 (tap_name, 0);
5121 /* Construct the API message */
5122 M (TAP_CONNECT, tap_connect);
5124 mp->use_random_mac = random_mac;
5125 clib_memcpy (mp->mac_address, mac_address, 6);
5126 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5127 vec_free (tap_name);
5132 /* Wait for a reply... */
5137 api_tap_modify (vat_main_t * vam)
5139 unformat_input_t *i = vam->input;
5140 vl_api_tap_modify_t *mp;
5146 u32 sw_if_index = ~0;
5147 u8 sw_if_index_set = 0;
5149 memset (mac_address, 0, sizeof (mac_address));
5151 /* Parse args required to build the message */
5152 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5154 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5155 sw_if_index_set = 1;
5156 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5157 sw_if_index_set = 1;
5158 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5162 else if (unformat (i, "random-mac"))
5164 else if (unformat (i, "tapname %s", &tap_name))
5170 if (sw_if_index_set == 0)
5172 errmsg ("missing vpp interface name");
5177 errmsg ("missing tap name\n");
5180 if (vec_len (tap_name) > 63)
5182 errmsg ("tap name too long\n");
5184 vec_add1 (tap_name, 0);
5186 /* Construct the API message */
5187 M (TAP_MODIFY, tap_modify);
5189 mp->use_random_mac = random_mac;
5190 mp->sw_if_index = ntohl (sw_if_index);
5191 clib_memcpy (mp->mac_address, mac_address, 6);
5192 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5193 vec_free (tap_name);
5198 /* Wait for a reply... */
5203 api_tap_delete (vat_main_t * vam)
5205 unformat_input_t *i = vam->input;
5206 vl_api_tap_delete_t *mp;
5208 u32 sw_if_index = ~0;
5209 u8 sw_if_index_set = 0;
5211 /* Parse args required to build the message */
5212 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5214 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5215 sw_if_index_set = 1;
5216 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5217 sw_if_index_set = 1;
5222 if (sw_if_index_set == 0)
5224 errmsg ("missing vpp interface name");
5228 /* Construct the API message */
5229 M (TAP_DELETE, tap_delete);
5231 mp->sw_if_index = ntohl (sw_if_index);
5236 /* Wait for a reply... */
5241 api_ip_add_del_route (vat_main_t * vam)
5243 unformat_input_t *i = vam->input;
5244 vl_api_ip_add_del_route_t *mp;
5246 u32 sw_if_index = ~0, vrf_id = 0;
5247 u8 sw_if_index_set = 0;
5249 u8 is_local = 0, is_drop = 0;
5250 u8 create_vrf_if_needed = 0;
5252 u8 next_hop_weight = 1;
5254 u8 is_multipath = 0;
5256 u8 address_length_set = 0;
5257 u32 lookup_in_vrf = 0;
5258 u32 resolve_attempts = 0;
5259 u32 dst_address_length = 0;
5260 u8 next_hop_set = 0;
5261 ip4_address_t v4_dst_address, v4_next_hop_address;
5262 ip6_address_t v6_dst_address, v6_next_hop_address;
5266 u32 random_add_del = 0;
5267 u32 *random_vector = 0;
5269 u32 random_seed = 0xdeaddabe;
5270 u32 classify_table_index = ~0;
5273 /* Parse args required to build the message */
5274 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5276 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5277 sw_if_index_set = 1;
5278 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5279 sw_if_index_set = 1;
5280 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
5285 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
5290 else if (unformat (i, "/%d", &dst_address_length))
5292 address_length_set = 1;
5295 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
5296 &v4_next_hop_address))
5300 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
5301 &v6_next_hop_address))
5305 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
5307 else if (unformat (i, "weight %d", &next_hop_weight))
5309 else if (unformat (i, "drop"))
5313 else if (unformat (i, "local"))
5317 else if (unformat (i, "classify %d", &classify_table_index))
5321 else if (unformat (i, "del"))
5323 else if (unformat (i, "add"))
5325 else if (unformat (i, "not-last"))
5327 else if (unformat (i, "multipath"))
5329 else if (unformat (i, "vrf %d", &vrf_id))
5331 else if (unformat (i, "create-vrf"))
5332 create_vrf_if_needed = 1;
5333 else if (unformat (i, "count %d", &count))
5335 else if (unformat (i, "lookup-in-vrf %d", &lookup_in_vrf))
5337 else if (unformat (i, "random"))
5339 else if (unformat (i, "seed %d", &random_seed))
5343 clib_warning ("parse error '%U'", format_unformat_error, i);
5348 if (resolve_attempts > 0 && sw_if_index_set == 0)
5350 errmsg ("ARP resolution needs explicit interface or sw_if_index\n");
5354 if (!next_hop_set && !is_drop && !is_local && !is_classify)
5356 errmsg ("next hop / local / drop / classify not set\n");
5360 if (address_set == 0)
5362 errmsg ("missing addresses\n");
5366 if (address_length_set == 0)
5368 errmsg ("missing address length\n");
5372 /* Generate a pile of unique, random routes */
5375 u32 this_random_address;
5376 random_hash = hash_create (count, sizeof (uword));
5378 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
5379 for (j = 0; j <= count; j++)
5383 this_random_address = random_u32 (&random_seed);
5384 this_random_address =
5385 clib_host_to_net_u32 (this_random_address);
5387 while (hash_get (random_hash, this_random_address));
5388 vec_add1 (random_vector, this_random_address);
5389 hash_set (random_hash, this_random_address, 1);
5391 hash_free (random_hash);
5392 v4_dst_address.as_u32 = random_vector[0];
5397 /* Turn on async mode */
5398 vam->async_mode = 1;
5399 vam->async_errors = 0;
5400 before = vat_time_now (vam);
5403 for (j = 0; j < count; j++)
5405 /* Construct the API message */
5406 M (IP_ADD_DEL_ROUTE, ip_add_del_route);
5408 mp->next_hop_sw_if_index = ntohl (sw_if_index);
5409 mp->vrf_id = ntohl (vrf_id);
5410 if (resolve_attempts > 0)
5412 mp->resolve_attempts = ntohl (resolve_attempts);
5413 mp->resolve_if_needed = 1;
5415 mp->create_vrf_if_needed = create_vrf_if_needed;
5417 mp->is_add = is_add;
5418 mp->is_drop = is_drop;
5419 mp->is_ipv6 = is_ipv6;
5420 mp->is_local = is_local;
5421 mp->is_classify = is_classify;
5422 mp->is_multipath = is_multipath;
5423 mp->not_last = not_last;
5424 mp->next_hop_weight = next_hop_weight;
5425 mp->dst_address_length = dst_address_length;
5426 mp->lookup_in_vrf = ntohl (lookup_in_vrf);
5427 mp->classify_table_index = ntohl (classify_table_index);
5431 clib_memcpy (mp->dst_address, &v6_dst_address,
5432 sizeof (v6_dst_address));
5434 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
5435 sizeof (v6_next_hop_address));
5436 increment_v6_address (&v6_dst_address);
5440 clib_memcpy (mp->dst_address, &v4_dst_address,
5441 sizeof (v4_dst_address));
5443 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
5444 sizeof (v4_next_hop_address));
5446 v4_dst_address.as_u32 = random_vector[j + 1];
5448 increment_v4_address (&v4_dst_address);
5454 /* When testing multiple add/del ops, use a control-ping to sync */
5457 vl_api_control_ping_t *mp;
5460 /* Shut off async mode */
5461 vam->async_mode = 0;
5463 M (CONTROL_PING, control_ping);
5466 timeout = vat_time_now (vam) + 1.0;
5467 while (vat_time_now (vam) < timeout)
5468 if (vam->result_ready == 1)
5473 if (vam->retval == -99)
5474 errmsg ("timeout\n");
5476 if (vam->async_errors > 0)
5478 errmsg ("%d asynchronous errors\n", vam->async_errors);
5481 vam->async_errors = 0;
5482 after = vat_time_now (vam);
5484 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
5485 count, after - before, count / (after - before));
5489 /* Wait for a reply... */
5493 /* Return the good/bad news */
5494 return (vam->retval);
5498 api_proxy_arp_add_del (vat_main_t * vam)
5500 unformat_input_t *i = vam->input;
5501 vl_api_proxy_arp_add_del_t *mp;
5505 ip4_address_t lo, hi;
5508 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5510 if (unformat (i, "vrf %d", &vrf_id))
5512 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
5513 unformat_ip4_address, &hi))
5515 else if (unformat (i, "del"))
5519 clib_warning ("parse error '%U'", format_unformat_error, i);
5526 errmsg ("address range not set\n");
5530 M (PROXY_ARP_ADD_DEL, proxy_arp_add_del);
5532 mp->vrf_id = ntohl (vrf_id);
5533 mp->is_add = is_add;
5534 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
5535 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
5544 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
5546 unformat_input_t *i = vam->input;
5547 vl_api_proxy_arp_intfc_enable_disable_t *mp;
5551 u8 sw_if_index_set = 0;
5553 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5555 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5556 sw_if_index_set = 1;
5557 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5558 sw_if_index_set = 1;
5559 else if (unformat (i, "enable"))
5561 else if (unformat (i, "disable"))
5565 clib_warning ("parse error '%U'", format_unformat_error, i);
5570 if (sw_if_index_set == 0)
5572 errmsg ("missing interface name or sw_if_index\n");
5576 M (PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable);
5578 mp->sw_if_index = ntohl (sw_if_index);
5579 mp->enable_disable = enable;
5588 api_mpls_add_del_decap (vat_main_t * vam)
5590 unformat_input_t *i = vam->input;
5591 vl_api_mpls_add_del_decap_t *mp;
5600 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5602 if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
5604 else if (unformat (i, "tx_vrf_id %d", &tx_vrf_id))
5606 else if (unformat (i, "label %d", &label))
5608 else if (unformat (i, "next-index %d", &next_index))
5610 else if (unformat (i, "del"))
5612 else if (unformat (i, "s-bit-clear"))
5616 clib_warning ("parse error '%U'", format_unformat_error, i);
5621 M (MPLS_ADD_DEL_DECAP, mpls_add_del_decap);
5623 mp->rx_vrf_id = ntohl (rx_vrf_id);
5624 mp->tx_vrf_id = ntohl (tx_vrf_id);
5625 mp->label = ntohl (label);
5626 mp->next_index = ntohl (next_index);
5628 mp->is_add = is_add;
5637 api_mpls_add_del_encap (vat_main_t * vam)
5639 unformat_input_t *i = vam->input;
5640 vl_api_mpls_add_del_encap_t *mp;
5645 ip4_address_t dst_address;
5648 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5650 if (unformat (i, "vrf %d", &vrf_id))
5652 else if (unformat (i, "label %d", &label))
5653 vec_add1 (labels, ntohl (label));
5654 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
5656 else if (unformat (i, "del"))
5660 clib_warning ("parse error '%U'", format_unformat_error, i);
5665 if (vec_len (labels) == 0)
5667 errmsg ("missing encap label stack\n");
5671 M2 (MPLS_ADD_DEL_ENCAP, mpls_add_del_encap,
5672 sizeof (u32) * vec_len (labels));
5674 mp->vrf_id = ntohl (vrf_id);
5675 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
5676 mp->is_add = is_add;
5677 mp->nlabels = vec_len (labels);
5678 clib_memcpy (mp->labels, labels, sizeof (u32) * mp->nlabels);
5689 api_mpls_gre_add_del_tunnel (vat_main_t * vam)
5691 unformat_input_t *i = vam->input;
5692 vl_api_mpls_gre_add_del_tunnel_t *mp;
5694 u32 inner_vrf_id = 0;
5695 u32 outer_vrf_id = 0;
5696 ip4_address_t src_address;
5697 ip4_address_t dst_address;
5698 ip4_address_t intfc_address;
5700 u8 intfc_address_length = 0;
5704 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5706 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
5708 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
5710 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
5712 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
5714 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
5715 &intfc_address, &tmp))
5716 intfc_address_length = tmp;
5717 else if (unformat (i, "l2-only"))
5719 else if (unformat (i, "del"))
5723 clib_warning ("parse error '%U'", format_unformat_error, i);
5728 M (MPLS_GRE_ADD_DEL_TUNNEL, mpls_gre_add_del_tunnel);
5730 mp->inner_vrf_id = ntohl (inner_vrf_id);
5731 mp->outer_vrf_id = ntohl (outer_vrf_id);
5732 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
5733 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
5734 clib_memcpy (mp->intfc_address, &intfc_address, sizeof (intfc_address));
5735 mp->intfc_address_length = intfc_address_length;
5736 mp->l2_only = l2_only;
5737 mp->is_add = is_add;
5746 api_mpls_ethernet_add_del_tunnel (vat_main_t * vam)
5748 unformat_input_t *i = vam->input;
5749 vl_api_mpls_ethernet_add_del_tunnel_t *mp;
5751 u32 inner_vrf_id = 0;
5752 ip4_address_t intfc_address;
5753 u8 dst_mac_address[6];
5756 u8 intfc_address_length = 0;
5760 int tx_sw_if_index_set = 0;
5762 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5764 if (unformat (i, "vrf %d", &inner_vrf_id))
5766 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
5767 &intfc_address, &tmp))
5768 intfc_address_length = tmp;
5769 else if (unformat (i, "%U", unformat_sw_if_index, vam, &tx_sw_if_index))
5770 tx_sw_if_index_set = 1;
5771 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5772 tx_sw_if_index_set = 1;
5773 else if (unformat (i, "dst %U", unformat_ethernet_address,
5776 else if (unformat (i, "l2-only"))
5778 else if (unformat (i, "del"))
5782 clib_warning ("parse error '%U'", format_unformat_error, i);
5789 errmsg ("dst (mac address) not set\n");
5792 if (!tx_sw_if_index_set)
5794 errmsg ("tx-intfc not set\n");
5798 M (MPLS_ETHERNET_ADD_DEL_TUNNEL, mpls_ethernet_add_del_tunnel);
5800 mp->vrf_id = ntohl (inner_vrf_id);
5801 clib_memcpy (mp->adj_address, &intfc_address, sizeof (intfc_address));
5802 mp->adj_address_length = intfc_address_length;
5803 clib_memcpy (mp->dst_mac_address, dst_mac_address,
5804 sizeof (dst_mac_address));
5805 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
5806 mp->l2_only = l2_only;
5807 mp->is_add = is_add;
5816 api_mpls_ethernet_add_del_tunnel_2 (vat_main_t * vam)
5818 unformat_input_t *i = vam->input;
5819 vl_api_mpls_ethernet_add_del_tunnel_2_t *mp;
5821 u32 inner_vrf_id = 0;
5822 u32 outer_vrf_id = 0;
5823 ip4_address_t adj_address;
5824 int adj_address_set = 0;
5825 ip4_address_t next_hop_address;
5826 int next_hop_address_set = 0;
5828 u8 adj_address_length = 0;
5831 u32 resolve_attempts = 5;
5832 u8 resolve_if_needed = 1;
5834 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5836 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
5838 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
5840 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
5841 &adj_address, &tmp))
5843 adj_address_length = tmp;
5844 adj_address_set = 1;
5846 else if (unformat (i, "next-hop %U", unformat_ip4_address,
5848 next_hop_address_set = 1;
5849 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
5851 else if (unformat (i, "resolve-if-needed %d", &tmp))
5852 resolve_if_needed = tmp;
5853 else if (unformat (i, "l2-only"))
5855 else if (unformat (i, "del"))
5859 clib_warning ("parse error '%U'", format_unformat_error, i);
5864 if (!adj_address_set)
5866 errmsg ("adjacency address/mask not set\n");
5869 if (!next_hop_address_set)
5871 errmsg ("ip4 next hop address (in outer fib) not set\n");
5875 M (MPLS_ETHERNET_ADD_DEL_TUNNEL_2, mpls_ethernet_add_del_tunnel_2);
5877 mp->inner_vrf_id = ntohl (inner_vrf_id);
5878 mp->outer_vrf_id = ntohl (outer_vrf_id);
5879 mp->resolve_attempts = ntohl (resolve_attempts);
5880 mp->resolve_if_needed = resolve_if_needed;
5881 mp->is_add = is_add;
5882 mp->l2_only = l2_only;
5883 clib_memcpy (mp->adj_address, &adj_address, sizeof (adj_address));
5884 mp->adj_address_length = adj_address_length;
5885 clib_memcpy (mp->next_hop_ip4_address_in_outer_vrf, &next_hop_address,
5886 sizeof (next_hop_address));
5895 api_sw_interface_set_unnumbered (vat_main_t * vam)
5897 unformat_input_t *i = vam->input;
5898 vl_api_sw_interface_set_unnumbered_t *mp;
5901 u32 unnum_sw_index = ~0;
5903 u8 sw_if_index_set = 0;
5905 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5907 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5908 sw_if_index_set = 1;
5909 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5910 sw_if_index_set = 1;
5911 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
5913 else if (unformat (i, "del"))
5917 clib_warning ("parse error '%U'", format_unformat_error, i);
5922 if (sw_if_index_set == 0)
5924 errmsg ("missing interface name or sw_if_index\n");
5928 M (SW_INTERFACE_SET_UNNUMBERED, sw_interface_set_unnumbered);
5930 mp->sw_if_index = ntohl (sw_if_index);
5931 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
5932 mp->is_add = is_add;
5941 api_ip_neighbor_add_del (vat_main_t * vam)
5943 unformat_input_t *i = vam->input;
5944 vl_api_ip_neighbor_add_del_t *mp;
5947 u8 sw_if_index_set = 0;
5953 u8 v4_address_set = 0;
5954 u8 v6_address_set = 0;
5955 ip4_address_t v4address;
5956 ip6_address_t v6address;
5958 memset (mac_address, 0, sizeof (mac_address));
5960 /* Parse args required to build the message */
5961 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5963 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5967 else if (unformat (i, "del"))
5969 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5970 sw_if_index_set = 1;
5971 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5972 sw_if_index_set = 1;
5973 else if (unformat (i, "is_static"))
5975 else if (unformat (i, "vrf %d", &vrf_id))
5977 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
5979 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
5983 clib_warning ("parse error '%U'", format_unformat_error, i);
5988 if (sw_if_index_set == 0)
5990 errmsg ("missing interface name or sw_if_index\n");
5993 if (v4_address_set && v6_address_set)
5995 errmsg ("both v4 and v6 addresses set\n");
5998 if (!v4_address_set && !v6_address_set)
6000 errmsg ("no address set\n");
6004 /* Construct the API message */
6005 M (IP_NEIGHBOR_ADD_DEL, ip_neighbor_add_del);
6007 mp->sw_if_index = ntohl (sw_if_index);
6008 mp->is_add = is_add;
6009 mp->vrf_id = ntohl (vrf_id);
6010 mp->is_static = is_static;
6012 clib_memcpy (mp->mac_address, mac_address, 6);
6016 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
6020 /* mp->is_ipv6 = 0; via memset in M macro above */
6021 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
6027 /* Wait for a reply, return good/bad news */
6035 api_reset_vrf (vat_main_t * vam)
6037 unformat_input_t *i = vam->input;
6038 vl_api_reset_vrf_t *mp;
6044 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6046 if (unformat (i, "vrf %d", &vrf_id))
6048 else if (unformat (i, "ipv6"))
6052 clib_warning ("parse error '%U'", format_unformat_error, i);
6057 if (vrf_id_set == 0)
6059 errmsg ("missing vrf id\n");
6063 M (RESET_VRF, reset_vrf);
6065 mp->vrf_id = ntohl (vrf_id);
6066 mp->is_ipv6 = is_ipv6;
6075 api_create_vlan_subif (vat_main_t * vam)
6077 unformat_input_t *i = vam->input;
6078 vl_api_create_vlan_subif_t *mp;
6081 u8 sw_if_index_set = 0;
6085 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6087 if (unformat (i, "sw_if_index %d", &sw_if_index))
6088 sw_if_index_set = 1;
6089 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6090 sw_if_index_set = 1;
6091 else if (unformat (i, "vlan %d", &vlan_id))
6095 clib_warning ("parse error '%U'", format_unformat_error, i);
6100 if (sw_if_index_set == 0)
6102 errmsg ("missing interface name or sw_if_index\n");
6106 if (vlan_id_set == 0)
6108 errmsg ("missing vlan_id\n");
6111 M (CREATE_VLAN_SUBIF, create_vlan_subif);
6113 mp->sw_if_index = ntohl (sw_if_index);
6114 mp->vlan_id = ntohl (vlan_id);
6122 #define foreach_create_subif_bit \
6129 _(outer_vlan_id_any) \
6130 _(inner_vlan_id_any)
6133 api_create_subif (vat_main_t * vam)
6135 unformat_input_t *i = vam->input;
6136 vl_api_create_subif_t *mp;
6139 u8 sw_if_index_set = 0;
6146 u32 exact_match = 0;
6147 u32 default_sub = 0;
6148 u32 outer_vlan_id_any = 0;
6149 u32 inner_vlan_id_any = 0;
6151 u16 outer_vlan_id = 0;
6152 u16 inner_vlan_id = 0;
6154 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6156 if (unformat (i, "sw_if_index %d", &sw_if_index))
6157 sw_if_index_set = 1;
6158 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6159 sw_if_index_set = 1;
6160 else if (unformat (i, "sub_id %d", &sub_id))
6162 else if (unformat (i, "outer_vlan_id %d", &tmp))
6163 outer_vlan_id = tmp;
6164 else if (unformat (i, "inner_vlan_id %d", &tmp))
6165 inner_vlan_id = tmp;
6167 #define _(a) else if (unformat (i, #a)) a = 1 ;
6168 foreach_create_subif_bit
6172 clib_warning ("parse error '%U'", format_unformat_error, i);
6177 if (sw_if_index_set == 0)
6179 errmsg ("missing interface name or sw_if_index\n");
6183 if (sub_id_set == 0)
6185 errmsg ("missing sub_id\n");
6188 M (CREATE_SUBIF, create_subif);
6190 mp->sw_if_index = ntohl (sw_if_index);
6191 mp->sub_id = ntohl (sub_id);
6193 #define _(a) mp->a = a;
6194 foreach_create_subif_bit;
6197 mp->outer_vlan_id = ntohs (outer_vlan_id);
6198 mp->inner_vlan_id = ntohs (inner_vlan_id);
6207 api_oam_add_del (vat_main_t * vam)
6209 unformat_input_t *i = vam->input;
6210 vl_api_oam_add_del_t *mp;
6214 ip4_address_t src, dst;
6218 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6220 if (unformat (i, "vrf %d", &vrf_id))
6222 else if (unformat (i, "src %U", unformat_ip4_address, &src))
6224 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
6226 else if (unformat (i, "del"))
6230 clib_warning ("parse error '%U'", format_unformat_error, i);
6237 errmsg ("missing src addr\n");
6243 errmsg ("missing dst addr\n");
6247 M (OAM_ADD_DEL, oam_add_del);
6249 mp->vrf_id = ntohl (vrf_id);
6250 mp->is_add = is_add;
6251 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
6252 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
6261 api_reset_fib (vat_main_t * vam)
6263 unformat_input_t *i = vam->input;
6264 vl_api_reset_fib_t *mp;
6270 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6272 if (unformat (i, "vrf %d", &vrf_id))
6274 else if (unformat (i, "ipv6"))
6278 clib_warning ("parse error '%U'", format_unformat_error, i);
6283 if (vrf_id_set == 0)
6285 errmsg ("missing vrf id\n");
6289 M (RESET_FIB, reset_fib);
6291 mp->vrf_id = ntohl (vrf_id);
6292 mp->is_ipv6 = is_ipv6;
6301 api_dhcp_proxy_config (vat_main_t * vam)
6303 unformat_input_t *i = vam->input;
6304 vl_api_dhcp_proxy_config_t *mp;
6309 u8 v4_address_set = 0;
6310 u8 v6_address_set = 0;
6311 ip4_address_t v4address;
6312 ip6_address_t v6address;
6313 u8 v4_src_address_set = 0;
6314 u8 v6_src_address_set = 0;
6315 ip4_address_t v4srcaddress;
6316 ip6_address_t v6srcaddress;
6318 /* Parse args required to build the message */
6319 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6321 if (unformat (i, "del"))
6323 else if (unformat (i, "vrf %d", &vrf_id))
6325 else if (unformat (i, "insert-cid %d", &insert_cid))
6327 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
6329 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
6331 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
6332 v4_src_address_set = 1;
6333 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
6334 v6_src_address_set = 1;
6339 if (v4_address_set && v6_address_set)
6341 errmsg ("both v4 and v6 server addresses set\n");
6344 if (!v4_address_set && !v6_address_set)
6346 errmsg ("no server addresses set\n");
6350 if (v4_src_address_set && v6_src_address_set)
6352 errmsg ("both v4 and v6 src addresses set\n");
6355 if (!v4_src_address_set && !v6_src_address_set)
6357 errmsg ("no src addresses set\n");
6361 if (!(v4_src_address_set && v4_address_set) &&
6362 !(v6_src_address_set && v6_address_set))
6364 errmsg ("no matching server and src addresses set\n");
6368 /* Construct the API message */
6369 M (DHCP_PROXY_CONFIG, dhcp_proxy_config);
6371 mp->insert_circuit_id = insert_cid;
6372 mp->is_add = is_add;
6373 mp->vrf_id = ntohl (vrf_id);
6377 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
6378 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
6382 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
6383 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
6389 /* Wait for a reply, return good/bad news */
6396 api_dhcp_proxy_config_2 (vat_main_t * vam)
6398 unformat_input_t *i = vam->input;
6399 vl_api_dhcp_proxy_config_2_t *mp;
6402 u32 server_vrf_id = 0;
6405 u8 v4_address_set = 0;
6406 u8 v6_address_set = 0;
6407 ip4_address_t v4address;
6408 ip6_address_t v6address;
6409 u8 v4_src_address_set = 0;
6410 u8 v6_src_address_set = 0;
6411 ip4_address_t v4srcaddress;
6412 ip6_address_t v6srcaddress;
6414 /* Parse args required to build the message */
6415 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6417 if (unformat (i, "del"))
6419 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
6421 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
6423 else if (unformat (i, "insert-cid %d", &insert_cid))
6425 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
6427 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
6429 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
6430 v4_src_address_set = 1;
6431 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
6432 v6_src_address_set = 1;
6437 if (v4_address_set && v6_address_set)
6439 errmsg ("both v4 and v6 server addresses set\n");
6442 if (!v4_address_set && !v6_address_set)
6444 errmsg ("no server addresses set\n");
6448 if (v4_src_address_set && v6_src_address_set)
6450 errmsg ("both v4 and v6 src addresses set\n");
6453 if (!v4_src_address_set && !v6_src_address_set)
6455 errmsg ("no src addresses set\n");
6459 if (!(v4_src_address_set && v4_address_set) &&
6460 !(v6_src_address_set && v6_address_set))
6462 errmsg ("no matching server and src addresses set\n");
6466 /* Construct the API message */
6467 M (DHCP_PROXY_CONFIG_2, dhcp_proxy_config_2);
6469 mp->insert_circuit_id = insert_cid;
6470 mp->is_add = is_add;
6471 mp->rx_vrf_id = ntohl (rx_vrf_id);
6472 mp->server_vrf_id = ntohl (server_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_set_vss (vat_main_t * vam)
6497 unformat_input_t *i = vam->input;
6498 vl_api_dhcp_proxy_set_vss_t *mp;
6509 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6511 if (unformat (i, "tbl_id %d", &tbl_id))
6513 if (unformat (i, "fib_id %d", &fib_id))
6515 if (unformat (i, "oui %d", &oui))
6517 else if (unformat (i, "ipv6"))
6519 else if (unformat (i, "del"))
6523 clib_warning ("parse error '%U'", format_unformat_error, i);
6528 if (tbl_id_set == 0)
6530 errmsg ("missing tbl id\n");
6534 if (fib_id_set == 0)
6536 errmsg ("missing fib id\n");
6541 errmsg ("missing oui\n");
6545 M (DHCP_PROXY_SET_VSS, dhcp_proxy_set_vss);
6546 mp->tbl_id = ntohl (tbl_id);
6547 mp->fib_id = ntohl (fib_id);
6548 mp->oui = ntohl (oui);
6549 mp->is_ipv6 = is_ipv6;
6550 mp->is_add = is_add;
6559 api_dhcp_client_config (vat_main_t * vam)
6561 unformat_input_t *i = vam->input;
6562 vl_api_dhcp_client_config_t *mp;
6565 u8 sw_if_index_set = 0;
6568 u8 disable_event = 0;
6570 /* Parse args required to build the message */
6571 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6573 if (unformat (i, "del"))
6575 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6576 sw_if_index_set = 1;
6577 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6578 sw_if_index_set = 1;
6579 else if (unformat (i, "hostname %s", &hostname))
6581 else if (unformat (i, "disable_event"))
6587 if (sw_if_index_set == 0)
6589 errmsg ("missing interface name or sw_if_index\n");
6593 if (vec_len (hostname) > 63)
6595 errmsg ("hostname too long\n");
6597 vec_add1 (hostname, 0);
6599 /* Construct the API message */
6600 M (DHCP_CLIENT_CONFIG, dhcp_client_config);
6602 mp->sw_if_index = ntohl (sw_if_index);
6603 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
6604 vec_free (hostname);
6605 mp->is_add = is_add;
6606 mp->want_dhcp_event = disable_event ? 0 : 1;
6607 mp->pid = getpid ();
6612 /* Wait for a reply, return good/bad news */
6619 api_set_ip_flow_hash (vat_main_t * vam)
6621 unformat_input_t *i = vam->input;
6622 vl_api_set_ip_flow_hash_t *mp;
6634 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6636 if (unformat (i, "vrf %d", &vrf_id))
6638 else if (unformat (i, "ipv6"))
6640 else if (unformat (i, "src"))
6642 else if (unformat (i, "dst"))
6644 else if (unformat (i, "sport"))
6646 else if (unformat (i, "dport"))
6648 else if (unformat (i, "proto"))
6650 else if (unformat (i, "reverse"))
6655 clib_warning ("parse error '%U'", format_unformat_error, i);
6660 if (vrf_id_set == 0)
6662 errmsg ("missing vrf id\n");
6666 M (SET_IP_FLOW_HASH, set_ip_flow_hash);
6672 mp->reverse = reverse;
6673 mp->vrf_id = ntohl (vrf_id);
6674 mp->is_ipv6 = is_ipv6;
6683 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
6685 unformat_input_t *i = vam->input;
6686 vl_api_sw_interface_ip6_enable_disable_t *mp;
6689 u8 sw_if_index_set = 0;
6692 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6694 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6695 sw_if_index_set = 1;
6696 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6697 sw_if_index_set = 1;
6698 else if (unformat (i, "enable"))
6700 else if (unformat (i, "disable"))
6704 clib_warning ("parse error '%U'", format_unformat_error, i);
6709 if (sw_if_index_set == 0)
6711 errmsg ("missing interface name or sw_if_index\n");
6715 M (SW_INTERFACE_IP6_ENABLE_DISABLE, sw_interface_ip6_enable_disable);
6717 mp->sw_if_index = ntohl (sw_if_index);
6718 mp->enable = enable;
6727 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
6729 unformat_input_t *i = vam->input;
6730 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
6733 u8 sw_if_index_set = 0;
6734 u32 address_length = 0;
6735 u8 v6_address_set = 0;
6736 ip6_address_t v6address;
6738 /* Parse args required to build the message */
6739 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6741 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6742 sw_if_index_set = 1;
6743 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6744 sw_if_index_set = 1;
6745 else if (unformat (i, "%U/%d",
6746 unformat_ip6_address, &v6address, &address_length))
6752 if (sw_if_index_set == 0)
6754 errmsg ("missing interface name or sw_if_index\n");
6757 if (!v6_address_set)
6759 errmsg ("no address set\n");
6763 /* Construct the API message */
6764 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS,
6765 sw_interface_ip6_set_link_local_address);
6767 mp->sw_if_index = ntohl (sw_if_index);
6768 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6769 mp->address_length = address_length;
6774 /* Wait for a reply, return good/bad news */
6783 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
6785 unformat_input_t *i = vam->input;
6786 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
6789 u8 sw_if_index_set = 0;
6790 u32 address_length = 0;
6791 u8 v6_address_set = 0;
6792 ip6_address_t v6address;
6794 u8 no_advertise = 0;
6796 u8 no_autoconfig = 0;
6799 u32 val_lifetime = 0;
6800 u32 pref_lifetime = 0;
6802 /* Parse args required to build the message */
6803 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6805 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6806 sw_if_index_set = 1;
6807 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6808 sw_if_index_set = 1;
6809 else if (unformat (i, "%U/%d",
6810 unformat_ip6_address, &v6address, &address_length))
6812 else if (unformat (i, "val_life %d", &val_lifetime))
6814 else if (unformat (i, "pref_life %d", &pref_lifetime))
6816 else if (unformat (i, "def"))
6818 else if (unformat (i, "noadv"))
6820 else if (unformat (i, "offl"))
6822 else if (unformat (i, "noauto"))
6824 else if (unformat (i, "nolink"))
6826 else if (unformat (i, "isno"))
6830 clib_warning ("parse error '%U'", format_unformat_error, i);
6835 if (sw_if_index_set == 0)
6837 errmsg ("missing interface name or sw_if_index\n");
6840 if (!v6_address_set)
6842 errmsg ("no address set\n");
6846 /* Construct the API message */
6847 M (SW_INTERFACE_IP6ND_RA_PREFIX, sw_interface_ip6nd_ra_prefix);
6849 mp->sw_if_index = ntohl (sw_if_index);
6850 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6851 mp->address_length = address_length;
6852 mp->use_default = use_default;
6853 mp->no_advertise = no_advertise;
6854 mp->off_link = off_link;
6855 mp->no_autoconfig = no_autoconfig;
6856 mp->no_onlink = no_onlink;
6858 mp->val_lifetime = ntohl (val_lifetime);
6859 mp->pref_lifetime = ntohl (pref_lifetime);
6864 /* Wait for a reply, return good/bad news */
6872 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
6874 unformat_input_t *i = vam->input;
6875 vl_api_sw_interface_ip6nd_ra_config_t *mp;
6878 u8 sw_if_index_set = 0;
6883 u8 send_unicast = 0;
6886 u8 default_router = 0;
6887 u32 max_interval = 0;
6888 u32 min_interval = 0;
6890 u32 initial_count = 0;
6891 u32 initial_interval = 0;
6894 /* Parse args required to build the message */
6895 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6897 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6898 sw_if_index_set = 1;
6899 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6900 sw_if_index_set = 1;
6901 else if (unformat (i, "maxint %d", &max_interval))
6903 else if (unformat (i, "minint %d", &min_interval))
6905 else if (unformat (i, "life %d", &lifetime))
6907 else if (unformat (i, "count %d", &initial_count))
6909 else if (unformat (i, "interval %d", &initial_interval))
6911 else if (unformat (i, "suppress") || unformat (i, "surpress"))
6913 else if (unformat (i, "managed"))
6915 else if (unformat (i, "other"))
6917 else if (unformat (i, "ll"))
6919 else if (unformat (i, "send"))
6921 else if (unformat (i, "cease"))
6923 else if (unformat (i, "isno"))
6925 else if (unformat (i, "def"))
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");
6940 /* Construct the API message */
6941 M (SW_INTERFACE_IP6ND_RA_CONFIG, sw_interface_ip6nd_ra_config);
6943 mp->sw_if_index = ntohl (sw_if_index);
6944 mp->max_interval = ntohl (max_interval);
6945 mp->min_interval = ntohl (min_interval);
6946 mp->lifetime = ntohl (lifetime);
6947 mp->initial_count = ntohl (initial_count);
6948 mp->initial_interval = ntohl (initial_interval);
6949 mp->suppress = suppress;
6950 mp->managed = managed;
6952 mp->ll_option = ll_option;
6953 mp->send_unicast = send_unicast;
6956 mp->default_router = default_router;
6961 /* Wait for a reply, return good/bad news */
6969 api_set_arp_neighbor_limit (vat_main_t * vam)
6971 unformat_input_t *i = vam->input;
6972 vl_api_set_arp_neighbor_limit_t *mp;
6978 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6980 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
6982 else if (unformat (i, "ipv6"))
6986 clib_warning ("parse error '%U'", format_unformat_error, i);
6993 errmsg ("missing limit value\n");
6997 M (SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit);
6999 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
7000 mp->is_ipv6 = is_ipv6;
7009 api_l2_patch_add_del (vat_main_t * vam)
7011 unformat_input_t *i = vam->input;
7012 vl_api_l2_patch_add_del_t *mp;
7015 u8 rx_sw_if_index_set = 0;
7017 u8 tx_sw_if_index_set = 0;
7020 /* Parse args required to build the message */
7021 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7023 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
7024 rx_sw_if_index_set = 1;
7025 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
7026 tx_sw_if_index_set = 1;
7027 else if (unformat (i, "rx"))
7029 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7031 if (unformat (i, "%U", unformat_sw_if_index, vam,
7033 rx_sw_if_index_set = 1;
7038 else if (unformat (i, "tx"))
7040 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7042 if (unformat (i, "%U", unformat_sw_if_index, vam,
7044 tx_sw_if_index_set = 1;
7049 else if (unformat (i, "del"))
7055 if (rx_sw_if_index_set == 0)
7057 errmsg ("missing rx interface name or rx_sw_if_index\n");
7061 if (tx_sw_if_index_set == 0)
7063 errmsg ("missing tx interface name or tx_sw_if_index\n");
7067 M (L2_PATCH_ADD_DEL, l2_patch_add_del);
7069 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
7070 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
7071 mp->is_add = is_add;
7080 api_trace_profile_add (vat_main_t * vam)
7082 unformat_input_t *input = vam->input;
7083 vl_api_trace_profile_add_t *mp;
7086 u32 trace_option_elts = 0;
7087 u32 trace_type = 0, node_id = 0, app_data = 0, trace_tsp = 2;
7088 int has_pow_option = 0;
7089 int has_ppc_option = 0;
7091 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7093 if (unformat (input, "id %d trace-type 0x%x trace-elts %d "
7094 "trace-tsp %d node-id 0x%x app-data 0x%x",
7095 &id, &trace_type, &trace_option_elts, &trace_tsp,
7096 &node_id, &app_data))
7098 else if (unformat (input, "pow"))
7100 else if (unformat (input, "ppc encap"))
7101 has_ppc_option = PPC_ENCAP;
7102 else if (unformat (input, "ppc decap"))
7103 has_ppc_option = PPC_DECAP;
7104 else if (unformat (input, "ppc none"))
7105 has_ppc_option = PPC_NONE;
7109 M (TRACE_PROFILE_ADD, trace_profile_add);
7110 mp->id = htons (id);
7111 mp->trace_type = trace_type;
7112 mp->trace_num_elt = trace_option_elts;
7113 mp->trace_ppc = has_ppc_option;
7114 mp->trace_app_data = htonl (app_data);
7115 mp->pow_enable = has_pow_option;
7116 mp->trace_tsp = trace_tsp;
7117 mp->node_id = htonl (node_id);
7127 api_trace_profile_apply (vat_main_t * vam)
7129 unformat_input_t *input = vam->input;
7130 vl_api_trace_profile_apply_t *mp;
7133 u32 mask_width = ~0;
7140 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7142 if (unformat (input, "%U/%d", unformat_ip6_address, &addr, &mask_width))
7144 else if (unformat (input, "id %d", &id))
7146 else if (unformat (input, "vrf-id %d", &vrf_id))
7148 else if (unformat (input, "add"))
7150 else if (unformat (input, "pop"))
7152 else if (unformat (input, "none"))
7158 if ((is_add + is_pop + is_none) != 1)
7160 errmsg ("One of (add, pop, none) required");
7163 if (mask_width == ~0)
7165 errmsg ("<address>/<mask-width> required");
7168 M (TRACE_PROFILE_APPLY, trace_profile_apply);
7169 clib_memcpy (mp->dest_ipv6, &addr, sizeof (mp->dest_ipv6));
7170 mp->id = htons (id);
7171 mp->prefix_length = htonl (mask_width);
7172 mp->vrf_id = htonl (vrf_id);
7174 mp->trace_op = IOAM_HBYH_ADD;
7176 mp->trace_op = IOAM_HBYH_POP;
7178 mp->trace_op = IOAM_HBYH_MOD;
7192 api_trace_profile_del (vat_main_t * vam)
7194 vl_api_trace_profile_del_t *mp;
7197 M (TRACE_PROFILE_DEL, trace_profile_del);
7204 api_sr_tunnel_add_del (vat_main_t * vam)
7206 unformat_input_t *i = vam->input;
7207 vl_api_sr_tunnel_add_del_t *mp;
7211 ip6_address_t src_address;
7212 int src_address_set = 0;
7213 ip6_address_t dst_address;
7215 int dst_address_set = 0;
7217 u32 rx_table_id = 0;
7218 u32 tx_table_id = 0;
7219 ip6_address_t *segments = 0;
7220 ip6_address_t *this_seg;
7221 ip6_address_t *tags = 0;
7222 ip6_address_t *this_tag;
7223 ip6_address_t next_address, tag;
7225 u8 *policy_name = 0;
7227 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7229 if (unformat (i, "del"))
7231 else if (unformat (i, "name %s", &name))
7233 else if (unformat (i, "policy %s", &policy_name))
7235 else if (unformat (i, "rx_fib_id %d", &rx_table_id))
7237 else if (unformat (i, "tx_fib_id %d", &tx_table_id))
7239 else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
7240 src_address_set = 1;
7241 else if (unformat (i, "dst %U/%d",
7242 unformat_ip6_address, &dst_address, &dst_mask_width))
7243 dst_address_set = 1;
7244 else if (unformat (i, "next %U", unformat_ip6_address, &next_address))
7246 vec_add2 (segments, this_seg, 1);
7247 clib_memcpy (this_seg->as_u8, next_address.as_u8,
7248 sizeof (*this_seg));
7250 else if (unformat (i, "tag %U", unformat_ip6_address, &tag))
7252 vec_add2 (tags, this_tag, 1);
7253 clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
7255 else if (unformat (i, "clean"))
7256 flags |= IP6_SR_HEADER_FLAG_CLEANUP;
7257 else if (unformat (i, "protected"))
7258 flags |= IP6_SR_HEADER_FLAG_PROTECTED;
7259 else if (unformat (i, "InPE %d", &pl_index))
7261 if (pl_index <= 0 || pl_index > 4)
7263 pl_index_range_error:
7264 errmsg ("pl index %d out of range\n", pl_index);
7268 IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE << (3 * (pl_index - 1));
7270 else if (unformat (i, "EgPE %d", &pl_index))
7272 if (pl_index <= 0 || pl_index > 4)
7273 goto pl_index_range_error;
7275 IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE << (3 * (pl_index - 1));
7277 else if (unformat (i, "OrgSrc %d", &pl_index))
7279 if (pl_index <= 0 || pl_index > 4)
7280 goto pl_index_range_error;
7282 IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3 * (pl_index - 1));
7288 if (!src_address_set)
7290 errmsg ("src address required\n");
7294 if (!dst_address_set)
7296 errmsg ("dst address required\n");
7302 errmsg ("at least one sr segment required\n");
7306 M2 (SR_TUNNEL_ADD_DEL, sr_tunnel_add_del,
7307 vec_len (segments) * sizeof (ip6_address_t)
7308 + vec_len (tags) * sizeof (ip6_address_t));
7310 clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
7311 clib_memcpy (mp->dst_address, &dst_address, sizeof (mp->dst_address));
7312 mp->dst_mask_width = dst_mask_width;
7313 mp->flags_net_byte_order = clib_host_to_net_u16 (flags);
7314 mp->n_segments = vec_len (segments);
7315 mp->n_tags = vec_len (tags);
7316 mp->is_add = is_del == 0;
7317 clib_memcpy (mp->segs_and_tags, segments,
7318 vec_len (segments) * sizeof (ip6_address_t));
7319 clib_memcpy (mp->segs_and_tags +
7320 vec_len (segments) * sizeof (ip6_address_t), tags,
7321 vec_len (tags) * sizeof (ip6_address_t));
7323 mp->outer_vrf_id = ntohl (rx_table_id);
7324 mp->inner_vrf_id = ntohl (tx_table_id);
7325 memcpy (mp->name, name, vec_len (name));
7326 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
7328 vec_free (segments);
7337 api_sr_policy_add_del (vat_main_t * vam)
7339 unformat_input_t *input = vam->input;
7340 vl_api_sr_policy_add_del_t *mp;
7344 u8 *tunnel_name = 0;
7345 u8 **tunnel_names = 0;
7350 int tunnel_names_length = 1; // Init to 1 to offset the #tunnel_names counter byte
7351 int tun_name_len = 0; // Different naming convention used as confusing these would be "bad" (TM)
7353 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7355 if (unformat (input, "del"))
7357 else if (unformat (input, "name %s", &name))
7359 else if (unformat (input, "tunnel %s", &tunnel_name))
7363 vec_add1 (tunnel_names, tunnel_name);
7365 - length = #bytes to store in serial vector
7366 - +1 = byte to store that length
7368 tunnel_names_length += (vec_len (tunnel_name) + 1);
7379 errmsg ("policy name required\n");
7383 if ((!tunnel_set) && (!is_del))
7385 errmsg ("tunnel name required\n");
7389 M2 (SR_POLICY_ADD_DEL, sr_policy_add_del, tunnel_names_length);
7393 mp->is_add = !is_del;
7395 memcpy (mp->name, name, vec_len (name));
7396 // Since mp->tunnel_names is of type u8[0] and not a u8 *, u8 ** needs to be serialized
7397 u8 *serial_orig = 0;
7398 vec_validate (serial_orig, tunnel_names_length);
7399 *serial_orig = vec_len (tunnel_names); // Store the number of tunnels as length in first byte of serialized vector
7400 serial_orig += 1; // Move along one byte to store the length of first tunnel_name
7402 for (j = 0; j < vec_len (tunnel_names); j++)
7404 tun_name_len = vec_len (tunnel_names[j]);
7405 *serial_orig = tun_name_len; // Store length of tunnel name in first byte of Length/Value pair
7406 serial_orig += 1; // Move along one byte to store the actual tunnel name
7407 memcpy (serial_orig, tunnel_names[j], tun_name_len);
7408 serial_orig += tun_name_len; // Advance past the copy
7410 memcpy (mp->tunnel_names, serial_orig - tunnel_names_length, tunnel_names_length); // Regress serial_orig to head then copy fwd
7412 vec_free (tunnel_names);
7413 vec_free (tunnel_name);
7421 api_sr_multicast_map_add_del (vat_main_t * vam)
7423 unformat_input_t *input = vam->input;
7424 vl_api_sr_multicast_map_add_del_t *mp;
7427 ip6_address_t multicast_address;
7428 u8 *policy_name = 0;
7429 int multicast_address_set = 0;
7431 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7433 if (unformat (input, "del"))
7437 (input, "address %U", unformat_ip6_address, &multicast_address))
7438 multicast_address_set = 1;
7439 else if (unformat (input, "sr-policy %s", &policy_name))
7445 if (!is_del && !policy_name)
7447 errmsg ("sr-policy name required\n");
7452 if (!multicast_address_set)
7454 errmsg ("address required\n");
7458 M (SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del);
7460 mp->is_add = !is_del;
7461 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
7462 clib_memcpy (mp->multicast_address, &multicast_address,
7463 sizeof (mp->multicast_address));
7466 vec_free (policy_name);
7474 #define foreach_ip4_proto_field \
7485 unformat_ip4_mask (unformat_input_t * input, va_list * args)
7487 u8 **maskp = va_arg (*args, u8 **);
7489 u8 found_something = 0;
7492 #define _(a) u8 a=0;
7493 foreach_ip4_proto_field;
7499 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7501 if (unformat (input, "version"))
7503 else if (unformat (input, "hdr_length"))
7505 else if (unformat (input, "src"))
7507 else if (unformat (input, "dst"))
7509 else if (unformat (input, "proto"))
7512 #define _(a) else if (unformat (input, #a)) a=1;
7513 foreach_ip4_proto_field
7519 #define _(a) found_something += a;
7520 foreach_ip4_proto_field;
7523 if (found_something == 0)
7526 vec_validate (mask, sizeof (*ip) - 1);
7528 ip = (ip4_header_t *) mask;
7530 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
7531 foreach_ip4_proto_field;
7534 ip->ip_version_and_header_length = 0;
7537 ip->ip_version_and_header_length |= 0xF0;
7540 ip->ip_version_and_header_length |= 0x0F;
7546 #define foreach_ip6_proto_field \
7554 unformat_ip6_mask (unformat_input_t * input, va_list * args)
7556 u8 **maskp = va_arg (*args, u8 **);
7558 u8 found_something = 0;
7560 u32 ip_version_traffic_class_and_flow_label;
7562 #define _(a) u8 a=0;
7563 foreach_ip6_proto_field;
7566 u8 traffic_class = 0;
7569 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7571 if (unformat (input, "version"))
7573 else if (unformat (input, "traffic-class"))
7575 else if (unformat (input, "flow-label"))
7577 else if (unformat (input, "src"))
7579 else if (unformat (input, "dst"))
7581 else if (unformat (input, "proto"))
7584 #define _(a) else if (unformat (input, #a)) a=1;
7585 foreach_ip6_proto_field
7591 #define _(a) found_something += a;
7592 foreach_ip6_proto_field;
7595 if (found_something == 0)
7598 vec_validate (mask, sizeof (*ip) - 1);
7600 ip = (ip6_header_t *) mask;
7602 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
7603 foreach_ip6_proto_field;
7606 ip_version_traffic_class_and_flow_label = 0;
7609 ip_version_traffic_class_and_flow_label |= 0xF0000000;
7612 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
7615 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
7617 ip->ip_version_traffic_class_and_flow_label =
7618 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
7625 unformat_l3_mask (unformat_input_t * input, va_list * args)
7627 u8 **maskp = va_arg (*args, u8 **);
7629 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7631 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
7633 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
7642 unformat_l2_mask (unformat_input_t * input, va_list * args)
7644 u8 **maskp = va_arg (*args, u8 **);
7659 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7661 if (unformat (input, "src"))
7663 else if (unformat (input, "dst"))
7665 else if (unformat (input, "proto"))
7667 else if (unformat (input, "tag1"))
7669 else if (unformat (input, "tag2"))
7671 else if (unformat (input, "ignore-tag1"))
7673 else if (unformat (input, "ignore-tag2"))
7675 else if (unformat (input, "cos1"))
7677 else if (unformat (input, "cos2"))
7679 else if (unformat (input, "dot1q"))
7681 else if (unformat (input, "dot1ad"))
7686 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
7687 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
7690 if (tag1 || ignore_tag1 || cos1 || dot1q)
7692 if (tag2 || ignore_tag2 || cos2 || dot1ad)
7695 vec_validate (mask, len - 1);
7698 memset (mask, 0xff, 6);
7701 memset (mask + 6, 0xff, 6);
7705 /* inner vlan tag */
7714 mask[21] = mask[20] = 0xff;
7735 mask[16] = mask[17] = 0xff;
7745 mask[12] = mask[13] = 0xff;
7752 unformat_classify_mask (unformat_input_t * input, va_list * args)
7754 u8 **maskp = va_arg (*args, u8 **);
7755 u32 *skipp = va_arg (*args, u32 *);
7756 u32 *matchp = va_arg (*args, u32 *);
7763 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7765 if (unformat (input, "hex %U", unformat_hex_string, &mask))
7767 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
7769 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
7775 if (mask || l2 || l3)
7779 /* "With a free Ethernet header in every package" */
7781 vec_validate (l2, 13);
7785 vec_append (mask, l3);
7790 /* Scan forward looking for the first significant mask octet */
7791 for (i = 0; i < vec_len (mask); i++)
7795 /* compute (skip, match) params */
7796 *skipp = i / sizeof (u32x4);
7797 vec_delete (mask, *skipp * sizeof (u32x4), 0);
7799 /* Pad mask to an even multiple of the vector size */
7800 while (vec_len (mask) % sizeof (u32x4))
7803 match = vec_len (mask) / sizeof (u32x4);
7805 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
7807 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
7808 if (*tmp || *(tmp + 1))
7813 clib_warning ("BUG: match 0");
7815 _vec_len (mask) = match * sizeof (u32x4);
7826 #define foreach_l2_next \
7828 _(ethernet, ETHERNET_INPUT) \
7833 unformat_l2_next_index (unformat_input_t * input, va_list * args)
7835 u32 *miss_next_indexp = va_arg (*args, u32 *);
7840 if (unformat (input, #n)) { next_index = L2_CLASSIFY_NEXT_##N; goto out;}
7844 if (unformat (input, "%d", &tmp))
7853 *miss_next_indexp = next_index;
7857 #define foreach_ip_next \
7864 unformat_ip_next_index (unformat_input_t * input, va_list * args)
7866 u32 *miss_next_indexp = va_arg (*args, u32 *);
7871 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
7875 if (unformat (input, "%d", &tmp))
7884 *miss_next_indexp = next_index;
7888 #define foreach_acl_next \
7892 unformat_acl_next_index (unformat_input_t * input, va_list * args)
7894 u32 *miss_next_indexp = va_arg (*args, u32 *);
7899 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
7903 if (unformat (input, "permit"))
7908 else if (unformat (input, "%d", &tmp))
7917 *miss_next_indexp = next_index;
7922 unformat_policer_precolor (unformat_input_t * input, va_list * args)
7924 u32 *r = va_arg (*args, u32 *);
7926 if (unformat (input, "conform-color"))
7927 *r = POLICE_CONFORM;
7928 else if (unformat (input, "exceed-color"))
7937 api_classify_add_del_table (vat_main_t * vam)
7939 unformat_input_t *i = vam->input;
7940 vl_api_classify_add_del_table_t *mp;
7946 u32 table_index = ~0;
7947 u32 next_table_index = ~0;
7948 u32 miss_next_index = ~0;
7949 u32 memory_size = 32 << 20;
7953 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7955 if (unformat (i, "del"))
7957 else if (unformat (i, "buckets %d", &nbuckets))
7959 else if (unformat (i, "memory_size %d", &memory_size))
7961 else if (unformat (i, "skip %d", &skip))
7963 else if (unformat (i, "match %d", &match))
7965 else if (unformat (i, "table %d", &table_index))
7967 else if (unformat (i, "mask %U", unformat_classify_mask,
7968 &mask, &skip, &match))
7970 else if (unformat (i, "next-table %d", &next_table_index))
7972 else if (unformat (i, "miss-next %U", unformat_ip_next_index,
7975 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
7978 else if (unformat (i, "acl-miss-next %U", unformat_acl_next_index,
7985 if (is_add && mask == 0)
7987 errmsg ("Mask required\n");
7991 if (is_add && skip == ~0)
7993 errmsg ("skip count required\n");
7997 if (is_add && match == ~0)
7999 errmsg ("match count required\n");
8003 if (!is_add && table_index == ~0)
8005 errmsg ("table index required for delete\n");
8009 M2 (CLASSIFY_ADD_DEL_TABLE, classify_add_del_table, vec_len (mask));
8011 mp->is_add = is_add;
8012 mp->table_index = ntohl (table_index);
8013 mp->nbuckets = ntohl (nbuckets);
8014 mp->memory_size = ntohl (memory_size);
8015 mp->skip_n_vectors = ntohl (skip);
8016 mp->match_n_vectors = ntohl (match);
8017 mp->next_table_index = ntohl (next_table_index);
8018 mp->miss_next_index = ntohl (miss_next_index);
8019 clib_memcpy (mp->mask, mask, vec_len (mask));
8029 unformat_ip4_match (unformat_input_t * input, va_list * args)
8031 u8 **matchp = va_arg (*args, u8 **);
8038 int src = 0, dst = 0;
8039 ip4_address_t src_val, dst_val;
8046 int fragment_id = 0;
8047 u32 fragment_id_val;
8053 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8055 if (unformat (input, "version %d", &version_val))
8057 else if (unformat (input, "hdr_length %d", &hdr_length_val))
8059 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
8061 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
8063 else if (unformat (input, "proto %d", &proto_val))
8065 else if (unformat (input, "tos %d", &tos_val))
8067 else if (unformat (input, "length %d", &length_val))
8069 else if (unformat (input, "fragment_id %d", &fragment_id_val))
8071 else if (unformat (input, "ttl %d", &ttl_val))
8073 else if (unformat (input, "checksum %d", &checksum_val))
8079 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
8080 + ttl + checksum == 0)
8084 * Aligned because we use the real comparison functions
8086 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
8088 ip = (ip4_header_t *) match;
8090 /* These are realistically matched in practice */
8092 ip->src_address.as_u32 = src_val.as_u32;
8095 ip->dst_address.as_u32 = dst_val.as_u32;
8098 ip->protocol = proto_val;
8101 /* These are not, but they're included for completeness */
8103 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
8106 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
8112 ip->length = length_val;
8118 ip->checksum = checksum_val;
8125 unformat_ip6_match (unformat_input_t * input, va_list * args)
8127 u8 **matchp = va_arg (*args, u8 **);
8132 u8 traffic_class = 0;
8133 u32 traffic_class_val = 0;
8136 int src = 0, dst = 0;
8137 ip6_address_t src_val, dst_val;
8140 int payload_length = 0;
8141 u32 payload_length_val;
8144 u32 ip_version_traffic_class_and_flow_label;
8146 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8148 if (unformat (input, "version %d", &version_val))
8150 else if (unformat (input, "traffic_class %d", &traffic_class_val))
8152 else if (unformat (input, "flow_label %d", &flow_label_val))
8154 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
8156 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
8158 else if (unformat (input, "proto %d", &proto_val))
8160 else if (unformat (input, "payload_length %d", &payload_length_val))
8162 else if (unformat (input, "hop_limit %d", &hop_limit_val))
8168 if (version + traffic_class + flow_label + src + dst + proto +
8169 payload_length + hop_limit == 0)
8173 * Aligned because we use the real comparison functions
8175 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
8177 ip = (ip6_header_t *) match;
8180 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
8183 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
8186 ip->protocol = proto_val;
8188 ip_version_traffic_class_and_flow_label = 0;
8191 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
8194 ip_version_traffic_class_and_flow_label |=
8195 (traffic_class_val & 0xFF) << 20;
8198 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
8200 ip->ip_version_traffic_class_and_flow_label =
8201 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
8204 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
8207 ip->hop_limit = hop_limit_val;
8214 unformat_l3_match (unformat_input_t * input, va_list * args)
8216 u8 **matchp = va_arg (*args, u8 **);
8218 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8220 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
8222 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
8231 unformat_vlan_tag (unformat_input_t * input, va_list * args)
8233 u8 *tagp = va_arg (*args, u8 *);
8236 if (unformat (input, "%d", &tag))
8238 tagp[0] = (tag >> 8) & 0x0F;
8239 tagp[1] = tag & 0xFF;
8247 unformat_l2_match (unformat_input_t * input, va_list * args)
8249 u8 **matchp = va_arg (*args, u8 **);
8269 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8271 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
8274 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
8276 else if (unformat (input, "proto %U",
8277 unformat_ethernet_type_host_byte_order, &proto_val))
8279 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
8281 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
8283 else if (unformat (input, "ignore-tag1"))
8285 else if (unformat (input, "ignore-tag2"))
8287 else if (unformat (input, "cos1 %d", &cos1_val))
8289 else if (unformat (input, "cos2 %d", &cos2_val))
8294 if ((src + dst + proto + tag1 + tag2 +
8295 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
8298 if (tag1 || ignore_tag1 || cos1)
8300 if (tag2 || ignore_tag2 || cos2)
8303 vec_validate_aligned (match, len - 1, sizeof (u32x4));
8306 clib_memcpy (match, dst_val, 6);
8309 clib_memcpy (match + 6, src_val, 6);
8313 /* inner vlan tag */
8314 match[19] = tag2_val[1];
8315 match[18] = tag2_val[0];
8317 match[18] |= (cos2_val & 0x7) << 5;
8320 match[21] = proto_val & 0xff;
8321 match[20] = proto_val >> 8;
8325 match[15] = tag1_val[1];
8326 match[14] = tag1_val[0];
8329 match[14] |= (cos1_val & 0x7) << 5;
8335 match[15] = tag1_val[1];
8336 match[14] = tag1_val[0];
8339 match[17] = proto_val & 0xff;
8340 match[16] = proto_val >> 8;
8343 match[14] |= (cos1_val & 0x7) << 5;
8349 match[18] |= (cos2_val & 0x7) << 5;
8351 match[14] |= (cos1_val & 0x7) << 5;
8354 match[13] = proto_val & 0xff;
8355 match[12] = proto_val >> 8;
8364 unformat_classify_match (unformat_input_t * input, va_list * args)
8366 u8 **matchp = va_arg (*args, u8 **);
8367 u32 skip_n_vectors = va_arg (*args, u32);
8368 u32 match_n_vectors = va_arg (*args, u32);
8374 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8376 if (unformat (input, "hex %U", unformat_hex_string, &match))
8378 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
8380 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
8386 if (match || l2 || l3)
8390 /* "Win a free Ethernet header in every packet" */
8392 vec_validate_aligned (l2, 13, sizeof (u32x4));
8396 vec_append_aligned (match, l3, sizeof (u32x4));
8401 /* Make sure the vector is big enough even if key is all 0's */
8402 vec_validate_aligned
8403 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
8406 /* Set size, include skipped vectors */
8407 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
8418 api_classify_add_del_session (vat_main_t * vam)
8420 unformat_input_t *i = vam->input;
8421 vl_api_classify_add_del_session_t *mp;
8423 u32 table_index = ~0;
8424 u32 hit_next_index = ~0;
8425 u32 opaque_index = ~0;
8429 u32 skip_n_vectors = 0;
8430 u32 match_n_vectors = 0;
8433 * Warning: you have to supply skip_n and match_n
8434 * because the API client cant simply look at the classify
8438 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8440 if (unformat (i, "del"))
8442 else if (unformat (i, "hit-next %U", unformat_ip_next_index,
8445 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
8448 else if (unformat (i, "acl-hit-next %U", unformat_acl_next_index,
8451 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
8453 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
8455 else if (unformat (i, "opaque-index %d", &opaque_index))
8457 else if (unformat (i, "skip_n %d", &skip_n_vectors))
8459 else if (unformat (i, "match_n %d", &match_n_vectors))
8461 else if (unformat (i, "match %U", unformat_classify_match,
8462 &match, skip_n_vectors, match_n_vectors))
8464 else if (unformat (i, "advance %d", &advance))
8466 else if (unformat (i, "table-index %d", &table_index))
8472 if (table_index == ~0)
8474 errmsg ("Table index required\n");
8478 if (is_add && match == 0)
8480 errmsg ("Match value required\n");
8484 M2 (CLASSIFY_ADD_DEL_SESSION, classify_add_del_session, vec_len (match));
8486 mp->is_add = is_add;
8487 mp->table_index = ntohl (table_index);
8488 mp->hit_next_index = ntohl (hit_next_index);
8489 mp->opaque_index = ntohl (opaque_index);
8490 mp->advance = ntohl (advance);
8491 clib_memcpy (mp->match, match, vec_len (match));
8500 api_classify_set_interface_ip_table (vat_main_t * vam)
8502 unformat_input_t *i = vam->input;
8503 vl_api_classify_set_interface_ip_table_t *mp;
8506 int sw_if_index_set;
8507 u32 table_index = ~0;
8510 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8512 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8513 sw_if_index_set = 1;
8514 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8515 sw_if_index_set = 1;
8516 else if (unformat (i, "table %d", &table_index))
8520 clib_warning ("parse error '%U'", format_unformat_error, i);
8525 if (sw_if_index_set == 0)
8527 errmsg ("missing interface name or sw_if_index\n");
8532 M (CLASSIFY_SET_INTERFACE_IP_TABLE, classify_set_interface_ip_table);
8534 mp->sw_if_index = ntohl (sw_if_index);
8535 mp->table_index = ntohl (table_index);
8536 mp->is_ipv6 = is_ipv6;
8545 api_classify_set_interface_l2_tables (vat_main_t * vam)
8547 unformat_input_t *i = vam->input;
8548 vl_api_classify_set_interface_l2_tables_t *mp;
8551 int sw_if_index_set;
8552 u32 ip4_table_index = ~0;
8553 u32 ip6_table_index = ~0;
8554 u32 other_table_index = ~0;
8556 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8558 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8559 sw_if_index_set = 1;
8560 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8561 sw_if_index_set = 1;
8562 else if (unformat (i, "ip4-table %d", &ip4_table_index))
8564 else if (unformat (i, "ip6-table %d", &ip6_table_index))
8566 else if (unformat (i, "other-table %d", &other_table_index))
8570 clib_warning ("parse error '%U'", format_unformat_error, i);
8575 if (sw_if_index_set == 0)
8577 errmsg ("missing interface name or sw_if_index\n");
8582 M (CLASSIFY_SET_INTERFACE_L2_TABLES, classify_set_interface_l2_tables);
8584 mp->sw_if_index = ntohl (sw_if_index);
8585 mp->ip4_table_index = ntohl (ip4_table_index);
8586 mp->ip6_table_index = ntohl (ip6_table_index);
8587 mp->other_table_index = ntohl (other_table_index);
8597 api_ipfix_enable (vat_main_t * vam)
8599 unformat_input_t *i = vam->input;
8600 vl_api_ipfix_enable_t *mp;
8601 ip4_address_t collector_address;
8602 u8 collector_address_set = 0;
8603 u32 collector_port = ~0;
8604 ip4_address_t src_address;
8605 u8 src_address_set = 0;
8608 u32 template_interval = ~0;
8611 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8613 if (unformat (i, "collector_address %U", unformat_ip4_address,
8614 &collector_address))
8615 collector_address_set = 1;
8616 else if (unformat (i, "collector_port %d", &collector_port))
8618 else if (unformat (i, "src_address %U", unformat_ip4_address,
8620 src_address_set = 1;
8621 else if (unformat (i, "vrf_id %d", &vrf_id))
8623 else if (unformat (i, "path_mtu %d", &path_mtu))
8625 else if (unformat (i, "template_interval %d", &template_interval))
8631 if (collector_address_set == 0)
8633 errmsg ("collector_address required\n");
8637 if (src_address_set == 0)
8639 errmsg ("src_address required\n");
8643 M (IPFIX_ENABLE, ipfix_enable);
8645 memcpy (mp->collector_address, collector_address.data,
8646 sizeof (collector_address.data));
8647 mp->collector_port = htons ((u16) collector_port);
8648 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
8649 mp->vrf_id = htonl (vrf_id);
8650 mp->path_mtu = htonl (path_mtu);
8651 mp->template_interval = htonl (template_interval);
8659 api_get_node_index (vat_main_t * vam)
8661 unformat_input_t *i = vam->input;
8662 vl_api_get_node_index_t *mp;
8666 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8668 if (unformat (i, "node %s", &name))
8675 errmsg ("node name required\n");
8678 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
8680 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
8684 M (GET_NODE_INDEX, get_node_index);
8685 clib_memcpy (mp->node_name, name, vec_len (name));
8695 api_get_next_index (vat_main_t * vam)
8697 unformat_input_t *i = vam->input;
8698 vl_api_get_next_index_t *mp;
8700 u8 *node_name = 0, *next_node_name = 0;
8702 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8704 if (unformat (i, "node-name %s", &node_name))
8706 else if (unformat (i, "next-node-name %s", &next_node_name))
8712 errmsg ("node name required\n");
8715 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
8717 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
8721 if (next_node_name == 0)
8723 errmsg ("next node name required\n");
8726 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
8728 errmsg ("next node name too long, max %d\n", ARRAY_LEN (mp->next_name));
8732 M (GET_NEXT_INDEX, get_next_index);
8733 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
8734 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
8735 vec_free (node_name);
8736 vec_free (next_node_name);
8745 api_add_node_next (vat_main_t * vam)
8747 unformat_input_t *i = vam->input;
8748 vl_api_add_node_next_t *mp;
8753 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8755 if (unformat (i, "node %s", &name))
8757 else if (unformat (i, "next %s", &next))
8764 errmsg ("node name required\n");
8767 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
8769 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
8774 errmsg ("next node required\n");
8777 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
8779 errmsg ("next name too long, max %d\n", ARRAY_LEN (mp->next_name));
8783 M (ADD_NODE_NEXT, add_node_next);
8784 clib_memcpy (mp->node_name, name, vec_len (name));
8785 clib_memcpy (mp->next_name, next, vec_len (next));
8796 api_l2tpv3_create_tunnel (vat_main_t * vam)
8798 unformat_input_t *i = vam->input;
8799 ip6_address_t client_address, our_address;
8800 int client_address_set = 0;
8801 int our_address_set = 0;
8802 u32 local_session_id = 0;
8803 u32 remote_session_id = 0;
8804 u64 local_cookie = 0;
8805 u64 remote_cookie = 0;
8806 u8 l2_sublayer_present = 0;
8807 vl_api_l2tpv3_create_tunnel_t *mp;
8810 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8812 if (unformat (i, "client_address %U", unformat_ip6_address,
8814 client_address_set = 1;
8815 else if (unformat (i, "our_address %U", unformat_ip6_address,
8817 our_address_set = 1;
8818 else if (unformat (i, "local_session_id %d", &local_session_id))
8820 else if (unformat (i, "remote_session_id %d", &remote_session_id))
8822 else if (unformat (i, "local_cookie %lld", &local_cookie))
8824 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
8826 else if (unformat (i, "l2-sublayer-present"))
8827 l2_sublayer_present = 1;
8832 if (client_address_set == 0)
8834 errmsg ("client_address required\n");
8838 if (our_address_set == 0)
8840 errmsg ("our_address required\n");
8844 M (L2TPV3_CREATE_TUNNEL, l2tpv3_create_tunnel);
8846 clib_memcpy (mp->client_address, client_address.as_u8,
8847 sizeof (mp->client_address));
8849 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
8851 mp->local_session_id = ntohl (local_session_id);
8852 mp->remote_session_id = ntohl (remote_session_id);
8853 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
8854 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
8855 mp->l2_sublayer_present = l2_sublayer_present;
8865 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
8867 unformat_input_t *i = vam->input;
8869 u8 sw_if_index_set = 0;
8870 u64 new_local_cookie = 0;
8871 u64 new_remote_cookie = 0;
8872 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
8875 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8877 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8878 sw_if_index_set = 1;
8879 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8880 sw_if_index_set = 1;
8881 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
8883 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
8889 if (sw_if_index_set == 0)
8891 errmsg ("missing interface name or sw_if_index\n");
8895 M (L2TPV3_SET_TUNNEL_COOKIES, l2tpv3_set_tunnel_cookies);
8897 mp->sw_if_index = ntohl (sw_if_index);
8898 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
8899 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
8908 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
8910 unformat_input_t *i = vam->input;
8911 vl_api_l2tpv3_interface_enable_disable_t *mp;
8914 u8 sw_if_index_set = 0;
8915 u8 enable_disable = 1;
8917 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8919 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8920 sw_if_index_set = 1;
8921 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8922 sw_if_index_set = 1;
8923 else if (unformat (i, "enable"))
8925 else if (unformat (i, "disable"))
8931 if (sw_if_index_set == 0)
8933 errmsg ("missing interface name or sw_if_index\n");
8937 M (L2TPV3_INTERFACE_ENABLE_DISABLE, l2tpv3_interface_enable_disable);
8939 mp->sw_if_index = ntohl (sw_if_index);
8940 mp->enable_disable = enable_disable;
8949 api_l2tpv3_set_lookup_key (vat_main_t * vam)
8951 unformat_input_t *i = vam->input;
8952 vl_api_l2tpv3_set_lookup_key_t *mp;
8956 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8958 if (unformat (i, "lookup_v6_src"))
8959 key = L2T_LOOKUP_SRC_ADDRESS;
8960 else if (unformat (i, "lookup_v6_dst"))
8961 key = L2T_LOOKUP_DST_ADDRESS;
8962 else if (unformat (i, "lookup_session_id"))
8963 key = L2T_LOOKUP_SESSION_ID;
8968 if (key == (u8) ~ 0)
8970 errmsg ("l2tp session lookup key unset\n");
8974 M (L2TPV3_SET_LOOKUP_KEY, l2tpv3_set_lookup_key);
8984 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
8985 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
8987 vat_main_t *vam = &vat_main;
8989 fformat (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)\n",
8990 format_ip6_address, mp->our_address,
8991 format_ip6_address, mp->client_address,
8992 clib_net_to_host_u32 (mp->sw_if_index));
8995 " local cookies %016llx %016llx remote cookie %016llx\n",
8996 clib_net_to_host_u64 (mp->local_cookie[0]),
8997 clib_net_to_host_u64 (mp->local_cookie[1]),
8998 clib_net_to_host_u64 (mp->remote_cookie));
9000 fformat (vam->ofp, " local session-id %d remote session-id %d\n",
9001 clib_net_to_host_u32 (mp->local_session_id),
9002 clib_net_to_host_u32 (mp->remote_session_id));
9004 fformat (vam->ofp, " l2 specific sublayer %s\n\n",
9005 mp->l2_sublayer_present ? "preset" : "absent");
9009 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
9010 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
9012 vat_main_t *vam = &vat_main;
9013 vat_json_node_t *node = NULL;
9014 struct in6_addr addr;
9016 if (VAT_JSON_ARRAY != vam->json_tree.type)
9018 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9019 vat_json_init_array (&vam->json_tree);
9021 node = vat_json_array_add (&vam->json_tree);
9023 vat_json_init_object (node);
9025 clib_memcpy (&addr, mp->our_address, sizeof (addr));
9026 vat_json_object_add_ip6 (node, "our_address", addr);
9027 clib_memcpy (&addr, mp->client_address, sizeof (addr));
9028 vat_json_object_add_ip6 (node, "client_address", addr);
9030 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
9031 vat_json_init_array (lc);
9032 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
9033 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
9034 vat_json_object_add_uint (node, "remote_cookie",
9035 clib_net_to_host_u64 (mp->remote_cookie));
9037 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
9038 vat_json_object_add_uint (node, "local_session_id",
9039 clib_net_to_host_u32 (mp->local_session_id));
9040 vat_json_object_add_uint (node, "remote_session_id",
9041 clib_net_to_host_u32 (mp->remote_session_id));
9042 vat_json_object_add_string_copy (node, "l2_sublayer",
9043 mp->l2_sublayer_present ? (u8 *) "present"
9048 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
9050 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
9053 /* Get list of l2tpv3-tunnel interfaces */
9054 M (SW_IF_L2TPV3_TUNNEL_DUMP, sw_if_l2tpv3_tunnel_dump);
9057 /* Use a control ping for synchronization */
9059 vl_api_control_ping_t *mp;
9060 M (CONTROL_PING, control_ping);
9067 static void vl_api_sw_interface_tap_details_t_handler
9068 (vl_api_sw_interface_tap_details_t * mp)
9070 vat_main_t *vam = &vat_main;
9072 fformat (vam->ofp, "%-16s %d\n",
9073 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
9076 static void vl_api_sw_interface_tap_details_t_handler_json
9077 (vl_api_sw_interface_tap_details_t * mp)
9079 vat_main_t *vam = &vat_main;
9080 vat_json_node_t *node = NULL;
9082 if (VAT_JSON_ARRAY != vam->json_tree.type)
9084 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9085 vat_json_init_array (&vam->json_tree);
9087 node = vat_json_array_add (&vam->json_tree);
9089 vat_json_init_object (node);
9090 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9091 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
9095 api_sw_interface_tap_dump (vat_main_t * vam)
9097 vl_api_sw_interface_tap_dump_t *mp;
9100 fformat (vam->ofp, "\n%-16s %s\n", "dev_name", "sw_if_index");
9101 /* Get list of tap interfaces */
9102 M (SW_INTERFACE_TAP_DUMP, sw_interface_tap_dump);
9105 /* Use a control ping for synchronization */
9107 vl_api_control_ping_t *mp;
9108 M (CONTROL_PING, control_ping);
9114 static uword unformat_vxlan_decap_next
9115 (unformat_input_t * input, va_list * args)
9117 u32 *result = va_arg (*args, u32 *);
9120 if (unformat (input, "drop"))
9121 *result = VXLAN_INPUT_NEXT_DROP;
9122 else if (unformat (input, "ip4"))
9123 *result = VXLAN_INPUT_NEXT_IP4_INPUT;
9124 else if (unformat (input, "ip6"))
9125 *result = VXLAN_INPUT_NEXT_IP6_INPUT;
9126 else if (unformat (input, "l2"))
9127 *result = VXLAN_INPUT_NEXT_L2_INPUT;
9128 else if (unformat (input, "%d", &tmp))
9136 api_vxlan_add_del_tunnel (vat_main_t * vam)
9138 unformat_input_t *line_input = vam->input;
9139 vl_api_vxlan_add_del_tunnel_t *mp;
9141 ip4_address_t src4, dst4;
9142 ip6_address_t src6, dst6;
9144 u8 ipv4_set = 0, ipv6_set = 0;
9147 u32 encap_vrf_id = 0;
9148 u32 decap_next_index = ~0;
9151 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9153 if (unformat (line_input, "del"))
9155 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
9160 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
9165 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
9170 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
9175 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
9177 else if (unformat (line_input, "decap-next %U",
9178 unformat_vxlan_decap_next, &decap_next_index))
9180 else if (unformat (line_input, "vni %d", &vni))
9184 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
9191 errmsg ("tunnel src address not specified\n");
9196 errmsg ("tunnel dst address not specified\n");
9200 if (ipv4_set && ipv6_set)
9202 errmsg ("both IPv4 and IPv6 addresses specified");
9206 if ((vni == 0) || (vni >> 24))
9208 errmsg ("vni not specified or out of range\n");
9212 M (VXLAN_ADD_DEL_TUNNEL, vxlan_add_del_tunnel);
9216 clib_memcpy (&mp->src_address, &src6, sizeof (src6));
9217 clib_memcpy (&mp->dst_address, &dst6, sizeof (dst6));
9221 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
9222 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
9224 mp->encap_vrf_id = ntohl (encap_vrf_id);
9225 mp->decap_next_index = ntohl (decap_next_index);
9226 mp->vni = ntohl (vni);
9227 mp->is_add = is_add;
9228 mp->is_ipv6 = ipv6_set;
9236 static void vl_api_vxlan_tunnel_details_t_handler
9237 (vl_api_vxlan_tunnel_details_t * mp)
9239 vat_main_t *vam = &vat_main;
9241 fformat (vam->ofp, "%11d%24U%24U%14d%18d%13d\n",
9242 ntohl (mp->sw_if_index),
9243 format_ip46_address, &(mp->src_address[0]),
9245 format_ip46_address, &(mp->dst_address[0]),
9247 ntohl (mp->encap_vrf_id),
9248 ntohl (mp->decap_next_index), ntohl (mp->vni));
9251 static void vl_api_vxlan_tunnel_details_t_handler_json
9252 (vl_api_vxlan_tunnel_details_t * mp)
9254 vat_main_t *vam = &vat_main;
9255 vat_json_node_t *node = NULL;
9257 struct in6_addr ip6;
9259 if (VAT_JSON_ARRAY != vam->json_tree.type)
9261 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9262 vat_json_init_array (&vam->json_tree);
9264 node = vat_json_array_add (&vam->json_tree);
9266 vat_json_init_object (node);
9267 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9270 clib_memcpy (&ip6, &(mp->src_address[0]), sizeof (ip6));
9271 vat_json_object_add_ip6 (node, "src_address", ip6);
9272 clib_memcpy (&ip6, &(mp->dst_address[0]), sizeof (ip6));
9273 vat_json_object_add_ip6 (node, "dst_address", ip6);
9277 clib_memcpy (&ip4, &(mp->src_address[0]), sizeof (ip4));
9278 vat_json_object_add_ip4 (node, "src_address", ip4);
9279 clib_memcpy (&ip4, &(mp->dst_address[0]), sizeof (ip4));
9280 vat_json_object_add_ip4 (node, "dst_address", ip4);
9282 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
9283 vat_json_object_add_uint (node, "decap_next_index",
9284 ntohl (mp->decap_next_index));
9285 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
9286 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
9290 api_vxlan_tunnel_dump (vat_main_t * vam)
9292 unformat_input_t *i = vam->input;
9293 vl_api_vxlan_tunnel_dump_t *mp;
9296 u8 sw_if_index_set = 0;
9298 /* Parse args required to build the message */
9299 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9301 if (unformat (i, "sw_if_index %d", &sw_if_index))
9302 sw_if_index_set = 1;
9307 if (sw_if_index_set == 0)
9312 if (!vam->json_output)
9314 fformat (vam->ofp, "%11s%24s%24s%14s%18s%13s\n",
9315 "sw_if_index", "src_address", "dst_address",
9316 "encap_vrf_id", "decap_next_index", "vni");
9319 /* Get list of vxlan-tunnel interfaces */
9320 M (VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump);
9322 mp->sw_if_index = htonl (sw_if_index);
9326 /* Use a control ping for synchronization */
9328 vl_api_control_ping_t *mp;
9329 M (CONTROL_PING, control_ping);
9336 api_gre_add_del_tunnel (vat_main_t * vam)
9338 unformat_input_t *line_input = vam->input;
9339 vl_api_gre_add_del_tunnel_t *mp;
9341 ip4_address_t src4, dst4;
9345 u32 outer_fib_id = 0;
9347 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9349 if (unformat (line_input, "del"))
9351 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
9353 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
9355 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
9359 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
9366 errmsg ("tunnel src address not specified\n");
9371 errmsg ("tunnel dst address not specified\n");
9376 M (GRE_ADD_DEL_TUNNEL, gre_add_del_tunnel);
9378 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
9379 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
9380 mp->outer_fib_id = ntohl (outer_fib_id);
9381 mp->is_add = is_add;
9389 static void vl_api_gre_tunnel_details_t_handler
9390 (vl_api_gre_tunnel_details_t * mp)
9392 vat_main_t *vam = &vat_main;
9394 fformat (vam->ofp, "%11d%15U%15U%14d\n",
9395 ntohl (mp->sw_if_index),
9396 format_ip4_address, &mp->src_address,
9397 format_ip4_address, &mp->dst_address, ntohl (mp->outer_fib_id));
9400 static void vl_api_gre_tunnel_details_t_handler_json
9401 (vl_api_gre_tunnel_details_t * mp)
9403 vat_main_t *vam = &vat_main;
9404 vat_json_node_t *node = NULL;
9407 if (VAT_JSON_ARRAY != vam->json_tree.type)
9409 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9410 vat_json_init_array (&vam->json_tree);
9412 node = vat_json_array_add (&vam->json_tree);
9414 vat_json_init_object (node);
9415 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9416 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
9417 vat_json_object_add_ip4 (node, "src_address", ip4);
9418 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
9419 vat_json_object_add_ip4 (node, "dst_address", ip4);
9420 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
9424 api_gre_tunnel_dump (vat_main_t * vam)
9426 unformat_input_t *i = vam->input;
9427 vl_api_gre_tunnel_dump_t *mp;
9430 u8 sw_if_index_set = 0;
9432 /* Parse args required to build the message */
9433 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9435 if (unformat (i, "sw_if_index %d", &sw_if_index))
9436 sw_if_index_set = 1;
9441 if (sw_if_index_set == 0)
9446 if (!vam->json_output)
9448 fformat (vam->ofp, "%11s%15s%15s%14s\n",
9449 "sw_if_index", "src_address", "dst_address", "outer_fib_id");
9452 /* Get list of gre-tunnel interfaces */
9453 M (GRE_TUNNEL_DUMP, gre_tunnel_dump);
9455 mp->sw_if_index = htonl (sw_if_index);
9459 /* Use a control ping for synchronization */
9461 vl_api_control_ping_t *mp;
9462 M (CONTROL_PING, control_ping);
9469 api_l2_fib_clear_table (vat_main_t * vam)
9471 // unformat_input_t * i = vam->input;
9472 vl_api_l2_fib_clear_table_t *mp;
9475 M (L2_FIB_CLEAR_TABLE, l2_fib_clear_table);
9484 api_l2_interface_efp_filter (vat_main_t * vam)
9486 unformat_input_t *i = vam->input;
9487 vl_api_l2_interface_efp_filter_t *mp;
9491 u8 sw_if_index_set = 0;
9493 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9495 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9496 sw_if_index_set = 1;
9497 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9498 sw_if_index_set = 1;
9499 else if (unformat (i, "enable"))
9501 else if (unformat (i, "disable"))
9505 clib_warning ("parse error '%U'", format_unformat_error, i);
9510 if (sw_if_index_set == 0)
9512 errmsg ("missing sw_if_index\n");
9516 M (L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter);
9518 mp->sw_if_index = ntohl (sw_if_index);
9519 mp->enable_disable = enable;
9527 #define foreach_vtr_op \
9528 _("disable", L2_VTR_DISABLED) \
9529 _("push-1", L2_VTR_PUSH_1) \
9530 _("push-2", L2_VTR_PUSH_2) \
9531 _("pop-1", L2_VTR_POP_1) \
9532 _("pop-2", L2_VTR_POP_2) \
9533 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
9534 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
9535 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
9536 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
9539 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
9541 unformat_input_t *i = vam->input;
9542 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
9545 u8 sw_if_index_set = 0;
9552 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9554 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9555 sw_if_index_set = 1;
9556 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9557 sw_if_index_set = 1;
9558 else if (unformat (i, "vtr_op %d", &vtr_op))
9560 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
9563 else if (unformat (i, "push_dot1q %d", &push_dot1q))
9565 else if (unformat (i, "tag1 %d", &tag1))
9567 else if (unformat (i, "tag2 %d", &tag2))
9571 clib_warning ("parse error '%U'", format_unformat_error, i);
9576 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
9578 errmsg ("missing vtr operation or sw_if_index\n");
9582 M (L2_INTERFACE_VLAN_TAG_REWRITE, l2_interface_vlan_tag_rewrite)
9583 mp->sw_if_index = ntohl (sw_if_index);
9584 mp->vtr_op = ntohl (vtr_op);
9585 mp->push_dot1q = ntohl (push_dot1q);
9586 mp->tag1 = ntohl (tag1);
9587 mp->tag2 = ntohl (tag2);
9596 api_create_vhost_user_if (vat_main_t * vam)
9598 unformat_input_t *i = vam->input;
9599 vl_api_create_vhost_user_if_t *mp;
9603 u8 file_name_set = 0;
9604 u32 custom_dev_instance = ~0;
9606 u8 use_custom_mac = 0;
9608 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9610 if (unformat (i, "socket %s", &file_name))
9614 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
9616 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
9618 else if (unformat (i, "server"))
9624 if (file_name_set == 0)
9626 errmsg ("missing socket file name\n");
9630 if (vec_len (file_name) > 255)
9632 errmsg ("socket file name too long\n");
9635 vec_add1 (file_name, 0);
9637 M (CREATE_VHOST_USER_IF, create_vhost_user_if);
9639 mp->is_server = is_server;
9640 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
9641 vec_free (file_name);
9642 if (custom_dev_instance != ~0)
9645 mp->custom_dev_instance = ntohl (custom_dev_instance);
9647 mp->use_custom_mac = use_custom_mac;
9648 clib_memcpy (mp->mac_address, hwaddr, 6);
9657 api_modify_vhost_user_if (vat_main_t * vam)
9659 unformat_input_t *i = vam->input;
9660 vl_api_modify_vhost_user_if_t *mp;
9664 u8 file_name_set = 0;
9665 u32 custom_dev_instance = ~0;
9666 u8 sw_if_index_set = 0;
9667 u32 sw_if_index = (u32) ~ 0;
9669 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9671 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9672 sw_if_index_set = 1;
9673 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9674 sw_if_index_set = 1;
9675 else if (unformat (i, "socket %s", &file_name))
9679 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
9681 else if (unformat (i, "server"))
9687 if (sw_if_index_set == 0)
9689 errmsg ("missing sw_if_index or interface name\n");
9693 if (file_name_set == 0)
9695 errmsg ("missing socket file name\n");
9699 if (vec_len (file_name) > 255)
9701 errmsg ("socket file name too long\n");
9704 vec_add1 (file_name, 0);
9706 M (MODIFY_VHOST_USER_IF, modify_vhost_user_if);
9708 mp->sw_if_index = ntohl (sw_if_index);
9709 mp->is_server = is_server;
9710 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
9711 vec_free (file_name);
9712 if (custom_dev_instance != ~0)
9715 mp->custom_dev_instance = ntohl (custom_dev_instance);
9725 api_delete_vhost_user_if (vat_main_t * vam)
9727 unformat_input_t *i = vam->input;
9728 vl_api_delete_vhost_user_if_t *mp;
9730 u32 sw_if_index = ~0;
9731 u8 sw_if_index_set = 0;
9733 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9735 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9736 sw_if_index_set = 1;
9737 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9738 sw_if_index_set = 1;
9743 if (sw_if_index_set == 0)
9745 errmsg ("missing sw_if_index or interface name\n");
9750 M (DELETE_VHOST_USER_IF, delete_vhost_user_if);
9752 mp->sw_if_index = ntohl (sw_if_index);
9760 static void vl_api_sw_interface_vhost_user_details_t_handler
9761 (vl_api_sw_interface_vhost_user_details_t * mp)
9763 vat_main_t *vam = &vat_main;
9765 fformat (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s\n",
9766 (char *) mp->interface_name,
9767 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
9768 clib_net_to_host_u64 (mp->features), mp->is_server,
9769 ntohl (mp->num_regions), (char *) mp->sock_filename);
9770 fformat (vam->ofp, " Status: '%s'\n", strerror (ntohl (mp->sock_errno)));
9773 static void vl_api_sw_interface_vhost_user_details_t_handler_json
9774 (vl_api_sw_interface_vhost_user_details_t * mp)
9776 vat_main_t *vam = &vat_main;
9777 vat_json_node_t *node = NULL;
9779 if (VAT_JSON_ARRAY != vam->json_tree.type)
9781 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9782 vat_json_init_array (&vam->json_tree);
9784 node = vat_json_array_add (&vam->json_tree);
9786 vat_json_init_object (node);
9787 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9788 vat_json_object_add_string_copy (node, "interface_name",
9789 mp->interface_name);
9790 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
9791 ntohl (mp->virtio_net_hdr_sz));
9792 vat_json_object_add_uint (node, "features",
9793 clib_net_to_host_u64 (mp->features));
9794 vat_json_object_add_uint (node, "is_server", mp->is_server);
9795 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
9796 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
9797 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
9801 api_sw_interface_vhost_user_dump (vat_main_t * vam)
9803 vl_api_sw_interface_vhost_user_dump_t *mp;
9806 "Interface name idx hdr_sz features server regions filename\n");
9808 /* Get list of vhost-user interfaces */
9809 M (SW_INTERFACE_VHOST_USER_DUMP, sw_interface_vhost_user_dump);
9812 /* Use a control ping for synchronization */
9814 vl_api_control_ping_t *mp;
9815 M (CONTROL_PING, control_ping);
9822 api_show_version (vat_main_t * vam)
9824 vl_api_show_version_t *mp;
9827 M (SHOW_VERSION, show_version);
9837 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
9839 unformat_input_t *line_input = vam->input;
9840 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
9842 ip4_address_t local4, remote4;
9843 ip6_address_t local6, remote6;
9845 u8 ipv4_set = 0, ipv6_set = 0;
9848 u32 encap_vrf_id = 0;
9849 u32 decap_vrf_id = 0;
9854 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9856 if (unformat (line_input, "del"))
9858 else if (unformat (line_input, "local %U",
9859 unformat_ip4_address, &local4))
9864 else if (unformat (line_input, "remote %U",
9865 unformat_ip4_address, &remote4))
9870 else if (unformat (line_input, "local %U",
9871 unformat_ip6_address, &local6))
9876 else if (unformat (line_input, "remote %U",
9877 unformat_ip6_address, &remote6))
9882 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
9884 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
9886 else if (unformat (line_input, "vni %d", &vni))
9888 else if (unformat (line_input, "next-ip4"))
9890 else if (unformat (line_input, "next-ip6"))
9892 else if (unformat (line_input, "next-ethernet"))
9894 else if (unformat (line_input, "next-nsh"))
9898 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
9905 errmsg ("tunnel local address not specified\n");
9908 if (remote_set == 0)
9910 errmsg ("tunnel remote address not specified\n");
9913 if (ipv4_set && ipv6_set)
9915 errmsg ("both IPv4 and IPv6 addresses specified");
9921 errmsg ("vni not specified\n");
9925 M (VXLAN_GPE_ADD_DEL_TUNNEL, vxlan_gpe_add_del_tunnel);
9930 clib_memcpy (&mp->local, &local6, sizeof (local6));
9931 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
9935 clib_memcpy (&mp->local, &local4, sizeof (local4));
9936 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
9939 mp->encap_vrf_id = ntohl (encap_vrf_id);
9940 mp->decap_vrf_id = ntohl (decap_vrf_id);
9941 mp->protocol = ntohl (protocol);
9942 mp->vni = ntohl (vni);
9943 mp->is_add = is_add;
9944 mp->is_ipv6 = ipv6_set;
9952 static void vl_api_vxlan_gpe_tunnel_details_t_handler
9953 (vl_api_vxlan_gpe_tunnel_details_t * mp)
9955 vat_main_t *vam = &vat_main;
9957 fformat (vam->ofp, "%11d%24U%24U%13d%12d%14d%14d\n",
9958 ntohl (mp->sw_if_index),
9959 format_ip46_address, &(mp->local[0]),
9960 format_ip46_address, &(mp->remote[0]),
9962 ntohl (mp->protocol),
9963 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
9966 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
9967 (vl_api_vxlan_gpe_tunnel_details_t * mp)
9969 vat_main_t *vam = &vat_main;
9970 vat_json_node_t *node = NULL;
9972 struct in6_addr ip6;
9974 if (VAT_JSON_ARRAY != vam->json_tree.type)
9976 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9977 vat_json_init_array (&vam->json_tree);
9979 node = vat_json_array_add (&vam->json_tree);
9981 vat_json_init_object (node);
9982 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9985 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
9986 vat_json_object_add_ip6 (node, "local", ip6);
9987 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
9988 vat_json_object_add_ip6 (node, "remote", ip6);
9992 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
9993 vat_json_object_add_ip4 (node, "local", ip4);
9994 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
9995 vat_json_object_add_ip4 (node, "remote", ip4);
9997 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
9998 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
9999 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
10000 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
10001 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
10005 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
10007 unformat_input_t *i = vam->input;
10008 vl_api_vxlan_gpe_tunnel_dump_t *mp;
10011 u8 sw_if_index_set = 0;
10013 /* Parse args required to build the message */
10014 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10016 if (unformat (i, "sw_if_index %d", &sw_if_index))
10017 sw_if_index_set = 1;
10022 if (sw_if_index_set == 0)
10027 if (!vam->json_output)
10029 fformat (vam->ofp, "%11s%24s%24s%13s%15s%14s%14s\n",
10030 "sw_if_index", "local", "remote", "vni",
10031 "protocol", "encap_vrf_id", "decap_vrf_id");
10034 /* Get list of vxlan-tunnel interfaces */
10035 M (VXLAN_GPE_TUNNEL_DUMP, vxlan_gpe_tunnel_dump);
10037 mp->sw_if_index = htonl (sw_if_index);
10041 /* Use a control ping for synchronization */
10043 vl_api_control_ping_t *mp;
10044 M (CONTROL_PING, control_ping);
10051 format_l2_fib_mac_address (u8 * s, va_list * args)
10053 u8 *a = va_arg (*args, u8 *);
10055 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
10056 a[2], a[3], a[4], a[5], a[6], a[7]);
10059 static void vl_api_l2_fib_table_entry_t_handler
10060 (vl_api_l2_fib_table_entry_t * mp)
10062 vat_main_t *vam = &vat_main;
10064 fformat (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
10066 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
10067 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
10071 static void vl_api_l2_fib_table_entry_t_handler_json
10072 (vl_api_l2_fib_table_entry_t * mp)
10074 vat_main_t *vam = &vat_main;
10075 vat_json_node_t *node = NULL;
10077 if (VAT_JSON_ARRAY != vam->json_tree.type)
10079 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10080 vat_json_init_array (&vam->json_tree);
10082 node = vat_json_array_add (&vam->json_tree);
10084 vat_json_init_object (node);
10085 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
10086 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
10087 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10088 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
10089 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
10090 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
10094 api_l2_fib_table_dump (vat_main_t * vam)
10096 unformat_input_t *i = vam->input;
10097 vl_api_l2_fib_table_dump_t *mp;
10102 /* Parse args required to build the message */
10103 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10105 if (unformat (i, "bd_id %d", &bd_id))
10111 if (bd_id_set == 0)
10113 errmsg ("missing bridge domain\n");
10118 "BD-ID Mac Address sw-ndx Static Filter BVI\n");
10120 /* Get list of l2 fib entries */
10121 M (L2_FIB_TABLE_DUMP, l2_fib_table_dump);
10123 mp->bd_id = ntohl (bd_id);
10126 /* Use a control ping for synchronization */
10128 vl_api_control_ping_t *mp;
10129 M (CONTROL_PING, control_ping);
10137 api_interface_name_renumber (vat_main_t * vam)
10139 unformat_input_t *line_input = vam->input;
10140 vl_api_interface_name_renumber_t *mp;
10141 u32 sw_if_index = ~0;
10143 u32 new_show_dev_instance = ~0;
10145 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10147 if (unformat (line_input, "%U", unformat_sw_if_index, vam,
10150 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
10152 else if (unformat (line_input, "new_show_dev_instance %d",
10153 &new_show_dev_instance))
10159 if (sw_if_index == ~0)
10161 errmsg ("missing interface name or sw_if_index\n");
10165 if (new_show_dev_instance == ~0)
10167 errmsg ("missing new_show_dev_instance\n");
10171 M (INTERFACE_NAME_RENUMBER, interface_name_renumber);
10173 mp->sw_if_index = ntohl (sw_if_index);
10174 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
10181 api_want_ip4_arp_events (vat_main_t * vam)
10183 unformat_input_t *line_input = vam->input;
10184 vl_api_want_ip4_arp_events_t *mp;
10186 ip4_address_t address;
10187 int address_set = 0;
10188 u32 enable_disable = 1;
10190 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10192 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
10194 else if (unformat (line_input, "del"))
10195 enable_disable = 0;
10200 if (address_set == 0)
10202 errmsg ("missing addresses\n");
10206 M (WANT_IP4_ARP_EVENTS, want_ip4_arp_events);
10207 mp->enable_disable = enable_disable;
10208 mp->pid = getpid ();
10209 mp->address = address.as_u32;
10216 api_input_acl_set_interface (vat_main_t * vam)
10218 unformat_input_t *i = vam->input;
10219 vl_api_input_acl_set_interface_t *mp;
10222 int sw_if_index_set;
10223 u32 ip4_table_index = ~0;
10224 u32 ip6_table_index = ~0;
10225 u32 l2_table_index = ~0;
10228 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10230 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10231 sw_if_index_set = 1;
10232 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10233 sw_if_index_set = 1;
10234 else if (unformat (i, "del"))
10236 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10238 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10240 else if (unformat (i, "l2-table %d", &l2_table_index))
10244 clib_warning ("parse error '%U'", format_unformat_error, i);
10249 if (sw_if_index_set == 0)
10251 errmsg ("missing interface name or sw_if_index\n");
10255 M (INPUT_ACL_SET_INTERFACE, input_acl_set_interface);
10257 mp->sw_if_index = ntohl (sw_if_index);
10258 mp->ip4_table_index = ntohl (ip4_table_index);
10259 mp->ip6_table_index = ntohl (ip6_table_index);
10260 mp->l2_table_index = ntohl (l2_table_index);
10261 mp->is_add = is_add;
10270 api_ip_address_dump (vat_main_t * vam)
10272 unformat_input_t *i = vam->input;
10273 vl_api_ip_address_dump_t *mp;
10274 u32 sw_if_index = ~0;
10275 u8 sw_if_index_set = 0;
10280 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10282 if (unformat (i, "sw_if_index %d", &sw_if_index))
10283 sw_if_index_set = 1;
10284 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10285 sw_if_index_set = 1;
10286 else if (unformat (i, "ipv4"))
10288 else if (unformat (i, "ipv6"))
10294 if (ipv4_set && ipv6_set)
10296 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
10300 if ((!ipv4_set) && (!ipv6_set))
10302 errmsg ("no ipv4 nor ipv6 flag set\n");
10306 if (sw_if_index_set == 0)
10308 errmsg ("missing interface name or sw_if_index\n");
10312 vam->current_sw_if_index = sw_if_index;
10313 vam->is_ipv6 = ipv6_set;
10315 M (IP_ADDRESS_DUMP, ip_address_dump);
10316 mp->sw_if_index = ntohl (sw_if_index);
10317 mp->is_ipv6 = ipv6_set;
10320 /* Use a control ping for synchronization */
10322 vl_api_control_ping_t *mp;
10323 M (CONTROL_PING, control_ping);
10330 api_ip_dump (vat_main_t * vam)
10332 vl_api_ip_dump_t *mp;
10333 unformat_input_t *in = vam->input;
10340 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
10342 if (unformat (in, "ipv4"))
10344 else if (unformat (in, "ipv6"))
10350 if (ipv4_set && ipv6_set)
10352 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
10356 if ((!ipv4_set) && (!ipv6_set))
10358 errmsg ("no ipv4 nor ipv6 flag set\n");
10362 is_ipv6 = ipv6_set;
10363 vam->is_ipv6 = is_ipv6;
10365 /* free old data */
10366 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
10368 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
10370 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
10372 M (IP_DUMP, ip_dump);
10373 mp->is_ipv6 = ipv6_set;
10376 /* Use a control ping for synchronization */
10378 vl_api_control_ping_t *mp;
10379 M (CONTROL_PING, control_ping);
10386 api_ipsec_spd_add_del (vat_main_t * vam)
10389 unformat_input_t *i = vam->input;
10390 vl_api_ipsec_spd_add_del_t *mp;
10395 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10397 if (unformat (i, "spd_id %d", &spd_id))
10399 else if (unformat (i, "del"))
10403 clib_warning ("parse error '%U'", format_unformat_error, i);
10409 errmsg ("spd_id must be set\n");
10413 M (IPSEC_SPD_ADD_DEL, ipsec_spd_add_del);
10415 mp->spd_id = ntohl (spd_id);
10416 mp->is_add = is_add;
10423 clib_warning ("unsupported (no dpdk)");
10429 api_ipsec_interface_add_del_spd (vat_main_t * vam)
10432 unformat_input_t *i = vam->input;
10433 vl_api_ipsec_interface_add_del_spd_t *mp;
10436 u8 sw_if_index_set = 0;
10437 u32 spd_id = (u32) ~ 0;
10440 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10442 if (unformat (i, "del"))
10444 else if (unformat (i, "spd_id %d", &spd_id))
10446 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10447 sw_if_index_set = 1;
10448 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10449 sw_if_index_set = 1;
10452 clib_warning ("parse error '%U'", format_unformat_error, i);
10458 if (spd_id == (u32) ~ 0)
10460 errmsg ("spd_id must be set\n");
10464 if (sw_if_index_set == 0)
10466 errmsg ("missing interface name or sw_if_index\n");
10470 M (IPSEC_INTERFACE_ADD_DEL_SPD, ipsec_interface_add_del_spd);
10472 mp->spd_id = ntohl (spd_id);
10473 mp->sw_if_index = ntohl (sw_if_index);
10474 mp->is_add = is_add;
10481 clib_warning ("unsupported (no dpdk)");
10487 api_ipsec_spd_add_del_entry (vat_main_t * vam)
10490 unformat_input_t *i = vam->input;
10491 vl_api_ipsec_spd_add_del_entry_t *mp;
10493 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
10494 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
10496 u32 rport_start = 0, rport_stop = (u32) ~ 0;
10497 u32 lport_start = 0, lport_stop = (u32) ~ 0;
10498 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
10499 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
10501 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
10502 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
10503 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
10504 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
10505 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
10506 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
10508 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10510 if (unformat (i, "del"))
10512 if (unformat (i, "outbound"))
10514 if (unformat (i, "inbound"))
10516 else if (unformat (i, "spd_id %d", &spd_id))
10518 else if (unformat (i, "sa_id %d", &sa_id))
10520 else if (unformat (i, "priority %d", &priority))
10522 else if (unformat (i, "protocol %d", &protocol))
10524 else if (unformat (i, "lport_start %d", &lport_start))
10526 else if (unformat (i, "lport_stop %d", &lport_stop))
10528 else if (unformat (i, "rport_start %d", &rport_start))
10530 else if (unformat (i, "rport_stop %d", &rport_stop))
10534 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
10540 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
10547 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
10553 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
10560 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
10566 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
10573 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
10579 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
10585 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
10587 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
10589 clib_warning ("unsupported action: 'resolve'");
10595 clib_warning ("parse error '%U'", format_unformat_error, i);
10601 M (IPSEC_SPD_ADD_DEL_ENTRY, ipsec_spd_add_del_entry);
10603 mp->spd_id = ntohl (spd_id);
10604 mp->priority = ntohl (priority);
10605 mp->is_outbound = is_outbound;
10607 mp->is_ipv6 = is_ipv6;
10608 if (is_ipv6 || is_ip_any)
10610 clib_memcpy (mp->remote_address_start, &raddr6_start,
10611 sizeof (ip6_address_t));
10612 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
10613 sizeof (ip6_address_t));
10614 clib_memcpy (mp->local_address_start, &laddr6_start,
10615 sizeof (ip6_address_t));
10616 clib_memcpy (mp->local_address_stop, &laddr6_stop,
10617 sizeof (ip6_address_t));
10621 clib_memcpy (mp->remote_address_start, &raddr4_start,
10622 sizeof (ip4_address_t));
10623 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
10624 sizeof (ip4_address_t));
10625 clib_memcpy (mp->local_address_start, &laddr4_start,
10626 sizeof (ip4_address_t));
10627 clib_memcpy (mp->local_address_stop, &laddr4_stop,
10628 sizeof (ip4_address_t));
10630 mp->protocol = (u8) protocol;
10631 mp->local_port_start = ntohs ((u16) lport_start);
10632 mp->local_port_stop = ntohs ((u16) lport_stop);
10633 mp->remote_port_start = ntohs ((u16) rport_start);
10634 mp->remote_port_stop = ntohs ((u16) rport_stop);
10635 mp->policy = (u8) policy;
10636 mp->sa_id = ntohl (sa_id);
10637 mp->is_add = is_add;
10638 mp->is_ip_any = is_ip_any;
10644 clib_warning ("unsupported (no dpdk)");
10650 api_ipsec_sad_add_del_entry (vat_main_t * vam)
10653 unformat_input_t *i = vam->input;
10654 vl_api_ipsec_sad_add_del_entry_t *mp;
10656 u32 sad_id = 0, spi = 0;
10657 u8 *ck = 0, *ik = 0;
10660 u8 protocol = IPSEC_PROTOCOL_AH;
10661 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
10662 u32 crypto_alg = 0, integ_alg = 0;
10663 ip4_address_t tun_src4;
10664 ip4_address_t tun_dst4;
10665 ip6_address_t tun_src6;
10666 ip6_address_t tun_dst6;
10668 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10670 if (unformat (i, "del"))
10672 else if (unformat (i, "sad_id %d", &sad_id))
10674 else if (unformat (i, "spi %d", &spi))
10676 else if (unformat (i, "esp"))
10677 protocol = IPSEC_PROTOCOL_ESP;
10678 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
10681 is_tunnel_ipv6 = 0;
10683 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
10686 is_tunnel_ipv6 = 0;
10688 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
10691 is_tunnel_ipv6 = 1;
10693 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
10696 is_tunnel_ipv6 = 1;
10700 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
10702 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
10703 crypto_alg > IPSEC_INTEG_ALG_SHA_512_256)
10705 clib_warning ("unsupported crypto-alg: '%U'",
10706 format_ipsec_crypto_alg, crypto_alg);
10710 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
10714 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
10716 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
10717 integ_alg > IPSEC_INTEG_ALG_SHA_512_256)
10719 clib_warning ("unsupported integ-alg: '%U'",
10720 format_ipsec_integ_alg, integ_alg);
10724 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
10728 clib_warning ("parse error '%U'", format_unformat_error, i);
10734 M (IPSEC_SAD_ADD_DEL_ENTRY, ipsec_sad_add_del_entry);
10736 mp->sad_id = ntohl (sad_id);
10737 mp->is_add = is_add;
10738 mp->protocol = protocol;
10739 mp->spi = ntohl (spi);
10740 mp->is_tunnel = is_tunnel;
10741 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
10742 mp->crypto_algorithm = crypto_alg;
10743 mp->integrity_algorithm = integ_alg;
10744 mp->crypto_key_length = vec_len (ck);
10745 mp->integrity_key_length = vec_len (ik);
10747 if (mp->crypto_key_length > sizeof (mp->crypto_key))
10748 mp->crypto_key_length = sizeof (mp->crypto_key);
10750 if (mp->integrity_key_length > sizeof (mp->integrity_key))
10751 mp->integrity_key_length = sizeof (mp->integrity_key);
10754 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
10756 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
10760 if (is_tunnel_ipv6)
10762 clib_memcpy (mp->tunnel_src_address, &tun_src6,
10763 sizeof (ip6_address_t));
10764 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
10765 sizeof (ip6_address_t));
10769 clib_memcpy (mp->tunnel_src_address, &tun_src4,
10770 sizeof (ip4_address_t));
10771 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
10772 sizeof (ip4_address_t));
10781 clib_warning ("unsupported (no dpdk)");
10787 api_ipsec_sa_set_key (vat_main_t * vam)
10790 unformat_input_t *i = vam->input;
10791 vl_api_ipsec_sa_set_key_t *mp;
10794 u8 *ck = 0, *ik = 0;
10796 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10798 if (unformat (i, "sa_id %d", &sa_id))
10800 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
10802 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
10806 clib_warning ("parse error '%U'", format_unformat_error, i);
10811 M (IPSEC_SA_SET_KEY, ipsec_set_sa_key);
10813 mp->sa_id = ntohl (sa_id);
10814 mp->crypto_key_length = vec_len (ck);
10815 mp->integrity_key_length = vec_len (ik);
10817 if (mp->crypto_key_length > sizeof (mp->crypto_key))
10818 mp->crypto_key_length = sizeof (mp->crypto_key);
10820 if (mp->integrity_key_length > sizeof (mp->integrity_key))
10821 mp->integrity_key_length = sizeof (mp->integrity_key);
10824 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
10826 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
10833 clib_warning ("unsupported (no dpdk)");
10839 api_ikev2_profile_add_del (vat_main_t * vam)
10842 unformat_input_t *i = vam->input;
10843 vl_api_ikev2_profile_add_del_t *mp;
10848 const char *valid_chars = "a-zA-Z0-9_";
10850 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10852 if (unformat (i, "del"))
10854 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
10855 vec_add1 (name, 0);
10858 errmsg ("parse error '%U'", format_unformat_error, i);
10863 if (!vec_len (name))
10865 errmsg ("profile name must be specified");
10869 if (vec_len (name) > 64)
10871 errmsg ("profile name too long");
10875 M (IKEV2_PROFILE_ADD_DEL, ikev2_profile_add_del);
10877 clib_memcpy (mp->name, name, vec_len (name));
10878 mp->is_add = is_add;
10886 clib_warning ("unsupported (no dpdk)");
10892 api_ikev2_profile_set_auth (vat_main_t * vam)
10895 unformat_input_t *i = vam->input;
10896 vl_api_ikev2_profile_set_auth_t *mp;
10900 u32 auth_method = 0;
10903 const char *valid_chars = "a-zA-Z0-9_";
10905 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10907 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
10908 vec_add1 (name, 0);
10909 else if (unformat (i, "auth_method %U",
10910 unformat_ikev2_auth_method, &auth_method))
10912 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
10914 else if (unformat (i, "auth_data %v", &data))
10918 errmsg ("parse error '%U'", format_unformat_error, i);
10923 if (!vec_len (name))
10925 errmsg ("profile name must be specified");
10929 if (vec_len (name) > 64)
10931 errmsg ("profile name too long");
10935 if (!vec_len (data))
10937 errmsg ("auth_data must be specified");
10943 errmsg ("auth_method must be specified");
10947 M (IKEV2_PROFILE_SET_AUTH, ikev2_profile_set_auth);
10949 mp->is_hex = is_hex;
10950 mp->auth_method = (u8) auth_method;
10951 mp->data_len = vec_len (data);
10952 clib_memcpy (mp->name, name, vec_len (name));
10953 clib_memcpy (mp->data, data, vec_len (data));
10962 clib_warning ("unsupported (no dpdk)");
10968 api_ikev2_profile_set_id (vat_main_t * vam)
10971 unformat_input_t *i = vam->input;
10972 vl_api_ikev2_profile_set_id_t *mp;
10980 const char *valid_chars = "a-zA-Z0-9_";
10982 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10984 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
10985 vec_add1 (name, 0);
10986 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
10988 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
10990 data = vec_new (u8, 4);
10991 clib_memcpy (data, ip4.as_u8, 4);
10993 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
10995 else if (unformat (i, "id_data %v", &data))
10997 else if (unformat (i, "local"))
10999 else if (unformat (i, "remote"))
11003 errmsg ("parse error '%U'", format_unformat_error, i);
11008 if (!vec_len (name))
11010 errmsg ("profile name must be specified");
11014 if (vec_len (name) > 64)
11016 errmsg ("profile name too long");
11020 if (!vec_len (data))
11022 errmsg ("id_data must be specified");
11028 errmsg ("id_type must be specified");
11032 M (IKEV2_PROFILE_SET_ID, ikev2_profile_set_id);
11034 mp->is_local = is_local;
11035 mp->id_type = (u8) id_type;
11036 mp->data_len = vec_len (data);
11037 clib_memcpy (mp->name, name, vec_len (name));
11038 clib_memcpy (mp->data, data, vec_len (data));
11047 clib_warning ("unsupported (no dpdk)");
11053 api_ikev2_profile_set_ts (vat_main_t * vam)
11056 unformat_input_t *i = vam->input;
11057 vl_api_ikev2_profile_set_ts_t *mp;
11061 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
11062 ip4_address_t start_addr, end_addr;
11064 const char *valid_chars = "a-zA-Z0-9_";
11066 start_addr.as_u32 = 0;
11067 end_addr.as_u32 = (u32) ~ 0;
11069 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11071 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11072 vec_add1 (name, 0);
11073 else if (unformat (i, "protocol %d", &proto))
11075 else if (unformat (i, "start_port %d", &start_port))
11077 else if (unformat (i, "end_port %d", &end_port))
11080 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
11082 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
11084 else if (unformat (i, "local"))
11086 else if (unformat (i, "remote"))
11090 errmsg ("parse error '%U'", format_unformat_error, i);
11095 if (!vec_len (name))
11097 errmsg ("profile name must be specified");
11101 if (vec_len (name) > 64)
11103 errmsg ("profile name too long");
11107 M (IKEV2_PROFILE_SET_TS, ikev2_profile_set_ts);
11109 mp->is_local = is_local;
11110 mp->proto = (u8) proto;
11111 mp->start_port = (u16) start_port;
11112 mp->end_port = (u16) end_port;
11113 mp->start_addr = start_addr.as_u32;
11114 mp->end_addr = end_addr.as_u32;
11115 clib_memcpy (mp->name, name, vec_len (name));
11123 clib_warning ("unsupported (no dpdk)");
11129 api_ikev2_set_local_key (vat_main_t * vam)
11132 unformat_input_t *i = vam->input;
11133 vl_api_ikev2_set_local_key_t *mp;
11137 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11139 if (unformat (i, "file %v", &file))
11140 vec_add1 (file, 0);
11143 errmsg ("parse error '%U'", format_unformat_error, i);
11148 if (!vec_len (file))
11150 errmsg ("RSA key file must be specified");
11154 if (vec_len (file) > 256)
11156 errmsg ("file name too long");
11160 M (IKEV2_SET_LOCAL_KEY, ikev2_set_local_key);
11162 clib_memcpy (mp->key_file, file, vec_len (file));
11170 clib_warning ("unsupported (no dpdk)");
11179 api_map_add_domain (vat_main_t * vam)
11181 unformat_input_t *i = vam->input;
11182 vl_api_map_add_domain_t *mp;
11185 ip4_address_t ip4_prefix;
11186 ip6_address_t ip6_prefix;
11187 ip6_address_t ip6_src;
11188 u32 num_m_args = 0;
11189 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
11190 0, psid_length = 0;
11191 u8 is_translation = 0;
11193 u32 ip6_src_len = 128;
11195 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11197 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
11198 &ip4_prefix, &ip4_prefix_len))
11200 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
11201 &ip6_prefix, &ip6_prefix_len))
11205 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
11208 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
11210 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
11212 else if (unformat (i, "psid-offset %d", &psid_offset))
11214 else if (unformat (i, "psid-len %d", &psid_length))
11216 else if (unformat (i, "mtu %d", &mtu))
11218 else if (unformat (i, "map-t"))
11219 is_translation = 1;
11222 clib_warning ("parse error '%U'", format_unformat_error, i);
11227 if (num_m_args != 6)
11229 errmsg ("mandatory argument(s) missing\n");
11233 /* Construct the API message */
11234 M (MAP_ADD_DOMAIN, map_add_domain);
11236 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
11237 mp->ip4_prefix_len = ip4_prefix_len;
11239 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
11240 mp->ip6_prefix_len = ip6_prefix_len;
11242 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
11243 mp->ip6_src_prefix_len = ip6_src_len;
11245 mp->ea_bits_len = ea_bits_len;
11246 mp->psid_offset = psid_offset;
11247 mp->psid_length = psid_length;
11248 mp->is_translation = is_translation;
11249 mp->mtu = htons (mtu);
11254 /* Wait for a reply, return good/bad news */
11259 api_map_del_domain (vat_main_t * vam)
11261 unformat_input_t *i = vam->input;
11262 vl_api_map_del_domain_t *mp;
11265 u32 num_m_args = 0;
11268 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11270 if (unformat (i, "index %d", &index))
11274 clib_warning ("parse error '%U'", format_unformat_error, i);
11279 if (num_m_args != 1)
11281 errmsg ("mandatory argument(s) missing\n");
11285 /* Construct the API message */
11286 M (MAP_DEL_DOMAIN, map_del_domain);
11288 mp->index = ntohl (index);
11293 /* Wait for a reply, return good/bad news */
11298 api_map_add_del_rule (vat_main_t * vam)
11300 unformat_input_t *i = vam->input;
11301 vl_api_map_add_del_rule_t *mp;
11304 ip6_address_t ip6_dst;
11305 u32 num_m_args = 0, index, psid = 0;
11307 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11309 if (unformat (i, "index %d", &index))
11311 else if (unformat (i, "psid %d", &psid))
11313 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
11315 else if (unformat (i, "del"))
11321 clib_warning ("parse error '%U'", format_unformat_error, i);
11326 /* Construct the API message */
11327 M (MAP_ADD_DEL_RULE, map_add_del_rule);
11329 mp->index = ntohl (index);
11330 mp->is_add = is_add;
11331 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
11332 mp->psid = ntohs (psid);
11337 /* Wait for a reply, return good/bad news */
11342 api_map_domain_dump (vat_main_t * vam)
11344 vl_api_map_domain_dump_t *mp;
11347 /* Construct the API message */
11348 M (MAP_DOMAIN_DUMP, map_domain_dump);
11353 /* Use a control ping for synchronization */
11355 vl_api_control_ping_t *mp;
11356 M (CONTROL_PING, control_ping);
11363 api_map_rule_dump (vat_main_t * vam)
11365 unformat_input_t *i = vam->input;
11366 vl_api_map_rule_dump_t *mp;
11368 u32 domain_index = ~0;
11370 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11372 if (unformat (i, "index %u", &domain_index))
11378 if (domain_index == ~0)
11380 clib_warning ("parse error: domain index expected");
11384 /* Construct the API message */
11385 M (MAP_RULE_DUMP, map_rule_dump);
11387 mp->domain_index = htonl (domain_index);
11392 /* Use a control ping for synchronization */
11394 vl_api_control_ping_t *mp;
11395 M (CONTROL_PING, control_ping);
11401 static void vl_api_map_add_domain_reply_t_handler
11402 (vl_api_map_add_domain_reply_t * mp)
11404 vat_main_t *vam = &vat_main;
11405 i32 retval = ntohl (mp->retval);
11407 if (vam->async_mode)
11409 vam->async_errors += (retval < 0);
11413 vam->retval = retval;
11414 vam->result_ready = 1;
11418 static void vl_api_map_add_domain_reply_t_handler_json
11419 (vl_api_map_add_domain_reply_t * mp)
11421 vat_main_t *vam = &vat_main;
11422 vat_json_node_t node;
11424 vat_json_init_object (&node);
11425 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
11426 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
11428 vat_json_print (vam->ofp, &node);
11429 vat_json_free (&node);
11431 vam->retval = ntohl (mp->retval);
11432 vam->result_ready = 1;
11436 api_get_first_msg_id (vat_main_t * vam)
11438 vl_api_get_first_msg_id_t *mp;
11440 unformat_input_t *i = vam->input;
11444 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11446 if (unformat (i, "client %s", &name))
11454 errmsg ("missing client name\n");
11457 vec_add1 (name, 0);
11459 if (vec_len (name) > 63)
11461 errmsg ("client name too long\n");
11465 M (GET_FIRST_MSG_ID, get_first_msg_id);
11466 clib_memcpy (mp->name, name, vec_len (name));
11474 api_cop_interface_enable_disable (vat_main_t * vam)
11476 unformat_input_t *line_input = vam->input;
11477 vl_api_cop_interface_enable_disable_t *mp;
11479 u32 sw_if_index = ~0;
11480 u8 enable_disable = 1;
11482 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11484 if (unformat (line_input, "disable"))
11485 enable_disable = 0;
11486 if (unformat (line_input, "enable"))
11487 enable_disable = 1;
11488 else if (unformat (line_input, "%U", unformat_sw_if_index,
11489 vam, &sw_if_index))
11491 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11497 if (sw_if_index == ~0)
11499 errmsg ("missing interface name or sw_if_index\n");
11503 /* Construct the API message */
11504 M (COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable);
11505 mp->sw_if_index = ntohl (sw_if_index);
11506 mp->enable_disable = enable_disable;
11510 /* Wait for the reply */
11515 api_cop_whitelist_enable_disable (vat_main_t * vam)
11517 unformat_input_t *line_input = vam->input;
11518 vl_api_cop_whitelist_enable_disable_t *mp;
11520 u32 sw_if_index = ~0;
11521 u8 ip4 = 0, ip6 = 0, default_cop = 0;
11524 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11526 if (unformat (line_input, "ip4"))
11528 else if (unformat (line_input, "ip6"))
11530 else if (unformat (line_input, "default"))
11532 else if (unformat (line_input, "%U", unformat_sw_if_index,
11533 vam, &sw_if_index))
11535 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11537 else if (unformat (line_input, "fib-id %d", &fib_id))
11543 if (sw_if_index == ~0)
11545 errmsg ("missing interface name or sw_if_index\n");
11549 /* Construct the API message */
11550 M (COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable);
11551 mp->sw_if_index = ntohl (sw_if_index);
11552 mp->fib_id = ntohl (fib_id);
11555 mp->default_cop = default_cop;
11559 /* Wait for the reply */
11564 api_get_node_graph (vat_main_t * vam)
11566 vl_api_get_node_graph_t *mp;
11569 M (GET_NODE_GRAPH, get_node_graph);
11573 /* Wait for the reply */
11578 /** Used for parsing LISP eids */
11579 typedef CLIB_PACKED(struct{
11580 u8 addr[16]; /**< eid address */
11581 u32 len; /**< prefix length if IP */
11582 u8 type; /**< type of eid */
11587 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
11589 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
11591 memset (a, 0, sizeof (a[0]));
11593 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
11595 a->type = 0; /* ipv4 type */
11597 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
11599 a->type = 1; /* ipv6 type */
11601 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
11603 a->type = 2; /* mac type */
11610 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
11619 lisp_eid_size_vat (u8 type)
11634 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
11636 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
11640 /** Used for transferring locators via VPP API */
11641 typedef CLIB_PACKED(struct
11643 u32 sw_if_index; /**< locator sw_if_index */
11644 u8 priority; /**< locator priority */
11645 u8 weight; /**< locator weight */
11650 api_lisp_add_del_locator_set (vat_main_t * vam)
11652 unformat_input_t *input = vam->input;
11653 vl_api_lisp_add_del_locator_set_t *mp;
11656 u8 *locator_set_name = NULL;
11657 u8 locator_set_name_set = 0;
11658 ls_locator_t locator, *locators = 0;
11659 u32 sw_if_index, priority, weight;
11661 /* Parse args required to build the message */
11662 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11664 if (unformat (input, "del"))
11668 else if (unformat (input, "locator-set %s", &locator_set_name))
11670 locator_set_name_set = 1;
11672 else if (unformat (input, "sw_if_index %u p %u w %u",
11673 &sw_if_index, &priority, &weight))
11675 locator.sw_if_index = htonl (sw_if_index);
11676 locator.priority = priority;
11677 locator.weight = weight;
11678 vec_add1 (locators, locator);
11680 else if (unformat (input, "iface %U p %u w %u", unformat_sw_if_index,
11681 vam, &sw_if_index, &priority, &weight))
11683 locator.sw_if_index = htonl (sw_if_index);
11684 locator.priority = priority;
11685 locator.weight = weight;
11686 vec_add1 (locators, locator);
11692 if (locator_set_name_set == 0)
11694 errmsg ("missing locator-set name");
11695 vec_free (locators);
11699 if (vec_len (locator_set_name) > 64)
11701 errmsg ("locator-set name too long\n");
11702 vec_free (locator_set_name);
11703 vec_free (locators);
11706 vec_add1 (locator_set_name, 0);
11708 /* Construct the API message */
11709 M (LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set);
11711 mp->is_add = is_add;
11712 clib_memcpy (mp->locator_set_name, locator_set_name,
11713 vec_len (locator_set_name));
11714 vec_free (locator_set_name);
11716 mp->locator_num = vec_len (locators);
11718 clib_memcpy (mp->locators, locators,
11719 (sizeof (ls_locator_t) * vec_len (locators)));
11720 vec_free (locators);
11725 /* Wait for a reply... */
11733 api_lisp_add_del_locator (vat_main_t * vam)
11735 unformat_input_t *input = vam->input;
11736 vl_api_lisp_add_del_locator_t *mp;
11738 u32 tmp_if_index = ~0;
11739 u32 sw_if_index = ~0;
11740 u8 sw_if_index_set = 0;
11741 u8 sw_if_index_if_name_set = 0;
11743 u8 priority_set = 0;
11747 u8 *locator_set_name = NULL;
11748 u8 locator_set_name_set = 0;
11750 /* Parse args required to build the message */
11751 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11753 if (unformat (input, "del"))
11757 else if (unformat (input, "locator-set %s", &locator_set_name))
11759 locator_set_name_set = 1;
11761 else if (unformat (input, "iface %U", unformat_sw_if_index, vam,
11764 sw_if_index_if_name_set = 1;
11765 sw_if_index = tmp_if_index;
11767 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
11769 sw_if_index_set = 1;
11770 sw_if_index = tmp_if_index;
11772 else if (unformat (input, "p %d", &priority))
11776 else if (unformat (input, "w %d", &weight))
11784 if (locator_set_name_set == 0)
11786 errmsg ("missing locator-set name");
11790 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
11792 errmsg ("missing sw_if_index");
11793 vec_free (locator_set_name);
11797 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
11799 errmsg ("cannot use both params interface name and sw_if_index");
11800 vec_free (locator_set_name);
11804 if (priority_set == 0)
11806 errmsg ("missing locator-set priority\n");
11807 vec_free (locator_set_name);
11811 if (weight_set == 0)
11813 errmsg ("missing locator-set weight\n");
11814 vec_free (locator_set_name);
11818 if (vec_len (locator_set_name) > 64)
11820 errmsg ("locator-set name too long\n");
11821 vec_free (locator_set_name);
11824 vec_add1 (locator_set_name, 0);
11826 /* Construct the API message */
11827 M (LISP_ADD_DEL_LOCATOR, lisp_add_del_locator);
11829 mp->is_add = is_add;
11830 mp->sw_if_index = ntohl (sw_if_index);
11831 mp->priority = priority;
11832 mp->weight = weight;
11833 clib_memcpy (mp->locator_set_name, locator_set_name,
11834 vec_len (locator_set_name));
11835 vec_free (locator_set_name);
11840 /* Wait for a reply... */
11848 api_lisp_add_del_local_eid (vat_main_t * vam)
11850 unformat_input_t *input = vam->input;
11851 vl_api_lisp_add_del_local_eid_t *mp;
11855 lisp_eid_vat_t _eid, *eid = &_eid;
11856 u8 *locator_set_name = 0;
11857 u8 locator_set_name_set = 0;
11860 /* Parse args required to build the message */
11861 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11863 if (unformat (input, "del"))
11867 else if (unformat (input, "vni %d", &vni))
11871 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
11875 else if (unformat (input, "locator-set %s", &locator_set_name))
11877 locator_set_name_set = 1;
11883 if (locator_set_name_set == 0)
11885 errmsg ("missing locator-set name\n");
11891 errmsg ("EID address not set!");
11892 vec_free (locator_set_name);
11896 if (vec_len (locator_set_name) > 64)
11898 errmsg ("locator-set name too long\n");
11899 vec_free (locator_set_name);
11902 vec_add1 (locator_set_name, 0);
11904 /* Construct the API message */
11905 M (LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid);
11907 mp->is_add = is_add;
11908 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
11909 mp->eid_type = eid->type;
11910 mp->prefix_len = eid->len;
11911 mp->vni = clib_host_to_net_u32 (vni);
11912 clib_memcpy (mp->locator_set_name, locator_set_name,
11913 vec_len (locator_set_name));
11915 vec_free (locator_set_name);
11920 /* Wait for a reply... */
11928 /** Used for transferring locators via VPP API */
11929 typedef CLIB_PACKED(struct
11931 u8 is_ip4; /**< is locator an IPv4 address? */
11932 u8 priority; /**< locator priority */
11933 u8 weight; /**< locator weight */
11934 u8 addr[16]; /**< IPv4/IPv6 address */
11939 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
11941 unformat_input_t *input = vam->input;
11942 vl_api_lisp_gpe_add_del_fwd_entry_t *mp;
11945 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
11946 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
11947 u8 rmt_eid_set = 0, lcl_eid_set = 0;
11948 u32 action = ~0, p, w;
11949 ip4_address_t rmt_rloc4, lcl_rloc4;
11950 ip6_address_t rmt_rloc6, lcl_rloc6;
11951 rloc_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
11953 memset (&rloc, 0, sizeof (rloc));
11955 /* Parse args required to build the message */
11956 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11958 if (unformat (input, "del"))
11962 else if (unformat (input, "rmt_eid %U", unformat_lisp_eid_vat, rmt_eid))
11966 else if (unformat (input, "lcl_eid %U", unformat_lisp_eid_vat, lcl_eid))
11970 else if (unformat (input, "p %d w %d", &p, &w))
11974 errmsg ("No RLOC configured for setting priority/weight!");
11977 curr_rloc->priority = p;
11978 curr_rloc->weight = w;
11980 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
11981 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
11985 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
11986 rloc.priority = rloc.weight = 0;
11987 vec_add1 (lcl_locs, rloc);
11989 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
11990 vec_add1 (rmt_locs, rloc);
11991 /* priority and weight saved in rmt loc */
11992 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
11994 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
11995 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
11998 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
11999 rloc.priority = rloc.weight = 0;
12000 vec_add1 (lcl_locs, rloc);
12002 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
12003 vec_add1 (rmt_locs, rloc);
12004 /* priority and weight saved in rmt loc */
12005 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
12007 else if (unformat (input, "action %d", &action))
12013 clib_warning ("parse error '%U'", format_unformat_error, input);
12020 errmsg ("remote eid addresses not set\n");
12024 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
12026 errmsg ("eid types don't match\n");
12030 if (0 == rmt_locs && (u32) ~ 0 == action)
12032 errmsg ("action not set for negative mapping\n");
12036 /* Construct the API message */
12037 M (LISP_GPE_ADD_DEL_FWD_ENTRY, lisp_gpe_add_del_fwd_entry);
12039 mp->is_add = is_add;
12040 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
12041 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
12042 mp->eid_type = rmt_eid->type;
12043 mp->rmt_len = rmt_eid->len;
12044 mp->lcl_len = lcl_eid->len;
12045 mp->action = action;
12047 if (0 != rmt_locs && 0 != lcl_locs)
12049 mp->loc_num = vec_len (rmt_locs);
12050 clib_memcpy (mp->lcl_locs, lcl_locs,
12051 (sizeof (rloc_t) * vec_len (lcl_locs)));
12052 clib_memcpy (mp->rmt_locs, rmt_locs,
12053 (sizeof (rloc_t) * vec_len (rmt_locs)));
12055 vec_free (lcl_locs);
12056 vec_free (rmt_locs);
12061 /* Wait for a reply... */
12069 api_lisp_add_del_map_resolver (vat_main_t * vam)
12071 unformat_input_t *input = vam->input;
12072 vl_api_lisp_add_del_map_resolver_t *mp;
12077 ip4_address_t ipv4;
12078 ip6_address_t ipv6;
12080 /* Parse args required to build the message */
12081 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12083 if (unformat (input, "del"))
12087 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
12091 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
12099 if (ipv4_set && ipv6_set)
12101 errmsg ("both eid v4 and v6 addresses set\n");
12105 if (!ipv4_set && !ipv6_set)
12107 errmsg ("eid addresses not set\n");
12111 /* Construct the API message */
12112 M (LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver);
12114 mp->is_add = is_add;
12118 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
12123 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
12129 /* Wait for a reply... */
12137 api_lisp_gpe_enable_disable (vat_main_t * vam)
12139 unformat_input_t *input = vam->input;
12140 vl_api_lisp_gpe_enable_disable_t *mp;
12145 /* Parse args required to build the message */
12146 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12148 if (unformat (input, "enable"))
12153 else if (unformat (input, "disable"))
12164 errmsg ("Value not set\n");
12168 /* Construct the API message */
12169 M (LISP_GPE_ENABLE_DISABLE, lisp_gpe_enable_disable);
12176 /* Wait for a reply... */
12184 api_lisp_enable_disable (vat_main_t * vam)
12186 unformat_input_t *input = vam->input;
12187 vl_api_lisp_enable_disable_t *mp;
12192 /* Parse args required to build the message */
12193 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12195 if (unformat (input, "enable"))
12200 else if (unformat (input, "disable"))
12210 errmsg ("Value not set\n");
12214 /* Construct the API message */
12215 M (LISP_ENABLE_DISABLE, lisp_enable_disable);
12222 /* Wait for a reply... */
12230 * Enable/disable LISP proxy ITR.
12232 * @param vam vpp API test context
12233 * @return return code
12236 api_lisp_pitr_set_locator_set (vat_main_t * vam)
12239 u8 ls_name_set = 0;
12240 unformat_input_t *input = vam->input;
12241 vl_api_lisp_pitr_set_locator_set_t *mp;
12245 /* Parse args required to build the message */
12246 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12248 if (unformat (input, "del"))
12250 else if (unformat (input, "locator-set %s", &ls_name))
12254 errmsg ("parse error '%U'", format_unformat_error, input);
12261 errmsg ("locator-set name not set!");
12265 M (LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set);
12267 mp->is_add = is_add;
12268 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
12269 vec_free (ls_name);
12274 /* wait for reply */
12282 api_show_lisp_pitr (vat_main_t * vam)
12284 vl_api_show_lisp_pitr_t *mp;
12287 if (!vam->json_output)
12289 fformat (vam->ofp, "%=20s\n", "lisp status:");
12292 M (SHOW_LISP_PITR, show_lisp_pitr);
12296 /* Wait for a reply... */
12304 * Add/delete mapping between vni and vrf
12307 api_lisp_eid_table_add_del_map (vat_main_t * vam)
12310 unformat_input_t *input = vam->input;
12311 vl_api_lisp_eid_table_add_del_map_t *mp;
12312 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
12313 u32 vni, vrf, bd_index;
12315 /* Parse args required to build the message */
12316 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12318 if (unformat (input, "del"))
12320 else if (unformat (input, "vrf %d", &vrf))
12322 else if (unformat (input, "bd_index %d", &bd_index))
12324 else if (unformat (input, "vni %d", &vni))
12330 if (!vni_set || (!vrf_set && !bd_index_set))
12332 errmsg ("missing arguments!");
12336 M (LISP_EID_TABLE_ADD_DEL_MAP, lisp_eid_table_add_del_map);
12338 mp->is_add = is_add;
12339 mp->vni = htonl (vni);
12340 mp->dp_table = htonl (vrf);
12341 mp->is_l2 = bd_index_set;
12346 /* wait for reply */
12354 * Add/del remote mapping to/from LISP control plane
12356 * @param vam vpp API test context
12357 * @return return code
12360 api_lisp_add_del_remote_mapping (vat_main_t * vam)
12362 unformat_input_t *input = vam->input;
12363 vl_api_lisp_add_del_remote_mapping_t *mp;
12366 //TODO: seid need remove
12367 lisp_eid_vat_t _eid, *eid = &_eid;
12368 lisp_eid_vat_t _seid, *seid = &_seid;
12369 u8 is_add = 1, del_all = 0, eid_set = 0;
12370 u32 action = ~0, p, w;
12371 ip4_address_t rloc4;
12372 ip6_address_t rloc6;
12373 rloc_t *rlocs = 0, rloc, *curr_rloc = 0;
12375 memset (&rloc, 0, sizeof (rloc));
12377 /* Parse args required to build the message */
12378 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12380 if (unformat (input, "del-all"))
12384 else if (unformat (input, "del"))
12388 else if (unformat (input, "add"))
12392 else if (unformat (input, "deid %U", unformat_lisp_eid_vat, eid))
12396 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, &seid))
12398 //TODO: Need remove, but first must be remove from CSIT test
12400 else if (unformat (input, "vni %d", &vni))
12404 else if (unformat (input, "p %d w %d", &p, &w))
12408 errmsg ("No RLOC configured for setting priority/weight!");
12411 curr_rloc->priority = p;
12412 curr_rloc->weight = w;
12414 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
12417 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
12418 vec_add1 (rlocs, rloc);
12419 curr_rloc = &rlocs[vec_len (rlocs) - 1];
12421 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
12424 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
12425 vec_add1 (rlocs, rloc);
12426 curr_rloc = &rlocs[vec_len (rlocs) - 1];
12428 else if (unformat (input, "action %d", &action))
12434 clib_warning ("parse error '%U'", format_unformat_error, input);
12441 errmsg ("missing params!");
12445 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
12447 errmsg ("no action set for negative map-reply!");
12451 M (LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping);
12452 mp->is_add = is_add;
12453 mp->vni = htonl (vni);
12454 mp->action = (u8) action;
12455 mp->eid_len = eid->len;
12456 mp->del_all = del_all;
12457 mp->eid_type = eid->type;
12458 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
12460 mp->rloc_num = vec_len (rlocs);
12461 clib_memcpy (mp->rlocs, rlocs, (sizeof (rloc_t) * vec_len (rlocs)));
12467 /* Wait for a reply... */
12475 * Add/del LISP adjacency. Saves mapping in LISP control plane and updates
12476 * forwarding entries in data-plane accordingly.
12478 * @param vam vpp API test context
12479 * @return return code
12482 api_lisp_add_del_adjacency (vat_main_t * vam)
12484 unformat_input_t *input = vam->input;
12485 vl_api_lisp_add_del_adjacency_t *mp;
12488 ip4_address_t seid4, deid4;
12489 ip6_address_t seid6, deid6;
12490 u8 deid_mac[6] = { 0 };
12491 u8 seid_mac[6] = { 0 };
12492 u8 deid_type, seid_type;
12493 u32 seid_len = 0, deid_len = 0, len;
12496 seid_type = deid_type = (u8) ~ 0;
12498 /* Parse args required to build the message */
12499 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12501 if (unformat (input, "del"))
12505 else if (unformat (input, "add"))
12509 else if (unformat (input, "deid %U/%d", unformat_ip4_address,
12512 deid_type = 0; /* ipv4 */
12515 else if (unformat (input, "deid %U/%d", unformat_ip6_address,
12518 deid_type = 1; /* ipv6 */
12521 else if (unformat (input, "deid %U", unformat_ethernet_address,
12524 deid_type = 2; /* mac */
12526 else if (unformat (input, "seid %U/%d", unformat_ip4_address,
12529 seid_type = 0; /* ipv4 */
12532 else if (unformat (input, "seid %U/%d", unformat_ip6_address,
12535 seid_type = 1; /* ipv6 */
12538 else if (unformat (input, "seid %U", unformat_ethernet_address,
12541 seid_type = 2; /* mac */
12543 else if (unformat (input, "vni %d", &vni))
12549 errmsg ("parse error '%U'", format_unformat_error, input);
12554 if ((u8) ~ 0 == deid_type)
12556 errmsg ("missing params!");
12560 if (seid_type != deid_type)
12562 errmsg ("source and destination EIDs are of different types!");
12566 M (LISP_ADD_DEL_ADJACENCY, lisp_add_del_adjacency);
12567 mp->is_add = is_add;
12568 mp->vni = htonl (vni);
12569 mp->seid_len = seid_len;
12570 mp->deid_len = deid_len;
12571 mp->eid_type = deid_type;
12573 switch (mp->eid_type)
12576 clib_memcpy (mp->seid, &seid4, sizeof (seid4));
12577 clib_memcpy (mp->deid, &deid4, sizeof (deid4));
12580 clib_memcpy (mp->seid, &seid6, sizeof (seid6));
12581 clib_memcpy (mp->deid, &deid6, sizeof (deid6));
12584 clib_memcpy (mp->seid, seid_mac, 6);
12585 clib_memcpy (mp->deid, deid_mac, 6);
12588 errmsg ("unknown EID type %d!", mp->eid_type);
12595 /* Wait for a reply... */
12603 api_lisp_gpe_add_del_iface (vat_main_t * vam)
12605 unformat_input_t *input = vam->input;
12606 vl_api_lisp_gpe_add_del_iface_t *mp;
12608 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
12609 u32 dp_table = 0, vni = 0;
12611 /* Parse args required to build the message */
12612 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12614 if (unformat (input, "up"))
12619 else if (unformat (input, "down"))
12624 else if (unformat (input, "table_id %d", &dp_table))
12628 else if (unformat (input, "bd_id %d", &dp_table))
12633 else if (unformat (input, "vni %d", &vni))
12641 if (action_set == 0)
12643 errmsg ("Action not set\n");
12646 if (dp_table_set == 0 || vni_set == 0)
12648 errmsg ("vni and dp_table must be set\n");
12652 /* Construct the API message */
12653 M (LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface);
12655 mp->is_add = is_add;
12656 mp->dp_table = dp_table;
12663 /* Wait for a reply... */
12671 * Add/del map request itr rlocs from LISP control plane and updates
12673 * @param vam vpp API test context
12674 * @return return code
12677 api_lisp_add_del_map_request_itr_rlocs (vat_main_t * vam)
12679 unformat_input_t *input = vam->input;
12680 vl_api_lisp_add_del_map_request_itr_rlocs_t *mp;
12682 u8 *locator_set_name = 0;
12683 u8 locator_set_name_set = 0;
12686 /* Parse args required to build the message */
12687 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12689 if (unformat (input, "del"))
12693 else if (unformat (input, "%_%v%_", &locator_set_name))
12695 locator_set_name_set = 1;
12699 clib_warning ("parse error '%U'", format_unformat_error, input);
12704 if (is_add && !locator_set_name_set)
12706 errmsg ("itr-rloc is not set!");
12710 if (is_add && vec_len (locator_set_name) > 64)
12712 errmsg ("itr-rloc locator-set name too long\n");
12713 vec_free (locator_set_name);
12717 M (LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, lisp_add_del_map_request_itr_rlocs);
12718 mp->is_add = is_add;
12721 clib_memcpy (mp->locator_set_name, locator_set_name,
12722 vec_len (locator_set_name));
12726 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
12728 vec_free (locator_set_name);
12733 /* Wait for a reply... */
12741 lisp_locator_dump_send_msg (vat_main_t * vam, u32 locator_set_index,
12744 vl_api_lisp_locator_dump_t *mp;
12747 M (LISP_LOCATOR_DUMP, lisp_locator_dump);
12749 mp->locator_set_index = htonl (locator_set_index);
12750 mp->filter = filter;
12755 /* Use a control ping for synchronization */
12757 vl_api_noprint_control_ping_t *mp;
12758 M (NOPRINT_CONTROL_PING, noprint_control_ping);
12761 /* Wait for a reply... */
12766 clean_locator_set_message (vat_main_t * vam)
12768 locator_set_msg_t *ls = 0;
12770 vec_foreach (ls, vam->locator_set_msg)
12772 vec_free (ls->locator_set_name);
12775 vec_free (vam->locator_set_msg);
12779 print_locator_in_locator_set (vat_main_t * vam, u8 filter)
12781 locator_set_msg_t *ls;
12782 locator_msg_t *loc;
12784 int i = 0, ret = 0;
12786 vec_foreach (ls, vam->locator_set_msg)
12788 ret = lisp_locator_dump_send_msg (vam, ls->locator_set_index, filter);
12791 vec_free (vam->locator_msg);
12792 clean_locator_set_message (vam);
12796 tmp_str = format (0, "%=20s%=16d%s", ls->locator_set_name,
12797 ls->locator_set_index,
12798 vec_len (vam->locator_msg) ? "" : "\n");
12800 vec_foreach (loc, vam->locator_msg)
12804 tmp_str = format (tmp_str, "%=37s", " ");
12808 tmp_str = format (tmp_str, "%=16d%=16d%=16d\n",
12809 loc->sw_if_index, loc->priority, loc->weight);
12813 tmp_str = format (tmp_str, "%=16U%=16d%=16d\n",
12814 loc->is_ipv6 ? format_ip6_address :
12815 format_ip4_address,
12816 loc->ip_address, loc->priority, loc->weight);
12821 fformat (vam->ofp, "%s", tmp_str);
12822 vec_free (tmp_str);
12823 vec_free (vam->locator_msg);
12826 clean_locator_set_message (vam);
12832 json_locator_in_locator_set (vat_main_t * vam, u8 filter)
12834 locator_set_msg_t *ls;
12835 locator_msg_t *loc;
12836 vat_json_node_t *node = NULL;
12837 vat_json_node_t *locator_array;
12838 vat_json_node_t *locator;
12839 struct in6_addr ip6;
12840 struct in_addr ip4;
12843 if (!vec_len (vam->locator_set_msg))
12845 /* just print [] */
12846 vat_json_init_array (&vam->json_tree);
12847 vat_json_print (vam->ofp, &vam->json_tree);
12848 vam->json_tree.type = VAT_JSON_NONE;
12852 if (VAT_JSON_ARRAY != vam->json_tree.type)
12854 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12855 vat_json_init_array (&vam->json_tree);
12858 vec_foreach (ls, vam->locator_set_msg)
12860 ret = lisp_locator_dump_send_msg (vam, ls->locator_set_index, filter);
12863 vec_free (ls->locator_set_name);
12864 vec_free (vam->locator_msg);
12865 vec_free (vam->locator_set_msg);
12866 vat_json_free (&vam->json_tree);
12867 vam->json_tree.type = VAT_JSON_NONE;
12871 node = vat_json_array_add (&vam->json_tree);
12872 vat_json_init_object (node);
12874 vat_json_object_add_uint (node, "locator-set-index",
12875 ls->locator_set_index);
12876 vat_json_object_add_string_copy (node, "locator-set",
12877 ls->locator_set_name);
12878 locator_array = vat_json_object_add_list (node, "locator");
12879 vec_foreach (loc, vam->locator_msg)
12881 locator = vat_json_array_add (locator_array);
12882 vat_json_init_object (locator);
12885 vat_json_object_add_uint (locator, "locator-index",
12892 clib_memcpy (&ip6, loc->ip_address, sizeof (ip6));
12893 vat_json_object_add_ip6 (locator, "locator", ip6);
12897 clib_memcpy (&ip4, loc->ip_address, sizeof (ip4));
12898 vat_json_object_add_ip4 (locator, "locator", ip4);
12901 vat_json_object_add_uint (locator, "priority", loc->priority);
12902 vat_json_object_add_uint (locator, "weight", loc->weight);
12905 vec_free (ls->locator_set_name);
12906 vec_free (vam->locator_msg);
12909 vat_json_print (vam->ofp, &vam->json_tree);
12910 vat_json_free (&vam->json_tree);
12911 vam->json_tree.type = VAT_JSON_NONE;
12913 vec_free (vam->locator_set_msg);
12919 get_locator_set_index_from_msg (vat_main_t * vam, u8 * locator_set,
12920 u32 * locator_set_index)
12922 locator_set_msg_t *ls;
12925 *locator_set_index = ~0;
12927 if (!vec_len (vam->locator_set_msg))
12932 vec_foreach (ls, vam->locator_set_msg)
12934 if (!strcmp ((char *) locator_set, (char *) ls->locator_set_name))
12936 *locator_set_index = ls->locator_set_index;
12937 vec_free (vam->locator_set_msg);
12942 vec_free (vam->locator_set_msg);
12948 get_locator_set_index (vat_main_t * vam, u8 * locator_set,
12949 u32 * locator_set_index)
12951 vl_api_lisp_locator_set_dump_t *mp;
12954 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
12958 /* Use a control ping for synchronization */
12960 vl_api_noprint_control_ping_t *mp;
12961 M (NOPRINT_CONTROL_PING, noprint_control_ping);
12965 vam->noprint_msg = 1;
12966 /* Wait for a reply... */
12970 get_locator_set_index_from_msg (vam, locator_set, locator_set_index);
12971 vam->noprint_msg = 0;
12980 lisp_locator_dump (vat_main_t * vam, u32 locator_set_index, u8 * locator_set,
12987 if (!vam->json_output)
12989 fformat (vam->ofp, "%=20s%=16s%=16s\n",
12990 "locator", "priority", "weight");
12995 ret = get_locator_set_index (vam, locator_set, &locator_set_index);
12998 if (!ret && ~0 == locator_set_index)
13003 ret = lisp_locator_dump_send_msg (vam, locator_set_index, filter);
13009 lisp_locator_set_dump (vat_main_t * vam, u8 filter)
13011 vl_api_lisp_locator_set_dump_t *mp;
13014 if (!vam->json_output)
13016 fformat (vam->ofp, "%=20s%=16s%=16s%=16s%=16s\n",
13017 "locator-set", "locator-set-index", "locator", "priority",
13021 vam->noprint_msg = 1;
13023 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
13025 mp->filter = filter;
13030 /* Use a control ping for synchronization */
13032 vl_api_noprint_control_ping_t *mp;
13033 M (NOPRINT_CONTROL_PING, noprint_control_ping);
13037 /* Wait for a reply... */
13041 if (vam->noprint_msg)
13043 if (!vam->json_output)
13045 print_locator_in_locator_set(vam, filter);
13049 json_locator_in_locator_set(vam, filter);
13052 vam->noprint_msg = 0;
13061 api_lisp_locator_set_dump (vat_main_t * vam)
13063 unformat_input_t *input = vam->input;
13064 vam->noprint_msg = 0;
13065 u32 locator_set_index = ~0;
13066 u8 locator_set_index_set = 0;
13067 u8 *locator_set = 0;
13068 u8 locator_set_set = 0;
13072 /* Parse args required to build the message */
13073 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13075 if (unformat (input, "locator-set-index %u", &locator_set_index))
13077 locator_set_index_set = 1;
13079 else if (unformat (input, "locator-set %s", &locator_set))
13081 locator_set_set = 1;
13083 else if (unformat (input, "local"))
13087 else if (unformat (input, "remote"))
13097 if (locator_set_index_set && locator_set_set)
13099 errmsg ("use only input parameter!\n");
13103 if (locator_set_index_set || locator_set_set)
13105 ret = lisp_locator_dump (vam, locator_set_index, locator_set, filter);
13109 ret = lisp_locator_set_dump (vam, filter);
13112 vec_free (locator_set);
13118 api_lisp_eid_table_map_dump (vat_main_t * vam)
13120 vl_api_lisp_eid_table_map_dump_t *mp;
13123 if (!vam->json_output)
13125 fformat (vam->ofp, "%=10s%=10s\n", "VNI", "VRF");
13128 M (LISP_EID_TABLE_MAP_DUMP, lisp_eid_table_map_dump);
13133 /* Use a control ping for synchronization */
13135 vl_api_control_ping_t *mp;
13136 M (CONTROL_PING, control_ping);
13139 /* Wait for a reply... */
13147 api_lisp_eid_table_vni_dump (vat_main_t * vam)
13149 vl_api_lisp_eid_table_vni_dump_t *mp;
13152 if (!vam->json_output)
13154 fformat (vam->ofp, "VNI\n");
13157 M (LISP_EID_TABLE_VNI_DUMP, lisp_eid_table_vni_dump);
13162 /* Use a control ping for synchronization */
13164 vl_api_control_ping_t *mp;
13165 M (CONTROL_PING, control_ping);
13168 /* Wait for a reply... */
13176 get_locator_set (vat_main_t * vam)
13178 vl_api_lisp_locator_set_dump_t *mp;
13181 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
13185 /* Use a control ping for synchronization */
13187 vl_api_noprint_control_ping_t *mp;
13188 M (NOPRINT_CONTROL_PING, noprint_control_ping);
13192 /* Wait for a reply... */
13200 format_eid_for_eid_table (vat_main_t * vam, u8 * str, eid_table_t * eid_table,
13203 u8 *(*format_eid) (u8 *, va_list *) = 0;
13205 ASSERT (vam != NULL);
13206 ASSERT (eid_table != NULL);
13213 switch (eid_table->eid_type)
13217 format_eid = (eid_table->eid_type ? format_ip6_address :
13218 format_ip4_address);
13219 str = format (0, "[%d] %U/%d",
13220 clib_net_to_host_u32 (eid_table->vni),
13221 format_eid, eid_table->eid, eid_table->eid_prefix_len);
13224 str = format (0, "[%d] %U",
13225 clib_net_to_host_u32 (eid_table->vni),
13226 format_ethernet_address, eid_table->eid);
13229 errmsg ("unknown EID type %d!", eid_table->eid_type);
13241 format_locator_set_for_eid_table (vat_main_t * vam, u8 * str,
13242 eid_table_t * eid_table)
13244 locator_set_msg_t *ls = 0;
13246 ASSERT (vam != NULL);
13247 ASSERT (eid_table != NULL);
13249 if (eid_table->is_local)
13251 vec_foreach (ls, vam->locator_set_msg)
13253 if (ls->locator_set_index == eid_table->locator_set_index)
13255 str = format (0, "local(%s)", ls->locator_set_name);
13260 str = format (0, "local(N/A)");
13264 str = format (0, "remote");
13271 format_locator_for_eid_table (vat_main_t * vam, u8 * str,
13272 eid_table_t * eid_table)
13274 locator_msg_t *loc = 0;
13275 int first_line = 1;
13277 ASSERT (vam != NULL);
13278 ASSERT (eid_table != NULL);
13280 vec_foreach (loc, vam->locator_msg)
13286 str = format (str, "%-55s%-d\n", " ", loc->sw_if_index);
13290 str = format (str, "%=55s%-U\n", " ",
13291 loc->is_ipv6 ? format_ip6_address :
13292 format_ip4_address, loc->ip_address);
13300 str = format (str, "%-30d%-20u%-u\n", loc->sw_if_index,
13301 eid_table->ttl, eid_table->authoritative);
13305 str = format (str, "%-30U%-20u%-u\n",
13306 loc->is_ipv6 ? format_ip6_address :
13307 format_ip4_address,
13308 loc->ip_address, eid_table->ttl,
13309 eid_table->authoritative);
13318 print_lisp_eid_table_dump (vat_main_t * vam)
13320 eid_table_t *eid_table = 0;
13321 u8 *tmp_str = 0, *tmp_str2 = 0;
13324 ASSERT (vam != NULL);
13326 ret = get_locator_set (vam);
13329 vec_free (vam->eid_tables);
13333 fformat (vam->ofp, "%-35s%-20s%-30s%-20s%-s\n", "EID", "type", "locators",
13334 "ttl", "authoritative");
13336 vec_foreach (eid_table, vam->eid_tables)
13338 ret = lisp_locator_dump_send_msg (vam, eid_table->locator_set_index, 0);
13341 vec_free (vam->locator_msg);
13342 clean_locator_set_message (vam);
13343 vec_free (vam->eid_tables);
13347 tmp_str2 = format_eid_for_eid_table (vam, tmp_str2, eid_table, &ret);
13350 vec_free (vam->locator_msg);
13351 clean_locator_set_message (vam);
13352 vec_free (vam->eid_tables);
13356 tmp_str = format (0, "%-35s", tmp_str2);
13357 vec_free (tmp_str2);
13359 tmp_str2 = format_locator_set_for_eid_table (vam, tmp_str2, eid_table);
13360 tmp_str = format (tmp_str, "%-20s", tmp_str2);
13361 vec_free (tmp_str2);
13363 tmp_str2 = format_locator_for_eid_table (vam, tmp_str2, eid_table);
13364 tmp_str = format (tmp_str, "%-s", tmp_str2);
13365 vec_free (tmp_str2);
13367 fformat (vam->ofp, "%s", tmp_str);
13368 vec_free (tmp_str);
13369 vec_free (vam->locator_msg);
13372 clean_locator_set_message (vam);
13373 vec_free (vam->eid_tables);
13379 json_locator_set_for_eid_table (vat_main_t * vam, vat_json_node_t * node,
13380 eid_table_t * eid_table)
13382 locator_set_msg_t *ls = 0;
13385 ASSERT (vam != NULL);
13386 ASSERT (node != NULL);
13387 ASSERT (eid_table != NULL);
13389 if (eid_table->is_local)
13391 vec_foreach (ls, vam->locator_set_msg)
13393 if (ls->locator_set_index == eid_table->locator_set_index)
13395 vat_json_object_add_string_copy (node, "locator-set",
13396 ls->locator_set_name);
13401 s = format (0, "N/A");
13403 vat_json_object_add_string_copy (node, "locator-set", s);
13408 s = format (0, "remote");
13410 vat_json_object_add_string_copy (node, "locator-set", s);
13416 json_eid_for_eid_table (vat_main_t * vam, vat_json_node_t * node,
13417 eid_table_t * eid_table)
13420 struct in6_addr ip6;
13421 struct in_addr ip4;
13423 ASSERT (vam != NULL);
13424 ASSERT (node != NULL);
13425 ASSERT (eid_table != NULL);
13427 switch (eid_table->eid_type)
13430 clib_memcpy (&ip4, eid_table->eid, sizeof (ip4));
13431 vat_json_object_add_ip4 (node, "eid", ip4);
13432 vat_json_object_add_uint (node, "eid-prefix-len",
13433 eid_table->eid_prefix_len);
13436 clib_memcpy (&ip6, eid_table->eid, sizeof (ip6));
13437 vat_json_object_add_ip6 (node, "eid", ip6);
13438 vat_json_object_add_uint (node, "eid-prefix-len",
13439 eid_table->eid_prefix_len);
13442 s = format (0, "%U", format_ethernet_address, eid_table->eid);
13444 vat_json_object_add_string_copy (node, "eid", s);
13448 errmsg ("unknown EID type %d!", eid_table->eid_type);
13456 json_locator_for_eid_table (vat_main_t * vam, vat_json_node_t * node,
13457 eid_table_t * eid_table)
13459 locator_msg_t *loc = 0;
13460 vat_json_node_t *locator_array = 0;
13461 vat_json_node_t *locator = 0;
13462 struct in6_addr ip6;
13463 struct in_addr ip4;
13465 ASSERT (vam != NULL);
13466 ASSERT (node != NULL);
13467 ASSERT (eid_table != NULL);
13469 locator_array = vat_json_object_add_list (node, "locator");
13470 vec_foreach (loc, vam->locator_msg)
13472 locator = vat_json_array_add (locator_array);
13473 vat_json_init_object (locator);
13476 vat_json_object_add_uint (locator, "locator-index", loc->sw_if_index);
13482 clib_memcpy (&ip6, loc->ip_address, sizeof (ip6));
13483 vat_json_object_add_ip6 (locator, "locator", ip6);
13487 clib_memcpy (&ip4, loc->ip_address, sizeof (ip4));
13488 vat_json_object_add_ip4 (locator, "locator", ip4);
13495 json_lisp_eid_table_dump (vat_main_t * vam)
13497 eid_table_t *eid_table;
13498 vat_json_node_t *node = 0;
13501 ASSERT (vam != NULL);
13503 ret = get_locator_set (vam);
13506 vec_free (vam->eid_tables);
13510 if (!vec_len (vam->eid_tables))
13512 /* just print [] */
13513 vat_json_init_array (&vam->json_tree);
13514 vat_json_print (vam->ofp, &vam->json_tree);
13515 vam->json_tree.type = VAT_JSON_NONE;
13519 if (VAT_JSON_ARRAY != vam->json_tree.type)
13521 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13522 vat_json_init_array (&vam->json_tree);
13525 vec_foreach (eid_table, vam->eid_tables)
13527 ret = lisp_locator_dump_send_msg (vam, eid_table->locator_set_index, 0);
13530 vec_free (vam->locator_msg);
13531 vec_free (vam->eid_tables);
13532 clean_locator_set_message (vam);
13533 vat_json_free (&vam->json_tree);
13534 vam->json_tree.type = VAT_JSON_NONE;
13538 node = vat_json_array_add (&vam->json_tree);
13539 vat_json_init_object (node);
13541 vat_json_object_add_uint (node, "vni", eid_table->vni);
13543 json_locator_set_for_eid_table (vam, node, eid_table);
13544 ret = json_eid_for_eid_table (vam, node, eid_table);
13547 vec_free (vam->locator_msg);
13548 vec_free (vam->eid_tables);
13549 clean_locator_set_message (vam);
13550 vat_json_free (&vam->json_tree);
13551 vam->json_tree.type = VAT_JSON_NONE;
13555 json_locator_for_eid_table (vam, node, eid_table);
13557 vat_json_object_add_uint (node, "ttl", eid_table->ttl);
13558 vat_json_object_add_uint (node, "authoritative",
13559 eid_table->authoritative);
13561 vec_free (vam->locator_msg);
13564 vat_json_print (vam->ofp, &vam->json_tree);
13565 vat_json_free (&vam->json_tree);
13566 vam->json_tree.type = VAT_JSON_NONE;
13568 clean_locator_set_message (vam);
13569 vec_free (vam->eid_tables);
13575 api_lisp_eid_table_dump (vat_main_t * vam)
13577 unformat_input_t *i = vam->input;
13578 vl_api_lisp_eid_table_dump_t *mp;
13580 struct in_addr ip4;
13581 struct in6_addr ip6;
13583 u8 eid_type = ~0, eid_set = 0;
13584 u32 prefix_length = ~0, t, vni = 0;
13587 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13589 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
13595 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
13601 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
13606 else if (unformat (i, "vni %d", &t))
13610 else if (unformat (i, "local"))
13614 else if (unformat (i, "remote"))
13620 errmsg ("parse error '%U'", format_unformat_error, i);
13625 M (LISP_EID_TABLE_DUMP, lisp_eid_table_dump);
13627 mp->filter = filter;
13631 mp->vni = htonl (vni);
13632 mp->eid_type = eid_type;
13636 mp->prefix_length = prefix_length;
13637 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
13640 mp->prefix_length = prefix_length;
13641 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
13644 clib_memcpy (mp->eid, mac, sizeof (mac));
13647 errmsg ("unknown EID type %d!", eid_type);
13652 vam->noprint_msg = 1;
13657 /* Use a control ping for synchronization */
13659 vl_api_noprint_control_ping_t *mp;
13660 M (NOPRINT_CONTROL_PING, noprint_control_ping);
13664 /* Wait for a reply... */
13668 if (vam->noprint_msg)
13670 if (!vam->json_output)
13672 vam->retval = print_lisp_eid_table_dump(vam);
13676 vam->retval = json_lisp_eid_table_dump(vam);
13679 vam->noprint_msg = 0;
13688 api_lisp_gpe_tunnel_dump (vat_main_t * vam)
13690 vl_api_lisp_gpe_tunnel_dump_t *mp;
13693 if (!vam->json_output)
13695 fformat (vam->ofp, "%=20s%=30s%=16s%=16s%=16s%=16s"
13696 "%=16s%=16s%=16s%=16s%=16s\n",
13697 "Tunel", "Source", "Destination", "Fib encap", "Fib decap",
13698 "Decap next", "Lisp version", "Flags", "Next protocol",
13699 "ver_res", "res", "iid");
13702 M (LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump);
13706 /* Use a control ping for synchronization */
13708 vl_api_control_ping_t *mp;
13709 M (CONTROL_PING, control_ping);
13712 /* Wait for a reply... */
13720 api_lisp_map_resolver_dump (vat_main_t * vam)
13722 vl_api_lisp_map_resolver_dump_t *mp;
13725 if (!vam->json_output)
13727 fformat (vam->ofp, "%=20s\n", "Map resolver");
13730 M (LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump);
13734 /* Use a control ping for synchronization */
13736 vl_api_control_ping_t *mp;
13737 M (CONTROL_PING, control_ping);
13740 /* Wait for a reply... */
13748 api_show_lisp_status (vat_main_t * vam)
13750 vl_api_show_lisp_status_t *mp;
13753 if (!vam->json_output)
13755 fformat (vam->ofp, "%-20s%-16s\n", "lisp status", "locator-set");
13758 M (SHOW_LISP_STATUS, show_lisp_status);
13761 /* Wait for a reply... */
13769 api_lisp_get_map_request_itr_rlocs (vat_main_t * vam)
13771 vl_api_lisp_get_map_request_itr_rlocs_t *mp;
13774 if (!vam->json_output)
13776 fformat (vam->ofp, "%=20s\n", "itr-rlocs:");
13779 M (LISP_GET_MAP_REQUEST_ITR_RLOCS, lisp_get_map_request_itr_rlocs);
13782 /* Wait for a reply... */
13790 api_af_packet_create (vat_main_t * vam)
13792 unformat_input_t *i = vam->input;
13793 vl_api_af_packet_create_t *mp;
13795 u8 *host_if_name = 0;
13797 u8 random_hw_addr = 1;
13799 memset (hw_addr, 0, sizeof (hw_addr));
13801 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13803 if (unformat (i, "name %s", &host_if_name))
13804 vec_add1 (host_if_name, 0);
13805 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
13806 random_hw_addr = 0;
13811 if (!vec_len (host_if_name))
13813 errmsg ("host-interface name must be specified");
13817 if (vec_len (host_if_name) > 64)
13819 errmsg ("host-interface name too long");
13823 M (AF_PACKET_CREATE, af_packet_create);
13825 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
13826 clib_memcpy (mp->hw_addr, hw_addr, 6);
13827 mp->use_random_hw_addr = random_hw_addr;
13828 vec_free (host_if_name);
13831 W2 (fprintf (vam->ofp, " new sw_if_index = %d ", vam->sw_if_index));
13837 api_af_packet_delete (vat_main_t * vam)
13839 unformat_input_t *i = vam->input;
13840 vl_api_af_packet_delete_t *mp;
13842 u8 *host_if_name = 0;
13844 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13846 if (unformat (i, "name %s", &host_if_name))
13847 vec_add1 (host_if_name, 0);
13852 if (!vec_len (host_if_name))
13854 errmsg ("host-interface name must be specified");
13858 if (vec_len (host_if_name) > 64)
13860 errmsg ("host-interface name too long");
13864 M (AF_PACKET_DELETE, af_packet_delete);
13866 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
13867 vec_free (host_if_name);
13876 api_policer_add_del (vat_main_t * vam)
13878 unformat_input_t *i = vam->input;
13879 vl_api_policer_add_del_t *mp;
13890 u8 color_aware = 0;
13891 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
13893 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
13894 conform_action.dscp = 0;
13895 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
13896 exceed_action.dscp = 0;
13897 violate_action.action_type = SSE2_QOS_ACTION_DROP;
13898 violate_action.dscp = 0;
13900 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13902 if (unformat (i, "del"))
13904 else if (unformat (i, "name %s", &name))
13905 vec_add1 (name, 0);
13906 else if (unformat (i, "cir %u", &cir))
13908 else if (unformat (i, "eir %u", &eir))
13910 else if (unformat (i, "cb %u", &cb))
13912 else if (unformat (i, "eb %u", &eb))
13914 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
13917 else if (unformat (i, "round_type %U", unformat_policer_round_type,
13920 else if (unformat (i, "type %U", unformat_policer_type, &type))
13922 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
13925 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
13928 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
13931 else if (unformat (i, "color-aware"))
13937 if (!vec_len (name))
13939 errmsg ("policer name must be specified");
13943 if (vec_len (name) > 64)
13945 errmsg ("policer name too long");
13949 M (POLICER_ADD_DEL, policer_add_del);
13951 clib_memcpy (mp->name, name, vec_len (name));
13953 mp->is_add = is_add;
13958 mp->rate_type = rate_type;
13959 mp->round_type = round_type;
13961 mp->conform_action_type = conform_action.action_type;
13962 mp->conform_dscp = conform_action.dscp;
13963 mp->exceed_action_type = exceed_action.action_type;
13964 mp->exceed_dscp = exceed_action.dscp;
13965 mp->violate_action_type = violate_action.action_type;
13966 mp->violate_dscp = violate_action.dscp;
13967 mp->color_aware = color_aware;
13976 api_policer_dump (vat_main_t * vam)
13978 unformat_input_t *i = vam->input;
13979 vl_api_policer_dump_t *mp;
13981 u8 *match_name = 0;
13982 u8 match_name_valid = 0;
13984 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13986 if (unformat (i, "name %s", &match_name))
13988 vec_add1 (match_name, 0);
13989 match_name_valid = 1;
13995 M (POLICER_DUMP, policer_dump);
13996 mp->match_name_valid = match_name_valid;
13997 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
13998 vec_free (match_name);
14002 /* Use a control ping for synchronization */
14004 vl_api_control_ping_t *mp;
14005 M (CONTROL_PING, control_ping);
14008 /* Wait for a reply... */
14016 api_policer_classify_set_interface (vat_main_t * vam)
14018 unformat_input_t *i = vam->input;
14019 vl_api_policer_classify_set_interface_t *mp;
14022 int sw_if_index_set;
14023 u32 ip4_table_index = ~0;
14024 u32 ip6_table_index = ~0;
14025 u32 l2_table_index = ~0;
14028 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14030 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
14031 sw_if_index_set = 1;
14032 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14033 sw_if_index_set = 1;
14034 else if (unformat (i, "del"))
14036 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14038 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14040 else if (unformat (i, "l2-table %d", &l2_table_index))
14044 clib_warning ("parse error '%U'", format_unformat_error, i);
14049 if (sw_if_index_set == 0)
14051 errmsg ("missing interface name or sw_if_index\n");
14055 M (POLICER_CLASSIFY_SET_INTERFACE, policer_classify_set_interface);
14057 mp->sw_if_index = ntohl (sw_if_index);
14058 mp->ip4_table_index = ntohl (ip4_table_index);
14059 mp->ip6_table_index = ntohl (ip6_table_index);
14060 mp->l2_table_index = ntohl (l2_table_index);
14061 mp->is_add = is_add;
14070 api_policer_classify_dump (vat_main_t * vam)
14072 unformat_input_t *i = vam->input;
14073 vl_api_policer_classify_dump_t *mp;
14075 u8 type = POLICER_CLASSIFY_N_TABLES;
14077 if (unformat (i, "type %U", unformat_classify_table_type, &type))
14081 errmsg ("classify table type must be specified\n");
14085 if (!vam->json_output)
14087 fformat (vam->ofp, "%10s%20s\n", "Intfc idx", "Classify table");
14090 M (POLICER_CLASSIFY_DUMP, policer_classify_dump);
14095 /* Use a control ping for synchronization */
14097 vl_api_control_ping_t *mp;
14098 M (CONTROL_PING, control_ping);
14101 /* Wait for a reply... */
14109 api_netmap_create (vat_main_t * vam)
14111 unformat_input_t *i = vam->input;
14112 vl_api_netmap_create_t *mp;
14116 u8 random_hw_addr = 1;
14120 memset (hw_addr, 0, sizeof (hw_addr));
14122 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14124 if (unformat (i, "name %s", &if_name))
14125 vec_add1 (if_name, 0);
14126 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
14127 random_hw_addr = 0;
14128 else if (unformat (i, "pipe"))
14130 else if (unformat (i, "master"))
14132 else if (unformat (i, "slave"))
14138 if (!vec_len (if_name))
14140 errmsg ("interface name must be specified");
14144 if (vec_len (if_name) > 64)
14146 errmsg ("interface name too long");
14150 M (NETMAP_CREATE, netmap_create);
14152 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
14153 clib_memcpy (mp->hw_addr, hw_addr, 6);
14154 mp->use_random_hw_addr = random_hw_addr;
14155 mp->is_pipe = is_pipe;
14156 mp->is_master = is_master;
14157 vec_free (if_name);
14166 api_netmap_delete (vat_main_t * vam)
14168 unformat_input_t *i = vam->input;
14169 vl_api_netmap_delete_t *mp;
14173 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14175 if (unformat (i, "name %s", &if_name))
14176 vec_add1 (if_name, 0);
14181 if (!vec_len (if_name))
14183 errmsg ("interface name must be specified");
14187 if (vec_len (if_name) > 64)
14189 errmsg ("interface name too long");
14193 M (NETMAP_DELETE, netmap_delete);
14195 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
14196 vec_free (if_name);
14204 static void vl_api_mpls_gre_tunnel_details_t_handler
14205 (vl_api_mpls_gre_tunnel_details_t * mp)
14207 vat_main_t *vam = &vat_main;
14209 i32 len = ntohl (mp->nlabels);
14211 if (mp->l2_only == 0)
14213 fformat (vam->ofp, "[%d]: src %U, dst %U, adj %U/%d, labels ",
14214 ntohl (mp->tunnel_index),
14215 format_ip4_address, &mp->tunnel_src,
14216 format_ip4_address, &mp->tunnel_dst,
14217 format_ip4_address, &mp->intfc_address,
14218 ntohl (mp->mask_width));
14219 for (i = 0; i < len; i++)
14221 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14223 fformat (vam->ofp, "\n");
14224 fformat (vam->ofp, " inner fib index %d, outer fib index %d\n",
14225 ntohl (mp->inner_fib_index), ntohl (mp->outer_fib_index));
14229 fformat (vam->ofp, "[%d]: src %U, dst %U, key %U, labels ",
14230 ntohl (mp->tunnel_index),
14231 format_ip4_address, &mp->tunnel_src,
14232 format_ip4_address, &mp->tunnel_dst,
14233 format_ip4_address, &mp->intfc_address);
14234 for (i = 0; i < len; i++)
14236 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14238 fformat (vam->ofp, "\n");
14239 fformat (vam->ofp, " l2 interface %d, outer fib index %d\n",
14240 ntohl (mp->hw_if_index), ntohl (mp->outer_fib_index));
14244 static void vl_api_mpls_gre_tunnel_details_t_handler_json
14245 (vl_api_mpls_gre_tunnel_details_t * mp)
14247 vat_main_t *vam = &vat_main;
14248 vat_json_node_t *node = NULL;
14249 struct in_addr ip4;
14251 i32 len = ntohl (mp->nlabels);
14253 if (VAT_JSON_ARRAY != vam->json_tree.type)
14255 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14256 vat_json_init_array (&vam->json_tree);
14258 node = vat_json_array_add (&vam->json_tree);
14260 vat_json_init_object (node);
14261 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
14262 clib_memcpy (&ip4, &(mp->intfc_address), sizeof (ip4));
14263 vat_json_object_add_ip4 (node, "intfc_address", ip4);
14264 vat_json_object_add_uint (node, "inner_fib_index",
14265 ntohl (mp->inner_fib_index));
14266 vat_json_object_add_uint (node, "mask_width", ntohl (mp->mask_width));
14267 vat_json_object_add_uint (node, "encap_index", ntohl (mp->encap_index));
14268 vat_json_object_add_uint (node, "hw_if_index", ntohl (mp->hw_if_index));
14269 vat_json_object_add_uint (node, "l2_only", ntohl (mp->l2_only));
14270 clib_memcpy (&ip4, &(mp->tunnel_src), sizeof (ip4));
14271 vat_json_object_add_ip4 (node, "tunnel_src", ip4);
14272 clib_memcpy (&ip4, &(mp->tunnel_dst), sizeof (ip4));
14273 vat_json_object_add_ip4 (node, "tunnel_dst", ip4);
14274 vat_json_object_add_uint (node, "outer_fib_index",
14275 ntohl (mp->outer_fib_index));
14276 vat_json_object_add_uint (node, "label_count", len);
14277 for (i = 0; i < len; i++)
14279 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14284 api_mpls_gre_tunnel_dump (vat_main_t * vam)
14286 vl_api_mpls_gre_tunnel_dump_t *mp;
14290 /* Parse args required to build the message */
14291 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
14293 if (!unformat (vam->input, "tunnel_index %d", &index))
14300 fformat (vam->ofp, " tunnel_index %d\n", index);
14302 M (MPLS_GRE_TUNNEL_DUMP, mpls_gre_tunnel_dump);
14303 mp->tunnel_index = htonl (index);
14306 /* Use a control ping for synchronization */
14308 vl_api_control_ping_t *mp;
14309 M (CONTROL_PING, control_ping);
14315 static void vl_api_mpls_eth_tunnel_details_t_handler
14316 (vl_api_mpls_eth_tunnel_details_t * mp)
14318 vat_main_t *vam = &vat_main;
14320 i32 len = ntohl (mp->nlabels);
14322 fformat (vam->ofp, "[%d]: dst %U, adj %U/%d, labels ",
14323 ntohl (mp->tunnel_index),
14324 format_ethernet_address, &mp->tunnel_dst_mac,
14325 format_ip4_address, &mp->intfc_address, ntohl (mp->mask_width));
14326 for (i = 0; i < len; i++)
14328 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14330 fformat (vam->ofp, "\n");
14331 fformat (vam->ofp, " tx on %d, rx fib index %d\n",
14332 ntohl (mp->tx_sw_if_index), ntohl (mp->inner_fib_index));
14335 static void vl_api_mpls_eth_tunnel_details_t_handler_json
14336 (vl_api_mpls_eth_tunnel_details_t * mp)
14338 vat_main_t *vam = &vat_main;
14339 vat_json_node_t *node = NULL;
14340 struct in_addr ip4;
14342 i32 len = ntohl (mp->nlabels);
14344 if (VAT_JSON_ARRAY != vam->json_tree.type)
14346 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14347 vat_json_init_array (&vam->json_tree);
14349 node = vat_json_array_add (&vam->json_tree);
14351 vat_json_init_object (node);
14352 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
14353 clib_memcpy (&ip4, &(mp->intfc_address), sizeof (ip4));
14354 vat_json_object_add_ip4 (node, "intfc_address", ip4);
14355 vat_json_object_add_uint (node, "inner_fib_index",
14356 ntohl (mp->inner_fib_index));
14357 vat_json_object_add_uint (node, "mask_width", ntohl (mp->mask_width));
14358 vat_json_object_add_uint (node, "encap_index", ntohl (mp->encap_index));
14359 vat_json_object_add_uint (node, "hw_if_index", ntohl (mp->hw_if_index));
14360 vat_json_object_add_uint (node, "l2_only", ntohl (mp->l2_only));
14361 vat_json_object_add_string_copy (node, "tunnel_dst_mac",
14362 format (0, "%U", format_ethernet_address,
14363 &mp->tunnel_dst_mac));
14364 vat_json_object_add_uint (node, "tx_sw_if_index",
14365 ntohl (mp->tx_sw_if_index));
14366 vat_json_object_add_uint (node, "label_count", len);
14367 for (i = 0; i < len; i++)
14369 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14374 api_mpls_eth_tunnel_dump (vat_main_t * vam)
14376 vl_api_mpls_eth_tunnel_dump_t *mp;
14380 /* Parse args required to build the message */
14381 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
14383 if (!unformat (vam->input, "tunnel_index %d", &index))
14390 fformat (vam->ofp, " tunnel_index %d\n", index);
14392 M (MPLS_ETH_TUNNEL_DUMP, mpls_eth_tunnel_dump);
14393 mp->tunnel_index = htonl (index);
14396 /* Use a control ping for synchronization */
14398 vl_api_control_ping_t *mp;
14399 M (CONTROL_PING, control_ping);
14405 static void vl_api_mpls_fib_encap_details_t_handler
14406 (vl_api_mpls_fib_encap_details_t * mp)
14408 vat_main_t *vam = &vat_main;
14410 i32 len = ntohl (mp->nlabels);
14412 fformat (vam->ofp, "table %d, dest %U, label ",
14413 ntohl (mp->fib_index), format_ip4_address, &mp->dest, len);
14414 for (i = 0; i < len; i++)
14416 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14418 fformat (vam->ofp, "\n");
14421 static void vl_api_mpls_fib_encap_details_t_handler_json
14422 (vl_api_mpls_fib_encap_details_t * mp)
14424 vat_main_t *vam = &vat_main;
14425 vat_json_node_t *node = NULL;
14427 i32 len = ntohl (mp->nlabels);
14428 struct in_addr ip4;
14430 if (VAT_JSON_ARRAY != vam->json_tree.type)
14432 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14433 vat_json_init_array (&vam->json_tree);
14435 node = vat_json_array_add (&vam->json_tree);
14437 vat_json_init_object (node);
14438 vat_json_object_add_uint (node, "table", ntohl (mp->fib_index));
14439 vat_json_object_add_uint (node, "entry_index", ntohl (mp->entry_index));
14440 clib_memcpy (&ip4, &(mp->dest), sizeof (ip4));
14441 vat_json_object_add_ip4 (node, "dest", ip4);
14442 vat_json_object_add_uint (node, "s_bit", ntohl (mp->s_bit));
14443 vat_json_object_add_uint (node, "label_count", len);
14444 for (i = 0; i < len; i++)
14446 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14451 api_mpls_fib_encap_dump (vat_main_t * vam)
14453 vl_api_mpls_fib_encap_dump_t *mp;
14456 M (MPLS_FIB_ENCAP_DUMP, mpls_fib_encap_dump);
14459 /* Use a control ping for synchronization */
14461 vl_api_control_ping_t *mp;
14462 M (CONTROL_PING, control_ping);
14468 static void vl_api_mpls_fib_decap_details_t_handler
14469 (vl_api_mpls_fib_decap_details_t * mp)
14471 vat_main_t *vam = &vat_main;
14474 "RX table %d, TX table/intfc %u, swif_tag '%s', label %u, s_bit %u\n",
14475 ntohl (mp->rx_table_id), ntohl (mp->tx_table_id), mp->swif_tag,
14476 ntohl (mp->label), ntohl (mp->s_bit));
14479 static void vl_api_mpls_fib_decap_details_t_handler_json
14480 (vl_api_mpls_fib_decap_details_t * mp)
14482 vat_main_t *vam = &vat_main;
14483 vat_json_node_t *node = NULL;
14484 struct in_addr ip4;
14486 if (VAT_JSON_ARRAY != vam->json_tree.type)
14488 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14489 vat_json_init_array (&vam->json_tree);
14491 node = vat_json_array_add (&vam->json_tree);
14493 vat_json_init_object (node);
14494 vat_json_object_add_uint (node, "table", ntohl (mp->fib_index));
14495 vat_json_object_add_uint (node, "entry_index", ntohl (mp->entry_index));
14496 clib_memcpy (&ip4, &(mp->dest), sizeof (ip4));
14497 vat_json_object_add_ip4 (node, "dest", ip4);
14498 vat_json_object_add_uint (node, "s_bit", ntohl (mp->s_bit));
14499 vat_json_object_add_uint (node, "label", ntohl (mp->label));
14500 vat_json_object_add_uint (node, "rx_table_id", ntohl (mp->rx_table_id));
14501 vat_json_object_add_uint (node, "tx_table_id", ntohl (mp->tx_table_id));
14502 vat_json_object_add_string_copy (node, "swif_tag", mp->swif_tag);
14506 api_mpls_fib_decap_dump (vat_main_t * vam)
14508 vl_api_mpls_fib_decap_dump_t *mp;
14511 M (MPLS_FIB_DECAP_DUMP, mpls_fib_decap_dump);
14514 /* Use a control ping for synchronization */
14516 vl_api_control_ping_t *mp;
14517 M (CONTROL_PING, control_ping);
14524 api_classify_table_ids (vat_main_t * vam)
14526 vl_api_classify_table_ids_t *mp;
14529 /* Construct the API message */
14530 M (CLASSIFY_TABLE_IDS, classify_table_ids);
14540 api_classify_table_by_interface (vat_main_t * vam)
14542 unformat_input_t *input = vam->input;
14543 vl_api_classify_table_by_interface_t *mp;
14546 u32 sw_if_index = ~0;
14547 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14549 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
14551 else if (unformat (input, "sw_if_index %d", &sw_if_index))
14556 if (sw_if_index == ~0)
14558 errmsg ("missing interface name or sw_if_index\n");
14562 /* Construct the API message */
14563 M (CLASSIFY_TABLE_BY_INTERFACE, classify_table_by_interface);
14565 mp->sw_if_index = ntohl (sw_if_index);
14574 api_classify_table_info (vat_main_t * vam)
14576 unformat_input_t *input = vam->input;
14577 vl_api_classify_table_info_t *mp;
14581 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14583 if (unformat (input, "table_id %d", &table_id))
14588 if (table_id == ~0)
14590 errmsg ("missing table id\n");
14594 /* Construct the API message */
14595 M (CLASSIFY_TABLE_INFO, classify_table_info);
14597 mp->table_id = ntohl (table_id);
14606 api_classify_session_dump (vat_main_t * vam)
14608 unformat_input_t *input = vam->input;
14609 vl_api_classify_session_dump_t *mp;
14613 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14615 if (unformat (input, "table_id %d", &table_id))
14620 if (table_id == ~0)
14622 errmsg ("missing table id\n");
14626 /* Construct the API message */
14627 M (CLASSIFY_SESSION_DUMP, classify_session_dump);
14629 mp->table_id = ntohl (table_id);
14632 /* Use a control ping for synchronization */
14634 vl_api_control_ping_t *mp;
14635 M (CONTROL_PING, control_ping);
14644 vl_api_ipfix_details_t_handler (vl_api_ipfix_details_t * mp)
14646 vat_main_t *vam = &vat_main;
14648 fformat (vam->ofp, "collector_address %U, collector_port %d, "
14649 "src_address %U, fib_index %u, path_mtu %u, "
14650 "template_interval %u\n",
14651 format_ip4_address, mp->collector_address,
14652 ntohs (mp->collector_port),
14653 format_ip4_address, mp->src_address,
14654 ntohl (mp->fib_index),
14655 ntohl (mp->path_mtu), ntohl (mp->template_interval));
14658 vam->result_ready = 1;
14662 vl_api_ipfix_details_t_handler_json (vl_api_ipfix_details_t * mp)
14664 vat_main_t *vam = &vat_main;
14665 vat_json_node_t node;
14666 struct in_addr collector_address;
14667 struct in_addr src_address;
14669 vat_json_init_object (&node);
14670 clib_memcpy (&collector_address, &mp->collector_address,
14671 sizeof (collector_address));
14672 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
14673 vat_json_object_add_uint (&node, "collector_port",
14674 ntohs (mp->collector_port));
14675 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
14676 vat_json_object_add_ip4 (&node, "src_address", src_address);
14677 vat_json_object_add_uint (&node, "fib_index", ntohl (mp->fib_index));
14678 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
14679 vat_json_object_add_uint (&node, "template_interval",
14680 ntohl (mp->template_interval));
14682 vat_json_print (vam->ofp, &node);
14683 vat_json_free (&node);
14685 vam->result_ready = 1;
14689 api_ipfix_dump (vat_main_t * vam)
14691 vl_api_ipfix_dump_t *mp;
14694 /* Construct the API message */
14695 M (IPFIX_DUMP, ipfix_dump);
14705 api_pg_create_interface (vat_main_t * vam)
14707 unformat_input_t *input = vam->input;
14708 vl_api_pg_create_interface_t *mp;
14712 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14714 if (unformat (input, "if_id %d", &if_id))
14721 errmsg ("missing pg interface index\n");
14725 /* Construct the API message */
14726 M (PG_CREATE_INTERFACE, pg_create_interface);
14728 mp->interface_id = ntohl (if_id);
14737 api_pg_capture (vat_main_t * vam)
14739 unformat_input_t *input = vam->input;
14740 vl_api_pg_capture_t *mp;
14746 u8 pcap_file_set = 0;
14748 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14750 if (unformat (input, "if_id %d", &if_id))
14752 else if (unformat (input, "pcap %s", &pcap_file))
14754 else if (unformat (input, "count %d", &count))
14756 else if (unformat (input, "disable"))
14763 errmsg ("missing pg interface index\n");
14766 if (pcap_file_set > 0)
14768 if (vec_len (pcap_file) > 255)
14770 errmsg ("pcap file name is too long\n");
14775 u32 name_len = vec_len (pcap_file);
14776 /* Construct the API message */
14777 M (PG_CAPTURE, pg_capture);
14779 mp->interface_id = ntohl (if_id);
14780 mp->is_enabled = enable;
14781 mp->count = ntohl (count);
14782 mp->pcap_name_length = ntohl (name_len);
14783 if (pcap_file_set != 0)
14785 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
14787 vec_free (pcap_file);
14796 api_pg_enable_disable (vat_main_t * vam)
14798 unformat_input_t *input = vam->input;
14799 vl_api_pg_enable_disable_t *mp;
14803 u8 stream_name_set = 0;
14804 u8 *stream_name = 0;
14805 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14807 if (unformat (input, "stream %s", &stream_name))
14808 stream_name_set = 1;
14809 else if (unformat (input, "disable"))
14815 if (stream_name_set > 0)
14817 if (vec_len (stream_name) > 255)
14819 errmsg ("stream name too long\n");
14824 u32 name_len = vec_len (stream_name);
14825 /* Construct the API message */
14826 M (PG_ENABLE_DISABLE, pg_enable_disable);
14828 mp->is_enabled = enable;
14829 if (stream_name_set != 0)
14831 mp->stream_name_length = ntohl (name_len);
14832 clib_memcpy (mp->stream_name, stream_name, name_len);
14834 vec_free (stream_name);
14843 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
14845 unformat_input_t *input = vam->input;
14846 vl_api_ip_source_and_port_range_check_add_del_t *mp;
14849 u16 *low_ports = 0;
14850 u16 *high_ports = 0;
14853 ip4_address_t ip4_addr;
14854 ip6_address_t ip6_addr;
14862 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14864 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
14870 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
14875 else if (unformat (input, "vrf %d", &vrf_id))
14877 else if (unformat (input, "del"))
14879 else if (unformat (input, "port %d", &tmp))
14881 if (tmp == 0 || tmp > 65535)
14883 errmsg ("port %d out of range", tmp);
14887 this_hi = this_low + 1;
14888 vec_add1 (low_ports, this_low);
14889 vec_add1 (high_ports, this_hi);
14891 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
14893 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
14895 errmsg ("incorrect range parameters\n");
14899 /* Note: in debug CLI +1 is added to high before
14900 passing to real fn that does "the work"
14901 (ip_source_and_port_range_check_add_del).
14902 This fn is a wrapper around the binary API fn a
14903 control plane will call, which expects this increment
14904 to have occurred. Hence letting the binary API control
14905 plane fn do the increment for consistency between VAT
14906 and other control planes.
14909 vec_add1 (low_ports, this_low);
14910 vec_add1 (high_ports, this_hi);
14916 if (prefix_set == 0)
14918 errmsg ("<address>/<mask> not specified\n");
14924 errmsg ("VRF ID required, not specified\n");
14931 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
14935 if (vec_len (low_ports) == 0)
14937 errmsg ("At least one port or port range required\n");
14941 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL,
14942 ip_source_and_port_range_check_add_del);
14944 mp->is_add = is_add;
14949 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
14954 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
14957 mp->mask_length = length;
14958 mp->number_of_ranges = vec_len (low_ports);
14960 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
14961 vec_free (low_ports);
14963 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
14964 vec_free (high_ports);
14966 mp->vrf_id = ntohl (vrf_id);
14975 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
14977 unformat_input_t *input = vam->input;
14978 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
14980 u32 sw_if_index = ~0;
14982 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
14983 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
14986 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14988 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
14990 else if (unformat (input, "sw_if_index %d", &sw_if_index))
14992 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
14994 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
14996 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
14998 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
15000 else if (unformat (input, "del"))
15006 if (sw_if_index == ~0)
15008 errmsg ("Interface required but not specified\n");
15014 errmsg ("VRF ID required but not specified\n");
15018 if (tcp_out_vrf_id == 0
15019 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
15022 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
15026 /* Construct the API message */
15027 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL,
15028 ip_source_and_port_range_check_interface_add_del);
15030 mp->sw_if_index = ntohl (sw_if_index);
15031 mp->is_add = is_add;
15032 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
15033 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
15034 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
15035 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
15040 /* Wait for a reply... */
15045 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
15047 unformat_input_t *i = vam->input;
15048 vl_api_ipsec_gre_add_del_tunnel_t *mp;
15050 u32 local_sa_id = 0;
15051 u32 remote_sa_id = 0;
15052 ip4_address_t src_address;
15053 ip4_address_t dst_address;
15056 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15058 if (unformat (i, "local_sa %d", &local_sa_id))
15060 else if (unformat (i, "remote_sa %d", &remote_sa_id))
15062 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
15064 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
15066 else if (unformat (i, "del"))
15070 clib_warning ("parse error '%U'", format_unformat_error, i);
15075 M (IPSEC_GRE_ADD_DEL_TUNNEL, ipsec_gre_add_del_tunnel);
15077 mp->local_sa_id = ntohl (local_sa_id);
15078 mp->remote_sa_id = ntohl (remote_sa_id);
15079 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
15080 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
15081 mp->is_add = is_add;
15089 static void vl_api_ipsec_gre_tunnel_details_t_handler
15090 (vl_api_ipsec_gre_tunnel_details_t * mp)
15092 vat_main_t *vam = &vat_main;
15094 fformat (vam->ofp, "%11d%15U%15U%14d%14d\n",
15095 ntohl (mp->sw_if_index),
15096 format_ip4_address, &mp->src_address,
15097 format_ip4_address, &mp->dst_address,
15098 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
15101 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
15102 (vl_api_ipsec_gre_tunnel_details_t * mp)
15104 vat_main_t *vam = &vat_main;
15105 vat_json_node_t *node = NULL;
15106 struct in_addr ip4;
15108 if (VAT_JSON_ARRAY != vam->json_tree.type)
15110 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15111 vat_json_init_array (&vam->json_tree);
15113 node = vat_json_array_add (&vam->json_tree);
15115 vat_json_init_object (node);
15116 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
15117 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
15118 vat_json_object_add_ip4 (node, "src_address", ip4);
15119 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
15120 vat_json_object_add_ip4 (node, "dst_address", ip4);
15121 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
15122 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
15126 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
15128 unformat_input_t *i = vam->input;
15129 vl_api_ipsec_gre_tunnel_dump_t *mp;
15132 u8 sw_if_index_set = 0;
15134 /* Parse args required to build the message */
15135 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15137 if (unformat (i, "sw_if_index %d", &sw_if_index))
15138 sw_if_index_set = 1;
15143 if (sw_if_index_set == 0)
15148 if (!vam->json_output)
15150 fformat (vam->ofp, "%11s%15s%15s%14s%14s\n",
15151 "sw_if_index", "src_address", "dst_address",
15152 "local_sa_id", "remote_sa_id");
15155 /* Get list of gre-tunnel interfaces */
15156 M (IPSEC_GRE_TUNNEL_DUMP, ipsec_gre_tunnel_dump);
15158 mp->sw_if_index = htonl (sw_if_index);
15162 /* Use a control ping for synchronization */
15164 vl_api_control_ping_t *mp;
15165 M (CONTROL_PING, control_ping);
15172 q_or_quit (vat_main_t * vam)
15174 longjmp (vam->jump_buf, 1);
15175 return 0; /* not so much */
15179 q (vat_main_t * vam)
15181 return q_or_quit (vam);
15185 quit (vat_main_t * vam)
15187 return q_or_quit (vam);
15191 comment (vat_main_t * vam)
15197 cmd_cmp (void *a1, void *a2)
15202 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
15206 help (vat_main_t * vam)
15211 unformat_input_t *i = vam->input;
15214 if (unformat (i, "%s", &name))
15218 vec_add1 (name, 0);
15220 hs = hash_get_mem (vam->help_by_name, name);
15222 fformat (vam->ofp, "usage: %s %s\n", name, hs[0]);
15224 fformat (vam->ofp, "No such msg / command '%s'\n", name);
15229 fformat (vam->ofp, "Help is available for the following:\n");
15232 hash_foreach_pair (p, vam->function_by_name,
15234 vec_add1 (cmds, (u8 *)(p->key));
15238 vec_sort_with_function (cmds, cmd_cmp);
15240 for (j = 0; j < vec_len (cmds); j++)
15241 fformat (vam->ofp, "%s\n", cmds[j]);
15248 set (vat_main_t * vam)
15250 u8 *name = 0, *value = 0;
15251 unformat_input_t *i = vam->input;
15253 if (unformat (i, "%s", &name))
15255 /* The input buffer is a vector, not a string. */
15256 value = vec_dup (i->buffer);
15257 vec_delete (value, i->index, 0);
15258 /* Almost certainly has a trailing newline */
15259 if (value[vec_len (value) - 1] == '\n')
15260 value[vec_len (value) - 1] = 0;
15261 /* Make sure it's a proper string, one way or the other */
15262 vec_add1 (value, 0);
15263 (void) clib_macro_set_value (&vam->macro_main,
15264 (char *) name, (char *) value);
15267 errmsg ("usage: set <name> <value>\n");
15275 unset (vat_main_t * vam)
15279 if (unformat (vam->input, "%s", &name))
15280 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
15281 errmsg ("unset: %s wasn't set\n", name);
15294 macro_sort_cmp (void *a1, void *a2)
15296 macro_sort_t *s1 = a1;
15297 macro_sort_t *s2 = a2;
15299 return strcmp ((char *) (s1->name), (char *) (s2->name));
15303 dump_macro_table (vat_main_t * vam)
15305 macro_sort_t *sort_me = 0, *sm;
15310 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
15312 vec_add2 (sort_me, sm, 1);
15313 sm->name = (u8 *)(p->key);
15314 sm->value = (u8 *) (p->value[0]);
15318 vec_sort_with_function (sort_me, macro_sort_cmp);
15320 if (vec_len (sort_me))
15321 fformat (vam->ofp, "%-15s%s\n", "Name", "Value");
15323 fformat (vam->ofp, "The macro table is empty...\n");
15325 for (i = 0; i < vec_len (sort_me); i++)
15326 fformat (vam->ofp, "%-15s%s\n", sort_me[i].name, sort_me[i].value);
15331 dump_node_table (vat_main_t * vam)
15334 vlib_node_t *node, *next_node;
15336 if (vec_len (vam->graph_nodes) == 0)
15338 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
15342 for (i = 0; i < vec_len (vam->graph_nodes); i++)
15344 node = vam->graph_nodes[i];
15345 fformat (vam->ofp, "[%d] %s\n", i, node->name);
15346 for (j = 0; j < vec_len (node->next_nodes); j++)
15348 if (node->next_nodes[j] != ~0)
15350 next_node = vam->graph_nodes[node->next_nodes[j]];
15351 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
15359 search_node_table (vat_main_t * vam)
15361 unformat_input_t *line_input = vam->input;
15364 vlib_node_t *node, *next_node;
15367 if (vam->graph_node_index_by_name == 0)
15369 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
15373 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15375 if (unformat (line_input, "%s", &node_to_find))
15377 vec_add1 (node_to_find, 0);
15378 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
15381 fformat (vam->ofp, "%s not found...\n", node_to_find);
15384 node = vam->graph_nodes[p[0]];
15385 fformat (vam->ofp, "[%d] %s\n", p[0], node->name);
15386 for (j = 0; j < vec_len (node->next_nodes); j++)
15388 if (node->next_nodes[j] != ~0)
15390 next_node = vam->graph_nodes[node->next_nodes[j]];
15391 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
15398 clib_warning ("parse error '%U'", format_unformat_error,
15404 vec_free (node_to_find);
15413 script (vat_main_t * vam)
15416 char *save_current_file;
15417 unformat_input_t save_input;
15418 jmp_buf save_jump_buf;
15419 u32 save_line_number;
15421 FILE *new_fp, *save_ifp;
15423 if (unformat (vam->input, "%s", &s))
15425 new_fp = fopen ((char *) s, "r");
15428 errmsg ("Couldn't open script file %s\n", s);
15435 errmsg ("Missing script name\n");
15439 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
15440 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
15441 save_ifp = vam->ifp;
15442 save_line_number = vam->input_line_number;
15443 save_current_file = (char *) vam->current_file;
15445 vam->input_line_number = 0;
15447 vam->current_file = s;
15450 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
15451 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
15452 vam->ifp = save_ifp;
15453 vam->input_line_number = save_line_number;
15454 vam->current_file = (u8 *) save_current_file;
15461 echo (vat_main_t * vam)
15463 fformat (vam->ofp, "%v", vam->input->buffer);
15467 /* List of API message constructors, CLI names map to api_xxx */
15468 #define foreach_vpe_api_msg \
15469 _(create_loopback,"[mac <mac-addr>]") \
15470 _(sw_interface_dump,"") \
15471 _(sw_interface_set_flags, \
15472 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
15473 _(sw_interface_add_del_address, \
15474 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
15475 _(sw_interface_set_table, \
15476 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
15477 _(sw_interface_set_vpath, \
15478 "<intfc> | sw_if_index <id> enable | disable") \
15479 _(sw_interface_set_l2_xconnect, \
15480 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
15481 "enable | disable") \
15482 _(sw_interface_set_l2_bridge, \
15483 "<intfc> | sw_if_index <id> bd_id <bridge-domain-id>\n" \
15484 "[shg <split-horizon-group>] [bvi]\n" \
15485 "enable | disable") \
15486 _(bridge_domain_add_del, \
15487 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n")\
15488 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
15490 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
15492 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
15494 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
15496 "tapname <name> mac <mac-addr> | random-mac") \
15498 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
15500 "<vpp-if-name> | sw_if_index <id>") \
15501 _(sw_interface_tap_dump, "") \
15502 _(ip_add_del_route, \
15503 "<addr>/<mask> via <addr> [vrf <n>]\n" \
15504 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
15505 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
15506 "[multipath] [count <n>]") \
15507 _(proxy_arp_add_del, \
15508 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
15509 _(proxy_arp_intfc_enable_disable, \
15510 "<intfc> | sw_if_index <id> enable | disable") \
15511 _(mpls_add_del_encap, \
15512 "label <n> dst <ip4-addr> [vrf <n>] [del]") \
15513 _(mpls_add_del_decap, \
15514 "label <n> [rx_vrf_id <n>] [tx_vrf_id] [s-bit-clear][del]") \
15515 _(mpls_gre_add_del_tunnel, \
15516 "inner_vrf_id <n> outer_vrf_id <n> src <ip4-address> dst <ip4-address>\n" \
15517 "adj <ip4-address>/<mask-width> [del]") \
15518 _(sw_interface_set_unnumbered, \
15519 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
15520 _(ip_neighbor_add_del, \
15521 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
15522 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
15523 _(reset_vrf, "vrf <id> [ipv6]") \
15524 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
15525 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
15526 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
15527 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
15528 "[outer_vlan_id_any][inner_vlan_id_any]") \
15529 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
15530 _(reset_fib, "vrf <n> [ipv6]") \
15531 _(dhcp_proxy_config, \
15532 "svr <v46-address> src <v46-address>\n" \
15533 "insert-cid <n> [del]") \
15534 _(dhcp_proxy_config_2, \
15535 "svr <v46-address> src <v46-address>\n" \
15536 "rx_vrf_id <nn> server_vrf_id <nn> insert-cid <n> [del]") \
15537 _(dhcp_proxy_set_vss, \
15538 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
15539 _(dhcp_client_config, \
15540 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
15541 _(set_ip_flow_hash, \
15542 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
15543 _(sw_interface_ip6_enable_disable, \
15544 "<intfc> | sw_if_index <id> enable | disable") \
15545 _(sw_interface_ip6_set_link_local_address, \
15546 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
15547 _(sw_interface_ip6nd_ra_prefix, \
15548 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
15549 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
15550 "[nolink] [isno]") \
15551 _(sw_interface_ip6nd_ra_config, \
15552 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
15553 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
15554 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
15555 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
15556 _(l2_patch_add_del, \
15557 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
15558 "enable | disable") \
15559 _(mpls_ethernet_add_del_tunnel, \
15560 "tx <intfc> | tx_sw_if_index <n> dst <mac-addr>\n" \
15561 "adj <ip4-addr>/<mw> dst <mac-addr> [del]") \
15562 _(mpls_ethernet_add_del_tunnel_2, \
15563 "inner_vrf_id <n> outer_vrf_id <n> next-hop <ip4-addr>\n" \
15564 "resolve-attempts <n> resolve-if-needed 0 | 1 [del]") \
15565 _(sr_tunnel_add_del, \
15566 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
15567 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
15568 "[policy <policy_name>]") \
15569 _(sr_policy_add_del, \
15570 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
15571 _(sr_multicast_map_add_del, \
15572 "address [ip6 multicast address] sr-policy [policy name] [del]") \
15573 _(classify_add_del_table, \
15574 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
15575 "[del] mask <mask-value>\n" \
15576 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>") \
15577 _(classify_add_del_session, \
15578 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
15579 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
15580 " [l3 [ip4|ip6]]") \
15581 _(classify_set_interface_ip_table, \
15582 "<intfc> | sw_if_index <nn> table <nn>") \
15583 _(classify_set_interface_l2_tables, \
15584 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15585 " [other-table <nn>]") \
15586 _(get_node_index, "node <node-name") \
15587 _(add_node_next, "node <node-name> next <next-node-name>") \
15588 _(l2tpv3_create_tunnel, \
15589 "client_address <ip6-addr> our_address <ip6-addr>\n" \
15590 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n"\
15591 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
15592 _(l2tpv3_set_tunnel_cookies, \
15593 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
15594 "[new_remote_cookie <nn>]\n") \
15595 _(l2tpv3_interface_enable_disable, \
15596 "<intfc> | sw_if_index <nn> enable | disable") \
15597 _(l2tpv3_set_lookup_key, \
15598 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
15599 _(sw_if_l2tpv3_tunnel_dump, "") \
15600 _(vxlan_add_del_tunnel, \
15601 "src <ip-addr> dst <ip-addr> vni <vni> [encap-vrf-id <nn>]\n" \
15602 " [decap-next l2|ip4|ip6] [del]") \
15603 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15604 _(gre_add_del_tunnel, \
15605 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [del]\n") \
15606 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15607 _(l2_fib_clear_table, "") \
15608 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
15609 _(l2_interface_vlan_tag_rewrite, \
15610 "<intfc> | sw_if_index <nn> \n" \
15611 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
15612 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
15613 _(create_vhost_user_if, \
15614 "socket <filename> [server] [renumber <dev_instance>] " \
15615 "[mac <mac_address>]") \
15616 _(modify_vhost_user_if, \
15617 "<intfc> | sw_if_index <nn> socket <filename>\n" \
15618 "[server] [renumber <dev_instance>]") \
15619 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
15620 _(sw_interface_vhost_user_dump, "") \
15621 _(show_version, "") \
15622 _(vxlan_gpe_add_del_tunnel, \
15623 "local <addr> remote <addr> vni <nn>\n" \
15624 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
15625 "[next-ethernet] [next-nsh]\n") \
15626 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15627 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
15628 _(interface_name_renumber, \
15629 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
15630 _(input_acl_set_interface, \
15631 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15632 " [l2-table <nn>] [del]") \
15633 _(want_ip4_arp_events, "address <ip4-address> [del]") \
15634 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
15635 _(ip_dump, "ipv4 | ipv6") \
15636 _(ipsec_spd_add_del, "spd_id <n> [del]") \
15637 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
15639 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
15640 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
15641 " integ_alg <alg> integ_key <hex>") \
15642 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
15643 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
15644 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
15645 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" )\
15646 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
15647 _(ikev2_profile_add_del, "name <profile_name> [del]") \
15648 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
15649 "(auth_data 0x<data> | auth_data <data>)") \
15650 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
15651 "(id_data 0x<data> | id_data <data>) (local|remote)") \
15652 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
15653 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
15654 "(local|remote)") \
15655 _(ikev2_set_local_key, "file <absolute_file_path>") \
15656 _(delete_loopback,"sw_if_index <nn>") \
15657 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
15658 _(map_add_domain, \
15659 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
15660 "ip6-src <ip6addr> " \
15661 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
15662 _(map_del_domain, "index <n>") \
15663 _(map_add_del_rule, \
15664 "index <n> psid <n> dst <ip6addr> [del]") \
15665 _(map_domain_dump, "") \
15666 _(map_rule_dump, "index <map-domain>") \
15667 _(want_interface_events, "enable|disable") \
15668 _(want_stats,"enable|disable") \
15669 _(get_first_msg_id, "client <name>") \
15670 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
15671 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
15672 "fib-id <nn> [ip4][ip6][default]") \
15673 _(get_node_graph, " ") \
15674 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
15675 _(trace_profile_add, "id <nn> trace-type <0x1f|0x3|0x9|0x11|0x19> " \
15676 "trace-elts <nn> trace-tsp <0|1|2|3> node-id <node id in hex> " \
15677 "app-data <app_data in hex> [pow] [ppc <encap|decap>]") \
15678 _(trace_profile_apply, "id <nn> <ip6-address>/<width>" \
15679 " vrf_id <nn> add | pop | none") \
15680 _(trace_profile_del, "") \
15681 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
15682 " sw_if_index <sw_if_index> p <priority> " \
15683 "w <weight>] [del]") \
15684 _(lisp_add_del_locator, "locator-set <locator_name> " \
15685 "iface <intf> | sw_if_index <sw_if_index> " \
15686 "p <priority> w <weight> [del]") \
15687 _(lisp_add_del_local_eid,"vni <vni> eid " \
15688 "<ipv4|ipv6>/<prefix> | <L2 address> " \
15689 "locator-set <locator_name> [del]") \
15690 _(lisp_gpe_add_del_fwd_entry, "rmt_eid <eid> [lcl_eid <eid>] vni <vni>" \
15691 "dp_table <table> loc-pair <lcl_loc> <rmt_loc> ... [del]") \
15692 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
15693 _(lisp_gpe_enable_disable, "enable|disable") \
15694 _(lisp_enable_disable, "enable|disable") \
15695 _(lisp_gpe_add_del_iface, "up|down") \
15696 _(lisp_add_del_remote_mapping, "add|del vni <vni> deid <dest-eid> " \
15697 "rloc <locator> p <prio> " \
15698 "w <weight> [rloc <loc> ... ] " \
15699 "action <action> [del-all]") \
15700 _(lisp_add_del_adjacency, "add|del vni <vni> deid <dest-eid> seid " \
15701 "<src-eid> rloc <locator> p <prio> w <weight>"\
15702 "[rloc <loc> ... ] action <action>") \
15703 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
15704 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
15705 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
15706 _(lisp_locator_set_dump, "[locator-set-index <ls-index> | " \
15707 "locator-set <loc-set-name>] [local | remote]")\
15708 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
15709 "[local] | [remote]") \
15710 _(lisp_eid_table_map_dump, "") \
15711 _(lisp_eid_table_vni_dump, "") \
15712 _(lisp_gpe_tunnel_dump, "") \
15713 _(lisp_map_resolver_dump, "") \
15714 _(show_lisp_status, "") \
15715 _(lisp_get_map_request_itr_rlocs, "") \
15716 _(show_lisp_pitr, "") \
15717 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
15718 _(af_packet_delete, "name <host interface name>") \
15719 _(policer_add_del, "name <policer name> <params> [del]") \
15720 _(policer_dump, "[name <policer name>]") \
15721 _(policer_classify_set_interface, \
15722 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15723 " [l2-table <nn>] [del]") \
15724 _(policer_classify_dump, "type [ip4|ip6|l2]") \
15725 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
15726 "[master|slave]") \
15727 _(netmap_delete, "name <interface name>") \
15728 _(mpls_gre_tunnel_dump, "tunnel_index <tunnel-id>") \
15729 _(mpls_eth_tunnel_dump, "tunnel_index <tunnel-id>") \
15730 _(mpls_fib_encap_dump, "") \
15731 _(mpls_fib_decap_dump, "") \
15732 _(classify_table_ids, "") \
15733 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
15734 _(classify_table_info, "table_id <nn>") \
15735 _(classify_session_dump, "table_id <nn>") \
15736 _(ipfix_enable, "collector_address <ip4> [collector_port <nn>] " \
15737 "src_address <ip4> [fib_id <nn>] [path_mtu <nn>] " \
15738 "[template_interval <nn>]") \
15739 _(ipfix_dump, "") \
15740 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
15741 _(pg_create_interface, "if_id <nn>") \
15742 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
15743 _(pg_enable_disable, "[stream <id>] disable") \
15744 _(ip_source_and_port_range_check_add_del, \
15745 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
15746 _(ip_source_and_port_range_check_interface_add_del, \
15747 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
15748 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
15749 _(ipsec_gre_add_del_tunnel, \
15750 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
15751 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]")
15753 /* List of command functions, CLI names map directly to functions */
15754 #define foreach_cli_function \
15755 _(comment, "usage: comment <ignore-rest-of-line>") \
15756 _(dump_interface_table, "usage: dump_interface_table") \
15757 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
15758 _(dump_ipv4_table, "usage: dump_ipv4_table") \
15759 _(dump_ipv6_table, "usage: dump_ipv6_table") \
15760 _(dump_stats_table, "usage: dump_stats_table") \
15761 _(dump_macro_table, "usage: dump_macro_table ") \
15762 _(dump_node_table, "usage: dump_node_table") \
15763 _(echo, "usage: echo <message>") \
15764 _(exec, "usage: exec <vpe-debug-CLI-command>") \
15765 _(help, "usage: help") \
15766 _(q, "usage: quit") \
15767 _(quit, "usage: quit") \
15768 _(search_node_table, "usage: search_node_table <name>...") \
15769 _(set, "usage: set <variable-name> <value>") \
15770 _(script, "usage: script <file-name>") \
15771 _(unset, "usage: unset <variable-name>")
15774 static void vl_api_##n##_t_handler_uni \
15775 (vl_api_##n##_t * mp) \
15777 vat_main_t * vam = &vat_main; \
15778 if (vam->json_output) { \
15779 vl_api_##n##_t_handler_json(mp); \
15781 vl_api_##n##_t_handler(mp); \
15784 foreach_vpe_api_reply_msg;
15788 vat_api_hookup (vat_main_t * vam)
15791 vl_msg_api_set_handlers(VL_API_##N, #n, \
15792 vl_api_##n##_t_handler_uni, \
15794 vl_api_##n##_t_endian, \
15795 vl_api_##n##_t_print, \
15796 sizeof(vl_api_##n##_t), 1);
15797 foreach_vpe_api_reply_msg;
15800 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
15802 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
15804 vam->function_by_name = hash_create_string (0, sizeof (uword));
15806 vam->help_by_name = hash_create_string (0, sizeof (uword));
15808 /* API messages we can send */
15809 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
15810 foreach_vpe_api_msg;
15814 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
15815 foreach_vpe_api_msg;
15818 /* CLI functions */
15819 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
15820 foreach_cli_function;
15824 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
15825 foreach_cli_function;
15829 #undef vl_api_version
15830 #define vl_api_version(n,v) static u32 vpe_api_version = v;
15831 #include <vpp-api/vpe.api.h>
15832 #undef vl_api_version
15835 vl_client_add_api_signatures (vl_api_memclnt_create_t * mp)
15838 * Send the main API signature in slot 0. This bit of code must
15839 * match the checks in ../vpe/api/api.c: vl_msg_api_version_check().
15841 mp->api_versions[0] = clib_host_to_net_u32 (vpe_api_version);
15845 * fd.io coding-style-patch-verification: ON
15848 * eval: (c-set-style "gnu")